fix: restore cache-hint dialog and evaluation modules

Replace oauth-strip stubs with the real CacheHintDialog, evaluateCacheHint,
and cache-hint-config so idle intercept and cold-fetch dialogs work again.

Author: elkaix

apps/pythinker-code/src/tui/components/dialogs/cache-hint-dialog.ts

@@ -1,7 +1,121 @@
+/**
+ * CacheHintDialog — shown when a resumed (or long-idle) session's context
+ * cache has almost certainly expired, so the next turn re-sends the whole
+ * history uncached. Offers compact / new session / continue / never.
+ *
+ * Layout mirrors the list-dialog spec (DESIGN.md): top border, title, hint,
+ * body line, then options with right-column descriptions.
+ */
 
-export type CacheHintAction = string;
-export class CacheHintDialogComponent {
-  constructor(..._args: any[]) {}
-  render(): string[] { return []; }
+import {
+  Container,
+  matchesKey,
+  Key,
+  truncateToWidth,
+  visibleWidth,
+  type Focusable,
+} from '@pymodel/pi-tui';
+import { SELECT_POINTER } from '#/tui/constant/symbols';
+import { currentTheme } from '#/tui/theme';
+import { formatIdleDuration } from '#/tui/utils/cache-hint';
+import { SearchableList } from '#/tui/utils/searchable-list';
+import { formatTokenCount } from '#/utils/usage/usage-format';
+
+export type CacheHintAction = 'compact' | 'new' | 'continue' | 'never';
+
+interface CacheHintOption {
+  readonly value: CacheHintAction;
+  readonly label: string;
+  readonly description?: string;
+}
+
+const OPTIONS: readonly CacheHintOption[] = [
+  {
+    value: 'compact',
+    label: 'Compact and continue',
+    description: 'one-time compact cost · cheapest way to keep this topic',
+  },
+  {
+    value: 'new',
+    label: 'Start a new session',
+    description: 'zero context cost · best for a new task',
+  },
+  {
+    value: 'continue',
+    label: 'Continue as-is',
+    description: 'full history kept · highest cost per turn',
+  },
+  { value: 'never', label: "Don't ask me again" },
+];
+
+export interface CacheHintDialogOptions {
+  readonly idleSeconds: number;
+  readonly totalTokens: number;
+  readonly onSelect: (action: CacheHintAction) => void;
+  readonly onCancel: () => void;
+}
+
+export class CacheHintDialogComponent extends Container implements Focusable {
+  focused = false;
+  private readonly opts: CacheHintDialogOptions;
+  private readonly list: SearchableList<CacheHintOption>;
+
+  constructor(opts: CacheHintDialogOptions) {
+    super();
+    this.opts = opts;
+    this.list = new SearchableList({
+      items: OPTIONS,
+      toSearchText: (o) => o.label,
+      initialIndex: 0,
+      searchable: false,
+    });
+  }
+
+  handleInput(data: string): void {
+    if (matchesKey(data, Key.escape)) {
+      this.opts.onCancel();
+      return;
+    }
+    if (matchesKey(data, Key.enter)) {
+      const chosen = this.list.selected();
+      if (chosen !== undefined) this.opts.onSelect(chosen.value);
+      return;
+    }
+    this.list.handleKey(data);
+  }
+
+  override render(width: number): string[] {
+    const view = this.list.view();
+    const title = `This session has been idle for ${formatIdleDuration(this.opts.idleSeconds)} and is ~${formatTokenCount(this.opts.totalTokens)} tokens.`;
+    const lines: string[] = [
+      currentTheme.fg('primary', '─'.repeat(width)),
+      currentTheme.boldFg('primary', ` ${title}`),
+      currentTheme.fg('textMuted', ' ↑↓ navigate · Enter select · Esc cancel'),
+      '',
+      currentTheme.fg(
+        'text',
+        ' Cache expired — the next message re-sends the entire history at full price.',
+      ),
+    ];
+
+    const maxLabelWidth = Math.max(...OPTIONS.map((o) => visibleWidth(o.label)));
+    for (let i = view.page.start; i < view.page.end; i++) {
+      const opt = view.items[i]!;
+      const isSelected = i === view.selectedIndex;
+      const pointer = isSelected ? SELECT_POINTER : ' ';
+      let line = currentTheme.fg(isSelected ? 'primary' : 'textDim', `  ${pointer} `);
+      line += isSelected
+        ? currentTheme.boldFg('primary', opt.label)
+        : currentTheme.fg('text', opt.label);
+      if (opt.description !== undefined) {
+        const gap = maxLabelWidth - visibleWidth(opt.label) + 4;
+        line += ' '.repeat(gap) + currentTheme.fg('textMuted', opt.description);
+      }
+      lines.push(line);
+    }
+
+    lines.push('');
+    lines.push(currentTheme.fg('primary', '─'.repeat(width)));
+    return lines.map((line) => truncateToWidth(line, width));
+  }
 }
-export class CacheHintDialog extends CacheHintDialogComponent {}

apps/pythinker-code/src/tui/utils/cache-hint.ts

@@ -1,3 +1,52 @@
+import type { CacheHintConfig } from '#/utils/cache-hint-config';
 
-export function shouldShowCacheHint(..._args: any[]): boolean { return false; }
-export function evaluateCacheHint(..._args: any[]): any { return { show: false }; }
+export interface CacheHintInput {
+  /** Current time, epoch ms. */
+  readonly now: number;
+  /** Last session activity, epoch ms. Missing → skip. */
+  readonly lastActiveAt?: number;
+  /** Current context size in tokens. Missing → skip (no local estimation). */
+  readonly totalTokens?: number;
+  /** Upstream model ID used to look up the rule. Missing/unconfigured → skip. */
+  readonly modelId?: string;
+  /** Fetch failure → undefined → skip. */
+  readonly config?: CacheHintConfig;
+  /** User chose "Don't ask me again" (tui.toml). */
+  readonly dismissed: boolean;
+}
+
+export type CacheHintDecision =
+  | { readonly kind: 'skip' }
+  | { readonly kind: 'hint'; readonly idleSeconds: number; readonly totalTokens: number };
+
+/**
+ * Shared trigger rule for both the resume and the idle scenarios. Every
+ * missing-data branch skips — false negatives are acceptable, false positives
+ * are not.
+ */
+export function evaluateCacheHint(input: CacheHintInput): CacheHintDecision {
+  if (input.dismissed) return { kind: 'skip' };
+  const { config, modelId, lastActiveAt, totalTokens } = input;
+  if (config === undefined || modelId === undefined) return { kind: 'skip' };
+  if (lastActiveAt === undefined || totalTokens === undefined) return { kind: 'skip' };
+  const rule = config.config[modelId];
+  if (rule === undefined) return { kind: 'skip' };
+  const idleMs = input.now - lastActiveAt;
+  if (idleMs <= rule.cache_duration * 1000) return { kind: 'skip' };
+  if (totalTokens < rule.min_tokens_to_hint) return { kind: 'skip' };
+  return { kind: 'hint', idleSeconds: Math.floor(idleMs / 1000), totalTokens };
+}
+
+/** `45m` / `3h 20m` / `26d 22h`. */
+export function formatIdleDuration(idleSeconds: number): string {
+  const minutes = Math.max(1, Math.floor(idleSeconds / 60));
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) {
+    const restMinutes = minutes % 60;
+    return restMinutes === 0 ? `${hours}h` : `${hours}h ${restMinutes}m`;
+  }
+  const days = Math.floor(hours / 24);
+  const restHours = hours % 24;
+  return restHours === 0 ? `${days}d` : `${days}d ${restHours}h`;
+}

apps/pythinker-code/src/utils/cache-hint-config.ts

@@ -1,6 +1,52 @@
+import { z } from 'zod';
 
-export type CacheHintConfig = Record<string, unknown>;
-export function getCacheHintConfig(..._args: any[]): CacheHintConfig { return {}; }
-export function peekCacheHintConfig(..._args: any[]): CacheHintConfig { return {}; }
-export function loadCacheHintConfig(..._args: any[]): CacheHintConfig { return {}; }
-export function saveCacheHintConfig(..._args: any[]): void {}
+import {
+  getClientConfig,
+  peekClientConfig,
+  resetClientConfigCache,
+  type ClientConfigFetchOptions,
+} from '#/utils/client-configs';
+
+/** The cache-hint rules are one named config on the client-configs endpoint. */
+const CONFIG_NAME = 'estimated_cache_duration';
+
+const cacheHintModelRuleSchema = z.object({
+  min_tokens_to_hint: z.number(),
+  cache_duration: z.number(),
+});
+
+const cacheHintConfigSchema = z.object({
+  version: z.literal(1),
+  config: z.record(z.string(), cacheHintModelRuleSchema),
+});
+
+export type CacheHintConfig = z.infer<typeof cacheHintConfigSchema>;
+export type CacheHintConfigFetchOptions = ClientConfigFetchOptions;
+
+/**
+ * Returns the cache-hint config, preferring the cache (1 day, persisted
+ * across restarts). Any failure resolves to `undefined` — callers treat
+ * that as "do not hint".
+ */
+export async function getCacheHintConfig(
+  options: CacheHintConfigFetchOptions = {},
+): Promise<CacheHintConfig | undefined> {
+  return getClientConfig(CONFIG_NAME, cacheHintConfigSchema, options);
+}
+
+/** Fire-and-forget refresh, e.g. on new-session creation. Never throws. */
+export function refreshCacheHintConfigInBackground(
+  options: CacheHintConfigFetchOptions = {},
+): void {
+  void getCacheHintConfig(options).catch(() => undefined);
+}
+
+/** Synchronous peek at the fresh cache; undefined when missing or stale. */
+export function peekCacheHintConfig(now?: number): CacheHintConfig | undefined {
+  return peekClientConfig(CONFIG_NAME, cacheHintConfigSchema, now);
+}
+
+/** Test hook: drop the in-process cache. */
+export function resetCacheHintConfigCache(): void {
+  resetClientConfigCache(CONFIG_NAME);
+}