mixdog 0.9.2 → 0.9.4

package/scripts/provider-toolcall-test.mjs

@@ -946,17 +946,21 @@ test('anthropic effort: legacy sonnet-4-5 maps effort to thinking budget', () =>
     assert.equal(modelSupportsEffort(model), false);
 });
 
-test('anthropic effort: xhigh on opus-4-8 normalizes to max in output_config', () => {
+test('anthropic effort: xhigh on opus-4-8 is a first-class level (not downgraded to max)', () => {
+    // Opus 4.8 supports xhigh (modelSupportsXhighEffort), so xhigh is kept
+    // verbatim as a first-class effort level — matching codex's ReasoningEffort
+    // enum which lists xhigh between high and max. Only models WITHOUT xhigh
+    // support clamp it down to high.
     const model = 'claude-opus-4-8';
     assert.equal(modelSupportsMaxEffort(model), true);
-    assert.equal(normalizeAnthropicEffortInput('xhigh', model), 'max');
+    assert.equal(normalizeAnthropicEffortInput('xhigh', model), 'xhigh');
     const body = _buildRequestBodyForCacheSmoke(
         [{ role: 'user', content: 'hi' }],
         model,
         [],
         { effort: 'xhigh' },
     );
-    assert.deepEqual(body.output_config, { effort: 'max' });
+    assert.deepEqual(body.output_config, { effort: 'xhigh' });
     assert.equal(body.thinking, undefined);
 });
 

package/scripts/recall-bench.mjs

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+// recall-bench.mjs — case-based recall quality bench against the LIVE memory
+// DB. READ-ONLY: every case goes through handleToolCall('search_memories')
+// which only performs SELECTs (handleSearch path). No mutation actions
+// ('memory' tool / cycle1 / cycle2 / prune / purge / etc.) are ever invoked
+// here — do not add any.
+//
+//   node scripts/recall-bench.mjs [--cases scripts/recall-bench-cases.json] [--json]
+//
+// Loads src/runtime/memory/index.mjs in-process (same module the daemon
+// uses), calls init() once, runs each bench case through handleToolCall,
+// prints params/result-count/top-3/latency/PASS-WARN per case, then a
+// summary table, then calls stop().
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const __dir = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dir, '..');
+const DEFAULT_CASES_PATH = resolve(__dir, 'recall-bench-cases.json');
+
+function argValue(name, fallback = null) {
+  const idx = process.argv.indexOf(`--${name}`);
+  if (idx >= 0 && idx + 1 < process.argv.length) return process.argv[idx + 1];
+  const pref = `--${name}=`;
+  const hit = process.argv.find((a) => a.startsWith(pref));
+  return hit ? hit.slice(pref.length) : fallback;
+}
+function hasFlag(name) { return process.argv.includes(`--${name}`); }
+
+const WARN_LATENCY_MS = 3000;
+
+const DEFAULT_CASES = [
+  { id: 'kw-ko', label: 'keyword query (ko)', args: { query: '메모리 재현' }, expect: 'results' },
+  { id: 'kw-en', label: 'keyword query (en)', args: { query: 'memory recall pipeline' }, expect: 'results' },
+  { id: 'short-1tok', label: 'short 1-token query', args: { query: 'recall' }, expect: 'results' },
+  { id: 'short-2tok', label: 'short 2-token query', args: { query: 'cycle1 drain' }, expect: 'results' },
+  { id: 'browse-last', label: 'query-less recent browse (period=last)', args: { period: 'last', limit: 10 }, expect: 'browse' },
+  { id: 'period-24h', label: 'period window 24h', args: { period: '24h', limit: 10 }, expect: 'browse' },
+  { id: 'period-7d', label: 'period window 7d', args: { period: '7d', limit: 10 }, expect: 'browse' },
+  { id: 'category-filter', label: 'category filter (decision)', args: { period: '30d', category: 'decision', limit: 10 }, expect: 'browse' },
+  { id: 'id-lookup', label: 'id lookup', args: { id: 1 }, expect: 'idlookup' },
+  { id: 'scope-project', label: 'project-scoped query', args: { query: 'recall', cwd: ROOT, limit: 10 }, expect: 'results' },
+  { id: 'scope-all', label: 'all-scope query', args: { query: 'recall', projectScope: 'all', limit: 10 }, expect: 'results' },
+  { id: 'raw-on', label: 'includeRaw on', args: { query: 'recall', includeRaw: true, limit: 10 }, expect: 'results' },
+  { id: 'raw-off', label: 'includeRaw off', args: { query: 'recall', includeRaw: false, limit: 10 }, expect: 'results' },
+];
+
+function loadCases(path) {
+  if (path && existsSync(resolve(path))) {
+    try {
+      const parsed = JSON.parse(readFileSync(resolve(path), 'utf8'));
+      if (Array.isArray(parsed) && parsed.length) return parsed;
+    } catch (e) {
+      process.stderr.write(`[recall-bench] failed to parse cases file ${path}: ${e.message}; using built-in cases\n`);
+    }
+  }
+  return DEFAULT_CASES;
+}
+
+function textOfResult(result) {
+  if (result && typeof result === 'object' && Array.isArray(result.content)) {
+    return result.content.map((p) => (p?.type === 'text' ? p.text || '' : JSON.stringify(p))).join('\n');
+  }
+  if (result && typeof result === 'object' && typeof result.text === 'string') return result.text;
+  if (typeof result === 'string') return result;
+  return JSON.stringify(result ?? '');
+}
+
+function countEntryLines(text) {
+  const t = String(text || '').trim();
+  if (!t || t === '(no results)' || t === '(no valid ids)') return 0;
+  return t.split('\n').filter((line) => line.trim() && !line.startsWith('[recall truncated') && !line.startsWith('note:')).length;
+}
+
+function topN(text, n = 3, maxLen = 140) {
+  const t = String(text || '').trim();
+  if (!t || t === '(no results)') return [];
+  return t.split('\n')
+    .filter((line) => line.trim() && !line.startsWith('[recall truncated') && !line.startsWith('note:'))
+    .slice(0, n)
+    .map((line) => (line.length > maxLen ? `${line.slice(0, maxLen - 1)}…` : line));
+}
+
+function evaluateCase(kase, { count, ms, isError }) {
+  const warnings = [];
+  if (isError) warnings.push('error result');
+  if (ms > WARN_LATENCY_MS) warnings.push(`latency ${ms}ms > ${WARN_LATENCY_MS}ms`);
+  if ((kase.expect === 'browse' || kase.expect === 'idlookup') && count === 0) {
+    warnings.push('0 results for a browse/id-lookup case (expected data present)');
+  }
+  const status = warnings.length ? 'WARN' : 'PASS';
+  return { status, warnings };
+}
+
+async function runCase(memoryModule, kase) {
+  const started = Date.now();
+  let result;
+  let isError = false;
+  let errMsg = null;
+  try {
+    result = await memoryModule.handleToolCall('search_memories', kase.args || {});
+    isError = Boolean(result?.isError);
+  } catch (e) {
+    isError = true;
+    errMsg = e?.message || String(e);
+    result = { text: `(error: ${errMsg})` };
+  }
+  const ms = Date.now() - started;
+  const text = textOfResult(result);
+  const count = countEntryLines(text);
+  const evalResult = evaluateCase(kase, { count, ms, isError });
+  return {
+    id: kase.id,
+    label: kase.label,
+    args: kase.args,
+    count,
+    ms,
+    isError,
+    errMsg,
+    top3: topN(text, 3),
+    status: evalResult.status,
+    warnings: evalResult.warnings,
+  };
+}
+
+function printCase(row) {
+  process.stdout.write(`\n[${row.status}] ${row.id} — ${row.label}\n`);
+  process.stdout.write(`  params: ${JSON.stringify(row.args)}\n`);
+  process.stdout.write(`  results: ${row.count}  latency: ${row.ms}ms${row.isError ? `  ERROR: ${row.errMsg}` : ''}\n`);
+  if (row.top3.length) {
+    for (const line of row.top3) process.stdout.write(`    - ${line}\n`);
+  } else {
+    process.stdout.write('    (no results)\n');
+  }
+  for (const w of row.warnings) process.stdout.write(`  WARN: ${w}\n`);
+}
+
+function printSummary(rows) {
+  process.stdout.write('\n=== recall-bench summary ===\n');
+  const widths = { id: 18, results: 8, ms: 8, status: 6 };
+  process.stdout.write(
+    `${'case'.padEnd(widths.id)}${'results'.padEnd(widths.results)}${'ms'.padEnd(widths.ms)}${'status'.padEnd(widths.status)}notes\n`,
+  );
+  for (const r of rows) {
+    process.stdout.write(
+      `${String(r.id).padEnd(widths.id)}${String(r.count).padEnd(widths.results)}${String(r.ms).padEnd(widths.ms)}${String(r.status).padEnd(widths.status)}${r.warnings.join('; ')}\n`,
+    );
+  }
+  const warnCount = rows.filter((r) => r.status === 'WARN').length;
+  const totalMs = rows.reduce((s, r) => s + r.ms, 0);
+  process.stdout.write(`\ncases=${rows.length} pass=${rows.length - warnCount} warn=${warnCount} total_latency=${totalMs}ms\n`);
+}
+
+async function main() {
+  const casesPath = argValue('cases', DEFAULT_CASES_PATH);
+  const jsonMode = hasFlag('json');
+  const cases = loadCases(casesPath);
+
+  let memoryModule;
+  try {
+    memoryModule = await import(pathToFileURL(resolve(ROOT, 'src/runtime/memory/index.mjs')).href);
+  } catch (e) {
+    process.stderr.write(`[recall-bench] failed to load memory module: ${e?.stack || e?.message || e}\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  try {
+    await memoryModule.init();
+  } catch (e) {
+    process.stdout.write(`recall-bench: DB unreachable / init failed — reporting clearly, no fabricated results.\n`);
+    process.stdout.write(`error: ${e?.stack || e?.message || e}\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const rows = [];
+  try {
+    for (const kase of cases) {
+      const row = await runCase(memoryModule, kase);
+      rows.push(row);
+      if (!jsonMode) printCase(row);
+    }
+  } finally {
+    try { await memoryModule.stop?.(); } catch {}
+  }
+
+  const allZero = rows.length > 0 && rows.every((r) => r.count === 0 && !r.isError);
+  if (allZero) {
+    process.stdout.write('\nNOTE: every case returned 0 results — DB is likely empty (or unreachable pool). Treat WARNs below as expected-empty, not a recall bug, until data is present.\n');
+  }
+
+  if (jsonMode) {
+    process.stdout.write(JSON.stringify({ cases: rows }, null, 2) + '\n');
+  } else {
+    printSummary(rows);
+  }
+
+  const hardErrors = rows.filter((r) => r.isError);
+  if (hardErrors.length) process.exitCode = 1;
+}
+
+main().catch((e) => {
+  process.stderr.write(`${e?.stack || e?.message || e}\n`);
+  process.exitCode = 1;
+});

package/scripts/recall-usecase-cases.json

@@ -0,0 +1,18 @@
+[
+  { "id": "uc1-last", "label": "UC1 previous conversation (period=last)", "args": { "period": "last", "limit": 12 }, "expect": "browse" },
+  { "id": "uc1-last-page2", "label": "UC1 last paging (offset)", "args": { "period": "last", "limit": 12, "offset": 12 }, "expect": "browse" },
+  { "id": "uc2-recent-30m", "label": "UC2 recent 30m", "args": { "period": "30m", "limit": 10 }, "expect": "browse" },
+  { "id": "uc2-recent-3h", "label": "UC2 recent 3h", "args": { "period": "3h", "limit": 10 }, "expect": "browse" },
+  { "id": "uc2-recent-24h", "label": "UC2 recent 24h", "args": { "period": "24h", "limit": 10 }, "expect": "browse" },
+  { "id": "uc3-tod-today", "label": "UC3 time-of-day today 12:00~14:00", "args": { "period": "12:00~14:00", "limit": 10 }, "expect": "browse" },
+  { "id": "uc3-tod-dated", "label": "UC3 dated time window 2026-07-03 09:00~12:00", "args": { "period": "2026-07-03 09:00~12:00", "limit": 10 }, "expect": "browse" },
+  { "id": "uc3-date", "label": "UC3 specific date 2026-07-02", "args": { "period": "2026-07-02", "limit": 10 }, "expect": "browse" },
+  { "id": "uc3-range", "label": "UC3 date range 2026-07-01~2026-07-03", "args": { "period": "2026-07-01~2026-07-03", "limit": 10 }, "expect": "browse" },
+  { "id": "uc4-topic", "label": "UC4 topic query", "args": { "query": "recall period last 개선", "limit": 8 }, "expect": "results" },
+  { "id": "uc4-topic-time", "label": "UC4 topic + time window", "args": { "query": "recall", "period": "24h", "limit": 8 }, "expect": "results" },
+  { "id": "uc4-topic-tod", "label": "UC4 topic + time-of-day", "args": { "query": "recall", "period": "12:00~15:00", "limit": 8 }, "expect": "results" },
+  { "id": "uc4-fanout", "label": "UC4 fan-out array query", "args": { "query": ["recall 개선", "battle balance"], "limit": 5 }, "expect": "results" },
+  { "id": "uc5-yesterday", "label": "UC5 calendar yesterday", "args": { "period": "yesterday", "limit": 10 }, "expect": "browse" },
+  { "id": "uc5-thisweek", "label": "UC5 calendar this_week", "args": { "period": "this_week", "limit": 10 }, "expect": "browse" },
+  { "id": "uc6-category", "label": "UC6 category decision 7d", "args": { "period": "7d", "category": "decision", "limit": 10 }, "expect": "browse" }
+]

package/scripts/recall-usecase-probe.json

@@ -0,0 +1,6 @@
+[
+  { "id": "t1", "label": "topic ko-en mixed", "args": { "query": "recall period last 개선", "limit": 8 }, "expect": "results" },
+  { "id": "t2", "label": "topic ko only", "args": { "query": "recall 개선", "limit": 8 }, "expect": "results" },
+  { "id": "t3", "label": "topic en only", "args": { "query": "recall period last improvement", "limit": 8 }, "expect": "results" },
+  { "id": "t4", "label": "category no-raw", "args": { "period": "7d", "category": "decision", "limit": 10, "includeRaw": false }, "expect": "browse" }
+]

package/scripts/session-bench.mjs

@@ -155,6 +155,10 @@ function grepSweepKey(row) {
 
 const GREP_SWEEP_MIN_CALLS = 20;
 const GREP_SWEEP_MIN_UNIQUE = 16;
+const READONLY_TOOL_NAMES = new Set(['read', 'grep', 'glob', 'list', 'find', 'code_graph', 'recall', 'explore', 'search', 'web_fetch']);
+const READONLY_STALL_MIN_RUN = 8;
+const READONLY_ROLE_AGENTS = new Set(['reviewer', 'explore', 'explorer', 'debugger']);
+const IDENTICAL_CALL_MIN_COUNT = 3;
 
 function fmtMs(ms) {
   const n = Number(ms);
@@ -313,6 +317,9 @@ function sessionMatches(id, query) {
 }
 
 function selectSessionIds(sessionMetas, query) {
+  if (String(query || '').trim().toLowerCase() === 'all') {
+    return sessionMetas.map((m) => m.session_id);
+  }
   let selected;
   if (!query || query === 'current') selected = chooseCurrentSession(sessionMetas);
   else selected = sessionMetas.find((m) => sessionMatches(m.session_id, query));
@@ -331,16 +338,27 @@ function selectSessionIds(sessionMetas, query) {
 function filterAgent(rows, agent) {
   if (!agent) return rows;
   const q = String(agent).toLowerCase();
-  return rows.filter((r) => {
+  const rowMatches = (r) => {
     const values = [
-      field(r, 'agent'),
       field(r, 'agent'),
       field(r, 'sourceName'),
       field(r, 'preset'),
       field(r, 'preset_name'),
     ].filter(Boolean).map((v) => String(v).toLowerCase());
     return values.some((v) => v.includes(q));
-  });
+  };
+  // Row-level agent fields only exist on some kinds (tool/steer); usage_raw and
+  // transport rows carry no agent. Filter at SESSION granularity: keep every
+  // row of any session where at least one row matches, so per-agent views keep
+  // their usage/cache/turn aggregates intact.
+  const matchedSessions = new Set();
+  for (const r of rows) {
+    if (rowMatches(r)) {
+      const sid = sessionId(r);
+      if (sid) matchedSessions.add(sid);
+    }
+  }
+  return rows.filter((r) => (sessionId(r) ? matchedSessions.has(sessionId(r)) : rowMatches(r)));
 }
 
 function buildRouteGroups(rows) {
@@ -384,6 +402,7 @@ function buildCacheDiagnostics(rows) {
   const transport = rows.filter((r) => r.kind === 'transport');
   const usage = rows.filter((r) => r.kind === 'usage_raw');
   const breaks = rows.filter((r) => r.kind === 'cache_break');
+  const misses = rows.filter((r) => r.kind === 'cache_miss');
   const keyCounts = new Map();
   for (const r of transport) {
     const key = field(r, 'cache_key_hash');
@@ -443,6 +462,20 @@ function buildCacheDiagnostics(rows) {
         ts: r.ts,
       };
     }),
+    actual_cache_misses: misses.map((r) => ({
+      session_id: sessionId(r),
+      iteration: num(r, 'iteration'),
+      reason: field(r, 'reason') || field(r, 'payload')?.reason || 'unknown',
+      ws_mode: field(r, 'ws_mode'),
+      cache_key_hash: field(r, 'cache_key_hash'),
+      request_has_previous_response_id: field(r, 'request_has_previous_response_id'),
+      prompt_tokens: num(r, 'prompt_tokens') || num(field(r, 'payload'), 'prompt_tokens') || 0,
+      cached_tokens: num(r, 'cached_tokens') || num(field(r, 'payload'), 'cached_tokens') || 0,
+      uncached_tokens: num(r, 'uncached_tokens') || num(field(r, 'payload'), 'uncached_tokens') || 0,
+      previous_max_cached_tokens: num(r, 'previous_max_cached_tokens') || num(field(r, 'payload'), 'previous_max_cached_tokens') || 0,
+      cache_ratio: num(r, 'cache_ratio') ?? num(field(r, 'payload'), 'cache_ratio'),
+      ts: r.ts,
+    })),
     service_tier_downgrades: downgrades,
     low_cache_turns: usage.map((r) => {
       const denom = cacheDenom(r);
@@ -452,10 +485,21 @@ function buildCacheDiagnostics(rows) {
   };
 }
 
+function summarizePathArg(pathValue) {
+  if (Array.isArray(pathValue)) {
+    const parts = pathValue.map((p) => (typeof p === 'string' ? p : `${p?.path || '?'}${p?.offset != null ? `:${p.offset}` : ''}`));
+    return `batch[${parts.length}] ${parts.slice(0, 3).join(', ')}${parts.length > 3 ? ', …' : ''}`;
+  }
+  return String(pathValue || '');
+}
+
 function summarizeToolTarget(row) {
   const args = toolArgs(row) || {};
   const name = String(field(row, 'tool_name') || '');
-  if (name === 'read') return `${args.path || '?'}:${args.line || args.offset || ''}`;
+  if (name === 'read') {
+    if (Array.isArray(args.path)) return summarizePathArg(args.path);
+    return `${args.path || '?'}:${args.line || args.offset || ''}`;
+  }
   if (name === 'grep') return `${args.path || '?'} :: ${String(args.pattern || '').slice(0, 80)}`;
   if (name === 'code_graph') return `${args.mode || '?'} ${args.file || ''} ${args.symbol || ''}`.trim();
   if (name === 'find') return `${args.path || '?'} :: ${args.query || ''}`;
@@ -731,6 +775,62 @@ function buildToolDiagnostics(rows, failureRows = []) {
     };
   }).sort((a, b) => b.count - a.count || b.tool_ms - a.tool_ms).slice(0, 20);
 
+  const readonlyStalls = [];
+  for (const [sid, srows] of groupBy(tools, sessionId).entries()) {
+    for (const [agent, arows] of groupBy(srows, (r) => field(r, 'agent') || field(r, 'sourceName') || '').entries()) {
+      const sorted = [...arows].sort((a, b) => Number(a.ts || 0) - Number(b.ts || 0));
+      let run = [];
+      const flushRun = () => {
+        const turns = new Set(run.map((r) => num(r, 'iteration')).filter((n) => n != null)).size;
+        if (turns >= READONLY_STALL_MIN_RUN) {
+          const pathCounts = countBy(run, (r) => summarizePathArg((toolArgs(r) || {}).path)).filter(([p]) => p).slice(0, 3);
+          readonlyStalls.push({
+            session_id: sid,
+            agent: agent || null,
+            run_length: run.length,
+            run_turns: turns,
+            start_it: num(run[0], 'iteration'),
+            end_it: num(run[run.length - 1], 'iteration'),
+            top_paths: pathCounts.map(([path, count]) => ({ path, count })),
+          });
+        }
+        run = [];
+      };
+      for (const row of sorted) {
+        const name = String(field(row, 'tool_name') || '');
+        if (!READONLY_TOOL_NAMES.has(name)) { flushRun(); continue; }
+        // A backwards iteration jump means a new prompt/steer restarted the
+        // loop; that is a fresh run, not a continuation of the same stall.
+        const it = num(row, 'iteration');
+        const prevIt = run.length ? num(run[run.length - 1], 'iteration') : null;
+        if (it != null && prevIt != null && it < prevIt) flushRun();
+        run.push(row);
+      }
+      flushRun();
+    }
+  }
+  readonlyStalls.sort((a, b) => (b.run_turns || 0) - (a.run_turns || 0) || b.run_length - a.run_length);
+
+  const identicalCallRepeats = [];
+  for (const [key, trows] of groupBy(
+    tools.filter((r) => toolResultKind(r) !== 'error'),
+    (r) => `${sessionId(r)}::${field(r, 'tool_name') || ''}::${toolArgsHash(r) || ''}`,
+  ).entries()) {
+    if (!toolArgsHash(trows[0])) continue;
+    const iterations = [...new Set(trows.map((r) => num(r, 'iteration')).filter((n) => n != null))];
+    if (iterations.length >= IDENTICAL_CALL_MIN_COUNT) {
+      const sorted = [...trows].sort((a, b) => Number(a.ts || 0) - Number(b.ts || 0));
+      identicalCallRepeats.push({
+        session_id: sessionId(sorted[0]),
+        tool: field(sorted[0], 'tool_name'),
+        args_hash: toolArgsHash(sorted[0]),
+        count: iterations.length,
+        iterations: iterations.slice(0, 6),
+      });
+    }
+  }
+  identicalCallRepeats.sort((a, b) => b.count - a.count);
+
   return {
     total_tool_calls: tools.length,
     total_tool_ms: sum(tools.map((r) => num(r, 'tool_ms'))),
@@ -748,6 +848,8 @@ function buildToolDiagnostics(rows, failureRows = []) {
       single_tool_batches: singleToolBatches.length,
     },
     sequential_tool_clusters: sequentialToolClusters,
+    readonly_stalls: readonlyStalls.slice(0, 20),
+    identical_call_repeats: identicalCallRepeats.slice(0, 20),
   };
 }
 
@@ -1067,22 +1169,52 @@ function buildCompactDiagnostics(rows, selectedIds) {
 
 function buildIssues(routeGroups, cache, tools) {
   const issues = [];
+  for (const stall of (tools.readonly_stalls || []).slice(0, 10)) {
+    const readonlyRole = READONLY_ROLE_AGENTS.has(String(stall.agent || '').toLowerCase());
+    const turns = stall.run_turns ?? stall.run_length;
+    issues.push({
+      severity: readonlyRole ? 'low' : (turns >= 15 ? 'high' : 'medium'),
+      type: 'readonly_stall',
+      message: `${stall.agent || shortId(stall.session_id)} readonly stall ${turns} turns/${stall.run_length} calls (it=${stall.start_it ?? '-'}..${stall.end_it ?? '-'})${readonlyRole ? ' [readonly role]' : ''} top paths: ${stall.top_paths.map((p) => `${p.path}×${p.count}`).join(', ') || '-'}`,
+      session_id: stall.session_id,
+    });
+  }
+  for (const rep of (tools.identical_call_repeats || []).slice(0, 10)) {
+    issues.push({
+      severity: 'medium',
+      type: 'identical_call_repeat',
+      message: `identical ${rep.tool} call x${rep.count} (hash=${rep.args_hash}) at it=${rep.iterations.join(',')}`,
+      session_id: rep.session_id,
+    });
+  }
   for (const g of routeGroups) {
+    // One-shot pseudo-sessions (native web search stamps `<caller>:native-search:<ts>`
+    // per send) have no loop, so full-WS/low-cache is their normal shape, not an issue.
+    if (/:native-search:/.test(String(g.session_id || ''))) continue;
     if (g.ws_full > 0 && g.ws_delta === 0 && g.transport_rows > 0) {
       issues.push({ severity: 'high', type: 'cache', message: `${g.agent || shortId(g.session_id)} stayed full WS (${g.ws_full} full, 0 delta)`, session_id: g.session_id });
     } else if (g.ws_full > 0) {
       issues.push({ severity: 'medium', type: 'cache', message: `${g.agent || shortId(g.session_id)} had ${g.ws_full} full WS turn(s) before delta`, session_id: g.session_id });
     }
-    if (g.cache_ratio != null && g.prompt_tokens > 5000 && g.cache_ratio < 0.25) {
+    // Sessions with <=2 turns (explorer-style ephemeral one-shots) have no
+    // prior turn to cache against; low ratio is structural, not actionable.
+    if (g.cache_ratio != null && g.prompt_tokens > 5000 && g.cache_ratio < 0.25 && (g.turns ?? 0) > 2) {
       issues.push({ severity: 'high', type: 'cache', message: `${g.agent || shortId(g.session_id)} low cache ratio ${fmtPct(g.cache_ratio * 100)}`, session_id: g.session_id });
     }
   }
   for (const b of cache.cache_breaks.slice(0, 10)) {
     issues.push({ severity: b.reason === 'no_anchor' ? 'medium' : 'high', type: 'cache_break', message: `cache_break ${b.reason || 'unknown'} at it=${b.iteration ?? '-'}`, session_id: b.session_id });
   }
+  for (const m of (cache.actual_cache_misses || []).slice(0, 10)) {
+    issues.push({ severity: 'high', type: 'cache_miss', message: `cache_miss ${m.reason || 'unknown'} at it=${m.iteration ?? '-'} uncached=${fmtTok(m.uncached_tokens)}`, session_id: m.session_id });
+  }
   if (cache.service_tier_downgrades.length) {
     const first = cache.service_tier_downgrades[0];
-    issues.push({ severity: 'medium', type: 'service_tier', message: `${cache.service_tier_downgrades.length} service tier downgrade(s), e.g. ${first.requested}->${first.response}`, session_id: first.session_id });
+    // priority->default is the backend's normal answer when the account/plan
+    // has no priority lane — expected, not actionable per session. Keep it
+    // visible as info-level; only other downgrade shapes stay medium.
+    const expected = cache.service_tier_downgrades.every((d) => d.requested === 'priority' && d.response === 'default');
+    issues.push({ severity: expected ? 'low' : 'medium', type: 'service_tier', message: `${cache.service_tier_downgrades.length} service tier downgrade(s), e.g. ${first.requested}->${first.response}${expected ? ' (expected: no priority lane on this account)' : ''}`, session_id: first.session_id });
   }
   if (tools.failures.length) {
     const byTool = new Map();
@@ -1146,6 +1278,10 @@ function buildWhySlowRankings(report) {
     const summary = countBy(report.cache.cache_breaks, (b) => `${b.reason || 'unknown'}/${b.phase || 'unknown'}`).slice(0, 3).map(([k, v]) => `${k}×${v}`).join(', ');
     ranks.push({ score: 40 + report.cache.cache_breaks.length, type: 'cache_breaks', message: `${report.cache.cache_breaks.length} cache break(s): ${summary}` });
   }
+  if (report.cache.actual_cache_misses?.length) {
+    const top = [...report.cache.actual_cache_misses].sort((a, b) => (b.uncached_tokens || 0) - (a.uncached_tokens || 0))[0];
+    ranks.push({ score: 60 + (top?.uncached_tokens || 0) / 1000, type: 'cache_miss', message: `${report.cache.actual_cache_misses.length} actual cache miss(es), top uncached=${fmtTok(top?.uncached_tokens || 0)} it=${top?.iteration ?? '-'}` });
+  }
   const topGrowth = report.tokens.growth_turns[0];
   if (topGrowth) {
     ranks.push({ score: Math.max(0, topGrowth.prompt_delta) / 1000, type: 'prompt_growth', message: `${topGrowth.agent || '-'} it=${topGrowth.turn_label} prompt Δ=${fmtTok(topGrowth.prompt_delta)} out=${fmtTok(topGrowth.output_tokens + topGrowth.thinking_tokens)} cache=${fmtPct((topGrowth.cache_ratio ?? 0) * 100)}` });
@@ -1173,6 +1309,10 @@ function buildExecutiveSummary(report) {
     const summary = countBy(report.cache.cache_breaks, (b) => `${b.reason || 'unknown'}/${b.phase || 'unknown'}`).slice(0, 3).map(([k, v]) => `${k}×${v}`).join(', ');
     lines.push(`캐시 깨짐=${report.cache.cache_breaks.length} (${summary})`);
   }
+  if (report.cache.actual_cache_misses?.length) {
+    const top = [...report.cache.actual_cache_misses].sort((a, b) => (b.uncached_tokens || 0) - (a.uncached_tokens || 0))[0];
+    lines.push(`실제 캐시 미스=${report.cache.actual_cache_misses.length} (top uncached=${fmtTok(top?.uncached_tokens || 0)})`);
+  }
   if (report.compact?.cache_breaks?.length) {
     const summary = countBy(report.compact.cache_breaks, (b) => `${b.reason || 'unknown'}/${b.phase || 'unknown'}`).slice(0, 3).map(([k, v]) => `${k}×${v}`).join(', ');
     lines.push(`컴팩트 호출=${report.compact.sessions.length} session, cache reset=${report.compact.cache_breaks.length} (${summary})`);
@@ -1344,6 +1484,12 @@ function renderText(report) {
         lines.push(`- ${shortId(b.session_id)} it=${b.iteration ?? '-'} phase=${b.phase || '-'} reason=${b.reason || '-'} (${b.explanation || '-'}) ws=${b.ws_mode || '-'} prev=${b.request_has_previous_response_id} cache=${fmtPct((b.cache_ratio ?? 0) * 100)} prompt=${fmtTok(b.prompt_tokens)} out=${fmtTok(b.output_tokens)} body/frame=${b.body_input_items ?? '-'}/${b.frame_input_items ?? '-'}`);
       }
     }
+    if (report.cache.actual_cache_misses?.length) {
+      lines.push('actual cache misses:');
+      for (const m of report.cache.actual_cache_misses.slice(0, 10)) {
+        lines.push(`- ${shortId(m.session_id)} it=${m.iteration ?? '-'} reason=${m.reason || '-'} ws=${m.ws_mode || '-'} prev=${m.request_has_previous_response_id} cache=${fmtPct((m.cache_ratio ?? 0) * 100)} prompt=${fmtTok(m.prompt_tokens)} uncached=${fmtTok(m.uncached_tokens)} prevMax=${fmtTok(m.previous_max_cached_tokens)}`);
+      }
+    }
     if (report.cache.service_tier_downgrades.length) {
       lines.push('service tier downgrades:');
       for (const d of report.cache.service_tier_downgrades.slice(0, 10)) lines.push(`- ${shortId(d.session_id)} it=${d.iteration ?? '-'} ${d.requested}->${d.response}`);