feat: Warn PostHog staff before continuing stale, costly conversations (#3122)

Co-authored-by: Claude <noreply@anthropic.com>

Author: webjunkie

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

@@ -1,6 +1,12 @@
 import type { AcpMessage } from "@posthog/shared";
 import { describe, expect, it } from "vitest";
-import { createContextUsageTracker, extractContextUsage } from "./contextUsage";
+import {
+  createContextUsageTracker,
+  DEFAULT_STALE_COSTLY_THRESHOLD,
+  extractContextUsage,
+  extractLastActivityAt,
+  shouldWarnStaleCostlyConversation,
+} from "./contextUsage";
 
 function usageUpdateEvent(used: number, size: number): AcpMessage {
   return {
@@ -132,3 +138,116 @@ 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);
+  });
+});
+
+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);
+  });
+
+  it("returns the maximum ts even when events are out of order", () => {
+    const events: AcpMessage[] = [
+      { ...usageUpdateEvent(50_000, 200_000), ts: 30 },
+      { ...agentChunkEvent(), ts: 10 },
+    ];
+    expect(extractLastActivityAt(events)).toBe(30);
+  });
+});

packages/core/src/sessions/contextUsage.ts

@@ -111,3 +111,76 @@ 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". See
+   * {@link DEFAULT_STALE_COSTLY_THRESHOLD} for how this bound is chosen.
+   */
+  staleMs: number;
+}
+
+/**
+ * Defaults for the stale-costly conversation warning.
+ *
+ * `tokens` (100k): only conversations big enough that a cold prefix rebuild is
+ * a real cost — roughly 10% of the 1M context window — trip the warning.
+ *
+ * `staleMs` (60 min): Anthropic ephemeral caches default to a 5-minute TTL and
+ * can opt into a 1-hour one; the effective value depends on what the Agent SDK
+ * requests, which we don't control or observe. We deliberately use the longer
+ * 1-hour bound so the cache is almost certainly cold before we warn — warning
+ * while it is still warm would nag about a continuation that is in fact cheap,
+ * the worse failure. Erring long only means we occasionally skip a warning,
+ * never that we nag needlessly.
+ */
+export const DEFAULT_STALE_COSTLY_THRESHOLD: StaleCostlyThreshold = {
+  tokens: 100_000,
+  staleMs: 60 * 60 * 1000,
+};
+
+/**
+ * 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.
+ *
+ * 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;
+  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;
+}
+
+/**
+ * Best-effort "time of last activity" for a session: the most recent (maximum)
+ * `ts` among events, or null for an empty list. Scans for the max rather than
+ * trusting positional order, so an out-of-order append can't report a staler
+ * time than reality. (Uses a loop, not the spread form of `Math.max`, which can
+ * overflow the stack on long event lists.) 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. Good enough for a soft
+ * cost warning; not a billing signal.
+ */
+export function extractLastActivityAt(events: AcpMessage[]): number | null {
+  if (events.length === 0) return null;
+  let latest = events[0].ts;
+  for (let i = 1; i < events.length; i++) {
+    if (events[i].ts > latest) latest = events[i].ts;
+  }
+  return latest;
+}

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

@@ -29,6 +29,7 @@ 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";
@@ -46,6 +47,7 @@ import {
 } from "@posthog/ui/features/sessions/sessionViewStore";
 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";
@@ -265,6 +267,10 @@ export function SessionView({
     [isOnline, onBeforeSubmit],
   );
 
+  // 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);
   const dragCounterRef = useRef(0);
@@ -617,16 +623,45 @@ export function SessionView({
                         }
                       >
                         {taskId && <QueuedMessagesDock taskId={taskId} />}
+                        {staleGate.dismissed && (
+                          <Flex justify="center" mb="2">
+                            <Button
+                              variant="soft"
+                              color="amber"
+                              size="1"
+                              onClick={staleGate.onReopen}
+                            >
+                              <Warning size={14} weight="fill" />
+                              Conversation paused to avoid a costly reload —
+                              review
+                            </Button>
+                          </Flex>
+                        )}
+                        <StaleConversationCostDialog
+                          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}
+                          disabled={
+                            (!isRunning && !handoffInProgress) ||
+                            staleGate.active
+                          }
                           submitDisabledExternal={
                             handoffInProgress || !isOnline
                           }
                           submitTooltipOverride={
-                            !isOnline ? "No internet connection" : undefined
+                            staleGate.active
+                              ? "Large idle conversation — review the cost notice to continue"
+                              : !isOnline
+                                ? "No internet connection"
+                                : undefined
                           }
                           isLoading={!!isPromptPending}
                           isActiveSession={isActiveSession}

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

@@ -0,0 +1,62 @@
+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;
+  lastActivityAt: number | null;
+  /** Cumulative session cost so far, when the gateway reports it. */
+  costUsd: number | null;
+  onContinue: () => void;
+  onOpenChange: (open: boolean) => void;
+}
+
+export function StaleConversationCostDialog({
+  open,
+  usedTokens,
+  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">
+        <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 {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.
+        </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>
+  );
+}

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

@@ -0,0 +1,39 @@
+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(acknowledged("s1")).toBe(false);
+  });
+
+  it("acknowledges a single session without affecting others", () => {
+    useStaleConversationGateStore.getState().acknowledge("s1");
+    expect(acknowledged("s1")).toBe(true);
+    expect(acknowledged("s2")).toBe(false);
+  });
+
+  it("replaces the Set immutably on acknowledge", () => {
+    const before =
+      useStaleConversationGateStore.getState().acknowledgedSessions;
+    useStaleConversationGateStore.getState().acknowledge("s1");
+    const after = useStaleConversationGateStore.getState().acknowledgedSessions;
+    expect(after).not.toBe(before);
+    expect(before.has("s1")).toBe(false);
+  });
+
+  it("is idempotent — acknowledging twice keeps the same reference", () => {
+    useStaleConversationGateStore.getState().acknowledge("s1");
+    const first = useStaleConversationGateStore.getState().acknowledgedSessions;
+    useStaleConversationGateStore.getState().acknowledge("s1");
+    const second =
+      useStaleConversationGateStore.getState().acknowledgedSessions;
+    expect(second).toBe(first);
+  });
+});