mixdog 0.9.3 → 0.9.4

package/scripts/freevar-smoke.mjs

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+/**
+ * scripts/freevar-smoke.mjs — undeclared-identifier gate for runtime source.
+ *
+ * Same engine as tui-render-smoke.mjs (acorn + eslint-scope) but pointed at
+ * the plain-ESM runtime sources instead of the TUI bundle. Any reference that
+ * resolves to no binding and is not a known Node global is a guaranteed
+ * ReferenceError on that code path — exactly the class of bug that section
+ * extractions leave behind on cold paths (missed import, orphaned helper).
+ *
+ * Run:  node scripts/freevar-smoke.mjs   (or `npm run smoke:freevars`)
+ * Exit: 0 = clean, 1 = undeclared identifiers found / parse failure.
+ */
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parse } from 'acorn';
+import { analyze } from 'eslint-scope';
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
+// Plain .mjs source roots. src/tui is covered by smoke:tui on the BUILT
+// bundle (App.jsx is JSX — acorn can't parse it raw); vendor is third-party.
+const SCAN_ROOTS = ['src/runtime', 'src/standalone', 'src/shared', 'scripts'].map(p => join(ROOT, p));
+const SKIP_DIRS = new Set(['node_modules', 'dist', '.git']);
+
+const KNOWN_GLOBALS = new Set([
+  'Array', 'ArrayBuffer', 'Atomics', 'BigInt', 'BigInt64Array', 'BigUint64Array', 'Boolean',
+  'DataView', 'Date', 'Error', 'EvalError', 'FinalizationRegistry', 'Float32Array',
+  'Float64Array', 'Function', 'Infinity', 'Int8Array', 'Int16Array', 'Int32Array',
+  'Intl', 'JSON', 'Map', 'Math', 'NaN', 'Number', 'Object', 'Promise', 'Proxy',
+  'RangeError', 'ReferenceError', 'Reflect', 'RegExp', 'Set', 'SharedArrayBuffer',
+  'String', 'Symbol', 'SyntaxError', 'TypeError', 'URIError', 'Uint8Array',
+  'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap', 'WeakRef', 'WeakSet',
+  'decodeURI', 'decodeURIComponent', 'encodeURI', 'encodeURIComponent', 'eval',
+  'globalThis', 'isFinite', 'isNaN', 'parseFloat', 'parseInt', 'undefined',
+  'AbortController', 'AbortSignal', 'Blob', 'Buffer', 'ByteLengthQueuingStrategy',
+  'CompressionStream', 'CountQueuingStrategy', 'Crypto', 'CryptoKey', 'CustomEvent',
+  'DecompressionStream', 'Event', 'EventTarget', 'File', 'FormData', 'Headers',
+  'MessageChannel', 'MessageEvent', 'MessagePort', 'Navigator', 'PerformanceEntry',
+  'PerformanceObserver', 'ReadableStream', 'ReadableStreamDefaultReader', 'Request',
+  'Response', 'SubtleCrypto', 'TextDecoder', 'TextDecoderStream', 'TextEncoder',
+  'TextEncoderStream', 'TransformStream', 'URL', 'URLSearchParams', 'WebAssembly',
+  'WebSocket', 'WritableStream', 'atob', 'btoa', 'clearImmediate', 'clearInterval',
+  'clearTimeout', 'console', 'crypto', 'fetch', 'navigator', 'performance',
+  'process', 'queueMicrotask', 'require', 'setImmediate', 'setInterval',
+  'setTimeout', 'structuredClone', 'reportError',
+  // Browser globals: legal inside puppeteer page.evaluate() callbacks, which
+  // execute in the BROWSER context (web-tools.mjs scrapers).
+  'document', 'window',
+]);
+
+function* walk(dir) {
+  for (const name of readdirSync(dir)) {
+    if (SKIP_DIRS.has(name)) continue;
+    const p = join(dir, name);
+    const st = statSync(p);
+    if (st.isDirectory()) yield* walk(p);
+    else if (name.endsWith('.mjs')) yield p;
+  }
+}
+
+let failures = 0;
+let scanned = 0;
+for (const root of SCAN_ROOTS) {
+  let files;
+  try { files = [...walk(root)]; } catch { continue; }
+  for (const file of files) {
+    scanned++;
+    const source = readFileSync(file, 'utf8');
+    let ast;
+    try {
+      ast = parse(source, { ecmaVersion: 'latest', sourceType: 'module', locations: true, ranges: true });
+    } catch (err) {
+      failures++;
+      console.error(`freevar-smoke: PARSE FAIL ${relative(ROOT, file)}: ${err.message}`);
+      continue;
+    }
+    const scopeManager = analyze(ast, { ecmaVersion: 2022, sourceType: 'module' });
+    const seen = new Set();
+    for (const ref of scopeManager.globalScope.through) {
+      const { name } = ref.identifier;
+      if (KNOWN_GLOBALS.has(name) || seen.has(name)) continue;
+      seen.add(name);
+      failures++;
+      const loc = ref.identifier.loc?.start;
+      console.error(`freevar-smoke: FAIL ${relative(ROOT, file)}:${loc ? `${loc.line}:${loc.column}` : '?'} — undeclared identifier \`${name}\``);
+    }
+  }
+}
+
+if (failures > 0) {
+  console.error(`freevar-smoke: ${failures} problem(s) across ${scanned} files — these are ReferenceErrors waiting on their code path.`);
+  process.exit(1);
+}
+console.log(`freevar-smoke: ok — ${scanned} files, no undeclared identifiers`);

package/scripts/internal-comms-bench.mjs

@@ -36,6 +36,7 @@ const RULE_FILES = [
   'agents/debugger/AGENT.md',
   'workflows/default/WORKFLOW.md',
   'rules/lead/lead-tool.md',
+  'rules/lead/lead-brief.md',
 ];
 
 const DEFAULT_WORKER_PROMPT =

package/scripts/internal-comms-smoke.mjs

@@ -24,17 +24,18 @@ function flat(text) {
   return String(text || '').replace(/\s+/g, ' ');
 }
 
-// --- Lead brief contract: canonical in lead-tool.md, referenced from WORKFLOW -
+// --- Lead brief contract: canonical in lead-brief.md, referenced from WORKFLOW -
 const workflow = readSrc('workflows', 'default', 'WORKFLOW.md');
-const leadTool = readSrc('rules', 'lead', 'lead-tool.md');
+const leadBrief = readSrc('rules', 'lead', 'lead-brief.md');
 const BRIEF_FIELDS = ['Goal:', 'Anchors:', 'Allow/Forbid:', 'Deliver:', 'Verify:'];
-// Canonical brief contract lives in lead-tool.md (Lead tool-use rules).
-assert(/minimum characters, maximum information/i.test(flat(leadTool)), 'lead-tool.md: brief must state min-char/max-info principle');
-for (const field of BRIEF_FIELDS) assert(leadTool.includes(field), `lead-tool.md: brief missing labeled field ${field}`);
-assert(leadTool.includes('Stop:'), 'lead-tool.md: brief must add Stop: for heavy-worker bound');
-assert(/role-known|already (?:owns|knows)|wasted cost|wasted/i.test(flat(leadTool)), 'lead-tool.md: brief must ban restating known rules/background as cost');
-// WORKFLOW.md must not duplicate the field list; it defers to the lead-tool contract.
-assert(/lead-tool brief contract/i.test(flat(workflow)), 'WORKFLOW.md: must defer to the lead-tool brief contract');
+// Canonical brief contract lives in lead-brief.md (Lead brief contract).
+assert(/minimum characters, maximum information/i.test(flat(leadBrief)), 'lead-brief.md: brief must state min-char/max-info principle');
+for (const field of BRIEF_FIELDS) assert(leadBrief.includes(field), `lead-brief.md: brief missing labeled field ${field}`);
+assert(leadBrief.includes('Stop:'), 'lead-brief.md: brief must add Stop: for heavy-worker bound');
+assert(/role-known|already (?:owns|knows)|wasted cost|wasted/i.test(flat(leadBrief)), 'lead-brief.md: brief must ban restating known rules/background as cost');
+assert(/authoritative/i.test(flat(leadBrief)), 'lead-brief.md: brief must state spec-file precedence over summary');
+// WORKFLOW.md must not duplicate the field list; it defers to the lead brief contract.
+assert(/lead brief contract/i.test(flat(workflow)), 'WORKFLOW.md: must defer to the lead brief contract');
 assert(!BRIEF_FIELDS.every((field) => workflow.includes(field)), 'WORKFLOW.md: must not duplicate the full brief field list');
 
 // --- Agent handoff contract (00-common.md) ---------------------------------

package/scripts/mouse-probe.mjs

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+/**
+ * scripts/mouse-probe.mjs — raw SGR mouse event probe.
+ *
+ * Enables the same SGR mouse tracking the TUI uses and prints every mouse
+ * escape sequence it receives, decoded (button id + modifier bits + coords).
+ * Use it to see EXACTLY what the terminal sends for ctrl+wheel — if the ctrl
+ * bit (16) never appears, the terminal is not forwarding the modifier and the
+ * app-side zoom passthrough can never trigger.
+ *
+ * Run:  node scripts/mouse-probe.mjs   (q or Ctrl+C to quit)
+ */
+const ON = '\x1b[?1000h\x1b[?1002h\x1b[?1006h';
+const OFF = '\x1b[?1006l\x1b[?1002l\x1b[?1000l';
+const MOUSE = /\x1b\[<(\d+);(\d+);(\d+)([Mm])/g;
+
+process.stdout.write(ON);
+process.stdout.write('mouse-probe: wheel / ctrl+wheel / click here. q to quit.\n');
+process.stdin.setRawMode(true);
+process.stdin.resume();
+
+const cleanup = () => {
+  process.stdout.write(OFF);
+  process.stdin.setRawMode(false);
+  process.exit(0);
+};
+process.on('SIGINT', cleanup);
+
+process.stdin.on('data', (buf) => {
+  const s = buf.toString('utf8');
+  if (s === 'q' || s === '\x03') return cleanup();
+  let m; MOUSE.lastIndex = 0;
+  let sawMouse = false;
+  while ((m = MOUSE.exec(s)) !== null) {
+    sawMouse = true;
+    const b = Number(m[1]);
+    const mods = [b & 4 ? 'shift' : '', b & 8 ? 'alt' : '', b & 16 ? 'ctrl' : ''].filter(Boolean).join('+') || 'none';
+    const base = b & ~(4 | 8 | 16);
+    const kind = base === 64 ? 'wheel-up' : base === 65 ? 'wheel-down' : base === 0 ? 'left' : base === 2 ? 'right' : (b & 32) ? 'motion' : `btn${base}`;
+    process.stdout.write(`button=${b} base=${base} kind=${kind} mods=${mods} x=${m[2]} y=${m[3]} ${m[4] === 'M' ? 'press' : 'release'}\n`);
+  }
+  if (!sawMouse && s.startsWith('\x1b')) {
+    process.stdout.write(`non-mouse escape: ${JSON.stringify(s)}\n`);
+  }
+});

package/scripts/output-style-bench.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// Lead output-style verbosity bench (default >= simple >= minimal >= oneline).
+// Lead output-style verbosity bench (default >= simple >= minimal >= extreme-minimal).
 import { createRequire } from 'node:module';
 import { execFileSync } from 'node:child_process';
 import {
@@ -19,7 +19,7 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 const __dir = dirname(fileURLToPath(import.meta.url));
 const REPO_ROOT = resolve(__dir, '..');
 const PLUGIN_ROOT = join(REPO_ROOT, 'src');
-const STYLES = ['default', 'simple', 'minimal', 'oneline'];
+const STYLES = ['default', 'simple', 'minimal', 'extreme-minimal'];
 const DEFAULT_PROMPT =
   'Reply in plain English only. What is 2+2? Give a short summary suitable for a status report (no tools, no file reads).';
 const MODEL_ALIASES = {
@@ -85,10 +85,10 @@ function runInjectionScaffold() {
     ? JSON.parse(readFileSync(templatePath, 'utf8'))
     : { outputStyle: 'default' };
   const markers = {
-    default: 'most detailed of the three',
+    default: 'most detailed style',
     simple: 'Practical concise',
     minimal: 'a very short summary',
-    oneline: 'exactly one sentence',
+    'extreme-minimal': 'exactly one sentence',
   };
   const snippets = {};
   try {
@@ -179,11 +179,18 @@ function runLiveLeadTurn({ dataDir, prompt, provider, model, cwd, effort, fast }
     `let result;`,
     `try { result = await askSession(session.id, ${JSON.stringify(prompt)}, null, null, ${JSON.stringify(cwd)}); }`,
     `finally { try { closeSession(session.id, 'output-style-bench'); } catch {} }`,
-    `process.stdout.write(JSON.stringify({ text: String(result?.text || result?.content || '').trim(), sessionId: session.id }));`,
+    // Pooled provider sockets (e.g. openai-oauth WS, 20-min idle TTL) keep the
+    // child alive after the turn; flush JSON then force-exit so execFileSync
+    // returns as soon as the turn completes.
+    `const payload = JSON.stringify({ text: String(result?.text || result?.content || '').trim(), sessionId: session.id });`,
+    `await new Promise((r) => process.stdout.write(payload, r));`,
+    `process.exit(0);`,
   ].filter(Boolean).join('\n');
   const raw = execFileSync('node', ['--input-type=module', '-e', driver], {
     encoding: 'utf8',
     maxBuffer: 64 * 1024 * 1024,
+    timeout: Number(process.env.OUTPUT_STYLE_BENCH_TURN_TIMEOUT_MS || 10 * 60_000),
+    killSignal: 'SIGKILL',
     env: { ...process.env, MIXDOG_ROOT: PLUGIN_ROOT, MIXDOG_DATA_DIR: dataDir },
   });
   const jsonStart = raw.lastIndexOf('{');
@@ -209,7 +216,7 @@ function evaluateVerbosityOrdering(results) {
   return { orderingOk, verdict, counts: styleCharCountsFromResults(results) };
 }
 function printUsage() {
-  process.stdout.write(`output-style-bench — Lead verbosity ladder (default >= simple >= minimal >= oneline).
+  process.stdout.write(`output-style-bench — Lead verbosity ladder (default >= simple >= minimal >= extreme-minimal).
 
 Output style is Lead-only (buildLeadMetaContent when owner is not agent).
 runHeadlessRole worker paths (owner=agent) do NOT inject outputStyle.

package/scripts/output-style-smoke.mjs

@@ -49,8 +49,8 @@ const defaultStyle = readFileSync(join(root, 'src', 'output-styles', 'default.md
 for (const required of [
   'name: default',
   'Concise engineering summaries',
-  'Mixdog default — the most detailed of the three styles',
-  'match length to the work',
+  'Mixdog default — the most detailed style',
+  'State conclusions, not reasoning',
   'Use labels such as',
   '`바뀐 점`, `확인한 것`,',
   'Synthesize agent or retrieval results',
@@ -72,7 +72,7 @@ for (const required of [
   'controlled detail',
   'Synthesize agent or retrieval results',
   'Do not hide blockers',
-  'if verification was',
+  'verification was not run, say so once',
 ]) {
   assert(simpleStyle.includes(required), `simple.md missing: ${required}`);
 }
@@ -81,7 +81,7 @@ for (const [name, style] of Object.entries({
   default: defaultStyle,
   simple: simpleStyle,
   minimal: readFileSync(join(root, 'src', 'output-styles', 'minimal.md'), 'utf8'),
-  oneline: readFileSync(join(root, 'src', 'output-styles', 'oneline.md'), 'utf8'),
+  'extreme-minimal': readFileSync(join(root, 'src', 'output-styles', 'extreme-minimal.md'), 'utf8'),
 })) {
   assert(!style.includes('pre-tool preamble'), `${name} output style must not own language preamble rules`);
   assert(!style.includes('selected/default user language'), `${name} output style must not duplicate profile language rules`);

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-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}`);