Warn staff before continuing a stale, costly conversation

claude · claude · commit 199a7fca20ef · 2026-07-03T09:41:07.000Z
When a PostHog employee (is_staff) opens a large conversation (>= 40k context tokens) left idle past the ~5-minute prompt-cache TTL, its Anthropic prompt cache has likely expired, so the next turn re-processes the whole prefix at full input price instead of the ~10% cached-read rate. Grey out the composer and show an AlertDialog offering to start fresh or continue anyway; the choice is remembered per session and the gate can be reopened from an inline notice. - core: pure shouldWarnStaleCostlyConversation() helper + default threshold in contextUsage.ts, with parameterised tests - ui: StaleConversationCostDialog, a per-session acknowledgement store (staleConversationGateStore), and SessionView wiring that ORs the gate into PromptInput's `disabled`/tooltip Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01RkLQSsdj7o4wQjcmjM1SD1
diff --git a/packages/core/src/sessions/contextUsage.test.ts b/packages/core/src/sessions/contextUsage.test.ts
@@ -1,6 +1,11 @@
 import type { AcpMessage } from "@posthog/shared";
 import { describe, expect, it } from "vitest";
-import { createContextUsageTracker, extractContextUsage } from "./contextUsage";
+import {
+  createContextUsageTracker,
+  DEFAULT_STALE_COSTLY_THRESHOLD,
+  extractContextUsage,
+  shouldWarnStaleCostlyConversation,
+} from "./contextUsage";
 
 function usageUpdateEvent(used: number, size: number): AcpMessage {
   return {
@@ -132,3 +137,94 @@ describe("createContextUsageTracker", () => {
     expect(tracker.update(events)).toEqual(extractContextUsage(events));
   });
 });
+
+describe("shouldWarnStaleCostlyConversation", () => {
+  const now = 1_000_000_000;
+  const threshold = { tokens: 40_000, staleMs: 5 * 60 * 1000 };
+
+  it.each([
+    {
+      name: "large + stale → warn",
+      usedTokens: 50_000,
+      idleMs: 10 * 60 * 1000,
+      expected: true,
+    },
+    {
+      name: "large + fresh → no warn",
+      usedTokens: 50_000,
+      idleMs: 60 * 1000,
+      expected: false,
+    },
+    {
+      name: "small + stale → no warn",
+      usedTokens: 10_000,
+      idleMs: 10 * 60 * 1000,
+      expected: false,
+    },
+    {
+      name: "small + fresh → no warn",
+      usedTokens: 10_000,
+      idleMs: 60 * 1000,
+      expected: false,
+    },
+    {
+      name: "exactly at both thresholds → warn",
+      usedTokens: 40_000,
+      idleMs: 5 * 60 * 1000,
+      expected: true,
+    },
+    {
+      name: "one token below the size threshold → no warn",
+      usedTokens: 39_999,
+      idleMs: 10 * 60 * 1000,
+      expected: false,
+    },
+    {
+      name: "one ms below the stale threshold → no warn",
+      usedTokens: 50_000,
+      idleMs: 5 * 60 * 1000 - 1,
+      expected: false,
+    },
+  ])("$name", ({ usedTokens, idleMs, expected }) => {
+    expect(
+      shouldWarnStaleCostlyConversation({
+        usedTokens,
+        lastActivityAt: now - idleMs,
+        now,
+        threshold,
+      }),
+    ).toBe(expected);
+  });
+
+  it("never warns without a last-activity timestamp", () => {
+    expect(
+      shouldWarnStaleCostlyConversation({
+        usedTokens: 1_000_000,
+        lastActivityAt: null,
+        now,
+        threshold,
+      }),
+    ).toBe(false);
+  });
+
+  it("treats a future timestamp (clock skew) as fresh", () => {
+    expect(
+      shouldWarnStaleCostlyConversation({
+        usedTokens: 50_000,
+        lastActivityAt: now + 60_000,
+        now,
+        threshold,
+      }),
+    ).toBe(false);
+  });
+
+  it("falls back to DEFAULT_STALE_COSTLY_THRESHOLD when none is given", () => {
+    expect(
+      shouldWarnStaleCostlyConversation({
+        usedTokens: DEFAULT_STALE_COSTLY_THRESHOLD.tokens,
+        lastActivityAt: now - DEFAULT_STALE_COSTLY_THRESHOLD.staleMs,
+        now,
+      }),
+    ).toBe(true);
+  });
+});
diff --git a/packages/core/src/sessions/contextUsage.ts b/packages/core/src/sessions/contextUsage.ts
@@ -111,3 +111,54 @@ function extractBreakdown(msg: AcpMessage["message"]): ContextBreakdown | null {
   const params = msg.params as { breakdown?: ContextBreakdown } | undefined;
   return params?.breakdown ?? null;
 }
+
+/**
+ * Threshold controlling when {@link shouldWarnStaleCostlyConversation} fires.
+ */
+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 to
+   * roughly the Anthropic prompt-cache TTL: once the cache expires, the next
+   * turn re-processes the whole prefix at full input price instead of the
+   * ~10% cached-read rate.
+   */
+  staleMs: number;
+}
+
+/**
+ * Defaults for the stale-costly conversation warning: a conversation large
+ * enough that a cold cache rebuild is noticeable, left idle past the default
+ * 5-minute prompt-cache TTL.
+ */
+export const DEFAULT_STALE_COSTLY_THRESHOLD: StaleCostlyThreshold = {
+  tokens: 40_000,
+  staleMs: 5 * 60 * 1000,
+};
+
+/**
+ * Decide whether to warn that continuing a conversation will be costly.
+ *
+ * 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.
+ */
+export function shouldWarnStaleCostlyConversation(args: {
+  usedTokens: number;
+  lastActivityAt: number | null;
+  now: number;
+  threshold?: StaleCostlyThreshold;
+}): boolean {
+  const { usedTokens, lastActivityAt, now } = args;
+  const threshold = args.threshold ?? DEFAULT_STALE_COSTLY_THRESHOLD;
+  if (lastActivityAt === null) return false;
+  if (usedTokens < threshold.tokens) return false;
+  return now - lastActivityAt >= threshold.staleMs;
+}
diff --git a/packages/ui/src/features/sessions/components/SessionView.tsx b/packages/ui/src/features/sessions/components/SessionView.tsx
@@ -1,4 +1,5 @@
 import { Pause, Spinner, Warning } from "@phosphor-icons/react";
+import { shouldWarnStaleCostlyConversation } from "@posthog/core/sessions/contextUsage";
 import {
   createLatestPlanTracker,
   SESSION_SERVICE,
@@ -7,6 +8,7 @@ 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,
@@ -29,9 +31,11 @@ import { QueuedMessagesDock } from "@posthog/ui/features/sessions/components/Que
 import { ReasoningLevelSelector } from "@posthog/ui/features/sessions/components/ReasoningLevelSelector";
 import { RawLogsView } from "@posthog/ui/features/sessions/components/raw-logs/RawLogsView";
 import { SessionResourcesBar } from "@posthog/ui/features/sessions/components/SessionResourcesBar";
+import { StaleConversationCostDialog } from "@posthog/ui/features/sessions/components/StaleConversationCostDialog";
 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 {
@@ -44,6 +48,7 @@ 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 { useSettingsStore } from "@posthog/ui/features/settings/settingsStore";
@@ -265,6 +270,41 @@ 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]);
+
   const [isDraggingFile, setIsDraggingFile] = useState(false);
   const editorRef = useRef<PromptInputHandle>(null);
   const dragCounterRef = useRef(0);
@@ -617,16 +657,50 @@ export function SessionView({
                         }
                       >
                         {taskId && <QueuedMessagesDock taskId={taskId} />}
+                        {costGateActive && !costGateDialogOpen && (
+                          <Flex justify="center" mb="2">
+                            <Button
+                              variant="soft"
+                              color="amber"
+                              size="1"
+                              onClick={() => setCostGateDismissedFor(null)}
+                            >
+                              <Warning size={14} weight="fill" />
+                              Conversation paused to avoid a costly reload —
+                              review
+                            </Button>
+                          </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)
+                          }
+                        />
                         <PromptInput
                           ref={editorRef}
                           sessionId={sessionId}
                           placeholder="Type a message... @ to mention files, ! for bash mode, / for skills"
-                          disabled={!isRunning && !handoffInProgress}
+                          disabled={
+                            (!isRunning && !handoffInProgress) || costGateActive
+                          }
                           submitDisabledExternal={
                             handoffInProgress || !isOnline
                           }
                           submitTooltipOverride={
-                            !isOnline ? "No internet connection" : undefined
+                            costGateActive
+                              ? "Large idle conversation — review the cost notice to continue"
+                              : !isOnline
+                                ? "No internet connection"
+                                : undefined
                           }
                           isLoading={!!isPromptPending}
                           isActiveSession={isActiveSession}
diff --git a/packages/ui/src/features/sessions/components/StaleConversationCostDialog.tsx b/packages/ui/src/features/sessions/components/StaleConversationCostDialog.tsx
@@ -0,0 +1,71 @@
+import { Warning } from "@phosphor-icons/react";
+import { AlertDialog, Button, Flex } from "@radix-ui/themes";
+
+interface StaleConversationCostDialogProps {
+  open: boolean;
+  usedTokens: number;
+  idleMs: number;
+  /** 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,
+  costUsd,
+  onContinue,
+  onOpenChange,
+}: StaleConversationCostDialogProps) {
+  return (
+    <AlertDialog.Root open={open} onOpenChange={onOpenChange}>
+      <AlertDialog.Content maxWidth="460px" size="2">
+        <AlertDialog.Title className="text-base">
+          <Flex align="center" gap="2">
+            <Warning size={18} weight="fill" color="var(--orange-9)" />
+            Continue this large, idle conversation?
+          </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
+          {costUsd !== null ? ` (≈$${costUsd.toFixed(2)} spent so far)` : ""}.
+          Starting a new conversation avoids the cost — continue only if you
+          need this thread's context.
+        </AlertDialog.Description>
+
+        <Flex justify="end" gap="2" mt="4">
+          <AlertDialog.Cancel>
+            <Button variant="soft" color="gray" size="1">
+              Not now
+            </Button>
+          </AlertDialog.Cancel>
+          <AlertDialog.Action>
+            <Button variant="solid" size="1" onClick={onContinue}>
+              Continue anyway
+            </Button>
+          </AlertDialog.Action>
+        </Flex>
+      </AlertDialog.Content>
+    </AlertDialog.Root>
+  );
+}
diff --git a/packages/ui/src/features/sessions/staleConversationGateStore.test.ts b/packages/ui/src/features/sessions/staleConversationGateStore.test.ts
diff --git a/packages/ui/src/features/sessions/staleConversationGateStore.ts b/packages/ui/src/features/sessions/staleConversationGateStore.ts
