Simplify stale-conversation gate: extract hook, reuse helpers, trim store

Cleanup pass (no behavior change):

- Extract useStaleConversationGate(sessionId, events) so SessionView stays a
  composition root instead of inlining the orchestration, mirroring the
  existing useBranchMismatchDialog pattern.
- Reuse formatTokensCompact (fixes a 40K/40k inconsistency with the context
  indicator) and formatRelativeTimeLong in the dialog; drop the two bespoke
  local formatters.
- Move the events[-1].ts staleness read into a core extractLastActivityAt()
  helper (with the heuristic documented) + tests.
- Trim the gate store to just acknowledge() — reset()/isAcknowledged() were
  only exercised by their own tests; production uses the .has() selector.
- Collapse the reopen condition to a positive `dismissed` predicate and
  de-duplicate the prompt-cache rationale across JSDoc blocks.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RkLQSsdj7o4wQjcmjM1SD1

Author: claude

packages/core/src/sessions/contextUsage.test.ts

@@ -4,6 +4,7 @@ import {
   createContextUsageTracker,
   DEFAULT_STALE_COSTLY_THRESHOLD,
   extractContextUsage,
+  extractLastActivityAt,
   shouldWarnStaleCostlyConversation,
 } from "./contextUsage";
 
@@ -228,3 +229,17 @@ describe("shouldWarnStaleCostlyConversation", () => {
     ).toBe(true);
   });
 });
+
+describe("extractLastActivityAt", () => {
+  it("returns null for an empty event list", () => {
+    expect(extractLastActivityAt([])).toBeNull();
+  });
+
+  it("returns the ts of the most recent event", () => {
+    const events: AcpMessage[] = [
+      { ...agentChunkEvent(), ts: 10 },
+      { ...usageUpdateEvent(50_000, 200_000), ts: 20 },
+    ];
+    expect(extractLastActivityAt(events)).toBe(20);
+  });
+});

packages/core/src/sessions/contextUsage.ts

@@ -119,10 +119,8 @@ export interface StaleCostlyThreshold {
   /** Minimum context tokens for a conversation to count as "large". */
   tokens: number;
   /**
-   * Minimum idle time (ms) before a conversation counts as "stale" — set at or
-   * above the prompt-cache TTL so that, once exceeded, the cache is expired and
-   * the next turn re-processes the whole prefix at full input price instead of
-   * the ~10% cached-read rate.
+   * Minimum idle time (ms) before a conversation counts as "stale". See
+   * {@link DEFAULT_STALE_COSTLY_THRESHOLD} for how this bound is chosen.
    */
   staleMs: number;
 }
@@ -147,17 +145,13 @@ export const DEFAULT_STALE_COSTLY_THRESHOLD: StaleCostlyThreshold = {
 };
 
 /**
- * Decide whether to warn that continuing a conversation will be costly.
+ * Decide whether to warn that continuing a conversation will be costly: true
+ * when it is both large (>= `threshold.tokens`) and stale (idle >=
+ * `threshold.staleMs`). See {@link DEFAULT_STALE_COSTLY_THRESHOLD} for the
+ * pricing rationale behind the defaults.
  *
- * Flags a conversation that is both large (>= `threshold.tokens` of context)
- * and stale (idle >= `threshold.staleMs`). Staleness approximates whether the
- * Anthropic prompt cache has expired: continuing a stale, large conversation
- * re-sends the whole prefix at full input price rather than the cached-read
- * rate, so starting fresh is often cheaper.
- *
- * Pure and time-injected (no `Date.now()`) so it stays host-agnostic and
- * testable. A `null` `lastActivityAt` (no activity yet) never warns, and a
- * future timestamp (clock skew) reads as fresh, not stale.
+ * Pure and time-injected (no `Date.now()`). A `null` `lastActivityAt` never
+ * warns, and a future timestamp (clock skew) reads as fresh.
  */
 export function shouldWarnStaleCostlyConversation(args: {
   usedTokens: number;
@@ -171,3 +165,15 @@ export function shouldWarnStaleCostlyConversation(args: {
   if (usedTokens < threshold.tokens) return false;
   return now - lastActivityAt >= threshold.staleMs;
 }
+
+/**
+ * Best-effort "time of last activity" for a session: the emit timestamp of the
+ * most recent event, or null for an empty list. Heuristic proxy for
+ * prompt-cache freshness — `ts` is stamped on *any* AcpMessage (agent chunks,
+ * tool calls, client-side events), not only turns sent to the model, so a
+ * purely local event can reset it without the cache being refreshed. Good
+ * enough for a soft cost warning; not a billing signal.
+ */
+export function extractLastActivityAt(events: AcpMessage[]): number | null {
+  return events.length > 0 ? events[events.length - 1].ts : null;
+}

packages/ui/src/features/sessions/components/SessionView.tsx

@@ -1,5 +1,4 @@
 import { Pause, Spinner, Warning } from "@phosphor-icons/react";
-import { shouldWarnStaleCostlyConversation } from "@posthog/core/sessions/contextUsage";
 import {
   createLatestPlanTracker,
   SESSION_SERVICE,
@@ -8,7 +7,6 @@ import {
 import { useService } from "@posthog/di/react";
 import type { AcpMessage } from "@posthog/shared";
 import type { Task, TaskRunStatus } from "@posthog/shared/domain-types";
-import { useMeQuery } from "@posthog/ui/features/auth/useMeQuery";
 import { showOfflineToast } from "@posthog/ui/features/connectivity/connectivityToast";
 import {
   PromptInput,
@@ -35,7 +33,6 @@ import { StaleConversationCostDialog } from "@posthog/ui/features/sessions/compo
 import { SteerQueueToggle } from "@posthog/ui/features/sessions/components/SteerQueueToggle";
 import { ThreadView } from "@posthog/ui/features/sessions/components/ThreadView";
 import { CHAT_CONTENT_MAX_WIDTH } from "@posthog/ui/features/sessions/constants";
-import { useContextUsage } from "@posthog/ui/features/sessions/hooks/useContextUsage";
 import { useSessionEventsResidency } from "@posthog/ui/features/sessions/hooks/useSessionEventsResidency";
 import { useToggleMessagingMode } from "@posthog/ui/features/sessions/hooks/useToggleMessagingMode";
 import {
@@ -48,9 +45,9 @@ import {
   useSessionViewActions,
   useShowRawLogs,
 } from "@posthog/ui/features/sessions/sessionViewStore";
-import { useStaleConversationGateStore } from "@posthog/ui/features/sessions/staleConversationGateStore";
 import type { Plan } from "@posthog/ui/features/sessions/types";
 import { useSessionHandoffInProgress } from "@posthog/ui/features/sessions/useSession";
+import { useStaleConversationGate } from "@posthog/ui/features/sessions/useStaleConversationGate";
 import { useSettingsStore } from "@posthog/ui/features/settings/settingsStore";
 import { useIsWorkspaceCloudRun } from "@posthog/ui/features/workspace/useWorkspace";
 import { useConnectivity } from "@posthog/ui/hooks/useConnectivity";
@@ -270,40 +267,9 @@ export function SessionView({
     [isOnline, onBeforeSubmit],
   );
 
-  // Warn PostHog employees before continuing a large conversation that has gone
-  // idle long enough that its Anthropic prompt cache has likely expired — the
-  // next turn would re-process the whole prefix at full price rather than the
-  // ~10% cached rate. Gated to staff via `is_staff`; dismissible per session.
-  const contextUsage = useContextUsage(events);
-  const { data: currentUser } = useMeQuery();
-  const isStaff = currentUser?.is_staff === true;
-  const staleConversationAcknowledged = useStaleConversationGateStore((s) =>
-    s.acknowledgedSessions.has(sessionId),
-  );
-  const acknowledgeStaleConversation = useStaleConversationGateStore(
-    (s) => s.acknowledge,
-  );
-  const lastActivityAt =
-    events.length > 0 ? events[events.length - 1].ts : null;
-  const now = Date.now();
-  const costGateActive =
-    isStaff &&
-    !staleConversationAcknowledged &&
-    shouldWarnStaleCostlyConversation({
-      usedTokens: contextUsage?.used ?? 0,
-      lastActivityAt,
-      now,
-    });
-  // Track which session the cost dialog was dismissed for, so switching to a
-  // different gated session re-opens it — without a reset effect.
-  const [costGateDismissedFor, setCostGateDismissedFor] = useState<
-    string | null
-  >(null);
-  const costGateDialogOpen =
-    costGateActive && costGateDismissedFor !== sessionId;
-  const handleContinueStaleConversation = useCallback(() => {
-    acknowledgeStaleConversation(sessionId);
-  }, [acknowledgeStaleConversation, sessionId]);
+  // Warn PostHog staff before continuing a large, idle conversation whose
+  // prompt cache has likely expired (see useStaleConversationGate).
+  const staleGate = useStaleConversationGate(sessionId, events);
 
   const [isDraggingFile, setIsDraggingFile] = useState(false);
   const editorRef = useRef<PromptInputHandle>(null);
@@ -657,13 +623,13 @@ export function SessionView({
                         }
                       >
                         {taskId && <QueuedMessagesDock taskId={taskId} />}
-                        {costGateActive && !costGateDialogOpen && (
+                        {staleGate.dismissed && (
                           <Flex justify="center" mb="2">
                             <Button
                               variant="soft"
                               color="amber"
                               size="1"
-                              onClick={() => setCostGateDismissedFor(null)}
+                              onClick={staleGate.onReopen}
                             >
                               <Warning size={14} weight="fill" />
                               Conversation paused to avoid a costly reload —
@@ -672,31 +638,26 @@ export function SessionView({
                           </Flex>
                         )}
                         <StaleConversationCostDialog
-                          open={costGateDialogOpen}
-                          usedTokens={contextUsage?.used ?? 0}
-                          idleMs={
-                            lastActivityAt !== null
-                              ? Math.max(0, now - lastActivityAt)
-                              : 0
-                          }
-                          costUsd={contextUsage?.cost?.amount ?? null}
-                          onContinue={handleContinueStaleConversation}
-                          onOpenChange={(open) =>
-                            setCostGateDismissedFor(open ? null : sessionId)
-                          }
+                          open={staleGate.dialogOpen}
+                          usedTokens={staleGate.usedTokens}
+                          lastActivityAt={staleGate.lastActivityAt}
+                          costUsd={staleGate.costUsd}
+                          onContinue={staleGate.onContinue}
+                          onOpenChange={staleGate.onDialogOpenChange}
                         />
                         <PromptInput
                           ref={editorRef}
                           sessionId={sessionId}
                           placeholder="Type a message... @ to mention files, ! for bash mode, / for skills"
                           disabled={
-                            (!isRunning && !handoffInProgress) || costGateActive
+                            (!isRunning && !handoffInProgress) ||
+                            staleGate.active
                           }
                           submitDisabledExternal={
                             handoffInProgress || !isOnline
                           }
                           submitTooltipOverride={
-                            costGateActive
+                            staleGate.active
                               ? "Large idle conversation — review the cost notice to continue"
                               : !isOnline
                                 ? "No internet connection"

packages/ui/src/features/sessions/components/StaleConversationCostDialog.tsx

@@ -1,39 +1,30 @@
 import { Warning } from "@phosphor-icons/react";
+import { formatRelativeTimeLong } from "@posthog/shared";
+import { formatTokensCompact } from "@posthog/ui/features/sessions/contextColors";
 import { AlertDialog, Button, Flex } from "@radix-ui/themes";
 
 interface StaleConversationCostDialogProps {
   open: boolean;
   usedTokens: number;
-  idleMs: number;
+  lastActivityAt: number | null;
   /** Cumulative session cost so far, when the gateway reports it. */
   costUsd: number | null;
   onContinue: () => void;
   onOpenChange: (open: boolean) => void;
 }
 
-function formatTokens(tokens: number): string {
-  if (tokens >= 1_000_000) return `${(tokens / 1_000_000).toFixed(1)}M`;
-  if (tokens >= 1_000) return `${Math.round(tokens / 1_000)}k`;
-  return `${tokens}`;
-}
-
-function formatIdle(ms: number): string {
-  const minutes = Math.round(ms / 60_000);
-  if (minutes < 60) return `${Math.max(1, minutes)} min`;
-  const hours = Math.round(minutes / 60);
-  if (hours < 24) return `${hours} hour${hours === 1 ? "" : "s"}`;
-  const days = Math.round(hours / 24);
-  return `${days} day${days === 1 ? "" : "s"}`;
-}
-
 export function StaleConversationCostDialog({
   open,
   usedTokens,
-  idleMs,
+  lastActivityAt,
   costUsd,
   onContinue,
   onOpenChange,
 }: StaleConversationCostDialogProps) {
+  const activity =
+    lastActivityAt !== null
+      ? `was last active ${formatRelativeTimeLong(lastActivityAt)}`
+      : "has been idle";
   return (
     <AlertDialog.Root open={open} onOpenChange={onOpenChange}>
       <AlertDialog.Content maxWidth="460px" size="2">
@@ -44,10 +35,10 @@ export function StaleConversationCostDialog({
           </Flex>
         </AlertDialog.Title>
         <AlertDialog.Description className="text-sm">
-          This conversation holds about {formatTokens(usedTokens)} tokens and
-          has been idle for {formatIdle(idleMs)}. Its prompt cache has likely
-          expired, so your next message re-processes the whole conversation at
-          full input price instead of the ~10% cached rate
+          This conversation holds about {formatTokensCompact(usedTokens)} tokens
+          and {activity}. Its prompt cache has likely expired, so your next
+          message re-processes the whole conversation at full input price
+          instead of the ~10% cached rate
           {costUsd !== null ? ` (≈$${costUsd.toFixed(2)} spent so far)` : ""}.
           Starting a new conversation avoids the cost — continue only if you
           need this thread's context.

packages/ui/src/features/sessions/staleConversationGateStore.test.ts

@@ -1,22 +1,22 @@
 import { beforeEach, describe, expect, it } from "vitest";
 import { useStaleConversationGateStore } from "./staleConversationGateStore";
 
+const acknowledged = (id: string) =>
+  useStaleConversationGateStore.getState().acknowledgedSessions.has(id);
+
 describe("useStaleConversationGateStore", () => {
   beforeEach(() => {
     useStaleConversationGateStore.setState({ acknowledgedSessions: new Set() });
   });
 
   it("starts with nothing acknowledged", () => {
-    expect(useStaleConversationGateStore.getState().isAcknowledged("s1")).toBe(
-      false,
-    );
+    expect(acknowledged("s1")).toBe(false);
   });
 
   it("acknowledges a single session without affecting others", () => {
     useStaleConversationGateStore.getState().acknowledge("s1");
-    const state = useStaleConversationGateStore.getState();
-    expect(state.isAcknowledged("s1")).toBe(true);
-    expect(state.isAcknowledged("s2")).toBe(false);
+    expect(acknowledged("s1")).toBe(true);
+    expect(acknowledged("s2")).toBe(false);
   });
 
   it("replaces the Set immutably on acknowledge", () => {
@@ -36,13 +36,4 @@ describe("useStaleConversationGateStore", () => {
       useStaleConversationGateStore.getState().acknowledgedSessions;
     expect(second).toBe(first);
   });
-
-  it("reset clears a single session's acknowledgement", () => {
-    const { acknowledge, reset } = useStaleConversationGateStore.getState();
-    acknowledge("s1");
-    reset("s1");
-    expect(useStaleConversationGateStore.getState().isAcknowledged("s1")).toBe(
-      false,
-    );
-  });
 });

packages/ui/src/features/sessions/staleConversationGateStore.ts

@@ -7,20 +7,19 @@ interface StaleConversationGateState {
 
 interface StaleConversationGateActions {
   acknowledge: (sessionId: string) => void;
-  isAcknowledged: (sessionId: string) => boolean;
-  reset: (sessionId: string) => void;
 }
 
 export type StaleConversationGateStore = StaleConversationGateState &
   StaleConversationGateActions;
 
 /**
- * Tracks which sessions have dismissed the stale-costly-conversation cost
- * warning. Ephemeral view state (not persisted): dismissing is per-session and
- * only needs to last for the current app run.
+ * Tracks which sessions have accepted the stale-costly-conversation cost
+ * warning. Ephemeral view state (not persisted): acknowledgement is per-session
+ * and only needs to last for the current app run. Read via the reactive
+ * `acknowledgedSessions.has(id)` selector.
  */
 export const useStaleConversationGateStore =
-  create<StaleConversationGateStore>()((set, get) => ({
+  create<StaleConversationGateStore>()((set) => ({
     acknowledgedSessions: new Set(),
 
     acknowledge: (sessionId) =>
@@ -30,14 +29,4 @@ export const useStaleConversationGateStore =
         next.add(sessionId);
         return { acknowledgedSessions: next };
       }),
-
-    isAcknowledged: (sessionId) => get().acknowledgedSessions.has(sessionId),
-
-    reset: (sessionId) =>
-      set((state) => {
-        if (!state.acknowledgedSessions.has(sessionId)) return state;
-        const next = new Set(state.acknowledgedSessions);
-        next.delete(sessionId);
-        return { acknowledgedSessions: next };
-      }),
   }));