@cat-factory/app 0.178.2 → 0.180.0

package/app/components/initiative/InitiativePlanningWindow.vue

@@ -10,16 +10,25 @@
 // (`ui.openInitiativePlanning`) or as the interviewer step's result view. Live `initiative`
 // stream events patch the store, so an open window follows the interview as it progresses.
 //
+// An interview runs over MULTIPLE ROUNDS and the entity keeps the settled ones, so the list is a
+// mix of what the human still owes an answer and what they already dealt with. It renders pending
+// first (`orderInterviewQuestions`) — see the `order` snapshot below for why that is recomputed per
+// round rather than live.
+//
 // CONTINUE/PROCEED ARE ASYNC. They only record the intent on the parked step and wake the durable
 // driver; the interviewer LLM then runs for as long as it takes, and the response carries the
 // PRE-resume entity. So the window must not key its body on the entity alone — that renders
 // identically before and after the click, which reads as the button having done nothing. The
 // phase below folds the planning RUN's status in, so the wait is visible and a failed pass says
 // so instead of leaving the human staring at questions they already submitted.
-import { computed, reactive, watch } from 'vue'
+import { computed, reactive, ref, watch } from 'vue'
 import ClarificationItem from '~/components/common/ClarificationItem.vue'
 import InterviewGateNotice from '~/components/common/InterviewGateNotice.vue'
-import { INITIATIVE_STATUS_LABEL_KEYS } from '~/utils/initiative'
+import {
+  INITIATIVE_STATUS_LABEL_KEYS,
+  isPendingQuestion,
+  orderInterviewQuestions,
+} from '~/utils/initiative'
 import { interviewGatePhase } from '~/utils/interviewGate'
 import ResultWindowShell from '~/components/panels/ResultWindowShell.vue'
 
@@ -41,9 +50,7 @@ const questions = computed(() =>
   (initiative.value?.qa ?? []).map((q, i) => ({ ...q, key: q.id ?? `q-${i}` })),
 )
 /** Questions still needing an answer: not dismissed, and not yet answered (mirrors backend). */
-const pending = computed(() =>
-  questions.value.filter((q) => q.status !== 'dismissed' && !(q.answer ?? '').trim()),
-)
+const pending = computed(() => questions.value.filter(isPendingQuestion))
 
 // Per-question answer drafts, seeded from the entity and refreshed as new rounds arrive
 // without clobbering an answer the human is mid-edit on.
@@ -58,6 +65,28 @@ watch(
   { immediate: true },
 )
 
+/**
+ * Render order (pending first — see `orderInterviewQuestions`), re-snapshotted ONLY when the
+ * question SET changes, i.e. when a round lands. Deriving it live from the answers instead would
+ * yank a question out from under the human the moment they blurred its textarea and shuffle
+ * everything below it up, while they are reading down the list. Re-snapshotting per ROUND rather
+ * than per question is what keeps a window left open across rounds correct: a question answered in
+ * round one has to sink below round two's new ones, which a rank frozen at first sight never would.
+ */
+const order = ref<string[]>([])
+watch(
+  () => questions.value.map((q) => q.key).join('|'),
+  () => {
+    order.value = orderInterviewQuestions(questions.value).map((q) => q.key)
+  },
+  { immediate: true },
+)
+const orderedQuestions = computed(() => {
+  const rank = new Map(order.value.map((key, i) => [key, i]))
+  // A question the snapshot has not seen is by definition new, so it is pending and sorts first.
+  return [...questions.value].sort((a, b) => (rank.get(a.key) ?? -1) - (rank.get(b.key) ?? -1))
+})
+
 const resuming = computed(() => initiatives.resuming)
 
 /**
@@ -221,7 +250,7 @@ async function onDiscard() {
         <!-- Interview questions — the shared clarification surface (answer / not-relevant /
                  recommend), reused with the requirements-review window. -->
         <ul v-else class="space-y-4">
-          <li v-for="q in questions" :key="q.key" data-testid="initiative-planning-question">
+          <li v-for="q in orderedQuestions" :key="q.key" data-testid="initiative-planning-question">
             <ClarificationItem
               v-model:answer="drafts[q.key]"
               :prompt="q.question"

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/components/tasks/BugHuntModal.vue

@@ -10,6 +10,13 @@
 // unavailable or failed still shows its candidates (flagged as unassessed, since the scan is
 // useful on its own), and a scan that hit its cap says so — a silently shortened list reads
 // exactly like an exhaustive one.
+//
+// The tracker selector doubles as the "add a tracker" affordance (the same two-tier menu
+// `<ContextIssuePicker>` renders, off the shared `buildSourceChoices`): a hunt is a common
+// place to find out the tracker holding the bugs isn't connected here yet, and the answer
+// has to be a route to that tracker's own connect screen rather than "go find the
+// Integrations hub". The connect modal opens OVER the hunt, so nothing typed here is lost.
+import type { DropdownMenuItem } from '@nuxt/ui'
 import type { TaskSourceReadReason } from '@cat-factory/contracts'
 import type {
   BugHuntAnalysisStatus,
@@ -17,6 +24,7 @@ import type {
   BugHuntConfidence,
   TaskSourceKind,
 } from '~/types/domain'
+import { type SourceChoice, buildSourceChoices, reconcileSource } from '~/utils/taskSources'
 import IntegrationBackTitle from '~/components/layout/IntegrationBackTitle.vue'
 
 const { t, d, n } = useI18n()
@@ -54,8 +62,64 @@ const containerItems = computed(() =>
     })),
 )
 
-const sourceItems = computed(() =>
-  tasks.offeredSources.map((s) => ({ label: s.label, value: s.source })),
+const descriptor = computed(() => (source.value ? tasks.descriptorFor(source.value) : undefined))
+
+// Two-tier tracker menu: pick one the workspace already offers, or add one it doesn't.
+const sourceChoices = computed(() => buildSourceChoices(tasks.sources, source.value))
+const sourceMenu = computed<DropdownMenuItem[][]>(() =>
+  sourceChoices.value.map((group) =>
+    group.map((choice) =>
+      choice.action === 'select'
+        ? {
+            label: choice.label,
+            icon: choice.icon,
+            trailingIcon: choice.active ? 'i-lucide-check' : undefined,
+            onSelect: () => {
+              source.value = choice.source
+            },
+          }
+        : {
+            label: addLabel(choice),
+            icon: 'i-lucide-plug',
+            onSelect: () => addSource(choice.source),
+          },
+    ),
+  ),
+)
+
+/** The trackers that can be added — the empty state's buttons, where none is offered yet. */
+const addableSources = computed(() =>
+  sourceChoices.value.flat().filter((c) => c.action !== 'select'),
+)
+
+/**
+ * Wording for an addable tracker: `enable` is connected but toggled off for this workspace,
+ * so the user is never told to "connect" something they already connected.
+ */
+function addLabel(choice: SourceChoice): string {
+  return choice.action === 'enable'
+    ? t('bugHunt.enableSource', { label: choice.label })
+    : t('bugHunt.connectSource', { label: choice.label })
+}
+
+/**
+ * The tracker the user left to add, so it becomes the selection the moment it turns up
+ * offered (the connect modal re-probes on success and this hunt stays open underneath it).
+ * Also the reconcile trigger for a source that STOPS being offered — disconnected, or
+ * toggled off in settings while the hunt sat open.
+ */
+const awaitingConnect = ref<TaskSourceKind | null>(null)
+function addSource(s: TaskSourceKind) {
+  awaitingConnect.value = s
+  ui.openTaskConnect(s)
+}
+watch(
+  () => tasks.offeredSources.map((s) => s.source),
+  (offered) => {
+    const next = reconcileSource(offered, source.value, awaitingConnect.value)
+    if (next && next === awaitingConnect.value) awaitingConnect.value = null
+    if (next !== source.value) source.value = next
+  },
 )
 
 const boardItems = computed(() =>
@@ -100,6 +164,7 @@ watch(open, (isOpen) => {
   boardId.value = ''
   issueType.value = ''
   labels.value = ''
+  awaitingConnect.value = null
   source.value = ui.bugHunt?.source ?? tasks.offeredSources[0]?.source ?? undefined
   containerId.value = ui.bugHunt?.containerId ?? containerItems.value[0]?.value
   if (source.value) hunt.loadBoards(source.value)
@@ -193,16 +258,16 @@ const STATUS_KEYS: Record<BugHuntAnalysisStatus, string> = {
       <div v-if="!tasks.anyOffered" class="space-y-3 text-center">
         <UIcon name="i-lucide-plug" class="mx-auto h-8 w-8 text-slate-500" />
         <p class="text-sm text-slate-400">{{ t('bugHunt.connectFirst') }}</p>
-        <div class="flex justify-center gap-2">
+        <div class="flex flex-wrap justify-center gap-2">
           <UButton
-            v-for="s in tasks.sources"
-            :key="s.source"
+            v-for="choice in addableSources"
+            :key="choice.source"
             color="primary"
             variant="soft"
-            :icon="s.icon"
-            @click="ui.openTaskConnect(s.source)"
+            :icon="choice.icon"
+            @click="addSource(choice.source)"
           >
-            {{ t('bugHunt.connectSource', { label: s.label }) }}
+            {{ addLabel(choice) }}
           </UButton>
         </div>
       </div>
@@ -217,7 +282,24 @@ const STATUS_KEYS: Record<BugHuntAnalysisStatus, string> = {
 
         <div class="grid gap-3 sm:grid-cols-2">
           <UFormField :label="t('bugHunt.tracker')">
-            <USelect v-model="source" :items="sourceItems" class="w-full" />
+            <!-- The selector is also the way to ADD a tracker: each entry in the second group
+                 opens that tracker's own connect screen over this modal, so the hunt (and
+                 anything typed into it) is still here when the user comes back. -->
+            <UDropdownMenu
+              :items="sourceMenu"
+              :content="{ side: 'bottom', align: 'start' }"
+              class="w-full"
+            >
+              <UButton
+                color="neutral"
+                variant="soft"
+                :icon="descriptor?.icon"
+                trailing-icon="i-lucide-chevron-down"
+                class="w-full justify-between"
+              >
+                <span class="truncate">{{ descriptor?.label ?? t('bugHunt.pickTracker') }}</span>
+              </UButton>
+            </UDropdownMenu>
           </UFormField>
 
           <UFormField :label="t('bugHunt.board')">

package/app/components/tasks/ContextIssuePicker.vue

@@ -21,7 +21,7 @@ import type { TaskSourceReadReason } from '@cat-factory/contracts'
 import type { SourceTask, TaskSearchResult, TaskSourceKind } from '~/types/domain'
 import { apiErrorReason } from '~/composables/api/errors'
 import EmptyState from '~/components/common/EmptyState.vue'
-import { buildSourceChoices, reconcileSource } from '~/components/tasks/ContextIssuePicker.logic'
+import { buildSourceChoices, reconcileSource } from '~/utils/taskSources'
 
 const props = defineProps<{
   /** contextKeys already staged by the caller, so they're filtered out / not re-offered. */

package/app/types/execution.ts

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

package/app/utils/initiative.spec.ts

@@ -1,7 +1,7 @@
 import { INITIATIVE_ITEM_TERMINAL_STATUSES } from '@cat-factory/contracts'
 import { describe, it, expect } from 'vitest'
-import type { InitiativeItem, InitiativePhase } from '~/types/domain'
-import { pendingCheckpointPhase } from './initiative'
+import type { InitiativeItem, InitiativePhase, InitiativeQa } from '~/types/domain'
+import { isPendingQuestion, orderInterviewQuestions, pendingCheckpointPhase } from './initiative'
 
 // `pendingCheckpointPhase` mirrors the backend `pendingCheckpoint` (orchestration
 // `initiative.logic.ts`); these pin the same ordering/edge cases the loop pauses on, so the
@@ -71,3 +71,82 @@ describe('pendingCheckpointPhase', () => {
     expect(pendingCheckpointPhase(phases, [item('a', 'p1', status)])?.id).toBe('p1')
   })
 })
+
+// `isPendingQuestion` mirrors the backend rule of the same name (orchestration
+// `initiative.logic.ts`); `orderInterviewQuestions` is what the planning window renders by, so a
+// multi-round interview puts what the human still owes an answer above what they already settled.
+
+const qa = (over: Partial<InitiativeQa> & { id: string }): InitiativeQa => ({
+  question: over.id,
+  answer: '',
+  status: 'open',
+  ...over,
+})
+
+describe('isPendingQuestion', () => {
+  it('is pending while unanswered and not dismissed', () => {
+    expect(isPendingQuestion(qa({ id: 'a' }))).toBe(true)
+  })
+
+  it('is settled once answered', () => {
+    expect(isPendingQuestion(qa({ id: 'a', answer: 'yes' }))).toBe(false)
+  })
+
+  it('treats a whitespace-only answer as unanswered', () => {
+    expect(isPendingQuestion(qa({ id: 'a', answer: '   \n' }))).toBe(true)
+  })
+
+  it('is settled once dismissed, answered or not', () => {
+    expect(isPendingQuestion(qa({ id: 'a', status: 'dismissed' }))).toBe(false)
+  })
+
+  it('treats an absent answer/status (a hand-authored exchange) as pending', () => {
+    expect(isPendingQuestion({})).toBe(true)
+  })
+})
+
+describe('orderInterviewQuestions', () => {
+  const ids = (list: InitiativeQa[]) => orderInterviewQuestions(list).map((q) => q.id)
+
+  it('floats a later round of unanswered questions above the settled digest', () => {
+    // The shape the backend's `[...retainedQa, ...pending]` append produces on round two.
+    const list = [
+      qa({ id: 'r1-answered', answer: 'yes' }),
+      qa({ id: 'r1-dismissed', status: 'dismissed' }),
+      qa({ id: 'r2-a' }),
+      qa({ id: 'r2-b' }),
+    ]
+    expect(ids(list)).toEqual(['r2-a', 'r2-b', 'r1-answered', 'r1-dismissed'])
+  })
+
+  it('keeps chronological order within each group', () => {
+    const list = [
+      qa({ id: 'p1' }),
+      qa({ id: 's1', answer: 'yes' }),
+      qa({ id: 'p2' }),
+      qa({ id: 's2', status: 'dismissed' }),
+      qa({ id: 'p3' }),
+    ]
+    expect(ids(list)).toEqual(['p1', 'p2', 'p3', 's1', 's2'])
+  })
+
+  it('leaves a first round (all pending) exactly as the interviewer asked it', () => {
+    const list = [qa({ id: 'a' }), qa({ id: 'b' }), qa({ id: 'c' })]
+    expect(ids(list)).toEqual(['a', 'b', 'c'])
+  })
+
+  it('leaves a fully settled interview in its digest order', () => {
+    const list = [qa({ id: 'a', answer: 'x' }), qa({ id: 'b', status: 'dismissed' })]
+    expect(ids(list)).toEqual(['a', 'b'])
+  })
+
+  it('does not mutate the stored order (the interviewer prompt + tracker digest read it)', () => {
+    const list = [qa({ id: 'answered', answer: 'x' }), qa({ id: 'pending' })]
+    orderInterviewQuestions(list)
+    expect(list.map((q) => q.id)).toEqual(['answered', 'pending'])
+  })
+
+  it('handles an empty interview', () => {
+    expect(orderInterviewQuestions([])).toEqual([])
+  })
+})

package/app/utils/initiative.ts

@@ -6,6 +6,7 @@ import type {
   InitiativePhase,
   InitiativePresetDescriptor,
   InitiativePresetInputs,
+  InitiativeQa,
   InitiativeStatus,
 } from '~/types/domain'
 
@@ -111,6 +112,37 @@ export function initiativeProgress(
   }
 }
 
+/**
+ * Whether a planning-interview question still needs a human answer: not dismissed, and no answer
+ * yet. Mirrors the backend `isPendingQuestion` (orchestration `initiative.logic.ts`) — the rule the
+ * interviewer, the retained-across-rounds digest and the continue gate all key off — so the window's
+ * pending list, its unanswered counter and its render order can never disagree with the engine
+ * about what is still open.
+ */
+export function isPendingQuestion(q: Partial<Pick<InitiativeQa, 'answer' | 'status'>>): boolean {
+  return q.status !== 'dismissed' && (q.answer ?? '').trim().length === 0
+}
+
+/**
+ * Interview questions in the order the planning window renders them: everything still pending
+ * first, everything already settled (answered, or dismissed as not relevant) after, each group
+ * keeping the interviewer's own chronological order.
+ *
+ * Each round APPENDS its new questions after the digest retained from the previous ones (backend
+ * `applyInterviewQuestions`: `[...retainedQa, ...pending]`), so from round two onwards the only
+ * questions the human still has to act on sit below a growing wall of ones they already settled —
+ * on a long interview, below the fold entirely. This reorders the RENDER only; the stored `qa`
+ * order, which the interviewer prompt and the in-repo tracker digest read, is untouched.
+ */
+export function orderInterviewQuestions<T extends Partial<Pick<InitiativeQa, 'answer' | 'status'>>>(
+  qa: readonly T[],
+): T[] {
+  const pending: T[] = []
+  const settled: T[] = []
+  for (const q of qa) (isPendingQuestion(q) ? pending : settled).push(q)
+  return [...pending, ...settled]
+}
+
 /**
  * The phase whose completed checkpoint (D2) is awaiting a human, or null. Mirrors the backend
  * `pendingCheckpoint` (orchestration `initiative.logic.ts`) so the SPA recomputes the pending

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/app/{components/tasks/ContextIssuePicker.logic.spec.ts → utils/taskSources.spec.ts}

@@ -1,12 +1,12 @@
 import { describe, it, expect } from 'vitest'
-import { buildSourceChoices, reconcileSource } from './ContextIssuePicker.logic'
+import { buildSourceChoices, reconcileSource } from './taskSources'
 import type { TaskSourceState } from '~/types/domain'
 
 /**
- * The pure source-selection behind `<ContextIssuePicker>`. Pins what the always-visible
- * selector promises: the tracker in use is named even when it is the only one, a tracker
- * the workspace hasn't got yet is offered as something to ADD (worded for its actual
- * state), and the selection stays valid as the offered set changes underneath it.
+ * The pure tracker-selection behind `<ContextIssuePicker>` and `<BugHuntModal>`. Pins what
+ * the always-visible selector promises: the tracker in use is named even when it is the only
+ * one, a tracker the workspace hasn't got yet is offered as something to ADD (worded for its
+ * actual state), and the selection stays valid as the offered set changes underneath it.
  */
 const state = (source: string, { available = true, enabled = true } = {}): TaskSourceState =>
   ({
@@ -55,6 +55,17 @@ describe('buildSourceChoices', () => {
     ])
   })
 
+  // What a surface's "nothing connected yet" state renders its add buttons from: it flattens
+  // the groups, so every choice there has to be addable. A `select` leaking through would
+  // offer to connect a tracker the workspace already has.
+  it('yields only addable choices when the workspace offers no tracker', () => {
+    const choices = buildSourceChoices(
+      [state('jira', { available: false }), state('linear', { enabled: false })],
+      undefined,
+    ).flat()
+    expect(choices.map((c) => c.action)).toEqual(['connect', 'enable'])
+  })
+
   it('drops empty groups so the menu renders no stray separator', () => {
     expect(buildSourceChoices([state('github')], 'github')).toHaveLength(1)
     expect(buildSourceChoices([state('jira', { available: false })], undefined)).toHaveLength(1)

package/app/{components/tasks/ContextIssuePicker.logic.ts → utils/taskSources.ts}

@@ -1,18 +1,20 @@
 import type { TaskSourceKind, TaskSourceState } from '~/types/domain'
 
 /**
- * Pure source-selection logic for `<ContextIssuePicker>`: which tracker the picker is
- * searching, and what the source menu offers. Kept out of the component so both the
- * template's `computed`s and the unit spec call the same code.
+ * Pure tracker-selection logic shared by every surface that picks a task source: which
+ * tracker is selected, and what its menu offers. Kept out of the components so their
+ * `computed`s and the unit spec call the same code.
  *
  * The menu is deliberately two-tier — pick an already-offered tracker, or go and add
- * one — because "attach a context issue" is where a user first discovers a tracker is
- * missing, and sending them to the Integrations hub loses their in-progress task.
+ * one — because a tracker-picking surface is exactly where a user discovers the tracker
+ * they want is missing, and sending them off to the Integrations hub loses whatever they
+ * had in progress. Today `<ContextIssuePicker>` (attach a context issue) and
+ * `<BugHuntModal>` (scan a board for bugs) both render it.
  */
 
-/** One row of the picker's source menu. */
+/** One row of a tracker menu. */
 export type SourceChoice =
-  /** An offered tracker the picker can search right now. */
+  /** An offered tracker the surface can use right now. */
   | { action: 'select'; source: TaskSourceKind; label: string; icon: string; active: boolean }
   /**
    * A configured tracker that is not offered yet, so it can be added from here. `connect`
@@ -23,8 +25,8 @@ export type SourceChoice =
   | { action: 'connect' | 'enable'; source: TaskSourceKind; label: string; icon: string }
 
 /**
- * The picker's source menu, as non-empty groups (the offered trackers, then the ones the
- * user could add). Empty groups are dropped so the menu never renders a stray separator.
+ * A tracker menu, as non-empty groups (the offered trackers, then the ones the user could
+ * add). Empty groups are dropped so the menu never renders a stray separator.
  */
 export function buildSourceChoices(
   sources: TaskSourceState[],
@@ -54,13 +56,13 @@ export function buildSourceChoices(
 }
 
 /**
- * The source the picker should hold once the offered set changes — after a connect, a
+ * The source a surface should hold once the offered set changes — after a connect, a
  * disconnect, or the per-workspace toggle flipping elsewhere.
  *
  * `awaiting` is the tracker the user just left to connect: the moment it becomes offered
  * it wins, so they land back on the source they went to add rather than on whatever was
  * selected before. Otherwise a still-offered selection is kept, and a selection that
- * stopped being offered falls back to the first one (searching a tracker the workspace no
+ * stopped being offered falls back to the first one (reading a tracker the workspace no
  * longer offers only yields errors).
  */
 export function reconcileSource(

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.",
@@ -3431,6 +3444,8 @@
     "intro": "Durchsuche ein Tracker-Board nach offenen, nicht zugewiesenen Fehlern und bewerte sie nach Auswirkung im Verhältnis zum geschätzten Aufwand. Wähle einen aus, und er wird zu einer Aufgabe, die die Fehlerbehebungs-Pipeline durchläuft.",
     "connectFirst": "Verbinde oder aktiviere zuerst eine Aufgabenquelle.",
     "connectSource": "{label} verbinden",
+    "enableSource": "{label} aktivieren",
+    "pickTracker": "Tracker auswählen",
     "needFrameFirst": "Füge zuerst einen Service-Rahmen zum Board hinzu, damit ein übernommener Fehler irgendwo landen kann.",
     "tracker": "Tracker",
     "board": "Board",

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.",
@@ -3854,6 +3867,8 @@
     "intro": "Scan a tracker board for open, unassigned bugs and rank them by impact against how hard each looks to fix. Pick one and it becomes a task running the bug-fix pipeline.",
     "connectFirst": "Connect or enable a task source first.",
     "connectSource": "Connect {label}",
+    "enableSource": "Enable {label}",
+    "pickTracker": "Pick a tracker",
     "needFrameFirst": "Add a service frame to the board first, so a picked-up bug has somewhere to land.",
     "tracker": "Tracker",
     "board": "Board",

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.",
@@ -3743,6 +3756,8 @@
     "intro": "Explora un tablero del gestor de incidencias en busca de errores abiertos y sin asignar, y clasifícalos por impacto frente a lo difícil que parece arreglar cada uno. Elige uno y se convertirá en una tarea que ejecuta la canalización de corrección de errores.",
     "connectFirst": "Conecta o activa primero una fuente de tareas.",
     "connectSource": "Conectar {label}",
+    "enableSource": "Habilitar {label}",
+    "pickTracker": "Elige un gestor de incidencias",
     "needFrameFirst": "Añade primero un marco de servicio al tablero para que el error elegido tenga dónde aterrizar.",
     "tracker": "Gestor de incidencias",
     "board": "Tablero",

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.",
@@ -3743,6 +3756,8 @@
     "intro": "Parcourez un tableau du gestionnaire de tickets à la recherche de bugs ouverts et non assignés, puis classez-les selon leur impact face à la difficulté apparente du correctif. Choisissez-en un et il devient une tâche qui exécute le pipeline de correction.",
     "connectFirst": "Connectez ou activez d'abord une source de tâches.",
     "connectSource": "Connecter {label}",
+    "enableSource": "Activer {label}",
+    "pickTracker": "Choisir un gestionnaire de tickets",
     "needFrameFirst": "Ajoutez d'abord un cadre de service au tableau, pour que le bug retenu ait un endroit où atterrir.",
     "tracker": "Gestionnaire de tickets",
     "board": "Tableau",

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 סופר אותם.",
@@ -3754,6 +3767,8 @@
     "intro": "סרוק לוח של מערכת מעקב לאיתור באגים פתוחים שאינם משויכים לאיש, ודרג אותם לפי ההשפעה מול מידת הקושי המשוערת בתיקון. בחר אחד והוא יהפוך למשימה שמריצה את צינור תיקון הבאגים.",
     "connectFirst": "חבר או הפעל תחילה מקור משימות.",
     "connectSource": "חבר את {label}",
+    "enableSource": "הפעל {label}",
+    "pickTracker": "בחר מערכת מעקב",
     "needFrameFirst": "הוסף תחילה מסגרת שירות ללוח, כדי שלבאג הנבחר יהיה לאן להגיע.",
     "tracker": "מערכת מעקב",
     "board": "לוח",

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.",
@@ -3431,6 +3444,8 @@
     "intro": "Esplora una bacheca del tracker alla ricerca di bug aperti e non assegnati e classificali per impatto rispetto a quanto sembra difficile risolverli. Scegline uno e diventerà un'attività che esegue la pipeline di correzione.",
     "connectFirst": "Collega o abilita prima una sorgente di attività.",
     "connectSource": "Collega {label}",
+    "enableSource": "Abilita {label}",
+    "pickTracker": "Scegli un tracker",
     "needFrameFirst": "Aggiungi prima un frame di servizio alla bacheca, così il bug scelto ha dove atterrare.",
     "tracker": "Tracker",
     "board": "Bacheca",

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 のコンテキスト表示と同じ数え方です。",
@@ -3755,6 +3768,8 @@
     "intro": "トラッカーのボードから未割り当ての未解決バグを探し、影響度と修正の難しさの比で並べ替えます。ひとつ選ぶと、バグ修正パイプラインを実行するタスクになります。",
     "connectFirst": "先にタスクソースを接続または有効化してください。",
     "connectSource": "{label} を接続",
+    "enableSource": "{label} を有効化",
+    "pickTracker": "トラッカーを選択",
     "needFrameFirst": "選んだバグの受け入れ先が必要なので、先にサービスフレームをボードに追加してください。",
     "tracker": "トラッカー",
     "board": "ボード",

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.",
@@ -3743,6 +3756,8 @@
     "intro": "Przeszukaj tablicę systemu zgłoszeń w poszukiwaniu otwartych, nieprzypisanych błędów i uszereguj je według wpływu w stosunku do przewidywanej trudności naprawy. Wybierz jeden, a stanie się zadaniem uruchamiającym potok naprawy błędów.",
     "connectFirst": "Najpierw połącz lub włącz źródło zadań.",
     "connectSource": "Połącz {label}",
+    "enableSource": "Włącz {label}",
+    "pickTracker": "Wybierz system zgłoszeń",
     "needFrameFirst": "Najpierw dodaj ramkę usługi do tablicy, aby wybrany błąd miał gdzie wylądować.",
     "tracker": "System zgłoszeń",
     "board": "Tablica",

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.",
@@ -3755,6 +3768,8 @@
     "intro": "Bir takip panosunu açık ve kimseye atanmamış hatalar için tarayın ve bunları etkilerine karşı düzeltmenin ne kadar zor göründüğüne göre sıralayın. Birini seçin, hata düzeltme hattını çalıştıran bir göreve dönüşsün.",
     "connectFirst": "Önce bir görev kaynağı bağlayın veya etkinleştirin.",
     "connectSource": "{label} bağla",
+    "enableSource": "{label} etkinleştir",
+    "pickTracker": "Bir takip aracı seçin",
     "needFrameFirst": "Seçilen hatanın ineceği bir yer olması için önce panoya bir servis çerçevesi ekleyin.",
     "tracker": "Takip aracı",
     "board": "Pano",

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.",
@@ -3743,6 +3756,8 @@
     "intro": "Перегляньте дошку трекера у пошуках відкритих і не призначених нікому помилок та впорядкуйте їх за впливом щодо того, наскільки складним видається виправлення. Оберіть одну, і вона стане завданням, що виконує конвеєр виправлення помилок.",
     "connectFirst": "Спершу під’єднайте або увімкніть джерело завдань.",
     "connectSource": "Під'єднати {label}",
+    "enableSource": "Увімкнути {label}",
+    "pickTracker": "Оберіть трекер",
     "needFrameFirst": "Спершу додайте рамку сервісу на дошку, щоб обрана помилка мала куди потрапити.",
     "tracker": "Трекер",
     "board": "Дошка",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.178.2",
+  "version": "0.180.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",