thatgfsj-code 3.0.2 → 3.0.3

package/src/cache/smartModel.ts

@@ -1,24 +1,37 @@
 /**
- * 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
+ *      Short conversations            → 5m  (cheap write, expires fast)
+ *      Long conversations (>15 turns) → 1h  (cache hits pay back the
+ *                                            expensive write each round)
+ *
+ * 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.
+ *
+ *   The "smart" part is that we look at the FULL conversation so far,
+ *   not just the last input. A 16-turn conversation that started with a
+ *   short prompt but grew into a long refactor still gets 1h.
+ *
+ * Trade-off: the first round is evaluated with 0 history, so it
+ * defaults to 5m. If the conversation then grows long, future rounds
+ * still use 5m for the system-token cache (because we already wrote
+ * it with 5m). The tool definition cache gets the same TTL.
  */
 
 import type { ChatMessage } from '../types.js';
@@ -30,6 +43,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 +70,76 @@ 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.
+ *
+ * Inputs:
+ *   - messages: full conversation so far (system + user + assistant + tool)
+ *   - previousTTL: TTL chosen in a prior round (null on round 0)
+ *
+ * Decision matrix:
+ *   - round 0 + any input length → 5m (default; user can override via init)
+ *   - round 1-14 + total chars < 50k → 5m (short sessions, 5m is enough)
+ *   - round 15+ OR total chars > 50k → 1h (long sessions, 1h amortizes the write)
+ *
+ * Stability rule: 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 };
+  }
+
+  const turnCount = messages.filter(m => m.role === 'user' || m.role === 'assistant').length;
+  const totalChars = totalConversationChars(messages);
+
+  // Round 0: empty / first input. Default to 5m.
+  if (turnCount === 0) {
+    return { ttl: '5m', reason: 'first-round-default', isFirstDecision: true };
+  }
+
+  // Multi-turn but small conversation → 5m
+  if (turnCount < 15 && totalChars < 50_000) {
+    return { ttl: '5m', reason: `short-session-${turnCount}-turns`, isFirstDecision: true };
+  }
+
+  // Long conversations → 1h
+  if (turnCount >= 15) {
+    return { ttl: '1h', reason: `long-session-${turnCount}-turns`, isFirstDecision: true };
+  }
+  if (totalChars >= 50_000) {
+    return { ttl: '1h', reason: `long-context-${totalChars}-chars`, isFirstDecision: true };
+  }
+
+  return { ttl: '5m', reason: 'fallback', isFirstDecision: true };
+}

package/src/config/index.ts

@@ -16,12 +16,14 @@ 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. Default = enabled, 'auto' TTL.
+  // v3.0.3: 'auto' TTL lets the runtime's decideTTL() pick 5m for short
+  // sessions and 1h for long ones (>= 15 turns or >= 50k chars). The
+  // chosen TTL is sticky across rounds within a session so the cache
+  // prefix stays stable.
   cache: {
     enabled: true,
-    ttl: '5m',
+    ttl: 'auto',
     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,27 @@ export class LLMService {
   ): AsyncGenerator<StreamChunk, ChatResponse> {
     if (!this.hasApiKey()) throw new Error(this.getNoKeyMessage());
 
+    // v3.0.3: Resolve TTL once per session. If config says 'auto', call
+    // decideTTL to pick 5m (short sessions) or 1h (long ones). For
+    // non-Anthropic providers we don't need to do anything — cache
+    // markers are wired into the system regardless.
+    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.3</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,33 @@ export function InitWizard({ onComplete, onCancel }: Props) {
     );
   }
 
-  // v3.0.0: prompt-cache strategy step
+  // v3.0.3: prompt-cache strategy step — auto / 5m / 1h / off.
+  // The wizard used to require two questions (on/off + 5m/1h). Now it
+  // gives the user a single, clear choice up front, with "自动" as the
+  // default. The auto path lets the runtime pick the TTL based on the
+  // conversation length (see cache/smartModel.ts decideTTL).
   if (step === 'cache_strategy') {
     const items = [
-      { label: '✓ 开启（推荐，节省 token 成本）', value: 'on' },
+      { label: '🤖 自动（推荐：根据会话长度智能选 5m / 1h）', value: 'auto' },
+      { label: '⏱ 强制 5 分钟（短会话，写入便宜）', value: '5m' },
+      { label: '🕐 强制 1 小时（长会话，命中率优先）', value: '1h' },
       { 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>自动模式：短会话用 5m（便宜），长会话（&gt;15 轮）自动切 1h。</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: '5m' });
+            } else if (item.value === 'auto') {
+              setCacheChoice({ enabled: true, ttl: '5m' });  // start at 5m, smartModel will upgrade
             } 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,42 @@ export function useCommands(app: App) {
       return { handled: true, output: lines.join('\n') };
     }
 
+    // v3.0.3: /ttl — view or pin the cache TTL.
+    //
+    //   /ttl              show current effective TTL + decision reason
+    //   /ttl 5m|1h        pin TTL for this session (sticky, no cache reset)
+    //   /ttl auto         resume auto-decision (clears the pin)
+    if (name === '/ttl') {
+      const configTtl = (app.config.get() as any).cache?.ttl as 'auto' | '5m' | '1h' | undefined;
+      const resolved = app.resolvedTtl;
+      if (arg === 'auto') {
+        app.config.save({ cache: { ...(app.config.get() as any).cache, ttl: 'auto' } });
+        app.resolvedTtl = null;
+        return { handled: true, output: '✓ Cache TTL 已重置为自动（下一轮重新评估）' };
+      }
+      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 lines = [
+        '⏱  Cache TTL',
+        '─────────────────────────',
+        `  配置:      ${configTtl ?? 'auto'}`,
+        `  当前会话:  ${resolved ?? '尚未评估'}`,
+        '',
+        '说明: '+
+          (configTtl === 'auto'
+            ? '自动模式 – 短会话(≤14 轮)用 5m节省写入成本，' +
+              '长会话(≥15 轮 或 ≥50k 字符)自动升级到 1h 复用缓存。'
+            : `${configTtl} 模式 – TTL 每次请求都固定。`),
+        '',
+        '/ttl 5m|1h|auto  调整 TTL',
+      ];
+      return { handled: true, output: lines.join('\n') };
+    }
+
     // ── /skills [id] ────────────────────────────────────
     if (name === '/skills') {
       if (arg) {

package/tests/cache/smartModel.test.ts

@@ -0,0 +1,112 @@
+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('round 0 → 5m (default)', () => {
+    const d = decideTTL([], null);
+    expect(d.ttl).toBe('5m');
+    expect(d.isFirstDecision).toBe(true);
+  });
+
+  it('short session (≤14 turns, <50k chars) → 5m', () => {
+    const messages = [
+      userMsg('hello'),
+      assistantMsg('hi'),
+      userMsg('how are you?'),
+      assistantMsg('good'),
+    ];
+    const d = decideTTL(messages, null);
+    expect(d.ttl).toBe('5m');
+    expect(d.reason).toMatch(/short-session/);
+  });
+
+  it('long session (≥15 turns) → 1h', () => {
+    // Build 16 user + 16 assistant = 32 messages (16 turns)
+    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');
+    expect(d.reason).toMatch(/long-session/);
+  });
+
+  it('large context (>50k chars) → 1h even with few turns', () => {
+    const bigContent = 'x'.repeat(60_000);
+    const messages: ChatMessage[] = [
+      userMsg('hi'),
+      { role: 'assistant', content: bigContent },
+    ];
+    const d = decideTTL(messages, null);
+    expect(d.ttl).toBe('1h');
+    expect(d.reason).toMatch(/long-context/);
+  });
+
+  it('reuses previous TTL (stability rule)', () => {
+    const messages = [userMsg('hello'), assistantMsg('hi')];
+    const d1 = decideTTL(messages, null);
+    expect(d1.ttl).toBe('5m');
+    expect(d1.isFirstDecision).toBe(true);
+
+    // Now grow to 30 turns without changing TTL
+    for (let i = 0; i < 30; i++) {
+      messages.push(userMsg(`q${i}`));
+      messages.push(assistantMsg(`a${i}`));
+    }
+    const d2 = decideTTL(messages, '5m');
+    expect(d2.ttl).toBe('5m');
+    expect(d2.isFirstDecision).toBe(false);
+    expect(d2.reason).toBe('reused-from-previous-round');
+  });
+});
+
+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');
+  });
+});