@cat-factory/app 0.168.0 → 0.170.0

package/README.md

@@ -56,9 +56,10 @@ over the WebSocket. How that sync works is written up in
 ## Interface modes (basic / advanced)
 
 The SPA renders at one of two **interface tiers**. `basic` (the default) is the everyday
-surface: the power-user nav destinations are hidden and the run/pipeline options that only
-exist to override a workspace-level default are left at that default. `advanced` shows
-everything. The tier resolves in a fixed order, first match wins:
+surface: the run/pipeline options that only exist to override a workspace-level default are
+left at that default, and the nav is trimmed to the destinations that are the **only route**
+to their capability. `advanced` shows everything. The tier resolves in a fixed order, first
+match wins:
 
 1. **`NUXT_PUBLIC_UI_MODE`** (`basic` | `advanced`) — the deployment pin. Like
    `NUXT_PUBLIC_API_BASE` it is baked in at **build** time (`ssr: false`), and while it is
@@ -81,7 +82,15 @@ hoc where it can be avoided:
 - **A nav destination** declares `advanced: true` in `app/modular/nav-contributions.ts`. The
   shared `navSlotFilter` drops it in basic mode across all three shells (sidebar, command
   palette, toolbar), independently of its RBAC `gate` — both must pass. A consumer module's
-  own contributions take the same flag.
+  own contributions take the same flag. The bar for setting it is **route count, not how
+  advanced the surface feels**: hiding the only way to reach a capability removes the
+  capability from the tier, while hiding a shortcut into a surface a basic destination also
+  opens removes nothing. So the flag belongs on a surface that sits beside the delivery path
+  (Sandbox, Kaizen), on a palette shortcut into a Workspace-settings tab, or on a knob the
+  Integrations hub already offers — and never on a sole route (the pipeline builder, the
+  fragment library, the infrastructure/PREnv windows, the operator + reports views).
+  `nav-contributions.spec.ts` pins the advanced set against a table of each item's
+  alternative route, so promoting one forces that claim to be written down.
 - **A less-used option inside a surface** reads `useUiModeStore().isAdvanced`. Hide, never
   disable, and only ever hide an OVERRIDE: what remains must be exactly the default the hidden
   field would have shown, so a basic-mode user never gets different behaviour from an advanced

package/app/components/observability/StepMetricsBar.vue

@@ -4,10 +4,10 @@ import type { StepMetrics } from '~/types/execution'
 import {
   formatMs,
   formatTokens,
-  freshPromptTokens,
   headroomColor,
   headroomRatio,
   pct,
+  totalInputTokens,
   transportRatio,
 } from '~/utils/observability'
 
@@ -23,12 +23,16 @@ defineEmits<{ inspect: [] }>()
 const { t } = useI18n()
 
 const m = computed(() => props.metrics)
-// The headline "↑" is FRESH (uncached) input, not the raw prompt-token sum: a long agentic
-// run re-sends its whole transcript every turn, so the raw sum is ~all cache reads and reads
-// as a blow-up. The cached prefix is shown separately (the green chip) so the two are distinct.
-const freshPrompt = computed(() =>
-  freshPromptTokens(m.value.promptTokens, m.value.cachedPromptTokens ?? 0),
-)
+// The headline "↑" is TOTAL input — fresh + both cache classes — the like-for-like measure of
+// Claude Code's own context gauge, which counts the same buckets because a cached token still
+// occupies the context window (see `totalInputTokens`). The three classes then render as the
+// breakdown, because they are priced an order of magnitude apart in opposite directions: a read
+// is ~0.1x base input, a write 1.25-2x. Volume in the headline, cost in the breakdown — leading
+// with fresh made a 31M-token run read as a 685-token one.
+const totalInput = computed(() => totalInputTokens(m.value))
+const cacheRead = computed(() => m.value.cacheReadTokens ?? 0)
+const cacheWrite = computed(() => m.value.cacheWriteTokens ?? 0)
+const hasCache = computed(() => cacheRead.value > 0 || cacheWrite.value > 0)
 const headroom = computed(() => headroomRatio(m.value))
 const transport = computed(() => transportRatio(m.value))
 const headroomTone = computed(() => headroomColor(headroom.value, m.value.truncatedCalls > 0))
@@ -53,20 +57,9 @@ const headroomTone = computed(() => headroomColor(headroom.value, m.value.trunca
       <span class="text-slate-500">·</span>
       <span
         class="tabular-nums text-slate-400"
-        :title="t('observability.metricsBar.promptCompletionTokens')"
+        :title="t('observability.metricsBar.inputCompletionTokens')"
       >
-        {{ formatTokens(freshPrompt) }}↑ {{ formatTokens(m.completionTokens) }}↓
-      </span>
-      <span
-        v-if="(m.cachedPromptTokens ?? 0) > 0"
-        class="tabular-nums text-emerald-400/80"
-        :title="t('observability.metricsBar.cachedTokensHint')"
-      >
-        {{
-          t('observability.metricsBar.cachedTokens', {
-            tokens: formatTokens(m.cachedPromptTokens ?? 0),
-          })
-        }}
+        {{ formatTokens(totalInput) }}↑ {{ formatTokens(m.completionTokens) }}↓
       </span>
       <div class="ms-auto flex items-center gap-1">
         <UBadge v-if="m.errors > 0" color="error" variant="subtle" size="sm">
@@ -83,6 +76,29 @@ const headroomTone = computed(() => headroomColor(headroom.value, m.value.trunca
       </div>
     </div>
 
+    <!-- input breakdown: the headline's three classes, priced an order of magnitude apart -->
+    <div v-if="hasCache" class="mt-1.5 flex items-center gap-1.5 text-[11px] tabular-nums">
+      <span class="text-slate-400" :title="t('observability.metricsBar.freshHint')">
+        {{ t('observability.metricsBar.fresh', { tokens: formatTokens(m.promptTokens) }) }}
+      </span>
+      <span v-if="cacheRead > 0" class="text-slate-600">·</span>
+      <span
+        v-if="cacheRead > 0"
+        class="text-emerald-400/80"
+        :title="t('observability.metricsBar.cacheReadHint')"
+      >
+        {{ t('observability.metricsBar.cacheRead', { tokens: formatTokens(cacheRead) }) }}
+      </span>
+      <span v-if="cacheWrite > 0" class="text-slate-600">·</span>
+      <span
+        v-if="cacheWrite > 0"
+        class="text-amber-400/80"
+        :title="t('observability.metricsBar.cacheWriteHint')"
+      >
+        {{ t('observability.metricsBar.cacheWrite', { tokens: formatTokens(cacheWrite) }) }}
+      </span>
+    </div>
+
     <!-- output-limit headroom -->
     <div v-if="headroom !== null" class="mt-2">
       <div class="flex items-center justify-between text-[11px]">

package/app/components/panels/ObservabilityPanel.vue

@@ -8,7 +8,7 @@ import type {
   WebSearchProvider,
 } from '~/types/execution'
 import { agentKindMeta } from '~/utils/catalog'
-import { formatMs, formatTokens, freshPromptTokens, pct } from '~/utils/observability'
+import { formatMs, formatTokens, pct, totalInputTokens } from '~/utils/observability'
 
 // Drill-down overlay for a run's LLM activity. Opened via
 // `ui.openObservability(instanceId)` from a step surface; loads the full per-call
@@ -126,15 +126,18 @@ const totals = computed(() => {
   const upstreamMs = sum(c, (x) => x.upstreamMs)
   const overheadMs = sum(c, (x) => x.overheadMs)
   const total = upstreamMs + overheadMs
+  // The three input classes are orthogonal at the source, so they are simply summed —
+  // `promptTokens` IS the fresh figure and needs no heuristic to recover it; the headline is
+  // their TOTAL (see `totalInputTokens` — the like-for-like Claude Code context gauge).
   const promptTokens = sum(c, (x) => x.promptTokens)
-  const cachedPromptTokens = sum(c, (x) => x.cachedPromptTokens)
+  const cacheReadTokens = sum(c, (x) => x.cacheReadTokens)
+  const cacheWriteTokens = sum(c, (x) => x.cacheWriteTokens)
   return {
     calls: c.length,
     promptTokens,
-    cachedPromptTokens,
-    // Fresh (uncached) input — the raw prompt-token sum is dominated by per-turn cache reads
-    // on a long agentic run, so surface fresh vs cached rather than the misleading raw total.
-    freshPromptTokens: freshPromptTokens(promptTokens, cachedPromptTokens),
+    cacheReadTokens,
+    cacheWriteTokens,
+    inputTokens: totalInputTokens({ promptTokens, cacheReadTokens, cacheWriteTokens }),
     completionTokens: sum(c, (x) => x.completionTokens),
     upstreamMs,
     overheadMs,
@@ -290,18 +293,47 @@ function exportJson() {
                     {{ t('observability.summary.tokensInOut') }}
                   </dt>
                   <dd class="mt-0.5 tabular-nums text-slate-200">
-                    {{ formatTokens(totals.freshPromptTokens) }} /
-                    {{ formatTokens(totals.completionTokens) }}
+                    <span :title="t('observability.summary.inputTokensHint')">
+                      {{ formatTokens(totals.inputTokens) }} /
+                      {{ formatTokens(totals.completionTokens) }}
+                    </span>
                     <span
-                      v-if="totals.cachedPromptTokens > 0"
-                      class="ms-1 text-[11px] text-emerald-400/80"
+                      v-if="totals.cacheReadTokens > 0 || totals.cacheWriteTokens > 0"
+                      class="mt-0.5 block text-[11px]"
                     >
-                      ·
-                      {{
-                        t('observability.summary.cached', {
-                          tokens: formatTokens(totals.cachedPromptTokens),
-                        })
-                      }}
+                      <span class="text-slate-400" :title="t('observability.summary.freshHint')">
+                        {{
+                          t('observability.summary.fresh', {
+                            tokens: formatTokens(totals.promptTokens),
+                          })
+                        }}
+                      </span>
+                      <template v-if="totals.cacheReadTokens > 0">
+                        <span class="text-slate-600"> · </span>
+                        <span
+                          class="text-emerald-400/80"
+                          :title="t('observability.summary.cacheReadHint')"
+                        >
+                          {{
+                            t('observability.summary.cacheRead', {
+                              tokens: formatTokens(totals.cacheReadTokens),
+                            })
+                          }}
+                        </span>
+                      </template>
+                      <template v-if="totals.cacheWriteTokens > 0">
+                        <span class="text-slate-600"> · </span>
+                        <span
+                          class="text-amber-400/80"
+                          :title="t('observability.summary.cacheWriteHint')"
+                        >
+                          {{
+                            t('observability.summary.cacheWrite', {
+                              tokens: formatTokens(totals.cacheWriteTokens),
+                            })
+                          }}
+                        </span>
+                      </template>
                     </span>
                   </dd>
                 </div>
@@ -418,12 +450,14 @@ function exportJson() {
                     <span
                       :title="
                         t('observability.call.tokensTitle', {
-                          prompt: c.promptTokens,
+                          input: totalInputTokens(c),
+                          fresh: c.promptTokens,
                           completion: c.completionTokens,
                         })
                       "
                     >
-                      {{ formatTokens(c.promptTokens) }}↑ {{ formatTokens(c.completionTokens) }}↓
+                      {{ formatTokens(totalInputTokens(c)) }}↑
+                      {{ formatTokens(c.completionTokens) }}↓
                     </span>
                     <span
                       v-if="headroomOf(c) !== null"
@@ -467,11 +501,14 @@ function exportJson() {
                     <span v-if="c.requestMaxTokens != null">{{
                       t('observability.call.maxTokens', { value: c.requestMaxTokens })
                     }}</span>
-                    <span v-if="c.cachedPromptTokens > 0" class="text-emerald-400">{{
-                      t('observability.call.promptCached', {
-                        cached: c.cachedPromptTokens,
-                        prompt: c.promptTokens,
-                      })
+                    <span v-if="c.cacheReadTokens > 0 || c.cacheWriteTokens > 0">{{
+                      t('observability.call.fresh', { tokens: c.promptTokens })
+                    }}</span>
+                    <span v-if="c.cacheReadTokens > 0" class="text-emerald-400">{{
+                      t('observability.call.cacheRead', { tokens: c.cacheReadTokens })
+                    }}</span>
+                    <span v-if="c.cacheWriteTokens > 0" class="text-amber-400">{{
+                      t('observability.call.cacheWrite', { tokens: c.cacheWriteTokens })
                     }}</span>
                     <span>{{
                       t('observability.call.total', { duration: formatMs(c.totalMs) })

package/app/modular/nav-contributions.spec.ts

@@ -99,11 +99,36 @@ describe('navSlotFilter', () => {
     expect(kept).toContain('integrations-hub')
     expect(kept).toContain('workspace-settings')
     expect(kept).toContain('model-config')
-    // ...and the authoring / operator surfaces don't.
-    expect(kept).not.toContain('build-pipeline')
-    expect(kept).not.toContain('fragments')
+    // ...and so does every destination that is the SOLE route to its capability, however deep
+    // it feels: authoring a flow, the standards library, the PREnv/runner plumbing, and the
+    // aggregate run-health / spend views.
+    expect(kept).toContain('build-pipeline')
+    expect(kept).toContain('fragments')
+    expect(kept).toContain('infrastructure')
+    expect(kept).toContain('environment-setup')
+    expect(kept).toContain('operator-dashboard')
+    expect(kept).toContain('reports')
+    // What drops is beside the delivery path (experimentation) or a shortcut into a surface
+    // basic mode already reaches another way.
     expect(kept).not.toContain('sandbox')
-    expect(kept).not.toContain('operator-dashboard')
+    expect(kept).not.toContain('kaizen')
+    expect(kept).not.toContain('merge-thresholds')
+  })
+
+  it('never makes an advanced item the only route to its capability', () => {
+    // The tier's governing rule (see the catalog comment): every advanced destination either
+    // sits beside the delivery path, or is a shortcut into a surface a basic destination also
+    // opens. Spelled out here as a table so promoting an item to `advanced` forces an explicit
+    // claim about how basic mode still reaches it, rather than a silent capability loss.
+    const ALTERNATIVE_ROUTE: Record<string, string> = {
+      sandbox: 'none needed - experimentation surface, not on the delivery path',
+      kaizen: 'none needed - self-grading history, not on the delivery path',
+      'merge-thresholds': 'workspace-settings -> Merge tab',
+      'service-fragment-defaults': 'workspace-settings -> Service best practices tab',
+      'local-models': 'integrations-hub -> Local runners',
+    }
+    const advanced = NAV_CONTRIBUTIONS.filter((i) => i.advanced).map((i) => i.id)
+    expect(advanced.sort()).toEqual(Object.keys(ALTERNATIVE_ROUTE).sort())
   })
 
   it('keeps the tier switch itself reachable in basic mode', () => {
@@ -119,15 +144,19 @@ describe('navSlotFilter', () => {
   })
 
   it('keeps the tier and the permission axes independent — both must pass', () => {
-    // `build-pipeline` is advanced AND needs board.write: neither axis alone reveals it.
+    // `sandbox` is advanced AND needs integrations.manage: neither axis alone reveals it.
     const advancedOnly: NavGates = { ...NO_GATES, advancedMode: true }
-    expect(ids(navSlotFilter(slots(), { gates: advancedOnly }))).not.toContain('build-pipeline')
+    expect(ids(navSlotFilter(slots(), { gates: advancedOnly }))).not.toContain('sandbox')
 
-    const permissionOnly: NavGates = { ...NO_GATES, canWriteBoard: true, advancedMode: false }
-    expect(ids(navSlotFilter(slots(), { gates: permissionOnly }))).not.toContain('build-pipeline')
+    const permissionOnly: NavGates = {
+      ...NO_GATES,
+      canManageIntegrations: true,
+      advancedMode: false,
+    }
+    expect(ids(navSlotFilter(slots(), { gates: permissionOnly }))).not.toContain('sandbox')
 
-    const both: NavGates = { ...NO_GATES, canWriteBoard: true, advancedMode: true }
-    expect(ids(navSlotFilter(slots(), { gates: both }))).toContain('build-pipeline')
+    const both: NavGates = { ...NO_GATES, canManageIntegrations: true, advancedMode: true }
+    expect(ids(navSlotFilter(slots(), { gates: both }))).toContain('sandbox')
   })
 
   it('leaves at least one sidebar destination in every basic-mode section it keeps', () => {

package/app/modular/nav-contributions.ts

@@ -153,13 +153,24 @@ const S = (...s: NavSurface[]) => s as readonly NavSurface[]
  *    with accounts enabled).
  *  - one icon per destination across shells.
  *
- * `advanced: true` marks the power-user half, hidden in basic interface mode. The line
- * drawn here is "would a team shipping their first task open this?": connecting a repo or
- * an integration, picking models, and the workspace/account settings stay; AUTHORING the
- * machinery those defaults come from (the pipeline builder, the fragment library, merge
- * thresholds, service fragment defaults), the experimentation surfaces (sandbox, Kaizen),
- * the infrastructure/environment plumbing, per-user local models, and the operator-tier
- * dashboards do not.
+ * `advanced: true` marks the power-user half, hidden in basic interface mode. The line is
+ * drawn by ROUTE COUNT, not by how advanced a surface feels: hiding the only way to reach a
+ * capability removes the capability from the tier, while hiding a shortcut to a surface basic
+ * mode already reaches removes nothing. So an item is advanced only when both of these hold —
+ * it is not the sole route to its capability, and nothing on the delivery path needs it:
+ *
+ *  - `sandbox` / `kaizen` — experimentation and self-grading surfaces, beside the delivery
+ *    path rather than on it.
+ *  - `merge-thresholds` / `service-fragment-defaults` — palette shortcuts into Workspace
+ *    settings tabs (Merge, Service best practices), which basic mode reaches via
+ *    `workspace-settings`.
+ *  - `local-models` — a per-user endpoint knob the Integrations hub already offers.
+ *
+ * Everything else stays in basic BECAUSE it is a sole route: authoring a flow
+ * (`build-pipeline`), the standards/skills library (`fragments`, whose only other route is a
+ * button two levels into Workspace settings), the PREnv + runner plumbing (`infrastructure`,
+ * `environment-setup`), and the operator/cost views that are the only aggregate read of run
+ * health and spend (`operator-dashboard`, `reports`).
  */
 export const NAV_CONTRIBUTIONS: readonly NavContribution[] = [
   {
@@ -167,7 +178,6 @@ export const NAV_CONTRIBUTIONS: readonly NavContribution[] = [
     labelKey: 'nav.buildPipeline',
     icon: 'i-lucide-workflow',
     surfaces: S('sidebar', 'command'),
-    advanced: true,
     gate: (g) => g.canWriteBoard,
     action: 'buildPipeline',
     testId: 'nav-build-pipeline',
@@ -253,7 +263,6 @@ export const NAV_CONTRIBUTIONS: readonly NavContribution[] = [
     labelKey: 'nav.infrastructure',
     icon: 'i-lucide-server-cog',
     surfaces: S('sidebar'),
-    advanced: true,
     gate: (g) => g.infrastructureAvailable,
     action: 'infrastructure',
     testId: 'nav-infrastructure',
@@ -264,7 +273,6 @@ export const NAV_CONTRIBUTIONS: readonly NavContribution[] = [
     labelKey: 'nav.environmentSetup',
     icon: 'i-lucide-flask-conical',
     surfaces: S('sidebar'),
-    advanced: true,
     gate: (g) => g.infrastructureAvailable,
     action: 'environmentSetup',
     testId: 'nav-environment-setup',
@@ -275,7 +283,6 @@ export const NAV_CONTRIBUTIONS: readonly NavContribution[] = [
     labelKey: 'nav.contextFragments',
     icon: 'i-lucide-book-marked',
     surfaces: S('sidebar', 'command'),
-    advanced: true,
     gate: (g) => g.libraryAvailable && g.canManageSettings,
     action: 'fragmentLibrary',
     testId: 'nav-fragments',
@@ -381,7 +388,6 @@ export const NAV_CONTRIBUTIONS: readonly NavContribution[] = [
     labelKey: 'nav.operatorDashboard',
     icon: 'i-lucide-gauge',
     surfaces: S('sidebar'),
-    advanced: true,
     gate: (g) => g.accountsEnabled && g.isAccountAdmin,
     action: 'operatorDashboard',
     testId: 'nav-operator-dashboard',
@@ -392,7 +398,6 @@ export const NAV_CONTRIBUTIONS: readonly NavContribution[] = [
     labelKey: 'nav.reports',
     icon: 'i-lucide-chart-column',
     surfaces: S('sidebar'),
-    advanced: true,
     gate: (g) => g.accountsEnabled && g.isAccountAdmin,
     action: 'reports',
     testId: 'nav-reports',

package/app/utils/observability.spec.ts

@@ -1,28 +1,28 @@
 import { describe, it, expect } from 'vitest'
-import { freshPromptTokens } from './observability'
+import { totalInputTokens } from './observability'
 
-describe('freshPromptTokens', () => {
-  it('subtracts the cached prefix from the prompt-token sum', () => {
-    expect(freshPromptTokens(1000, 300)).toBe(700)
+describe('totalInputTokens', () => {
+  it('sums all three input classes, so the headline matches Claude Code’s context gauge', () => {
+    expect(
+      totalInputTokens({ promptTokens: 685, cacheReadTokens: 31_099_813, cacheWriteTokens: 0 }),
+    ).toBe(31_100_498)
   })
 
-  it('reduces a near-fully-cached agentic run to its tiny fresh input (inclusive shape)', () => {
-    // The 31M-cache-read shape from the investigation on the INCLUSIVE shape (subscription
-    // harness / OpenAI-style): prompt tokens INCLUDE the cache reads, so subtracting the cached
-    // subset leaves the few-hundred-token fresh figure, not tens of millions.
-    expect(freshPromptTokens(31_100_498, 31_099_813)).toBe(685)
+  it('counts cache WRITES too — they occupy the window like any other input token', () => {
+    expect(
+      totalInputTokens({ promptTokens: 100, cacheReadTokens: 900, cacheWriteTokens: 40 }),
+    ).toBe(1040)
   })
 
-  it('treats promptTokens as already-fresh when cached exceeds it (Anthropic separate shape)', () => {
-    // Anthropic via the LLM proxy reports cache reads SEPARATELY, so promptTokens is fresh-only
-    // and cachedPromptTokens can far exceed it. The fresh figure is promptTokens itself — NOT 0
-    // (the old subtract-and-clamp collapsed real fresh input to zero on this shape).
-    expect(freshPromptTokens(685, 31_099_813)).toBe(685)
+  it('does NOT lead with the fresh figure on a cache-dominated run', () => {
+    // The regression this pins: leading with fresh made a ~31M-token run render as 685 tokens,
+    // discounting cache reads because their dollar cost is low. Volume is the thing being
+    // measured here, and a cached token costs the same context window as a fresh one.
+    const m = { promptTokens: 685, cacheReadTokens: 31_099_813, cacheWriteTokens: 0 }
+    expect(totalInputTokens(m)).toBeGreaterThan(m.promptTokens * 1000)
   })
 
-  it('never returns negative, and treats a fully-cached inclusive rollup as 0 fresh', () => {
-    expect(freshPromptTokens(500, 500)).toBe(0)
-    // cached > prompt ⇒ separate shape ⇒ fresh = prompt (never a negative number).
-    expect(freshPromptTokens(500, 600)).toBe(500)
+  it('degrades to the fresh count when an older snapshot carries no cache fields', () => {
+    expect(totalInputTokens({ promptTokens: 500 })).toBe(500)
   })
 })

package/app/utils/observability.ts

@@ -12,31 +12,28 @@ export function formatTokens(n: number): string {
 }
 
 /**
- * FRESH (uncached) prompt tokens: the input tokens actually processed this call/rollup after
- * excluding the prefix served from the provider's cache. A long agentic run re-sends its whole
- * growing transcript every turn, so on the "inclusive" shape the raw `promptTokens` sum is
- * dominated by cache reads (often >99%) — showing THAT as "tokens burned" reads as a blow-up
- * when almost nothing fresh was processed. This surfaces the fresh figure alongside cached.
+ * TOTAL input tokens: fresh + cache read + cache write. This is the headline "↑" figure on
+ * every LLM surface, and it deliberately COUNTS THE CACHED CLASSES.
  *
- * `cachedPromptTokens` has PROVIDER-DEPENDENT semantics (see the field docs on `stepMetricsSchema`
- * / `llmCallMetricSchema`), so we can't blindly subtract:
- *  - Inclusive shape (OpenAI/DeepSeek, and the subscription-CLI harness, which folds cache into
- *    `promptTokens`): cached is a SUBSET of prompt ⇒ fresh = prompt − cached.
- *  - Separate shape (Anthropic via the LLM proxy): cache reads are reported SEPARATELY and
- *    `promptTokens` is ALREADY fresh-only, so cached can EXCEED prompt. Subtracting there would
- *    wrongly collapse a real fresh input to 0 — when cached ≥ prompt, `promptTokens` itself IS
- *    the fresh figure.
+ * That is the like-for-like measure of Claude Code's own context gauge, which sums exactly these
+ * buckets because a cached token still physically occupies the context window. Leading with the
+ * fresh figure instead (what this surface used to do, on the grounds that the raw sum "reads as a
+ * blow-up") discounts cache reads because their DOLLAR cost is low — but the quota, latency and
+ * context-window cost is the whole thing an autonomous run burns, and hiding it is what let a
+ * ~31M-token run look like a 685-token one. See
+ * `docs/initiatives/token-burn-instrumentation.md`.
  *
- * NOTE: with only these two aggregates we cannot distinguish the separate shape while cached is
- * still ≤ prompt (there the subtraction under-counts fresh by the cache-read amount). A fully
- * exact split needs the wire contract to carry cache-read vs cache-write distinctly at the
- * source; this heuristic fixes the dominant (cached ≫ prompt) case and never returns negative.
+ * The three classes are still rendered as the breakdown beneath it, because they are priced an
+ * order of magnitude apart in opposite directions — this makes the volume honest WITHOUT making
+ * the cost unreadable. The two fields are optional on an older snapshot, where absent reads as 0
+ * and the total degrades to the fresh count.
  */
-export function freshPromptTokens(promptTokens: number, cachedPromptTokens: number): number {
-  // Separate shape: promptTokens is already fresh-only (cache reads counted separately).
-  if (cachedPromptTokens > promptTokens) return promptTokens
-  // Inclusive shape: cached is a subset of prompt.
-  return promptTokens - cachedPromptTokens
+export function totalInputTokens(m: {
+  promptTokens: number
+  cacheReadTokens?: number
+  cacheWriteTokens?: number
+}): number {
+  return m.promptTokens + (m.cacheReadTokens ?? 0) + (m.cacheWriteTokens ?? 0)
 }
 
 /** Compact duration: 850 → "850ms", 1500 → "1.5s", 90_000 → "1m 30s". */

package/i18n/locales/de.json

@@ -2906,13 +2906,23 @@
       "transportOverhead": "Transport-Overhead",
       "modelExecution": "Modellausführung",
       "truncated": "{count} abgeschnitten | {count} abgeschnitten",
-      "cached": "{tokens} gecacht"
+      "inputTokensHint": "Eingabe- / Ausgabe-Tokens insgesamt. Die Eingabe zählt auch gecachte Tokens mit: Sie belegen weiterhin das Kontextfenster, genau wie es die Kontextanzeige von Claude Code zählt.",
+      "fresh": "{tokens} frisch",
+      "freshHint": "Eingabe, die von Grund auf verarbeitet wurde, ohne Anteil aus dem Cache",
+      "cacheRead": "{tokens} aus dem Cache gelesen",
+      "cacheReadHint": "Eingabe-Tokens, die aus dem Cache des Providers bedient wurden (etwa 0,1x der Preis frischer Eingabe-Tokens)",
+      "cacheWrite": "{tokens} in den Cache geschrieben",
+      "cacheWriteHint": "Eingabe-Tokens, die in den Cache des Providers geschrieben wurden (1,25x bis 2x der Preis frischer Eingabe-Tokens)"
     },
     "metricsBar": {
       "calls": "{count} Aufruf | {count} Aufrufe",
-      "promptCompletionTokens": "Frische (nicht gecachte) Prompt-/Completion-Tokens",
-      "cachedTokens": "({tokens} zwischengespeichert)",
-      "cachedTokensHint": "Prompt-Tokens, die aus dem Cache des Providers bedient wurden",
+      "inputCompletionTokens": "Eingabe- / Ausgabe-Tokens insgesamt. Die Eingabe zählt auch gecachte Tokens mit: Sie belegen weiterhin das Kontextfenster, genau wie es die Kontextanzeige von Claude Code zählt.",
+      "fresh": "{tokens} frisch",
+      "freshHint": "Eingabe, die von Grund auf verarbeitet wurde, ohne Anteil aus dem Cache",
+      "cacheRead": "{tokens} aus dem Cache gelesen",
+      "cacheReadHint": "Eingabe-Tokens, die aus dem Cache des Providers bedient wurden (etwa 0,1x der Preis frischer Eingabe-Tokens)",
+      "cacheWrite": "{tokens} in den Cache geschrieben",
+      "cacheWriteHint": "Eingabe-Tokens, die in den Cache des Providers geschrieben wurden (1,25x bis 2x der Preis frischer Eingabe-Tokens)",
       "errors": "{count} Fehler | {count} Fehler",
       "warnings": "{count} Warnung | {count} Warnungen",
       "outputLimit": "Ausgabelimit",
@@ -2922,7 +2932,7 @@
       "modelExecution": "Modellausführung"
     },
     "call": {
-      "tokensTitle": "{prompt} Prompt- / {completion} Completion-Tokens",
+      "tokensTitle": "{input} Eingabe-Tokens (davon {fresh} frisch) / {completion} Ausgabe-Tokens",
       "outputUsedVsLimit": "Ausgabe genutzt vs. Limit",
       "transportVsExecution": "Transport-Overhead / Modellausführung",
       "error": "Fehler",
@@ -2932,7 +2942,9 @@
       "streamed": "gestreamt",
       "buffered": "gepuffert",
       "maxTokens": "max_tokens {value}",
-      "promptCached": "{cached}/{prompt} Prompt zwischengespeichert",
+      "fresh": "{tokens} frisch",
+      "cacheRead": "{tokens} aus dem Cache gelesen",
+      "cacheWrite": "{tokens} in den Cache geschrieben",
       "total": "gesamt {duration}",
       "prompt": "Prompt",
       "promptPrefixOmitted": "(nur neue Nachrichten: {count} frühere ausgelassen)",

package/i18n/locales/en.json

@@ -1434,13 +1434,23 @@
       "transportOverhead": "Transport overhead",
       "modelExecution": "Model execution",
       "truncated": "{count} truncated | {count} truncated",
-      "cached": "{tokens} cached"
+      "inputTokensHint": "Total input / completion tokens. Input counts cached tokens too: they still occupy the context window, exactly as Claude Code's own context gauge counts them.",
+      "fresh": "{tokens} fresh",
+      "freshHint": "Input processed from scratch, with nothing served from the cache",
+      "cacheRead": "{tokens} cache read",
+      "cacheReadHint": "Input tokens served from the provider's cache (about 0.1x the price of fresh input)",
+      "cacheWrite": "{tokens} cache write",
+      "cacheWriteHint": "Input tokens written into the provider's cache (1.25x to 2x the price of fresh input)"
     },
     "metricsBar": {
       "calls": "{count} call | {count} calls",
-      "promptCompletionTokens": "Fresh (uncached) prompt / completion tokens",
-      "cachedTokens": "({tokens} cached)",
-      "cachedTokensHint": "Prompt tokens served from the provider's cache",
+      "inputCompletionTokens": "Total input / completion tokens. Input counts cached tokens too: they still occupy the context window, exactly as Claude Code's own context gauge counts them.",
+      "fresh": "{tokens} fresh",
+      "freshHint": "Input processed from scratch, with nothing served from the cache",
+      "cacheRead": "{tokens} cache read",
+      "cacheReadHint": "Input tokens served from the provider's cache (about 0.1x the price of fresh input)",
+      "cacheWrite": "{tokens} cache write",
+      "cacheWriteHint": "Input tokens written into the provider's cache (1.25x to 2x the price of fresh input)",
       "errors": "{count} error | {count} errors",
       "warnings": "{count} warning | {count} warnings",
       "outputLimit": "Output limit",
@@ -1450,7 +1460,7 @@
       "modelExecution": "Model execution"
     },
     "call": {
-      "tokensTitle": "{prompt} prompt / {completion} completion tokens",
+      "tokensTitle": "{input} input tokens ({fresh} of them fresh) / {completion} completion tokens",
       "outputUsedVsLimit": "Output used vs limit",
       "transportVsExecution": "Transport overhead / model execution",
       "error": "error",
@@ -1460,7 +1470,9 @@
       "streamed": "streamed",
       "buffered": "buffered",
       "maxTokens": "max_tokens {value}",
-      "promptCached": "{cached}/{prompt} prompt cached",
+      "fresh": "{tokens} fresh",
+      "cacheRead": "{tokens} cache read",
+      "cacheWrite": "{tokens} cache write",
       "total": "total {duration}",
       "prompt": "Prompt",
       "promptPrefixOmitted": "(new messages only: {count} earlier omitted)",

package/i18n/locales/es.json

@@ -1368,13 +1368,23 @@
       "transportOverhead": "Sobrecarga de transporte",
       "modelExecution": "Ejecución del modelo",
       "truncated": "{count} truncada | {count} truncadas",
-      "cached": "{tokens} en caché"
+      "inputTokensHint": "Tokens totales de entrada / salida. La entrada tambien cuenta los tokens en caché: siguen ocupando la ventana de contexto, igual que los cuenta el medidor de contexto de Claude Code.",
+      "fresh": "{tokens} frescos",
+      "freshHint": "Entrada procesada desde cero, sin nada servido desde la caché",
+      "cacheRead": "{tokens} leídos de caché",
+      "cacheReadHint": "Tokens de entrada servidos desde la caché del proveedor (unas 0,1 veces el precio de la entrada fresca)",
+      "cacheWrite": "{tokens} escritos en caché",
+      "cacheWriteHint": "Tokens de entrada escritos en la caché del proveedor (de 1,25 a 2 veces el precio de la entrada fresca)"
     },
     "metricsBar": {
       "calls": "{count} llamada | {count} llamadas",
-      "promptCompletionTokens": "Tokens frescos (sin caché) de prompt / completado",
-      "cachedTokens": "({tokens} en caché)",
-      "cachedTokensHint": "Tokens de prompt servidos desde la caché del proveedor",
+      "inputCompletionTokens": "Tokens totales de entrada / salida. La entrada tambien cuenta los tokens en caché: siguen ocupando la ventana de contexto, igual que los cuenta el medidor de contexto de Claude Code.",
+      "fresh": "{tokens} frescos",
+      "freshHint": "Entrada procesada desde cero, sin nada servido desde la caché",
+      "cacheRead": "{tokens} leídos de caché",
+      "cacheReadHint": "Tokens de entrada servidos desde la caché del proveedor (unas 0,1 veces el precio de la entrada fresca)",
+      "cacheWrite": "{tokens} escritos en caché",
+      "cacheWriteHint": "Tokens de entrada escritos en la caché del proveedor (de 1,25 a 2 veces el precio de la entrada fresca)",
       "errors": "{count} error | {count} errores",
       "warnings": "{count} advertencia | {count} advertencias",
       "outputLimit": "Límite de salida",
@@ -1384,7 +1394,7 @@
       "modelExecution": "Ejecución del modelo"
     },
     "call": {
-      "tokensTitle": "{prompt} tokens de prompt / {completion} de completado",
+      "tokensTitle": "{input} tokens de entrada ({fresh} de ellos frescos) / {completion} tokens de salida",
       "outputUsedVsLimit": "Salida usada frente al límite",
       "transportVsExecution": "Sobrecarga de transporte / ejecución del modelo",
       "error": "error",
@@ -1394,7 +1404,9 @@
       "streamed": "en streaming",
       "buffered": "en búfer",
       "maxTokens": "max_tokens {value}",
-      "promptCached": "{cached}/{prompt} de prompt en caché",
+      "fresh": "{tokens} frescos",
+      "cacheRead": "{tokens} leídos de caché",
+      "cacheWrite": "{tokens} escritos en caché",
       "total": "total {duration}",
       "prompt": "Prompt",
       "promptPrefixOmitted": "(solo mensajes nuevos: {count} anteriores omitidos)",

package/i18n/locales/fr.json

@@ -1368,13 +1368,23 @@
       "transportOverhead": "Surcoût de transport",
       "modelExecution": "Exécution du modèle",
       "truncated": "{count} tronqué | {count} tronqués",
-      "cached": "{tokens} en cache"
+      "inputTokensHint": "Total des tokens d'entrée / de sortie. L'entree compte aussi les tokens en cache : ils occupent toujours la fenêtre de contexte, exactement comme les compte la jauge de contexte de Claude Code.",
+      "fresh": "{tokens} frais",
+      "freshHint": "Entrée traitée de zero, sans rien servi depuis le cache",
+      "cacheRead": "{tokens} lus depuis le cache",
+      "cacheReadHint": "Tokens d'entrée servis depuis le cache du fournisseur (environ 0,1 fois le prix d'une entrée fraîche)",
+      "cacheWrite": "{tokens} écrits dans le cache",
+      "cacheWriteHint": "Tokens d'entrée écrits dans le cache du fournisseur (1,25 à 2 fois le prix d'une entrée fraîche)"
     },
     "metricsBar": {
       "calls": "{count} appel | {count} appels",
-      "promptCompletionTokens": "Tokens frais (non mis en cache) de prompt / complétion",
-      "cachedTokens": "({tokens} en cache)",
-      "cachedTokensHint": "Tokens de prompt servis depuis le cache du fournisseur",
+      "inputCompletionTokens": "Total des tokens d'entrée / de sortie. L'entree compte aussi les tokens en cache : ils occupent toujours la fenêtre de contexte, exactement comme les compte la jauge de contexte de Claude Code.",
+      "fresh": "{tokens} frais",
+      "freshHint": "Entrée traitée de zero, sans rien servi depuis le cache",
+      "cacheRead": "{tokens} lus depuis le cache",
+      "cacheReadHint": "Tokens d'entrée servis depuis le cache du fournisseur (environ 0,1 fois le prix d'une entrée fraîche)",
+      "cacheWrite": "{tokens} écrits dans le cache",
+      "cacheWriteHint": "Tokens d'entrée écrits dans le cache du fournisseur (1,25 à 2 fois le prix d'une entrée fraîche)",
       "errors": "{count} erreur | {count} erreurs",
       "warnings": "{count} avertissement | {count} avertissements",
       "outputLimit": "Limite de sortie",
@@ -1384,7 +1394,7 @@
       "modelExecution": "Exécution du modèle"
     },
     "call": {
-      "tokensTitle": "{prompt} tokens de prompt / {completion} de complétion",
+      "tokensTitle": "{input} tokens d'entrée (dont {fresh} frais) / {completion} tokens de sortie",
       "outputUsedVsLimit": "Sortie utilisée vs limite",
       "transportVsExecution": "Surcoût de transport / exécution du modèle",
       "error": "erreur",
@@ -1394,7 +1404,9 @@
       "streamed": "en streaming",
       "buffered": "en mémoire tampon",
       "maxTokens": "max_tokens {value}",
-      "promptCached": "{cached}/{prompt} prompt en cache",
+      "fresh": "{tokens} frais",
+      "cacheRead": "{tokens} lus depuis le cache",
+      "cacheWrite": "{tokens} écrits dans le cache",
       "total": "total {duration}",
       "prompt": "Prompt",
       "promptPrefixOmitted": "(nouveaux messages uniquement : {count} antérieurs omis)",

package/i18n/locales/he.json

@@ -1368,13 +1368,23 @@
       "transportOverhead": "תקורת תעבורה",
       "modelExecution": "הרצת מודל",
       "truncated": "{count} נקטע | {count} נקטעו",
-      "cached": "{tokens} במטמון"
+      "inputTokensHint": "סך טוקני הקלט / הפלט. הקלט סופר גם טוקנים מהמטמון: הם עדיין תופסים את חלון ההקשר, בדיוק כפי שמד ההקשר של Claude Code סופר אותם.",
+      "fresh": "{tokens} חדשים",
+      "freshHint": "קלט שעובד מאפס, ללא שום חלק שהוגש מהמטמון",
+      "cacheRead": "{tokens} נקראו מהמטמון",
+      "cacheReadHint": "טוקני קלט שהוגשו ממטמון הספק (כ-0.1 ממחיר קלט חדש)",
+      "cacheWrite": "{tokens} נכתבו למטמון",
+      "cacheWriteHint": "טוקני קלט שנכתבו למטמון הספק (פי 1.25 עד 2 ממחיר קלט חדש)"
     },
     "metricsBar": {
       "calls": "{count} קריאה | {count} קריאות",
-      "promptCompletionTokens": "טוקני פרומפט / השלמה חדשים (ללא מטמון)",
-      "cachedTokens": "({tokens} במטמון)",
-      "cachedTokensHint": "טוקני פרומפט שהוגשו ממטמון הספק",
+      "inputCompletionTokens": "סך טוקני הקלט / הפלט. הקלט סופר גם טוקנים מהמטמון: הם עדיין תופסים את חלון ההקשר, בדיוק כפי שמד ההקשר של Claude Code סופר אותם.",
+      "fresh": "{tokens} חדשים",
+      "freshHint": "קלט שעובד מאפס, ללא שום חלק שהוגש מהמטמון",
+      "cacheRead": "{tokens} נקראו מהמטמון",
+      "cacheReadHint": "טוקני קלט שהוגשו ממטמון הספק (כ-0.1 ממחיר קלט חדש)",
+      "cacheWrite": "{tokens} נכתבו למטמון",
+      "cacheWriteHint": "טוקני קלט שנכתבו למטמון הספק (פי 1.25 עד 2 ממחיר קלט חדש)",
       "errors": "{count} שגיאה | {count} שגיאות",
       "warnings": "{count} אזהרה | {count} אזהרות",
       "outputLimit": "מגבלת פלט",
@@ -1384,7 +1394,7 @@
       "modelExecution": "הרצת מודל"
     },
     "call": {
-      "tokensTitle": "{prompt} טוקני פרומפט / {completion} טוקני השלמה",
+      "tokensTitle": "{input} טוקני קלט ({fresh} מהם חדשים) / {completion} טוקני פלט",
       "outputUsedVsLimit": "פלט בשימוש לעומת המגבלה",
       "transportVsExecution": "תקורת תעבורה / הרצת מודל",
       "error": "שגיאה",
@@ -1394,7 +1404,9 @@
       "streamed": "הוזרם",
       "buffered": "באגירה",
       "maxTokens": "max_tokens {value}",
-      "promptCached": "{cached}/{prompt} טוקני פרומפט במטמון",
+      "fresh": "{tokens} חדשים",
+      "cacheRead": "{tokens} נקראו מהמטמון",
+      "cacheWrite": "{tokens} נכתבו למטמון",
       "total": "סך הכל {duration}",
       "prompt": "פרומפט",
       "promptPrefixOmitted": "(הודעות חדשות בלבד: {count} מוקדמות יותר הושמטו)",

package/i18n/locales/it.json

@@ -2906,13 +2906,23 @@
       "transportOverhead": "Overhead di trasporto",
       "modelExecution": "Esecuzione del modello",
       "truncated": "{count} troncata | {count} troncate",
-      "cached": "{tokens} in cache"
+      "inputTokensHint": "Token totali di input / output. L'input conta anche i token in cache: occupano comunque la finestra di contesto, esattamente come li conta l'indicatore di contesto di Claude Code.",
+      "fresh": "{tokens} freschi",
+      "freshHint": "Input elaborato da zero, senza nulla servito dalla cache",
+      "cacheRead": "{tokens} letti dalla cache",
+      "cacheReadHint": "Token di input serviti dalla cache del provider (circa 0,1 volte il prezzo dell'input fresco)",
+      "cacheWrite": "{tokens} scritti nella cache",
+      "cacheWriteHint": "Token di input scritti nella cache del provider (da 1,25 a 2 volte il prezzo dell'input fresco)"
     },
     "metricsBar": {
       "calls": "{count} chiamata | {count} chiamate",
-      "promptCompletionTokens": "Token freschi (non in cache) di prompt / completion",
-      "cachedTokens": "({tokens} in cache)",
-      "cachedTokensHint": "Token di prompt serviti dalla cache del provider",
+      "inputCompletionTokens": "Token totali di input / output. L'input conta anche i token in cache: occupano comunque la finestra di contesto, esattamente come li conta l'indicatore di contesto di Claude Code.",
+      "fresh": "{tokens} freschi",
+      "freshHint": "Input elaborato da zero, senza nulla servito dalla cache",
+      "cacheRead": "{tokens} letti dalla cache",
+      "cacheReadHint": "Token di input serviti dalla cache del provider (circa 0,1 volte il prezzo dell'input fresco)",
+      "cacheWrite": "{tokens} scritti nella cache",
+      "cacheWriteHint": "Token di input scritti nella cache del provider (da 1,25 a 2 volte il prezzo dell'input fresco)",
       "errors": "{count} errore | {count} errori",
       "warnings": "{count} avviso | {count} avvisi",
       "outputLimit": "Limite di output",
@@ -2922,7 +2932,7 @@
       "modelExecution": "Esecuzione del modello"
     },
     "call": {
-      "tokensTitle": "{prompt} token di prompt / {completion} di completion",
+      "tokensTitle": "{input} token di input (di cui {fresh} freschi) / {completion} token di output",
       "outputUsedVsLimit": "Output usato vs limite",
       "transportVsExecution": "Overhead di trasporto / esecuzione del modello",
       "error": "errore",
@@ -2932,7 +2942,9 @@
       "streamed": "in streaming",
       "buffered": "bufferizzato",
       "maxTokens": "max_tokens {value}",
-      "promptCached": "{cached}/{prompt} prompt in cache",
+      "fresh": "{tokens} freschi",
+      "cacheRead": "{tokens} letti dalla cache",
+      "cacheWrite": "{tokens} scritti nella cache",
       "total": "totale {duration}",
       "prompt": "Prompt",
       "promptPrefixOmitted": "(solo nuovi messaggi: {count} precedenti omessi)",

package/i18n/locales/ja.json

@@ -1368,13 +1368,23 @@
       "transportOverhead": "転送オーバーヘッド",
       "modelExecution": "モデル実行",
       "truncated": "{count} 件が切り詰め | {count} 件が切り詰め",
-      "cached": "{tokens} キャッシュ済み"
+      "inputTokensHint": "入力 / 出力トークンの合計。入力にはキャッシュされたトークンも含まれます。それらも依然としてコンテキストウィンドウを占有するため、Claude Code のコンテキスト表示と同じ数え方です。",
+      "fresh": "{tokens} 新規",
+      "freshHint": "キャッシュから提供された分を含まない、ゼロから処理された入力",
+      "cacheRead": "{tokens} キャッシュ読み取り",
+      "cacheReadHint": "プロバイダーのキャッシュから提供された入力トークン (新規入力の約 0.1 倍の価格)",
+      "cacheWrite": "{tokens} キャッシュ書き込み",
+      "cacheWriteHint": "プロバイダーのキャッシュに書き込まれた入力トークン (新規入力の 1.25 倍から 2 倍の価格)"
     },
     "metricsBar": {
       "calls": "{count} 件の呼び出し | {count} 件の呼び出し",
-      "promptCompletionTokens": "新規（キャッシュ外）のプロンプト / 完了トークン",
-      "cachedTokens": "({tokens} 件キャッシュ済み)",
-      "cachedTokensHint": "プロバイダーのキャッシュから提供されたプロンプトトークン",
+      "inputCompletionTokens": "入力 / 出力トークンの合計。入力にはキャッシュされたトークンも含まれます。それらも依然としてコンテキストウィンドウを占有するため、Claude Code のコンテキスト表示と同じ数え方です。",
+      "fresh": "{tokens} 新規",
+      "freshHint": "キャッシュから提供された分を含まない、ゼロから処理された入力",
+      "cacheRead": "{tokens} キャッシュ読み取り",
+      "cacheReadHint": "プロバイダーのキャッシュから提供された入力トークン (新規入力の約 0.1 倍の価格)",
+      "cacheWrite": "{tokens} キャッシュ書き込み",
+      "cacheWriteHint": "プロバイダーのキャッシュに書き込まれた入力トークン (新規入力の 1.25 倍から 2 倍の価格)",
       "errors": "{count} 件のエラー | {count} 件のエラー",
       "warnings": "{count} 件の警告 | {count} 件の警告",
       "outputLimit": "出力上限",
@@ -1384,7 +1394,7 @@
       "modelExecution": "モデル実行"
     },
     "call": {
-      "tokensTitle": "{prompt} プロンプト / {completion} 完了トークン",
+      "tokensTitle": "入力トークン {input} 件 (うち新規 {fresh} 件) / 出力トークン {completion} 件",
       "outputUsedVsLimit": "使用済み出力 vs 上限",
       "transportVsExecution": "転送オーバーヘッド / モデル実行",
       "error": "エラー",
@@ -1394,7 +1404,9 @@
       "streamed": "ストリーミング",
       "buffered": "バッファ済み",
       "maxTokens": "max_tokens {value}",
-      "promptCached": "{cached}/{prompt} プロンプトをキャッシュ",
+      "fresh": "{tokens} 新規",
+      "cacheRead": "{tokens} キャッシュ読み取り",
+      "cacheWrite": "{tokens} キャッシュ書き込み",
       "total": "合計 {duration}",
       "prompt": "プロンプト",
       "promptPrefixOmitted": "(新規メッセージのみ: 以前の {count} 件を省略)",

package/i18n/locales/pl.json

@@ -1368,13 +1368,23 @@
       "transportOverhead": "Narzut transportu",
       "modelExecution": "Wykonanie modelu",
       "truncated": "{count} obcięte | {count} obcięte | {count} obciętych",
-      "cached": "{tokens} z pamięci podręcznej"
+      "inputTokensHint": "Łączna liczba tokenów wejścia / wyjscia. Wejście liczy takze tokeny z pamięci podręcznej: nadal zajmują okno kontekstu, dokładnie tak, jak liczy je wskaźnik kontekstu w Claude Code.",
+      "fresh": "{tokens} świeżych",
+      "freshHint": "Wejście przetworzone od zera, bez żadnej części obsłużonej z pamięci podręcznej",
+      "cacheRead": "{tokens} odczytane z pamięci podręcznej",
+      "cacheReadHint": "Tokeny wejściowe obsłużone z pamięci podręcznej dostawcy (około 0,1 ceny świeżego wejścia)",
+      "cacheWrite": "{tokens} zapisane do pamięci podręcznej",
+      "cacheWriteHint": "Tokeny wejściowe zapisane do pamięci podręcznej dostawcy (od 1,25 do 2 razy cena świeżego wejścia)"
     },
     "metricsBar": {
       "calls": "{count} wywołanie | {count} wywołania | {count} wywołań",
-      "promptCompletionTokens": "Świeże (niebuforowane) tokeny promptu / dopełnienia",
-      "cachedTokens": "({tokens} z pamięci podręcznej)",
-      "cachedTokensHint": "Tokeny promptu obsłużone z pamięci podręcznej dostawcy",
+      "inputCompletionTokens": "Łączna liczba tokenów wejścia / wyjscia. Wejście liczy takze tokeny z pamięci podręcznej: nadal zajmują okno kontekstu, dokładnie tak, jak liczy je wskaźnik kontekstu w Claude Code.",
+      "fresh": "{tokens} świeżych",
+      "freshHint": "Wejście przetworzone od zera, bez żadnej części obsłużonej z pamięci podręcznej",
+      "cacheRead": "{tokens} odczytane z pamięci podręcznej",
+      "cacheReadHint": "Tokeny wejściowe obsłużone z pamięci podręcznej dostawcy (około 0,1 ceny świeżego wejścia)",
+      "cacheWrite": "{tokens} zapisane do pamięci podręcznej",
+      "cacheWriteHint": "Tokeny wejściowe zapisane do pamięci podręcznej dostawcy (od 1,25 do 2 razy cena świeżego wejścia)",
       "errors": "{count} błąd | {count} błędy | {count} błędów",
       "warnings": "{count} ostrzeżenie | {count} ostrzeżenia | {count} ostrzeżeń",
       "outputLimit": "Limit wyjścia",
@@ -1384,7 +1394,7 @@
       "modelExecution": "Wykonanie modelu"
     },
     "call": {
-      "tokensTitle": "{prompt} tokenów promptu / {completion} tokenów dopełnienia",
+      "tokensTitle": "{input} tokenów wejścia (w tym {fresh} świeżych) / {completion} tokenów wyjścia",
       "outputUsedVsLimit": "Użyte wyjście a limit",
       "transportVsExecution": "Narzut transportu / wykonanie modelu",
       "error": "błąd",
@@ -1394,7 +1404,9 @@
       "streamed": "strumieniowane",
       "buffered": "buforowane",
       "maxTokens": "max_tokens {value}",
-      "promptCached": "{cached}/{prompt} promptu w pamięci podręcznej",
+      "fresh": "{tokens} świeżych",
+      "cacheRead": "{tokens} odczytane z pamięci podręcznej",
+      "cacheWrite": "{tokens} zapisane do pamięci podręcznej",
       "total": "łącznie {duration}",
       "prompt": "Prompt",
       "promptPrefixOmitted": "(tylko nowe wiadomości: {count} wcześniejszych pominięto)",

package/i18n/locales/tr.json

@@ -1368,13 +1368,23 @@
       "transportOverhead": "Taşıma yükü",
       "modelExecution": "Model yürütme",
       "truncated": "{count} kesildi | {count} kesildi",
-      "cached": "{tokens} önbellekte"
+      "inputTokensHint": "Toplam giriş / çıkış token'i. Giriş, önbelleğe alınmış token'ları da sayar: bunlar hâlâ bağlam penceresini kaplar, tıpkı Claude Code'un kendi bağlam göstergesinin saydığı gibi.",
+      "fresh": "{tokens} yeni",
+      "freshHint": "Önbellekten hiçbir şey sunulmadan sıfırdan işlenen giriş",
+      "cacheRead": "{tokens} önbellekten okundu",
+      "cacheReadHint": "Sağlayıcının önbelleğinden sunulan giriş token'ları (yeni girişin yaklaşık 0,1 katı fiyat)",
+      "cacheWrite": "{tokens} önbelleğe yazıldı",
+      "cacheWriteHint": "Sağlayıcının önbelleğine yazılan giriş token'ları (yeni girişin 1,25 ila 2 katı fiyat)"
     },
     "metricsBar": {
       "calls": "{count} çağrı | {count} çağrı",
-      "promptCompletionTokens": "Yeni (önbelleğe alınmamış) istem / tamamlama token'ları",
-      "cachedTokens": "({tokens} önbelleğe alındı)",
-      "cachedTokensHint": "Sağlayıcının önbelleğinden sunulan istem token'ları",
+      "inputCompletionTokens": "Toplam giriş / çıkış token'i. Giriş, önbelleğe alınmış token'ları da sayar: bunlar hâlâ bağlam penceresini kaplar, tıpkı Claude Code'un kendi bağlam göstergesinin saydığı gibi.",
+      "fresh": "{tokens} yeni",
+      "freshHint": "Önbellekten hiçbir şey sunulmadan sıfırdan işlenen giriş",
+      "cacheRead": "{tokens} önbellekten okundu",
+      "cacheReadHint": "Sağlayıcının önbelleğinden sunulan giriş token'ları (yeni girişin yaklaşık 0,1 katı fiyat)",
+      "cacheWrite": "{tokens} önbelleğe yazıldı",
+      "cacheWriteHint": "Sağlayıcının önbelleğine yazılan giriş token'ları (yeni girişin 1,25 ila 2 katı fiyat)",
       "errors": "{count} hata | {count} hata",
       "warnings": "{count} uyarı | {count} uyarı",
       "outputLimit": "Çıkış sınırı",
@@ -1384,7 +1394,7 @@
       "modelExecution": "Model yürütme"
     },
     "call": {
-      "tokensTitle": "{prompt} istem / {completion} tamamlama token'ı",
+      "tokensTitle": "{input} giriş token'i ({fresh} tanesi yeni) / {completion} çıkış token'i",
       "outputUsedVsLimit": "Kullanılan çıkış ile sınır",
       "transportVsExecution": "Taşıma yükü / model yürütme",
       "error": "hata",
@@ -1394,7 +1404,9 @@
       "streamed": "akışlı",
       "buffered": "ara belleğe alınmış",
       "maxTokens": "max_tokens {value}",
-      "promptCached": "{cached}/{prompt} istem önbelleğe alındı",
+      "fresh": "{tokens} yeni",
+      "cacheRead": "{tokens} önbellekten okundu",
+      "cacheWrite": "{tokens} önbelleğe yazıldı",
       "total": "toplam {duration}",
       "prompt": "İstem",
       "promptPrefixOmitted": "(yalnızca yeni mesajlar: {count} öncekisi atlandı)",

package/i18n/locales/uk.json

@@ -1368,13 +1368,23 @@
       "transportOverhead": "Накладні витрати транспорту",
       "modelExecution": "Виконання моделі",
       "truncated": "{count} обрізаний | {count} обрізані | {count} обрізаних",
-      "cached": "{tokens} з кешу"
+      "inputTokensHint": "Загальна кількість токенів входу / виходу. Вхід враховує й токени з кешу: вони так само займають вікно контексту, точно як їх рахує індикатор контексту в Claude Code.",
+      "fresh": "{tokens} нових",
+      "freshHint": "Вхід, оброблений з нуля, без жодної частини з кешу",
+      "cacheRead": "{tokens} прочитано з кешу",
+      "cacheReadHint": "Вхідні токени, надані з кешу провайдера (приблизно 0,1 ціни нових вхідних токенів)",
+      "cacheWrite": "{tokens} записано в кеш",
+      "cacheWriteHint": "Вхідні токени, записані в кеш провайдера (від 1,25 до 2 разів ціна нових вхідних токенів)"
     },
     "metricsBar": {
       "calls": "{count} виклик | {count} виклики | {count} викликів",
-      "promptCompletionTokens": "Нові (некешовані) токени запиту / завершення",
-      "cachedTokens": "({tokens} з кешу)",
-      "cachedTokensHint": "Токени запиту, надані з кешу провайдера",
+      "inputCompletionTokens": "Загальна кількість токенів входу / виходу. Вхід враховує й токени з кешу: вони так само займають вікно контексту, точно як їх рахує індикатор контексту в Claude Code.",
+      "fresh": "{tokens} нових",
+      "freshHint": "Вхід, оброблений з нуля, без жодної частини з кешу",
+      "cacheRead": "{tokens} прочитано з кешу",
+      "cacheReadHint": "Вхідні токени, надані з кешу провайдера (приблизно 0,1 ціни нових вхідних токенів)",
+      "cacheWrite": "{tokens} записано в кеш",
+      "cacheWriteHint": "Вхідні токени, записані в кеш провайдера (від 1,25 до 2 разів ціна нових вхідних токенів)",
       "errors": "{count} помилка | {count} помилки | {count} помилок",
       "warnings": "{count} попередження | {count} попередження | {count} попереджень",
       "outputLimit": "Ліміт виводу",
@@ -1384,7 +1394,7 @@
       "modelExecution": "Виконання моделі"
     },
     "call": {
-      "tokensTitle": "{prompt} токенів запиту / {completion} токенів завершення",
+      "tokensTitle": "{input} токенів входу (з них {fresh} нових) / {completion} токенів виходу",
       "outputUsedVsLimit": "Використано виводу проти ліміту",
       "transportVsExecution": "Накладні витрати транспорту / виконання моделі",
       "error": "помилка",
@@ -1394,7 +1404,9 @@
       "streamed": "потоково",
       "buffered": "буферизовано",
       "maxTokens": "max_tokens {value}",
-      "promptCached": "{cached}/{prompt} запиту з кешу",
+      "fresh": "{tokens} нових",
+      "cacheRead": "{tokens} прочитано з кешу",
+      "cacheWrite": "{tokens} записано в кеш",
       "total": "усього {duration}",
       "prompt": "Запит",
       "promptPrefixOmitted": "(лише нові повідомлення: {count} раніших пропущено)",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.168.0",
+  "version": "0.170.0",
   "description": "Reusable Nuxt layer for the Agent Architecture Board SPA (components, stores, composables, pages). Consume it from a thin deployment app via `extends: ['@cat-factory/app']` and point it at your backend with NUXT_PUBLIC_API_BASE. See deploy/frontend for an example.",
   "repository": {
     "type": "git",
@@ -40,7 +40,7 @@
     "valibot": "^1.4.2",
     "vue": "3.5.40",
     "wretch": "^3.0.9",
-    "@cat-factory/contracts": "0.181.0"
+    "@cat-factory/contracts": "0.182.0"
   },
   "devDependencies": {
     "@toad-contracts/testing": "0.3.2",