thaddeus 1.0.26 → 1.0.28

package/src/components/FeedbackSurvey/TranscriptSharePrompt.js

@@ -0,0 +1,84 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
+import React from 'react';
+import { BLACK_CIRCLE } from '../../constants/figures.js';
+import { Box, Text } from '../../ink.js';
+import { useDebouncedDigitInput } from './useDebouncedDigitInput.js';
+const RESPONSE_INPUTS = ['1', '2', '3'];
+const inputToResponse = {
+    '1': 'yes',
+    '2': 'no',
+    '3': 'dont_ask_again'
+};
+const isValidResponseInput = (input) => RESPONSE_INPUTS.includes(input);
+export function TranscriptSharePrompt(t0) {
+    const $ = _c(11);
+    const { onSelect, inputValue, setInputValue } = t0;
+    let t1;
+    if ($[0] !== onSelect) {
+        t1 = digit => onSelect(inputToResponse[digit]);
+        $[0] = onSelect;
+        $[1] = t1;
+    }
+    else {
+        t1 = $[1];
+    }
+    let t2;
+    if ($[2] !== inputValue || $[3] !== setInputValue || $[4] !== t1) {
+        t2 = {
+            inputValue,
+            setInputValue,
+            isValidDigit: isValidResponseInput,
+            onDigit: t1
+        };
+        $[2] = inputValue;
+        $[3] = setInputValue;
+        $[4] = t1;
+        $[5] = t2;
+    }
+    else {
+        t2 = $[5];
+    }
+    useDebouncedDigitInput(t2);
+    let t3;
+    if ($[6] === Symbol.for("react.memo_cache_sentinel")) {
+        t3 = _jsxs(Box, { children: [_jsxs(Text, { color: "ansi:cyan", children: [BLACK_CIRCLE, " "] }), _jsx(Text, { bold: true, children: "Can Delphi Labs look at your session transcript to help us improve Thaddeus?" })] });
+        $[6] = t3;
+    }
+    else {
+        t3 = $[6];
+    }
+    let t4;
+    if ($[7] === Symbol.for("react.memo_cache_sentinel")) {
+        t4 = _jsx(Box, { marginLeft: 2, children: _jsx(Text, { dimColor: true, children: "Learn more: https://delphilabsinc.com/thaddeus/docs/en/data-usage#session-quality-surveys" }) });
+        $[7] = t4;
+    }
+    else {
+        t4 = $[7];
+    }
+    let t5;
+    if ($[8] === Symbol.for("react.memo_cache_sentinel")) {
+        t5 = _jsx(Box, { width: 10, children: _jsxs(Text, { children: [_jsx(Text, { color: "ansi:cyan", children: "1" }), ": Yes"] }) });
+        $[8] = t5;
+    }
+    else {
+        t5 = $[8];
+    }
+    let t6;
+    if ($[9] === Symbol.for("react.memo_cache_sentinel")) {
+        t6 = _jsx(Box, { width: 10, children: _jsxs(Text, { children: [_jsx(Text, { color: "ansi:cyan", children: "2" }), ": No"] }) });
+        $[9] = t6;
+    }
+    else {
+        t6 = $[9];
+    }
+    let t7;
+    if ($[10] === Symbol.for("react.memo_cache_sentinel")) {
+        t7 = _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [t3, t4, _jsxs(Box, { marginLeft: 2, children: [t5, t6, _jsx(Box, { children: _jsxs(Text, { children: [_jsx(Text, { color: "ansi:cyan", children: "3" }), ": Don't ask again"] }) })] })] });
+        $[10] = t7;
+    }
+    else {
+        t7 = $[10];
+    }
+    return t7;
+}

package/src/components/FeedbackSurvey/submitTranscriptShare.js

@@ -0,0 +1,10 @@
+// THADDEUS: Transcript sharing disabled. Do not send transcripts to Anthropic.
+/**
+ * Submit a transcript share to Anthropic.
+ *
+ * THADDEUS: No-op — do not send transcripts to api.delphilabsinc.com.
+ */
+export async function submitTranscriptShare(_messages, _trigger, _appearanceId) {
+    // THADDEUS: No-op — transcript sharing disabled
+    return { success: false };
+}

package/src/components/FeedbackSurvey/useDebouncedDigitInput.js

@@ -0,0 +1,51 @@
+import { useEffect, useRef } from 'react';
+import { normalizeFullWidthDigits } from '../../utils/stringUtils.js';
+// Delay before accepting a digit as a response, to prevent accidental
+// submissions when users start messages with numbers (e.g., numbered lists).
+// Short enough to feel instant for intentional presses, long enough to
+// cancel when the user types more characters.
+const DEFAULT_DEBOUNCE_MS = 400;
+/**
+ * Detects when the user types a single valid digit into the prompt input,
+ * debounces to avoid accidental submissions (e.g., "1. First item"),
+ * trims the digit from the input, and fires a callback.
+ *
+ * Used by survey components that accept numeric responses typed directly
+ * into the main prompt input.
+ */
+export function useDebouncedDigitInput({ inputValue, setInputValue, isValidDigit, onDigit, enabled = true, once = false, debounceMs = DEFAULT_DEBOUNCE_MS, }) {
+    const initialInputValue = useRef(inputValue);
+    const hasTriggeredRef = useRef(false);
+    const debounceRef = useRef(null);
+    // Latest-ref pattern so callers can pass inline callbacks without causing
+    // the effect to re-run (which would reset the debounce timer every render).
+    const callbacksRef = useRef({ setInputValue, isValidDigit, onDigit });
+    callbacksRef.current = { setInputValue, isValidDigit, onDigit };
+    useEffect(() => {
+        if (!enabled || (once && hasTriggeredRef.current)) {
+            return;
+        }
+        if (debounceRef.current !== null) {
+            clearTimeout(debounceRef.current);
+            debounceRef.current = null;
+        }
+        if (inputValue !== initialInputValue.current) {
+            const lastChar = normalizeFullWidthDigits(inputValue.slice(-1));
+            if (callbacksRef.current.isValidDigit(lastChar)) {
+                const trimmed = inputValue.slice(0, -1);
+                debounceRef.current = setTimeout((debounceRef, hasTriggeredRef, callbacksRef, trimmed, lastChar) => {
+                    debounceRef.current = null;
+                    hasTriggeredRef.current = true;
+                    callbacksRef.current.setInputValue(trimmed);
+                    callbacksRef.current.onDigit(lastChar);
+                }, debounceMs, debounceRef, hasTriggeredRef, callbacksRef, trimmed, lastChar);
+            }
+        }
+        return () => {
+            if (debounceRef.current !== null) {
+                clearTimeout(debounceRef.current);
+                debounceRef.current = null;
+            }
+        };
+    }, [inputValue, enabled, once, debounceMs]);
+}

package/src/components/FeedbackSurvey/useFeedbackSurvey.js

@@ -0,0 +1,258 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { useDynamicConfig } from 'src/hooks/useDynamicConfig.js';
+import { isFeedbackSurveyDisabled } from 'src/services/analytics/config.js';
+import { logEvent } from 'src/services/analytics/index.js';
+import { isPolicyAllowed } from '../../services/policyLimits/index.js';
+import { getGlobalConfig, saveGlobalConfig } from '../../utils/config.js';
+import { isEnvTruthy } from '../../utils/envUtils.js';
+import { getLastAssistantMessage } from '../../utils/messages.js';
+import { getMainLoopModel } from '../../utils/model/model.js';
+import { getInitialSettings } from '../../utils/settings/settings.js';
+import { logOTelEvent } from '../../utils/telemetry/events.js';
+import { submitTranscriptShare } from './submitTranscriptShare.js';
+import { useSurveyState } from './useSurveyState.js';
+const DEFAULT_FEEDBACK_SURVEY_CONFIG = {
+    minTimeBeforeFeedbackMs: 600000,
+    minTimeBetweenFeedbackMs: 3600000,
+    minTimeBetweenGlobalFeedbackMs: 100000000,
+    minUserTurnsBeforeFeedback: 5,
+    minUserTurnsBetweenFeedback: 10,
+    hideThanksAfterMs: 3000,
+    onForModels: ['*'],
+    probability: 0.005
+};
+const DEFAULT_TRANSCRIPT_ASK_CONFIG = {
+    probability: 0
+};
+export function useFeedbackSurvey(messages, isLoading, submitCount, surveyType = 'session', hasActivePrompt = false) {
+    const lastAssistantMessageIdRef = useRef('unknown');
+    lastAssistantMessageIdRef.current = getLastAssistantMessage(messages)?.message?.id || 'unknown';
+    const [feedbackSurvey, setFeedbackSurvey] = useState(() => ({
+        timeLastShown: null,
+        submitCountAtLastAppearance: null
+    }));
+    const config = useDynamicConfig('thaddeus_feedback_survey_config', DEFAULT_FEEDBACK_SURVEY_CONFIG);
+    const badTranscriptAskConfig = useDynamicConfig('thaddeus_bad_survey_transcript_ask_config', DEFAULT_TRANSCRIPT_ASK_CONFIG);
+    const goodTranscriptAskConfig = useDynamicConfig('thaddeus_good_survey_transcript_ask_config', DEFAULT_TRANSCRIPT_ASK_CONFIG);
+    const settingsRate = getInitialSettings().feedbackSurveyRate;
+    const sessionStartTime = useRef(Date.now());
+    const submitCountAtSessionStart = useRef(submitCount);
+    const submitCountRef = useRef(submitCount);
+    submitCountRef.current = submitCount;
+    const messagesRef = useRef(messages);
+    messagesRef.current = messages;
+    // Probability gate: roll once when eligibility conditions are met, not on every
+    // useMemo re-evaluation. Without this, each dependency change (submitCount,
+    // isLoading toggle, etc.) re-rolls Math.random(), making the survey almost
+    // certain to appear after enough renders.
+    const probabilityPassedRef = useRef(false);
+    const lastEligibleSubmitCountRef = useRef(null);
+    const updateLastShownTime = useCallback((timestamp, submitCountValue) => {
+        setFeedbackSurvey(prev => {
+            if (prev.timeLastShown === timestamp && prev.submitCountAtLastAppearance === submitCountValue) {
+                return prev;
+            }
+            return {
+                timeLastShown: timestamp,
+                submitCountAtLastAppearance: submitCountValue
+            };
+        });
+        // Persist cross-session pacing state (previously done by onChangeAppState observer)
+        if (getGlobalConfig().feedbackSurveyState?.lastShownTime !== timestamp) {
+            saveGlobalConfig(current => ({
+                ...current,
+                feedbackSurveyState: {
+                    lastShownTime: timestamp
+                }
+            }));
+        }
+    }, []);
+    const onOpen = useCallback((appearanceId) => {
+        updateLastShownTime(Date.now(), submitCountRef.current);
+        logEvent('thaddeus_feedback_survey_event', {
+            event_type: 'appeared',
+            appearance_id: appearanceId,
+            last_assistant_message_id: lastAssistantMessageIdRef.current,
+            survey_type: surveyType
+        });
+        void logOTelEvent('feedback_survey', {
+            event_type: 'appeared',
+            appearance_id: appearanceId,
+            survey_type: surveyType
+        });
+    }, [updateLastShownTime, surveyType]);
+    const onSelect = useCallback((appearanceId_0, selected) => {
+        updateLastShownTime(Date.now(), submitCountRef.current);
+        logEvent('thaddeus_feedback_survey_event', {
+            event_type: 'responded',
+            appearance_id: appearanceId_0,
+            response: selected,
+            last_assistant_message_id: lastAssistantMessageIdRef.current,
+            survey_type: surveyType
+        });
+        void logOTelEvent('feedback_survey', {
+            event_type: 'responded',
+            appearance_id: appearanceId_0,
+            response: selected,
+            survey_type: surveyType
+        });
+    }, [updateLastShownTime, surveyType]);
+    const shouldShowTranscriptPrompt = useCallback((selected_0) => {
+        // Only bad and good ratings trigger the transcript ask
+        if (selected_0 !== 'bad' && selected_0 !== 'good') {
+            return false;
+        }
+        // Don't show if user previously chose "Don't ask again"
+        if (getGlobalConfig().transcriptShareDismissed) {
+            return false;
+        }
+        // Don't show if product feedback is blocked by org policy (ZDR)
+        if (!isPolicyAllowed('allow_product_feedback')) {
+            return false;
+        }
+        // Probability gate from GrowthBook config (separate per rating)
+        const probability = selected_0 === 'bad' ? badTranscriptAskConfig.probability : goodTranscriptAskConfig.probability;
+        return Math.random() <= probability;
+    }, [badTranscriptAskConfig.probability, goodTranscriptAskConfig.probability]);
+    const onTranscriptPromptShown = useCallback((appearanceId_1, surveyResponse) => {
+        const trigger = surveyResponse === 'good' ? 'good_feedback_survey' : 'bad_feedback_survey';
+        logEvent('thaddeus_feedback_survey_event', {
+            event_type: 'transcript_prompt_appeared',
+            appearance_id: appearanceId_1,
+            last_assistant_message_id: lastAssistantMessageIdRef.current,
+            survey_type: surveyType,
+            trigger: trigger
+        });
+        void logOTelEvent('feedback_survey', {
+            event_type: 'transcript_prompt_appeared',
+            appearance_id: appearanceId_1,
+            survey_type: surveyType
+        });
+    }, [surveyType]);
+    const onTranscriptSelect = useCallback(async (appearanceId_2, selected_1, surveyResponse_0) => {
+        const trigger_0 = surveyResponse_0 === 'good' ? 'good_feedback_survey' : 'bad_feedback_survey';
+        logEvent('thaddeus_feedback_survey_event', {
+            event_type: `transcript_share_${selected_1}`,
+            appearance_id: appearanceId_2,
+            last_assistant_message_id: lastAssistantMessageIdRef.current,
+            survey_type: surveyType,
+            trigger: trigger_0
+        });
+        if (selected_1 === 'dont_ask_again') {
+            saveGlobalConfig(current_0 => ({
+                ...current_0,
+                transcriptShareDismissed: true
+            }));
+        }
+        if (selected_1 === 'yes') {
+            const result = await submitTranscriptShare(messagesRef.current, trigger_0, appearanceId_2);
+            logEvent('thaddeus_feedback_survey_event', {
+                event_type: (result.success ? 'transcript_share_submitted' : 'transcript_share_failed'),
+                appearance_id: appearanceId_2,
+                trigger: trigger_0
+            });
+            return result.success;
+        }
+        return false;
+    }, [surveyType]);
+    const { state, lastResponse, open, handleSelect, handleTranscriptSelect } = useSurveyState({
+        hideThanksAfterMs: config.hideThanksAfterMs,
+        onOpen,
+        onSelect,
+        shouldShowTranscriptPrompt,
+        onTranscriptPromptShown,
+        onTranscriptSelect
+    });
+    const currentModel = getMainLoopModel();
+    const isModelAllowed = useMemo(() => {
+        if (config.onForModels.length === 0) {
+            return false;
+        }
+        if (config.onForModels.includes('*')) {
+            return true;
+        }
+        return config.onForModels.includes(currentModel);
+    }, [config.onForModels, currentModel]);
+    const shouldOpen = useMemo(() => {
+        if (state !== 'closed') {
+            return false;
+        }
+        if (isLoading) {
+            return false;
+        }
+        // Don't show survey when permission or ask question prompts are visible
+        if (hasActivePrompt) {
+            return false;
+        }
+        // Force display for testing
+        if (process.env.CLAUDE_FORCE_DISPLAY_SURVEY && !feedbackSurvey.timeLastShown) {
+            return true;
+        }
+        if (!isModelAllowed) {
+            return false;
+        }
+        if (isEnvTruthy(process.env.THADDEUS_DISABLE_FEEDBACK_SURVEY)) {
+            return false;
+        }
+        if (isFeedbackSurveyDisabled()) {
+            return false;
+        }
+        // Check if product feedback is allowed by org policy
+        if (!isPolicyAllowed('allow_product_feedback')) {
+            return false;
+        }
+        // Check session-local pacing
+        if (feedbackSurvey.timeLastShown) {
+            // Check time elapsed since last appearance in this session
+            const timeSinceLastShown = Date.now() - feedbackSurvey.timeLastShown;
+            if (timeSinceLastShown < config.minTimeBetweenFeedbackMs) {
+                return false;
+            }
+            // Check user turn requirement for subsequent appearances
+            if (feedbackSurvey.submitCountAtLastAppearance !== null && submitCount < feedbackSurvey.submitCountAtLastAppearance + config.minUserTurnsBetweenFeedback) {
+                return false;
+            }
+        }
+        else {
+            // First appearance in this session
+            const timeSinceSessionStart = Date.now() - sessionStartTime.current;
+            if (timeSinceSessionStart < config.minTimeBeforeFeedbackMs) {
+                return false;
+            }
+            if (submitCount < submitCountAtSessionStart.current + config.minUserTurnsBeforeFeedback) {
+                return false;
+            }
+        }
+        // Probability check: roll once per eligibility window to avoid re-rolling
+        // on every useMemo re-evaluation (which would make triggering near-certain).
+        if (lastEligibleSubmitCountRef.current !== submitCount) {
+            lastEligibleSubmitCountRef.current = submitCount;
+            probabilityPassedRef.current = Math.random() <= (settingsRate ?? config.probability);
+        }
+        if (!probabilityPassedRef.current) {
+            return false;
+        }
+        // Check global pacing (across all sessions)
+        // Leave this till last because it reads from the filesystem which is expensive.
+        const globalFeedbackState = getGlobalConfig().feedbackSurveyState;
+        if (globalFeedbackState?.lastShownTime) {
+            const timeSinceGlobalLastShown = Date.now() - globalFeedbackState.lastShownTime;
+            if (timeSinceGlobalLastShown < config.minTimeBetweenGlobalFeedbackMs) {
+                return false;
+            }
+        }
+        return true;
+    }, [state, isLoading, hasActivePrompt, isModelAllowed, feedbackSurvey.timeLastShown, feedbackSurvey.submitCountAtLastAppearance, submitCount, config.minTimeBetweenFeedbackMs, config.minTimeBetweenGlobalFeedbackMs, config.minUserTurnsBetweenFeedback, config.minTimeBeforeFeedbackMs, config.minUserTurnsBeforeFeedback, config.probability, settingsRate]);
+    useEffect(() => {
+        if (shouldOpen) {
+            open();
+        }
+    }, [shouldOpen, open]);
+    return {
+        state,
+        lastResponse,
+        handleSelect,
+        handleTranscriptSelect
+    };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["useCallback","useEffect","useMemo","useRef","useState","useDynamicConfig","isFeedbackSurveyDisabled","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","isPolicyAllowed","Message","getGlobalConfig","saveGlobalConfig","isEnvTruthy","getLastAssistantMessage","getMainLoopModel","getInitialSettings","logOTelEvent","submitTranscriptShare","TranscriptShareTrigger","TranscriptShareResponse","useSurveyState","FeedbackSurveyResponse","FeedbackSurveyType","FeedbackSurveyConfig","minTimeBeforeFeedbackMs","minTimeBetweenFeedbackMs","minTimeBetweenGlobalFeedbackMs","minUserTurnsBeforeFeedback","minUserTurnsBetweenFeedback","hideThanksAfterMs","onForModels","probability","TranscriptAskConfig","DEFAULT_FEEDBACK_SURVEY_CONFIG","DEFAULT_TRANSCRIPT_ASK_CONFIG","useFeedbackSurvey","messages","isLoading","submitCount","surveyType","hasActivePrompt","state","lastResponse","handleSelect","selected","handleTranscriptSelect","lastAssistantMessageIdRef","current","message","id","feedbackSurvey","setFeedbackSurvey","timeLastShown","submitCountAtLastAppearance","config","badTranscriptAskConfig","goodTranscriptAskConfig","settingsRate","feedbackSurveyRate","sessionStartTime","Date","now","submitCountAtSessionStart","submitCountRef","messagesRef","probabilityPassedRef","lastEligibleSubmitCountRef","updateLastShownTime","timestamp","submitCountValue","prev","feedbackSurveyState","lastShownTime","onOpen","appearanceId","event_type","appearance_id","last_assistant_message_id","survey_type","onSelect","response","shouldShowTranscriptPrompt","transcriptShareDismissed","Math","random","onTranscriptPromptShown","surveyResponse","trigger","onTranscriptSelect","Promise","result","success","open","currentModel","isModelAllowed","length","includes","shouldOpen","process","env","CLAUDE_FORCE_DISPLAY_SURVEY","CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY","timeSinceLastShown","timeSinceSessionStart","globalFeedbackState","timeSinceGlobalLastShown"],"sources":["useFeedbackSurvey.tsx"],"sourcesContent":["import { useCallback, useEffect, useMemo, useRef, useState } from 'react'\nimport { useDynamicConfig } from 'src/hooks/useDynamicConfig.js'\nimport { isFeedbackSurveyDisabled } from 'src/services/analytics/config.js'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from 'src/services/analytics/index.js'\nimport { isPolicyAllowed } from '../../services/policyLimits/index.js'\nimport type { Message } from '../../types/message.js'\nimport { getGlobalConfig, saveGlobalConfig } from '../../utils/config.js'\nimport { isEnvTruthy } from '../../utils/envUtils.js'\nimport { getLastAssistantMessage } from '../../utils/messages.js'\nimport { getMainLoopModel } from '../../utils/model/model.js'\nimport { getInitialSettings } from '../../utils/settings/settings.js'\nimport { logOTelEvent } from '../../utils/telemetry/events.js'\nimport {\n  submitTranscriptShare,\n  type TranscriptShareTrigger,\n} from './submitTranscriptShare.js'\nimport type { TranscriptShareResponse } from './TranscriptSharePrompt.js'\nimport { useSurveyState } from './useSurveyState.js'\nimport type { FeedbackSurveyResponse, FeedbackSurveyType } from './utils.js'\n\ntype FeedbackSurveyConfig = {\n  minTimeBeforeFeedbackMs: number\n  minTimeBetweenFeedbackMs: number\n  minTimeBetweenGlobalFeedbackMs: number\n  minUserTurnsBeforeFeedback: number\n  minUserTurnsBetweenFeedback: number\n  hideThanksAfterMs: number\n  onForModels: string[]\n  probability: number\n}\n\ntype TranscriptAskConfig = {\n  probability: number\n}\n\nconst DEFAULT_FEEDBACK_SURVEY_CONFIG: FeedbackSurveyConfig = {\n  minTimeBeforeFeedbackMs: 600000,\n  minTimeBetweenFeedbackMs: 3600000,\n  minTimeBetweenGlobalFeedbackMs: 100000000,\n  minUserTurnsBeforeFeedback: 5,\n  minUserTurnsBetweenFeedback: 10,\n  hideThanksAfterMs: 3000,\n  onForModels: ['*'],\n  probability: 0.005,\n}\n\nconst DEFAULT_TRANSCRIPT_ASK_CONFIG: TranscriptAskConfig = {\n  probability: 0,\n}\n\nexport function useFeedbackSurvey(\n  messages: Message[],\n  isLoading: boolean,\n  submitCount: number,\n  surveyType: FeedbackSurveyType = 'session',\n  hasActivePrompt: boolean = false,\n): {\n  state:\n    | 'closed'\n    | 'open'\n    | 'thanks'\n    | 'transcript_prompt'\n    | 'submitting'\n    | 'submitted'\n  lastResponse: FeedbackSurveyResponse | null\n  handleSelect: (selected: FeedbackSurveyResponse) => boolean\n  handleTranscriptSelect: (selected: TranscriptShareResponse) => void\n} {\n  const lastAssistantMessageIdRef = useRef('unknown')\n  lastAssistantMessageIdRef.current =\n    getLastAssistantMessage(messages)?.message?.id || 'unknown'\n  const [feedbackSurvey, setFeedbackSurvey] = useState<{\n    timeLastShown: number | null\n    submitCountAtLastAppearance: number | null\n  }>(() => ({ timeLastShown: null, submitCountAtLastAppearance: null }))\n  const config = useDynamicConfig<FeedbackSurveyConfig>(\n    'tengu_feedback_survey_config',\n    DEFAULT_FEEDBACK_SURVEY_CONFIG,\n  )\n  const badTranscriptAskConfig = useDynamicConfig<TranscriptAskConfig>(\n    'tengu_bad_survey_transcript_ask_config',\n    DEFAULT_TRANSCRIPT_ASK_CONFIG,\n  )\n  const goodTranscriptAskConfig = useDynamicConfig<TranscriptAskConfig>(\n    'tengu_good_survey_transcript_ask_config',\n    DEFAULT_TRANSCRIPT_ASK_CONFIG,\n  )\n  const settingsRate = getInitialSettings().feedbackSurveyRate\n  const sessionStartTime = useRef(Date.now())\n  const submitCountAtSessionStart = useRef(submitCount)\n  const submitCountRef = useRef(submitCount)\n  submitCountRef.current = submitCount\n  const messagesRef = useRef(messages)\n  messagesRef.current = messages\n  // Probability gate: roll once when eligibility conditions are met, not on every\n  // useMemo re-evaluation. Without this, each dependency change (submitCount,\n  // isLoading toggle, etc.) re-rolls Math.random(), making the survey almost\n  // certain to appear after enough renders.\n  const probabilityPassedRef = useRef(false)\n  const lastEligibleSubmitCountRef = useRef<number | null>(null)\n\n  const updateLastShownTime = useCallback(\n    (timestamp: number, submitCountValue: number) => {\n      setFeedbackSurvey(prev => {\n        if (\n          prev.timeLastShown === timestamp &&\n          prev.submitCountAtLastAppearance === submitCountValue\n        ) {\n          return prev\n        }\n        return {\n          timeLastShown: timestamp,\n          submitCountAtLastAppearance: submitCountValue,\n        }\n      })\n      // Persist cross-session pacing state (previously done by onChangeAppState observer)\n      if (getGlobalConfig().feedbackSurveyState?.lastShownTime !== timestamp) {\n        saveGlobalConfig(current => ({\n          ...current,\n          feedbackSurveyState: {\n            lastShownTime: timestamp,\n          },\n        }))\n      }\n    },\n    [],\n  )\n\n  const onOpen = useCallback(\n    (appearanceId: string) => {\n      updateLastShownTime(Date.now(), submitCountRef.current)\n      logEvent('tengu_feedback_survey_event', {\n        event_type:\n          'appeared' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        appearance_id:\n          appearanceId as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        last_assistant_message_id:\n          lastAssistantMessageIdRef.current as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        survey_type:\n          surveyType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n      void logOTelEvent('feedback_survey', {\n        event_type: 'appeared',\n        appearance_id: appearanceId,\n        survey_type: surveyType,\n      })\n    },\n    [updateLastShownTime, surveyType],\n  )\n\n  const onSelect = useCallback(\n    (appearanceId: string, selected: FeedbackSurveyResponse) => {\n      updateLastShownTime(Date.now(), submitCountRef.current)\n      logEvent('tengu_feedback_survey_event', {\n        event_type:\n          'responded' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        appearance_id:\n          appearanceId as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        response:\n          selected as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        last_assistant_message_id:\n          lastAssistantMessageIdRef.current as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        survey_type:\n          surveyType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n      void logOTelEvent('feedback_survey', {\n        event_type: 'responded',\n        appearance_id: appearanceId,\n        response: selected,\n        survey_type: surveyType,\n      })\n    },\n    [updateLastShownTime, surveyType],\n  )\n\n  const shouldShowTranscriptPrompt = useCallback(\n    (selected: FeedbackSurveyResponse) => {\n      // Only bad and good ratings trigger the transcript ask\n      if (selected !== 'bad' && selected !== 'good') {\n        return false\n      }\n\n      // Don't show if user previously chose \"Don't ask again\"\n      if (getGlobalConfig().transcriptShareDismissed) {\n        return false\n      }\n\n      // Don't show if product feedback is blocked by org policy (ZDR)\n      if (!isPolicyAllowed('allow_product_feedback')) {\n        return false\n      }\n\n      // Probability gate from GrowthBook config (separate per rating)\n      const probability =\n        selected === 'bad'\n          ? badTranscriptAskConfig.probability\n          : goodTranscriptAskConfig.probability\n      return Math.random() <= probability\n    },\n    [badTranscriptAskConfig.probability, goodTranscriptAskConfig.probability],\n  )\n\n  const onTranscriptPromptShown = useCallback(\n    (appearanceId: string, surveyResponse: FeedbackSurveyResponse) => {\n      const trigger: TranscriptShareTrigger =\n        surveyResponse === 'good'\n          ? 'good_feedback_survey'\n          : 'bad_feedback_survey'\n      logEvent('tengu_feedback_survey_event', {\n        event_type:\n          'transcript_prompt_appeared' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        appearance_id:\n          appearanceId as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        last_assistant_message_id:\n          lastAssistantMessageIdRef.current as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        survey_type:\n          surveyType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        trigger:\n          trigger as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n      void logOTelEvent('feedback_survey', {\n        event_type: 'transcript_prompt_appeared',\n        appearance_id: appearanceId,\n        survey_type: surveyType,\n      })\n    },\n    [surveyType],\n  )\n\n  const onTranscriptSelect = useCallback(\n    async (\n      appearanceId: string,\n      selected: TranscriptShareResponse,\n      surveyResponse: FeedbackSurveyResponse | null,\n    ): Promise<boolean> => {\n      const trigger: TranscriptShareTrigger =\n        surveyResponse === 'good'\n          ? 'good_feedback_survey'\n          : 'bad_feedback_survey'\n\n      logEvent('tengu_feedback_survey_event', {\n        event_type:\n          `transcript_share_${selected}` as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        appearance_id:\n          appearanceId as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        last_assistant_message_id:\n          lastAssistantMessageIdRef.current as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        survey_type:\n          surveyType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        trigger:\n          trigger as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n\n      if (selected === 'dont_ask_again') {\n        saveGlobalConfig(current => ({\n          ...current,\n          transcriptShareDismissed: true,\n        }))\n      }\n\n      if (selected === 'yes') {\n        const result = await submitTranscriptShare(\n          messagesRef.current,\n          trigger,\n          appearanceId,\n        )\n        logEvent('tengu_feedback_survey_event', {\n          event_type: (result.success\n            ? 'transcript_share_submitted'\n            : 'transcript_share_failed') as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          appearance_id:\n            appearanceId as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          trigger:\n            trigger as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        })\n        return result.success\n      }\n\n      return false\n    },\n    [surveyType],\n  )\n\n  const { state, lastResponse, open, handleSelect, handleTranscriptSelect } =\n    useSurveyState({\n      hideThanksAfterMs: config.hideThanksAfterMs,\n      onOpen,\n      onSelect,\n      shouldShowTranscriptPrompt,\n      onTranscriptPromptShown,\n      onTranscriptSelect,\n    })\n\n  const currentModel = getMainLoopModel()\n  const isModelAllowed = useMemo(() => {\n    if (config.onForModels.length === 0) {\n      return false\n    }\n    if (config.onForModels.includes('*')) {\n      return true\n    }\n    return config.onForModels.includes(currentModel)\n  }, [config.onForModels, currentModel])\n\n  const shouldOpen = useMemo(() => {\n    if (state !== 'closed') {\n      return false\n    }\n\n    if (isLoading) {\n      return false\n    }\n\n    // Don't show survey when permission or ask question prompts are visible\n    if (hasActivePrompt) {\n      return false\n    }\n\n    // Force display for testing\n    if (\n      process.env.CLAUDE_FORCE_DISPLAY_SURVEY &&\n      !feedbackSurvey.timeLastShown\n    ) {\n      return true\n    }\n\n    if (!isModelAllowed) {\n      return false\n    }\n\n    if (isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY)) {\n      return false\n    }\n\n    if (isFeedbackSurveyDisabled()) {\n      return false\n    }\n\n    // Check if product feedback is allowed by org policy\n    if (!isPolicyAllowed('allow_product_feedback')) {\n      return false\n    }\n\n    // Check session-local pacing\n    if (feedbackSurvey.timeLastShown) {\n      // Check time elapsed since last appearance in this session\n      const timeSinceLastShown = Date.now() - feedbackSurvey.timeLastShown\n      if (timeSinceLastShown < config.minTimeBetweenFeedbackMs) {\n        return false\n      }\n      // Check user turn requirement for subsequent appearances\n      if (\n        feedbackSurvey.submitCountAtLastAppearance !== null &&\n        submitCount <\n          feedbackSurvey.submitCountAtLastAppearance +\n            config.minUserTurnsBetweenFeedback\n      ) {\n        return false\n      }\n    } else {\n      // First appearance in this session\n      const timeSinceSessionStart = Date.now() - sessionStartTime.current\n      if (timeSinceSessionStart < config.minTimeBeforeFeedbackMs) {\n        return false\n      }\n      if (\n        submitCount <\n        submitCountAtSessionStart.current + config.minUserTurnsBeforeFeedback\n      ) {\n        return false\n      }\n    }\n\n    // Probability check: roll once per eligibility window to avoid re-rolling\n    // on every useMemo re-evaluation (which would make triggering near-certain).\n    if (lastEligibleSubmitCountRef.current !== submitCount) {\n      lastEligibleSubmitCountRef.current = submitCount\n      probabilityPassedRef.current =\n        Math.random() <= (settingsRate ?? config.probability)\n    }\n    if (!probabilityPassedRef.current) {\n      return false\n    }\n\n    // Check global pacing (across all sessions)\n    // Leave this till last because it reads from the filesystem which is expensive.\n    const globalFeedbackState = getGlobalConfig().feedbackSurveyState\n    if (globalFeedbackState?.lastShownTime) {\n      const timeSinceGlobalLastShown =\n        Date.now() - globalFeedbackState.lastShownTime\n      if (timeSinceGlobalLastShown < config.minTimeBetweenGlobalFeedbackMs) {\n        return false\n      }\n    }\n\n    return true\n  }, [\n    state,\n    isLoading,\n    hasActivePrompt,\n    isModelAllowed,\n    feedbackSurvey.timeLastShown,\n    feedbackSurvey.submitCountAtLastAppearance,\n    submitCount,\n    config.minTimeBetweenFeedbackMs,\n    config.minTimeBetweenGlobalFeedbackMs,\n    config.minUserTurnsBetweenFeedback,\n    config.minTimeBeforeFeedbackMs,\n    config.minUserTurnsBeforeFeedback,\n    config.probability,\n    settingsRate,\n  ])\n\n  useEffect(() => {\n    if (shouldOpen) {\n      open()\n    }\n  }, [shouldOpen, open])\n\n  return { state, lastResponse, handleSelect, handleTranscriptSelect }\n}\n"],"mappings":"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","ignoreList":[]}

package/src/components/FeedbackSurvey/useFrustrationDetection.js

@@ -0,0 +1,8 @@
+// useFrustrationDetection — ant-only frustration detection hook
+// Stub: always returns closed state.
+export function useFrustrationDetection() {
+    return {
+        state: 'closed',
+        handleTranscriptSelect: () => { },
+    };
+}