claude-finops 0.7.2 → 0.8.0

package/web/app.js

@@ -3,7 +3,7 @@ const {fmtUSD, fmtNum, fmtInt, fmtPct, seriesVar} = C;
 
 /* ============================ state ============================ */
 const S = {
-  view: 'overview',
+  view: 'hygiene',
   opts: null,
   filter: {start: null, end: null, agents: [], models: [], projects: [], categories: [],
            include_sandbox: true, min_cost: null, min_tokens: null},
@@ -12,6 +12,8 @@ const S = {
   grain: 'day',
   cache: new Map(),
   drawerStack: [],
+  sessPage: {offset: 0, limit: 200},
+  promptPage: {offset: 0, limit: 200},
 };
 const $ = (s, r = document) => r.querySelector(s);
 const h = (html) => { const t = document.createElement('template');
@@ -104,6 +106,7 @@ function wireTable(host, rows, onRow) {
 /* ============================ chrome ============================ */
 const NAV = [
   ['Command center', [
+    ['hygiene', '◫', 'Context hygiene'],
     ['overview', '◧', 'Executive overview'],
     ['advisor', '✦', 'What should I do?'],
     ['agents', '◎', 'Agents'],
@@ -128,7 +131,6 @@ const NAV = [
     ['diagnose', '✚', 'Why so many tokens?', 'priced'],
     ['attribution', '⧉', 'Who used the tokens', 'priced'],
     ['waste', '⚠', 'Waste detection'],
-    ['modelswitch', '⇄', 'Model switch', 'priced'],
     ['freemodels', '◇', 'Free models', 'claude'],
     ['compare', '⚖', 'Compare models', 'priced'],
     ['toolkit', '✎', 'Skills & MCP', 'claude'],
@@ -297,6 +299,9 @@ function openPop(btn, kind) {
       <input type="number" step="0.01" id="mc" value="${f.min_cost ?? ''}" placeholder="any">
       <div class="hd">Minimum billable tokens</div>
       <input type="number" id="mt" value="${f.min_tokens ?? ''}" placeholder="any">
+      <div class="note" style="margin:8px 0 6px">These apply per <strong>request</strong>, not per
+        session or prompt. A session's totals will count only its requests above the
+        threshold, so filtered totals read lower than the session's real cost.</div>
       <button class="chip on" id="applyth" style="width:100%;justify-content:center">Apply</button>`;
   } else {
     const key = kind, src = kind === 'models' ? o.models.map(m => [m.model, modelName(m.model), m.n])
@@ -360,7 +365,6 @@ document.addEventListener('keydown', e => { if (e.key === 'Escape') closeDrawer(
 async function openPrompt(id) {
   const d = drawer('Prompt detail', '<div class="loading">Loading…</div>');
   const p = await fetch(`/api/prompt/${id}`).then(r => r.json());
-  const adv = p.advisor || {};
   d.querySelector('.content').innerHTML = `
     <div class="grid g4">
       ${kpi('Estimated cost', fmtUSD(p.est_cost_usd), null, {badge: BADGE.estimated})}
@@ -376,22 +380,6 @@ async function openPrompt(id) {
         <span>${fmtInt(p.char_len)} chars · ${fmtInt(p.word_len)} words</span>
         ${p.source ? `<span class="pill">${esc(p.source)}</span>` : ''}
       </div>`, {badge: BADGE.actual})}
-    ${card('Cost drivers & optimization advice', adv.available ? `
-      <div class="stack">
-        <div><b style="font-size:12px">Why this was expensive</b>
-          <ul style="margin:5px 0 0 18px;font-size:12px;color:var(--text-2)">
-            ${adv.why_expensive.map(x => `<li>${esc(x)}</li>`).join('')}</ul></div>
-        <div><b style="font-size:12px">Suggested changes</b>
-          <ul style="margin:5px 0 0 18px;font-size:12px;color:var(--text-2)">
-            ${adv.suggestions.map(x => `<li>${esc(x)}</li>`).join('')}</ul></div>
-        <div class="grid g3">
-          ${kpi('Est. token reduction', '~' + adv.estimated_token_reduction_pct + '%', null, {badge: BADGE.recommendation})}
-          ${kpi('Est. cost reduction', '~' + adv.estimated_cost_reduction_pct + '%')}
-          ${kpi('Est. cost avoided', '~' + fmtUSD(adv.estimated_cost_reduction_usd))}
-        </div></div>`
-      : `<div class="na">${esc(adv.message || 'No analysis available')}</div>`,
-      {badge: BADGE.recommendation,
-       footer: adv.available ? esc(adv.disclaimer) : null})}
     ${card('Requests in this turn', table([
       {h: 'Time', f: r => `<span class="mono">${esc((r.ts||'').slice(11,19))}</span>`},
       {h: 'Model', f: r => `<span class="swatch" style="background:${modelColor(r.model)}"></span>${esc(modelName(r.model))}`},
@@ -572,12 +560,8 @@ VIEWS.overview = async (page) => {
       ${card('Optimization opportunities', `<div class="stack">${
         b.recommendations.recommendations.length
         ? b.recommendations.recommendations.slice(0, 5).map(r => `<div class="item">
-            <div class="hd">${esc(r.title)}<span class="spacer"></span>
-              <span class="badge rec">${r.confidence} confidence</span></div>
-            <div class="mt"><span>Actual ${fmtUSD(r.actual_cost_usd)}</span>
-              <span>Est. alternative ${fmtUSD(r.estimated_alternative_cost_usd)}</span>
-              <span style="color:var(--good-ink);font-weight:600">
-                Est. saving ${fmtUSD(r.estimated_savings_usd)} (${r.estimated_savings_pct}%)</span></div>
+            <div class="hd">${esc(r.title)}</div>
+            <div class="mt"><span>Actual ${fmtUSD(r.actual_cost_usd)}</span></div>
             <div class="note">${esc(r.caveat)}</div></div>`).join('')
         : '<div class="empty">No recommendation met the evidence threshold</div>'}</div>`,
         {badge: BADGE.recommendation})}
@@ -588,7 +572,7 @@ VIEWS.overview = async (page) => {
         {badge: BADGE.forecast, hint: forecast.available ? forecast.method : ''})}
       ${card('FinOps score', `<div class="scorewrap">
         <div><div class="scorenum">${scorecard.score}</div>
-          <div class="scoregrade">out of 100 · grade ${scorecard.grade}</div></div>
+          <div class="scoregrade">out of 100</div></div>
         <div style="flex:1;min-width:230px" class="stack">${scorecard.dimensions.map(d => `
           <div><div style="display:flex;justify-content:space-between;font-size:11.5px">
             <span>${esc(d.name)}</span><span style="font-variant-numeric:tabular-nums">${d.score}</span></div>
@@ -602,9 +586,10 @@ VIEWS.overview = async (page) => {
   if (alloc.configured) {
     C.gauge(gEl, {pct: alloc.used_pct, status: alloc.status, label: 'of plan allowance'});
     $('#burnnotes', page).innerHTML = `<div class="stack">
-      <div class="item"><div class="hd">${statusGlyph(alloc.status)} You are likely to reach your
-        current limit in <b>${alloc.days_until_limit}</b> days${alloc.limit_date
-        ? ` (around ${esc(alloc.limit_date)})` : ''}.</div></div>
+      <div class="item"><div class="hd">${statusGlyph(alloc.status)} ${alloc.days_until_limit == null
+        ? `<b>Exceeded</b> your current limit.`
+        : `You are likely to reach your current limit in <b>${alloc.days_until_limit}</b> days${alloc.limit_date
+          ? ` (around ${esc(alloc.limit_date)})` : ''}.`}</div></div>
       <div class="item"><div class="hd">At the current burn rate you will
         ${alloc.projected_overage_pct > 0 ? `exceed your allowance by
           <b>${fmtPct(alloc.projected_overage_pct)}</b>` : `finish the period at
@@ -659,7 +644,7 @@ VIEWS.overview = async (page) => {
   ], lp, {onRow: 1});
   wireTable($('#topprompts', page), lp, r => openPrompt(r.prompt_id));
 
-  const ls = await api('sessions', '&limit=10&order=cost');
+  const ls = (await api('sessions', '&limit=10&order=cost')).rows;
   $('#topsessions', page).innerHTML = table([
     {h: 'Session', trunc: 1, title: r => r.session_id,
      f: r => esc(r.title || shortId(r.session_id))},
@@ -670,13 +655,16 @@ VIEWS.overview = async (page) => {
   ], ls, {onRow: 1});
   wireTable($('#topsessions', page), ls, r => openSession(r.session_id));
 
-  if (forecast.available) {
+  if (forecast.available && !forecast.insufficient_history) {
     C.forecastFan($('#fan', page), {history: burn.series, scenarios: forecast.scenarios,
       remainingDays: forecast.remaining_days});
     $('#fanleg', page).innerHTML = `<span class="it"><span class="swatch"
       style="background:var(--s1)"></span>Cumulative actual (estimated cost)</span>
       <span class="it"><span class="swatch" style="background:var(--s1);opacity:.35"></span>
       Forecast band: conservative → high</span>`;
+  } else if (forecast.available) {
+    $('#fan', page).innerHTML = '<div class="empty">Fewer than 7 priced days in the window: '
+      + 'bands not shown.</div>';
   } else $('#fan', page).innerHTML = '<div class="empty">Not enough history to forecast</div>';
 
   renderAdvisorHero(page, advisor);
@@ -700,9 +688,7 @@ function renderAdvisorHero(page, advisor) {
           : a.basis === 'recommendation' ? 'rec' : 'est'}">${esc(a.basis.split(':')[0])}</span></b>
         <span>${esc(a.detail)}</span></div></div>`).join('')
       : '<div class="empty">Nothing needs your attention in this range</div>'}</div>
-    ${advisor.estimated_savings_range_usd[1] > 0 ? `<div class="note" style="margin-top:9px">
-      Estimated savings opportunity in range: <b>${fmtUSD(advisor.estimated_savings_range_usd[0])}
-      – ${fmtUSD(advisor.estimated_savings_range_usd[1])}</b> — modelled, not booked.</div>` : ''}
+
   </div>`);
   page.insertBefore(hero, page.firstChild);
 }
@@ -729,14 +715,12 @@ VIEWS.advisor = async (page) => {
     </div>
     ${card('All recommendations', recs.recommendations.length ? `<div class="stack">
       ${recs.recommendations.map(r => `<div class="item"><div class="hd">${esc(r.title)}
-        <span class="spacer"></span><span class="badge rec">${esc(r.confidence)} confidence</span></div>
+        <span class="spacer"></span><span class="badge">${esc(r.confidence)}</span></div>
         ${r.current_model ? `<div class="dt"><b>Currently on:</b> ${esc(r.current_model)}${
           r.scope ? ` · ${esc(r.scope)}` : ''}</div>` : ''}
+        ${r.detail ? `<div class="dt">${esc(r.detail)}</div>` : ''}
         <div class="grid g3" style="gap:8px;margin:4px 0">
-          ${kpi('Actual cost', fmtUSD(r.actual_cost_usd), null, {small: 1, badge: BADGE.estimated})}
-          ${kpi('Est. alternative', fmtUSD(r.estimated_alternative_cost_usd), null, {small: 1})}
-          ${kpi('Est. potential saving', fmtUSD(r.estimated_savings_usd),
-            `${r.estimated_savings_pct}%`, {small: 1, badge: BADGE.recommendation})}
+          ${kpi('Spend involved', fmtUSD(r.actual_cost_usd), null, {small: 1, badge: BADGE.estimated})}
         </div>
         ${r.alternatives && r.alternatives.length ? `<div class="dt" style="margin-top:6px">
           <b>Your options${r.agent ? ` within ${esc(r.agent)}` : ''}</b> — pick the trade-off you want:</div>
@@ -745,13 +729,11 @@ VIEWS.advisor = async (page) => {
               ? ' <span class="badge rec">suggested</span>' : '')},
             {h: 'Tier', f: a => esc(a.tier)},
             {h: 'Est. cost', num: 1, f: a => fmtUSD(a.estimated_cost_usd)},
-            {h: 'Est. saving', num: 1, f: a =>
-              `${fmtUSD(a.estimated_savings_usd)} <span class="note">(${a.estimated_savings_pct}%)</span>`},
           ], r.alternatives)}` : ''}
         <div class="note">${esc(r.caveat)}</div></div>`).join('')}</div>`
       : '<div class="empty">No recommendation met the evidence threshold for this range</div>',
       {badge: BADGE.recommendation,
-       footer: 'Estimated potential savings are modelled from token counts and configured pricing. They are opportunities to evaluate, never booked savings, and do not account for output quality.'})}
+       footer: 'These are observations from your own usage. No dollar saving is attached unless the method can support one — a guessed percentage of spend is not a saving.'})}
     ${card('Anomalies to inspect', `<div class="stack" id="anolist">${anos.anomalies.map((a, i) =>
       `<div class="item sev-${a.severity} clickable" data-i="${i}"><div class="hd">
         ${a.severity === 'high' ? '🚨' : '⚠️'} ${esc(a.title)}</div>
@@ -807,7 +789,10 @@ VIEWS.usage = async (page) => {
       </div>
       <div class="chart" id="tl"></div>`,
       {badge: S.metric === 'cost' ? BADGE.estimated : BADGE.actual,
-       hint: 'click a bucket to drill into that day', flush: 0})}
+       hint: 'click a bucket to drill into that day',
+       footer: 'Days are bucketed in UTC, as Claude Code timestamps its transcripts. '
+             + 'If you work late in a timezone ahead of UTC, that work lands on the previous day here.',
+       flush: 0})}
     ${card('Model mix over time', '<div class="legend" id="mixleg"></div>' +
       '<div class="chart" id="mix"></div>', {badge: BADGE.estimated,
       hint: 'stacked estimated cost per model'})}
@@ -901,8 +886,9 @@ VIEWS.burn = async (page) => {
             <dt>Overage</dt><dd>${fmtPct(a.projected_overage_pct)}</dd>
           </dl></div></div>
         <div class="item" style="margin-top:9px">
-          <div class="hd">${statusGlyph(a.status)} You are likely to reach this limit in
-            <b>${a.days_until_limit}</b> days.</div>
+          <div class="hd">${statusGlyph(a.status)} ${a.days_until_limit == null
+            ? `<b>Exceeded</b> this limit.`
+            : `You are likely to reach this limit in <b>${a.days_until_limit}</b> days.`}</div>
           <div class="dt">At the current burn rate you will
             ${a.projected_overage_pct > 0
               ? `exceed the allowance by <b>${fmtPct(a.projected_overage_pct)}</b>.`
@@ -926,10 +912,23 @@ VIEWS.burn = async (page) => {
 
 /* ---------- models ---------- */
 VIEWS.models = async (page) => {
-  const m = await api('models');
+  const [m, lc] = await Promise.all([api('models'), api('long_context_pricing')]);
   const sup = m.superlatives, rows = m.rows;
   const find = k => rows.find(r => r.model === sup[k]);
   page.innerHTML = `
+    ${lc.unpriced_requests ? `<div class="hero">
+      <h3>⚠️ Some long-context requests are priced low</h3>
+      <div class="stack">
+        <div class="item sev-high">
+          <div class="hd">${fmtInt(lc.unpriced_requests)} requests sent more context than their
+            model's standard window, so they ran on the long-context variant — which bills at a
+            premium this price table does not have.</div>
+          <div class="dt">Affected: ${lc.unpriced_models.map(esc).join(', ')}.
+            Their estimated cost is <strong>understated</strong>. Add a
+            <code>"&lt;model&gt;[1m]"</code> entry to <code>config/pricing.json</code> and rebuild
+            to correct it. Requests with a configured long-context price
+            (${fmtInt(lc.repriced_requests)}) are already billed at it.</div></div>
+      </div></div>` : ''}
     <div class="grid g4">
       ${kpi('Most expensive', sup.most_expensive ? esc(modelName(sup.most_expensive)) : null,
         find('most_expensive') ? fmtUSD(find('most_expensive').cost) + ' estimated' : '', {small: 1})}
@@ -977,7 +976,9 @@ VIEWS.models = async (page) => {
   $('#mt', page).innerHTML = table([
     {h: 'Model', f: r => `<span class="swatch" style="background:${modelColor(r.model)}"></span>${esc(r.display_name)}
       ${r.pricing_known ? '' : '<span class="badge na" title="no price entry — default pricing used">default price</span>'}`},
-    {h: 'Tier', f: r => `<span class="pill">${esc(r.tier)}</span>`},
+    {h: 'Tier', f: r => r.tier === 'unknown'
+      ? `<span class="pill">unpriced</span><span class="badge na" title="no price in pricing.json">no price in pricing.json</span>`
+      : `<span class="pill">${esc(r.tier)}</span>`},
     {h: 'Requests', num: 1, f: r => fmtInt(r.requests)},
     {h: 'Sessions', num: 1, f: r => fmtInt(r.sessions)},
     {h: 'Input', num: 1, f: r => fmtNum(r.input_tokens)},
@@ -986,7 +987,8 @@ VIEWS.models = async (page) => {
     {h: 'Cache write', num: 1, f: r => fmtNum(r.cache_write_tokens)},
     {h: 'Tokens', num: 1, f: r => fmtNum(r.tokens)},
     {h: 'Avg context', num: 1, f: r => fmtNum(r.avg_context)},
-    {h: 'Ctx util', num: 1, f: r => r.utilization_pct == null ? '—' : fmtPct(r.utilization_pct)},
+    {h: 'Ctx util', num: 1, f: r => (r.utilization_pct == null ? '—' : fmtPct(r.utilization_pct))
+      + (r.over_window_requests ? ` <span class="note" title="requests over a window this price table cannot explain">· ${fmtInt(r.over_window_requests)} over</span>` : '')},
     {h: 'Avg latency', num: 1, f: r => r.avg_latency_ms ? (r.avg_latency_ms/1000).toFixed(1)+'s' : '—'},
     {h: '$/1K out', num: 1, f: r => r.cost_per_1k_output ? '$' + r.cost_per_1k_output.toFixed(3) : '—'},
     {h: 'Est. cost', num: 1, f: r => fmtUSD(r.cost)},
@@ -1031,16 +1033,18 @@ VIEWS.projects = async (page) => {
 /* ---------- sessions ---------- */
 VIEWS.sessions = async (page) => {
   const order = S.sessOrder || 'cost';
-  const rows = await api('sessions', `&limit=400&order=${order}`);
+  const sp = S.sessPage;
+  const res = await api('sessions', `&limit=${sp.offset + sp.limit}&order=${order}`);
+  const rows = res.rows, total = res.total;
   const eff = await api('efficiency');
   const avgTok = rows.length ? rows.reduce((a, r) => a + r.tokens, 0) / rows.length : 0;
   page.innerHTML = `
     <div class="grid g4">
-      ${kpi('Sessions in range', fmtInt(rows.length), null, {badge: BADGE.actual})}
-      ${kpi('Avg cost / session', fmtUSD(rows.reduce((a, r) => a + r.cost, 0) / (rows.length || 1)),
+      ${kpi('Sessions in range', fmtInt(total), null, {badge: BADGE.actual})}
+      ${kpi('Avg cost / loaded session', fmtUSD(rows.reduce((a, r) => a + r.cost, 0) / (rows.length || 1)),
         null, {badge: BADGE.estimated})}
-      ${kpi('Avg tokens / session', fmtNum(avgTok))}
-      ${kpi('Avg tokens / prompt', fmtNum(rows.reduce((a, r) => a + (r.tokens_per_prompt || 0), 0)
+      ${kpi('Avg tokens / loaded session', fmtNum(avgTok))}
+      ${kpi('Avg tokens / loaded prompt', fmtNum(rows.reduce((a, r) => a + (r.tokens_per_prompt || 0), 0)
         / (rows.filter(r => r.tokens_per_prompt).length || 1)))}
     </div>
     ${card('Session explorer', `<div class="filters" style="margin:0 0 8px">
@@ -1049,7 +1053,12 @@ VIEWS.sessions = async (page) => {
           `<button class="chip ${order === k ? 'on' : ''}" data-so="${k}">${l}</button>`).join('')}
         <span class="spacer"></span>
         <span class="note">rows above ${fmtNum(avgTok * 3)} tokens are unusually expensive</span>
-      </div><div id="st"></div>`, {badge: BADGE.estimated, hint: 'click a row to open the session'})}
+      </div><div id="st"></div>
+      <div class="filters" style="margin-top:8px">
+        <span class="note">Showing ${fmtInt(Math.min(rows.length, total))} of ${fmtInt(total)}</span>
+        <span class="spacer"></span>
+        ${rows.length < total ? '<button class="btn pb-copy" id="sess-more">Load more</button>' : ''}
+      </div>`, {badge: BADGE.estimated, hint: 'click a row to open the session'})}
     <div class="grid g2">
       ${card('Lowest output yield', table([
         {h: 'Session', trunc: 1, f: r => esc(r.title || shortId(r.session_id))},
@@ -1065,7 +1074,9 @@ VIEWS.sessions = async (page) => {
       ], eff.high_efficiency_sessions, {onRow: 1}), {badge: BADGE.estimated, hint: 'high efficiency'})}
     </div>`;
   page.querySelectorAll('[data-so]').forEach(b => b.onclick = () => {
-    S.sessOrder = b.dataset.so; bust(); render(); });
+    S.sessOrder = b.dataset.so; S.sessPage.offset = 0; bust(); render(); });
+  const sessMore = $('#sess-more', page);
+  if (sessMore) sessMore.onclick = () => { sp.offset += sp.limit; bust(); render(); };
   $('#st', page).innerHTML = table([
     {h: 'Session', trunc: 1, title: r => r.session_id,
      f: r => `${r.tokens > avgTok * 3 ? '🔴 ' : ''}${esc(r.title || shortId(r.session_id))}
@@ -1107,8 +1118,10 @@ VIEWS.sessions = async (page) => {
 VIEWS.prompts = async (page) => {
   const order = S.promptOrder || 'cost';
   const q = S.promptQ || '';
-  const rows = await api('prompts',
-    `&limit=400&order=${order}${q ? '&q=' + encodeURIComponent(q) : ''}`);
+  const pp = S.promptPage;
+  const res = await api('prompts',
+    `&limit=${pp.offset + pp.limit}&order=${order}${q ? '&q=' + encodeURIComponent(q) : ''}`);
+  const rows = res.rows, total = res.total;
   page.innerHTML = `
     ${card('Prompt explorer', `
       <div class="filters" style="margin:0 0 8px">
@@ -1119,16 +1132,19 @@ VIEWS.prompts = async (page) => {
            ['efficiency', 'Most efficient'], ['cheapest', 'Cheapest'], ['recent', 'Most recent']]
           .map(([k, l]) => `<button class="chip ${order === k ? 'on' : ''}" data-po="${k}">${l}</button>`).join('')}
         <span class="spacer"></span>
-        <span class="note">${fmtInt(rows.length)} prompts · global filters apply</span>
+        <span class="note">Showing ${fmtInt(Math.min(rows.length, total))} of ${fmtInt(total)} prompts · global filters apply</span>
+        ${rows.length < total ? '<button class="btn pb-copy" id="prompt-more">Load more</button>' : ''}
       </div><div id="pt"></div>`,
       {badge: BADGE.estimated, hint: 'click any row for the full prompt, usage and advice',
        footer: 'Prompt text is read from your local transcripts and never leaves this machine.'})}`;
   const inp = $('#pq', page);
   let t; inp.oninput = e => { clearTimeout(t); const v = e.target.value;
-    t = setTimeout(() => { S.promptQ = v; bust(); render().then(() => {
+    t = setTimeout(() => { S.promptQ = v; S.promptPage.offset = 0; bust(); render().then(() => {
       const i = $('#pq'); if (i) { i.focus(); i.setSelectionRange(v.length, v.length); } }); }, 300); };
   page.querySelectorAll('[data-po]').forEach(b => b.onclick = () => {
-    S.promptOrder = b.dataset.po; bust(); render(); });
+    S.promptOrder = b.dataset.po; S.promptPage.offset = 0; bust(); render(); });
+  const promptMore = $('#prompt-more', page);
+  if (promptMore) promptMore.onclick = () => { pp.offset += pp.limit; bust(); render(); };
   $('#pt', page).innerHTML = table([
     {h: 'When', f: r => `<span class="mono">${esc((r.ts || '').slice(0, 16).replace('T', ' '))}</span>`},
     {h: 'Prompt', trunc: 1, title: r => r.preview, f: r => esc(r.preview)},
@@ -1249,10 +1265,108 @@ VIEWS.categories = async (page) => {
 };
 
 /* ---------- context & cache ---------- */
+/* ---------- context & session hygiene: observed shares, no savings ---------- */
+VIEWS.hygiene = async (page) => {
+  const [hy, fit] = await Promise.all([api('hygiene'), api('context_window_fit')]);
+  const T = hy.thresholds.map(String), kT = String(hy.rank_threshold);
+  const K = t => `${Math.round(+t / 1000)}K`;
+  const ab = t => hy.above[t];
+  page.innerHTML = `
+    <div class="note" style="margin:0 0 10px">Everything on this page is observed from your transcripts.
+      It shows where spend sat while a large prefix was being re-sent on every turn. It does
+      <b>not</b> estimate what /compact or a fresh session would have saved — that depends on
+      what the work still needed, which the transcript does not say. Auto-compaction is not
+      recorded; it is detected as the context dropping by more than half. A typed /compact is
+      recorded and also counts.</div>
+    <div class="grid g4">
+      ${T.map(t => kpi(`Spend in requests ≥ ${K(t)} context`, fmtPct(ab(t).share_pct),
+        `${fmtUSD(ab(t).cost_usd)} · ${fmtInt(ab(t).requests)} requests`, {badge: BADGE.actual})).join('')}
+      ${T.map(t => kpi(`Spend after a session first crossed ${K(t)}`, fmtPct(ab(t).share_after_first_cross_pct),
+        `${fmtInt(ab(t).sessions)} of ${fmtInt(hy.sessions)} sessions crossed it`, {badge: BADGE.actual})).join('')}
+    </div>
+    <div class="grid g3">
+      ${kpi('Spend near or over the context window', fmtPct(fit.near_or_over_cost_pct),
+        `≥ ${fit.threshold_pct}% of the window in use · ${fmtInt(fit.near_requests + fit.over_requests)} requests`,
+        {badge: BADGE.actual})}
+      ${kpi('Sessions in range', fmtInt(hy.sessions), `${fmtInt(hy.requests)} main-thread requests`, {badge: BADGE.actual})}
+      ${kpi('Spend in range', fmtUSD(hy.cost_usd), 'subagent turns excluded (own prefix)', {badge: BADGE.estimated})}
+    </div>
+    ${card('Context per request, most expensive session after ' + K(kT), '<div class="chart" id="hy-traj"></div>',
+      {badge: BADGE.actual, hint: 'prompt-side tokens on each request, in order · click a row below to change session'})}
+    ${card('Sessions ranked by spend after crossing ' + K(kT), '<div id="hy-sess"></div>',
+      {badge: BADGE.actual, flush: 1,
+       footer: hy.note + ' Subagent turns are excluded because they run against their own prefix.'})}`;
+
+  const drawTraj = s => {
+    const rows = s.context_trajectory.map((c, i) => ({i: i + 1, ctx: c, cum: s.cumulative_cost[i]}));
+    C.timeSeries($('#hy-traj', page), {rows, x: 'i', type: 'area', height: 210, fmt: fmtNum,
+      series: [{key: 'ctx', label: 'Context tokens', color: seriesVar(0)}],
+      xLabel: v => `#${v}`});
+    $('#hy-traj', page).insertAdjacentHTML('beforeend',
+      `<div class="note" style="margin-top:6px">${esc(s.title || shortId(s.session_id))} — ${fmtInt(s.requests)} requests,
+       ${fmtUSD(s.cost_usd)}. Crossed ${K(kT)} at request #${s.ever_crossed[kT] ? s.first_cross_idx[kT] + 1 : '—'};
+       ${fmtPct(s.cost_after_pct[kT])} of its spend came after that.</div>`);
+  };
+  const rows = hy.sessions_ranked;
+  $('#hy-sess', page).innerHTML = table([
+    {h: 'Session', trunc: 1, f: r => esc(r.title || shortId(r.session_id))},
+    {h: 'Project', trunc: 1, f: r => esc(r.project || '')},
+    {h: 'Context', f: r => `<span class="spk" data-i="${rows.indexOf(r)}" style="display:inline-block;width:110px"></span>`},
+    {h: 'Requests', num: 1, f: r => fmtInt(r.requests)},
+    {h: 'Peak ctx', num: 1, f: r => fmtNum(r.max_context)},
+    ...T.map(t => ({h: `After ${K(t)}`, num: 1, f: r => !r.ever_crossed[t] ? '<span class="na">never</span>'
+      : `<b>${fmtUSD(r.cost_after[t])}</b> <span class="note">(${fmtPct(r.cost_after_pct[t])})</span>`})),
+    {h: 'Session cost', num: 1, f: r => fmtUSD(r.cost_usd)},
+  ], rows);
+  page.querySelectorAll('#hy-sess .spk').forEach(el => C.spark(el, rows[+el.dataset.i].context_trajectory, seriesVar(0), 22));
+  page.querySelectorAll('#hy-sess table.tbl tbody tr').forEach(tr => {
+    tr.classList.add('clickable');
+    tr.onclick = e => { if (e.altKey) openSession(rows[+tr.dataset.i].session_id); else drawTraj(rows[+tr.dataset.i]); };
+  });
+  if (rows.length) drawTraj(rows[0]);
+};
+
 VIEWS.context = async (page) => {
-  const [ctx, eff] = await Promise.all([api('context'), api('efficiency')]);
+  const [ctx, eff, ttl] = await Promise.all([api('context'), api('efficiency'), api('ttl_replay')]);
   const ca = eff.cache;
+  const ttlCard = () => {
+    if (!ttl || !ttl.segments) return '';
+    if (!ttl.reconciled) {
+      return card('Cache TTL comparison', `
+        <p class="note" style="margin:0">Not shown. Replaying your actual 1h TTL produced
+          ${fmtUSD(ttl.replay_1h_usd)} against ${fmtUSD(ttl.logged_cost_usd)} of logged cost
+          (${ttl.reconciliation_drift_pct}% drift). A replay that cannot reproduce the bill you
+          did get is not evidence about one you did not, so the comparison is withheld.</p>`,
+        {badge: BADGE.actual, hint: 'arithmetic · failed its own reconciliation check'});
+    }
+    const cheaper5 = ttl.cheaper_ttl === '5m';
+    return card('Cache TTL: what you use vs the alternative', `
+      <p class="note" style="margin:0 0 10px">Replayed over <strong>${fmtInt(ttl.segments)}</strong>
+        cache segments using your real inter-turn gaps. No assumption is made about model
+        behaviour — this is arithmetic on timestamps and token counts.</p>
+      <div class="grid g3" style="gap:8px">
+        ${kpi('Your 1h TTL', fmtUSD(ttl.replay_1h_usd), 'replayed', {small: 1, badge: BADGE.actual})}
+        ${kpi('Same work on a 5m TTL', fmtUSD(ttl.replay_5m_usd), 'counterfactual', {small: 1})}
+        ${kpi(cheaper5 ? 'A 5m TTL would save' : 'Your 1h TTL saves',
+          fmtUSD(Math.abs(ttl.difference_usd)), cheaper5 ? 'switch to save' : 'already the cheaper choice',
+          {small: 1, badge: BADGE.actual})}
+      </div>
+      <div class="stack" style="margin-top:10px">
+        <div class="item sev-${cheaper5 ? 'medium' : 'low'}">
+          <div class="hd">${cheaper5
+            ? 'A shorter TTL would be cheaper for how you actually work.'
+            : 'Keep the 1h TTL — a 5m TTL would cost you more, not less.'}</div>
+          <div class="dt">${cheaper5
+            ? 'Your turns come close enough together that the prefix rarely expires, so you are paying the 2x write premium for protection you do not use.'
+            : 'The gaps where a 5m prefix would expire force a full-prefix rewrite, and that costs more than the cheaper write rate saves.'}
+            This only matters if the TTL is configurable in your setup.</div></div>
+      </div>`,
+      {badge: BADGE.actual,
+       hint: 'arithmetic · reconciled to ' + ttl.reconciliation_drift_pct + '% of logged cost',
+       footer: ttl.note});
+  };
   page.innerHTML = `
+    ${ttlCard()}
     <div class="grid g5">
       ${kpi('Avg context / request', fmtNum(ctx.avg_context), null, {badge: BADGE.actual})}
       ${kpi('Max context seen', fmtNum(ctx.max_context),
@@ -1262,8 +1376,36 @@ VIEWS.context = async (page) => {
         'average vs largest configured window')}
       ${kpi('Tokens / request', fmtNum(eff.tokens_per_request))}
       ${kpi('Cache hit ratio', ca.reads ? fmtPct(eff.cache_hit_ratio * 100) : null,
-        'reads ÷ (reads + writes)', {badge: BADGE.actual})}
+        'reads ÷ (reads + writes), by token', {badge: BADGE.actual})}
     </div>
+    ${(() => {
+      const cs = ca.cost_split;
+      if (!cs || !cs.read_cost_share) return '';
+      const mult = cs.write_vs_read_multiple, h1 = cs.write_1h_token_share;
+      return card('Cache reads vs writes, by cost', `
+        <p class="note" style="margin:0 0 10px">Writes are
+          <strong>${fmtPct(100 * (1 - cs.read_token_share))}</strong> of your cache tokens but
+          <strong>${fmtPct(100 * cs.write_cost_share)}</strong> of your cache cost${
+            mult ? `, because a write token costs ${mult.toFixed(1)}x a read token` : ''}.
+          The token ratio above is the flattering number; this is the one that moves the bill.</p>
+        <dl class="kv">
+          <dt>Cache reads</dt><dd>${fmtNum(cs.read_tokens)} tokens · ${fmtUSD(cs.read_cost_usd)}
+            (${fmtPct(100 * cs.read_cost_share)} of cache cost)</dd>
+          <dt>Cache writes</dt><dd>${fmtNum(cs.write_tokens)} tokens · ${fmtUSD(cs.write_cost_usd)}
+            (${fmtPct(100 * cs.write_cost_share)} of cache cost)</dd>
+          <dt>— 5m writes</dt><dd>${fmtNum(cs.write_5m_tokens)} tokens · ${fmtUSD(cs.write_5m_cost_usd)}</dd>
+          <dt>— 1h writes</dt><dd>${fmtNum(cs.write_1h_tokens)} tokens · ${fmtUSD(cs.write_1h_cost_usd)}</dd>
+        </dl>
+        ${h1 !== null && h1 >= 0.5 && cs.write_tokens ? `<div class="stack" style="margin-top:10px">
+          <div class="item sev-low">
+            <div class="hd">${fmtPct(100 * h1)} of your cache writes use the 1h TTL.</div>
+            <div class="dt">A 1h write costs more per token than a 5m one, but that does not make
+              it the wrong choice — whether it pays off depends on your real inter-turn gaps.
+              The TTL comparison above replays them and answers it with arithmetic rather than
+              a rule of thumb.</div></div>
+        </div>` : ''}`, {badge: BADGE.estimated,
+        footer: 'Component costs are re-derived per model from config/pricing.json, since a request stores one blended cost.'});
+    })()}
     ${ctx.large_context_cost_pct > 0 ? `<div class="hero">
       <h3>⚠️ Context warnings</h3>
       <div class="stack">
@@ -1283,8 +1425,8 @@ VIEWS.context = async (page) => {
         <div class="grid g3" style="gap:8px">
           ${kpi('Est. cost with caching', fmtUSD(ca.cost_with_cache), null, {small: 1, badge: BADGE.estimated})}
           ${kpi('Est. cost without caching', fmtUSD(ca.cost_without_cache), 'same tokens at input rates', {small: 1})}
-          ${kpi('Est. savings', fmtUSD(ca.estimated_savings_usd), fmtPct(ca.savings_pct),
-            {small: 1, badge: BADGE.estimated})}
+          ${kpi('Uncached counterfactual', fmtUSD(ca.uncached_counterfactual_delta_usd),
+            `${fmtPct(ca.uncached_counterfactual_pct)} · not a saving`, {small: 1, badge: BADGE.estimated})}
         </div>
         <div class="chart" id="cachebar" style="margin-top:10px"></div>
         <dl class="kv" style="margin-top:10px">
@@ -1322,224 +1464,6 @@ VIEWS.context = async (page) => {
   wireTable($('#hs', page), ctx.heavy_sessions, r => openSession(r.session_id));
 };
 
-/* ---------- model switch ---------- */
-// Verdicts from the back-test. Wording matters here: "supported" means your own
-// history backs the switch, not that we modelled it.
-const VERDICT = {
-  supported: ['🟢', 'Backed by your data', 'healthy'],
-  caution:   ['🟠', 'Trial first', 'approaching'],
-  risky:     ['🔴', 'Cost more work', 'critical'],
-  marginal:  ['⚪', 'Too close to call', 'high'],
-};
-
-function evidenceBody(ev) {
-  if (!ev || !ev.categories?.length) {
-    return `<div class="empty">No category yet has ${ev?.min_prompts || 8}+ prompts on two
-      different models of the same agent, so there is nothing to compare. Run a cheaper model on
-      a handful of real tasks and this fills in.</div>`;
-  }
-  const rows = [];
-  ev.categories.forEach(c => c.candidates.forEach((x, i) => rows.push({c, x, first: i === 0})));
-  return table([
-    {h: 'Work', f: r => r.first ? `<b>${esc(r.c.category.replace('_', ' '))}</b>` : ''},
-    {h: 'You use now', f: r => r.first
-      ? `${esc(r.c.current.name)} <span class="note">${fmtUSD(r.c.current.cost_per_prompt)}/prompt ·
-         ${Math.round(r.c.current.turns)} turns</span>` : ''},
-    {h: 'Instead of', f: r => `<b>${esc(r.x.name)}</b>`},
-    {h: '$ / prompt', num: 1, f: r => fmtUSD(r.x.cost_per_prompt)},
-    {h: 'Turns', num: 1, f: r => `${Math.round(r.x.turns)} <span class="note">(${r.x.turn_ratio}×)</span>`},
-    {h: 'Re-asked', num: 1, f: r => `${fmtPct(r.x.repeat_pct)}<span class="note">${
-      r.x.repeat_delta > 0 ? ' +' + r.x.repeat_delta : ''}</span>`},
-    {h: 'On', num: 1, f: r => `${fmtInt(r.x.prompts)} prompts`},
-    {h: 'Verdict', f: r => `<span title="${esc(r.x.why)}">${
-      statusChip(VERDICT[r.x.verdict][2], VERDICT[r.x.verdict][1])}</span>`},
-    {h: 'Would save', num: 1, f: r => r.x.verdict === 'supported'
-      ? `<b>${fmtUSD(r.x.estimated_savings_usd)}</b>` : `<span class="note">${fmtUSD(r.x.estimated_savings_usd)}</span>`},
-    {h: '', f: r => `<button class="act ghost trial-btn" data-cat="${esc(r.c.category)}"
-       data-model="${esc(r.x.model)}" data-name="${esc(r.x.name)}">Try it →</button>`},
-  ], rows) + `<div class="note" style="padding:10px 14px">${esc(ev.method)}</div>`;
-}
-
-VIEWS.modelswitch = async (page) => {
-  const [m, ev] = await Promise.all([
-    api('model_switch'),
-    api('model_evidence').catch(() => null),
-  ]);
-  const sc = m.savings_by_confidence || {};
-  const conf = c => `<span class="badge rec">${esc(c)} confidence</span>`;
-  page.innerHTML = `
-    <div class="grid g4">
-      ${kpi('Backed by your own runs', fmtUSD(ev?.estimated_savings_usd || 0),
-        `${ev?.categories?.filter(c => c.recommended).length || 0} categories where a cheaper model
-         already did the same work for less`, {badge: BADGE.actual})}
-      ${kpi('Potential savings', fmtUSD(m.estimated_savings_usd),
-        `${fmtPct(m.total_cost_usd ? 100 * m.estimated_savings_usd / m.total_cost_usd : 0)} of ${fmtUSD(m.total_cost_usd)} in range`,
-        {badge: BADGE.recommendation})}
-      ${kpi('Safe to switch', fmtUSD(m.safe_savings_usd), 'High + medium confidence only', {badge: BADGE.recommendation})}
-      ${kpi('Try on a sample first', fmtUSD(sc.low || 0), 'Low confidence: coding and refactoring', {badge: BADGE.recommendation})}
-      ${kpi('Stays on current model', fmtUSD(m.blocked_by_context_usd),
-        `${fmtInt(m.blocked_by_context_requests)} requests too big for the cheaper model's context`, {badge: BADGE.estimated})}
-    </div>
-    ${card('What actually happened when you used a cheaper model',
-      `<div id="ms-ev">${evidenceBody(ev)}</div>`, {badge: BADGE.actual, flush: 1,
-      hint: 'Measured from your own prompts — no repricing, no assumptions about tokens',
-      footer: ev ? esc(ev.caveat) : ''})}
-    <div class="note">The table above is history; the one below is a model. Where they disagree,
-      believe the history: repricing assumes the cheaper model would finish in the same number of
-      turns, and your data shows that is often where the saving goes.</div>
-    ${card('Switch these (repriced, not measured)', `<div id="ms-sw"></div>`,
-      {badge: BADGE.recommendation, flush: 1,
-      hint: 'Each request repriced on the model its work needs, same tokens',
-      footer: esc(m.caveat)})}
-    ${card('Default model per project', `<div id="ms-pj"></div>`, {badge: BADGE.recommendation, flush: 1,
-      hint: 'Based on how much frontier-model spend is reasoning-heavy work'})}
-    ${card('How to switch', `<div class="stack">
-      ${(m.providers?.length ? m.providers : ['anthropic']).map(pv => { const h = (m.how_by_agent || {})[pv] || m.how; return `
-      <div class="dt"><b>${esc(h.agent || 'Claude Code')}</b></div>
-      <div class="dt"><b>This session:</b> <code>${esc(h.session)}</code></div>
-      <div class="dt"><b>Whole project:</b> <code>${esc(h.project)}</code></div>
-      ${pv === 'anthropic' ? `<div class="dt"><b>Subagents:</b> <code>${esc(m.how.subagent)}</code></div>` : ''}`; }).join('')}
-      <div class="dt note">Kept on the top model: ${esc(Object.entries(m.rules).filter(([, v]) => v === 'keep').map(([k]) => k.replace('_', ' ')).join(', '))}.</div>
-    </div>`)}`;
-  $('#ms-sw', page).innerHTML = table([
-    {h: 'Work', f: r => esc(r.scope)},
-    {h: 'Now', f: r => esc(r.current_name)},
-    {h: 'Switch to', f: r => `<b>${esc(r.recommended_name)}</b>`},
-    {h: 'Confidence', f: r => conf(r.confidence)},
-    {h: 'Requests', num: 1, f: r => fmtInt(r.requests)},
-    {h: 'Est. cost now', num: 1, f: r => fmtUSD(r.cost)},
-    {h: 'After switch', num: 1, f: r => fmtUSD(r.alt)},
-    {h: 'Saves', num: 1, f: r => `<b>${fmtUSD(r.estimated_savings_usd)}</b> (${fmtPct(r.estimated_savings_pct)})`},
-  ], m.switches);
-  $('#ms-pj', page).innerHTML = table([
-    {h: 'Project', trunc: 1, f: r => esc(r.project)},
-    {h: 'Frontier spend', num: 1, f: r => fmtUSD(r.frontier_cost)},
-    {h: 'Reasoning-heavy', num: 1, f: r => fmtPct(r.keep_pct)},
-    {h: 'Suggested default', f: r => `<b>${esc(r.suggested_default)}</b>`},
-    {h: 'Could save', num: 1, f: r => fmtUSD(r.estimated_savings_usd)},
-    {h: 'Why', f: r => esc(r.why)},
-  ], m.projects);
-  wireTrials(page);
-  addChart(page, 'Savings by switch', el => C.barsH(el, {
-    rows: m.switches.slice(0, 10), label: r => clip(`${r.scope} → ${r.recommended_name}`, 48),
-    value: r => r.estimated_savings_usd,
-    color: r => r.confidence === 'high' ? seriesVar(2) : r.confidence === 'medium' ? seriesVar(0) : 'var(--warning)',
-    sub: r => `<div class="row"><span class="k">Now</span><span class="v">${fmtUSD(r.cost)}</span></div>
-      <div class="row"><span class="k">After</span><span class="v">${fmtUSD(r.alt)}</span></div>
-      <div class="row"><span class="k">Confidence</span><span class="v">${esc(r.confidence)}</span></div>`}),
-    {badge: BADGE.recommendation, hint: 'Colour = confidence (green high, blue medium, amber low)'});
-};
-
-/* ---------- trial: stop recommending, start measuring ----------
-   The evidence ends at "strong evidence for a trial, not proof". This runs the
-   trial: real prompts out of your own history, re-run headlessly on the
-   candidate model, priced against what they cost the first time. It spends real
-   money, so nothing happens without two clicks. */
-function trialPanelHTML(cat, model, name, s) {
-  if (!s.available) {
-    return `<div class="empty">The <code>claude</code> CLI is not on PATH, so a trial cannot be
-      run from here.</div>`;
-  }
-  if (!s.samples.length) {
-    return `<div class="empty">No prompt you actually typed in this category is short enough to
-      re-run safely.</div>`;
-  }
-  const base = s.samples.reduce((a, x) => a + (x.baseline_cost_usd || 0), 0);
-  return `
-    <div class="dt">These are ${s.samples.length} prompts you really sent in
-      <b>${esc(cat.replace('_', ' '))}</b>. Running them again on <b>${esc(name)}</b> costs money —
-      they cost ${fmtUSD(base)} the first time, and the cheaper model should come in under that.</div>
-    <div class="stack trial-samples">${s.samples.map((x, i) => `
-      <div class="dt trial-s" data-i="${i}">
-        <span class="note">${esc(x.day)} · ${esc(x.baseline_name)} · ${fmtUSD(x.baseline_cost_usd)} ·
-          ${fmtInt(x.baseline_turns)} turns</span>
-        <div class="trial-text">${esc(x.text.slice(0, 400))}${x.text.length > 400 ? '…' : ''}</div>
-      </div>`).join('')}</div>
-    <div class="dt note">Runs headlessly in a scratch directory. Tools that need permission are
-      denied, because a headless agent cannot ask — so a task that needs your repo will look
-      smaller here than it really is.</div>
-    <div class="live-actions">
-      <button class="act trial-run">▶ Run ${s.samples.length} prompts on ${esc(name)}</button>
-      <button class="act ghost trial-copy">Copy the first prompt instead</button>
-      <span class="trial-msg note"></span>
-    </div>
-    <div class="trial-out"></div>`;
-}
-
-const TRIAL_VERDICT = {
-  confirmed:    ['healthy', 'Confirmed by running it'],
-  marginal:     ['high', 'Smaller than advertised'],
-  contradicted: ['critical', 'History overstated it'],
-  failed:       ['critical', 'Runs failed'],
-  unclear:      ['high', 'Inconclusive'],
-};
-
-function trialResultHTML(r) {
-  const v = TRIAL_VERDICT[r.verdict] || TRIAL_VERDICT.unclear;
-  return `<div class="dt"><b>${statusChip(v[0], v[1])}</b> ${esc(r.why)}</div>` + table([
-    {h: 'Prompt', trunc: 1, f: x => esc(x.prompt)},
-    {h: 'First time', num: 1, f: x => fmtUSD(x.baseline_cost_usd)},
-    {h: 'On ' + esc(r.alias), num: 1, f: x => x.ok ? fmtUSD(x.cost_usd) : '—'},
-    {h: 'Turns', num: 1, f: x => x.ok ? fmtInt(x.turns) : '—'},
-    {h: 'Took', num: 1, f: x => x.ok ? x.elapsed_s + 's' : '—'},
-    {h: 'Denied', num: 1, f: x => x.denials ? fmtInt(x.denials) : ''},
-    {h: 'Result', f: x => x.ok ? `<span class="note">${esc((x.result || '').slice(0, 120))}</span>`
-      : `<span class="status critical">${esc((x.error || 'failed').slice(0, 120))}</span>`},
-  ], r.runs) + `<div class="note" style="padding:8px 14px">${esc(r.note)}</div>`;
-}
-
-function wireTrials(page) {
-  page.querySelectorAll('.trial-btn').forEach(b => b.onclick = async () => {
-    const row = b.closest('tr');
-    if (row.nextElementSibling?.classList.contains('trial-row')) {
-      row.nextElementSibling.remove(); return;
-    }
-    const {cat, model, name} = b.dataset;
-    const tr = h(`<tr class="trial-row"><td colspan="10"><div class="trial-panel">
-      <div class="empty">Finding prompts you sent…</div></div></td></tr>`);
-    row.after(tr);
-    const host = tr.querySelector('.trial-panel');
-    let s;
-    try {
-      s = await fetch(`/api/trial?category=${encodeURIComponent(cat)}&limit=3`).then(r => r.json());
-    } catch (e) { host.innerHTML = `<div class="empty">${esc(e.message)}</div>`; return; }
-    host.innerHTML = trialPanelHTML(cat, model, name, s);
-    const msg = host.querySelector('.trial-msg');
-    host.querySelector('.trial-copy')?.addEventListener('click', async () => {
-      try { await navigator.clipboard.writeText(s.samples[0].text); msg.textContent = 'Copied.'; }
-      catch { msg.textContent = 'Could not copy.'; }
-    });
-    host.querySelector('.trial-run')?.addEventListener('click', async ev => {
-      const btn = ev.currentTarget;
-      if (btn.dataset.armed !== '1') {
-        btn.dataset.armed = '1';
-        btn.textContent = 'Click again to spend real money';
-        btn.classList.add('warn');
-        return;
-      }
-      btn.disabled = true;
-      btn.textContent = 'Running…';
-      msg.textContent = 'Each prompt runs to completion; this can take a few minutes.';
-      try {
-        const r = await fetch('/api/trial/run', {
-          method: 'POST',
-          headers: {'X-FinOps-Action': '1', 'Content-Type': 'application/json'},
-          body: JSON.stringify({category: cat, model, prompts: s.samples}),
-        }).then(x => x.json());
-        host.querySelector('.trial-out').innerHTML = r.ok
-          ? trialResultHTML(r) : `<div class="empty">${esc(r.error || 'failed')}</div>`;
-        msg.textContent = '';
-      } catch (e) {
-        msg.textContent = e.message;
-      }
-      btn.disabled = false;
-      btn.classList.remove('warn');
-      btn.textContent = '▶ Run again';
-      btn.dataset.armed = '';
-    });
-  });
-}
-
 /* ---------- waste ---------- */
 VIEWS.waste = async (page) => {
   const w = await api('waste');
@@ -1557,8 +1481,8 @@ VIEWS.waste = async (page) => {
     </div>
     <div class="note"><b>Exposed spend</b> is what the flagged items cost in total — money worth
       reviewing, not money wasted. <b>Estimated excess</b> is how much more that work cost than a
-      reasonable baseline, de-duplicated across rules, and is what the FinOps score grades. Each
-      rule below states the baseline it measures against.</div>
+      reasonable baseline, de-duplicated across rules. Each rule below states the baseline it
+      measures against.</div>
     ${['high', 'medium', 'low'].map(sev => {
       const list = w.findings.filter(f => f.severity === sev);
       if (!list.length) return '';
@@ -1725,6 +1649,8 @@ VIEWS.live = async (page) => {
     fetch('/api/live?agents=' + encodeURIComponent(S.filter.agents.join(','))).then(r => r.json()),   // never cached: always live
     fetch('/api/usage').then(r => r.json()).catch(e => ({ok: false, error: e.message}))]);
   const list = res.sessions || [];
+  const liveActions = res.actions || ['interrupt', 'close', 'kill'];
+  const canInterrupt = liveActions.includes('interrupt');
   const agentName = id => ((S.opts?.agents || []).find(a => a.id === id) || {}).name || id;
   const busy = list.filter(x => x.status === 'busy');
   const sevOf = x => x.severity === 'high' ? 'high' : x.severity === 'medium' ? 'medium' : 'low';
@@ -1758,15 +1684,11 @@ VIEWS.live = async (page) => {
         <div class="dt">${x.status === 'busy' ? '<b>Working now</b>' : 'Idle'}${x.uptime ? ` · up ${esc(x.uptime)}` : ''} ·
           last activity ${x.last_write_s == null ? '—' : dur(x.last_write_s)} ago${x.memory_mb == null ? '' : ` · ${fmtInt(x.memory_mb)} MB`} ·
           <span class="note">${esc(x.cwd)}</span></div>
-        ${x.advice ? `<div class="dt switch-tip"><b>${x.advice.trial ? 'Worth trying' : 'Cheaper model'}:</b>
-          ${esc(x.advice.line)}
-          <button class="act ghost" data-copy="${esc(x.advice.command)}"
-            title="${esc(x.advice.why)}">Copy ${esc(x.advice.command)}</button></div>` : ''}
         ${x.severity !== 'ok' ? `<div class="dt"><b>Advice:</b> ${x.severity === 'high'
           ? 'Very large context. Use <b>Hand over</b> to continue in a fresh session, or split the remaining work into sub-sessions.'
           : 'Getting heavy. Hit <b>Compact</b> at the next break, or close it if the task is done.'}</div>` : ''}
         <div class="live-actions">
-          ${x.signalable ? `<button class="act" data-a="interrupt" ${x.status !== 'busy' ? 'disabled title="Nothing running"' : ''}>⏸ Interrupt</button>
+          ${x.signalable ? `${canInterrupt ? `<button class="act" data-a="interrupt" ${x.status !== 'busy' ? 'disabled title="Nothing running"' : ''}>⏸ Interrupt</button>` : ''}
           ${x.agent === 'claude' ? '<button class="act" data-a="compact" title="Types /compact into that session\'s terminal">🗜 Compact</button>' : ''}
           <button class="act warn" data-a="close">⏹ Close session</button>
           <button class="act danger" data-a="kill">✖ Force kill</button>` : `<span class="note">${x.agent === 'cursor' ? 'Runs inside the Cursor IDE: stop it there.' : 'No matching process found: stop it in its terminal.'}</span>`}
@@ -1902,10 +1824,10 @@ VIEWS.diagnose = async (page) => {
         <div class="hd"><a href="#" class="sess-link" data-sess="${esc(x.session_id)}">${esc(x.title || shortId(x.session_id))}</a>
           <span class="note">· ${esc(x.project)}</span><span class="spacer"></span>
           <span style="font-variant-numeric:tabular-nums">peak ${fmtNum(x.peak)} · ${fmtUSD(x.cost)} ·
-            ~${fmtUSD(x.avoidable_cost)} above a 100K baseline</span></div>
+            ~${fmtNum(x.tokens_above_100k)} tokens re-read above 100K (not a saving)</span></div>
         ${x.fixes.map(t => `<div class="dt">• ${esc(t)}</div>`).join('')}${pb(x.playbook)}</div>`).join('')
       || '<div class="empty">No session passed 150K context</div>'}</div>`,
-      {badge: BADGE.recommendation, hint: '"Above baseline" = context re-read beyond 100K, at cache-read price (est.)'})}
+      {badge: BADGE.recommendation, hint: '"Above baseline" = context re-read beyond 100K'})}
     <div id="dx-mem"></div>${card(`Add to ${md}${isCl ? ' / memory' : ''} (from your past prompts)`, `<div class="stack">${d.memory_suggestions.map(x => `
       <div class="item sev-${x.kind === 'security' ? 'high' : x.already_saved ? 'low' : 'medium'}">
         <div class="hd">${x.kind === 'security' ? '🔐' : x.kind === 'template' ? '⚙' : x.kind === 'reference' ? '🔗' : '📝'}
@@ -1924,11 +1846,10 @@ VIEWS.diagnose = async (page) => {
       {badge: BADGE.actual, hint: 'Drivers overlap, so shares do not add up to 100%'})}
     <div id="dx-recs"></div>${card('What to change', `<div class="stack">${d.recommendations.map(r => `
       <div class="item sev-${r.priority === 1 ? 'high' : r.priority === 2 ? 'medium' : 'low'}">
-        <div class="hd">${esc(r.title)}<span class="spacer"></span>
-          ${r.est_savings_usd ? `<span>~${fmtUSD(r.est_savings_usd)} est.</span>` : ''}</div>
+        <div class="hd">${esc(r.title)}</div>
         <div class="dt"><b>Why:</b> ${esc(r.why)}</div>
         <div class="dt"><b>How:</b> ${esc(r.how)}</div>
-        ${r.savings_basis ? `<div class="dt note">${esc(r.savings_basis)}</div>` : ''}${pb(r.playbook)}</div>`).join('')
+        ${pb(r.playbook)}</div>`).join('')
       || '<div class="empty">Nothing stands out</div>'}</div>`, {badge: BADGE.recommendation})}
     ${card(`Projects: ${esc(d.vocab?.name || 'Claude')} config health`, `<div id="dx-proj"></div>`,
       {badge: BADGE.recommendation, hint: isCl ? 'CLAUDE.md, memory, .claude/settings.json and MCP checked on disk now' : `${md} checked on disk now`, flush: 1})}
@@ -2019,8 +1940,6 @@ VIEWS.forecast = async (page) => {
     return; }
   page.innerHTML = `
     <div class="grid g4">
-      ${kpi('End of day', fmtUSD(f.end_of_day_cost), null, {badge: BADGE.forecast})}
-      ${kpi('End of week', fmtUSD(f.end_of_week_cost), null, {badge: BADGE.forecast})}
       ${kpi('End of billing period', fmtUSD(f.scenarios.expected.end_of_period_cost),
         `${f.remaining_days} days remaining`, {badge: BADGE.forecast})}
       ${kpi('Estimated monthly cost', fmtUSD(f.estimated_monthly_cost), null, {badge: BADGE.forecast})}
@@ -2034,22 +1953,26 @@ VIEWS.forecast = async (page) => {
         : kpi('Limit exhaustion date', esc(f.limit_exhaustion_date),
             f.will_exceed ? '🔴 forecast exceeds allowance' : '🟢 within allowance', {badge: BADGE.forecast})}
     </div>
-    ${card('Cumulative spend and forecast fan', '<div class="chart" id="fan2"></div>' +
-      '<div class="legend" id="fl2"></div>', {badge: BADGE.forecast,
+    ${card('Cumulative spend and forecast fan', f.insufficient_history
+        ? '<div class="empty">Fewer than 7 priced days in the window: bands not shown.</div>'
+        : '<div class="chart" id="fan2"></div><div class="legend" id="fl2"></div>',
+      {badge: BADGE.forecast,
       hint: f.method,
-      footer: 'Scenarios are the 14-day mean daily spend minus, at, and plus one standard deviation, projected across the remaining days of the billing period. They assume your recent pattern continues.'})}
+      footer: 'Scenarios are the 14-calendar-day mean daily spend minus, at, and plus one standard deviation, projected across the remaining days of the billing period. Days you did not use Claude count as zero, since the projection runs over calendar days. They assume your recent pattern continues.'})}
     ${card('Scenarios', table([
       {h: 'Scenario', f: r => `<b>${esc(r[0])}</b>`},
       {h: 'Daily rate', num: 1, f: r => fmtUSD(r[1].daily_rate)},
       {h: 'Projected end of period', num: 1, f: r => fmtUSD(r[1].end_of_period_cost)},
       {h: 'vs today', num: 1, f: r => '+' + fmtUSD(r[1].end_of_period_cost - f.period_used)},
     ], Object.entries(f.scenarios)), {badge: BADGE.forecast})}`;
-  C.forecastFan($('#fan2', page), {history: burn.series, scenarios: f.scenarios,
-    remainingDays: f.remaining_days, height: 300});
-  $('#fl2', page).innerHTML = `<span class="it"><span class="swatch" style="background:var(--s1)"></span>
-    Cumulative actual (estimated cost)</span>
-    <span class="it"><span class="swatch" style="background:var(--s1);opacity:.35"></span>
-    Forecast band (conservative → high)</span>`;
+  if (!f.insufficient_history) {
+    C.forecastFan($('#fan2', page), {history: burn.series, scenarios: f.scenarios,
+      remainingDays: f.remaining_days, height: 300});
+    $('#fl2', page).innerHTML = `<span class="it"><span class="swatch" style="background:var(--s1)"></span>
+      Cumulative actual (estimated cost)</span>
+      <span class="it"><span class="swatch" style="background:var(--s1);opacity:.35"></span>
+      Forecast band (conservative → high)</span>`;
+  }
 };
 
 /* ---------- budgets ---------- */
@@ -2120,7 +2043,7 @@ VIEWS.budgets = async (page) => {
       </div>`, {footer: `Plan allowances are NOT available from ${agentWord()} data. Anything you enter here is your own declared figure, used only to compute usage-vs-limit and days-until-limit.`})}`;
   $('#savecfg', page).onclick = async () => {
     const v = id => { const x = $('#' + id, page).value.trim(); return x === '' ? null : +x; };
-    await fetch('/api/settings', {method: 'POST', headers: {'Content-Type': 'application/json'},
+    await fetch('/api/settings', {method: 'POST', headers: {'Content-Type': 'application/json', 'X-FinOps-Action': '1'},
       body: JSON.stringify({
         budgets: {monthly_usd: v('b-monthly'), daily_usd: v('b-daily'), monthly_tokens: v('b-tokens')},
         limits: {monthly_cost_allowance_usd: v('l-cost'), monthly_token_allowance: v('l-tok'),
@@ -2144,7 +2067,7 @@ VIEWS.scorecard = async (page) => {
     ${card('AI FinOps Score', `<div class="scorewrap">
       <div style="text-align:center">
         <div class="scorenum">${sc.score}</div>
-        <div class="scoregrade">out of 100 · grade <b>${sc.grade}</b></div>
+        <div class="scoregrade">out of 100</div>
         <div class="chart" id="sg" style="width:190px;margin-top:6px"></div></div>
       <div style="flex:1;min-width:280px" class="stack">${sc.dimensions.map(d => `
         <div><div style="display:flex;justify-content:space-between;font-size:12px">
@@ -2154,7 +2077,7 @@ VIEWS.scorecard = async (page) => {
           : d.score >= 30 ? 'approaching' : 'critical'}"><i style="width:${d.score}%"></i></div>
         <div class="note">${esc(d.detail)}</div></div>`).join('')}
       </div></div>`, {badge: BADGE.estimated,
-      footer: 'The score is a weighted mean of the dimensions above, each graded against a reference in config/settings.json → scorecard. It is a self-consistency measure of your own usage, not a benchmark against other users.'})}
+      footer: 'Each dimension is measured from your transcripts; budget adherence needs a budget in Settings.'})}
     <div class="grid g3">
       ${card('✅ What is good', `<ul style="margin:0 0 0 18px;font-size:12.5px">${
         sc.what_is_good.map(x => `<li style="margin-bottom:6px">${esc(x)}</li>`).join('')
@@ -2317,8 +2240,8 @@ VIEWS.exports = async (page) => {
           <div class="dt">Projected from history. Assumes recent patterns continue; it is not a
           commitment or a quote.</div></div>
         <div class="item"><div class="hd">${BADGE.recommendation} Recommendation</div>
-          <div class="dt">Modelled opportunity. Savings estimates hold token usage constant on the
-          alternative and do not model output quality.</div></div>
+          <div class="dt">A recommendation grounded in an observed share of spend. No saving is
+          estimated.</div></div>
       </div>
       <h3 style="font-size:12.5px;margin:14px 0 6px">Deliberately not fabricated</h3>
       <dl class="kv">
@@ -2341,7 +2264,7 @@ function focusItems(d) {
   for (const m of d.memory_suggestions || []) if (m.kind === 'security')
     out.push({lvl: 1, text: `Credentials pasted in prompts (${m.sessions} sessions): rotate them`, view: 'diagnose', anchor: 'dx-mem'});
   for (const r of d.recommendations || []) if (r.priority === 1)
-    out.push({lvl: 1, text: r.title + (r.est_savings_usd ? ` (~${fmtUSD(r.est_savings_usd)})` : ''), view: 'diagnose', anchor: 'dx-recs'});
+    out.push({lvl: 1, text: r.title, view: 'diagnose', anchor: 'dx-recs'});
   for (const p of d.projects || []) for (const i of p.issues) if (i.severity === 'high')
     out.push({lvl: 1, text: `${p.name}: ${i.title}`, view: 'diagnose', anchor: 'dx-issues'});
   const s0 = (d.session_health || [])[0];
@@ -2491,7 +2414,9 @@ async function render() {
   applyRange('30d');
   // ?view=<name> opens straight to one screen, so a link (or a screenshot run)
   // can point at a specific report rather than always landing on the overview.
-  const want = new URLSearchParams(location.search).get('view');
+  let want = new URLSearchParams(location.search).get('view');
+  // The repriced Model switch view was removed; its links now open the measured comparison.
+  if (want === 'modelswitch') want = 'compare';
   if (want && NAV.some(([, items]) => items.some(([id]) => id === want))) S.view = want;
   await render();
   if (!want) maybeFirstTour();   // arriving on a deep link is not a first visit
@@ -2624,7 +2549,7 @@ VIEWS.freemodels = async (page) => {
   const d = await fetch('/api/free_models').then(r => r.json());
   page.innerHTML = `
     <div class="note">${esc(d.how_it_works)} Free models are weaker than Claude: use them for routine
-      work (see <a data-go="modelswitch">Model switch</a> for which work that is) and keep Claude for hard problems.</div>
+      work (see <a data-go="compare">Compare models</a> for what your own history shows) and keep Claude for hard problems.</div>
     ${!d.bin_on_path ? `<div class="item sev-medium"><div class="dt">${esc(d.bin_dir)} is not on your PATH, so the new commands
       won't run by name. Add <code>export PATH="$HOME/.local/bin:$PATH"</code> to ~/.zshrc.</div></div>` : ''}
     ${card('How to use and test a free model', `<div class="stack">
@@ -2715,6 +2640,7 @@ async function addFreeModel(id) {
 /* ---------- compare Claude vs free models ---------- */
 VIEWS.compare = async (page) => {
   const d = await fetch('/api/compare?agents=' + encodeURIComponent(S.filter.agents.join(','))).then(r => r.json());
+  if (d.error) throw new Error(d.error);
   const hasFree = d.rows.some(r => r.kind === 'free');
   const stars = n => n == null ? '<span class="na">—</span>' : '★'.repeat(Math.floor(n)) + (n % 1 ? '½' : '') +
     `<span style="opacity:.25">${'★'.repeat(5 - Math.ceil(n))}</span>`;
@@ -2727,7 +2653,7 @@ VIEWS.compare = async (page) => {
       hint: hasFree ? `This machine: ${esc(d.os)}, ${d.ram_gb} GB RAM` : 'List prices, your usage in range', footer: esc(d.note)})}
     ${!hasFree ? '' : `<div class="grid g3">
       ${card('Use Claude for', `<div class="dt">Multi-file changes, debugging, anything agentic or long-running.
-        Sonnet is the value pick; keep Opus for the hardest problems (see <a data-go="modelswitch">Model switch</a>).</div>`)}
+        Sonnet is the value pick; keep Opus for the hardest problems (see <a data-go="compare">Compare models</a>).</div>`)}
       ${card('Use a free model for', `<div class="dt">Offline or private work, throwaway snippets, explanations,
         single-file edits. Cloud Qwen is the strongest free option; locally, pick the biggest one that fits your RAM.</div>`)}
       ${card('Try it on your own work', `<div class="dt">Give the same small task to a free model (e.g. <code>claude-qwen</code>)
@@ -2925,13 +2851,13 @@ const TOURS = {
     {el: 'card:Top 10 most expensive prompts', t: 'Most expensive prompts', see: 'The ten single prompts that cost the most.', get: 'The requests worth rewriting or splitting.', act: 'Click a prompt to see every step it triggered.'},
     {el: 'card:Most expensive sessions', t: 'Most expensive sessions', see: 'The longest-running, highest-cost sessions.', get: 'The marathon sessions where context kept being re-read.', act: 'Click one to see where it grew.'},
     {el: 'card:Waste detection', t: 'Waste at a glance', see: 'A summary of the patterns that burn tokens for nothing.', get: 'An estimate of what you could avoid.', act: 'Open <b>Waste detection</b> for the full findings and evidence.'},
-    {el: 'card:Optimization opportunities', t: 'Opportunities', see: 'The top ranked changes with estimated savings.', get: 'What to fix first.', act: 'Open <b>What should I do?</b> for the full list with ready-made prompts.'},
+    {el: 'card:Optimization opportunities', t: 'Opportunities', see: 'The top ranked changes, ranked by spend involved.', get: 'What to fix first.', act: 'Open <b>What should I do?</b> for the full list with ready-made prompts.'},
     {el: 'card:Forecast', t: 'Forecast', see: 'Projected spend to the end of the billing period.', get: 'An early read on whether you\'ll go over.', act: 'Open <b>Forecast</b> for the optimistic and pessimistic scenarios.'},
-    {el: 'card:FinOps score', t: 'FinOps score', see: 'Your overall score for cache use, model mix, waste and budget.', get: 'One number for how efficiently you work.', act: 'Open <b>FinOps scorecard</b> to see what each component grades.'}],
+    {el: 'card:FinOps score', t: 'FinOps score', see: 'Your overall score for context share, cache break-even and budget adherence.', get: 'One number for how efficiently you work.', act: 'Open <b>FinOps scorecard</b> to see what each dimension measures.'}],
   advisor: [
-    {el: 'card:Biggest optimization opportunity', t: 'Start here', see: 'The single change with the largest estimated saving, with the evidence behind it.', get: 'The best use of your next ten minutes.', act: 'Read the estimate, then apply the change.'},
+    {el: 'card:Biggest optimization opportunity', t: 'Start here', see: 'The change involving the most spend, with the evidence behind it.', get: 'The best use of your next ten minutes.', act: 'Read the estimate, then apply the change.'},
     {el: 'card:What is going well', t: 'Strengths & gaps', see: 'What your habits already do well, and the items that need attention.', get: 'Confirmation of what to keep doing, and where you lose money.', act: 'Work down the <b>Needs attention</b> list.'},
-    {el: 'card:All recommendations', t: 'All recommendations', see: 'Every recommendation, ranked by estimated saving, each with its reasoning.', get: 'A prioritised to-do list built from your own usage.', act: 'Copy a recommendation\'s prompt straight into your agent.'},
+    {el: 'card:All recommendations', t: 'All recommendations', see: 'Every recommendation, ranked by spend involved, each with its reasoning.', get: 'A prioritised to-do list built from your own usage.', act: 'Copy a recommendation\'s prompt straight into your agent.'},
     {el: 'card:Anomalies to inspect', t: 'Anomalies', see: 'Days and sessions that spent far more than your normal.', get: 'Surprises caught before they repeat.', act: 'Click one to see what happened that day.'}],
   agents: [
     {el: 'kpis', t: 'Agent totals', see: 'One tile per agent with its usage for the current filters.', get: 'How spend splits across Claude Code, Codex, Gemini CLI and Cursor.', act: 'Use the agent chips in the header to focus on one.'},
@@ -2946,7 +2872,7 @@ const TOURS = {
     {el: 'card:AI FinOps Score', t: 'Your score', see: 'The overall score with a component breakdown: cache use, model mix, waste and budget.', get: 'Where your habits are strong and where they cost money.', act: 'Hover a component to see how it is calculated.'},
     {el: 'card:✅ What is good', t: 'What is good', see: 'The components you already score well on.', get: 'The habits worth keeping.', act: 'Keep these when you change your setup.'},
     {el: 'card:⚠️ Needs attention', t: 'Needs attention', see: 'The components dragging the score down.', get: 'A short list of what to fix.', act: 'Start at the top: it carries the most weight.'},
-    {el: 'card:🎯 Biggest opportunity', t: 'Biggest opportunity', see: 'The single change that would move the score most.', get: 'One concrete action with an estimated saving.', act: 'Apply it, then Sync and re-check the score.'}],
+    {el: 'card:🎯 Biggest opportunity', t: 'Biggest opportunity', see: 'The single change that would move the score most.', get: 'One concrete action grounded in observed spend.', act: 'Apply it, then Sync and re-check the score.'}],
   usage: [
     {el: 'kpis', t: 'Token breakdown', see: 'Total, input, output, thinking, cache read and cache write tokens, plus requests, sessions, prompts and active days.', get: 'Exactly which kind of token you spend on. Cache read is cheap; uncached input is not.', act: 'Compare cache read against input: a low ratio means context is being re-sent, not reused.'},
     {el: 'card0', t: 'Usage over time', see: 'Tokens or cost per day (or per hour on short ranges).', get: 'Spikes and quiet periods at a glance.', act: 'Hover a bar for the day\'s numbers; narrow the range to zoom in.'},
@@ -2965,7 +2891,7 @@ const TOURS = {
   context: [
     {el: 'kpis', t: 'Context & cache', see: 'Average and peak context per request, and how much is served from cache.', get: 'How much re-reading history costs you, and what caching saves.', act: 'Large average context? Clear or compact sessions more often.'},
     {el: 'card:Cost by context size', t: 'Cost by context size', see: 'Spend grouped by how large the context was.', get: 'Proof of how quickly cost climbs with context.', act: 'See how much sits in the largest buckets.'},
-    {el: 'card:Caching: with vs without', t: 'What caching saves', see: 'What you paid against what the same work would cost with no cache.', get: 'The value of cache hits in money.', act: 'A small gap means sessions are restarted too often to build a cache.'},
+    {el: 'card:Caching: with vs without', t: 'Caching, with vs without', see: 'What you paid against what the same tokens would cost with no cache at all.', get: 'A counterfactual, not a saving: nobody would have run it that way.', act: 'A small gap means sessions are restarted too often to build a cache.'},
     {el: 'card:Sessions with the largest context', t: 'Largest contexts', see: 'The sessions that carried the most history.', get: 'The sessions to split or hand over next time.', act: 'Click one to see where it grew.'},
     {el: 'card:Context distribution', t: 'Context distribution', see: 'How your requests spread across context sizes.', get: 'Whether large contexts are the exception or the norm.', act: 'A long right tail means /compact earlier.'}],
   projects: [
@@ -2988,7 +2914,7 @@ const TOURS = {
   categories: [
     {el: 'card:Cost by activity', t: 'Cost by activity', see: 'Spend per kind of work: coding, debugging, docs, review and so on.', get: 'Which kinds of work cost most.', act: 'Cheap, repetitive categories are the ones to move to a smaller model.'},
     {el: 'card:Prompts by activity', t: 'Prompts by activity', see: 'How many prompts fall into each category.', get: 'Volume next to cost: a category can be frequent but cheap.', act: 'Compare this with the cost chart to find the expensive outliers.'},
-    {el: 'card:Activity breakdown', t: 'Activity breakdown', see: 'Per category: prompts, tokens, cost and the model used.', get: 'Concrete evidence for routing work to a cheaper model.', act: 'Then open <b>Model switch</b> to see the saving.'}],
+    {el: 'card:Activity breakdown', t: 'Activity breakdown', see: 'Per category: prompts, tokens, cost and the model used.', get: 'Concrete evidence for routing work to a cheaper model.', act: 'Then open <b>Model switch</b> to see the options.'}],
   developer: [
     {el: 'card:Cost per repository', t: 'Cost per repository', see: 'Spend per repo checked out on this machine.', get: 'Which codebase is expensive to work in.', act: 'Click a repo to filter the dashboards.'},
     {el: 'card:Tool usage', t: 'Tool usage', see: 'Each tool the agent called and how often.', get: 'Tools with huge call counts: they fill context and cost money.', act: 'Big Read or Grep counts? Add project memory so the agent re-reads less.'},
@@ -3015,16 +2941,14 @@ const TOURS = {
     {el: 'card:Slash commands', t: 'Slash commands', see: 'The commands and user-invoked skills you actually use.', get: 'Which shortcuts earn their keep.', act: 'Delete the ones you never call.'},
     {el: 'card:MCP servers', t: 'MCP servers', see: 'Each configured server, whether it was ever called, and its context cost.', get: 'Tool definitions loaded on every request for nothing.', act: 'Remove servers that are configured but never called.'},
     {el: 'card:Connectors', t: 'Connectors', see: 'claude.ai connectors and their share of context.', get: 'The same check for connectors as for MCP servers.', act: 'Disconnect what you don\'t use from this machine.'}],
+  hygiene: [
+    {el: 'kpis', t: 'Where spend sat', see: 'The share of spend in requests above each context size, and the share that came after a session first crossed it.', get: 'How much of the bill was re-sending a large prefix.', act: 'A high "after crossing" share means the expensive part of a session was its tail.'},
+    {el: 'card:Sessions ranked', t: 'Sessions', see: 'Each session\'s context trajectory and what it spent after crossing the threshold.', get: 'The sessions where a fresh start would have mattered most.', act: 'Click a row for its trajectory; alt-click to open the session.'}],
   waste: [
     {el: 'kpis', t: 'Waste headlines', see: 'Estimated excess, exposed spend, and how many prompts, sessions and rules are involved.', get: 'An honest estimate of avoidable spend.', act: '<b>Exposed</b> is what flagged work cost in total; <b>excess</b> is how much more than a fair baseline.'},
     {el: 'card:🔴 High waste', t: 'High waste', see: 'The rules that fired hardest: repeated reads, retries, stale sessions.', get: 'The costly patterns, each with the baseline it is measured against.', act: 'Open <b>Show flagged items</b> to see the evidence, then fix these first.'},
-    {el: 'card:🟡 Optimization opportunities', t: 'Medium findings', see: 'Patterns worth changing but not urgent.', get: 'The next tier of savings.', act: 'Batch these into one config change.'},
+    {el: 'card:🟡 Optimization opportunities', t: 'Medium findings', see: 'Patterns worth changing but not urgent.', get: 'The next tier of opportunities.', act: 'Batch these into one config change.'},
     {el: 'card:⚪ Low-priority observations', t: 'Low-priority observations', see: 'Small findings, kept for completeness.', get: 'Context for the numbers above.', act: 'Skim them; act only if one matches a habit you want to change.'}],
-  modelswitch: [
-    {el: 'kpis', t: 'Model switch', see: 'What you\'d save running routine work on a cheaper model from the same vendor, split by confidence.', get: 'Savings you can trust, separated from savings that need a judgement call.', act: 'Start with the high-confidence figure.'},
-    {el: 'card:Switch these', t: 'Switch these', see: 'The specific prompts or categories that a smaller model could have handled.', get: 'Evidence per item, not a blanket recommendation.', act: 'Check a few prompts yourself before you trust the pattern.'},
-    {el: 'card:Default model per project', t: 'Default per project', see: 'A suggested default model for each project, from the work you do there.', get: 'A setting you change once instead of choosing per prompt.', act: 'Apply it to your cheapest, most repetitive repo first.'},
-    {el: 'card:How to switch', t: 'How to switch', see: 'The exact command or setting for each agent.', get: 'No guessing at flag names.', act: 'Copy the command for your agent and try it on a small task.'}],
   freemodels: [
     {el: 'card:How to use and test a free model', t: 'How it works', see: 'How to plug a local or free cloud model into Claude Code, and how to test it.', get: 'Zero-cost options for simple or private work.', act: 'Read the RAM guidance before you pick a model.'},
     {el: 'card1', t: 'A model', see: 'Each model with its size, RAM needs, strengths and limits.', get: 'A realistic idea of what runs on your machine.', act: 'Click <b>＋ Add</b> on a model that fits your RAM.'}],
@@ -3037,9 +2961,9 @@ const TOURS = {
     {el: 'card:MCP servers for work you repeat', t: 'MCP suggestions', see: 'Servers suggested from the work your prompts repeat.', get: 'Fewer manual steps and smaller prompts.', act: 'Add one, then check its context cost in <b>Who used the tokens</b>.'},
     {el: 'card:Skills from what you repeat', t: 'Skill suggestions', see: 'Skills drafted from the instructions you keep retyping.', get: 'Repetition moved out of your prompts.', act: 'Create a suggested skill in one click.'}],
   recommendations: [
-    {el: 'card:Biggest optimization opportunity', t: 'Start here', see: 'The change with the largest estimated saving.', get: 'The best single thing to do next.', act: 'Apply it, then Sync and re-check.'},
+    {el: 'card:Biggest optimization opportunity', t: 'Start here', see: 'The change involving the most spend, with the evidence behind it.', get: 'The best single thing to do next.', act: 'Apply it, then Sync and re-check.'},
     {el: 'card:What is going well', t: 'Strengths & gaps', see: 'What already works, and what needs attention.', get: 'What to keep and what to change.', act: 'Work down the <b>Needs attention</b> list.'},
-    {el: 'card:All recommendations', t: 'All recommendations', see: 'Every recommendation with its estimated saving and reasoning.', get: 'A prioritised list of what to change.', act: 'Start with the highest saving.'},
+    {el: 'card:All recommendations', t: 'All recommendations', see: 'Every recommendation with its spend involved and reasoning.', get: 'A prioritised list of what to change.', act: 'Start with the highest spend involved.'},
     {el: 'card:Anomalies to inspect', t: 'Anomalies', see: 'Unusual days and sessions worth a look.', get: 'Problems caught before they become habits.', act: 'Click one to see what happened.'}],
   anomalies: [
     {el: 'card:Daily spend with anomalies highlighted', t: 'Spend with anomalies', see: 'Daily spend with the outlier days marked against your normal band.', get: 'How far outside normal each day was.', act: 'Hover a highlighted day for its numbers.'},