fix: address qa-swarm review on the stale-conversation gate

- suppress "Compact and continue" while a permission is pending (a
  queued /compact would land after the permission resumes the costly
  turn, paying the reload twice)
- guard the compact choice on connectivity so the gate is not released
  when the send cannot happen
- wait for isRunning before showing the notice so choices cannot fire
  into a session that is still reconnecting
- track which of the three options staff pick (typed analytics event)
- let Escape bubble out of ActionSelector when there is no onCancel
- explicit new-session branch in the notice dispatch, cost parenthetical
  moved next to the pricing sentence, comment on the active derivation

Generated-By: PostHog Code
Task-Id: 1ec8e82e-b126-48b8-8fd4-54edcaf041d5

Author: pauldambra

packages/shared/src/analytics-events.ts

@@ -135,6 +135,12 @@ export interface PromptSentProperties {
   prompt_length_chars: number;
 }
 
+export interface StaleConversationGateChoiceProperties {
+  choice: "compact" | "continue" | "new_session";
+  used_tokens: number;
+  cost_usd: number | null;
+}
+
 // Git operations
 export interface GitActionExecutedProperties {
   action_type: GitActionType;
@@ -1005,6 +1011,7 @@ export const ANALYTICS_EVENTS = {
   TASK_RUN_COMPLETED: "Task run completed",
   TASK_RUN_CANCELLED: "Task run cancelled",
   PROMPT_SENT: "Prompt sent",
+  STALE_CONVERSATION_GATE_CHOICE: "Stale conversation gate choice",
 
   // Claude Code session import
   CLAUDE_SESSIONS_SHOWN: "Claude Code sessions shown",
@@ -1159,6 +1166,7 @@ export type EventPropertyMap = {
   [ANALYTICS_EVENTS.TASK_RUN_COMPLETED]: TaskRunCompletedProperties;
   [ANALYTICS_EVENTS.TASK_RUN_CANCELLED]: TaskRunCancelledProperties;
   [ANALYTICS_EVENTS.PROMPT_SENT]: PromptSentProperties;
+  [ANALYTICS_EVENTS.STALE_CONVERSATION_GATE_CHOICE]: StaleConversationGateChoiceProperties;
 
   // Claude Code session import
   [ANALYTICS_EVENTS.CLAUDE_SESSIONS_SHOWN]: ClaudeSessionsShownProperties;

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

@@ -5,7 +5,7 @@ import {
   type SessionService,
 } from "@posthog/core/sessions/sessionService";
 import { useService } from "@posthog/di/react";
-import type { AcpMessage } from "@posthog/shared";
+import { type AcpMessage, ANALYTICS_EVENTS } from "@posthog/shared";
 import type { Task, TaskRunStatus } from "@posthog/shared/domain-types";
 import { showOfflineToast } from "@posthog/ui/features/connectivity/connectivityToast";
 import {
@@ -52,6 +52,7 @@ import { useSettingsStore } from "@posthog/ui/features/settings/settingsStore";
 import { useIsWorkspaceCloudRun } from "@posthog/ui/features/workspace/useWorkspace";
 import { useConnectivity } from "@posthog/ui/hooks/useConnectivity";
 import { toast } from "@posthog/ui/primitives/toast";
+import { track } from "@posthog/ui/shell/analytics";
 import {
   pendingTaskPromptStoreApi,
   usePendingTaskPrompt,
@@ -271,10 +272,38 @@ export function SessionView({
   // prompt cache has likely expired (see useStaleConversationGate).
   const staleGate = useStaleConversationGate(sessionId, events);
 
+  const trackStaleGateChoice = useCallback(
+    (choice: "compact" | "continue" | "new_session") =>
+      track(ANALYTICS_EVENTS.STALE_CONVERSATION_GATE_CHOICE, {
+        choice,
+        used_tokens: staleGate.usedTokens,
+        cost_usd: staleGate.costUsd,
+      }),
+    [staleGate.usedTokens, staleGate.costUsd],
+  );
+
   const handleStaleCompact = useCallback(() => {
+    if (!isOnline) {
+      showOfflineToast();
+      return;
+    }
+    trackStaleGateChoice("compact");
     staleGate.onContinue();
     onSendPrompt("/compact");
-  }, [staleGate.onContinue, onSendPrompt]);
+  }, [isOnline, trackStaleGateChoice, staleGate.onContinue, onSendPrompt]);
+
+  const handleStaleContinue = useCallback(() => {
+    trackStaleGateChoice("continue");
+    staleGate.onContinue();
+  }, [trackStaleGateChoice, staleGate.onContinue]);
+
+  const handleStaleNewSession = useMemo(() => {
+    if (!onNewSession) return undefined;
+    return () => {
+      trackStaleGateChoice("new_session");
+      onNewSession();
+    };
+  }, [trackStaleGateChoice, onNewSession]);
 
   const [isDraggingFile, setIsDraggingFile] = useState(false);
   const editorRef = useRef<PromptInputHandle>(null);
@@ -577,9 +606,11 @@ export function SessionView({
                       )}
                     </Flex>
                   </Flex>
-                ) : hideInput ? null : staleGate.active ? (
+                ) : hideInput ? null : staleGate.active && isRunning ? (
                   // Replaces the composer (and any pending permission — answering
                   // one also resumes the costly turn) until the user chooses.
+                  // Waits for isRunning so the choices can't fire into a session
+                  // that is still reconnecting.
                   <Box className="min-h-0 shrink-0 overflow-y-auto">
                     <Box
                       className={compact ? "p-1" : "mx-auto px-2 pb-3"}
@@ -593,9 +624,16 @@ export function SessionView({
                         usedTokens={staleGate.usedTokens}
                         lastActivityAt={staleGate.lastActivityAt}
                         costUsd={staleGate.costUsd}
-                        onContinue={staleGate.onContinue}
-                        onCompact={handleStaleCompact}
-                        onNewSession={onNewSession}
+                        onContinue={handleStaleContinue}
+                        // A queued /compact would land after the pending
+                        // permission resumes the costly turn — paying the
+                        // reload twice — so the option hides until then.
+                        onCompact={
+                          firstPendingPermission
+                            ? undefined
+                            : handleStaleCompact
+                        }
+                        onNewSession={handleStaleNewSession}
                       />
                     </Box>
                   </Box>

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

@@ -12,8 +12,12 @@ interface StaleConversationCostNoticeProps {
   /** Cumulative session cost so far, when the gateway reports it. */
   costUsd: number | null;
   onContinue: () => void;
-  /** Compact the thread: pay the reload once, then every later turn is smaller. */
-  onCompact: () => void;
+  /**
+   * Compact the thread: pay the reload once, then every later turn is
+   * smaller. Omitted while a permission is pending — a queued /compact would
+   * land after answering it, paying the reload twice.
+   */
+  onCompact?: () => void;
   onNewSession?: () => void;
 }
 
@@ -40,13 +44,18 @@ export function StaleConversationCostNotice({
   return (
     <ActionSelector
       title="Continue this large, idle conversation?"
-      question={`This conversation holds about ${formatTokensCompact(usedTokens)} tokens and ${activity}${spent}. Its prompt cache has likely expired, so the next message re-processes everything at full input price instead of the ~10% cached rate. How do you want to continue?`}
+      question={`This conversation holds about ${formatTokensCompact(usedTokens)} tokens and ${activity}. Its prompt cache has likely expired, so the next message re-processes everything at full input price instead of the ~10% cached rate${spent}. How do you want to continue?`}
       options={[
-        {
-          id: COMPACT_OPTION,
-          label: "Compact and continue",
-          description: "Pays the reload once, then every later turn is cheaper",
-        },
+        ...(onCompact
+          ? [
+              {
+                id: COMPACT_OPTION,
+                label: "Compact and continue",
+                description:
+                  "Pays the reload once, then every later turn is cheaper",
+              },
+            ]
+          : []),
         {
           id: CONTINUE_OPTION,
           label: "Continue anyway",
@@ -63,9 +72,9 @@ export function StaleConversationCostNotice({
           : []),
       ]}
       onSelect={(optionId) => {
-        if (optionId === COMPACT_OPTION) onCompact();
+        if (optionId === COMPACT_OPTION) onCompact?.();
         else if (optionId === CONTINUE_OPTION) onContinue();
-        else onNewSession?.();
+        else if (optionId === NEW_SESSION_OPTION) onNewSession?.();
       }}
     />
   );

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

@@ -66,6 +66,9 @@ export function useStaleConversationGate(
   );
 
   return {
+    // shouldEngage covers the first paint before the effect latches;
+    // engagement covers every render after (reconnect events flip
+    // shouldEngage back off — see the hook doc).
     active: shouldEngage || engagement !== undefined,
     usedTokens,
     lastActivityAt: engagement ? engagement.lastActivityAt : liveLastActivityAt,

packages/ui/src/primitives/action-selector/ActionSelector.tsx

@@ -102,18 +102,25 @@ export function ActionSelector({
     hasSteps,
     showSubmitButton,
     multiSelect,
+    hasCancel: onCancel !== undefined,
   });
   stateRef.current = {
     showInlineEdit,
     hasSteps,
     showSubmitButton,
     multiSelect,
+    hasCancel: onCancel !== undefined,
   };
 
   useEffect(() => {
     const handler = (e: KeyboardEvent) => {
-      const { showInlineEdit, hasSteps, showSubmitButton, multiSelect } =
-        stateRef.current;
+      const {
+        showInlineEdit,
+        hasSteps,
+        showSubmitButton,
+        multiSelect,
+        hasCancel,
+      } = stateRef.current;
       const h = handlersRef.current;
 
       if (showInlineEdit || document.activeElement?.tagName === "TEXTAREA")
@@ -179,6 +186,8 @@ export function ActionSelector({
           }
           break;
         case "Escape":
+          // Nothing to cancel — let Escape bubble instead of swallowing it.
+          if (!hasCancel) break;
           e.preventDefault();
           e.stopPropagation();
           h.handleCancel();