mixdog 0.9.3 → 0.9.5

package/scripts/recall-bench.mjs

@@ -68,27 +68,67 @@ function textOfResult(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;
+  return resultLines(text).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:'))
+  return resultLines(text)
     .slice(0, n)
     .map((line) => (line.length > maxLen ? `${line.slice(0, maxLen - 1)}…` : line));
 }
 
-function evaluateCase(kase, { count, ms, isError }) {
+// Full ordered list of result lines (no slice), used for topNContains rank
+// scoring. Same filtering rule as countEntryLines/topN.
+function resultLines(text) {
+  const t = String(text || '').trim();
+  if (!t || t === '(no results)' || t === '(no valid ids)') return [];
+  return t.split('\n').filter((line) => {
+    const trimmed = line.trim();
+    return trimmed
+      && !trimmed.startsWith('[recall truncated')
+      && !trimmed.startsWith('note:')
+      && !/^\[[^\]]+\]$/.test(trimmed);
+  });
+}
+
+// Score expect.topNContains: for each expected substring, find the 1-indexed
+// rank of the first result line containing it (case-insensitive), over the
+// FULL result list (not just the topN cutoff) so we can tell "missed
+// entirely" from "present but ranked below cutoff". hit@N/MRR are then
+// computed against the topN cutoff.
+function scoreTopNContains(lines, substrings, n) {
+  const lower = lines.map((l) => l.toLowerCase());
+  const perSubstring = substrings.map((needle) => {
+    const hay = String(needle || '').toLowerCase();
+    let rank = null;
+    for (let i = 0; i < lower.length; i++) {
+      if (hay && lower[i].includes(hay)) { rank = i + 1; break; }
+    }
+    const hit = rank !== null && rank <= n;
+    return { needle, rank, hit, rr: hit ? 1 / rank : 0 };
+  });
+  const total = perSubstring.length || 1;
+  const hitAtN = perSubstring.reduce((s, p) => s + (p.hit ? 1 : 0), 0) / total;
+  const mrr = perSubstring.reduce((s, p) => s + p.rr, 0) / total;
+  return { perSubstring, hitAtN, mrr, n };
+}
+
+function evaluateCase(kase, { count, ms, isError }, quality) {
   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)');
   }
+  if (quality) {
+    for (const p of quality.perSubstring) {
+      if (!p.hit) {
+        warnings.push(p.rank === null
+          ? `topNContains miss: "${p.needle}" not found in results`
+          : `topNContains miss: "${p.needle}" found at rank ${p.rank} > topN ${quality.n}`);
+      }
+    }
+  }
   const status = warnings.length ? 'WARN' : 'PASS';
   return { status, warnings };
 }
@@ -109,7 +149,14 @@ async function runCase(memoryModule, kase) {
   const ms = Date.now() - started;
   const text = textOfResult(result);
   const count = countEntryLines(text);
-  const evalResult = evaluateCase(kase, { count, ms, isError });
+  // expect stays a plain string for legacy cases ('results'/'browse'/'idlookup').
+  // New quality cases use an object: { kind?, topNContains: [...], topN? }.
+  const expectObj = kase.expect && typeof kase.expect === 'object' ? kase.expect : null;
+  const expectKind = expectObj ? expectObj.kind : kase.expect;
+  const topNContains = expectObj && Array.isArray(expectObj.topNContains) ? expectObj.topNContains : null;
+  const cutoffN = expectObj && Number.isInteger(expectObj.topN) ? expectObj.topN : 5;
+  const quality = topNContains ? scoreTopNContains(resultLines(text), topNContains, cutoffN) : null;
+  const evalResult = evaluateCase({ ...kase, expect: expectKind }, { count, ms, isError }, quality);
   return {
     id: kase.id,
     label: kase.label,
@@ -119,6 +166,7 @@ async function runCase(memoryModule, kase) {
     isError,
     errMsg,
     top3: topN(text, 3),
+    quality,
     status: evalResult.status,
     warnings: evalResult.warnings,
   };
@@ -128,6 +176,12 @@ 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.quality) {
+    process.stdout.write(`  hit@${row.quality.n}: ${row.quality.hitAtN.toFixed(2)}  MRR: ${row.quality.mrr.toFixed(2)}\n`);
+    for (const p of row.quality.perSubstring) {
+      process.stdout.write(`    substr "${p.needle}" -> rank ${p.rank ?? 'none'}${p.hit ? '' : '  (miss)'}\n`);
+    }
+  }
   if (row.top3.length) {
     for (const line of row.top3) process.stdout.write(`    - ${line}\n`);
   } else {
@@ -138,18 +192,27 @@ function printCase(row) {
 
 function printSummary(rows) {
   process.stdout.write('\n=== recall-bench summary ===\n');
-  const widths = { id: 18, results: 8, ms: 8, status: 6 };
+  const widths = { id: 18, results: 8, ms: 8, status: 6, hit: 9, mrr: 7 };
   process.stdout.write(
-    `${'case'.padEnd(widths.id)}${'results'.padEnd(widths.results)}${'ms'.padEnd(widths.ms)}${'status'.padEnd(widths.status)}notes\n`,
+    `${'case'.padEnd(widths.id)}${'results'.padEnd(widths.results)}${'ms'.padEnd(widths.ms)}${'status'.padEnd(widths.status)}${'hit@N'.padEnd(widths.hit)}${'MRR'.padEnd(widths.mrr)}notes\n`,
   );
   for (const r of rows) {
+    const hitStr = r.quality ? r.quality.hitAtN.toFixed(2) : '-';
+    const mrrStr = r.quality ? r.quality.mrr.toFixed(2) : '-';
     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`,
+      `${String(r.id).padEnd(widths.id)}${String(r.count).padEnd(widths.results)}${String(r.ms).padEnd(widths.ms)}${String(r.status).padEnd(widths.status)}${hitStr.padEnd(widths.hit)}${mrrStr.padEnd(widths.mrr)}${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`);
+  const qualityRows = rows.filter((r) => r.quality);
+  let aggLine = '';
+  if (qualityRows.length) {
+    const aggHit = qualityRows.reduce((s, r) => s + r.quality.hitAtN, 0) / qualityRows.length;
+    const aggMrr = qualityRows.reduce((s, r) => s + r.quality.mrr, 0) / qualityRows.length;
+    aggLine = `  agg_hit@N=${aggHit.toFixed(3)} agg_MRR=${aggMrr.toFixed(3)} (${qualityRows.length} scored cases)`;
+  }
+  process.stdout.write(`\ncases=${rows.length} pass=${rows.length - warnCount} warn=${warnCount} total_latency=${totalMs}ms${aggLine}\n`);
 }
 
 async function main() {

package/scripts/recall-quality-cases.json

@@ -0,0 +1,12 @@
+[
+  { "id": "q-kr-recall-phrase", "label": "Korean distinctive phrase: persistent memory", "args": { "query": "영속 메모리" }, "expect": { "kind": "results", "topNContains": ["영속 메모리"], "topN": 5 } },
+  { "id": "q-en-recall-pipeline", "label": "English distinctive phrase: recall fast-track builder", "args": { "query": "buildRecallFastTrackQuery" }, "expect": { "kind": "results", "topNContains": ["buildRecallFastTrackQuery"], "topN": 5 } },
+  { "id": "q-cycle1-drain", "label": "cycle1 ECONNRESET topic", "args": { "query": "cycle1 ECONNRESET" }, "expect": { "kind": "results", "topNContains": ["cycle1", "ECONNRESET"], "topN": 5 } },
+  { "id": "q-recall-general", "label": "bare recall keyword", "args": { "query": "recall" }, "expect": { "kind": "results", "topNContains": ["recall"], "topN": 5 } },
+  { "id": "q-uc4-topic-kr", "label": "UC4 topic query with Korean qualifier", "args": { "query": "recall period last 개선", "limit": 8 }, "expect": { "kind": "results", "topNContains": ["개선"], "topN": 5 } },
+  { "id": "q-recall-improve-kr", "label": "cache improvement topic", "args": { "query": "캐시 개선" }, "expect": { "kind": "results", "topNContains": ["개선"], "topN": 5 } },
+  { "id": "q-battle-balance", "label": "ProjectAA topic", "args": { "query": "ProjectAA" }, "expect": { "kind": "results", "topNContains": ["ProjectAA"], "topN": 5 } },
+  { "id": "q-fanout-recall-battle", "label": "fan-out array query cache+ProjectAA", "args": { "query": ["캐시 개선", "ProjectAA"], "limit": 5 }, "expect": { "kind": "results", "topNContains": ["개선", "ProjectAA"], "topN": 10 } },
+  { "id": "q-short-2tok-cycle", "label": "short 2-token cycle1 query", "args": { "query": "cycle1 drain", "limit": 8 }, "expect": { "kind": "results", "topNContains": ["cycle1"], "topN": 3 } },
+  { "id": "q-recall-scope-project", "label": "project-scoped recall query", "args": { "query": "recall", "cwd": "C:\\Project\\mixdog" , "limit": 10 }, "expect": { "kind": "results", "topNContains": ["recall"], "topN": 5 } }
+]

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

package/scripts/tool-smoke.mjs

@@ -11,7 +11,7 @@ import { buildHeadlessSpawnArgs } from '../src/headless-role.mjs';
 import { createStandaloneChannelWorker } from '../src/standalone/channel-worker.mjs';
 import { OpenAIOAuthProvider, buildRequestBody, sendViaHttpSse } from '../src/runtime/agent/orchestrator/providers/openai-oauth.mjs';
 import { _test as _anthropicOAuthTest } from '../src/runtime/agent/orchestrator/providers/anthropic-oauth.mjs';
-import { _logicalResponseItemMatch, _resolveOpenAiPromptCacheRatePolicy } from '../src/runtime/agent/orchestrator/providers/openai-oauth-ws.mjs';
+import { _logicalResponseItemMatch } from '../src/runtime/agent/orchestrator/providers/openai-oauth-ws.mjs';
 import { _mergePendingMessageEntries, applyAskTerminalUsageTotals, closeSession, createSession, drainPendingMessages, enqueuePendingMessage, resumeSession } from '../src/runtime/agent/orchestrator/session/manager.mjs';
 import {
   contentHasImage,
@@ -137,46 +137,6 @@ function assertOk(name, result, pattern = null) {
 }
 
 {
-  const fullPolicy = _resolveOpenAiPromptCacheRatePolicy({}, {
-    mode: 'full',
-    frameInputItems: 40,
-    deltaTokens: 9000,
-    hasPreviousResponseId: false,
-  });
-  assert(fullPolicy.policy === 'full_guard' && fullPolicy.limitPerMin === 12, `full cache lane should keep 12rpm guard: ${JSON.stringify(fullPolicy)}`);
-
-  const deltaPolicy = _resolveOpenAiPromptCacheRatePolicy({}, {
-    mode: 'delta',
-    frameInputItems: 1,
-    deltaTokens: 9000,
-    hasPreviousResponseId: true,
-  });
-  assert(deltaPolicy.policy === 'delta_relaxed' && deltaPolicy.limitPerMin === 60, `small delta should use relaxed cache lane rpm: ${JSON.stringify(deltaPolicy)}`);
-
-  const largeDeltaPolicy = _resolveOpenAiPromptCacheRatePolicy({}, {
-    mode: 'delta',
-    frameInputItems: 20,
-    deltaTokens: 9000,
-    hasPreviousResponseId: true,
-  });
-  assert(largeDeltaPolicy.policy === 'delta_guarded' && largeDeltaPolicy.limitPerMin === 12, `large delta should fall back to full guard: ${JSON.stringify(largeDeltaPolicy)}`);
-
-  const customDeltaPolicy = _resolveOpenAiPromptCacheRatePolicy({ openaiCacheLaneDeltaRateLimitPerMin: 90 }, {
-    mode: 'delta',
-    frameInputItems: 1,
-    deltaTokens: 9000,
-    hasPreviousResponseId: true,
-  });
-  assert(customDeltaPolicy.limitPerMin === 90, `custom delta rpm should be honored: ${JSON.stringify(customDeltaPolicy)}`);
-
-  const unlimitedDeltaPolicy = _resolveOpenAiPromptCacheRatePolicy({ openaiCacheLaneDeltaRateLimitPerMin: 0 }, {
-    mode: 'delta',
-    frameInputItems: 1,
-    deltaTokens: 9000,
-    hasPreviousResponseId: true,
-  });
-  assert(unlimitedDeltaPolicy.policy === 'delta_unlimited' && unlimitedDeltaPolicy.limitPerMin === 0, `delta rpm=0 should disable delta rate wait: ${JSON.stringify(unlimitedDeltaPolicy)}`);
-
   const originalFunctionCall = {
     type: 'function_call',
     call_id: 'call_tool_1',
@@ -589,20 +549,28 @@ if (grepContextPolicyArgs['-C'] !== GREP_CONTEXT_MAX || Object.prototype.hasOwnP
   throw new Error(`grep context policy must canonicalize and clamp explicit context: ${JSON.stringify(grepContextPolicyArgs)}`);
 }
 
-const invalidGrepPath = validateBuiltinArgs('grep', {
+// Multiple absolute paths in one string are now auto-split into a path array
+// (arg-guard splitMultipleAbsoluteWindowsPaths) instead of rejected.
+const multiGrepPathArgs = {
   pattern: 'providerStatus',
   path: 'C:\\Project\\mixdog\\src\\tui C:\\Project\\mixdog\\src\\mixdog-session-runtime.mjs',
-});
-if (!/multiple absolute paths/i.test(invalidGrepPath || '')) {
-  throw new Error(`grep multi-path guard failed: ${invalidGrepPath}`);
+};
+const multiGrepPathErr = validateBuiltinArgs('grep', multiGrepPathArgs);
+if (multiGrepPathErr) {
+  throw new Error(`grep multi-path auto-split should pass validation: ${multiGrepPathErr}`);
+}
+if (!Array.isArray(multiGrepPathArgs.path) || multiGrepPathArgs.path.length !== 2) {
+  throw new Error(`grep multi-path auto-split should coerce to 2-element array: ${JSON.stringify(multiGrepPathArgs.path)}`);
 }
 
-const invalidGrepLookaround = validateBuiltinArgs('grep', {
+// Lookaround/backrefs are no longer rejected at validation time: search-tool
+// routes them to rg --pcre2 at runtime (arg-guard.mjs comment near globKeys).
+const lookaroundGrepErr = validateBuiltinArgs('grep', {
   pattern: 'C:\\\\Project(?!\\\\mixdog)',
   path: root,
 });
-if (!/lookaround\/backrefs/i.test(invalidGrepLookaround || '')) {
-  throw new Error(`grep unsupported-regex guard failed: ${invalidGrepLookaround}`);
+if (lookaroundGrepErr) {
+  throw new Error(`grep lookaround pattern should pass validation (PCRE2 runtime routing): ${lookaroundGrepErr}`);
 }
 
 // Windows drive path + no explicit shell used to be rejected with a retry hint;
@@ -991,10 +959,7 @@ setInternalToolsProvider({
     { name: 'recall', description: 'Memory recall surface.', inputSchema: { type: 'object', properties: {} }, annotations: { readOnlyHint: true } },
     { name: 'search', description: 'Web search surface.', inputSchema: { type: 'object', properties: {} }, annotations: { readOnlyHint: true, openWorldHint: true } },
     { name: 'reply', description: 'Channel reply surface.', inputSchema: { type: 'object', properties: {} }, annotations: { destructiveHint: true } },
-    { name: 'edit_message', description: 'Channel edit surface.', inputSchema: { type: 'object', properties: {} }, annotations: { destructiveHint: true } },
     { name: 'web_fetch', description: 'Web fetch surface.', inputSchema: { type: 'object', properties: {} }, annotations: { readOnlyHint: true, openWorldHint: true } },
-    { name: 'reload_config', description: 'Config reload surface.', inputSchema: { type: 'object', properties: {} }, annotations: { destructiveHint: true } },
-    { name: 'inject_command', description: 'Command injection surface.', inputSchema: { type: 'object', properties: {} }, annotations: { destructiveHint: true } },
   ],
 });
 {
@@ -1197,12 +1162,12 @@ setInternalToolsProvider({
     if (readTools.includes('shell') || writeTools.includes('shell')) {
       throw new Error(`read/read-write agent schemas must omit shell: read=${readTools.join(', ')} write=${writeTools.join(', ')}`);
     }
-    for (const name of ['shell', 'apply_patch', 'task', 'diagnostics', 'open_config']) {
+    for (const name of ['shell', 'apply_patch', 'task']) {
       if (readTools.includes(name)) {
         throw new Error(`read agent schema must omit non-read tool ${name}: read=${readTools.join(', ')}`);
       }
     }
-    for (const name of ['apply_patch', 'task', 'diagnostics']) {
+    for (const name of ['apply_patch', 'task']) {
       if (name === 'apply_patch' && !writeTools.includes(name)) {
         throw new Error(`read-write agent schema must preserve apply_patch: write=${writeTools.join(', ')}`);
       }
@@ -1210,12 +1175,7 @@ setInternalToolsProvider({
         throw new Error(`read-write agent schema must omit non-edit tool ${name}: write=${writeTools.join(', ')}`);
       }
     }
-    for (const name of ['open_config']) {
-      if (writeTools.includes(name)) {
-        throw new Error(`read-write agent schema must omit config/skill tool ${name}: write=${writeTools.join(', ')}`);
-      }
-    }
-    for (const name of ['memory', 'recall', 'reply', 'edit_message', 'reload_config', 'inject_command']) {
+    for (const name of ['memory', 'recall', 'reply']) {
       if (readTools.includes(name) || writeTools.includes(name)) {
         throw new Error(`read/read-write agent schema must not expose full-runtime internal tool ${name}: read=${readTools.join(', ')} write=${writeTools.join(', ')}`);
       }
@@ -1293,7 +1253,7 @@ setInternalToolsProvider({
   const hiddenAgents = JSON.parse(readFileSync(join(root, 'src', 'defaults', 'agents.json'), 'utf8')).agents || [];
   const hiddenPreset = { id: 'hidden-smoke', name: 'hidden-smoke', type: 'agent', provider: 'openai-oauth', model: 'tool-smoke-model', tools: 'full' };
   const hiddenRuntimeSpec = { scopeKey: 'hidden-role-smoke', lane: 'agent' };
-  const hiddenBadTools = new Set(['shell', 'task', 'diagnostics', 'open_config', 'Skill', 'memory', 'reply', 'edit_message', 'recall', 'reload_config', 'inject_command']);
+  const hiddenBadTools = new Set(['shell', 'task', 'Skill', 'memory', 'reply', 'recall']);
   const expectedForHiddenAgent = (permission, schemaAllowedTools) => {
     if (Array.isArray(schemaAllowedTools)) return schemaAllowedTools.slice();
     if (permission === 'none') return [];
@@ -1517,13 +1477,13 @@ if (!/before text grep/i.test(codeGraphDescription)) {
 if (!/repo-local/i.test(codeGraphDescription) || !/NOT web search|not web/i.test(codeGraphDescription)) {
   throw new Error('code_graph description must mark itself repo-local (not web search)');
 }
-if (!/repo-local|not web/i.test(codeGraphProps.mode?.description || '') || !/source file/i.test(codeGraphProps.file?.description || '')) {
+if (!/repo-local|not web/i.test(codeGraphProps.mode?.description || '') || !/source file/i.test(codeGraphProps.files?.description || '')) {
   throw new Error('code_graph schema must keep compact, repo-local field descriptions');
 }
 const recallTool = MEMORY_TOOL_DEFS.find((tool) => tool.name === 'recall');
 const recallProps = recallTool?.inputSchema?.properties || {};
-if (!/when in doubt, recall first/i.test(recallTool?.description || '') || !recallProps.id?.anyOf || !/Do not invent ids/i.test(recallProps.id?.description || '')) {
-  throw new Error('recall schema must preserve prior-context guidance and id lookup shape');
+if (!/Use only to check prior conversation or past events/i.test(recallTool?.description || '') || !recallProps.id?.anyOf || !/Do not invent ids/i.test(recallProps.id?.description || '')) {
+  throw new Error('recall schema must preserve scoped prior-context guidance and id lookup shape');
 }
 if (!/array for independent fan-out/i.test(recallProps.query?.description || '') || !/Project pool selector/i.test(recallProps.projectScope?.description || '')) {
   throw new Error('recall schema must explain fan-out query and project scope filters');
@@ -1588,7 +1548,7 @@ if (!recallProps.sessionOnly || !/session only/i.test(recallProps.sessionOnly?.d
 }
 const memoryTool = MEMORY_TOOL_DEFS.find((tool) => tool.name === 'memory');
 const memoryProps = memoryTool?.inputSchema?.properties || {};
-if (!/explicit mutation/i.test(memoryTool?.description || '') || !/Destructive jobs require exact confirm/i.test(memoryTool?.description || '') || !/Exact confirmation phrase/i.test(memoryProps.confirm?.description || '')) {
+if (!/mutation/i.test(memoryTool?.description || '') || !/Exact confirmation phrase/i.test(memoryProps.confirm?.description || '')) {
   throw new Error('memory schema must preserve mutation/destructive confirmation guidance');
 }
 const searchTool = SEARCH_TOOL_DEFS.find((tool) => tool.name === 'search');
@@ -1783,7 +1743,7 @@ if (grepTool?.inputSchema?.properties?.head_limit?.minimum !== 0 || !/keep small
 if (grepTool?.inputSchema?.properties?.type) {
   throw new Error('grep type schema must stay hidden; prefer glob for extension narrowing');
 }
-if (!/code flow before text search/i.test(codeGraphProps.mode?.description || '') || !/one anchor is enough/i.test(codeGraphProps.symbol?.description || '') || !/one call/i.test(codeGraphProps.symbols?.description || '')) {
+if (!/code flow before text search/i.test(codeGraphProps.mode?.description || '') || !/one anchor is enough/i.test(codeGraphProps.symbols?.description || '') || !/one call/i.test(codeGraphProps.symbols?.description || '')) {
   throw new Error('code_graph schema fields must steer away from repeated lookup loops');
 }