@opengeni/react 6.5.2-canary.41607687019001 → 6.7.0

package/dist/chunk-PC2EBA5G.js

@@ -1,4116 +0,0 @@
-"use client";
-import {
-  ArtifactLinkBoundary
-} from "./chunk-366XZ4PM.js";
-import {
-  descendantsRunning,
-  hintTouchesTree,
-  isSubSessionResponseOutput,
-  lineageSessionIds,
-  subSessionResponseCallIds,
-  waitingDescendants
-} from "./chunk-U6552Q3T.js";
-import {
-  HumanInputDelegationRecord
-} from "./chunk-E6NRSRBE.js";
-import {
-  ModelRecoveryNotice
-} from "./chunk-3QX55WLC.js";
-import {
-  SessionWorkspace
-} from "./chunk-MYUFMVCH.js";
-import {
-  TerminalSessionArchive,
-  TerminalSessionBanner,
-  UserMessageBody
-} from "./chunk-5FH5LQVS.js";
-import {
-  useMessageSenderRenderer
-} from "./chunk-DJIJHRX4.js";
-import {
-  ReadOnlySessionNotice,
-  sessionReadOnlyArchive
-} from "./chunk-JW33RV4V.js";
-import {
-  UnavailableModelNotice
-} from "./chunk-RDBSUNNS.js";
-import {
-  CodexUsageNotice,
-  ModelSwitchHeadsUp
-} from "./chunk-BUBNGKWG.js";
-import {
-  OwnLoginsSharedHeadsUp,
-  ownLoginsInUse
-} from "./chunk-TW3LKRJF.js";
-import {
-  SessionMachinePickerAction,
-  SessionRunsOnMenuBody,
-  useSessionRunsOn
-} from "./chunk-HLOEPV5C.js";
-import {
-  useReadSessionInbox
-} from "./chunk-3OVIXY4O.js";
-import {
-  useSessionOpening
-} from "./chunk-QZKM4S2G.js";
-import {
-  useCodexUsageModelSwitch
-} from "./chunk-Z2C2LA2F.js";
-import {
-  applySessionAttentionProjection,
-  notifySessionAttentionChanged,
-  sessionReadProjectionKey,
-  shouldAcknowledgeActiveSession,
-  shouldProjectActiveSessionRead,
-  updateLocalSessionDeliveryAttention
-} from "./chunk-SDHGQUS4.js";
-import {
-  isPersonalMachine,
-  moveChatToMachine
-} from "./chunk-LA5T52RM.js";
-import {
-  useStreamHealthTelemetry
-} from "./chunk-PRUVBCX6.js";
-import {
-  getComposerSendBlocker
-} from "./chunk-AFRGP2VP.js";
-import {
-  clearGitHubInstallRequest,
-  recordGitHubInstallRequest
-} from "./chunk-PVNI2KHS.js";
-import {
-  noteTurnFailureAction
-} from "./chunk-3QAINO5E.js";
-import {
-  chatLearningScope
-} from "./chunk-SCN7CKBA.js";
-import {
-  isCodexUsageLimitFailure,
-  latestTurnFailedOnUsageLimit,
-  sessionModelMissingFromCatalog,
-  unavailableModelName,
-  unavailableModelReplacement
-} from "./chunk-LT4GTDNO.js";
-import {
-  connectableSubscriptions,
-  isDeploymentFreeModel
-} from "./chunk-SNWZ45EM.js";
-import {
-  timelineShowsFailure
-} from "./chunk-VVT4VXU6.js";
-import {
-  isTerminalSessionStatus,
-  projectSessionTimeline,
-  summarizeSessionFailure
-} from "./chunk-F7U3QPZ3.js";
-import {
-  sessionTimelineEmptyStateCopy
-} from "./chunk-42KJZNTB.js";
-import {
-  useBackgroundAttentionTitle
-} from "./chunk-ZXVFQATC.js";
-import {
-  needsSandboxRecoveryCheck
-} from "./chunk-IIFO2H3P.js";
-import {
-  createFailedSessionRetry
-} from "./chunk-R2NCKRTE.js";
-import {
-  useFixedRigScope,
-  usePersonalResourceAttachment
-} from "./chunk-FP3Z4I5D.js";
-import {
-  currentModelRecovery
-} from "./chunk-A7ZZ2VWS.js";
-import {
-  readSessionDockNavigation,
-  sessionDockLayoutStorageId,
-  updateSessionDockNavigation
-} from "./chunk-ESYN5AUB.js";
-import {
-  secretSaveTargets
-} from "./chunk-P46SRX7L.js";
-import {
-  chatComposerPlaceholder,
-  failedSessionCopy,
-  failureFallbackReason
-} from "./chunk-EGBII4CP.js";
-import {
-  ChatViewportFileDropTarget
-} from "./chunk-CMH22OQY.js";
-import {
-  useConnectionAccounts
-} from "./chunk-7BYWOFVH.js";
-import {
-  SessionSecretsMenuBody,
-  sessionSecretsSummary
-} from "./chunk-YSVD5HI4.js";
-import {
-  useWorkspaceMachines
-} from "./chunk-TZAO65I4.js";
-import {
-  useFollowUpRepositories
-} from "./chunk-M4SDVTKJ.js";
-import {
-  OPEN_SESSION_USAGE_LIMIT_EVENT,
-  goalPausedAtUsageLimit,
-  lineageHasRunningSession,
-  sessionUsageLimitCapability,
-  usageLimitRefusalFromState,
-  useSessionUsageLimit
-} from "./chunk-RBRX5ZS3.js";
-import {
-  EMPTY_COMPOSER_LAUNCH,
-  composerLaunchSearchAfterPolicyApply,
-  composerLaunchSearchKey
-} from "./chunk-L34IVLQC.js";
-import {
-  personalMachineUseIntent
-} from "./chunk-ESSGVLV2.js";
-import {
-  coveredModelChoice,
-  creditRefusalGap,
-  freeCreditGap
-} from "./chunk-XVU32APP.js";
-import {
-  useArtifactCatalogMutationInvalidation
-} from "./chunk-JUJ6QCI2.js";
-import {
-  expireArtifactCatalog
-} from "./chunk-7NLCCKNJ.js";
-import {
-  isEditableArtifactKind
-} from "./chunk-DAD2474Q.js";
-import {
-  useWorkspaceModelCatalog
-} from "./chunk-LQDUHU3Y.js";
-import {
-  githubAppConnectRequest
-} from "./chunk-6D473WWV.js";
-import {
-  ChatPaymentPages
-} from "./chunk-Y5ZNKYN3.js";
-import {
-  MarkdownText
-} from "./chunk-Q52CXW6C.js";
-import {
-  useWorkspaceAppLinkResolver
-} from "./chunk-VS5RLPQY.js";
-import {
-  ConsoleComposer
-} from "./chunk-TA5CFTO4.js";
-import {
-  useSessionRouteMemory
-} from "./chunk-2DVTNHTC.js";
-import {
-  CONSOLE_TIMELINE_ALLOWANCE_LABELS
-} from "./chunk-OF22GYK5.js";
-import {
-  isApiErrorStatus,
-  useAppApi
-} from "./chunk-XIQPI2NM.js";
-import {
-  FORK_CURRENT_CHAT_EVENT,
-  useRail
-} from "./chunk-D6L4GHRH.js";
-import {
-  OPEN_CONVERSATION_FIND_EVENT
-} from "./chunk-7ZEGSUR7.js";
-import {
-  FOCUS_SESSION_COMPOSER_EVENT,
-  consumeSessionComposerFocusIntent,
-  focusSessionComposerWhenReady,
-  sessionComposerFocusIntentIsEligible
-} from "./chunk-MMY23KS7.js";
-import {
-  useSessionUiFeature
-} from "./chunk-FWXMQTVG.js";
-import {
-  FollowUpRepositoryMenuBody
-} from "./chunk-BF4SADKX.js";
-import {
-  useBrowserAccountBridgeBlocker
-} from "./chunk-7LP3W5H5.js";
-import {
-  ModelPicker
-} from "./chunk-TPMZBOFH.js";
-import {
-  LoadingPanel,
-  ProblemPanel
-} from "./chunk-UYE47LO6.js";
-import {
-  WorkspaceComposerPlus
-} from "./chunk-NXWBBZJV.js";
-import {
-  startMcpOAuthWithTimeout
-} from "./chunk-HUKUDAIP.js";
-import {
-  connectorSelectionUpdate,
-  followWorkspaceConnectorPolicy,
-  sessionConnectorPolicyIsCustomized
-} from "./chunk-MA6O7CM6.js";
-import {
-  catalogConnectionAccountSelection,
-  oauthConnectionOwnership,
-  oauthConnectionRef
-} from "./chunk-XOSQP3YA.js";
-import {
-  PersonalResourceAttachmentSurface
-} from "./chunk-QE3ZFGI3.js";
-import {
-  FailureRecoveryBoundary
-} from "./chunk-BZO5ZMUP.js";
-import {
-  observeSessionTurnEvents
-} from "./chunk-55S3W7RZ.js";
-import {
-  SessionUsageLimitNotice
-} from "./chunk-NWGNFN3N.js";
-import {
-  creationHandoffReconciled
-} from "./chunk-UKZ3SGNF.js";
-import {
-  markIntegrationConnectRedirect
-} from "./chunk-OXD6ET34.js";
-import {
-  mergeSessionContextProjection,
-  mergeSessionDetailReadProjection
-} from "./chunk-JHZRAYI4.js";
-import {
-  creditRefusalRecord
-} from "./chunk-INXGSG3J.js";
-import {
-  t
-} from "./chunk-GE33BGB7.js";
-import {
-  clientFirstPartyMcpToolPolicy,
-  firstPartySessionToolOptionsFor,
-  sessionPolicyPickerIds
-} from "./chunk-ZPW5NFYD.js";
-import {
-  canConnectWorkspaceMcpFromChat,
-  hasAccountPermission,
-  hasWorkspacePermission
-} from "./chunk-H2ALCTWC.js";
-import {
-  isPersonalWorkspace
-} from "./chunk-LBSXJVHD.js";
-import {
-  useNavigate,
-  usePage,
-  useRouterState
-} from "./chunk-U5EFEMYU.js";
-import {
-  useHostMessageContext,
-  useReportSessionState
-} from "./chunk-ENFLCAR3.js";
-import {
-  toast
-} from "./chunk-YG6NARQY.js";
-import {
-  createSessionEventFeedStore,
-  useAppContext
-} from "./chunk-JDFDPMKX.js";
-import {
-  connectorLogo,
-  connectorLogoIndex
-} from "./chunk-I5UOUBST.js";
-import {
-  sessionAgentsSignal
-} from "./chunk-GXO7ECQZ.js";
-import {
-  useUiEventTarget
-} from "./chunk-WGPLDFEC.js";
-import {
-  cn
-} from "./chunk-A3MTTRCX.js";
-import {
-  EmptyState
-} from "./chunk-QE4XESS7.js";
-import {
-  apiErrorFacts,
-  userErrorText
-} from "./chunk-L4OF77LE.js";
-import {
-  isCodexProductModel,
-  sessionDisplayTitle,
-  sessionHasPendingWake,
-  sessionInputWait,
-  withLineageAutomationFacts
-} from "./chunk-6AHATAAY.js";
-import {
-  SessionAdmissionNotice,
-  SessionMachineAccessNotice
-} from "./chunk-JJZPLGIP.js";
-import {
-  loadSessionFeedback,
-  turnRatingsFromFeedback
-} from "./chunk-TMNMI67B.js";
-import {
-  sessionAuthRecommendation
-} from "./chunk-2GDNWKSC.js";
-import {
-  useSessionSecrets
-} from "./chunk-ZR6WALSK.js";
-import {
-  useSessionLineage
-} from "./chunk-BU3TJN46.js";
-import {
-  stopOwnLoginsHere,
-  turnOnOwnLoginsHere
-} from "./chunk-IGDADFW4.js";
-import {
-  attachSessionCapability,
-  completeSessionCapabilityOAuth,
-  continueAfterCapabilitySetup
-} from "./chunk-52Y2X66Q.js";
-import {
-  ApprovalSurface,
-  MessageTimeline,
-  SessionChrome,
-  useLiveSessionEvents
-} from "./chunk-TG7DADJR.js";
-import {
-  KnowledgeActivityProvider,
-  LearningRefusalActionsProvider,
-  ToolActionReviewDetails,
-  ToolReviewHistoryProvider,
-  createSessionRetainedScreenshotLoader,
-  createWorkspaceRetainedArtifactLoader,
-  createWorkspaceRetainedVideoLoader
-} from "./chunk-LRJIYTZW.js";
-import {
-  inertProps
-} from "./chunk-USG4XNMA.js";
-import {
-  conversationTimeline,
-  useGoal,
-  useHumanInputRequests,
-  useSession,
-  useSessionEvents,
-  useSessionStartupTimeline,
-  useTurnQueue
-} from "./chunk-SWIHWCTW.js";
-import {
-  SessionStartupProvider
-} from "./chunk-EMIVOS73.js";
-import {
-  admissionControlNeedsRefresh,
-  admissionRecheckControl,
-  currentSessionMachineAccess,
-  recheckSessionAdmission,
-  sessionAdmissionNeedsDifferentMachine,
-  sessionAdmissionReason
-} from "./chunk-JWKGPA6Q.js";
-import {
-  approvalsDecidable,
-  projectPendingApprovals
-} from "./chunk-VXORMNU4.js";
-import {
-  creditExhaustedFromEvents,
-  creditRefusalFromEvents
-} from "./chunk-4YCA2Y73.js";
-import {
-  useFileAttachments
-} from "./chunk-I6FIXEL4.js";
-import {
-  sessionAttentionReadThroughSequence
-} from "./chunk-C5ZCSVZ7.js";
-import {
-  promptSendDestination,
-  sessionAdmissionBlocked,
-  sessionDisplayStatus,
-  sessionTurnKeepsRunControl
-} from "./chunk-TSENLSW6.js";
-import {
-  LazyPart,
-  retainedImageId
-} from "./chunk-VIEFJ2DM.js";
-import {
-  OpenGeniLinkProvider
-} from "./chunk-NPNX7LTL.js";
-import {
-  sessionComputeLabel
-} from "./chunk-ZY2Z2IU3.js";
-import {
-  MACHINES_SESSION_POLL_MS
-} from "./chunk-XDBYWVCW.js";
-import {
-  useCalmServiceFailure,
-  useComposerWithStreamState
-} from "./chunk-SVKPSCTH.js";
-import {
-  useComposer,
-  useQueuedPromptRecall
-} from "./chunk-AXBSYWKX.js";
-import {
-  LightboxProvider
-} from "./chunk-UI4HI5QK.js";
-import {
-  Button
-} from "./chunk-7QQN3KNP.js";
-import {
-  usePortalContainer
-} from "./chunk-UD6AAZSC.js";
-import {
-  useDebouncedCallback,
-  useSessionEventTrigger
-} from "./chunk-RV3O5OCQ.js";
-import {
-  isModelUnavailableSubmissionError,
-  isSessionUsageLimitSubmissionError
-} from "./chunk-5MOJZORA.js";
-import {
-  InteractiveAnswerProvider,
-  browserInteractiveAnswerStore
-} from "./chunk-OONTDHBV.js";
-import {
-  useOpenGeni
-} from "./chunk-TVQCDDSZ.js";
-import {
-  effortOptionsForModel,
-  findPickerRow,
-  runnableLatencyModesForModel
-} from "./chunk-ZHC47M2B.js";
-
-// src/app/routes/session.tsx
-import { Fragment } from "react";
-
-// src/app/routes/session-capability-oauth-return.ts
-async function finishMcpCapabilityOAuthReturn(input) {
-  const { client, workspaceId, sessionId, params } = input;
-  const item = input.catalog.find((candidate) => candidate.id === input.capabilityId);
-  const connectionId = params.get("connectionId");
-  const providerDomain = params.get("providerDomain");
-  const ownership = oauthConnectionOwnership(params.get("ownership"));
-  if (!item || item.kind !== "mcp" || !connectionId || !providerDomain || !ownership) {
-    throw new Error("The authorized capability could not be resolved from the live catalog.");
-  }
-  await client.enableCapability(workspaceId, item.id, {
-    connectionRef: oauthConnectionRef(
-      ownership,
-      connectionId,
-      providerDomain,
-      catalogConnectionAccountSelection(item)
-    )
-  });
-  await input.refreshCatalog(workspaceId);
-  const connected = (await client.listCapabilities(workspaceId)).items.find(
-    (candidate) => candidate.id === item.id
-  );
-  if (!connected?.enabled)
-    throw new Error("The connection was authorized, but enabling its tools could not be verified.");
-  if (connected.connectionRef?.subjectScope === "subject")
-    return { name: item.name, needsPersonalReview: true };
-  await attachSessionCapability(t, client, workspaceId, sessionId, connected);
-  continueAfterCapabilitySetup(client, workspaceId, sessionId, connected.id);
-  return { name: item.name, needsPersonalReview: false };
-}
-
-// src/app/lib/session-composer-readiness.ts
-import { useCallback, useLayoutEffect, useMemo, useState } from "react";
-function useSessionSendGate() {
-  const [committedPolicyValid, commitPolicyValid] = useState(false);
-  const blocker = useCallback(
-    (state) => getComposerSendBlocker({
-      uploadPending: state.uploadPending,
-      repositoryError: state.repositoryError,
-      policyValid: committedPolicyValid,
-      personalDecision: state.personalDecision,
-      machineAccessDenied: state.machineAccessDenied,
-      personalLoading: state.loading || state.loadFailed
-    }),
-    [committedPolicyValid]
-  );
-  return { committedPolicyValid, commitPolicyValid, blocker };
-}
-function useSessionComposerDelivery(composer, gate, {
-  policyValid,
-  catalogLoading,
-  replacingModel,
-  send
-}) {
-  const { commitPolicyValid, committedPolicyValid } = gate;
-  useLayoutEffect(() => {
-    commitPolicyValid(policyValid);
-  }, [commitPolicyValid, policyValid]);
-  const preparing = composer.preparing === true || policyValid !== committedPolicyValid || catalogLoading && !policyValid || replacingModel || send.loading;
-  return useMemo(
-    () => composer.preparing === true === preparing ? composer : { ...composer, preparing },
-    [composer, preparing]
-  );
-}
-
-// src/app/lib/use-descendant-requests-refresh.ts
-import { useCallback as useCallback2, useEffect, useMemo as useMemo2, useRef, useState as useState2 } from "react";
-var LINEAGE_POLL_MS = 3e4;
-var LINEAGE_POLL_ACTIVE_WITHOUT_HINTS_MS = 15e3;
-function treeNeedsWatching(nodes) {
-  return descendantsRunning(nodes) || waitingDescendants(nodes).length > 0;
-}
-function useLineagePollInterval(workspaceId) {
-  const { workspaceSessionListEvent } = useOpenGeni();
-  const [active, setActive] = useState2(false);
-  const observeTree = useCallback2(
-    (nodes) => setActive(treeNeedsWatching(nodes)),
-    []
-  );
-  const live = workspaceSessionListEvent?.workspaceId === workspaceId && workspaceSessionListEvent.available === true;
-  return {
-    pollIntervalMs: !live && active ? LINEAGE_POLL_ACTIVE_WITHOUT_HINTS_MS : LINEAGE_POLL_MS,
-    observeTree
-  };
-}
-function useDescendantRequestsRefresh(options) {
-  const { client, workspaceId, sessionId, events, nodes, refreshLineage } = options;
-  const { workspaceSessionListEvent } = useOpenGeni();
-  const [signal, setSignal] = useState2(0);
-  const refreshLineageRef = useRef(refreshLineage);
-  useEffect(() => {
-    refreshLineageRef.current = refreshLineage;
-  }, [refreshLineage]);
-  const refreshTreeSoon = useDebouncedCallback(() => {
-    void refreshLineageRef.current();
-  }, 150);
-  const refreshAllSoon = useDebouncedCallback(() => {
-    void refreshLineageRef.current();
-    setSignal((value) => value + 1);
-  }, 150);
-  const tree = useMemo2(
-    () => ({ ids: lineageSessionIds(nodes), running: descendantsRunning(nodes) }),
-    [nodes]
-  );
-  const treeRef = useRef(tree);
-  useEffect(() => {
-    treeRef.current = tree;
-  }, [tree]);
-  useEffect(() => {
-    const hint = workspaceSessionListEvent;
-    if (!hint || hint.workspaceId !== workspaceId || !hint.available) return;
-    if (document.visibilityState === "hidden") return;
-    const current = treeRef.current;
-    const unseen = current.running && (hint.sessionIds ?? []).some((id) => id !== sessionId && !current.ids.has(id));
-    if (hintTouchesTree(hint, current.ids) || unseen) refreshTreeSoon();
-  }, [refreshTreeSoon, sessionId, workspaceId, workspaceSessionListEvent]);
-  const responseCallIds = useMemo2(() => subSessionResponseCallIds(events), [events]);
-  const matchResponse = useCallback2(
-    (event) => isSubSessionResponseOutput(event, responseCallIds),
-    [responseCallIds]
-  );
-  const [history, setHistory] = useState2(null);
-  const newest = events.at(-1);
-  if (newest && newest.sessionId === sessionId && history?.sessionId !== sessionId) {
-    setHistory({ sessionId, through: newest.sequence });
-  }
-  const readThrough = history?.sessionId === sessionId ? history.through : "reading";
-  const onResponse = useCallback2(() => refreshAllSoon(), [refreshAllSoon]);
-  useSessionEventTrigger(client, workspaceId, sessionId, matchResponse, onResponse, {
-    events,
-    readThrough
-  });
-  return signal;
-}
-
-// src/app/routes/session.tsx
-import { OpenGeniSessionUsageLimitReachedError } from "@opengeni/sdk/browser";
-import { SESSION_USAGE_LIMIT_GOAL_PAUSED_REASON } from "@opengeni/sdk/session-usage-limits";
-import {
-  BotIcon,
-  BugIcon,
-  Loader2Icon,
-  MenuIcon,
-  MessagesSquareIcon,
-  PanelsTopLeftIcon
-} from "lucide-react";
-import {
-  createElement,
-  lazy,
-  Suspense,
-  useCallback as useCallback3,
-  useEffect as useEffect4,
-  useLayoutEffect as useLayoutEffect2,
-  useMemo as useMemo3,
-  useRef as useRef2,
-  useState as useState3
-} from "react";
-
-// src/app/lib/session-failure-toasts.ts
-import { useEffect as useEffect2 } from "react";
-function useSessionFailureToasts(loadError, streamError) {
-  const streamCalm = useCalmServiceFailure(streamError);
-  const loadCalm = useCalmServiceFailure(loadError);
-  useEffect2(() => {
-    if (streamError && !streamCalm && !isApiErrorStatus(streamError, 404)) {
-      toast.error("Event stream disconnected", {
-        description: streamError.message
-      });
-    }
-  }, [streamCalm, streamError]);
-  useEffect2(() => {
-    if (loadError && !loadCalm && !isApiErrorStatus(loadError, 404)) {
-      toast.error("Failed to load session", { description: String(loadError) });
-    }
-  }, [loadCalm, loadError]);
-}
-
-// src/app/lib/session-route-placement.ts
-function ignoreRoutedUpdate() {
-}
-function sessionRouteAppState(placement, context, panelEventFeed) {
-  if (placement === "page") {
-    return {
-      routed: true,
-      setSession: context.setSession,
-      setConnectionState: context.setConnectionState,
-      sessionEventFeedStore: context.sessionEventFeedStore
-    };
-  }
-  return {
-    routed: false,
-    setSession: ignoreRoutedUpdate,
-    setConnectionState: ignoreRoutedUpdate,
-    sessionEventFeedStore: panelEventFeed
-  };
-}
-function sessionRouteCreationHandoff(input) {
-  const { sessionId, given, app, appSession, routed } = input;
-  if (given?.session.id === sessionId) return given;
-  if (routed && app?.session.id === sessionId && appSession?.id === sessionId) return app;
-  return null;
-}
-
-// src/app/lib/find-shortcut.ts
-import { useEffect as useEffect3 } from "react";
-function useFindShortcut(input, open) {
-  const { scope } = input;
-  useEffect3(() => {
-    if (!scope) return;
-    const onKeyDown = (event) => {
-      if (!(event.ctrlKey || event.metaKey) || event.altKey || event.shiftKey || event.key.toLowerCase() !== "f")
-        return;
-      const target = event.target;
-      if (target instanceof Element && target.closest('[role="dialog"], .cm-editor, .xterm, [data-native-find]'))
-        return;
-      event.preventDefault();
-      open();
-    };
-    scope.addEventListener("keydown", onKeyDown);
-    return () => scope.removeEventListener("keydown", onKeyDown);
-  }, [open, scope]);
-}
-
-// src/app/lib/codex-model-switch.ts
-var CONTEXT_CHECKPOINT_EVENT_TYPES = [
-  "session.context.compacted",
-  "session.context.cleared"
-];
-function latestCheckpointIsCompaction(events) {
-  let latest = null;
-  for (const event of events) {
-    if (event.type !== "session.context.compacted" && event.type !== "session.context.cleared")
-      continue;
-    if (!latest || event.sequence > latest.sequence) latest = event;
-  }
-  return latest ? latest.type === "session.context.compacted" : null;
-}
-function needsModelSwitchHeadsUp(input) {
-  return input.codexCompactionMode === "remote_v2" && input.codexCompacted && typeof input.model === "string" && input.model.length > 0 && !isCodexProductModel(input.model);
-}
-function modelSwitchHeadsUpText(modelLabel) {
-  return `Earlier messages will be re-summarized for ${modelLabel}, so it may remember less detail.`;
-}
-function codexUsageResetsAt(events) {
-  let latest = null;
-  for (const event of events) {
-    const usageEvent = event.type === "codex.capacity.waiting" || event.type === "turn.capacity_waiting" || event.type === "turn.failed" && payloadField(event, "code") === "codex_usage_limit_reached";
-    if (usageEvent && (!latest || event.sequence > latest.sequence)) latest = event;
-  }
-  const resetsAt = latest ? payloadField(latest, "resetsAt") ?? payloadField(latest, "earliestResetAt") : null;
-  return typeof resetsAt === "string" && !Number.isNaN(Date.parse(resetsAt)) ? resetsAt : null;
-}
-var USAGE_WAIT_REASONS = /* @__PURE__ */ new Set([
-  "no_eligible_capacity",
-  "compaction_provider_locked",
-  // The chat's pinned account is out of usage until its reset.
-  "pinned_account_unavailable"
-]);
-function codexWaitIsUsageLimit(events) {
-  let latest = null;
-  for (const event of events) {
-    const wait = event.type === "codex.capacity.waiting" || event.type === "turn.capacity_waiting";
-    if (wait && (!latest || event.sequence > latest.sequence)) latest = event;
-  }
-  if (!latest || payloadField(latest, "actionRequired") === true) return false;
-  const reason = payloadField(latest, "waitReason");
-  return reason === void 0 || reason === null || USAGE_WAIT_REASONS.has(String(reason));
-}
-function payloadField(event, key) {
-  const payload = event.payload;
-  return payload && typeof payload === "object" ? payload[key] : void 0;
-}
-function codexUsageContinuesAtReset(input) {
-  return input.status === "waiting_capacity" && !input.paused;
-}
-function codexUsageNoticeApplies(input) {
-  return input.status !== "waiting_capacity" || input.usageWait && input.resetsAt !== null;
-}
-function codexUsageContinueAtResetAction(input) {
-  if (input.next === codexUsageContinuesAtReset(input)) return null;
-  if (input.status === "waiting_capacity") return input.next ? "resume" : "pause";
-  if (!input.next) return null;
-  return input.paused ? "resume_and_run_on_codex" : "run_on_codex";
-}
-function codexUsageResetText(resetsAt, options = {}) {
-  const reset = resetsAt === null ? Number.NaN : Date.parse(resetsAt);
-  if (Number.isNaN(reset)) return "Reset time unknown.";
-  const now = options.now ?? /* @__PURE__ */ new Date();
-  if (reset <= now.getTime()) return "Resets soon.";
-  const zone = options.timeZone ? { timeZone: options.timeZone } : {};
-  const day = (date2) => new Intl.DateTimeFormat("en-CA", { dateStyle: "short", ...zone }).format(date2);
-  const at = new Date(reset);
-  const time = new Intl.DateTimeFormat(options.locale, { timeStyle: "short", ...zone }).format(at);
-  if (day(at) === day(now)) return `Resets at ${time}.`;
-  const withinWeek = reset - now.getTime() < 6 * 24 * 60 * 60 * 1e3;
-  const date = new Intl.DateTimeFormat(
-    options.locale,
-    withinWeek ? { weekday: "short", ...zone } : { month: "short", day: "numeric", ...zone }
-  ).format(at);
-  return `Resets ${date} ${time}.`;
-}
-
-// src/app/routes/session.tsx
-import { resolveWorkspaceBusySend, stableJson } from "@opengeni/contracts";
-import { connectProviderAcceptsRequestedScopes } from "@opengeni/contracts/connect";
-import { Fragment as Fragment2, jsx, jsxs } from "react/jsx-runtime";
-var InlineChatArtifact = lazy(
-  () => import("./app/components/artifacts/retained-file-preview.js").then((module) => ({
-    default: module.InlineChatArtifact
-  }))
-);
-var ChatInteractiveBlock = lazy(
-  () => import("./app/components/artifacts/chat-interactive-block.js").then((module) => ({
-    default: module.ChatInteractiveBlock
-  }))
-);
-var HumanInputSurface = lazy(() => import("./app/components/session/human-input.js"));
-var DescendantRequests = lazy(() => import("./app/components/session/descendant-requests.js"));
-var SessionSkillReviews = lazy(
-  () => import("./app/components/session/session-skill-reviews.js").then((module) => ({
-    default: module.SessionSkillReviews
-  }))
-);
-var SessionCommands = lazy(
-  () => import("./session-ui.js").then((module) => ({ default: module.SessionCommands }))
-);
-var SessionCapabilityCard = lazy(async () => ({
-  default: (await import("./app/components/capabilities/session-capability-card.js")).SessionCapabilityCard
-}));
-var NativeConnectSetup = lazy(
-  () => import("./app/components/capabilities/native-connect-setup.js").then((module) => ({
-    default: module.NativeConnectSetup
-  }))
-);
-var MessageForkDialog = lazy(
-  () => import("./app/components/session/session-tenancy-control.js").then((module) => ({
-    default: module.SessionTenancyRouteControl
-  }))
-);
-var MessageActions = lazy(() => import("./app/components/session/message-actions.js"));
-var ConversationFind = lazy(() => import("./app/components/session/conversation-find.js"));
-var EMPTY_SEARCH_TARGET = {};
-var SubagentTree = lazy(
-  () => import("./app/components/session/subagents.js").then((module) => ({ default: module.SubagentTree }))
-);
-var LazyFailedSessionBanner = lazy(
-  () => import("./app/components/session/failed-session-banner.js").then((module) => ({
-    default: module.FailedSessionBanner
-  }))
-);
-var LazyCreditRefusalNotice = lazy(
-  () => import("./app/components/credits/credit-refusal-notice.js").then((module) => ({
-    default: module.CreditRefusalNotice
-  }))
-);
-var LazyCreditTopupPrompt = lazy(
-  () => import("./app/components/credit-required-prompt.js").then((module) => ({
-    default: module.CreditRequiredPrompt
-  }))
-);
-var LazyAgentConfigurationPanel = lazy(
-  () => import("./app/components/session/agent-configuration-panel.js").then(({ AgentConfigurationPanel }) => ({
-    default: AgentConfigurationPanel
-  }))
-);
-var LazySessionInspector = lazy(
-  () => import("./app/components/session/inspector.js").then(({ SessionInspector }) => ({
-    default: SessionInspector
-  }))
-);
-var LazySessionEditableArtifactsWorkspace = lazy(
-  () => import("./app/components/session/editable-artifacts-workspace.js").then(
-    ({ SessionEditableArtifactsWorkspace }) => ({
-      default: SessionEditableArtifactsWorkspace
-    })
-  )
-);
-var LazyCodexRealtimeControl = lazy(
-  () => import("./realtime.js").then(({ SessionRealtimeControl }) => ({
-    default: SessionRealtimeControl
-  }))
-);
-var LazySessionRouteAuxiliary = lazy(
-  () => import("./app/components/session/session-tenancy-control.js")
-);
-function SessionRoute({
-  workspaceId,
-  sessionId,
-  launch = EMPTY_COMPOSER_LAUNCH,
-  realtimeAutostartModel,
-  searchTarget = EMPTY_SEARCH_TARGET,
-  placement = "page",
-  onEvent,
-  messageContext,
-  creationHandoff: givenCreationHandoff,
-  initialDraft,
-  onNewSession,
-  onRealtimeAutostartConsumed
-}) {
-  const uiEvents = useUiEventTarget("document");
-  const dockEnabled = useSessionUiFeature("dock");
-  useReadSessionInbox(sessionId);
-  const context = useAppContext();
-  const routed = placement === "page";
-  const rail = useRail();
-  const navigate = useNavigate();
-  const page = usePage();
-  const consumeRealtimeAutostart = useCallback3(() => {
-    if (onRealtimeAutostartConsumed) {
-      onRealtimeAutostartConsumed();
-      return;
-    }
-    void navigate({
-      to: "/workspaces/$workspaceId/sessions/$sessionId",
-      params: { workspaceId, sessionId },
-      search: {},
-      replace: true
-    });
-  }, [navigate, onRealtimeAutostartConsumed, sessionId, workspaceId]);
-  const hasSearchOrigin = searchTarget.searchOrigin === "session-search";
-  const consumeSearchOrigin = useCallback3(() => {
-    if (!hasSearchOrigin) return;
-    void navigate({
-      to: "/workspaces/$workspaceId/sessions/$sessionId",
-      params: { workspaceId, sessionId },
-      search: ({ searchOrigin: _searchOrigin, ...rest }) => rest,
-      replace: true
-    });
-  }, [hasSearchOrigin, navigate, sessionId, workspaceId]);
-  const {
-    events,
-    timeline: eventTimeline,
-    sessionStatus,
-    sessionStatusSequence,
-    connectionState,
-    initialLoading,
-    initialHistoryReady,
-    hasOlder,
-    loadingOlder,
-    loadOlder,
-    hasNewer,
-    loadingNewer,
-    loadNewer,
-    loadingOldest,
-    loadOldest,
-    jumpToLatest,
-    jumpToSequence,
-    error: streamError
-  } = useSessionEvents(sessionId);
-  useEffect4(() => observeSessionTurnEvents(sessionId, events), [events, sessionId]);
-  useLiveSessionEvents(sessionId, events, initialHistoryReady, onEvent);
-  useReportSessionState({ sessionId, status: sessionStatus, events, initialLoading }, routed);
-  const sessionDetailReadOwner = useRef2({});
-  const beginSessionDetailRead = useCallback3(
-    () => context.sessionChannelProjectionAuthority.beginDetailRead(sessionDetailReadOwner.current, {
-      id: sessionId,
-      workspaceId
-    }),
-    [context.sessionChannelProjectionAuthority, sessionId, workspaceId]
-  );
-  const {
-    session: fetchedSession,
-    error: loadError,
-    readRevision: sessionReadRevision,
-    readGeneration: sessionReadGeneration,
-    refresh: refreshSession
-  } = useSession(sessionId, {
-    events,
-    beginRead: beginSessionDetailRead
-  });
-  const restoredSessionId = useRouterState({
-    select: (state) => state.location.state.restoredSessionId
-  });
-  const leaveRestoredSession = useCallback3(() => {
-    void navigate({
-      to: "/workspaces/$workspaceId/sessions",
-      params: { workspaceId },
-      replace: true
-    });
-  }, [navigate, workspaceId]);
-  const leavingRestoredSession = useSessionRouteMemory({
-    subjectId: context.accessContext.subjectId,
-    workspaceId,
-    sessionId,
-    openedSessionId: fetchedSession?.id ?? null,
-    loadError,
-    restoredSessionId,
-    leave: leaveRestoredSession,
-    enabled: routed
-  });
-  useEffect4(
-    () => () => context.sessionChannelProjectionAuthority.finishDetailReads(sessionDetailReadOwner.current),
-    [context.sessionChannelProjectionAuthority, sessionId, workspaceId]
-  );
-  useEffect4(() => {
-    if (loadError) {
-      context.sessionChannelProjectionAuthority.finishDetailReads(sessionDetailReadOwner.current);
-    }
-  }, [context.sessionChannelProjectionAuthority, loadError]);
-  const creationHandoff = sessionRouteCreationHandoff({
-    sessionId,
-    given: givenCreationHandoff,
-    app: context.sessionCreationHandoff,
-    appSession: context.session,
-    routed
-  });
-  const pendingCreationHandoff = creationHandoffReconciled(creationHandoff, events) ? null : creationHandoff;
-  const queue = useTurnQueue(sessionId, { events });
-  const goal = useGoal(sessionId, { events });
-  const humanInput = useHumanInputRequests(sessionId, { events });
-  const sessionSeed = fetchedSession ?? creationHandoff?.session ?? null;
-  const session = useMemo3(
-    () => sessionSeed ? {
-      ...sessionSeed,
-      // Old idle events must not overwrite a fresh queued/claimed detail read.
-      status: (sessionStatusSequence ?? 0) > sessionSeed.lastSequence ? sessionStatus ?? sessionSeed.status : sessionSeed.status,
-      effectiveControl: queue.effectiveControl ?? sessionSeed.effectiveControl
-    } : null,
-    [queue.effectiveControl, sessionSeed, sessionStatus, sessionStatusSequence]
-  );
-  useBackgroundAttentionTitle(sessionId, session?.status ?? null);
-  const waitingForDispatch = session?.status === "queued" && session.activeTurnId === null && session.effectiveControl.state === "active";
-  useEffect4(() => {
-    if (!waitingForDispatch) return;
-    let stopped = false;
-    let timer;
-    const refresh = async () => {
-      try {
-        if (document.visibilityState === "visible") await refreshSession();
-      } finally {
-        if (!stopped) timer = setTimeout(() => void refresh(), 15e3);
-      }
-    };
-    timer = setTimeout(() => void refresh(), 15e3);
-    return () => {
-      stopped = true;
-      clearTimeout(timer);
-    };
-  }, [waitingForDispatch, sessionId, refreshSession]);
-  const [viewClearedAfter, setViewClearedAfter] = useState3(null);
-  useEffect4(() => {
-    setViewClearedAfter(null);
-  }, [sessionId]);
-  const clearView = useCallback3(() => {
-    const latestSequence = events.reduce((max, event) => Math.max(max, event.sequence), 0);
-    setViewClearedAfter(latestSequence);
-  }, [events]);
-  const visibleEvents = useMemo3(
-    () => viewClearedAfter !== null ? events.filter((event) => event.sequence > viewClearedAfter) : events,
-    [events, viewClearedAfter]
-  );
-  const { opened, hasObservedHistory } = useSessionOpening(
-    `${workspaceId}:${sessionId}`,
-    Boolean(session && (initialHistoryReady || pendingCreationHandoff)),
-    events.length > 0
-  );
-  const timeline = useMemo3(() => {
-    if (!session) {
-      return [];
-    }
-    if ((!opened || initialLoading || hasObservedHistory) && visibleEvents.length === 0 && !pendingCreationHandoff) {
-      return [];
-    }
-    const projected = projectSessionTimeline(
-      session,
-      visibleEvents,
-      pendingCreationHandoff?.clientEventId,
-      viewClearedAfter === null ? eventTimeline : void 0
-    );
-    return viewClearedAfter !== null && visibleEvents.length === 0 ? [] : projected;
-  }, [
-    pendingCreationHandoff,
-    session,
-    visibleEvents,
-    viewClearedAfter,
-    opened,
-    initialLoading,
-    hasObservedHistory,
-    eventTimeline
-  ]);
-  const approvals = useMemo3(() => projectPendingApprovals(events), [events]);
-  const creditExhausted = useMemo3(() => creditExhaustedFromEvents(events), [events]);
-  const creditRefusal = useMemo3(() => creditRefusalFromEvents(events), [events]);
-  const failure = useMemo3(
-    () => session && (session.status === "failed" || creditExhausted) ? summarizeSessionFailure(
-      events,
-      session.status,
-      session.failureDiagnostics,
-      session.lastSequence
-    ) : null,
-    [events, session, creditExhausted]
-  );
-  const [panelEventFeed] = useState3(createSessionEventFeedStore);
-  const { client, captureWorkspaceInvocation, ownsWorkspaceInvocation } = context;
-  const {
-    setSession: setContextSession,
-    setConnectionState: setContextConnectionState,
-    sessionEventFeedStore
-  } = sessionRouteAppState(placement, context, panelEventFeed);
-  const acknowledgedProjectionRef = useRef2(null);
-  const confirmedProjectionRef = useRef2(null);
-  const retriedProjectionRef = useRef2(null);
-  const [foreground, setForeground] = useState3(() => ({
-    documentVisible: document.visibilityState === "visible",
-    windowFocused: document.hasFocus()
-  }));
-  const [attentionRetryRevision, setAttentionRetryRevision] = useState3(0);
-  const reconciledSessionRead = useRef2(null);
-  useEffect4(() => {
-    if (!fetchedSession || sessionReadRevision === 0) return;
-    if (reconciledSessionRead.current?.sessionId === sessionId && reconciledSessionRead.current.revision === sessionReadRevision) {
-      return;
-    }
-    reconciledSessionRead.current = {
-      sessionId,
-      revision: sessionReadRevision
-    };
-    const accepted = context.sessionChannelProjectionAuthority.recordRead(
-      fetchedSession,
-      sessionReadGeneration
-    );
-    setContextSession(
-      (current) => mergeSessionDetailReadProjection(
-        current,
-        fetchedSession,
-        context.sessionChannelProjectionAuthority,
-        sessionReadGeneration,
-        accepted
-      )
-    );
-  }, [
-    context.sessionChannelProjectionAuthority,
-    fetchedSession,
-    sessionId,
-    sessionReadGeneration,
-    sessionReadRevision,
-    setContextSession
-  ]);
-  useEffect4(() => {
-    setContextSession(
-      (current) => mergeSessionContextProjection(
-        current,
-        session,
-        context.sessionChannelProjectionAuthority,
-        "live"
-      )
-    );
-  }, [context.sessionChannelProjectionAuthority, session, setContextSession]);
-  useEffect4(() => {
-    const reconcileForeground = () => {
-      setForeground({
-        documentVisible: document.visibilityState === "visible",
-        windowFocused: document.hasFocus()
-      });
-    };
-    window.addEventListener("focus", reconcileForeground);
-    window.addEventListener("blur", reconcileForeground);
-    document.addEventListener("visibilitychange", reconcileForeground);
-    return () => {
-      window.removeEventListener("focus", reconcileForeground);
-      window.removeEventListener("blur", reconcileForeground);
-      document.removeEventListener("visibilitychange", reconcileForeground);
-    };
-  }, []);
-  const projectSessionAttention = useCallback3(
-    (projection) => {
-      notifySessionAttentionChanged(projection);
-      setContextSession(
-        (current) => current?.id === projection.id ? applySessionAttentionProjection(current, projection) : current
-      );
-    },
-    [setContextSession]
-  );
-  const attentionThroughSequence = useMemo3(
-    () => sessionAttentionReadThroughSequence(events),
-    [events]
-  );
-  const readThroughSequence = Math.max(session?.lastSequence ?? 0, attentionThroughSequence);
-  const activeReadProjectionKey = session ? sessionReadProjectionKey(session.id, readThroughSequence) : null;
-  const routeUnreadProjection = useMemo3(
-    () => session ? {
-      ...session,
-      unread: session.unread || readThroughSequence > session.lastSequence
-    } : null,
-    [readThroughSequence, session]
-  );
-  useLayoutEffect2(() => {
-    if (!session || !activeReadProjectionKey) return;
-    if (confirmedProjectionRef.current === activeReadProjectionKey || !shouldProjectActiveSessionRead({
-      activeSessionId: sessionId,
-      workspaceId,
-      session: routeUnreadProjection,
-      ...foreground
-    })) {
-      return;
-    }
-    const optimisticProjection = {
-      id: session.id,
-      workspaceId: session.workspaceId,
-      unread: false,
-      ...session.attentionVersion !== void 0 ? { attentionVersion: session.attentionVersion } : {},
-      lastSequence: readThroughSequence
-    };
-    projectSessionAttention(optimisticProjection);
-  }, [
-    activeReadProjectionKey,
-    foreground,
-    projectSessionAttention,
-    readThroughSequence,
-    routeUnreadProjection,
-    session,
-    sessionId,
-    workspaceId
-  ]);
-  const acknowledgementSessionId = session?.id ?? null;
-  const acknowledgementEligible = shouldAcknowledgeActiveSession({
-    activeSessionId: sessionId,
-    workspaceId,
-    session: routeUnreadProjection,
-    ...foreground
-  });
-  useEffect4(() => {
-    const projectionKey = activeReadProjectionKey;
-    if (!acknowledgementSessionId || !projectionKey || acknowledgedProjectionRef.current === projectionKey || !acknowledgementEligible) {
-      return;
-    }
-    let active = true;
-    const acceptedTransition = captureWorkspaceInvocation(workspaceId);
-    if (!acceptedTransition) return;
-    acknowledgedProjectionRef.current = projectionKey;
-    void client.updateSessionAttention(workspaceId, acknowledgementSessionId, {
-      unread: false,
-      acknowledgedThroughSequence: readThroughSequence
-    }).then((updated) => {
-      if (!ownsWorkspaceInvocation(workspaceId, acceptedTransition)) return;
-      confirmedProjectionRef.current = projectionKey;
-      projectSessionAttention(updated);
-    }).catch(() => {
-      if (active && ownsWorkspaceInvocation(workspaceId, acceptedTransition) && acknowledgedProjectionRef.current === projectionKey && retriedProjectionRef.current !== projectionKey) {
-        retriedProjectionRef.current = projectionKey;
-        acknowledgedProjectionRef.current = null;
-        setAttentionRetryRevision((revision) => revision + 1);
-        return;
-      }
-      if (acknowledgedProjectionRef.current === projectionKey) {
-        acknowledgedProjectionRef.current = null;
-      }
-    });
-    return () => {
-      active = false;
-    };
-  }, [
-    acknowledgementEligible,
-    acknowledgementSessionId,
-    attentionRetryRevision,
-    activeReadProjectionKey,
-    captureWorkspaceInvocation,
-    client,
-    ownsWorkspaceInvocation,
-    projectSessionAttention,
-    readThroughSequence,
-    workspaceId
-  ]);
-  useEffect4(() => {
-    setContextConnectionState(connectionState);
-  }, [connectionState, setContextConnectionState]);
-  useStreamHealthTelemetry("session", connectionState);
-  useEffect4(() => {
-    sessionEventFeedStore.set({ sessionId, events });
-  }, [events, sessionId, sessionEventFeedStore]);
-  useEffect4(
-    () => () => {
-      setContextSession(null);
-      setContextConnectionState("idle");
-      if (sessionEventFeedStore.getSnapshot()?.sessionId === sessionId) {
-        sessionEventFeedStore.set(null);
-      }
-    },
-    [sessionId, sessionEventFeedStore, setContextConnectionState, setContextSession]
-  );
-  useSessionFailureToasts(loadError, streamError);
-  const oauthReturnHandled = useRef2(false);
-  const capabilityClient = context.client;
-  const capabilityCatalog = context.workspaceCapabilityCatalog;
-  const capabilityCatalogReady = context.workspaceMcpCatalogReady;
-  const refreshCapabilityCatalog = context.refreshWorkspaceMcpServers;
-  useEffect4(() => {
-    if (oauthReturnHandled.current || !capabilityCatalogReady) {
-      return;
-    }
-    const params = page.readQuery();
-    const outcome = params.get("integration_oauth");
-    if (!outcome) {
-      return;
-    }
-    oauthReturnHandled.current = true;
-    page.replaceQuery(new URLSearchParams());
-    const capabilityId = params.get("capability_auth");
-    if (outcome !== "success") {
-      void import("./app/lib/oauth-callback-messages.js").then(
-        ({ mcpOAuthCallbackFailureMessage }) => toast.error("Reconnect failed", {
-          description: mcpOAuthCallbackFailureMessage(params.get("stage"), params.get("reason"))
-        })
-      );
-      return;
-    }
-    if (!capabilityId) {
-      toast.success("Connection restored", {
-        description: "The earlier tool call wasn't replayed. Send a new message to try again."
-      });
-      return;
-    }
-    void (async () => {
-      const finished = await finishMcpCapabilityOAuthReturn({
-        client: capabilityClient,
-        workspaceId,
-        sessionId,
-        capabilityId,
-        params,
-        catalog: capabilityCatalog,
-        refreshCatalog: refreshCapabilityCatalog
-      });
-      toast.success(`${finished.name} connected`, {
-        description: finished.needsPersonalReview ? "Review its connection card to allow your personal account in this conversation." : "It is available to new tool calls in this session."
-      });
-    })().catch((error) => {
-      toast.error("Connection succeeded, but setup needs attention", {
-        description: userErrorText(error)
-      });
-    });
-  }, [
-    page,
-    capabilityCatalog,
-    capabilityCatalogReady,
-    capabilityClient,
-    refreshCapabilityCatalog,
-    workspaceId,
-    sessionId
-  ]);
-  const nativeReturnHandled = useRef2(false);
-  useEffect4(() => {
-    if (nativeReturnHandled.current || !capabilityCatalogReady) return;
-    const params = page.readQuery();
-    const social = params.get("social_oauth");
-    const fiken = params.get("fiken");
-    if (!social && !fiken) return;
-    nativeReturnHandled.current = true;
-    page.replaceQuery(new URLSearchParams());
-    if (social === "success" || fiken === "connected") {
-      const capabilityId = params.get("capability_auth");
-      void (async () => {
-        await refreshCapabilityCatalog(workspaceId);
-        await completeSessionCapabilityOAuth(
-          t,
-          capabilityClient,
-          workspaceId,
-          sessionId,
-          capabilityId
-        );
-        toast.success("Connection setup completed", {
-          description: "It is available to new tool calls in this session."
-        });
-      })().catch(
-        (error) => toast.error("Connection authorized, but setup needs attention", {
-          description: userErrorText(error)
-        })
-      );
-    } else {
-      toast.error("Connection wasn't completed", {
-        description: "You can retry from the connection card."
-      });
-    }
-  }, [
-    page,
-    capabilityCatalogReady,
-    capabilityClient,
-    refreshCapabilityCatalog,
-    workspaceId,
-    sessionId
-  ]);
-  const githubReturnHandled = useRef2(false);
-  useEffect4(() => {
-    if (githubReturnHandled.current) return;
-    const params = page.readQuery();
-    const outcome = params.get("github");
-    if (outcome !== "connected" && outcome !== "requested") return;
-    githubReturnHandled.current = true;
-    page.replaceQuery(new URLSearchParams());
-    if (outcome === "requested") {
-      recordGitHubInstallRequest(workspaceId);
-      toast.success("Request sent to your GitHub organization owners", {
-        description: "After an owner approves, an owner of the organization connects it here. Your GitHub card updates on its own."
-      });
-      return;
-    }
-    clearGitHubInstallRequest(workspaceId);
-    toast.success("GitHub connected", {
-      description: "Repository access is now available to new tool calls in this session."
-    });
-  }, [page, workspaceId]);
-  const reconnectTransport = useMemo3(() => context.client.connectTransport(), [context.client]);
-  const [reconnectRequest, setReconnectRequest] = useState3(null);
-  const reconnectCardConnections = useRef2(/* @__PURE__ */ new WeakMap());
-  const connectGitHubApp = useCallback3(() => {
-    setReconnectRequest(githubAppConnectRequest(workspaceId, reconnectTransport, page.href()));
-  }, [page, reconnectTransport, workspaceId]);
-  const connectPersonalGitHub = context.connectPersonalGitHub;
-  const reconnectPersonalGitHub = context.reconnectPersonalGitHub;
-  const personalGitHubConnection = context.personalGitHubStatus?.connection ?? null;
-  const personalGitHubNeedsReconnect = personalGitHubConnection !== null && personalGitHubConnection.status !== "active" && personalGitHubConnection.status !== "revoked";
-  const onReconnect = useCallback3(
-    async (item) => {
-      if (item.authoritySource === "host") {
-        if (!item.authorizationUrl) {
-          throw new Error(
-            "This connection is managed by the embedding host and has no recovery link."
-          );
-        }
-        page.assign(item.authorizationUrl);
-        return;
-      }
-      if (item.connectionId) {
-        const { findConnectRecoveryAccount } = await import("@opengeni/connect");
-        const account = findConnectRecoveryAccount(
-          await reconnectTransport.accounts(workspaceId),
-          item.connectionId
-        );
-        if (account) {
-          const request = {
-            scope: { workspaceId, transport: reconnectTransport },
-            providerId: account.providerId,
-            ownership: account.ownership,
-            reconnectAccountId: account.id,
-            // A tool needed more access than the account was connected with:
-            // the reconnect asks the provider for exactly that (incremental consent).
-            // Other providers keep their fixed permission set.
-            ...item.reason === "insufficient_scope" && item.scopes.length > 0 && connectProviderAcceptsRequestedScopes(account.providerId) ? { requestedScopes: [...item.scopes] } : {},
-            displayName: account.label,
-            returnUrl: page.href(),
-            idempotencyKey: crypto.randomUUID()
-          };
-          reconnectCardConnections.current.set(request, item.connectionId);
-          setReconnectRequest(request);
-          return;
-        }
-      }
-      if (item.capability) {
-        const returnPath2 = `${new URL(page.href()).pathname}?capability_auth=${encodeURIComponent(item.capability.id)}`;
-        if (item.capability.id === "api:github-app") {
-          const status = await context.client.getGitHubApp(workspaceId, {
-            returnPath: returnPath2
-          });
-          if (status.status === "bound") {
-            toast.success("GitHub is already connected");
-            return;
-          }
-          if (!status.linkUrl) {
-            throw new Error(
-              status.configured ? "Your account cannot manage this workspace's GitHub connection." : "GitHub is not configured on this deployment."
-            );
-          }
-          await markIntegrationConnectRedirect("github", "app_install");
-          page.assign(status.linkUrl);
-          return;
-        }
-        if (item.capability.id === "api:github-personal") {
-          await (personalGitHubNeedsReconnect ? reconnectPersonalGitHub : connectPersonalGitHub)(
-            workspaceId
-          );
-          return;
-        }
-        if (item.capability.id === "mcp:codex_apps") {
-          page.assign(`/workspaces/${encodeURIComponent(workspaceId)}/settings`);
-          return;
-        }
-        const catalogItem = context.workspaceCapabilityCatalog.find(
-          (candidate) => candidate.id === item.capability?.id
-        );
-        const canInstall = canConnectWorkspaceMcpFromChat(
-          context.accessContext,
-          workspaceId,
-          catalogItem,
-          context.workspaceMemberIntegrationSetup
-        );
-        const mcpUrl = catalogItem?.mcpUrl ?? catalogItem?.endpointUrl ?? null;
-        if (canInstall && catalogItem?.kind === "mcp" && catalogItem.authKind === "oauth2" && mcpUrl) {
-          const response2 = await startMcpOAuthWithTimeout(context.client, workspaceId, {
-            mcpUrl,
-            ...catalogItem.providerDomain ? { providerDomain: catalogItem.providerDomain } : {},
-            ownership: "workspace",
-            returnPath: returnPath2
-          });
-          if (!response2.authorizationUrl) {
-            throw new Error("The provider did not return an authorization link.");
-          }
-          await markIntegrationConnectRedirect({ domain: mcpUrl }, "oauth");
-          page.assign(response2.authorizationUrl);
-          return;
-        }
-        page.assign(
-          `/workspaces/${encodeURIComponent(workspaceId)}/capabilities?suggested_capability=${encodeURIComponent(item.capability.id)}`
-        );
-        return;
-      }
-      if (item.serverId === "codex_apps") {
-        page.assign(`/workspaces/${encodeURIComponent(workspaceId)}/settings`);
-        return;
-      }
-      const connections = await context.client.listConnections(workspaceId).catch(() => []);
-      const connection = item.connectionId ? connections.find((candidate) => candidate.id === item.connectionId) ?? null : null;
-      if (connection?.kind === "api_key") {
-        page.assign(
-          `/workspaces/${encodeURIComponent(workspaceId)}/capabilities?reconnect_domain=${encodeURIComponent(item.providerDomain)}`
-        );
-        return;
-      }
-      const pageUrl = new URL(page.href());
-      const returnPath = `${pageUrl.pathname}${pageUrl.search}`;
-      const response = await context.client.startConnectionOAuth(workspaceId, {
-        providerDomain: item.providerDomain,
-        ...item.connectionId ? { connectionId: item.connectionId } : {},
-        ...item.resource ? { resource: item.resource } : {},
-        returnPath
-      });
-      if (!response.authorizationUrl) {
-        throw new Error("The provider did not return an authorization link.");
-      }
-      await markIntegrationConnectRedirect({ domain: item.providerDomain }, "oauth");
-      page.assign(response.authorizationUrl);
-    },
-    [
-      page,
-      context.accessContext,
-      context.client,
-      connectPersonalGitHub,
-      reconnectPersonalGitHub,
-      personalGitHubNeedsReconnect,
-      context.workspaceCapabilityCatalog,
-      context.workspaceMemberIntegrationSetup,
-      workspaceId,
-      reconnectTransport
-    ]
-  );
-  const providerLogos = useMemo3(
-    () => connectorLogoIndex(
-      context.workspaceCapabilityCatalog,
-      (path) => context.client.catalogAssetUrl(path ?? null)
-    ),
-    [context.client, context.workspaceCapabilityCatalog]
-  );
-  const resolveProviderLogo = useCallback3(
-    (domain) => connectorLogo(providerLogos, domain),
-    [providerLogos]
-  );
-  const lineagePoll = useLineagePollInterval(workspaceId);
-  const lineage = useSessionLineage(sessionId, {
-    events,
-    pollIntervalMs: lineagePoll.pollIntervalMs
-  });
-  const agentNodes = useMemo3(() => lineage.lineage?.children ?? [], [lineage.lineage]);
-  const observeLineageTree = lineagePoll.observeTree;
-  useEffect4(() => observeLineageTree(agentNodes), [agentNodes, observeLineageTree]);
-  const descendantRefreshSignal = useDescendantRequestsRefresh({
-    client: context.client,
-    workspaceId,
-    sessionId,
-    events,
-    nodes: agentNodes,
-    refreshLineage: lineage.refresh
-  });
-  const lineageTitles = useMemo3(() => {
-    const titles = /* @__PURE__ */ new Map();
-    for (const ancestor of lineage.lineage?.ancestors ?? []) {
-      titles.set(ancestor.id, sessionDisplayTitle(ancestor));
-    }
-    const visit = (nodes) => {
-      for (const node of nodes) {
-        titles.set(node.session.id, sessionDisplayTitle(node.session));
-        visit(node.children);
-      }
-    };
-    visit(lineage.lineage?.children ?? []);
-    return titles;
-  }, [lineage.lineage]);
-  const resolveSessionTitle = useCallback3(
-    (agentSessionId) => lineageTitles.get(agentSessionId) ?? null,
-    [lineageTitles]
-  );
-  const sandboxFileRequestSeq = useRef2(0);
-  const [sandboxFileRequest, setSandboxFileRequest] = useState3(null);
-  useEffect4(() => {
-    setSandboxFileRequest(null);
-  }, [sessionId]);
-  const setInspectorOpen = context.setInspectorOpen;
-  const agentSettingsRequestSeq = useRef2(0);
-  const [agentSettingsRequest, setAgentSettingsRequest] = useState3(null);
-  const openAgentSettings = useCallback3(() => {
-    setAgentSettingsRequest({
-      sessionId,
-      requestId: ++agentSettingsRequestSeq.current,
-      target: "learning"
-    });
-    setInspectorOpen(true);
-  }, [sessionId, setInspectorOpen]);
-  const openUsageLimit = useCallback3(() => {
-    setAgentSettingsRequest({
-      sessionId,
-      requestId: ++agentSettingsRequestSeq.current,
-      target: "usage-limit"
-    });
-    setInspectorOpen(true);
-  }, [sessionId, setInspectorOpen]);
-  useEffect4(() => {
-    uiEvents.addEventListener(OPEN_SESSION_USAGE_LIMIT_EVENT, openUsageLimit);
-    return () => uiEvents.removeEventListener(OPEN_SESSION_USAGE_LIMIT_EVENT, openUsageLimit);
-  }, [openUsageLimit, uiEvents]);
-  const openSandboxFile = useCallback3(
-    (path, line) => {
-      setSandboxFileRequest({
-        path,
-        line,
-        requestId: ++sandboxFileRequestSeq.current
-      });
-      setInspectorOpen(true);
-    },
-    [setInspectorOpen]
-  );
-  if (!session || !opened) {
-    if (leavingRestoredSession) return /* @__PURE__ */ jsx(LoadingPanel, {});
-    if (!session && loadError) {
-      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(LoadingPanel, {}), children: /* @__PURE__ */ jsx(
-        LazySessionRouteAuxiliary,
-        {
-          workspaceId,
-          sessionId,
-          loadError,
-          onRetry: () => void refreshSession()
-        }
-      ) });
-    }
-    return /* @__PURE__ */ jsx("div", { className: "flex min-h-0 w-full min-w-0 flex-1 overflow-hidden", children: /* @__PURE__ */ jsx(
-      SessionDock,
-      {
-        workspaceId,
-        sessionId,
-        session: null,
-        events,
-        connectionState,
-        primary: session && streamError && !initialLoading ? /* @__PURE__ */ jsx(
-          ProblemPanel,
-          {
-            title: "Conversation couldn't be loaded",
-            description: "Your saved messages are unchanged. Try loading them again.",
-            action: /* @__PURE__ */ jsx(Button, { variant: "outline", onClick: () => void jumpToLatest(), children: "Retry conversation" })
-          }
-        ) : /* @__PURE__ */ jsx(LoadingPanel, {}),
-        onReloadSession: refreshSession,
-        dockCollapsed: !context.inspectorOpen,
-        onDockCollapsedChange: (collapsed) => context.setInspectorOpen(!collapsed),
-        openFileRequest: sandboxFileRequest,
-        onOpenNavigation: () => {
-          context.setInspectorOpen(false);
-          rail.setDrawerOpen(true);
-        }
-      }
-    ) });
-  }
-  const chatPane = /* @__PURE__ */ jsx(
-    SessionChatPane,
-    {
-      session,
-      admissionSessionControl: sessionSeed?.effectiveControl ?? session.effectiveControl,
-      events,
-      timeline,
-      searchTarget,
-      onJumpToSequence: jumpToSequence,
-      initialLoading,
-      historyReloadFailed: hasObservedHistory && events.length === 0 && !!streamError,
-      launch,
-      realtimeAutostartModel,
-      onRealtimeAutostartConsumed: consumeRealtimeAutostart,
-      onSearchOriginConsumed: consumeSearchOrigin,
-      placement,
-      messageContext,
-      initialDraft,
-      approvals,
-      humanInput,
-      failure,
-      creditExhausted,
-      creditRefusal,
-      goal,
-      queue,
-      agentNodes,
-      pendingWake: sessionHasPendingWake(withLineageAutomationFacts(session, lineage.lineage)),
-      descendantRefreshSignal,
-      onDescendantResolved: () => void lineage.refresh(),
-      hasOlder,
-      loadingOlder,
-      onLoadOlder: loadOlder,
-      hasNewer,
-      loadingNewer,
-      onLoadNewer: loadNewer,
-      loadingOldest,
-      onJumpToStart: loadOldest,
-      onJumpToLatest: jumpToLatest,
-      onClearView: clearView,
-      resolveSessionTitle,
-      onOpenSession: (nextSessionId) => void navigate({
-        to: "/workspaces/$workspaceId/sessions/$sessionId",
-        params: { workspaceId, sessionId: nextSessionId }
-      }),
-      onMemoryClick: (memoryId) => void navigate({
-        to: "/workspaces/$workspaceId/memory",
-        params: { workspaceId },
-        search: { memory: memoryId }
-      }),
-      onLearningRefusalOpen: (place) => {
-        switch (place.kind) {
-          case "skill":
-            void navigate({
-              href: `/workspaces/${encodeURIComponent(workspaceId)}/plugins?section=skills&open=${encodeURIComponent(`skill:${place.skillId}`)}`
-            });
-            return;
-          case "skills":
-            void navigate({
-              to: "/workspaces/$workspaceId/plugins",
-              params: { workspaceId },
-              search: { section: "skills" }
-            });
-            return;
-          case "instructions":
-            void navigate({
-              to: "/workspaces/$workspaceId/state",
-              params: { workspaceId },
-              search: { view: "instructions" }
-            });
-            return;
-          case "knowledge":
-            void navigate({ to: "/workspaces/$workspaceId/state", params: { workspaceId } });
-            return;
-          case "learning-settings":
-            void navigate({
-              to: "/workspaces/$workspaceId/settings",
-              params: { workspaceId },
-              search: { section: "learning" }
-            });
-        }
-      },
-      onNewSession: onNewSession ?? (() => void navigate({
-        to: "/workspaces/$workspaceId/sessions",
-        params: { workspaceId }
-      })),
-      onContinueInNewSession: () => void navigate({
-        to: "/workspaces/$workspaceId/sessions",
-        params: { workspaceId },
-        search: { continueSessionId: sessionId }
-      }),
-      onApprove: (approvalId, answer) => approve(approvalId, "approve", answer),
-      onReject: (approvalId) => approve(approvalId, "reject"),
-      onReconnect,
-      onConnectGitHubApp: connectGitHubApp,
-      resolveProviderLogo,
-      onReloadSession: refreshSession,
-      onOpenSandboxFile: dockEnabled ? openSandboxFile : void 0,
-      onOpenAgentSettings: dockEnabled ? openAgentSettings : void 0,
-      onOpenUsageLimit: dockEnabled ? openUsageLimit : void 0,
-      connectionState
-    },
-    session.id
-  );
-  const routeView = /* @__PURE__ */ jsxs("div", { className: "flex min-h-0 w-full min-w-0 flex-1 overflow-hidden", children: [
-    reconnectRequest && /* @__PURE__ */ jsx(LazyPart, { fallback: /* @__PURE__ */ jsx(LoadingPanel, { label: "Opening connection setup" }), children: /* @__PURE__ */ jsx(
-      NativeConnectSetup,
-      {
-        transport: reconnectTransport,
-        workspaceId,
-        request: reconnectRequest,
-        onClose: () => setReconnectRequest(null),
-        onComplete: () => {
-          setReconnectRequest((current) => current === reconnectRequest ? null : current);
-          if (reconnectRequest.providerId === "github-app") {
-            toast.success("GitHub connected");
-            void context.refreshGitHub(workspaceId, void 0, {
-              sync: true,
-              userInitiated: true
-            });
-            return;
-          }
-          const connectionId = reconnectCardConnections.current.get(reconnectRequest);
-          if (connectionId)
-            void Promise.resolve().then(
-              () => context.client.continueAfterCapabilitySetup(workspaceId, sessionId, {
-                connectionId
-              })
-            ).catch(() => void 0);
-          toast.success("Connection updated", {
-            description: "New tool calls can use the updated connection."
-          });
-        }
-      }
-    ) }),
-    /* @__PURE__ */ jsx(
-      SessionDock,
-      {
-        workspaceId,
-        sessionId,
-        session,
-        events,
-        connectionState,
-        primary: /* @__PURE__ */ jsx(
-          ChatPaymentPages,
-          {
-            accountId: session?.accountId ?? context.workspaces.find((candidate) => candidate.id === workspaceId)?.accountId,
-            children: chatPane
-          }
-        ),
-        onReloadSession: refreshSession,
-        dockCollapsed: !context.inspectorOpen,
-        onDockCollapsedChange: (collapsed) => context.setInspectorOpen(!collapsed),
-        openFileRequest: sandboxFileRequest,
-        openAgentSettingsRequest: agentSettingsRequest?.sessionId === sessionId ? agentSettingsRequest : null,
-        onOpenNavigation: () => {
-          context.setInspectorOpen(false);
-          rail.setDrawerOpen(true);
-        }
-      }
-    )
-  ] });
-  return routed ? routeView : /* @__PURE__ */ jsx(SessionStartupProvider, { session, children: routeView });
-  async function approve(approvalId, decision, answer) {
-    try {
-      await context.client.sendApprovalDecision(workspaceId, sessionId, {
-        approvalId,
-        decision,
-        ...answer
-      });
-    } catch (error) {
-      toast.error("Couldn't submit the decision", {
-        description: userErrorText(error)
-      });
-      throw error instanceof Error ? error : new Error(String(error));
-    }
-  }
-}
-function withHostMessageContext(...sources) {
-  const value = sources.map((source) => source?.()).filter((part) => Boolean(part)).join("\n\n");
-  return value ? { modelContext: value } : {};
-}
-function lastAgentChange(events) {
-  for (let index = events.length - 1; index >= 0; index -= 1) {
-    const event = events[index];
-    if (event.type !== "session.agent.updated") continue;
-    const pending = !events.slice(index + 1).some((later) => later.type === "turn.started");
-    return { at: event.occurredAt, pending };
-  }
-  return null;
-}
-function SessionDock(props) {
-  if (!useSessionUiFeature("dock")) {
-    return /* @__PURE__ */ jsx("div", { className: "flex min-h-0 min-w-0 flex-1 flex-col overflow-hidden", children: props.primary });
-  }
-  return /* @__PURE__ */ jsx(SessionDockPanel, { ...props });
-}
-function SessionDockPanel(props) {
-  const context = useAppContext();
-  const tabRequestSeq = useRef2(0);
-  const [tabRequest, setTabRequest] = useState3(null);
-  const agentSettingsRequestId = props.openAgentSettingsRequest?.requestId ?? null;
-  const agentSettingsTarget = props.openAgentSettingsRequest?.target ?? "learning";
-  const [agentLearningFocus, setAgentLearningFocus] = useState3(0);
-  const [usageLimitFocus, setUsageLimitFocus] = useState3(0);
-  useEffect4(() => {
-    if (agentSettingsRequestId === null) return;
-    setTabRequest({
-      sessionId: props.sessionId,
-      tab: "agent",
-      requestId: ++tabRequestSeq.current
-    });
-    if (agentSettingsTarget === "usage-limit") setUsageLimitFocus((value) => value + 1);
-    else setAgentLearningFocus((value) => value + 1);
-  }, [agentSettingsRequestId, props.sessionId]);
-  const goalPausedAtLimit = useMemo3(() => goalPausedAtUsageLimit(props.events), [props.events]);
-  const currentTabRequest = tabRequest?.sessionId === props.sessionId ? tabRequest : null;
-  const dockLayoutStorageId = sessionDockLayoutStorageId(
-    context.accessContext.subjectId,
-    props.sessionId
-  );
-  const dockNavigation = useMemo3(
-    () => readSessionDockNavigation(dockLayoutStorageId),
-    [dockLayoutStorageId]
-  );
-  const rememberArtifact = useCallback3(
-    (artifactId) => updateSessionDockNavigation(dockLayoutStorageId, { artifactId }),
-    [dockLayoutStorageId]
-  );
-  const artifactRefreshSequence = useMemo3(() => {
-    for (let index = props.events.length - 1; index >= 0; index -= 1) {
-      const event = props.events[index];
-      if (event && (event.type === "agent.toolCall.output" || event.type === "turn.completed" || event.type === "turn.failed" || event.type === "turn.cancelled")) {
-        return event.sequence;
-      }
-    }
-    return 0;
-  }, [props.events]);
-  useEffect4(() => {
-    if (artifactRefreshSequence) expireArtifactCatalog(context.client, props.workspaceId);
-  }, [artifactRefreshSequence, context.client, props.workspaceId]);
-  const artifactState = useSessionEditableArtifactSummaries({
-    workspaceId: props.workspaceId,
-    sessionId: props.sessionId,
-    refreshSequence: artifactRefreshSequence
-  });
-  const expireAfterArtifactMutation = useArtifactCatalogMutationInvalidation(
-    context.client,
-    props.workspaceId,
-    expireArtifactCatalog
-  );
-  const [artifactRequest, setArtifactRequest] = useState3(null);
-  const currentArtifactRequest = artifactRequest?.sessionId === props.sessionId ? artifactRequest : null;
-  const artifactTabRequestId = currentArtifactRequest?.requestId ?? null;
-  useEffect4(() => {
-    if (artifactTabRequestId === null) return;
-    setTabRequest({
-      sessionId: props.sessionId,
-      tab: "artifacts",
-      requestId: ++tabRequestSeq.current
-    });
-  }, [artifactTabRequestId, props.sessionId]);
-  const artifactSummaries = [...artifactState.artifacts];
-  if (currentArtifactRequest && !artifactSummaries.some(
-    (item) => item.id === currentArtifactRequest.artifactId && (!currentArtifactRequest.artifactKind || item.modality === currentArtifactRequest.artifactKind || currentArtifactRequest.artifactKind === "file" && item.modality === "image")
-  )) {
-    artifactSummaries.push({
-      id: currentArtifactRequest.artifactId,
-      modality: currentArtifactRequest.artifactKind ?? "site",
-      title: currentArtifactRequest.artifactKind === "image" ? "Image" : currentArtifactRequest.artifactKind === "file" ? "File" : "Site"
-    });
-  }
-  const trailingTabs = [
-    {
-      id: "artifacts",
-      label: "Artifacts",
-      icon: /* @__PURE__ */ jsx(PanelsTopLeftIcon, {}),
-      ...artifactSummaries.length > 0 ? {
-        badge: /* @__PURE__ */ jsx("span", { className: "rounded-og-xs bg-og-accent-soft px-1 text-og-xs text-og-fg-muted", children: artifactSummaries.length })
-      } : {},
-      content: /* @__PURE__ */ jsx(LazyPart, { fallback: /* @__PURE__ */ jsx(LoadingPanel, { label: "Opening artifact" }), children: /* @__PURE__ */ jsx(
-        LazySessionEditableArtifactsWorkspace,
-        {
-          workspaceId: props.workspaceId,
-          sessionId: props.sessionId,
-          artifacts: artifactSummaries,
-          status: artifactState.status,
-          onRetry: artifactState.retry,
-          initialSelectedArtifactId: dockNavigation.artifactId,
-          openArtifactRequest: currentArtifactRequest,
-          onSelectedArtifactIdChange: rememberArtifact,
-          onPin: hasWorkspacePermission(context.accessContext, props.workspaceId, "artifacts:publish") ? async (item, pinned) => {
-            await context.client.updateArtifactPin(
-              props.workspaceId,
-              item.kind,
-              item.id,
-              pinned
-            );
-            artifactState.applyPin(item.kind, item.id, pinned);
-            expireAfterArtifactMutation();
-            artifactState.retry();
-          } : void 0
-        },
-        props.sessionId
-      ) })
-    }
-  ];
-  if (props.session) {
-    trailingTabs.push({
-      id: "agent",
-      label: "Agent",
-      icon: /* @__PURE__ */ jsx(BotIcon, {}),
-      content: /* @__PURE__ */ jsx(LazyPart, { fallback: /* @__PURE__ */ jsx(LoadingPanel, { label: "Opening agent settings" }), children: /* @__PURE__ */ jsx(
-        LazyAgentConfigurationPanel,
-        {
-          session: props.session,
-          lastChange: lastAgentChange(props.events),
-          onReloadSession: props.onReloadSession,
-          learningFocusRequest: agentLearningFocus,
-          usageLimitFocusRequest: usageLimitFocus,
-          goalPausedAtUsageLimit: goalPausedAtLimit
-        },
-        props.session.id
-      ) })
-    });
-  }
-  if (props.session) {
-    trailingTabs.push({
-      id: "debug",
-      label: "Debug",
-      icon: /* @__PURE__ */ jsx(BugIcon, {}),
-      content: /* @__PURE__ */ jsx(LazyPart, { fallback: /* @__PURE__ */ jsx(LoadingPanel, { label: "Opening debug inspector" }), children: /* @__PURE__ */ jsx(
-        LazySessionInspector,
-        {
-          session: props.session,
-          events: props.events,
-          connectionState: props.connectionState,
-          onReloadSession: props.onReloadSession
-        }
-      ) })
-    });
-  }
-  return /* @__PURE__ */ jsx(
-    SessionWorkspace,
-    {
-      workspaceId: props.workspaceId,
-      sessionId: props.sessionId,
-      preferenceOwnerId: context.accessContext.subjectId,
-      events: props.events,
-      primary: /* @__PURE__ */ jsx(
-        ArtifactLinkBoundary,
-        {
-          workspaceId: props.workspaceId,
-          onOpen: (target) => {
-            if (target.editable && !artifactSummaries.some(
-              (item) => item.id === target.id && isEditableArtifactKind(item.modality)
-            ))
-              return false;
-            setArtifactRequest((previous) => ({
-              sessionId: props.sessionId,
-              artifactId: target.id,
-              artifactKind: target.kind === "file" ? artifactSummaries.find(
-                (item) => item.id === target.id && (item.modality === "file" || item.modality === "image")
-              )?.modality ?? "file" : target.editable ? artifactSummaries.find(
-                (item) => item.id === target.id && isEditableArtifactKind(item.modality)
-              )?.modality : "site",
-              requestId: (previous?.requestId ?? 0) + 1,
-              tab: "artifacts"
-            }));
-            return true;
-          },
-          children: props.primary
-        }
-      ),
-      openTabRequest: currentTabRequest,
-      trailingTabs,
-      collapsed: props.dockCollapsed,
-      onCollapsedChange: props.onDockCollapsedChange,
-      ...props.openFileRequest ? { openFileRequest: props.openFileRequest } : {},
-      mobileLeadingControl: /* @__PURE__ */ jsx(
-        Button,
-        {
-          type: "button",
-          variant: "ghost",
-          size: "icon-sm",
-          "aria-label": "Open navigation",
-          onClick: props.onOpenNavigation,
-          className: "size-11",
-          children: /* @__PURE__ */ jsx(MenuIcon, { className: "size-4" })
-        }
-      )
-    }
-  );
-}
-function useSessionEditableArtifactSummaries(input) {
-  const context = useAppContext();
-  const authorityKey = `${input.workspaceId}:${input.sessionId}:${context.accessKeyVersion}`;
-  const [retrySequence, setRetrySequence] = useState3(0);
-  const discovery = useRef2(null);
-  const [loaded, setLoaded] = useState3(null);
-  useEffect4(
-    () => () => {
-      discovery.current = null;
-    },
-    []
-  );
-  useEffect4(() => {
-    if (discovery.current?.key !== authorityKey || discovery.current.client !== context.client || discovery.current.retrySequence !== retrySequence)
-      discovery.current = {
-        key: authorityKey,
-        client: context.client,
-        retrySequence,
-        running: false,
-        again: false
-      };
-    const run = discovery.current;
-    setLoaded(
-      (previous) => previous?.key === authorityKey && previous.client === context.client && previous.status === "ready" ? previous : {
-        key: authorityKey,
-        client: context.client,
-        status: "loading",
-        artifacts: previous?.key === authorityKey && previous.client === context.client ? previous.artifacts : []
-      }
-    );
-    if (run.running) {
-      run.again = true;
-      return;
-    }
-    const workspaceId = input.workspaceId;
-    const sessionId = input.sessionId;
-    const client = context.client;
-    const live = () => discovery.current === run;
-    const previousArtifacts = (previous) => previous?.key === authorityKey && previous.client === client ? previous.artifacts : [];
-    const start = () => {
-      run.running = true;
-      run.again = false;
-      void import("./app/lib/session-artifact-discovery.js").then(async ({ discoverSessionArtifacts }) => {
-        const reconcile = await discoverSessionArtifacts(workspaceId, sessionId, live, client);
-        if (live())
-          setLoaded((previous) => ({
-            key: authorityKey,
-            client,
-            ...reconcile(previousArtifacts(previous))
-          }));
-      }).catch(() => {
-        if (!live()) return;
-        setLoaded((previous) => ({
-          key: authorityKey,
-          client,
-          status: "error",
-          artifacts: previousArtifacts(previous)
-        }));
-      }).finally(() => {
-        run.running = false;
-        if (run.again && live()) start();
-      });
-    };
-    start();
-  }, [
-    authorityKey,
-    context.client,
-    input.refreshSequence,
-    input.sessionId,
-    input.workspaceId,
-    retrySequence
-  ]);
-  const retry = useCallback3(() => setRetrySequence((value) => value + 1), []);
-  const applyPin = useCallback3(
-    (kind, id, pinned) => {
-      setLoaded((previous) => {
-        if (previous?.key !== authorityKey || previous.client !== context.client) return previous;
-        return {
-          ...previous,
-          artifacts: previous.artifacts.map(
-            (artifact) => artifact.modality === kind && artifact.id === id && artifact.catalogItem ? { ...artifact, catalogItem: { ...artifact.catalogItem, pinned } } : artifact
-          )
-        };
-      });
-    },
-    [authorityKey, context.client]
-  );
-  return loaded?.key === authorityKey && loaded.client === context.client ? { artifacts: loaded.artifacts, status: loaded.status, retry, applyPin } : { artifacts: [], status: "loading", retry, applyPin };
-}
-function approvalDecisionKey(approval) {
-  return `${approval.id}\0${approval.elicitation?.round ?? ""}`;
-}
-function SessionChatPane(props) {
-  const findEvents = useUiEventTarget("document");
-  const portalContainer = usePortalContainer();
-  const [panelRoot, setPanelRoot] = useState3(null);
-  const context = useAppContext();
-  const api = useAppApi();
-  const page = usePage();
-  const navigate = useNavigate();
-  const openSession = useCallback3(
-    (workspaceId, sessionId) => void navigate({
-      to: "/workspaces/$workspaceId/sessions/$sessionId",
-      params: { workspaceId, sessionId }
-    }),
-    [navigate]
-  );
-  const resolveLink = useWorkspaceAppLinkResolver(props.session.workspaceId, openSession);
-  const hostMessageContext = useHostMessageContext();
-  const gutter = props.placement === "panel" ? "px-3" : "px-4 sm:px-6";
-  const realtimeClient = useMemo3(
-    () => api.voiceRealtimeClient(context.client, () => page.href()),
-    [api, context.client, page]
-  );
-  const momentSequence = props.searchTarget.find ? void 0 : props.searchTarget.at;
-  const loadedMoment = useRef2(null);
-  const { onJumpToSequence, initialLoading: historyLoading } = props;
-  const firstLoadedSequence = props.events[0]?.sequence;
-  useEffect4(() => {
-    if (!momentSequence || historyLoading || loadedMoment.current === momentSequence) return;
-    loadedMoment.current = momentSequence;
-    if (firstLoadedSequence !== void 0 && firstLoadedSequence > momentSequence) {
-      void onJumpToSequence(momentSequence);
-    }
-  }, [momentSequence, historyLoading, firstLoadedSequence, onJumpToSequence]);
-  const [findOpen, setFindOpen] = useState3(!!props.searchTarget.find);
-  const [findMounted, setFindMounted] = useState3(!!props.searchTarget.find);
-  const [findFocusRevision, setFindFocusRevision] = useState3(0);
-  const [activeSearchTarget, setActiveSearchTarget] = useState3(null);
-  const findReturnFocus = useRef2(null);
-  const openFind = useCallback3(() => {
-    const active = document.activeElement;
-    if (active instanceof HTMLElement && active !== document.body) findReturnFocus.current = active;
-    setFindMounted(true);
-    setFindOpen(true);
-    setFindFocusRevision((value) => value + 1);
-  }, []);
-  const { onSearchOriginConsumed } = props;
-  const closeFind = useCallback3(() => {
-    setFindOpen(false);
-    setActiveSearchTarget(null);
-    onSearchOriginConsumed();
-    requestAnimationFrame(() => {
-      const opener = findReturnFocus.current;
-      findReturnFocus.current = null;
-      const trigger = document.querySelector("[data-conversation-find-trigger]");
-      const target = opener?.isConnected ? opener : trigger && trigger.getClientRects().length > 0 ? trigger : null;
-      target?.focus({ preventScroll: true });
-    });
-  }, [onSearchOriginConsumed]);
-  useEffect4(() => {
-    findEvents.addEventListener(OPEN_CONVERSATION_FIND_EVENT, openFind);
-    return () => findEvents.removeEventListener(OPEN_CONVERSATION_FIND_EVENT, openFind);
-  }, [findEvents, openFind]);
-  useEffect4(() => {
-    if (props.searchTarget.find) openFind();
-  }, [
-    props.searchTarget.find,
-    props.searchTarget.matchSequence,
-    props.searchTarget.matchOffset,
-    openFind
-  ]);
-  useFindShortcut(
-    props.placement === "panel" ? { scope: panelRoot } : { scope: portalContainer ?? window },
-    openFind
-  );
-  const fundingRevision = useMemo3(() => {
-    for (let index = props.events.length - 1; index >= 0; index -= 1) {
-      const event = props.events[index];
-      if (event.type === "agent.model.usage") return event.sequence;
-    }
-    return 0;
-  }, [props.events]);
-  const modelCatalog = useWorkspaceModelCatalog(
-    props.session.workspaceId,
-    `${props.session.id}:${props.session.status}:${fundingRevision}`
-  );
-  const fleet = useWorkspaceMachines({
-    sessionId: props.session.id,
-    pollIntervalMs: MACHINES_SESSION_POLL_MS
-  });
-  const computeLabel = sessionComputeLabel(t, fleet.machines);
-  const loadRetainedScreenshot = useMemo3(
-    () => createSessionRetainedScreenshotLoader(
-      context.client,
-      props.session.workspaceId,
-      props.session.id
-    ),
-    [context.client, props.session.id, props.session.workspaceId]
-  );
-  const loadRetainedArtifact = useMemo3(
-    () => createWorkspaceRetainedArtifactLoader(context.client, props.session.workspaceId),
-    [context.client, props.session.workspaceId]
-  );
-  const loadVideoArtifactPlayback = useMemo3(
-    () => createWorkspaceRetainedVideoLoader(context.client, props.session.workspaceId),
-    [context.client, props.session.workspaceId]
-  );
-  const cancelled = isTerminalSessionStatus(props.session.status);
-  const readOnlyArchive = sessionReadOnlyArchive(props.session);
-  const terminal = cancelled || readOnlyArchive !== null;
-  const answerStore = useMemo3(() => browserInteractiveAnswerStore(), []);
-  const composerRegionRef = useRef2(null);
-  const [composerFocusSignal, setComposerFocusSignal] = useState3(0);
-  const focusEvents = useUiEventTarget("window");
-  const [modelPickerSession, setModelPickerSession] = useState3(null);
-  const [refusedModel, setRefusedModel] = useState3(
-    null
-  );
-  const [creditRefusal, setCreditRefusal] = useState3(null);
-  useEffect4(() => {
-    const onFocusRequest = (event) => {
-      const detail = event.detail;
-      if (detail?.workspaceId === props.session.workspaceId && detail.sessionId === props.session.id) {
-        setComposerFocusSignal(detail.nonce);
-      }
-    };
-    focusEvents.addEventListener(FOCUS_SESSION_COMPOSER_EVENT, onFocusRequest);
-    return () => focusEvents.removeEventListener(FOCUS_SESSION_COMPOSER_EVENT, onFocusRequest);
-  }, [focusEvents, props.session.id, props.session.workspaceId]);
-  const loadFocusSessionRef = useRef2(null);
-  const composerFocusWaitRef = useRef2(null);
-  useEffect4(
-    () => () => {
-      composerFocusWaitRef.current?.cancel();
-      composerFocusWaitRef.current = null;
-    },
-    []
-  );
-  useEffect4(() => {
-    if (composerFocusWaitRef.current && composerFocusWaitRef.current.sessionId !== props.session.id) {
-      composerFocusWaitRef.current.cancel();
-      composerFocusWaitRef.current = null;
-    }
-    const intent = consumeSessionComposerFocusIntent(
-      focusEvents,
-      props.session.workspaceId,
-      props.session.id
-    );
-    const firstRunForChat = loadFocusSessionRef.current !== props.session.id;
-    loadFocusSessionRef.current = props.session.id;
-    const source = intent?.source ?? (firstRunForChat ? "load" : null);
-    if (!source) return;
-    if (!sessionComposerFocusIntentIsEligible({
-      viewportWidth: globalThis.innerWidth,
-      coarsePointer: globalThis.matchMedia?.("(pointer: coarse)").matches ?? false,
-      terminal,
-      requiresAction: props.session.status === "requires_action",
-      pendingHumanInput: props.humanInput.requests.length > 0,
-      pendingApproval: props.approvals.length > 0
-    })) {
-      return;
-    }
-    composerFocusWaitRef.current?.cancel();
-    composerFocusWaitRef.current = {
-      sessionId: props.session.id,
-      cancel: focusSessionComposerWhenReady({
-        textarea: () => composerRegionRef.current?.querySelector("textarea"),
-        sessionId: props.session.id,
-        source
-      })
-    };
-  }, [
-    composerFocusSignal,
-    focusEvents,
-    props.approvals.length,
-    props.humanInput.requests.length,
-    props.session.id,
-    props.session.status,
-    props.session.workspaceId,
-    terminal
-  ]);
-  const agentsSignal = useMemo3(() => sessionAgentsSignal(t, props.agentNodes), [props.agentNodes]);
-  const [resumingSubSessions, setResumingSubSessions] = useState3(
-    () => /* @__PURE__ */ new Set()
-  );
-  const onSubSessionResumingChange = useCallback3((sessionId, resuming) => {
-    setResumingSubSessions((current) => {
-      if (current.has(sessionId) === resuming) return current;
-      const next = new Set(current);
-      if (resuming) next.add(sessionId);
-      else next.delete(sessionId);
-      return next;
-    });
-  }, []);
-  const waitingSubSessions = useMemo3(
-    () => waitingDescendants(props.agentNodes, resumingSubSessions),
-    [props.agentNodes, resumingSubSessions]
-  );
-  useEffect4(() => {
-    if (resumingSubSessions.size === 0) return;
-    const live = new Set(waitingSubSessions.map((session) => session.id));
-    for (const id of resumingSubSessions) {
-      if (!live.has(id)) onSubSessionResumingChange(id, false);
-    }
-  }, [onSubSessionResumingChange, resumingSubSessions, waitingSubSessions]);
-  const codexConnected = modelCatalog.models.some(
-    (candidate) => candidate.provider === "codex-subscription" && candidate.credentialReadiness.status === "ready"
-  );
-  const [voiceActive, setVoiceActive] = useState3(false);
-  const onVoiceActiveChange = useCallback3((active) => {
-    setVoiceActive(active);
-  }, []);
-  const [selectedApprovalId, setSelectedApprovalId] = useState3(null);
-  const [reviewDetails, setReviewDetails] = useState3(null);
-  const loadToolReview = useCallback3(
-    (approval) => context.client.getToolActionReview(props.session.workspaceId, props.session.id, approval.id),
-    [context.client, props.session.workspaceId, props.session.id]
-  );
-  const loadRecordedToolReview = useCallback3(
-    (id) => context.client.getToolActionReview(props.session.workspaceId, props.session.id, id),
-    [context.client, props.session.workspaceId, props.session.id]
-  );
-  const viewToolReviewDetails = useCallback3(
-    (review, path) => setReviewDetails({
-      review,
-      path,
-      origin: document.activeElement?.closest("[data-review-origin]")?.getAttribute("data-review-origin") ?? void 0
-    }),
-    []
-  );
-  const loadToolReviewDetails = useCallback3(
-    (review, path, offset) => context.client.getToolReviewDetails(props.session.workspaceId, props.session.id, review.id, {
-      actionDigest: review.actionDigest,
-      path,
-      offset
-    }),
-    [context.client, props.session.workspaceId, props.session.id]
-  );
-  const [approvalPending, setApprovalPending] = useState3({});
-  const [approvalSettled, setApprovalSettled] = useState3({});
-  useEffect4(() => {
-    if (!approvalsDecidable(props.session.status)) {
-      setApprovalPending((current) => Object.keys(current).length ? {} : current);
-      setApprovalSettled((current) => Object.keys(current).length ? {} : current);
-    }
-  }, [props.session.status]);
-  useEffect4(() => {
-    const waiting = new Set(props.approvals.map(approvalDecisionKey));
-    setApprovalSettled((current) => {
-      const kept = Object.entries(current).filter(([key]) => waiting.has(key));
-      return kept.length === Object.keys(current).length ? current : Object.fromEntries(kept);
-    });
-  }, [props.approvals]);
-  const approvalInFlightRef = useRef2(/* @__PURE__ */ new Set());
-  const decideApproval = useCallback3(
-    async (approvalId, decision, answer) => {
-      const approval = props.approvals.find((candidate) => candidate.id === approvalId);
-      const key = approval ? approvalDecisionKey(approval) : approvalId;
-      if (approvalInFlightRef.current.has(key) || approvalPending[key] || approvalSettled[key]) {
-        return;
-      }
-      approvalInFlightRef.current.add(key);
-      setApprovalPending((current) => ({ ...current, [key]: decision }));
-      try {
-        await (decision === "approve" ? props.onApprove(approvalId, answer) : props.onReject(approvalId));
-        setApprovalSettled((current) => ({
-          ...current,
-          [key]: decision
-        }));
-      } finally {
-        approvalInFlightRef.current.delete(key);
-        setApprovalPending((current) => {
-          const next = { ...current };
-          delete next[key];
-          return next;
-        });
-      }
-    },
-    [approvalPending, approvalSettled, props]
-  );
-  const attachments = useFileAttachments({
-    scope: props.session.tenancy?.visibility === "private" || props.session.memoryScope === "user" ? "personal" : "workspace"
-  });
-  const repositories = useFollowUpRepositories(props.session, props.onConnectGitHubApp);
-  const firstPartyToolOptions = firstPartySessionToolOptionsFor(
-    clientFirstPartyMcpToolPolicy(context.clientConfig).allowed
-  );
-  const selectableSessionMcpServers = context.toolMcpServers;
-  const selectableToolIds = useMemo3(
-    () => selectableSessionMcpServers.map((server) => server.id),
-    [selectableSessionMcpServers]
-  );
-  const policyToolIds = useMemo3(
-    () => sessionPolicyPickerIds(props.session, selectableToolIds, context.workspaceDefaultToolIds),
-    [context.workspaceDefaultToolIds, props.session, selectableToolIds]
-  );
-  const [durableToolSelection, setDurableToolSelection] = useState3(() => ({
-    mcpServerIds: new Set(policyToolIds),
-    firstPartyToolIds: new Set(props.session.firstPartyMcpTools)
-  }));
-  const [durableToolsSnapshot, setDurableToolsSnapshot] = useState3(props.session);
-  const durableToolsSaveInFlight = useRef2(false);
-  const [durableToolsHydrated, setDurableToolsHydrated] = useState3(false);
-  const durableToolsSessionId = useRef2(props.session.id);
-  const [durableToolsSaving, setDurableToolsSaving] = useState3(false);
-  const [durableToolsError, setDurableToolsError] = useState3(null);
-  const [connectorCustomizingOverride, setConnectorCustomizingOverride] = useState3(
-    null
-  );
-  const runsOn = useSessionRunsOn(props.session.id, props.session.sandboxBackend);
-  const machineAccess = currentSessionMachineAccess(
-    runsOn.fleet.sessionMachineAccess,
-    props.session.activeSandboxId
-  );
-  const sharedChat = props.session.tenancy?.visibility === "workspace" && !isPersonalWorkspace(
-    context.workspaces.find((candidate) => candidate.id === props.session.workspaceId) ?? null,
-    context.managedSelfContext
-  );
-  const showMachineAccess = machineAccess !== null && (!machineAccess.isOwner || sharedChat);
-  const connectionAccounts = useConnectionAccounts(
-    context.client,
-    {
-      id: props.session.id,
-      workspaceId: props.session.workspaceId,
-      selectedIds: [...durableToolSelection.mcpServerIds]
-    },
-    context.workspaceCapabilityCatalog,
-    context.accessContext === null ? null : hasWorkspacePermission(
-      context.accessContext,
-      props.session.workspaceId,
-      "connections:read"
-    )
-  );
-  const chatSendContext = useRef2({
-    blocked: null,
-    awaitingHuman: false,
-    extras: {}
-  });
-  const readChatSendContext = useCallback3(() => chatSendContext.current, []);
-  const runsOnAttach = runsOn.fleet.attach;
-  const runsOnPreviousSandboxId = runsOn.fleet.activeSandboxId;
-  const runsOnActiveMachineConsent = runsOn.activeMachine && isPersonalMachine(runsOn.activeMachine) && runsOn.activeMachine.sandboxId === props.session.activeSandboxId ? personalMachineUseIntent(props.session.tenancy) : void 0;
-  const runsOnCanMessage = context.accessContext === null || context.accessContext === void 0 || hasWorkspacePermission(context.accessContext, props.session.workspaceId, "sessions:control");
-  const reloadSessionAfterMachineChange = props.onReloadSession;
-  const moveSavedMessage = runsOnAttach;
-  const moveRunsOn = useCallback3(
-    async (machine) => {
-      if (!isPersonalMachine(machine)) {
-        if (!await runsOnAttach(machine.sandboxId))
-          return "The machine change could not be confirmed. Try refreshing the machine list.";
-        await reloadSessionAfterMachineChange();
-        return null;
-      }
-      const result = await moveChatToMachine({
-        machine,
-        chat: readChatSendContext(),
-        canMessage: runsOnCanMessage,
-        previousSandboxId: runsOnPreviousSandboxId,
-        attach: runsOnAttach,
-        sendMessage: (message) => context.client.sendMessage(props.session.workspaceId, props.session.id, message)
-      });
-      if (result.moved) await reloadSessionAfterMachineChange();
-      return result.moved ? null : result.reason ?? "The machine change could not be confirmed. Refresh the machine list and try again.";
-    },
-    [
-      context.client,
-      props.session.id,
-      props.session.workspaceId,
-      reloadSessionAfterMachineChange,
-      readChatSendContext,
-      runsOnAttach,
-      runsOnCanMessage,
-      runsOnPreviousSandboxId
-    ]
-  );
-  const sessionResourcesKey = stableJson(props.session.resources);
-  const stableSessionResources = useMemo3(() => props.session.resources, [sessionResourcesKey]);
-  const reloadSessionAfterSetup = props.onReloadSession;
-  const refreshConnectionAccounts = connectionAccounts.refresh;
-  const afterConnectionSetup = useCallback3(async () => {
-    await reloadSessionAfterSetup();
-    await refreshConnectionAccounts();
-  }, [reloadSessionAfterSetup, refreshConnectionAccounts]);
-  const renderAuthNeeded = useCallback3(
-    (item) => {
-      const recommendation = item.setupRequest ? item : sessionAuthRecommendation(t, item, context.workspaceCapabilityCatalog);
-      return recommendation ? /* @__PURE__ */ jsx(
-        Suspense,
-        {
-          fallback: /* @__PURE__ */ jsx("p", { role: "status", className: "text-sm text-fg-muted", children: "Loading connection card\u2026" }),
-          children: /* @__PURE__ */ jsx(
-            SessionCapabilityCard,
-            {
-              item: recommendation,
-              workspaceId: props.session.workspaceId,
-              sessionId: props.session.id,
-              visibility: props.session.tenancy?.visibility ?? "workspace",
-              resources: stableSessionResources,
-              sendContext: readChatSendContext,
-              onConfigured: afterConnectionSetup
-            },
-            `${props.session.id}:${props.session.tenancy?.authorityEpoch}:${item.id}`
-          )
-        }
-      ) : void 0;
-    },
-    [
-      context.workspaceCapabilityCatalog,
-      props.session.id,
-      props.session.workspaceId,
-      props.session.tenancy?.visibility,
-      props.session.tenancy?.authorityEpoch,
-      stableSessionResources,
-      readChatSendContext,
-      afterConnectionSetup
-    ]
-  );
-  const launch = props.launch ?? EMPTY_COMPOSER_LAUNCH;
-  const launchModel = launch.model;
-  const launchEffort = launch.effort;
-  const launchLatency = launch.latency;
-  const launchRealtime = launch.realtime;
-  const launchKey = composerLaunchSearchKey(launch);
-  const appliedLaunchKeyRef = useRef2(null);
-  useEffect4(() => {
-    if (durableToolsSessionId.current !== props.session.id) {
-      durableToolsSessionId.current = props.session.id;
-      setDurableToolsSnapshot(props.session);
-      setDurableToolsHydrated(false);
-      setConnectorCustomizingOverride(null);
-      return;
-    }
-    if (!context.workspaceMcpCatalogReady) {
-      setDurableToolsHydrated(false);
-      return;
-    }
-    if (durableToolsSaving) return;
-    const snapshot = props.session.toolPolicyVersion > durableToolsSnapshot.toolPolicyVersion ? props.session : durableToolsSnapshot;
-    if (snapshot !== durableToolsSnapshot) setDurableToolsSnapshot(snapshot);
-    const nextMcpIds = sessionPolicyPickerIds(
-      snapshot,
-      selectableToolIds,
-      context.workspaceDefaultToolIds
-    );
-    const nextFirstPartyIds = new Set(snapshot.firstPartyMcpTools);
-    setDurableToolSelection(
-      (current) => current.mcpServerIds.size === nextMcpIds.size && [...nextMcpIds].every((id) => current.mcpServerIds.has(id)) && current.firstPartyToolIds.size === nextFirstPartyIds.size && [...nextFirstPartyIds].every((id) => current.firstPartyToolIds.has(id)) ? current : { mcpServerIds: nextMcpIds, firstPartyToolIds: nextFirstPartyIds }
-    );
-    setDurableToolsHydrated(true);
-  }, [
-    context.workspaceMcpCatalogReady,
-    context.workspaceDefaultToolIds,
-    selectableToolIds,
-    durableToolsSaving,
-    durableToolsSnapshot,
-    props.session
-  ]);
-  const connectorCustomizing = connectorCustomizingOverride ?? sessionConnectorPolicyIsCustomized(durableToolsSnapshot);
-  const applyDurableToolPolicy = useCallback3(
-    async (request, optimistic) => {
-      if (durableToolsSaveInFlight.current) return;
-      durableToolsSaveInFlight.current = true;
-      const targetSessionId = props.session.id;
-      if (optimistic) setDurableToolSelection(optimistic);
-      setDurableToolsSaving(true);
-      setDurableToolsError(null);
-      try {
-        const updated = await context.client.updateSessionToolPolicy(
-          props.session.workspaceId,
-          targetSessionId,
-          request
-        );
-        if (durableToolsSessionId.current !== targetSessionId) return;
-        setDurableToolSelection({
-          mcpServerIds: sessionPolicyPickerIds(
-            updated,
-            selectableToolIds,
-            context.workspaceDefaultToolIds
-          ),
-          firstPartyToolIds: new Set(updated.firstPartyMcpTools)
-        });
-        setDurableToolsSnapshot(updated);
-        setConnectorCustomizingOverride((current) => current === true ? true : null);
-      } catch (error) {
-        const message = userErrorText(error);
-        setDurableToolsError(message);
-        toast.error("Couldn't save session tools", { description: message });
-        try {
-          const refreshed = await context.client.getSession(
-            props.session.workspaceId,
-            props.session.id
-          );
-          if (durableToolsSessionId.current !== targetSessionId) return;
-          setDurableToolSelection({
-            mcpServerIds: sessionPolicyPickerIds(
-              refreshed,
-              selectableToolIds,
-              context.workspaceDefaultToolIds
-            ),
-            firstPartyToolIds: new Set(refreshed.firstPartyMcpTools)
-          });
-          setDurableToolsSnapshot(refreshed);
-          setConnectorCustomizingOverride((current) => current === true ? true : null);
-        } catch {
-          if (durableToolsSessionId.current === targetSessionId) {
-            setDurableToolSelection({
-              mcpServerIds: sessionPolicyPickerIds(
-                durableToolsSnapshot,
-                selectableToolIds,
-                context.workspaceDefaultToolIds
-              ),
-              firstPartyToolIds: new Set(durableToolsSnapshot.firstPartyMcpTools)
-            });
-          }
-        }
-      } finally {
-        durableToolsSaveInFlight.current = false;
-        setDurableToolsSaving(false);
-      }
-    },
-    [
-      context.client,
-      context.workspaceDefaultToolIds,
-      durableToolsSnapshot,
-      props.session.id,
-      props.session.workspaceId,
-      selectableToolIds
-    ]
-  );
-  const saveDurableToolPolicy = useCallback3(
-    async (next) => {
-      await applyDurableToolPolicy(
-        connectorSelectionUpdate(
-          durableToolsSnapshot,
-          durableToolSelection.mcpServerIds,
-          next.mcpServerIds,
-          context.workspaceDefaultToolIds
-        ),
-        {
-          mcpServerIds: new Set(next.mcpServerIds),
-          firstPartyToolIds: new Set(next.firstPartyToolIds)
-        }
-      );
-    },
-    [
-      applyDurableToolPolicy,
-      context.workspaceDefaultToolIds,
-      durableToolsSnapshot,
-      durableToolSelection
-    ]
-  );
-  const sendGate = useSessionSendGate();
-  const workspace = context.workspaces.find((candidate) => candidate.id === props.session.workspaceId) ?? null;
-  const loadSkillReview = useCallback3(
-    (reference) => context.client.readWorkspaceSkill(
-      props.session.workspaceId,
-      reference.skillId,
-      reference.revisionId
-    ),
-    // A browser-account switch must discard the previous actor's loaded preview
-    // even when the SDK client instance and workspace remain unchanged.
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [context.client, props.session.workspaceId, context.accessContext.subjectId]
-  );
-  const fixedResourceCatalogEnabled = props.session.sandboxBackend !== "selfhosted";
-  const fixedRigScope = useFixedRigScope(
-    context.client,
-    workspace?.id ?? null,
-    props.session.rigId,
-    fixedResourceCatalogEnabled && hasWorkspacePermission(context.accessContext, props.session.workspaceId, "rigs:use")
-  );
-  const personalAttachment = usePersonalResourceAttachment({
-    client: context.client,
-    authMode: context.clientConfig.auth.mode,
-    authSession: context.authSession,
-    accessSubjectId: context.accessContext.subjectId,
-    accessContext: context.accessContext,
-    managedSelfContext: context.managedSelfContext,
-    workspace,
-    session: props.session,
-    enabled: props.session.sandboxBackend !== "selfhosted",
-    fixed: {
-      rigId: props.session.rigId,
-      rigScope: fixedRigScope,
-      connectedMachine: null
-    },
-    personalWorkspaceTarget: isPersonalWorkspace(workspace, context.managedSelfContext),
-    onReloadSession: props.onReloadSession
-  });
-  const sendState = {
-    uploadPending: attachments.hasUnresolved,
-    repositoryError: repositories.error,
-    personalDecision: personalAttachment.requiresDecision || connectionAccounts.requiresAccountChoice,
-    machineAccessDenied: machineAccess !== null && !machineAccess.isOwner,
-    loading: durableToolsSaving || durableToolsSaveInFlight.current || !durableToolsHydrated || personalAttachment.loading || personalAttachment.refreshing || connectionAccounts.loading,
-    loadFailed: connectionAccounts.error !== null
-  };
-  const composerSendBlocker = () => sendGate.blocker(sendState);
-  const workspaceAccountId = context.workspaces.find(
-    (candidate) => candidate.id === props.session.workspaceId
-  )?.accountId;
-  const canBuyCredits = context.clientConfig.billingMode === "stripe" && Boolean(workspaceAccountId) && hasAccountPermission(context.accessContext, workspaceAccountId ?? "", "billing:manage");
-  const composer = useComposer(props.session.id, {
-    canBuyCredits,
-    events: props.events,
-    sendExtras: () => ({
-      ...withHostMessageContext(hostMessageContext, props.messageContext),
-      resources: [...attachments.readyResources, ...repositories.pendingResources],
-      connectionAccounts: [
-        ...connectionAccounts.selections,
-        ...repositories.pendingResources.some(
-          (resource) => resource.kind === "repository" && resource.connectionType === "github_personal"
-        ) && context.personalGitHubAuthority ? [context.personalGitHubAuthority] : []
-      ],
-      ...personalAttachment.intent ? { personalResourceAttachment: personalAttachment.intent } : runsOnActiveMachineConsent ? { personalResourceAttachment: runsOnActiveMachineConsent } : {}
-    }),
-    sendBlocked: () => composerSendBlocker() !== null,
-    effectiveControl: props.queue.effectiveControl ?? props.session.effectiveControl,
-    sendDestination: () => promptSendDestination({
-      status: props.session.status,
-      activeTurnId: props.session.activeTurnId,
-      queuedPrompts: props.queue.queue.length,
-      admissionBlock: props.session.admissionBlock
-    }),
-    busySend: resolveWorkspaceBusySend(workspace?.settings),
-    ...props.initialDraft ? { initialDraft: props.initialDraft } : {},
-    // The console always offers the other choice beside Send.
-    offerQueue: true,
-    // Ordinary Send is acknowledged locally. Clear only resources captured in
-    // that immutable optimistic operation; later additions belong to the next
-    // draft, while retry keeps the original resource refs in the failed bubble.
-    onSubmitted: (_text, input) => {
-      noteTurnFailureAction("send_message");
-      attachments.removeReadyFiles(
-        (input.resources ?? []).flatMap(
-          (resource) => resource.kind === "file" ? [resource.fileId] : []
-        )
-      );
-      repositories.commitSent(input.resources ?? []);
-    },
-    // Steer and recovered sends do not pass through onSubmitted. Keep the
-    // host-owned upload/repository queue in sync once those inputs are
-    // accepted too; the immutable input snapshot preserves later additions.
-    onSent: (_text, input) => {
-      setCreditRefusal(null);
-      attachments.removeReadyFiles(
-        (input.resources ?? []).flatMap(
-          (resource) => resource.kind === "file" ? [resource.fileId] : []
-        )
-      );
-      repositories.commitSent(input.resources ?? []);
-      personalAttachment.onAccepted(input);
-    },
-    onDeliveryError: (error, input, delivery) => {
-      personalAttachment.onDeliveryError(error, input, delivery);
-      connectionAccounts.onSelectionError(error);
-      if (isModelUnavailableSubmissionError(error)) {
-        const refused = refusedModelId(error, input);
-        if (refused) setRefusedModel({ sessionId: props.session.id, model: refused });
-        void modelCatalog.refresh();
-        setModelPickerSession(props.session.id);
-      }
-      const refusal = creditRefusalRecord(
-        error,
-        { sessionId: props.session.id },
-        refusedModelId(error, input) ?? props.session.model
-      );
-      if (refusal) {
-        setCreditRefusal(refusal);
-        void modelCatalog.refresh();
-      }
-    }
-  });
-  const composerView = useComposerWithStreamState(
-    composer,
-    props.connectionState,
-    props.initialLoading
-  );
-  const queuedRecall = useQueuedPromptRecall({
-    queue: props.queue,
-    composer,
-    subjectId: context.accessContext.subjectId,
-    enabled: !terminal
-  });
-  useBrowserAccountBridgeBlocker(`session-composer:${props.session.id}`, () => {
-    if (attachments.hasUnresolved) {
-      return {
-        id: "ignored",
-        label: "A file upload is not settled",
-        detail: "Wait for the upload or remove it before changing accounts."
-      };
-    }
-    if (composer.sending || composer.draftSaving || durableToolsSaving) {
-      return {
-        id: "ignored",
-        label: "A session mutation is still running",
-        detail: "Wait for the current save or send to finish."
-      };
-    }
-    return composer.hasDraftContent() ? {
-      id: "ignored",
-      label: "This session has an unsent draft",
-      detail: "Continuing clears the account-bound composer state."
-    } : null;
-  });
-  chatSendContext.current = {
-    blocked: isTerminalSessionStatus(props.session.status) ? "This chat has ended. Start a new chat to use a repository." : sessionReadOnlyArchive(props.session) ? "This chat is archived. Continue in a new chat to use a repository." : connectionAccounts.requiresAccountChoice ? "Choose an account for this chat's connected tools in the composer first." : personalAttachment.requiresDecision ? "Finish the personal access choice in the composer first." : null,
-    awaitingHuman: props.session.status === "requires_action" && !sessionAdmissionBlocked(props.session),
-    // Moving the chat onto the person's own machine turns it on in this workspace.
-    personalMachineIntent: personalMachineUseIntent(props.session.tenancy, "always"),
-    extras: {
-      ...composer.sendPolicy ?? {},
-      ...(props.queue.effectiveControl ?? props.session.effectiveControl)?.controlEtag ? {
-        controlEtag: (props.queue.effectiveControl ?? props.session.effectiveControl).controlEtag
-      } : {},
-      ...connectionAccounts.selections.length > 0 ? { connectionAccounts: connectionAccounts.selections } : {}
-    }
-  };
-  const composerPolicy = composer.policy;
-  const [retryOperation, setRetryOperation] = useState3(null);
-  const pendingRetryInput = retryOperation?.failureEventId === props.failure?.failureEventId ? retryOperation : null;
-  const failureTurnId = props.session.failureDiagnostics?.eventId === props.failure?.failureEventId ? props.session.failureDiagnostics?.turnId : props.events.find((event) => event.id === props.failure?.failureEventId)?.turnId;
-  const retryHasRetainedTurn = Boolean(failureTurnId);
-  const retryFailedSession = useMemo3(
-    () => createFailedSessionRetry(
-      (input) => context.client.retrySession(props.session.workspaceId, props.session.id, input),
-      setRetryOperation
-    ),
-    [context.client, props.session.workspaceId, props.session.id]
-  );
-  const composerDraftLoading = composer.draftLoading;
-  const setComposerModel = composer.setModel;
-  const setComposerReasoningEffort = composer.setReasoningEffort;
-  const setComposerLatencyMode = composer.setLatencyMode;
-  const hasComposerPolicy = composerPolicy !== null;
-  const modelPickerDisabled = composer.sending || composer.draftLoading || !hasComposerPolicy || Boolean(pendingRetryInput);
-  const canChooseRecoveryModel = !modelPickerDisabled;
-  const stopRefusal = props.creditExhausted ? props.creditRefusal : null;
-  const creditGap = props.creditExhausted && !stopRefusal ? freeCreditGap(modelCatalog.rows, props.session.model, {
-    selectedModel: composerPolicy?.model,
-    preferredModel: modelCatalog.defaultSelection?.model
-  }) : null;
-  const failureFallback = props.failure ? /* @__PURE__ */ jsx("div", { role: "alert", className: cn("mx-auto my-2 w-full max-w-3xl text-sm text-fg-muted", gutter), children: failureFallbackReason(
-    failedSessionCopy(
-      props.failure,
-      props.creditExhausted && !props.failure.structuralSandboxFailure,
-      Boolean(composerPolicy && composerPolicy.model !== props.session.model),
-      canChooseRecoveryModel && !props.failure.structuralSandboxFailure,
-      creditGap,
-      stopRefusal
-    ),
-    canBuyCredits
-  ) }) : null;
-  const model = composerPolicy?.model ?? props.session.model;
-  const reasoningEffort = composerPolicy?.reasoningEffort ?? props.session.reasoningEffort;
-  const latencyMode = composerPolicy?.latencyMode ?? props.session.latencyMode;
-  const selectedPolicyRow = findPickerRow(modelCatalog.rows, model);
-  const chooseCoveredModel = (id) => {
-    const row = findPickerRow(modelCatalog.rows, id);
-    const choice = row && !modelPickerDisabled ? coveredModelChoice(row, reasoningEffort, latencyMode) : null;
-    if (!choice) return;
-    setComposerModel(choice.model);
-    setComposerReasoningEffort(choice.effort);
-    if (choice.latencyMode !== null) setComposerLatencyMode(choice.latencyMode);
-  };
-  const matchesFrozenSessionPolicy = Boolean(
-    composerPolicy && composerPolicy.model === props.session.model && composerPolicy.reasoningEffort === props.session.reasoningEffort && composerPolicy.latencyMode === props.session.latencyMode
-  );
-  const catalogComboValid = Boolean(
-    selectedPolicyRow?.selectable && effortOptionsForModel(selectedPolicyRow.catalog).includes(reasoningEffort) && (latencyMode === "standard" || runnableLatencyModesForModel(selectedPolicyRow.catalog).includes(latencyMode))
-  );
-  const refusedSessionModel = refusedModel?.sessionId === props.session.id ? refusedModel.model : null;
-  const composerModelUnavailable = model === refusedSessionModel || sessionModelMissingFromCatalog({
-    model,
-    models: modelCatalog.models,
-    error: modelCatalog.error
-  });
-  const sessionModelUnavailable = props.session.model === refusedSessionModel || sessionModelMissingFromCatalog({
-    model: props.session.model,
-    models: modelCatalog.models,
-    error: modelCatalog.error
-  });
-  const canControlSession = Boolean(
-    context.accessContext.workspaceGrants.find((grant) => grant.workspaceId === props.session.workspaceId)?.permissions.includes("sessions:control")
-  );
-  const composerPolicyValid = Boolean(
-    composerPolicy && (catalogComboValid || matchesFrozenSessionPolicy && !composerModelUnavailable)
-  );
-  const noRunnableModel = !modelCatalog.loading && modelCatalog.rows.length > 0 && !modelCatalog.rows.some((row) => row.selectable);
-  const composerPolicyError = composerPolicy && !modelCatalog.loading && !composerPolicyValid && !noRunnableModel ? composerModelUnavailable ? "This model is no longer available. Select a different model to continue." : "Choose a model, reasoning level, and speed supported by this session." : null;
-  const unavailableReplacement = useMemo3(
-    () => composerModelUnavailable || sessionModelUnavailable ? unavailableModelReplacement({
-      rows: modelCatalog.rows,
-      defaultSelection: modelCatalog.defaultSelection,
-      latencyMode
-    }) : null,
-    [
-      composerModelUnavailable,
-      sessionModelUnavailable,
-      modelCatalog.rows,
-      modelCatalog.defaultSelection,
-      latencyMode
-    ]
-  );
-  const replacesUnavailableModel = Boolean(
-    composerModelUnavailable && unavailableReplacement && !composerDraftLoading && hasComposerPolicy && !modelPickerDisabled && !terminal && // A failed session keeps its model until the person chooses: the
-    // failure banner's Retry re-runs that turn with the composer's model.
-    canControlSession && !props.failure
-  );
-  useEffect4(() => {
-    if (!replacesUnavailableModel || !unavailableReplacement) return;
-    setComposerModel(unavailableReplacement.model);
-    setComposerReasoningEffort(unavailableReplacement.reasoningEffort);
-    if (unavailableReplacement.latencyMode) {
-      setComposerLatencyMode(unavailableReplacement.latencyMode);
-    }
-  }, [
-    replacesUnavailableModel,
-    setComposerLatencyMode,
-    setComposerModel,
-    setComposerReasoningEffort,
-    unavailableReplacement
-  ]);
-  const composerDelivery = useSessionComposerDelivery(composerView, sendGate, {
-    policyValid: composerPolicyValid,
-    catalogLoading: modelCatalog.loading,
-    replacingModel: replacesUnavailableModel,
-    send: sendState
-  });
-  const unavailableModelNotice = (sessionModelUnavailable || composerModelUnavailable) && !terminal ? /* @__PURE__ */ jsx(
-    UnavailableModelNotice,
-    {
-      modelName: unavailableModelName(sessionModelUnavailable ? props.session.model : model),
-      replacementLabel: composerModelUnavailable ? null : selectedPolicyRow?.label ?? null
-    }
-  ) : null;
-  useEffect4(() => {
-    if (!launchKey || appliedLaunchKeyRef.current === launchKey || composerDraftLoading || !hasComposerPolicy) {
-      return;
-    }
-    const hasPolicy = Boolean(launchModel || launchEffort || launchLatency);
-    appliedLaunchKeyRef.current = launchKey;
-    if (!hasPolicy) return;
-    if (launchModel) setComposerModel(launchModel);
-    if (launchEffort) setComposerReasoningEffort(launchEffort);
-    if (launchLatency) setComposerLatencyMode(launchLatency);
-    void navigate({
-      to: "/workspaces/$workspaceId/sessions/$sessionId",
-      params: {
-        workspaceId: props.session.workspaceId,
-        sessionId: props.session.id
-      },
-      search: composerLaunchSearchAfterPolicyApply({
-        model: launchModel,
-        effort: launchEffort,
-        latency: launchLatency,
-        realtime: launchRealtime
-      }),
-      replace: true
-    });
-  }, [
-    composerDraftLoading,
-    hasComposerPolicy,
-    launchEffort,
-    launchKey,
-    launchLatency,
-    launchModel,
-    launchRealtime,
-    navigate,
-    props.session.id,
-    props.session.workspaceId,
-    setComposerLatencyMode,
-    setComposerModel,
-    setComposerReasoningEffort
-  ]);
-  const acceptedClientEventIds = useMemo3(
-    () => new Set(
-      props.events.filter((event) => event.type === "user.message" && event.clientEventId).map((event) => event.clientEventId)
-    ),
-    [props.events]
-  );
-  const {
-    optimisticMessages,
-    retryOptimisticMessage,
-    restoreOptimisticMessage,
-    removeOptimisticMessage
-  } = composer;
-  const failedOptimisticMessageCount = (optimisticMessages ?? []).filter(
-    (message) => message.state === "failed" && !acceptedClientEventIds.has(message.clientEventId)
-  ).length;
-  useEffect4(() => {
-    updateLocalSessionDeliveryAttention({
-      workspaceId: props.session.workspaceId,
-      sessionId: props.session.id,
-      failedMessageCount: failedOptimisticMessageCount
-    });
-  }, [failedOptimisticMessageCount, props.session.id, props.session.workspaceId]);
-  const usageLimitCapability = sessionUsageLimitCapability(context.clientConfig);
-  const usageLimitTreeActive = props.session.status === "running" || lineageHasRunningSession(props.agentNodes);
-  const usageLimit = useSessionUsageLimit({
-    client: context.client,
-    workspaceId: props.session.workspaceId,
-    sessionId: props.session.id,
-    initial: props.session.usageLimit,
-    enabled: usageLimitCapability !== "absent",
-    live: {
-      events: props.events,
-      active: usageLimitTreeActive,
-      watch: props.agentNodes.length > 0,
-      connectionState: props.connectionState
-    }
-  });
-  const refusedUsageLimitSendIds = (optimisticMessages ?? []).filter(
-    (message) => message.state === "failed" && message.error !== void 0 && !acceptedClientEventIds.has(message.clientEventId) && isSessionUsageLimitSubmissionError(new Error(message.error))
-  ).map((message) => message.clientEventId).join(",");
-  const composerUsageLimitError = composer.error instanceof OpenGeniSessionUsageLimitReachedError ? composer.error : null;
-  const [usageLimitRefusalPending, setUsageLimitRefusalPending] = useState3(false);
-  const refreshUsageLimit = usageLimit.refresh;
-  useEffect4(() => {
-    if (!refusedUsageLimitSendIds && !composerUsageLimitError) return;
-    setUsageLimitRefusalPending(true);
-    void refreshUsageLimit().finally(() => setUsageLimitRefusalPending(false));
-  }, [composerUsageLimitError, refreshUsageLimit, refusedUsageLimitSendIds]);
-  const usageLimitRefusal = usageLimitRefusalFromState({
-    pending: usageLimitRefusalPending,
-    error: composerUsageLimitError,
-    usage: usageLimit.usage
-  });
-  const usageLimitChild = Boolean(props.session.parentSessionId) || usageLimit.usage?.inherited === true;
-  const usageLimitRootId = usageLimit.usage?.rootSessionId ?? null;
-  const usageLimitNotice = usageLimitCapability !== "absent" && !terminal ? /* @__PURE__ */ jsx(
-    SessionUsageLimitNotice,
-    {
-      usage: usageLimit.usage,
-      stale: usageLimit.error !== null && usageLimit.usage !== null,
-      refusal: usageLimitRefusal,
-      onChangeLimit: !usageLimitChild && canControlSession ? props.onOpenUsageLimit : void 0,
-      mainTaskHref: usageLimitChild && usageLimitRootId ? `/workspaces/${props.session.workspaceId}/sessions/${usageLimitRootId}` : void 0,
-      goalPaused: props.goal.goal?.pausedReason === SESSION_USAGE_LIMIT_GOAL_PAUSED_REASON,
-      dismissStorageKey: `opengeni:${props.session.workspaceId}`
-    }
-  ) : null;
-  const timelineWithOptimisticSends = useMemo3(() => {
-    return conversationTimeline(
-      props.timeline,
-      {
-        queue: props.queue.queue,
-        snapshot: props.queue.snapshot,
-        acceptedSteers: props.queue.acceptedSteers
-      },
-      {
-        optimisticMessages,
-        retryOptimisticMessage,
-        restoreOptimisticMessage,
-        removeOptimisticMessage
-      }
-    );
-  }, [
-    optimisticMessages,
-    removeOptimisticMessage,
-    props.queue.acceptedSteers,
-    props.queue.queue,
-    props.queue.snapshot,
-    props.timeline,
-    retryOptimisticMessage,
-    restoreOptimisticMessage
-  ]);
-  const repositoryPickerProps = repositories.pickerProps(terminal || composer.sending);
-  const admissionControl = admissionRecheckControl(
-    props.admissionSessionControl,
-    props.queue.effectiveControl,
-    composer.effectiveControl
-  );
-  const admissionRefreshRequired = admissionControlNeedsRefresh(
-    admissionControl,
-    props.admissionSessionControl,
-    props.queue.effectiveControl,
-    composer.effectiveControl
-  );
-  const timelineWithStartup = useSessionStartupTimeline(timelineWithOptimisticSends, {
-    session: { ...props.session, effectiveControl: admissionControl },
-    events: props.events,
-    optimisticMessages,
-    hasNewer: props.hasNewer,
-    queue: props.queue.snapshot
-  });
-  const timelineEmptyStateCopy = sessionTimelineEmptyStateCopy(
-    sessionDisplayStatus(props.session),
-    (props.queue.effectiveControl ?? props.session.effectiveControl).state === "paused"
-  );
-  const workspacePermissions = useMemo3(
-    () => context.accessContext.workspaceGrants.find(
-      (grant) => grant.workspaceId === props.session.workspaceId
-    )?.permissions ?? [],
-    [context.accessContext.workspaceGrants, props.session.workspaceId]
-  );
-  const codexUsageBlocked = isCodexProductModel(props.session.model) && (props.session.status === "waiting_capacity" || (props.session.status === "failed" ? isCodexUsageLimitFailure(props.failure?.failureCode) : props.session.status === "idle" && latestTurnFailedOnUsageLimit(props.events)));
-  const codexUsageChoices = codexUsageBlocked && workspacePermissions.includes("sessions:control");
-  const codexUsageResetsAtValue = useMemo3(
-    () => codexUsageChoices ? codexUsageResetsAt(props.events) : null,
-    [codexUsageChoices, props.events]
-  );
-  const [usageContinuationState, setUsageContinuation] = useState3(null);
-  const usageContinuationInFlight = useRef2(false);
-  const usageContinuation = usageContinuationState?.sessionId === props.session.id ? usageContinuationState : null;
-  const remoteV2Chat = props.session.codexCompactionMode === "remote_v2";
-  const loadedCheckpointIsCompaction = useMemo3(
-    () => remoteV2Chat ? latestCheckpointIsCompaction(props.events) : null,
-    [remoteV2Chat, props.events]
-  );
-  const [fetchedCodexCompaction, setFetchedCodexCompaction] = useState3(null);
-  useEffect4(() => {
-    if (!remoteV2Chat || loadedCheckpointIsCompaction !== null) return;
-    let stale = false;
-    const sessionId = props.session.id;
-    context.client.listEvents(props.session.workspaceId, sessionId, {
-      includeTypes: CONTEXT_CHECKPOINT_EVENT_TYPES,
-      // Newest first: only the latest checkpoint matters.
-      direction: "before",
-      limit: 20,
-      payloadMode: "none"
-    }).then((events) => {
-      if (!stale)
-        setFetchedCodexCompaction({
-          sessionId,
-          compacted: latestCheckpointIsCompaction(events) === true
-        });
-    }).catch(() => void 0);
-    return () => {
-      stale = true;
-    };
-  }, [
-    context.client,
-    loadedCheckpointIsCompaction,
-    props.session.id,
-    props.session.workspaceId,
-    remoteV2Chat
-  ]);
-  const codexCompacted = loadedCheckpointIsCompaction ?? (fetchedCodexCompaction?.sessionId === props.session.id && fetchedCodexCompaction.compacted);
-  const switchHeadsUp = (target, label) => needsModelSwitchHeadsUp({
-    codexCompactionMode: props.session.codexCompactionMode,
-    codexCompacted,
-    model: target
-  }) ? modelSwitchHeadsUpText(label) : null;
-  const continueAfterUsageLimit = async (policy, options = {}) => {
-    if (usageContinuationInFlight.current) return;
-    usageContinuationInFlight.current = true;
-    const sessionId = props.session.id;
-    setUsageContinuation({ sessionId, pending: true, error: null });
-    let error = null;
-    try {
-      if (options.resumeFirst)
-        await context.client.resumeSession(props.session.workspaceId, sessionId, {
-          clientEventId: crypto.randomUUID(),
-          // Never undo a pause made after this page last read the control.
-          expectedControlEtag: admissionControl.controlEtag
-        });
-      if (props.session.status === "failed" && props.failure?.failureEventId && retryHasRetainedTurn) {
-        await retryFailedSession(props.failure.failureEventId, policy);
-      } else {
-        const chat = readChatSendContext();
-        if (chat.blocked) error = chat.blocked;
-        else {
-          const message = {
-            text: "Continue",
-            ...chat.extras,
-            ...policy,
-            clientEventId: crypto.randomUUID()
-          };
-          if (props.session.status === "waiting_capacity")
-            await context.client.steerMessage(props.session.workspaceId, sessionId, message);
-          else await context.client.sendMessage(props.session.workspaceId, sessionId, message);
-        }
-      }
-    } catch (failure) {
-      error = userErrorText(failure, "Try again.");
-    } finally {
-      usageContinuationInFlight.current = false;
-      setUsageContinuation({ sessionId, pending: false, error });
-      await Promise.allSettled([props.onReloadSession(), props.queue.refresh()]);
-    }
-  };
-  const usagePaused = admissionControl.state === "paused";
-  const continueAtReset = codexUsageContinuesAtReset({
-    status: props.session.status,
-    paused: usagePaused
-  });
-  const setContinueAtReset = (next) => {
-    const action = codexUsageContinueAtResetAction({
-      status: props.session.status,
-      paused: usagePaused,
-      next
-    });
-    if (action === "pause") void composer.pause();
-    else if (action === "resume") void composer.resume();
-    else if (action === "run_on_codex" || action === "resume_and_run_on_codex")
-      void continueAfterUsageLimit(
-        {
-          model: props.session.model,
-          reasoningEffort: props.session.reasoningEffort,
-          latencyMode: props.session.latencyMode
-        },
-        { resumeFirst: action === "resume_and_run_on_codex" }
-      );
-  };
-  const usageModelSwitch = useCodexUsageModelSwitch({
-    sessionId: props.session.id,
-    sessionModel: props.session.model,
-    composerModel: model,
-    enabled: codexUsageChoices,
-    closePicker: () => setModelPickerSession(null),
-    onContinue: (picked) => void continueAfterUsageLimit(
-      { model: picked, reasoningEffort, latencyMode },
-      // A Steer resumes a paused waiting chat itself; resuming first would
-      // wake its Codex wait for nothing.
-      { resumeFirst: usagePaused && props.session.status !== "waiting_capacity" }
-    )
-  });
-  const codexUsageChoice = codexUsageChoices && codexUsageNoticeApplies({
-    status: props.session.status,
-    resetsAt: codexUsageResetsAtValue,
-    usageWait: codexWaitIsUsageLimit(props.events)
-  }) ? {
-    resetText: codexUsageResetText(codexUsageResetsAtValue),
-    continueAtReset,
-    pending: usageContinuation?.pending || composer.pausing || composer.resuming,
-    error: usageContinuation?.error,
-    onContinueAtResetChange: setContinueAtReset
-  } : void 0;
-  const codexUsageNotice = codexUsageChoice && props.session.status !== "failed" && !terminal ? /* @__PURE__ */ jsx(CodexUsageNotice, { choice: codexUsageChoice }) : null;
-  const chosenModelHeadsUp = !terminal ? switchHeadsUp(model, selectedPolicyRow?.label ?? unavailableModelName(model)) : null;
-  const modelSwitchHeadsUp = chosenModelHeadsUp ? /* @__PURE__ */ jsx(ModelSwitchHeadsUp, { text: chosenModelHeadsUp, className: "px-3.5 pt-2.5 md:px-4" }) : null;
-  const ownLoginsApply = !terminal && props.session.tenancy?.visibility === "workspace" && !isPersonalWorkspace(workspace, context.managedSelfContext);
-  const ownLoginsHeadsUp = ownLoginsApply ? /* @__PURE__ */ jsx(
-    OwnLoginsSharedHeadsUp,
-    {
-      logins: connectionAccounts.loading || connectionAccounts.error ? null : ownLoginsInUse(
-        // Only the connectors this chat uses.
-        connectionAccounts.accountGroups,
-        connectionAccounts.accountChoices,
-        context.accessContext.subjectId
-      ),
-      className: "px-3.5 pt-2.5 md:px-4",
-      logoFor: (login) => props.resolveProviderLogo(login.accounts[0].providerDomain),
-      onChange: async (login, on) => {
-        try {
-          if (on)
-            await turnOnOwnLoginsHere(context.client, props.session.workspaceId, login.accounts);
-          else await stopOwnLoginsHere(context.client, props.session.workspaceId, login.accounts);
-        } finally {
-          await connectionAccounts.refresh();
-        }
-      }
-    },
-    props.session.id
-  ) : null;
-  const sessionSecrets = useSessionSecrets(props.session.id, {
-    enabled: workspacePermissions.includes("secrets:list")
-  });
-  const secretsView = sessionSecrets.secrets;
-  const renderMessageSender = useMessageSenderRenderer(
-    context.client,
-    props.session.workspaceId,
-    context.accessContext.subjectId
-  );
-  const commandContext = useMemo3(
-    () => ({
-      client: context.client,
-      workspaceId: props.session.workspaceId,
-      sessionId: props.session.id,
-      status: props.session.status,
-      permissions: workspacePermissions
-    }),
-    [
-      context.client,
-      props.session.workspaceId,
-      props.session.id,
-      props.session.status,
-      workspacePermissions
-    ]
-  );
-  const [forkEventId, setForkEventId] = useState3(null);
-  const [turnRatings, setTurnRatings] = useState3({});
-  const mayRate = hasWorkspacePermission(
-    context.accessContext,
-    props.session.workspaceId,
-    "sessions:create"
-  );
-  useEffect4(() => {
-    setTurnRatings({});
-    setForkEventId(null);
-    if (!mayRate) return;
-    return loadSessionFeedback(
-      context.client,
-      props.session.workspaceId,
-      props.session.id,
-      ({ feedback }) => {
-        const ratings = turnRatingsFromFeedback(feedback);
-        setTurnRatings((saved) => ({ ...ratings, ...saved }));
-      }
-    );
-  }, [
-    context.client,
-    props.session.workspaceId,
-    props.session.id,
-    mayRate,
-    context.accessContext.subjectId
-  ]);
-  const mayForkMessage = context.clientConfig.auth.mode === "managedSession" && context.authSession !== null && Boolean(props.session.tenancy) && mayRate;
-  const forkRequests = useUiEventTarget("document");
-  const eventsRef = useRef2(props.events);
-  eventsRef.current = props.events;
-  useEffect4(() => {
-    if (!mayForkMessage) return;
-    const fork = () => {
-      const events = eventsRef.current;
-      for (let index = events.length - 1; index >= 0; index -= 1) {
-        const event = events[index];
-        if (event.type === "agent.message.completed" || event.type === "user.message") {
-          setForkEventId(event.id);
-          return;
-        }
-      }
-    };
-    forkRequests.addEventListener(FORK_CURRENT_CHAT_EVENT, fork);
-    return () => forkRequests.removeEventListener(FORK_CURRENT_CHAT_EVENT, fork);
-  }, [forkRequests, mayForkMessage]);
-  const onMessageRated = useCallback3((turnId, sentiment) => {
-    setTurnRatings((saved) => ({ ...saved, [turnId]: sentiment }));
-  }, []);
-  const renderMessageActions = useCallback3(
-    (item) => /* @__PURE__ */ jsx(Suspense, { fallback: null, children: /* @__PURE__ */ jsx(
-      MessageActions,
-      {
-        item,
-        client: context.client,
-        workspaceId: props.session.workspaceId,
-        sessionId: props.session.id,
-        mayRate,
-        mayFork: mayForkMessage,
-        savedSentiment: item.kind === "agent-message" && item.turnId ? turnRatings[item.turnId] ?? null : null,
-        onRated: onMessageRated,
-        onFork: setForkEventId
-      }
-    ) }),
-    [
-      context.client,
-      props.session.workspaceId,
-      props.session.id,
-      mayRate,
-      mayForkMessage,
-      turnRatings,
-      onMessageRated
-    ]
-  );
-  const renderImage = useCallback3(
-    (image) => {
-      const artifactId = retainedImageId(image.src);
-      return artifactId ? /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx("span", { role: "status", children: "Loading image\u2026" }), children: /* @__PURE__ */ jsx(
-        InlineChatArtifact,
-        {
-          workspaceId: props.session.workspaceId,
-          artifactId,
-          alt: image.alt
-        },
-        props.session.workspaceId + ":" + artifactId
-      ) }) : null;
-    },
-    [props.session.workspaceId]
-  );
-  const renderInteractiveBlock = useCallback3(
-    (block) => /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx("span", { role: "status", children: "Loading preview\u2026" }), children: /* @__PURE__ */ jsx(ChatInteractiveBlock, { workspaceId: props.session.workspaceId, ...block }) }),
-    [props.session.workspaceId]
-  );
-  const renderMessageText = useCallback3(
-    (text, item, renderContext) => {
-      if (item.kind === "user-message") {
-        if (item.humanInputDelegation) {
-          return /* @__PURE__ */ jsx(
-            HumanInputDelegationRecord,
-            {
-              client: context.client,
-              workspaceId: props.session.workspaceId,
-              item: { ...item, humanInputDelegation: item.humanInputDelegation },
-              viewerSubjectId: context.accessContext.subjectId
-            }
-          );
-        }
-        return /* @__PURE__ */ jsx(
-          UserMessageBody,
-          {
-            sessionId: props.session.id,
-            workspaceId: props.session.workspaceId,
-            item,
-            searchTarget: renderContext.searchTarget
-          }
-        );
-      }
-      return /* @__PURE__ */ jsx("div", { "data-testid": "assistant-markdown", children: /* @__PURE__ */ jsx(
-        MarkdownText,
-        {
-          artifactHref: (id) => `/workspaces/${props.session.workspaceId}/artifacts/files/${id}`,
-          text,
-          searchTarget: renderContext.searchTarget,
-          softLineBreaks: true,
-          streaming: item.kind === "agent-message" && item.streaming,
-          onSandboxFile: props.onOpenSandboxFile,
-          renderInteractiveBlock,
-          renderImage
-        }
-      ) });
-    },
-    [
-      context.accessContext.subjectId,
-      context.client,
-      props.onOpenSandboxFile,
-      props.session.id,
-      props.session.workspaceId,
-      renderInteractiveBlock,
-      renderImage
-    ]
-  );
-  const [creditTopupOpen, setCreditTopupOpen] = useState3(false);
-  const openCreditTopup = canBuyCredits ? () => setCreditTopupOpen(true) : void 0;
-  const topupRefusal = ((creditRefusal?.sessionId === props.session.id ? creditRefusal.code : null) ?? stopRefusal) === "byok_paid_credit_required" ? "byok_paid_credit_required" : null;
-  const creditTopupPrompt = canBuyCredits && workspaceAccountId ? /* @__PURE__ */ jsx(Suspense, { fallback: null, children: creditTopupOpen ? /* @__PURE__ */ jsx(
-    LazyCreditTopupPrompt,
-    {
-      purpose: "topup",
-      refusalCode: topupRefusal,
-      open: true,
-      workspaceId: props.session.workspaceId,
-      accountId: workspaceAccountId,
-      canBuyCredits: true,
-      onOpenChange: setCreditTopupOpen,
-      beforeLeave: composer.flushDraft
-    }
-  ) : null }) : null;
-  const canConnectModel = hasWorkspacePermission(
-    context.accessContext,
-    props.session.workspaceId,
-    "connections:write"
-  );
-  const failureRecovery = !props.hasNewer && !readOnlyArchive && props.failure && (props.session.status === "failed" || props.creditExhausted && props.session.status === "idle") ? /* @__PURE__ */ jsx(FailureRecoveryBoundary, { fallback: failureFallback, children: /* @__PURE__ */ jsx(Suspense, { fallback: failureFallback, children: /* @__PURE__ */ jsx(
-    LazyFailedSessionBanner,
-    {
-      failure: props.failure,
-      shownInTimeline: timelineShowsFailure(timelineWithStartup, {
-        failureEventId: props.failure.failureEventId,
-        turnId: failureTurnId
-      }),
-      analyticsKey: props.failure.failureEventId ?? `${props.session.id}:${props.failure.failedAt ?? "unknown"}`,
-      canChooseModel: canChooseRecoveryModel,
-      codexUsage: codexUsageChoice,
-      hasModelPicker: hasComposerPolicy,
-      freeModel: isDeploymentFreeModel(modelCatalog.rows, props.session.model),
-      subscriptions: connectableSubscriptions(context.clientConfig.models),
-      modelChanged: Boolean(composerPolicy && composerPolicy.model !== props.session.model),
-      creditExhausted: props.creditExhausted,
-      creditRefusal: stopRefusal,
-      freeCreditGap: creditGap,
-      onChooseModel: chooseCoveredModel,
-      workspaceId: props.session.workspaceId,
-      canBuyCredits,
-      onAddCredits: openCreditTopup,
-      canConnectModel,
-      sandboxRecovery: needsSandboxRecoveryCheck(props.session, props.failure.structuralSandboxFailure) ? {
-        client: context.client,
-        workspaceId: props.session.workspaceId,
-        sessionId: props.session.id,
-        canControl: workspacePermissions.includes("sessions:control")
-      } : void 0,
-      actions: {
-        failureId: props.failure.failureEventId,
-        retryInput: pendingRetryInput,
-        composerBlocker: composerSendBlocker(),
-        onRetry: async () => {
-          if (composer.hasDraftContent() || composerSendBlocker() || !props.failure?.failureEventId || !retryHasRetainedTurn || !composerPolicy || !workspacePermissions.includes("sessions:control") || admissionControl.state === "paused")
-            return false;
-          try {
-            return await retryFailedSession(props.failure.failureEventId, composerPolicy);
-          } finally {
-            await Promise.allSettled([props.onReloadSession(), props.queue.refresh()]);
-          }
-        },
-        retryBlocker: !workspacePermissions.includes("sessions:control") ? "permission" : admissionControl.state === "paused" ? "paused" : composer.hasDraftContent() ? "draft" : failedOptimisticMessageCount > 0 ? "unsent" : (optimisticMessages ?? []).some(
-          (message) => !acceptedClientEventIds.has(message.clientEventId)
-        ) ? "delivery" : props.session.activeTurnId !== null || props.queue.queue.length > 0 ? "queued" : composer.sending || composer.draftLoading || !hasComposerPolicy || !retryHasRetainedTurn || !props.failure.failureEventId ? "loading" : null
-      }
-    },
-    props.session.id
-  ) }) }, props.session.id) : null;
-  const sessionCreditRefusal = creditRefusal?.sessionId === props.session.id && !terminal && !(failureRecovery && props.creditExhausted) ? creditRefusal : null;
-  const creditRefusalFallback = sessionCreditRefusal ? /* @__PURE__ */ jsx("p", { role: "alert", className: "px-1.5 text-sm text-fg-muted", children: apiErrorFacts(sessionCreditRefusal.message).serverMessage ?? sessionCreditRefusal.message }) : null;
-  const creditRefusalNotice = sessionCreditRefusal ? /* @__PURE__ */ jsx(FailureRecoveryBoundary, { fallback: creditRefusalFallback, children: /* @__PURE__ */ jsx(Suspense, { fallback: creditRefusalFallback, children: /* @__PURE__ */ jsx(
-    LazyCreditRefusalNotice,
-    {
-      gap: creditRefusalGap(modelCatalog.rows, sessionCreditRefusal.model, {
-        selectedModel: composerPolicy?.model,
-        preferredModel: modelCatalog.defaultSelection?.model
-      }),
-      message: sessionCreditRefusal.message,
-      refusalCode: sessionCreditRefusal.code,
-      workspaceId: props.session.workspaceId,
-      accountId: workspaceAccountId,
-      canReadBilling: Boolean(workspaceAccountId) && hasAccountPermission(context.accessContext, workspaceAccountId ?? "", "billing:read"),
-      canBuyCredits,
-      canConnectModel,
-      continuing: true,
-      onChooseModel: modelPickerDisabled ? void 0 : chooseCoveredModel,
-      onAddCredits: openCreditTopup,
-      onDismiss: () => setCreditRefusal(null)
-    }
-  ) }) }, props.session.id) : null;
-  const modelRecovery = props.hasNewer ? null : currentModelRecovery({ ...props.session, effectiveControl: admissionControl }, props.events);
-  const reviewDetailPane = reviewDetails ? /* @__PURE__ */ jsx("div", { className: "min-h-0 flex-1 overflow-y-auto", "data-workspace-scroll-owner": "self-managed", children: /* @__PURE__ */ jsx(
-    ToolActionReviewDetails,
-    {
-      review: reviewDetails.review,
-      path: reviewDetails.path,
-      load: loadToolReviewDetails,
-      onBack: () => {
-        const { review, path, origin } = reviewDetails;
-        setReviewDetails(null);
-        requestAnimationFrame(() => {
-          const selector = `[data-approval-id="${CSS.escape(review.id)}"]${origin ? `[data-review-origin="${CSS.escape(origin)}"]` : ""} button[data-review-path="${CSS.escape(path)}"]`;
-          document.querySelector(selector)?.focus();
-        });
-      }
-    },
-    reviewDetails.review.id + reviewDetails.path
-  ) }) : null;
-  return createElement(
-    Fragment,
-    null,
-    reviewDetailPane,
-    creditTopupPrompt,
-    createElement(
-      "div",
-      {
-        className: reviewDetails ? "hidden" : "contents",
-        ...inertProps(Boolean(reviewDetails)),
-        ...props.placement === "panel" ? { ref: setPanelRoot } : {}
-      },
-      createElement(
-        LightboxProvider,
-        null,
-        /* @__PURE__ */ jsxs(
-          ChatViewportFileDropTarget,
-          {
-            "data-workspace-scroll-owner": "self-managed",
-            enabled: !terminal && context.clientConfig.fileUploads.enabled === true,
-            onFiles: attachments.addFiles,
-            children: [
-              findMounted ? /* @__PURE__ */ jsx(LazyPart, { fallback: null, children: /* @__PURE__ */ jsx(
-                ConversationFind,
-                {
-                  workspaceId: props.session.workspaceId,
-                  sessionId: props.session.id,
-                  open: findOpen,
-                  focusRevision: findFocusRevision,
-                  initial: props.searchTarget,
-                  showBackToSessionSearch: props.searchTarget.searchOrigin === "session-search",
-                  onClose: closeFind,
-                  onTarget: setActiveSearchTarget,
-                  onJump: props.onJumpToSequence
-                }
-              ) }) : null,
-              cancelled ? /* @__PURE__ */ jsxs("div", { className: cn("mx-auto w-full max-w-3xl pt-6", gutter), children: [
-                /* @__PURE__ */ jsx(TerminalSessionBanner, { session: props.session, onNewSession: props.onNewSession }),
-                /* @__PURE__ */ jsx(TerminalSessionArchive, { session: props.session, eventCount: props.timeline.length })
-              ] }) : readOnlyArchive ? /* @__PURE__ */ jsx("div", { className: cn("mx-auto w-full max-w-3xl pt-6", gutter), children: /* @__PURE__ */ jsx(
-                ReadOnlySessionNotice,
-                {
-                  session: props.session,
-                  onContinue: props.onContinueInNewSession
-                }
-              ) }) : null,
-              /* @__PURE__ */ jsx(Fragment2, { children: /* @__PURE__ */ jsx("div", { "data-testid": "session-timeline", className: "min-h-0 min-w-0 flex-1", children: /* @__PURE__ */ jsx(LearningRefusalActionsProvider, { onOpen: props.onLearningRefusalOpen, children: /* @__PURE__ */ jsx(
-                KnowledgeActivityProvider,
-                {
-                  onInspect: props.onMemoryClick,
-                  onRetryFile: (fileId) => composer.send(
-                    `Retry searchable source preparation for attached file ${fileId}. Use knowledge_retain_file and report its result.`
-                  ),
-                  retryDisabled: composer.hasDraftContent() || composer.sending || composer.draftLoading || !hasComposerPolicy,
-                  children: /* @__PURE__ */ jsx(
-                    ToolReviewHistoryProvider,
-                    {
-                      events: props.events,
-                      load: loadRecordedToolReview,
-                      onViewDetails: viewToolReviewDetails,
-                      children: /* @__PURE__ */ jsx(
-                        InteractiveAnswerProvider,
-                        {
-                          send: composer.send,
-                          scope: props.session.id,
-                          store: answerStore,
-                          readOnly: terminal,
-                          children: /* @__PURE__ */ jsx(
-                            MessageTimeline,
-                            {
-                              resolveLink,
-                              renderMessageSender,
-                              allowanceExhaustedLabels: CONSOLE_TIMELINE_ALLOWANCE_LABELS,
-                              trailingState: /* @__PURE__ */ jsxs(Fragment2, { children: [
-                                failureRecovery,
-                                props.approvals.length > 0 && approvalsDecidable(props.session.status) && /* @__PURE__ */ jsx(
-                                  ApprovalSurface,
-                                  {
-                                    approvals: props.approvals,
-                                    selectedApprovalId,
-                                    onSelectedApprovalChange: setSelectedApprovalId,
-                                    loadReview: loadToolReview,
-                                    onViewDetails: viewToolReviewDetails,
-                                    onApprove: (approval, answer) => decideApproval(approval.id, "approve", answer),
-                                    onReject: (approval) => decideApproval(approval.id, "reject")
-                                  }
-                                ),
-                                /* @__PURE__ */ jsx(LazyPart, { fallback: null, children: /* @__PURE__ */ jsx(
-                                  SessionSkillReviews,
-                                  {
-                                    context,
-                                    workspaceId: props.session.workspaceId,
-                                    sessionId: props.session.id,
-                                    events: props.events
-                                  },
-                                  `${context.accessContext.subjectId}:${props.session.workspaceId}:${props.session.id}`
-                                ) }),
-                                props.humanInput.requests.length > 0 && props.session.status === "requires_action" ? /* @__PURE__ */ jsx("div", { className: "pb-1", "data-human-input-timeline-surface": "", children: /* @__PURE__ */ jsx(LazyPart, { fallback: /* @__PURE__ */ jsx(LoadingPanel, { label: "Loading questions\u2026" }), children: /* @__PURE__ */ jsx(
-                                  HumanInputSurface,
-                                  {
-                                    loadSkillReview,
-                                    allowedSaveTo: secretSaveTargets(
-                                      context.accessContext,
-                                      props.session.workspaceId
-                                    ),
-                                    requests: props.humanInput.requests,
-                                    respondingRequestId: props.humanInput.respondingRequestId,
-                                    error: props.humanInput.mutationError?.message,
-                                    onSubmit: async (requestId, response) => {
-                                      if (!await props.humanInput.respond(requestId, response)) {
-                                        throw new Error("Your answer wasn't sent. Try again.");
-                                      }
-                                    }
-                                  }
-                                ) }) }) : null
-                              ] }),
-                              turnSummary: { rolling: true },
-                              className: "h-full",
-                              items: timelineWithStartup,
-                              searchTarget: activeSearchTarget,
-                              focusSequence: momentSequence,
-                              events: props.events,
-                              status: props.session.status,
-                              computeLabel,
-                              renderMessageText,
-                              renderMessageActions,
-                              onAnnotate: composer.addAnnotation,
-                              draftAnnotations: composer.annotations,
-                              onDraftAnnotationSelect: composer.requestAnnotationReview,
-                              onOpenSession: props.onOpenSession,
-                              resolveSessionTitle: props.resolveSessionTitle,
-                              onMemoryClick: props.onMemoryClick,
-                              onReconnect: props.onReconnect,
-                              renderAuthNeeded,
-                              resolveProviderLogo: props.resolveProviderLogo,
-                              loadRetainedScreenshot,
-                              loadRetainedArtifact,
-                              loadVideoArtifactPlayback,
-                              hasOlder: props.hasOlder,
-                              loadingOlder: props.loadingOlder,
-                              onLoadOlder: props.onLoadOlder,
-                              hasNewer: props.hasNewer,
-                              loadingNewer: props.loadingNewer,
-                              onLoadNewer: props.onLoadNewer,
-                              loadingOldest: props.loadingOldest,
-                              onJumpToStart: async () => {
-                                await props.onJumpToStart();
-                              },
-                              onJumpToLatest: props.onJumpToLatest,
-                              emptyState: (
-                                // Clear view hides history, not the retained failure or retry operation.
-                                failureRecovery ?? (props.queue.stoppingPreviousAttempt ? /* @__PURE__ */ jsx(
-                                  EmptyState,
-                                  {
-                                    className: "min-h-[24rem]",
-                                    icon: /* @__PURE__ */ jsx(Loader2Icon, { className: "size-4 animate-spin motion-reduce:animate-none" }),
-                                    title: props.queue.effectiveControl?.state === "paused" ? "Stopping current work" : "Stopping previous work",
-                                    description: props.queue.effectiveControl?.state === "paused" ? "Waiting for the current command to stop safely. Queued work stays saved." : "Your direction is saved. It starts after the previous command stops safely."
-                                  }
-                                ) : props.initialLoading ? /* @__PURE__ */ jsx("div", { className: "flex min-h-[24rem]", children: /* @__PURE__ */ jsx(LoadingPanel, {}) }) : props.historyReloadFailed ? /* @__PURE__ */ jsx(
-                                  ProblemPanel,
-                                  {
-                                    title: "Conversation couldn't be loaded",
-                                    description: "Your saved messages are unchanged. Try loading them again.",
-                                    action: /* @__PURE__ */ jsx(
-                                      Button,
-                                      {
-                                        variant: "outline",
-                                        onClick: () => void props.onJumpToLatest(),
-                                        children: "Retry conversation"
-                                      }
-                                    )
-                                  }
-                                ) : /* @__PURE__ */ jsx(
-                                  EmptyState,
-                                  {
-                                    className: "min-h-[24rem]",
-                                    icon: props.session.status === "running" || props.session.status === "recovering" ? /* @__PURE__ */ jsx(Loader2Icon, { className: "size-4 animate-spin motion-reduce:animate-none" }) : /* @__PURE__ */ jsx(MessagesSquareIcon, { className: "size-4" }),
-                                    title: timelineEmptyStateCopy.title,
-                                    description: timelineEmptyStateCopy.description
-                                  }
-                                ))
-                              )
-                            },
-                            props.session.id
-                          )
-                        }
-                      )
-                    }
-                  )
-                }
-              ) }) }) }),
-              forkEventId ? /* @__PURE__ */ jsx(LazyPart, { fallback: null, children: /* @__PURE__ */ jsx(
-                MessageForkDialog,
-                {
-                  session: props.session,
-                  events: props.events,
-                  sourceEventId: forkEventId,
-                  onForkClose: () => setForkEventId(null)
-                },
-                forkEventId
-              ) }) : null,
-              repositories.removalDialog,
-              modelRecovery ? /* @__PURE__ */ jsx(ModelRecoveryNotice, { recovery: modelRecovery }) : null,
-              /* @__PURE__ */ jsx("div", { className: cn("mb-1 w-full shrink-0 has-[>div:empty]:hidden", gutter), children: /* @__PURE__ */ jsxs("div", { className: "mx-auto w-full max-w-3xl", children: [
-                /* @__PURE__ */ jsx(
-                  SessionAdmissionNotice,
-                  {
-                    session: props.session,
-                    machineAccess,
-                    machineAction: /* @__PURE__ */ jsx(
-                      SessionMachinePickerAction,
-                      {
-                        queuedWork: true,
-                        runsOn,
-                        workspaceId: props.session.workspaceId,
-                        rigId: props.session.rigId,
-                        move: moveRunsOn
-                      }
-                    ),
-                    machines: runsOn.fleet.machines,
-                    onMoveToMachine: runsOn.fleet.canAttach ? moveSavedMessage : void 0,
-                    canControl: workspacePermissions.includes("sessions:control"),
-                    paused: admissionControl.state === "paused",
-                    refreshRequired: admissionRefreshRequired,
-                    busy: composer.resuming || composer.pausing || composer.sending || props.queue.mutating,
-                    onRecheck: () => recheckSessionAdmission({
-                      control: admissionControl,
-                      refreshOnly: admissionRefreshRequired,
-                      resume: (control) => context.client.resumeSession(props.session.workspaceId, props.session.id, {
-                        clientEventId: crypto.randomUUID(),
-                        expectedControlEtag: control.controlEtag
-                      }),
-                      refresh: [props.onReloadSession, props.queue.refresh]
-                    }),
-                    onContinueWaitingWork: async () => {
-                      await context.client.continueSessionWaitingWork(
-                        props.session.workspaceId,
-                        props.session.id
-                      );
-                      if (sessionAdmissionReason(props.session) !== null && admissionControl.state !== "paused")
-                        await recheckSessionAdmission({
-                          control: admissionControl,
-                          refreshOnly: admissionRefreshRequired,
-                          resume: (control) => context.client.resumeSession(props.session.workspaceId, props.session.id, {
-                            clientEventId: crypto.randomUUID(),
-                            expectedControlEtag: control.controlEtag
-                          }),
-                          refresh: [props.onReloadSession, props.queue.refresh]
-                        });
-                      else await props.onReloadSession();
-                      await runsOn.fleet.refresh();
-                    }
-                  },
-                  `${props.session.workspaceId}:${props.session.id}`
-                ),
-                waitingSubSessions.length > 0 ? /* @__PURE__ */ jsx(LazyPart, { fallback: null, children: /* @__PURE__ */ jsx(OpenGeniLinkProvider, { resolveLink, children: /* @__PURE__ */ jsx(
-                  DescendantRequests,
-                  {
-                    client: context.client,
-                    workspaceId: props.session.workspaceId,
-                    parentSessionId: props.session.id,
-                    events: props.events,
-                    waiting: waitingSubSessions,
-                    onResolved: props.onDescendantResolved,
-                    onResumingChange: onSubSessionResumingChange,
-                    refreshSignal: props.descendantRefreshSignal,
-                    loadSkillReview,
-                    allowedSaveTo: secretSaveTargets(
-                      context.accessContext,
-                      props.session.workspaceId
-                    )
-                  }
-                ) }) }) : null,
-                /* @__PURE__ */ jsx(
-                  SessionChrome,
-                  {
-                    sessionStatus: props.session.status,
-                    wait: admissionControl.state === "active" ? sessionInputWait(props.session) : null,
-                    onOpenSession: props.onOpenSession,
-                    queue: props.queue,
-                    composer: terminal ? void 0 : composer,
-                    queuedRecall,
-                    goal: props.goal,
-                    readOnly: terminal,
-                    commandsCount: props.session.backgroundCommandActivity?.count ?? 0,
-                    commandsPanel: /* @__PURE__ */ jsx(LazyPart, { fallback: /* @__PURE__ */ jsx(LoadingPanel, { label: "Loading commands\u2026" }), children: /* @__PURE__ */ jsx(
-                      SessionCommands,
-                      {
-                        sessionId: props.session.id,
-                        readOnly: terminal
-                      },
-                      props.session.id
-                    ) }),
-                    agentsSignal,
-                    agentsPanel: props.agentNodes.length > 0 ? /* @__PURE__ */ jsx(LazyPart, { fallback: /* @__PURE__ */ jsx(LoadingPanel, { label: "Loading agents\u2026" }), children: /* @__PURE__ */ jsx(
-                      SubagentTree,
-                      {
-                        workspaceId: props.session.workspaceId,
-                        nodes: props.agentNodes
-                      }
-                    ) }) : null
-                  }
-                )
-              ] }) }),
-              /* @__PURE__ */ jsx(
-                "div",
-                {
-                  ref: composerRegionRef,
-                  "data-read-only-composer": readOnlyArchive ? "hidden" : void 0,
-                  className: cn(
-                    "shrink-0",
-                    props.placement === "panel" ? "pb-3" : "pb-4",
-                    gutter,
-                    readOnlyArchive && "hidden"
-                  ),
-                  children: /* @__PURE__ */ jsxs("div", { className: "mx-auto w-full max-w-3xl", children: [
-                    /* @__PURE__ */ jsx(
-                      PersonalResourceAttachmentSurface,
-                      {
-                        controller: personalAttachment,
-                        disabled: terminal || composer.sending,
-                        compact: true
-                      }
-                    ),
-                    /* @__PURE__ */ jsx(
-                      ConsoleComposer,
-                      {
-                        workspaceId: props.session.workspaceId,
-                        usageRefreshKey: props.session.status,
-                        composer: composerDelivery,
-                        attachments,
-                        effectiveControl: composer.effectiveControl,
-                        queuedAheadCount: props.queue.queue.length,
-                        queuedRecall,
-                        running: usageLimitTreeActive || sessionTurnKeepsRunControl(props.session.status) || props.pendingWake,
-                        canControlWorkspace: workspacePermissions.includes("workspace:admin"),
-                        controlLinks: {
-                          workspaceHref: `/workspaces/${props.session.workspaceId}`,
-                          sessionHref: (sessionId) => `/workspaces/${props.session.workspaceId}/sessions/${sessionId}`
-                        },
-                        disabled: terminal,
-                        header: ownLoginsHeadsUp || unavailableModelNotice || codexUsageNotice || modelSwitchHeadsUp || usageLimitNotice || creditRefusalNotice || showMachineAccess ? /* @__PURE__ */ jsxs(Fragment2, { children: [
-                          !sessionAdmissionNeedsDifferentMachine(
-                            sessionAdmissionReason(props.session),
-                            machineAccess
-                          ) ? /* @__PURE__ */ jsx(
-                            SessionMachineAccessNotice,
-                            {
-                              access: machineAccess,
-                              shared: sharedChat,
-                              className: "px-3.5 pt-2.5 md:px-4",
-                              action: /* @__PURE__ */ jsx(
-                                SessionMachinePickerAction,
-                                {
-                                  runsOn,
-                                  workspaceId: props.session.workspaceId,
-                                  rigId: props.session.rigId,
-                                  move: moveRunsOn,
-                                  compact: machineAccess?.isOwner === true
-                                }
-                              )
-                            }
-                          ) : null,
-                          unavailableModelNotice,
-                          codexUsageNotice,
-                          modelSwitchHeadsUp,
-                          usageLimitNotice,
-                          creditRefusalNotice ? /* @__PURE__ */ jsx("div", { className: "px-2 pt-2", children: creditRefusalNotice }) : null,
-                          ownLoginsHeadsUp
-                        ] }) : null,
-                        commandContext,
-                        onClearView: props.onClearView,
-                        fileUploadsEnabled: context.clientConfig.fileUploads.enabled === true,
-                        transcriptionSuppressed: voiceActive,
-                        controlsLeading: /* @__PURE__ */ jsx(Fragment2, { children: /* @__PURE__ */ jsx(
-                          WorkspaceComposerPlus,
-                          {
-                            connectorActions: {
-                              accountControls: {
-                                groups: connectionAccounts.availableAccountGroups,
-                                choices: connectionAccounts.accountChoices,
-                                onChoose: connectionAccounts.selectAccount,
-                                loading: connectionAccounts.loading,
-                                error: connectionAccounts.error,
-                                accessDenied: connectionAccounts.accessDenied,
-                                onRefresh: () => void connectionAccounts.refresh(),
-                                disabled: terminal || composer.sending || durableToolsSaving || !durableToolsHydrated
-                              }
-                            },
-                            chatSettings: props.onOpenAgentSettings ? {
-                              workspaceId: props.session.workspaceId,
-                              sessionId: props.session.id,
-                              scope: chatLearningScope(props.session),
-                              canEdit: workspacePermissions.includes("sessions:control"),
-                              onOpen: props.onOpenAgentSettings
-                            } : void 0,
-                            workspaceId: props.session.workspaceId,
-                            disabled: terminal || composer.sending,
-                            fileUploadsEnabled: context.clientConfig.fileUploads.enabled === true,
-                            servers: selectableSessionMcpServers,
-                            firstPartyTools: firstPartyToolOptions,
-                            selection: durableToolSelection,
-                            toolsSaving: durableToolsSaving,
-                            toolsDisabled: composer.sending || terminal || durableToolsSaving || !durableToolsHydrated,
-                            connectorCustomizing,
-                            onConnectorCustomizingChange: (next) => {
-                              setConnectorCustomizingOverride(next);
-                              if (next) return;
-                              connectionAccounts.resetEmptyChoices();
-                              void applyDurableToolPolicy(
-                                followWorkspaceConnectorPolicy(durableToolsSnapshot)
-                              );
-                            },
-                            onToolSelectionChange: (next) => void saveDurableToolPolicy(next),
-                            ...secretsView?.capabilityEnabled ? {
-                              secrets: {
-                                summary: sessionSecretsSummary(
-                                  secretsView.policy,
-                                  secretsView.reachableVaults
-                                ),
-                                panel: /* @__PURE__ */ jsx(
-                                  SessionSecretsMenuBody,
-                                  {
-                                    vaults: secretsView.reachableVaults,
-                                    policy: secretsView.policy,
-                                    narrowedByParent: secretsView.narrowedBySessionId !== null,
-                                    taskItems: secretsView.taskItems,
-                                    canEdit: workspacePermissions.includes("sessions:control"),
-                                    disabled: terminal,
-                                    loading: sessionSecrets.loading,
-                                    error: sessionSecrets.error,
-                                    onRetry: () => void sessionSecrets.refresh(),
-                                    onPolicyChange: async (policy) => {
-                                      await sessionSecrets.api.setSessionVaultPolicy(
-                                        props.session.id,
-                                        policy
-                                      );
-                                      await sessionSecrets.refresh();
-                                    },
-                                    onSaveTo: async (item, target) => {
-                                      await sessionSecrets.api.moveItem(item.vaultId, item.id, {
-                                        targetVaultId: target.id,
-                                        mode: "copy"
-                                      });
-                                      toast.success(`Saved ${item.name} to ${target.name}`);
-                                    },
-                                    onManage: () => void navigate({
-                                      to: "/workspaces/$workspaceId/secrets",
-                                      params: { workspaceId: props.session.workspaceId }
-                                    })
-                                  }
-                                )
-                              }
-                            } : {},
-                            repositories: {
-                              selectedCount: repositories.selectionCount,
-                              disabled: terminal || composer.sending,
-                              panel: /* @__PURE__ */ jsx(FollowUpRepositoryMenuBody, { ...repositoryPickerProps })
-                            },
-                            ...runsOn.hasChoices || props.session.rigId || runsOn.activeMachine && !runsOn.activeMachine.isSessionGroup ? {
-                              runsOn: {
-                                summary: runsOn.activeName,
-                                panel: /* @__PURE__ */ jsx(
-                                  SessionRunsOnMenuBody,
-                                  {
-                                    runsOn,
-                                    workspaceId: props.session.workspaceId,
-                                    rigId: props.session.rigId ?? null,
-                                    move: moveRunsOn
-                                  }
-                                )
-                              }
-                            } : {}
-                          }
-                        ) }),
-                        actions: !terminal ? /* @__PURE__ */ jsx(LazyPart, { onLoadFailure: "hide", fallback: null, children: /* @__PURE__ */ jsx(
-                          LazyCodexRealtimeControl,
-                          {
-                            client: realtimeClient,
-                            workspaceId: props.session.workspaceId,
-                            sessionId: props.session.id,
-                            sessionStatus: props.session.status,
-                            effectiveControl: props.queue.effectiveControl ?? props.session.effectiveControl,
-                            events: props.events,
-                            eventsReady: !props.initialLoading,
-                            codexConnected,
-                            realtimeAutostartModel: props.realtimeAutostartModel,
-                            onRealtimeAutostartConsumed: props.onRealtimeAutostartConsumed,
-                            onVoiceActiveChange
-                          }
-                        ) }) : null,
-                        placeholder: chatComposerPlaceholder({
-                          cancelled: props.session.status === "cancelled",
-                          creditStopped: Boolean(props.creditExhausted) && (props.session.status === "failed" || props.session.status === "idle"),
-                          stopRefusal,
-                          creditGap,
-                          canBuyCredits
-                        }),
-                        controls: /* @__PURE__ */ jsxs("div", { className: "@container/model-controls flex min-w-0 flex-1 items-center gap-1.5", children: [
-                          /* @__PURE__ */ jsx(
-                            ModelPicker,
-                            {
-                              hasImageAttachments: attachments.attachments.some(
-                                (file) => file.status !== "failed" && file.contentType.startsWith("image/")
-                              ),
-                              open: modelPickerSession === props.session.id && !pendingRetryInput,
-                              onOpenChange: (open) => {
-                                setModelPickerSession(open ? props.session.id : null);
-                                if (open) void modelCatalog.refresh();
-                              },
-                              rows: modelCatalog.rows,
-                              model,
-                              effort: reasoningEffort,
-                              latencyMode,
-                              disabled: modelPickerDisabled,
-                              loading: modelCatalog.loading || composer.draftLoading,
-                              error: modelCatalog.error ?? composerPolicyError,
-                              sessionKey: props.session.id,
-                              menuSide: "top",
-                              connectModelsHref: `/workspaces/${encodeURIComponent(props.session.workspaceId)}/settings?section=models`,
-                              claudeSubscriptionAvailable: context.clientConfig.claudeSubscriptionEnabled === true,
-                              onModelChange: (modelId) => {
-                                composer.setModel(modelId);
-                                usageModelSwitch.modelPicked(modelId);
-                              },
-                              onEffortChange: composer.setReasoningEffort,
-                              onLatencyModeChange: composer.setLatencyMode
-                            }
-                          ),
-                          durableToolsError ? /* @__PURE__ */ jsx("span", { className: "sr-only", role: "alert", children: durableToolsError }) : null
-                        ] })
-                      }
-                    )
-                  ] })
-                }
-              )
-            ]
-          }
-        )
-      )
-    )
-  );
-}
-function refusedModelId(error, input) {
-  const details = error.details;
-  if (typeof details?.modelId === "string" && details.modelId) return details.modelId;
-  const attempted = input?.model;
-  return typeof attempted === "string" && attempted ? attempted : null;
-}
-
-export {
-  SessionRoute
-};
-//# sourceMappingURL=chunk-PC2EBA5G.js.map