@cat-factory/app 0.114.1 → 0.115.1

package/app/components/forkDecision/ForkDecisionWindow.vue

@@ -3,14 +3,16 @@
 // materially different implementation approaches, opened via the universal result-view host
 // (`ui.openForkDecision`). It reads the live fork state straight off the run's Coder step
 // (`step.forkDecision`, kept fresh by the execution stream) and lets a human pick a proposed
-// fork OR enter their own free-text approach. Once chosen, the Coder re-runs with the chosen
-// approach folded in. Chat is added in a later slice.
+// fork OR enter their own free-text approach, or CHAT about the forks before deciding. Once
+// chosen, the Coder re-runs with the chosen approach folded in. Chat replies are computed by an
+// inline grounded LLM in the durable driver and arrive live on the execution stream.
 import { computed, ref, watch } from 'vue'
+import { DEFAULT_FORK_MAX_CHAT_TURNS } from '@cat-factory/contracts'
 import { useResultView } from '~/composables/useResultView'
 import { useExecutionStore } from '~/stores/execution'
 import { useBoardStore } from '~/stores/board'
 import { useForkDecisionStore } from '~/stores/forkDecision'
-import type { ForkDecisionStepState, ForkOption } from '~/types/execution'
+import type { ForkChatMessage, ForkDecisionStepState, ForkOption } from '~/types/execution'
 import { FORK_DECISION_META } from '~/utils/catalog'
 
 const execution = useExecutionStore()
@@ -36,11 +38,25 @@ const state = computed<ForkDecisionStepState | null>(() => step.value?.forkDecis
 const status = computed(() => state.value?.status ?? null)
 const forks = computed<ForkOption[]>(() => state.value?.forks ?? [])
 const awaiting = computed(() => status.value === 'awaiting_choice')
+// A chat turn is being answered by the inline responder (the reply arrives via the stream).
+const answering = computed(() => status.value === 'answering')
+// The interactive surface (fork cards + chat + choose) is shown while awaiting OR answering.
+const interactive = computed(() => awaiting.value || answering.value)
+const chat = computed<ForkChatMessage[]>(() => state.value?.chat ?? [])
+// The chat has spent its human-turn budget once the human has sent `maxChatTurns` messages.
+const chatBudgetSpent = computed(() => {
+  const max = state.value?.maxChatTurns ?? DEFAULT_FORK_MAX_CHAT_TURNS
+  return chat.value.filter((m) => m.role === 'human').length >= max
+})
+// `awaiting` and `answering` are mutually exclusive statuses, so awaiting already implies the
+// chat isn't mid-answer — no separate `!answering` guard is needed.
+const canChat = computed(() => awaiting.value && !chatBudgetSpent.value && !forkDecision.chatting)
 
 // The human's selection: a proposed fork id, or the sentinel 'custom' for the free-text path.
 const selected = ref<string | null>(null)
 const customText = ref('')
 const note = ref('')
+const chatInput = ref('')
 
 // Default the selection to the recommended fork whenever the fork set changes.
 watch(
@@ -72,6 +88,14 @@ async function onChoose() {
       : { forkId: selected.value!, note: noteText }
   await forkDecision.choose(id, choice).catch(() => {})
 }
+
+async function onSend() {
+  const id = instanceId.value
+  const text = chatInput.value.trim()
+  if (!id || !text || !canChat.value) return
+  chatInput.value = ''
+  await forkDecision.chat(id, text).catch(() => {})
+}
 </script>
 
 <template>
@@ -157,8 +181,8 @@ async function onChoose() {
             </p>
           </div>
 
-          <!-- Awaiting the human's choice. -->
-          <div v-else-if="awaiting" class="space-y-3">
+          <!-- Awaiting the human's choice (or answering a chat turn). -->
+          <div v-else-if="interactive" class="space-y-3">
             <p
               v-if="forkDecision.error"
               class="rounded-md bg-rose-500/10 px-3 py-2 text-[12px] text-rose-300"
@@ -263,6 +287,74 @@ async function onChoose() {
                 class="w-full rounded-md border border-slate-700 bg-slate-950/60 px-2.5 py-1.5 text-[12px] text-slate-100 placeholder:text-slate-600 focus:border-violet-500 focus:outline-none"
               />
             </div>
+
+            <!-- Grounded chat: ask about the forks before deciding. -->
+            <section class="rounded-xl border border-slate-800 bg-slate-900/40 px-4 py-3">
+              <p class="text-[11px] font-medium text-slate-400">
+                {{ t('forkDecision.chat.title') }}
+              </p>
+              <div
+                v-if="chat.length || answering"
+                class="mt-2 max-h-64 space-y-2 overflow-y-auto pr-1"
+              >
+                <div
+                  v-for="msg in chat"
+                  :key="msg.id"
+                  data-testid="fork-chat-message"
+                  class="flex"
+                  :class="msg.role === 'human' ? 'justify-end' : 'justify-start'"
+                >
+                  <p
+                    class="max-w-[85%] whitespace-pre-wrap rounded-lg px-3 py-1.5 text-[12px]"
+                    :class="
+                      msg.role === 'human'
+                        ? 'bg-violet-500/15 text-violet-100'
+                        : 'bg-slate-800/70 text-slate-200'
+                    "
+                  >
+                    {{ msg.text }}
+                  </p>
+                </div>
+                <div v-if="answering" class="flex justify-start">
+                  <p
+                    class="flex items-center gap-1.5 rounded-lg bg-slate-800/70 px-3 py-1.5 text-[12px] text-slate-400"
+                  >
+                    <UIcon name="i-lucide-loader-circle" class="h-3.5 w-3.5 animate-spin" />
+                    {{ t('forkDecision.chat.thinking') }}
+                  </p>
+                </div>
+              </div>
+              <p v-else class="mt-1 text-[11px] text-slate-500">
+                {{ t('forkDecision.chat.hint') }}
+              </p>
+              <div class="mt-2 flex items-end gap-2">
+                <textarea
+                  v-model="chatInput"
+                  data-testid="fork-chat-input"
+                  rows="2"
+                  :disabled="!canChat"
+                  :placeholder="
+                    chatBudgetSpent
+                      ? t('forkDecision.chat.budgetSpent')
+                      : t('forkDecision.chat.placeholder')
+                  "
+                  class="min-h-0 flex-1 resize-y rounded-md border border-slate-700 bg-slate-950/60 px-2.5 py-1.5 text-[12px] text-slate-100 placeholder:text-slate-600 focus:border-violet-500 focus:outline-none disabled:opacity-50"
+                  @keydown.enter.exact.prevent="onSend"
+                />
+                <UButton
+                  data-testid="fork-chat-send"
+                  color="neutral"
+                  variant="soft"
+                  size="sm"
+                  icon="i-lucide-send"
+                  :loading="forkDecision.chatting"
+                  :disabled="!canChat || chatInput.trim().length === 0"
+                  @click="onSend"
+                >
+                  {{ t('forkDecision.chat.send') }}
+                </UButton>
+              </div>
+            </section>
           </div>
 
           <!-- Skipped / no state: nothing to decide. -->
@@ -276,7 +368,7 @@ async function onChoose() {
         </div>
 
         <footer
-          v-if="awaiting"
+          v-if="interactive"
           class="flex items-center justify-end gap-2 border-t border-slate-800 px-5 py-3"
         >
           <UButton color="neutral" variant="ghost" size="sm" @click="close">

package/app/components/pipeline/PipelineProgress.vue

@@ -554,6 +554,8 @@ const ITEM_ICON: Record<string, string> = {
           <button
             v-if="forkPhase(s)"
             type="button"
+            data-testid="fork-decision-open"
+            :data-fork-phase="forkPhase(s)"
             class="mt-3 flex w-full items-center gap-2 rounded-lg border border-dashed px-2.5 py-1.5 text-start transition hover:border-violet-400/60"
             :class="
               forkPhase(s) === 'awaiting_choice'

package/app/components/provisioning/ProvisioningLogsDrawer.vue

@@ -76,7 +76,12 @@ watch(
 )
 
 onMounted(() => reload())
-onBeforeUnmount(stopPolling)
+onBeforeUnmount(() => {
+  stopPolling()
+  // Drop this run's accumulated log state so the per-execution map doesn't grow for the app's
+  // lifetime (a re-opened drawer re-fetches on mount). Subsystem mode keeps its fixed-size state.
+  if (props.executionId) store.evict(props.executionId)
+})
 
 // Exhaustive enum→label maps of literal `t(...)` keys (keeps the typed-key drift guard
 // live for these runtime-indexed lookups).

package/app/composables/api/forkDecision.ts

@@ -1,4 +1,8 @@
-import { chooseForkContract, getForkDecisionContract } from '@cat-factory/contracts'
+import {
+  chooseForkContract,
+  forkChatContract,
+  getForkDecisionContract,
+} from '@cat-factory/contracts'
 import type { ApiContext } from './context'
 
 /**
@@ -14,6 +18,14 @@ export function forkDecisionApi({ send, ws }: ApiContext) {
     getForkDecision: (workspaceId: string, executionId: string) =>
       send(getForkDecisionContract, { pathPrefix: ws(workspaceId), pathParams: { executionId } }),
 
+    // Send a grounded chat message about the surfaced forks (the reply arrives via the stream).
+    forkChat: (workspaceId: string, executionId: string, text: string) =>
+      send(forkChatContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { executionId },
+        body: { text },
+      }),
+
     // Choose an implementation approach — a proposed fork id or a custom approach (+ note).
     chooseFork: (
       workspaceId: string,

package/app/stores/forkDecision.ts

@@ -20,6 +20,8 @@ export const useForkDecisionStore = defineStore('forkDecision', () => {
 
   /** True while a choose call is in flight (drives the Choose button spinner / disabled state). */
   const choosing = ref(false)
+  /** True while a chat send is in flight (drives the chat send spinner / disabled state). */
+  const chatting = ref(false)
   /** The last error message from an action, surfaced inline; cleared on the next action. */
   const error = ref<string | null>(null)
 
@@ -80,5 +82,25 @@ export const useForkDecisionStore = defineStore('forkDecision', () => {
     }
   }
 
-  return { choosing, error, load, choose }
+  /**
+   * Send a grounded chat message about the surfaced forks. The reply is computed inline in the
+   * durable driver and arrives via the execution stream; the immediate response is the
+   * `answering` state (the human message already appended), which we reflect so the thread shows
+   * the sent turn + a "thinking…" bubble without waiting for the stream.
+   */
+  async function chat(executionId: string, text: string): Promise<void> {
+    error.value = null
+    chatting.value = true
+    try {
+      const state = await api.forkChat(workspace.requireId(), executionId, text)
+      reflect(executionId, state as ForkDecisionStepState)
+    } catch (e) {
+      error.value = e instanceof Error ? e.message : 'Failed to send message'
+      throw e
+    } finally {
+      chatting.value = false
+    }
+  }
+
+  return { choosing, chatting, error, load, choose, chat }
 })

package/app/stores/provisioningLogs.spec.ts

@@ -92,4 +92,92 @@ describe('provisioningLogs store — loadForExecution', () => {
     expect(store.byExecution.exec1!.entries).toHaveLength(0)
     expect(store.byExecution.exec1!.error).toBe('503')
   })
+
+  it('a slower stale load never clobbers a newer one (monotonic guard)', async () => {
+    // Two loads race: the FIRST-issued resolves LAST with a stale timeline. Without the guard its
+    // `s.entries = entries` would overwrite the fresher second result — a card/row would vanish.
+    const deferred: Array<(r: { entries: ProvisioningLogEntry[] }) => void> = []
+    vi.stubGlobal('useApi', () => ({
+      listProvisioningLogs: () =>
+        new Promise<{ entries: ProvisioningLogEntry[] }>((res) => deferred.push(res)),
+    }))
+
+    const store = useProvisioningLogsStore()
+    const first = store.loadForExecution('exec1', { silent: true }) // issued #1 (stale)
+    const second = store.loadForExecution('exec1', { silent: true }) // issued #2 (fresh)
+
+    // Resolve NEWEST first, then the older/staler one.
+    deferred[1]!({ entries: [entry({ id: 'fresh', operation: 'release' })] })
+    deferred[0]!({ entries: [entry({ id: 'stale', operation: 'dispatch' })] })
+    await Promise.all([first, second])
+
+    // The fresher result survives — the stale late-resolver was discarded.
+    expect(store.byExecution.exec1!.entries).toHaveLength(1)
+    expect(store.byExecution.exec1!.entries[0]!.id).toBe('fresh')
+  })
+
+  it('a superseding visible load owns the final entries and clears the spinner', async () => {
+    // A visible load in flight, then a newer visible load; the OLDER resolves last and must neither
+    // clobber the entries nor leave a stuck spinner.
+    const deferred: Array<(r: { entries: ProvisioningLogEntry[] }) => void> = []
+    vi.stubGlobal('useApi', () => ({
+      listProvisioningLogs: () =>
+        new Promise<{ entries: ProvisioningLogEntry[] }>((res) => deferred.push(res)),
+    }))
+
+    const store = useProvisioningLogsStore()
+    const first = store.loadForExecution('exec1')
+    const second = store.loadForExecution('exec1')
+
+    deferred[1]!({ entries: [entry({ id: 'fresh' })] })
+    deferred[0]!({ entries: [entry({ id: 'stale' })] })
+    await Promise.all([first, second])
+
+    expect(store.byExecution.exec1!.entries[0]!.id).toBe('fresh')
+    expect(store.byExecution.exec1!.loading).toBe(false)
+  })
+
+  it("evict drops a run's accumulated state (map does not grow unbounded)", async () => {
+    vi.stubGlobal('useApi', () => ({
+      listProvisioningLogs: () => Promise.resolve({ entries: [entry()] }),
+    }))
+
+    const store = useProvisioningLogsStore()
+    await store.loadForExecution('exec1')
+    expect(store.byExecution.exec1).toBeDefined()
+
+    store.evict('exec1')
+    expect(store.byExecution.exec1).toBeUndefined()
+
+    // After eviction a fresh load re-seeds cleanly (the drawer re-fetches on re-mount) — and the
+    // per-execution ticket record was dropped too, so the guard still holds for the new lifecycle.
+    await store.loadForExecution('exec1')
+    expect(store.byExecution.exec1!.entries).toHaveLength(1)
+  })
+
+  it('a load in flight when evict runs cannot resurrect stale state after the drawer re-opens', async () => {
+    // Close-then-reopen while the pre-close fetch is still pending: the drawer unmounts (evict), then
+    // re-mounts and issues a fresh load, then the OLD pre-evict fetch finally resolves. With a global
+    // (never-reset) load ticket the re-opened load out-ranks the straggler, so the stale result is
+    // discarded rather than clobbering the fresh timeline (a per-execution counter reset on evict
+    // would let the two collide on the same seq and the straggler would win).
+    const deferred: Array<(r: { entries: ProvisioningLogEntry[] }) => void> = []
+    vi.stubGlobal('useApi', () => ({
+      listProvisioningLogs: () =>
+        new Promise<{ entries: ProvisioningLogEntry[] }>((res) => deferred.push(res)),
+    }))
+
+    const store = useProvisioningLogsStore()
+    const preEvict = store.loadForExecution('exec1', { silent: true }) // issued before close
+    store.evict('exec1') // drawer unmounts mid-flight
+    const reopened = store.loadForExecution('exec1', { silent: true }) // drawer re-opens, fresh load
+
+    // The re-opened load resolves first (fresh), then the stale pre-evict straggler.
+    deferred[1]!({ entries: [entry({ id: 'fresh', operation: 'release' })] })
+    deferred[0]!({ entries: [entry({ id: 'stale', operation: 'dispatch' })] })
+    await Promise.all([preEvict, reopened])
+
+    expect(store.byExecution.exec1!.entries).toHaveLength(1)
+    expect(store.byExecution.exec1!.entries[0]!.id).toBe('fresh')
+  })
 })

package/app/stores/provisioningLogs.ts

@@ -30,6 +30,17 @@ export const useProvisioningLogsStore = defineStore('provisioningLogs', () => {
     container: emptyState(),
   })
   const byExecution = reactive<Record<string, LogState>>({})
+  // Monotonic load-ordering guard: the drawer's silent background poll and a manual/visible refresh
+  // can be in flight at once, and each ends in a REPLACE-style `s.entries = entries`. Without ordering
+  // a slower/staler fetch resolving AFTER a newer one clobbers the fresher timeline (the same
+  // out-of-order-overwrite hazard the CLAUDE.md live-push rules warn about, and that
+  // stores/workspace.ts guards its full refresh with). Each load takes a ticket from a single
+  // ever-increasing counter; `latestLoad` records the newest ticket issued per execution, and only
+  // that load commits. The counter is GLOBAL (never reset on `evict`) so a drawer re-opened for an
+  // evicted execution always out-ranks any still-in-flight prior load — no seq collision can let a
+  // stale fetch win. NOT reactive — pure bookkeeping the UI never reads.
+  let loadTicket = 0
+  const latestLoad = new Map<string, number>()
 
   async function load(subsystem: ProvisioningSubsystem) {
     const ws = useWorkspaceStore()
@@ -60,23 +71,45 @@ export const useProvisioningLogsStore = defineStore('provisioningLogs', () => {
       s.loading = true
       s.error = null
     }
+    const seq = ++loadTicket
+    latestLoad.set(executionId, seq)
     try {
       const { entries } = await api.listProvisioningLogs(ws.requireId(), {
         executionId,
         limit: 200,
       })
+      // A newer load (silent poll or manual refresh) superseded this one while it was in flight —
+      // discard this staler result so it can't clobber the fresher timeline.
+      if (latestLoad.get(executionId) !== seq) return
       s.entries = entries
       s.error = null
     } catch (err) {
+      if (latestLoad.get(executionId) !== seq) return
       // A background poll keeps the last snapshot on a blip; only a visible load reports.
       if (!opts?.silent) {
         s.error = err instanceof Error ? err.message : 'Failed to load logs'
         s.entries = []
       }
     } finally {
+      // The visible spinner is owned by the visible request that turned it on, so clear it in its
+      // own finally regardless of supersession — a superseded load still ends its own spinner.
       if (!opts?.silent) s.loading = false
     }
   }
 
-  return { bySubsystem, byExecution, load, loadForExecution }
+  /**
+   * Drop a run's accumulated log state (called by the drawer on unmount). `byExecution` would
+   * otherwise accrete one entry per execution viewed and never evict — a slow memory creep across
+   * a long board session. The drawer re-fetches on re-mount, so dropping a closed run's state is
+   * free; keeping it while OPEN is what the manual-refresh-after-terminal affordance relies on.
+   */
+  function evict(executionId: string) {
+    delete byExecution[executionId]
+    // Drop the per-execution ticket record too (its map must not grow unbounded either). The global
+    // `loadTicket` counter is deliberately NOT reset, so a re-opened drawer still out-ranks any load
+    // that was in flight when this ran.
+    latestLoad.delete(executionId)
+  }
+
+  return { bySubsystem, byExecution, load, loadForExecution, evict }
 })

package/i18n/locales/de.json

@@ -4610,6 +4610,14 @@
       "title": "Eigenen Ansatz eingeben",
       "placeholder": "Beschreibe, wie dies umgesetzt werden soll…"
     },
+    "chat": {
+      "title": "Zu diesen Ansätzen nachfragen",
+      "hint": "Unsicher, welchen Sie wählen sollen? Stellen Sie vor der Entscheidung eine Frage.",
+      "thinking": "Denkt nach …",
+      "placeholder": "Fragen Sie nach Kompromissen, Risiken oder einer anderen Richtung …",
+      "budgetSpent": "Chat-Limit erreicht – wählen Sie einen Ansatz oder geben Sie einen eigenen ein.",
+      "send": "Senden"
+    },
     "empty": {
       "title": "Nichts zu entscheiden"
     }

package/i18n/locales/en.json

@@ -4727,6 +4727,14 @@
       "title": "Enter your own approach",
       "placeholder": "Describe how you want this implemented…"
     },
+    "chat": {
+      "title": "Ask about these approaches",
+      "hint": "Not sure which to pick? Ask a question before you decide.",
+      "thinking": "Thinking…",
+      "placeholder": "Ask about the trade-offs, risks, or a different direction…",
+      "budgetSpent": "Chat limit reached — pick an approach or enter your own.",
+      "send": "Send"
+    },
     "empty": {
       "title": "Nothing to decide"
     }

package/i18n/locales/es.json

@@ -4598,6 +4598,14 @@
       "title": "Introduce tu propio enfoque",
       "placeholder": "Describe cómo quieres que se implemente…"
     },
+    "chat": {
+      "title": "Pregunta sobre estos enfoques",
+      "hint": "¿No sabes cuál elegir? Haz una pregunta antes de decidir.",
+      "thinking": "Pensando…",
+      "placeholder": "Pregunta por las ventajas y desventajas, los riesgos o una dirección distinta…",
+      "budgetSpent": "Límite del chat alcanzado: elige un enfoque o introduce el tuyo.",
+      "send": "Enviar"
+    },
     "empty": {
       "title": "Nada que decidir"
     }

package/i18n/locales/fr.json

@@ -4598,6 +4598,14 @@
       "title": "Saisir votre propre approche",
       "placeholder": "Décrivez comment vous voulez que ce soit implémenté…"
     },
+    "chat": {
+      "title": "Poser une question sur ces approches",
+      "hint": "Vous hésitez ? Posez une question avant de décider.",
+      "thinking": "Réflexion en cours…",
+      "placeholder": "Interrogez sur les compromis, les risques ou une autre direction…",
+      "budgetSpent": "Limite de discussion atteinte — choisissez une approche ou saisissez la vôtre.",
+      "send": "Envoyer"
+    },
     "empty": {
       "title": "Rien à décider"
     }

package/i18n/locales/he.json

@@ -4609,6 +4609,14 @@
       "title": "הזן גישה משלך",
       "placeholder": "תאר כיצד ברצונך שזה ימומש…"
     },
+    "chat": {
+      "title": "שאל על הגישות האלה",
+      "hint": "לא בטוח מה לבחור? שאל שאלה לפני שתחליט.",
+      "thinking": "חושב…",
+      "placeholder": "שאל על היתרונות והחסרונות, הסיכונים או כיוון אחר…",
+      "budgetSpent": "הגעת למגבלת הצ׳אט — בחר גישה או הזן גישה משלך.",
+      "send": "שלח"
+    },
     "empty": {
       "title": "אין מה להחליט"
     }

package/i18n/locales/it.json

@@ -4610,6 +4610,14 @@
       "title": "Inserisci il tuo approccio",
       "placeholder": "Descrivi come vuoi che venga implementato…"
     },
+    "chat": {
+      "title": "Fai una domanda su questi approcci",
+      "hint": "Non sai quale scegliere? Fai una domanda prima di decidere.",
+      "thinking": "Sto pensando…",
+      "placeholder": "Chiedi dei compromessi, dei rischi o di una direzione diversa…",
+      "budgetSpent": "Limite della chat raggiunto: scegli un approccio o inserisci il tuo.",
+      "send": "Invia"
+    },
     "empty": {
       "title": "Nulla da decidere"
     }

package/i18n/locales/ja.json

@@ -4610,6 +4610,14 @@
       "title": "独自のアプローチを入力",
       "placeholder": "どのように実装したいか記述してください…"
     },
+    "chat": {
+      "title": "これらのアプローチについて質問する",
+      "hint": "どれを選ぶか迷っていますか？決める前に質問できます。",
+      "thinking": "考えています…",
+      "placeholder": "トレードオフやリスク、別の方向性について質問してください…",
+      "budgetSpent": "チャットの上限に達しました。アプローチを選ぶか、独自の方法を入力してください。",
+      "send": "送信"
+    },
     "empty": {
       "title": "決定する項目はありません"
     }

package/i18n/locales/pl.json

@@ -4598,6 +4598,14 @@
       "title": "Wpisz własne podejście",
       "placeholder": "Opisz, jak chcesz to zaimplementować…"
     },
+    "chat": {
+      "title": "Zapytaj o te podejścia",
+      "hint": "Nie wiesz, które wybrać? Zadaj pytanie przed podjęciem decyzji.",
+      "thinking": "Myślę…",
+      "placeholder": "Zapytaj o kompromisy, ryzyko lub inny kierunek…",
+      "budgetSpent": "Osiągnięto limit czatu — wybierz podejście lub wprowadź własne.",
+      "send": "Wyślij"
+    },
     "empty": {
       "title": "Nie ma czego decydować"
     }

package/i18n/locales/tr.json

@@ -4610,6 +4610,14 @@
       "title": "Kendi yaklaşımınızı girin",
       "placeholder": "Bunun nasıl uygulanmasını istediğinizi açıklayın…"
     },
+    "chat": {
+      "title": "Bu yaklaşımlar hakkında soru sorun",
+      "hint": "Hangisini seçeceğinizden emin değil misiniz? Karar vermeden önce soru sorun.",
+      "thinking": "Düşünüyor…",
+      "placeholder": "Ödünleşimleri, riskleri veya farklı bir yönü sorun…",
+      "budgetSpent": "Sohbet sınırına ulaşıldı — bir yaklaşım seçin veya kendinizinkini girin.",
+      "send": "Gönder"
+    },
     "empty": {
       "title": "Karar verilecek bir şey yok"
     }

package/i18n/locales/uk.json

@@ -4598,6 +4598,14 @@
       "title": "Введіть власний підхід",
       "placeholder": "Опишіть, як ви хочете це реалізувати…"
     },
+    "chat": {
+      "title": "Запитайте про ці підходи",
+      "hint": "Не впевнені, що обрати? Поставте запитання, перш ніж вирішувати.",
+      "thinking": "Обмірковую…",
+      "placeholder": "Запитайте про компроміси, ризики або інший напрям…",
+      "budgetSpent": "Досягнуто ліміту чату — оберіть підхід або введіть власний.",
+      "send": "Надіслати"
+    },
     "empty": {
       "title": "Нема чого вирішувати"
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.114.1",
+  "version": "0.115.1",
   "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",
@@ -34,7 +34,7 @@
     "valibot": "^1.4.2",
     "vue": "3.5.39",
     "wretch": "^3.0.9",
-    "@cat-factory/contracts": "0.126.0"
+    "@cat-factory/contracts": "0.127.0"
   },
   "devDependencies": {
     "@toad-contracts/testing": "0.3.2",