thatgfsj-code 3.0.2 → 3.0.4

package/src/cache/smartModel.ts

@@ -1,24 +1,35 @@
 /**
- * Smart-model routing (P3 of the Reasonix plan).
- *
- * Idea: classify the user's input as "simple" or "complex" and route
- * simple queries to a cheaper / faster model while keeping the main model
- * for complex work. The classification is intentionally trivial — prompt
- * length + presence of recent tool calls — because the cost of a
- * misclassification (a slightly worse answer on a simple query) is much
- * lower than the cost of running a frontier model on every greeting.
- *
- * Trade-off: each routing decision adds one model swap (different
- * `model` field on the wire). If the cache prefix is keyed on the model
- * string, the cache miss rate can spike on every simple query. To keep
- * the prefix stable, callers should pass a *family* (e.g. "anthropic" or
- * "deepseek") rather than a specific model name when forwarding the
- * prompt to the downstream provider — that's outside the scope of this
- * hook; this module only answers the question "should I downgrade?".
- *
- * v3.0.0: shipped as a stub. Real decision logic is conservative
- * (downgrade only when prompt is short AND no recent tool activity).
- * Future iterations can add heuristic or classifier-based routing.
+ * Smart-model routing + auto TTL selection (P3 of the Reasonix plan,
+ * v3.0.3 onwards).
+ *
+ * Idea: classify the conversation as "short" / "medium" / "long" and
+ * route accordingly. Two levers:
+ *
+ *   1. Model downgrade
+ *      Short follow-ups ("yes", "thanks") → mini model
+ *      Tool-heavy turns → main model
+ *
+ *   2. Cache TTL
+ *      v3.0.4: default to 1h (long-task TTL). We cannot predict task
+ *      length at round 0, so we choose the TTL that cannot expire
+ *      mid-task. 5m is opt-in only (user pins it via /ttl 5m or the
+ *      init wizard).
+ *
+ * Why TTL is decided per-ROUND but CHANGES per-CONVERSATION:
+ *   The Anthropic cache_control marker is part of the request body.
+ *   Changing the TTL between rounds would push the wire bytes to a
+ *   different Anthropic cache bucket, blowing the cache on every round
+ *   and *costing* more in cache_creation_input_tokens than what we save.
+ *
+ *   So we compute the TTL once per conversation (lazily, on the first
+ *   round) and never change it. Subsequent rounds get the same TTL,
+ *   which keeps the cache prefix stable and lets Anthropic match it.
+ *
+ * Trade-off: 1h write costs 2x input price (vs 1.25x for 5m), but
+ * reads are the same 0.1x. A long task hitting cache 2-3 times pays
+ * back the extra write cost; a short task pays it once and moves on.
+ * That is strictly better than guessing 5m and having the cache expire
+ * mid-task.
  */
 
 import type { ChatMessage } from '../types.js';
@@ -30,6 +41,13 @@ export interface SmartModelDecision {
   reason: string;
 }
 
+export interface SmartTTLDecision {
+  ttl: '5m' | '1h';
+  reason: string;
+  /** Computed per-conversation. Once we pick a TTL, we keep it. */
+  isFirstDecision: boolean;
+}
+
 /**
  * Heuristic: downgrade when
  *   1. The latest user message is short (< 200 chars), AND
@@ -50,3 +68,66 @@ export function shouldDowngrade(messages: ChatMessage[], lastUserInput: string):
   }
   return { downgrade: true, reason: 'short-no-tools' };
 }
+
+/**
+ * Total character count of all message content. Used as a cheap
+ * proxy for "is this conversation long enough to justify 1h TTL?"
+ * (Anthropic charges cache_creation at 1.25x normal input, so we
+ * need to be sure the conversation will hit cache ~10+ times to
+ * break even on 1h vs 5m.)
+ */
+export function totalConversationChars(messages: ChatMessage[]): number {
+  let total = 0;
+  for (const m of messages) {
+    if (typeof m.content === 'string') {
+      total += m.content.length;
+    } else if (Array.isArray(m.content)) {
+      for (const blk of m.content) {
+        if (blk.type === 'text') total += (blk as any).text.length;
+      }
+    }
+  }
+  return total;
+}
+
+/**
+ * Decide the cache TTL for the current round.
+ *
+ * v3.0.4: The previous implementation tried to *predict* the task length
+ * from the conversation so far (short sessions → 5m, long → 1h). That
+ * was wrong: at the moment the decision is made (first round), the task
+ * hasn't started yet — there is no way to know whether it will be a
+ * 30-second question or a 3-hour refactor. Predicting 5m for a task
+ * that turns out to be long means the cache expires mid-task (5-minute
+ * TTL counts from the last HIT, and agent work often has >5m gaps while
+ * tools run / user reads output), so every round after the gap re-writes
+ * the whole prefix at full price.
+ *
+ * Correct rule: DEFAULT TO THE LONG TTL (1h) and don't guess.
+ *   - 1h costs 2x input price to WRITE (vs 1.25x for 5m), but reads are
+ *     the same 0.1x for both.
+ *   - A long task that hits cache even 2-3 times pays back the extra
+ *     write cost. A short task only pays the extra write once.
+ *   - Users who are SURE the session is short can pin 5m via
+ *     /ttl 5m or the init wizard — the default stays 1h.
+ *
+ * Stability rule (unchanged): once a TTL is chosen, it is reused for
+ * every subsequent round in the same session. Changing TTL between
+ * rounds would invalidate the Anthropic cache prefix and cost more
+ * than it saves.
+ *
+ * The `isFirstDecision` flag tells the caller whether to apply the
+ * decision (first round) or reuse the previous one (later rounds).
+ */
+export function decideTTL(
+  messages: ChatMessage[],
+  previousTTL: '5m' | '1h' | null,
+): SmartTTLDecision {
+  if (previousTTL) {
+    return { ttl: previousTTL, reason: 'reused-from-previous-round', isFirstDecision: false };
+  }
+  // Default: long-task TTL. We cannot know the task length upfront, so
+  // we pick the TTL that cannot expire mid-task. 5m is only used when
+  // the user explicitly pins it.
+  return { ttl: '1h', reason: 'default-long-task', isFirstDecision: true };
+}

package/src/config/index.ts

@@ -16,12 +16,12 @@ const DEFAULT_CONFIG: Config = {
   maxTokens: 4096,
   contextLength: 50,
   provider: 'siliconflow',
-  // v3.0.0: prompt cache policy. Default = enabled, 5m TTL, auto strategy
-  // (Anthropic gets explicit cache_control markers; everything else falls
-  // through to the provider's built-in caching).
+  // v3.0.0: prompt cache policy. v3.0.4: default TTL is 1h (long-task).
+  // We cannot predict task length at round 0, so we default to the TTL
+  // that cannot expire mid-task. 5m is opt-in via /ttl 5m or init wizard.
   cache: {
     enabled: true,
-    ttl: '5m',
+    ttl: '1h',
     strategy: 'auto',
   },
 };

package/src/config/types.ts

@@ -43,10 +43,14 @@ export interface Config {
    * Note: enabling/disabling only affects Anthropic; other providers do
    * not expose a programmatic cache toggle, so the flag is purely
    * advisory there.
+   *
+   * v3.0.3: `ttl` accepts '5m' | '1h' | 'auto'. 'auto' lets the runtime
+   * pick the TTL based on conversation length (decideTTL in smartModel.ts).
+   * The wizard's default is 'auto' so users don't have to choose.
    */
   cache?: {
     enabled: boolean;
-    ttl?: '5m' | '1h';
+    ttl?: '5m' | '1h' | 'auto';
     strategy?: 'auto' | 'manual' | 'off';
   };
 }

package/src/llm/anthropic.ts

@@ -46,11 +46,31 @@ const DEFAULT_CACHE_TTL: '5m' | '1h' = '5m';
 export class AnthropicProvider implements LLMProvider {
   readonly name = 'anthropic';
   protected config: ProviderConfig;
+  /**
+   * v3.0.3: TTL resolved from the user's config + smart routing. This is
+   * the *actual* TTL attached to every cache_control marker we send this
+   * session. Stays stable across rounds to keep the Anthropic cache
+   * prefix intact.
+   *
+   * Computed once by LLMService.chatStream when ttl='auto', then
+   * persisted via setResolvedTTL. Subsequent rounds call chatStream
+   * without re-deciding (ChatOptions.resolvedTtl is sticky per session).
+   */
+  protected resolvedTtl: '5m' | '1h' = DEFAULT_CACHE_TTL;
 
   constructor(config: ProviderConfig) {
     this.config = config;
   }
 
+  /**
+   * Called by LLMService after decideTTL(). Persists the TTL on the
+   * provider instance so buildRequest() writes it consistently across
+   * every round in this session.
+   */
+  setResolvedTTL(ttl: '5m' | '1h'): void {
+    this.resolvedTtl = ttl;
+  }
+
   buildTools(tools: Tool[]): any[] {
     return tools.map(tool => ({
       name: tool.name,
@@ -247,7 +267,12 @@ export class AnthropicProvider implements LLMProvider {
     //    final block (and only the final block, per Anthropic convention)
     //    carries the cache_control marker.
     const systemMessages = messages.filter(m => m.role === 'system');
-    const cacheTtl = (this.config.cache?.ttl) || DEFAULT_CACHE_TTL;
+    // v3.0.3: TTL is sticky per session. The provider's resolvedTtl is
+    // set once by LLMService after decideTTL() and never changed within
+    // a session (changing it would invalidate the Anthropic cache
+    // prefix and cost more in cache_creation_input_tokens than it
+    // saves).
+    const cacheTtl = this.resolvedTtl;
     const cacheEnabled = this.config.cache?.enabled !== false; // default on for Anthropic
 
     const systemBlocks = systemMessages.length === 0 ? undefined : systemMessages.map((m, i, arr) => {

package/src/llm/index.ts

@@ -20,6 +20,7 @@ import { PROVIDERS } from '../config/providers.js';
 import { OpenAIProvider } from './openai.js';
 import { AnthropicProvider } from './anthropic.js';
 import { GeminiProvider } from './gemini.js';
+import { decideTTL } from '../cache/smartModel.js';
 
 export class LLMService {
   private provider: LLMProvider;
@@ -31,6 +32,19 @@ export class LLMService {
     this.apiKey = apiKey;
   }
 
+  /**
+   * v3.0.3: TTL resolved from config + smart routing. Stays null until
+   * the first round, then never changes for the session. Anthropic
+   * provider's setResolvedTTL is called at the same time, so the wire
+   * prefix is consistent across rounds.
+   */
+  private resolvedTtl: '5m' | '1h' | null = null;
+
+  /** Public accessor used by App.streamResponse to surface TTL in the UI. */
+  getResolvedTTL(): '5m' | '1h' | null {
+    return this.resolvedTtl;
+  }
+
   static fromConfig(config: AIConfig & { cache?: Config['cache'] }): LLMService {
     const providerName = config.provider || 'siliconflow';
     const providerConfig = PROVIDERS[providerName];
@@ -43,7 +57,9 @@ export class LLMService {
       maxTokens: config.maxTokens ?? 4096,
       // v3.0.0: forward cache policy. Anthropic reads this to decide
       // whether to attach cache_control markers; other providers ignore it.
-      cache: config.cache ?? { enabled: true, ttl: '5m', strategy: 'auto' as const },
+      // v3.0.3: ttl accepts '5m' | '1h' | 'auto'. 'auto' is resolved
+      // per-session by decideTTL() inside chatStream.
+      cache: config.cache ?? { enabled: true, ttl: 'auto' as const, strategy: 'auto' as const },
     };
 
     const format = providerConfig.format;
@@ -98,6 +114,28 @@ export class LLMService {
   ): AsyncGenerator<StreamChunk, ChatResponse> {
     if (!this.hasApiKey()) throw new Error(this.getNoKeyMessage());
 
+    // v3.0.3: Resolve TTL once per session.
+    // v3.0.4: default is 1h (long-task). 'auto' (legacy config value)
+    // resolves via decideTTL which now always returns 1h — we cannot
+    // predict task length at round 0, so we default to the TTL that
+    // cannot expire mid-task. '5m'/'1h' are explicit user pins.
+    const configTtl = (this.provider as any).config?.cache?.ttl;
+    if (configTtl === 'auto' && this.resolvedTtl === null) {
+      const decision = decideTTL(messages, null);
+      this.resolvedTtl = decision.ttl;
+      if (typeof (this.provider as any).setResolvedTTL === 'function') {
+        (this.provider as any).setResolvedTTL(decision.ttl);
+      }
+    } else if (configTtl === '5m' || configTtl === '1h') {
+      // User pinned a specific TTL — apply it once and keep it.
+      if (this.resolvedTtl === null) {
+        this.resolvedTtl = configTtl;
+        if (typeof (this.provider as any).setResolvedTTL === 'function') {
+          (this.provider as any).setResolvedTTL(configTtl);
+        }
+      }
+    }
+
     const maxIterations = options?.maxIterations ?? 10;
     let currentMessages = [...messages];
     let iterations = 0;

package/src/llm/provider.ts

@@ -52,10 +52,15 @@ export interface ProviderConfig {
    * Optional cache control policy. When omitted, providers fall back to their
    * default behavior (Anthropic: explicit cache_control markers; OpenAI / Gemini
    * / DeepSeek: automatic prefix cache, no markers needed).
+   *
+   * v3.0.3: `ttl` accepts '5m' | '1h' | 'auto'. 'auto' lets the runtime
+   * decide per-session via decideTTL() in cache/smartModel.ts. The actual
+   * value used at request time is what gets stored on the provider's
+   * resolvedTtl field (set by LLMService.chatStream).
    */
   cache?: {
     enabled: boolean;
-    ttl?: '5m' | '1h';
+    ttl?: '5m' | '1h' | 'auto';
     /**
      * 'auto'   — provider default (Anthropic: explicit, OpenAI/DeepSeek: auto)
      * 'manual' — always emit cache_control markers regardless of provider

package/src/tui/app.tsx

@@ -48,8 +48,14 @@ export function TuiApp({ app }: Props) {
   // change (i.e. a round just completed and recorded new usage). Polling on
   // an interval would be wasteful; React re-render is the trigger.
   const [cacheSnapshot, setCacheSnapshot] = useState(() => app.cacheStats.snapshot());
+  // v3.0.3: resolved TTL (sticky per session). null until first round.
+  const [resolvedTtl, setResolvedTtl] = useState<'5m' | '1h' | null>(app.resolvedTtl);
+  // The user-pinned config TTL ('auto' | '5m' | '1h') — used to render the
+  // Header chip BEFORE the first round, when resolvedTtl is still null.
+  const configTtl = (app.config.get() as any).cache?.ttl as 'auto' | '5m' | '1h' | undefined;
   useEffect(() => {
     setCacheSnapshot(app.cacheStats.snapshot());
+    setResolvedTtl(app.resolvedTtl);
   }, [messages.length]);
 
   const addMsg = useCallback((content: string) => {
@@ -99,6 +105,7 @@ export function TuiApp({ app }: Props) {
         model={app.config.get().model}
         cacheHitRate={cacheSnapshot.hitRate > 0 ? cacheSnapshot.hitRate : null}
         cacheSavingsCNY={cacheSnapshot.estimatedSavingsCNY}
+        cacheTtl={resolvedTtl ?? configTtl ?? null}
       />
       <ChatList
         messages={allMessages}

package/src/tui/components/Header.tsx

@@ -13,6 +13,13 @@ interface Props {
    */
   cacheHitRate?: number | null;
   cacheSavingsCNY?: number;
+  /**
+   * v3.0.3: cache TTL marker. '5m' (default for short sessions) or '1h'
+   * (auto-decided for long sessions, or pinned by the user). 'auto' is
+   * the user-pinned setting and shows up as ⏱ auto. null = not yet
+   * decided (waiting for first round).
+   */
+  cacheTtl?: '5m' | '1h' | 'auto' | null;
 }
 
 /**
@@ -27,7 +34,7 @@ function hitRateColor(rate: number): string {
   return '#6B7280';
 }
 
-export const Header = React.memo(function Header({ provider, model, cacheHitRate, cacheSavingsCNY }: Props) {
+export const Header = React.memo(function Header({ provider, model, cacheHitRate, cacheSavingsCNY, cacheTtl }: Props) {
   const showCache = typeof cacheHitRate === 'number' && cacheHitRate > 0;
   return (
     <Box flexDirection="column" marginBottom={0}>
@@ -35,7 +42,7 @@ export const Header = React.memo(function Header({ provider, model, cacheHitRate
         <Box>
           <Text color="#06B6D4" bold> ⚡ </Text>
           <Text color="#22D3EE" bold>THATGFSJ CODE</Text>
-          <Text dimColor> v3.0.0</Text>
+          <Text dimColor> v3.0.4</Text>
         </Box>
         <Box>
           {showCache && (
@@ -45,6 +52,9 @@ export const Header = React.memo(function Header({ provider, model, cacheHitRate
               <Text dimColor> · </Text>
             </>
           )}
+          {cacheTtl && (
+            <Text color="#A78BFA" bold> ⏱ {cacheTtl} </Text>
+          )}
           <Text color="#06B6D4" bold> {provider} </Text>
           <Text dimColor>/</Text>
           <Text color="#22D3EE"> {model} </Text>

package/src/tui/components/InitWizard.tsx

@@ -14,7 +14,7 @@ interface Props {
   onCancel: () => void;
 }
 
-type InitStep = 'provider' | 'custom_url' | 'api_key' | 'model' | 'custom_model' | 'cache_strategy' | 'cache_ttl';
+type InitStep = 'provider' | 'custom_url' | 'api_key' | 'model' | 'custom_model' | 'cache_strategy';
 
 interface CacheChoice {
   enabled: boolean;
@@ -208,46 +208,29 @@ export function InitWizard({ onComplete, onCancel }: Props) {
     );
   }
 
-  // v3.0.0: prompt-cache strategy step
+  // v3.0.4: prompt-cache strategy step.
+  // Default is 1h (long-task TTL): we cannot predict how long a task
+  // will run, so we pick the TTL that cannot expire mid-task. 5m is
+  // for users who are sure the session is short.
   if (step === 'cache_strategy') {
     const items = [
-      { label: '✓ 开启（推荐，节省 token 成本）', value: 'on' },
+      { label: '🕐 1 小时（推荐：默认长任务，缓存不中途失效）', value: '1h' },
+      { label: '⏱ 5 分钟（只适合你确认是短会话）', value: '5m' },
       { label: '✗ 关闭（每次请求都重新计算）', value: 'off' },
     ];
     return (
       <Box flexDirection="column" paddingLeft={1}>
-        <Text color="#06B6D4" bold>是否开启 Prompt Caching?</Text>
-        <Text dimColor>对 Anthropic / DeepSeek / Gemini 有效，OpenAI 兼容接口默认自动缓存。</Text>
+        <Text color="#06B6D4" bold>Prompt Caching 策略:</Text>
+        <Text dimColor>对 Anthropic / DeepSeek / Gemini 有效。</Text>
+        <Text dimColor>推荐 1 小时：任务开始前无法预知长度，5 分钟 TTL 会在长任务中途过期。</Text>
         <SelectInput
           items={items}
           onSelect={(item) => {
-            if (item.value === 'on') {
-              setCacheChoice(c => ({ ...c, enabled: true }));
-              setStep('cache_ttl');
+            if (item.value === 'off') {
+              setCacheChoice({ enabled: false, ttl: '1h' });
             } else {
-              setCacheChoice(c => ({ ...c, enabled: false }));
-              saveConfig(selectedProvider, selectedModel, apiKey, customUrl || undefined);
-              onComplete(selectedProvider, selectedModel, apiKey, customUrl || undefined);
+              setCacheChoice({ enabled: true, ttl: item.value as '5m' | '1h' });
             }
-          }}
-        />
-      </Box>
-    );
-  }
-
-  // v3.0.0: TTL choice
-  if (step === 'cache_ttl') {
-    const items = [
-      { label: '5 分钟（写入成本低，适合短会话）', value: '5m' },
-      { label: '1 小时（写入成本高，适合长会话）', value: '1h' },
-    ];
-    return (
-      <Box flexDirection="column" paddingLeft={1}>
-        <Text color="#06B6D4" bold>Cache TTL:</Text>
-        <SelectInput
-          items={items}
-          onSelect={(item) => {
-            setCacheChoice(c => ({ ...c, ttl: item.value as '5m' | '1h' }));
             saveConfig(selectedProvider, selectedModel, apiKey, customUrl || undefined);
             onComplete(selectedProvider, selectedModel, apiKey, customUrl || undefined);
           }}

package/src/tui/hooks/useCommands.ts

@@ -20,6 +20,8 @@ const CMD_ALIASES: Record<string, string> = {
   '/服务商': '/provider',
   '/思考': '/thinking',
   '/缓存': '/cache',
+  '/ttl': '/ttl',
+  '/TTL': '/ttl',
 };
 
 export const COMMAND_LIST = [
@@ -28,6 +30,7 @@ export const COMMAND_LIST = [
   { name: '/新建', desc: '新建会话' },
   { name: '/压缩', desc: '压缩上下文' },
   { name: '/缓存', desc: '缓存命中率' },
+  { name: '/ttl', desc: '查看/设置 Cache TTL' },
   { name: '/技能', desc: '管理技能' },
   { name: '/mcp', desc: 'MCP 设置' },
   { name: '/帮助', desc: '查看帮助' },
@@ -142,6 +145,40 @@ export function useCommands(app: App) {
       return { handled: true, output: lines.join('\n') };
     }
 
+    // v3.0.3: /ttl — view or pin the cache TTL.
+    // v3.0.4: default is 1h (long-task). We cannot predict task length
+    // at round 0, so the default TTL is the one that cannot expire
+    // mid-task. Pinning 5m is only for users who are sure the session
+    // is short.
+    //
+    //   /ttl              show current effective TTL + decision reason
+    //   /ttl 5m|1h        pin TTL for this session (sticky, no cache reset)
+    //   /ttl 1h           back to the long-task default
+    if (name === '/ttl') {
+      const configTtl = (app.config.get() as any).cache?.ttl as 'auto' | '5m' | '1h' | undefined;
+      const resolved = app.resolvedTtl;
+      if (arg === '5m' || arg === '1h') {
+        app.config.save({ cache: { ...(app.config.get() as any).cache, ttl: arg } });
+        app.resolvedTtl = arg;
+        return { handled: true, output: `✓ Cache TTL 已固定为 ${arg}（首次请求会重建缓存）` };
+      }
+      // No arg: show current state
+      const effective = resolved ?? (configTtl === 'auto' ? '1h' : (configTtl ?? '1h'));
+      const lines = [
+        '⏱  Cache TTL',
+        '─────────────────────────',
+        `  配置:      ${configTtl ?? '1h'}`,
+        `  当前会话:  ${resolved ?? '尚未评估'}`,
+        '',
+        '说明: 默认 1 小时（长任务）。任务开始前无法预知长度，',
+        '      5 分钟 TTL 会在长任务中途过期；1 小时缓存命中即可回本。',
+        '      只有你确定会话很短时才建议 /ttl 5m。',
+        '',
+        '/ttl 5m|1h  调整 TTL',
+      ];
+      return { handled: true, output: lines.join('\n') };
+    }
+
     // ── /skills [id] ────────────────────────────────────
     if (name === '/skills') {
       if (arg) {

package/tests/cache/smartModel.test.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect } from 'vitest';
+import { decideTTL, totalConversationChars, shouldDowngrade } from '../../src/cache/smartModel.js';
+import type { ChatMessage } from '../../src/types.js';
+
+function userMsg(s: string): ChatMessage {
+  return { role: 'user', content: s };
+}
+function assistantMsg(s: string): ChatMessage {
+  return { role: 'assistant', content: s };
+}
+
+describe('decideTTL', () => {
+  it('defaults to 1h (long-task) on round 0 — task length unknown', () => {
+    const d = decideTTL([], null);
+    expect(d.ttl).toBe('1h');
+    expect(d.isFirstDecision).toBe(true);
+    expect(d.reason).toBe('default-long-task');
+  });
+
+  it('defaults to 1h even for a small conversation — cannot predict future length', () => {
+    const messages = [
+      userMsg('hello'),
+      assistantMsg('hi'),
+      userMsg('how are you?'),
+      assistantMsg('good'),
+    ];
+    const d = decideTTL(messages, null);
+    expect(d.ttl).toBe('1h');
+  });
+
+  it('defaults to 1h for a large conversation too', () => {
+    const messages: ChatMessage[] = [];
+    for (let i = 0; i < 16; i++) {
+      messages.push(userMsg(`question ${i}`));
+      messages.push(assistantMsg(`answer ${i} long enough to be content`));
+    }
+    const d = decideTTL(messages, null);
+    expect(d.ttl).toBe('1h');
+  });
+
+  it('reuses previous TTL (stability rule)', () => {
+    const messages = [userMsg('hello'), assistantMsg('hi')];
+    const d1 = decideTTL(messages, null);
+    expect(d1.ttl).toBe('1h');
+    expect(d1.isFirstDecision).toBe(true);
+
+    // Once pinned to 5m by the user, later rounds keep 5m.
+    const d2 = decideTTL(messages, '5m');
+    expect(d2.ttl).toBe('5m');
+    expect(d2.isFirstDecision).toBe(false);
+    expect(d2.reason).toBe('reused-from-previous-round');
+
+    // And once pinned to 1h, later rounds keep 1h.
+    const d3 = decideTTL(messages, '1h');
+    expect(d3.ttl).toBe('1h');
+    expect(d3.isFirstDecision).toBe(false);
+  });
+});
+
+describe('totalConversationChars', () => {
+  it('sums string content', () => {
+    const total = totalConversationChars([
+      userMsg('abc'),
+      assistantMsg('defgh'),
+    ]);
+    expect(total).toBe(8);
+  });
+
+  it('handles array content blocks', () => {
+    const total = totalConversationChars([
+      { role: 'user', content: [
+        { type: 'text', text: 'hello' },
+        { type: 'image', source: { type: 'base64', media_type: 'image/png', data: 'XXXX' } },
+      ] as any },
+    ]);
+    expect(total).toBe(5);
+  });
+});
+
+describe('shouldDowngrade', () => {
+  it('downgrades short prompts without tool calls', () => {
+    const d = shouldDowngrade([], 'hi');
+    expect(d.downgrade).toBe(true);
+  });
+
+  it('does not downgrade long prompts', () => {
+    const d = shouldDowngrade([], 'x'.repeat(300));
+    expect(d.downgrade).toBe(false);
+    expect(d.reason).toBe('prompt-too-long');
+  });
+
+  it('does not downgrade when recent tool calls exist', () => {
+    const messages: ChatMessage[] = [
+      { role: 'assistant', content: '...', tool_calls: [{ id: '1', type: 'function', function: { name: 'f', arguments: '{}' } }] },
+    ];
+    const d = shouldDowngrade(messages, 'hi');
+    expect(d.downgrade).toBe(false);
+    expect(d.reason).toBe('recent-tool-call');
+  });
+});