@cat-factory/app 0.178.2 → 0.179.0

package/app/components/panels/ObservabilityPanel.vue

@@ -8,7 +8,13 @@ import type {
   WebSearchProvider,
 } from '~/types/execution'
 import { agentKindMeta } from '~/utils/catalog'
-import { formatMs, formatTokens, pct, totalInputTokens } from '~/utils/observability'
+import {
+  foldRunPhaseMetrics,
+  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
@@ -151,6 +157,26 @@ const totals = computed(() => {
 function sum(items: LlmCallMetric[], pick: (m: LlmCallMetric) => number): number {
   return items.reduce((acc, m) => acc + pick(m), 0)
 }
+
+// Where the run's tokens went, by PHASE. Unlike the totals above (derived from the capped call
+// list), this reads the engine's SQL rollup off the steps, so it stays honest on a long run.
+const phaseRows = computed(() => foldRunPhaseMetrics(instance.value?.steps ?? []))
+const phaseCarryTotal = computed(() =>
+  phaseRows.value.reduce((acc, p) => acc + p.carryCostTokens, 0),
+)
+/** Share of the run's carry cost a phase accounts for (0..100), or null when nothing carried. */
+function carryShare(carryCostTokens: number): number | null {
+  return phaseCarryTotal.value > 0 ? pct(carryCostTokens / phaseCarryTotal.value) : null
+}
+/**
+ * The phase label as shown. The vocabulary belongs to the HARNESS — it is whatever its handlers
+ * pass to `onPhase`, so there is deliberately no closed union to translate against; a newer
+ * image's phase must render verbatim rather than disappear. The one label the platform owns is
+ * the empty string, which means "nothing could attribute this call" and needs saying in words.
+ */
+function phaseLabel(phase: string): string {
+  return phase || t('observability.phase.unattributed')
+}
 function isWarning(finishReason: string | null): boolean {
   return finishReason === 'length' || finishReason === 'content_filter'
 }
@@ -384,6 +410,84 @@ function exportJson() {
               </div>
             </section>
 
+            <!-- where the run's tokens went, by phase (the engine's SQL rollup, not the
+                 capped call list) -->
+            <section
+              v-if="phaseRows.length"
+              class="rounded-xl border border-slate-800 bg-slate-900/50 p-4"
+            >
+              <div class="flex items-baseline gap-2">
+                <h2 class="text-[11px] uppercase tracking-wide text-slate-500">
+                  {{ t('observability.phase.title') }}
+                </h2>
+                <span class="text-[11px] text-slate-600">
+                  {{ t('observability.phase.subtitle') }}
+                </span>
+              </div>
+              <div class="mt-3 overflow-x-auto">
+                <table class="w-full min-w-[32rem] text-[12px]">
+                  <thead>
+                    <tr class="text-[11px] uppercase tracking-wide text-slate-500">
+                      <th class="py-1 pe-3 text-start font-normal">
+                        {{ t('observability.phase.columns.phase') }}
+                      </th>
+                      <th class="py-1 px-3 text-end font-normal">
+                        {{ t('observability.phase.columns.turns') }}
+                      </th>
+                      <th class="py-1 px-3 text-end font-normal">
+                        {{ t('observability.phase.columns.tokensInOut') }}
+                      </th>
+                      <!-- The sort key, MARKED as one. Rows lead with carry cost rather than
+                           with tokens, and the two orders genuinely differ: a phase that runs
+                           late carries almost nothing however much it spent (nothing after it
+                           re-sends its context). Leaving that implicit invites reading row 1
+                           as "the phase that burned the most", which is the neighbouring
+                           column. -->
+                      <th aria-sort="descending" class="py-1 ps-3 text-end font-normal">
+                        <span :title="t('observability.phase.carryCostHint')">
+                          {{ t('observability.phase.columns.carryCost') }} ↓
+                        </span>
+                      </th>
+                    </tr>
+                  </thead>
+                  <tbody>
+                    <tr v-for="p in phaseRows" :key="p.phase" class="border-t border-slate-800/70">
+                      <td class="py-1.5 pe-3 text-slate-200">
+                        <span :class="p.phase ? '' : 'text-slate-400 italic'">
+                          {{ phaseLabel(p.phase) }}
+                        </span>
+                        <span v-if="!p.phase" class="ms-1.5 text-[11px] text-slate-600">
+                          {{ t('observability.phase.unattributedHint') }}
+                        </span>
+                        <UBadge
+                          v-if="p.errors"
+                          color="error"
+                          variant="subtle"
+                          size="sm"
+                          class="ms-2"
+                        >
+                          {{ t('observability.metricsBar.errors', { count: p.errors }, p.errors) }}
+                        </UBadge>
+                      </td>
+                      <td class="py-1.5 px-3 text-end tabular-nums text-slate-300">
+                        {{ p.calls }}
+                      </td>
+                      <td class="py-1.5 px-3 text-end tabular-nums text-slate-300">
+                        {{ formatTokens(totalInputTokens(p)) }}↑
+                        {{ formatTokens(p.completionTokens) }}↓
+                      </td>
+                      <td class="py-1.5 ps-3 text-end tabular-nums text-slate-300">
+                        {{ formatTokens(p.carryCostTokens) }}
+                        <span v-if="carryShare(p.carryCostTokens) !== null" class="text-slate-600">
+                          · {{ carryShare(p.carryCostTokens) }}%
+                        </span>
+                      </td>
+                    </tr>
+                  </tbody>
+                </table>
+              </div>
+            </section>
+
             <!-- states -->
             <p
               v-if="loading && !calls.length"

package/app/types/execution.ts

@@ -21,6 +21,7 @@ export type {
   PriorStepOutput,
   StepApproval,
   StepMetrics,
+  StepPhaseMetrics,
   LlmCallMetric,
   LlmCallActivity,
   LlmExportInsight,

package/app/utils/observability.spec.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect } from 'vitest'
-import { totalInputTokens } from './observability'
+import type { PipelineStep, StepPhaseMetrics } from '~/types/execution'
+import { foldRunPhaseMetrics, totalInputTokens } from './observability'
 
 describe('totalInputTokens', () => {
   it('sums all three input classes, so the headline matches Claude Code’s context gauge', () => {
@@ -26,3 +27,61 @@ describe('totalInputTokens', () => {
     expect(totalInputTokens({ promptTokens: 500 })).toBe(500)
   })
 })
+
+describe('foldRunPhaseMetrics', () => {
+  const phase = (over: Partial<StepPhaseMetrics> & Pick<StepPhaseMetrics, 'phase'>) => ({
+    calls: 1,
+    promptTokens: 10,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    completionTokens: 5,
+    carryCostTokens: 0,
+    errors: 0,
+    ...over,
+  })
+  const step = (agentKind: string, byPhase: StepPhaseMetrics[]) =>
+    ({ agentKind, metrics: { byPhase } }) as unknown as PipelineStep
+
+  it('does NOT double-count two steps that share an agent kind', () => {
+    // A step's rollup covers its agent KIND across the whole run (the proxy keys a conversation
+    // by `(execution, agentKind)`), so two tester steps carry identical numbers. Summing them
+    // would report twice the tokens the run actually spent.
+    const rows = [phase({ phase: 'agent', calls: 3, carryCostTokens: 90 })]
+    const folded = foldRunPhaseMetrics([step('tester', rows), step('tester', rows)])
+    expect(folded).toHaveLength(1)
+    expect(folded[0]).toMatchObject({ phase: 'agent', calls: 3, carryCostTokens: 90 })
+  })
+
+  it('merges a phase across different agent kinds and sorts costliest first', () => {
+    const folded = foldRunPhaseMetrics([
+      step('coder', [
+        phase({ phase: 'agent', calls: 2, carryCostTokens: 10 }),
+        phase({ phase: 'validation-repair', calls: 1, carryCostTokens: 500 }),
+      ]),
+      step('reviewer', [phase({ phase: 'agent', calls: 4, carryCostTokens: 40 })]),
+    ])
+    expect(folded.map((p) => [p.phase, p.calls, p.carryCostTokens])).toEqual([
+      ['validation-repair', 1, 500],
+      ['agent', 6, 50],
+    ])
+  })
+
+  it("keeps the unattributed '' phase rather than hiding it", () => {
+    const folded = foldRunPhaseMetrics([step('coder', [phase({ phase: '', calls: 7 })])])
+    expect(folded.map((p) => p.phase)).toEqual([''])
+  })
+
+  it('is empty when no step carries a rollup, so the section simply does not render', () => {
+    expect(foldRunPhaseMetrics([{ agentKind: 'coder' } as unknown as PipelineStep])).toEqual([])
+  })
+
+  it('returns fresh rows rather than aliasing the store objects it folded', () => {
+    // The single-kind case is the one that used to pass a `step.metrics.byPhase` row straight
+    // through: a caller mutating what a fold handed it would have written into the store.
+    const row = phase({ phase: 'agent', calls: 3, carryCostTokens: 90 })
+    const folded = foldRunPhaseMetrics([step('coder', [row])])
+    expect(folded[0]).not.toBe(row)
+    folded[0]!.calls = 999
+    expect(row.calls).toBe(3)
+  })
+})

package/app/utils/observability.ts

@@ -2,7 +2,7 @@
 // rollups + the drill-down panel). Kept here so the components stay declarative and
 // the number-crunching is unit-testable.
 
-import type { StepMetrics } from '~/types/execution'
+import type { PipelineStep, StepMetrics, StepPhaseMetrics } from '~/types/execution'
 
 /** Compact token count: 1234 → "1.2k", 980 → "980", 2_500_000 → "2.5M". */
 export function formatTokens(n: number): string {
@@ -69,6 +69,61 @@ export function transportRatio(m: Pick<StepMetrics, 'upstreamMs' | 'overheadMs'>
   return total > 0 ? m.overheadMs / total : null
 }
 
+/** Zero cell, so the fold below has one accumulator shape and never aliases a store row. */
+const EMPTY_PHASE: Omit<StepPhaseMetrics, 'phase'> = {
+  calls: 0,
+  promptTokens: 0,
+  cacheReadTokens: 0,
+  cacheWriteTokens: 0,
+  completionTokens: 0,
+  carryCostTokens: 0,
+  errors: 0,
+}
+
+/**
+ * The run's model spend split by the PHASE that spent it, folded from the per-step rollups the
+ * engine already pushes. Rows come back costliest-carry-cost first — the slice worth attacking.
+ *
+ * Two things make this correct rather than a naive sum over `steps`:
+ *
+ * 1. **Deduplicate by agent kind.** A step's `metrics` is the rollup for its AGENT KIND across
+ *    the whole run (the proxy keys a conversation by `(execution, agentKind)`, not by step
+ *    index), so two steps of the same kind carry the SAME numbers. Adding them would double
+ *    every figure on any pipeline with, say, two tester steps.
+ * 2. **Read it off the rollup, not off the loaded calls.** The panel's call list is capped, so
+ *    folding phases client-side from it would silently under-report exactly the long runs this
+ *    breakdown exists for. The rollup is a SQL aggregate over every row.
+ *
+ * Every returned row is a FRESH object, never a row of `step.metrics.byPhase` passed through:
+ * those belong to the store, and a fold whose output aliases its input is a trap for the next
+ * caller that reasonably assumes it may mutate what a fold handed it.
+ */
+export function foldRunPhaseMetrics(steps: readonly PipelineStep[]): StepPhaseMetrics[] {
+  const seenKinds = new Set<string>()
+  const byPhase = new Map<string, StepPhaseMetrics>()
+  for (const step of steps) {
+    const rows = step.metrics?.byPhase
+    if (!rows?.length || seenKinds.has(step.agentKind)) continue
+    seenKinds.add(step.agentKind)
+    for (const row of rows) {
+      const prev = byPhase.get(row.phase) ?? EMPTY_PHASE
+      byPhase.set(row.phase, {
+        phase: row.phase,
+        calls: prev.calls + row.calls,
+        promptTokens: prev.promptTokens + row.promptTokens,
+        cacheReadTokens: prev.cacheReadTokens + row.cacheReadTokens,
+        cacheWriteTokens: prev.cacheWriteTokens + row.cacheWriteTokens,
+        completionTokens: prev.completionTokens + row.completionTokens,
+        carryCostTokens: prev.carryCostTokens + row.carryCostTokens,
+        errors: prev.errors + row.errors,
+      })
+    }
+  }
+  return [...byPhase.values()].sort(
+    (a, b) => b.carryCostTokens - a.carryCostTokens || b.calls - a.calls,
+  )
+}
+
 /** Tailwind text/bg colour for an output-headroom level (green → amber → red). */
 export function headroomColor(ratio: number | null, truncated: boolean): string {
   if (truncated || (ratio != null && ratio >= 0.98)) return 'text-rose-400'

package/i18n/locales/de.json

@@ -3010,6 +3010,19 @@
       "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)"
     },
+    "phase": {
+      "title": "Wohin die Tokens geflossen sind",
+      "subtitle": "nach Phase des Laufs, sortiert nach Mitschleppkosten",
+      "columns": {
+        "phase": "Phase",
+        "turns": "Runden",
+        "tokensInOut": "Tokens (ein / aus)",
+        "carryCost": "Mitschleppkosten"
+      },
+      "carryCostHint": "Wie stark jede Phase die nachfolgenden Runden belastet hat: ihr Kontext einmal für jede spätere Runde gezählt, die ihn erneut senden musste. Vergleichen Sie die Phasen eines Laufs miteinander; für sich allein sagt die Zahl nichts aus. Eine spät laufende Phase schleppt wenig mit, wie viel sie auch verbraucht hat; lesen Sie diese Spalte daher zusammen mit den Tokens daneben.",
+      "unattributed": "Nicht zugeordnet",
+      "unattributedHint": "von einem Kanal erfasst, der keine Phase meldet"
+    },
     "metricsBar": {
       "calls": "{count} Aufruf | {count} Aufrufe",
       "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.",

package/i18n/locales/en.json

@@ -1474,6 +1474,19 @@
       "cacheWrite": "{tokens} cache write",
       "cacheWriteHint": "Input tokens written into the provider's cache (1.25x to 2x the price of fresh input)"
     },
+    "phase": {
+      "title": "Where the tokens went",
+      "subtitle": "by phase of the run, ordered by carry cost",
+      "columns": {
+        "phase": "Phase",
+        "turns": "Turns",
+        "tokensInOut": "Tokens (in / out)",
+        "carryCost": "Carry cost"
+      },
+      "carryCostHint": "How much each phase burdened the turns that came after it: its context counted once for every later turn that had to re-send it. Compare a run's phases with each other; on its own the number means nothing. A phase that runs late carries little however much it spent, so read this column alongside the tokens beside it.",
+      "unattributed": "Unattributed",
+      "unattributedHint": "recorded by a channel that reports no phase"
+    },
     "metricsBar": {
       "calls": "{count} call | {count} calls",
       "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.",

package/i18n/locales/es.json

@@ -1408,6 +1408,19 @@
       "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)"
     },
+    "phase": {
+      "title": "Adónde fueron los tokens",
+      "subtitle": "por fase de la ejecución, ordenado por coste de arrastre",
+      "columns": {
+        "phase": "Fase",
+        "turns": "Turnos",
+        "tokensInOut": "Tokens (entrada / salida)",
+        "carryCost": "Coste de arrastre"
+      },
+      "carryCostHint": "Cuánto cargó cada fase sobre los turnos posteriores: su contexto contado una vez por cada turno que tuvo que reenviarlo. Compara entre sí las fases de una ejecución; por sí sola la cifra no significa nada. Una fase que se ejecuta al final arrastra poco por mucho que haya gastado, así que lee esta columna junto a los tokens de al lado.",
+      "unattributed": "Sin atribuir",
+      "unattributedHint": "registrado por un canal que no informa de la fase"
+    },
     "metricsBar": {
       "calls": "{count} llamada | {count} llamadas",
       "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.",

package/i18n/locales/fr.json

@@ -1408,6 +1408,19 @@
       "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)"
     },
+    "phase": {
+      "title": "Où sont passés les tokens",
+      "subtitle": "par phase de l'exécution, trié par coût de report",
+      "columns": {
+        "phase": "Phase",
+        "turns": "Tours",
+        "tokensInOut": "Tokens (entrée / sortie)",
+        "carryCost": "Coût de report"
+      },
+      "carryCostHint": "Ce que chaque phase a fait peser sur les tours suivants : son contexte compté une fois pour chaque tour ultérieur ayant dû le renvoyer. Comparez les phases d'une exécution entre elles ; isolée, la valeur ne signifie rien. Une phase qui s'exécute en dernier reporte peu, quoi qu'elle ait dépensé : lisez donc cette colonne avec les tokens voisins.",
+      "unattributed": "Non attribué",
+      "unattributedHint": "enregistré par un canal qui ne rapporte aucune phase"
+    },
     "metricsBar": {
       "calls": "{count} appel | {count} appels",
       "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.",

package/i18n/locales/he.json

@@ -1408,6 +1408,19 @@
       "cacheWrite": "{tokens} נכתבו למטמון",
       "cacheWriteHint": "טוקני קלט שנכתבו למטמון הספק (פי 1.25 עד 2 ממחיר קלט חדש)"
     },
+    "phase": {
+      "title": "לאן הלכו הטוקנים",
+      "subtitle": "לפי שלב בהרצה, ממוין לפי עלות גרירה",
+      "columns": {
+        "phase": "שלב",
+        "turns": "תורים",
+        "tokensInOut": "טוקנים (נכנס / יוצא)",
+        "carryCost": "עלות גרירה"
+      },
+      "carryCostHint": "כמה כל שלב העמיס על התורים שבאו אחריו: ההקשר שלו נספר פעם אחת עבור כל תור מאוחר יותר שנאלץ לשלוח אותו שוב. השוו בין שלבי ההרצה זה לזה; בפני עצמו המספר אינו אומר דבר. שלב שרץ בסוף גורר מעט גם אם צרך הרבה, ולכן קראו את העמודה הזאת יחד עם הטוקנים שלצדה.",
+      "unattributed": "ללא שיוך",
+      "unattributedHint": "נרשם על ידי ערוץ שאינו מדווח על שלב"
+    },
     "metricsBar": {
       "calls": "{count} קריאה | {count} קריאות",
       "inputCompletionTokens": "סך טוקני הקלט / הפלט. הקלט סופר גם טוקנים מהמטמון: הם עדיין תופסים את חלון ההקשר, בדיוק כפי שמד ההקשר של Claude Code סופר אותם.",

package/i18n/locales/it.json

@@ -3010,6 +3010,19 @@
       "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)"
     },
+    "phase": {
+      "title": "Dove sono finiti i token",
+      "subtitle": "per fase dell'esecuzione, ordinato per costo di trascinamento",
+      "columns": {
+        "phase": "Fase",
+        "turns": "Turni",
+        "tokensInOut": "Token (in / out)",
+        "carryCost": "Costo di trascinamento"
+      },
+      "carryCostHint": "Quanto ogni fase ha gravato sui turni successivi: il suo contesto contato una volta per ogni turno che ha dovuto rinviarlo. Confronta tra loro le fasi di un'esecuzione; da solo il numero non significa nulla. Una fase che viene eseguita per ultima trascina poco per quanto abbia speso, quindi leggi questa colonna insieme ai token accanto.",
+      "unattributed": "Non attribuito",
+      "unattributedHint": "registrato da un canale che non riporta la fase"
+    },
     "metricsBar": {
       "calls": "{count} chiamata | {count} chiamate",
       "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.",

package/i18n/locales/ja.json

@@ -1408,6 +1408,19 @@
       "cacheWrite": "{tokens} キャッシュ書き込み",
       "cacheWriteHint": "プロバイダーのキャッシュに書き込まれた入力トークン (新規入力の 1.25 倍から 2 倍の価格)"
     },
+    "phase": {
+      "title": "トークンの使われ先",
+      "subtitle": "実行のフェーズ別、持ち越しコスト順",
+      "columns": {
+        "phase": "フェーズ",
+        "turns": "ターン数",
+        "tokensInOut": "トークン (入力 / 出力)",
+        "carryCost": "持ち越しコスト"
+      },
+      "carryCostHint": "各フェーズが後続のターンにどれだけ負担をかけたか。そのコンテキストを、再送が必要になった後続ターンの数だけ数えた値です。1 回の実行内でフェーズ同士を比較してください。単独の数値には意味がありません。最後に実行されるフェーズは、どれだけ消費しても持ち越しはわずかです。この列は隣のトークン数と併せて読んでください。",
+      "unattributed": "未特定",
+      "unattributedHint": "フェーズを報告しないチャネルで記録"
+    },
     "metricsBar": {
       "calls": "{count} 件の呼び出し | {count} 件の呼び出し",
       "inputCompletionTokens": "入力 / 出力トークンの合計。入力にはキャッシュされたトークンも含まれます。それらも依然としてコンテキストウィンドウを占有するため、Claude Code のコンテキスト表示と同じ数え方です。",

package/i18n/locales/pl.json

@@ -1408,6 +1408,19 @@
       "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)"
     },
+    "phase": {
+      "title": "Na co poszły tokeny",
+      "subtitle": "według fazy przebiegu, posortowane według kosztu przenoszenia",
+      "columns": {
+        "phase": "Faza",
+        "turns": "Tury",
+        "tokensInOut": "Tokeny (we / wy)",
+        "carryCost": "Koszt przenoszenia"
+      },
+      "carryCostHint": "Jak bardzo każda faza obciążyła kolejne tury: jej kontekst policzony raz za każdą późniejszą turę, która musiała go wysłać ponownie. Porównuj fazy jednego przebiegu ze sobą; sama liczba nic nie znaczy. Faza wykonywana na końcu przenosi niewiele, choć by zużyła dużo, dlatego czytaj tę kolumnę razem z tokenami obok.",
+      "unattributed": "Bez przypisania",
+      "unattributedHint": "zarejestrowane przez kanał, który nie podaje fazy"
+    },
     "metricsBar": {
       "calls": "{count} wywołanie | {count} wywołania | {count} wywołań",
       "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.",

package/i18n/locales/tr.json

@@ -1408,6 +1408,19 @@
       "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)"
     },
+    "phase": {
+      "title": "Token'lar nereye gitti",
+      "subtitle": "çalıştırmanın aşamasına göre, taşıma maliyetine göre sıralanır",
+      "columns": {
+        "phase": "Aşama",
+        "turns": "Tur",
+        "tokensInOut": "Token (giriş / çıkış)",
+        "carryCost": "Taşıma maliyeti"
+      },
+      "carryCostHint": "Her aşamanın kendisinden sonraki turlara ne kadar yük bindirdiği: bağlamı, onu yeniden göndermek zorunda kalan her sonraki tur için bir kez sayılır. Bir çalıştırmanın aşamalarını birbiriyle karşılaştırın; tek başına bu sayı bir şey ifade etmez. En sonda çalışan bir aşama ne kadar harcarsa harcasın az taşır; bu sütunu yanındaki token sayılarıyla birlikte okuyun.",
+      "unattributed": "Atanmamış",
+      "unattributedHint": "aşama bildirmeyen bir kanal tarafından kaydedildi"
+    },
     "metricsBar": {
       "calls": "{count} çağrı | {count} çağrı",
       "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.",

package/i18n/locales/uk.json

@@ -1408,6 +1408,19 @@
       "cacheWrite": "{tokens} записано в кеш",
       "cacheWriteHint": "Вхідні токени, записані в кеш провайдера (від 1,25 до 2 разів ціна нових вхідних токенів)"
     },
+    "phase": {
+      "title": "Куди пішли токени",
+      "subtitle": "за фазою запуску, упорядковано за вартістю перенесення",
+      "columns": {
+        "phase": "Фаза",
+        "turns": "Ходи",
+        "tokensInOut": "Токени (вхід / вихід)",
+        "carryCost": "Вартість перенесення"
+      },
+      "carryCostHint": "Наскільки кожна фаза обтяжила наступні ходи: її контекст пораховано один раз за кожен пізніший хід, який мусив надіслати його знову. Порівнюйте фази одного запуску між собою; сама по собі ця величина нічого не означає. Фаза, що виконується останньою, переносить мало, скільки б не витратила, тож читайте цей стовпець разом із токенами поруч.",
+      "unattributed": "Без атрибуції",
+      "unattributedHint": "записано каналом, який не повідомляє фазу"
+    },
     "metricsBar": {
       "calls": "{count} виклик | {count} виклики | {count} викликів",
       "inputCompletionTokens": "Загальна кількість токенів входу / виходу. Вхід враховує й токени з кешу: вони так само займають вікно контексту, точно як їх рахує індикатор контексту в Claude Code.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.178.2",
+  "version": "0.179.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.188.0"
+    "@cat-factory/contracts": "0.189.0"
   },
   "devDependencies": {
     "@toad-contracts/testing": "0.3.2",