@cat-factory/app 0.209.0 → 0.210.1

package/app/components/settings/CapabilityCredentialsPanel.vue

@@ -160,16 +160,26 @@ async function removeKey(key: string) {
           })
         }}
       </p>
-      <!-- An EMPTY row is not the same fact in both deployments, so it must not read the same
-           way. Behind the store the deployment's own environment may still answer for this key,
-           and calling that "missing" would send an operator hunting for a value that is already
-           resolving. -->
-      <p v-else-if="view?.environmentFallback" class="text-[11px] text-slate-500">
+      <!-- An EMPTY row is not the same fact in every deployment, so it must not read the same way.
+           Three states, and the backend reports them off the chain it actually composed: with the
+           fallback the deployment's own environment may still answer, and calling that "missing"
+           would send an operator hunting for a value that is already resolving; without it, blank
+           really does mean the capability cannot authenticate.
+
+           The third is that the chain cannot be described, and this copy says exactly that and
+           stops. It must not name a cause: a deployment's own resolver replacing the chain is the
+           usual one, but a facade that wired the store and dropped the flag lands here too, and
+           blaming a custom resolver would make that wiring bug read as a deliberate configuration
+           and send the operator to the one place that cannot explain it. -->
+      <p v-else-if="view?.environmentFallback === true" class="text-[11px] text-slate-500">
         {{ t('settings.capabilityCredentials.notStoredWithFallback') }}
       </p>
-      <p v-else class="text-[11px] text-amber-400">
+      <p v-else-if="view?.environmentFallback === false" class="text-[11px] text-amber-400">
         {{ t('settings.capabilityCredentials.notStored') }}
       </p>
+      <p v-else class="text-[11px] text-slate-500">
+        {{ t('settings.capabilityCredentials.notStoredUnknownFallback') }}
+      </p>
 
       <div class="flex items-end gap-2">
         <UFormField

package/app/composables/useRunDeepLink.spec.ts

@@ -30,6 +30,11 @@ describe('captureRunDeepLink', () => {
     })
   })
 
+  it('parses the captured-evidence link the lifecycle section emits', () => {
+    setUrl('?ws=ws_1&block=blk_1&run=exec_1&view=test-evidence')
+    expect(captureRunDeepLink()?.view).toBe('test-evidence')
+  })
+
   it('strips its own params so a reload does not re-open the panel', () => {
     setUrl('?ws=ws_1&run=exec_1&view=observability&keep=yes')
     captureRunDeepLink()

package/app/composables/useRunDeepLink.ts

@@ -1,11 +1,12 @@
 /**
- * Boot-time replay of a RUN deep link — `?ws=<id>&block=<id>&run=<id>&view=observability`.
+ * Boot-time replay of a RUN deep link: `?ws=<id>&block=<id>&run=<id>&view=<panel>`.
  *
- * The engine's PR verification report links each PR back to the run's observability panel
- * (Model activity / Provided context), built from the deployment's public app URL. The SPA is a
- * single canvas with no URL identity for anything, so this is the narrow consumer that makes
- * that link resolve: pin the board before the snapshot loads, then — once the board is ready —
- * select the task and open the panel for the run.
+ * The engine's PR verification report links each PR back into the run: to the observability
+ * panel (Model activity / Provided context), and to the Tester's result window holding the
+ * evidence its environment-lifecycle section lists. Both are built from the deployment's public
+ * app URL. The SPA is a single canvas with no URL identity for anything, so this is the narrow
+ * consumer that makes those links resolve: pin the board before the snapshot loads, then, once
+ * the board is ready, select the task and open the panel for the run.
  *
  * Deliberately narrow. The GENERAL parser (every entity, every window, plus state→URL sync) is
  * slice 4 of `docs/initiatives/global-search-and-deep-links.md`; when it lands, this composable
@@ -81,9 +82,11 @@ export function useRunDeepLink(): void {
       if (!ready || applied) return
       applied = true
       if (link.blockId) ui.select(link.blockId)
-      // `observability` is the only view this narrow parser serves — an unknown view still
-      // lands the user on the right board and task rather than failing the navigation.
+      // Two views are served: the observability panel and the Tester's result window (where the
+      // screenshots the report's environment-lifecycle section lists are rendered). An unknown
+      // view still lands the user on the right board and task rather than failing the navigation.
       if (link.view === 'observability') ui.openObservability(link.runId)
+      else if (link.view === 'test-evidence') ui.openTestEvidence(link.runId)
       stop?.()
     },
     { immediate: true },

package/app/stores/ui/resultViews.ts

@@ -2,6 +2,7 @@ import { ref } from 'vue'
 import { useExecutionStore } from '~/stores/execution'
 import { agentKindMeta } from '~/utils/catalog'
 import { dedicatedParkView } from '~/utils/pipelineRender'
+import { createRunStepOpeners } from './runStepOpeners'
 
 /**
  * The step-inspection / result-view slice of the UI store: the dedicated result-view overlay
@@ -126,84 +127,16 @@ export function createUiResultViews() {
   function openInitiativePlanning(blockId: string) {
     resultView.value = { view: 'initiative-planning', blockId, instanceId: null, stepIndex: null }
   }
-  // Open the Follow-up companion window for a run's Coder step (the blinking chip + the
-  // `followup_pending` notification). Resolves the Coder step index from the run when not
-  // given, so callers that only know the run can still open it.
-  function openFollowUps(instanceId: string, stepIndex: number | null = null) {
-    const execution = useExecutionStore()
-    const instance = execution.getInstance(instanceId)
-    if (!instance) return
-    // A pipeline may carry more than one follow-up-enabled Coder step, so don't blindly pick
-    // the first when no index is given: prefer the step that still has undecided items (the
-    // one the run is parked on), else the current step, else the first enabled one.
-    const resolveIdx = () => {
-      const pending = instance.steps.findIndex(
-        (s) => s.followUps?.enabled && s.followUps.items.some((i) => i.status === 'pending'),
-      )
-      if (pending >= 0) return pending
-      const current = instance.steps[instance.currentStep]
-      if (current?.followUps?.enabled) return instance.currentStep
-      return instance.steps.findIndex((s) => s.followUps?.enabled)
-    }
-    const idx = stepIndex ?? resolveIdx()
-    if (idx < 0) return
-    resultView.value = {
-      view: 'follow-ups',
-      blockId: instance.blockId,
-      instanceId,
-      stepIndex: idx,
-    }
-  }
-  // Open the implementation-fork decision window for a run's coder step (from the inspector /
-  // pipeline chip / `fork_decision_pending` notification). Resolves the coder step index from
-  // the run when not given, preferring the step parked awaiting a choice.
-  function openForkDecision(instanceId: string, stepIndex: number | null = null) {
-    const execution = useExecutionStore()
-    const instance = execution.getInstance(instanceId)
-    if (!instance) return
-    const resolveIdx = () => {
-      const awaiting = instance.steps.findIndex(
-        (s) => s.agentKind === 'coder' && s.forkDecision?.status === 'awaiting_choice',
-      )
-      if (awaiting >= 0) return awaiting
-      const current = instance.steps[instance.currentStep]
-      if (current?.agentKind === 'coder' && current.forkDecision) return instance.currentStep
-      return instance.steps.findIndex((s) => s.agentKind === 'coder' && s.forkDecision)
-    }
-    const idx = stepIndex ?? resolveIdx()
-    if (idx < 0) return
-    resultView.value = {
-      view: 'fork-decision',
-      blockId: instance.blockId,
-      instanceId,
-      stepIndex: idx,
-    }
-  }
-  // Open the PR deep-review window for a run's `pr-reviewer` step (from the `pr_review_ready`
-  // notification / the step). Resolves the step index from the run when not given, preferring
-  // the step parked awaiting a finding selection.
-  function openPrReview(instanceId: string, stepIndex: number | null = null) {
-    const execution = useExecutionStore()
-    const instance = execution.getInstance(instanceId)
-    if (!instance) return
-    const resolveIdx = () => {
-      const awaiting = instance.steps.findIndex(
-        (s) => s.agentKind === 'pr-reviewer' && s.prReview?.status === 'awaiting_selection',
-      )
-      if (awaiting >= 0) return awaiting
-      const current = instance.steps[instance.currentStep]
-      if (current?.agentKind === 'pr-reviewer' && current.prReview) return instance.currentStep
-      return instance.steps.findIndex((s) => s.agentKind === 'pr-reviewer' && s.prReview)
-    }
-    const idx = stepIndex ?? resolveIdx()
-    if (idx < 0) return
-    resultView.value = {
-      view: 'pr-review',
-      blockId: instance.blockId,
-      instanceId,
-      stepIndex: idx,
-    }
-  }
+  // The run-scoped openers (a caller that knows only the RUN, so the step index has to be
+  // resolved) live in a sibling module: they share one shape and one hazard, and lifting them out
+  // keeps this factory inside its per-function line budget. Their two seams are bound here.
+  const { openFollowUps, openForkDecision, openPrReview, openTestEvidence } = createRunStepOpeners({
+    dispatchStepView: (instanceId, stepIndex) => dispatchStepView(instanceId, stepIndex),
+    setResultView: (view, instance, stepIndex) => {
+      resultView.value = { view, blockId: instance.blockId, instanceId: instance.id, stepIndex }
+    },
+  })
+
   function closeResultView() {
     resultView.value = null
   }
@@ -243,6 +176,7 @@ export function createUiResultViews() {
     openFollowUps,
     openForkDecision,
     openPrReview,
+    openTestEvidence,
     closeResultView,
     closeRequirementReview,
     openStepDetail,

package/app/stores/ui/runStepOpeners.ts

@@ -0,0 +1,143 @@
+import { useExecutionStore } from '~/stores/execution'
+import { isTesterKind } from '~/utils/catalog'
+import type { ExecutionInstance, PipelineStep } from '~/types/domain'
+
+/**
+ * The RUN-SCOPED window openers: entry points that know only which run to open, and have to
+ * resolve WHICH step of it the caller means before dispatching.
+ *
+ * They share one shape (find the step, bail if the run has none, open its window) and one hazard:
+ * a pipeline may carry the same agent kind more than once, so "the first matching step" is the
+ * wrong answer for every one of them. Each resolver states which of its candidates is the one a
+ * human was pointed at (the step parked awaiting a decision, the one that actually reported), and
+ * the callers that DO know the index still pass it and skip the resolution entirely.
+ *
+ * Extracted from `resultViews.ts` when the `test-evidence` opener pushed that factory over its
+ * per-function line budget: the budget is a split trigger, and this is the cohesive seam it named.
+ * Purely a move plus the new opener; the store's public surface is unchanged.
+ */
+export interface RunStepOpenerDeps {
+  /** Open a step's bespoke window through the universal routing seam. */
+  dispatchStepView: (instanceId: string, stepIndex: number) => void
+  /** Set the result-view overlay directly, for a window the routing seam does not select. */
+  setResultView: (view: string, instance: ExecutionInstance, stepIndex: number) => void
+}
+
+/** Index of the first step matching `predicate`, or -1. */
+function indexOf(instance: ExecutionInstance, predicate: (step: PipelineStep) => boolean): number {
+  return instance.steps.findIndex(predicate)
+}
+
+export function createRunStepOpeners(deps: RunStepOpenerDeps) {
+  /**
+   * Resolve the run, then the step index (the caller's when given, else `resolve`'s), then hand
+   * both to `open`. A run the store has not hydrated, or a pipeline with no candidate step, is a
+   * silent no-op: these are notification and deep-link entry points, and failing loudly at one
+   * would strand a user on a blank overlay.
+   */
+  function withStep(
+    instanceId: string,
+    stepIndex: number | null,
+    resolve: (instance: ExecutionInstance) => number,
+    open: (instance: ExecutionInstance, idx: number) => void,
+  ): void {
+    const instance = useExecutionStore().getInstance(instanceId)
+    if (!instance) return
+    const idx = stepIndex ?? resolve(instance)
+    if (idx < 0) return
+    open(instance, idx)
+  }
+
+  // Open the Follow-up companion window for a run's Coder step (the blinking chip + the
+  // `followup_pending` notification). Resolves the Coder step index from the run when not
+  // given, so callers that only know the run can still open it.
+  function openFollowUps(instanceId: string, stepIndex: number | null = null) {
+    withStep(
+      instanceId,
+      stepIndex,
+      // A pipeline may carry more than one follow-up-enabled Coder step, so don't blindly pick
+      // the first when no index is given: prefer the step that still has undecided items (the
+      // one the run is parked on), else the current step, else the first enabled one.
+      (instance) => {
+        const pending = indexOf(
+          instance,
+          (s) => !!s.followUps?.enabled && s.followUps.items.some((i) => i.status === 'pending'),
+        )
+        if (pending >= 0) return pending
+        const current = instance.steps[instance.currentStep]
+        if (current?.followUps?.enabled) return instance.currentStep
+        return indexOf(instance, (s) => !!s.followUps?.enabled)
+      },
+      (instance, idx) => deps.setResultView('follow-ups', instance, idx),
+    )
+  }
+
+  // Open the implementation-fork decision window for a run's coder step (from the inspector /
+  // pipeline chip / `fork_decision_pending` notification). Resolves the coder step index from
+  // the run when not given, preferring the step parked awaiting a choice.
+  function openForkDecision(instanceId: string, stepIndex: number | null = null) {
+    withStep(
+      instanceId,
+      stepIndex,
+      (instance) => {
+        const awaiting = indexOf(
+          instance,
+          (s) => s.agentKind === 'coder' && s.forkDecision?.status === 'awaiting_choice',
+        )
+        if (awaiting >= 0) return awaiting
+        const current = instance.steps[instance.currentStep]
+        if (current?.agentKind === 'coder' && current.forkDecision) return instance.currentStep
+        return indexOf(instance, (s) => s.agentKind === 'coder' && !!s.forkDecision)
+      },
+      (instance, idx) => deps.setResultView('fork-decision', instance, idx),
+    )
+  }
+
+  // Open the PR deep-review window for a run's `pr-reviewer` step (from the `pr_review_ready`
+  // notification / the step). Resolves the step index from the run when not given, preferring
+  // the step parked awaiting a finding selection.
+  function openPrReview(instanceId: string, stepIndex: number | null = null) {
+    withStep(
+      instanceId,
+      stepIndex,
+      (instance) => {
+        const awaiting = indexOf(
+          instance,
+          (s) => s.agentKind === 'pr-reviewer' && s.prReview?.status === 'awaiting_selection',
+        )
+        if (awaiting >= 0) return awaiting
+        const current = instance.steps[instance.currentStep]
+        if (current?.agentKind === 'pr-reviewer' && current.prReview) return instance.currentStep
+        return indexOf(instance, (s) => s.agentKind === 'pr-reviewer' && !!s.prReview)
+      },
+      (instance, idx) => deps.setResultView('pr-review', instance, idx),
+    )
+  }
+
+  // Open the Tester's result window for a run, where the screenshots and per-area outcomes it
+  // captured are rendered. The entry point is the `test-evidence` deep link the engine puts in
+  // every PR verification report's environment-lifecycle section, so the caller only ever knows
+  // the run.
+  function openTestEvidence(instanceId: string) {
+    withStep(
+      instanceId,
+      null,
+      // Prefer the tester step that actually REPORTED: a pipeline may carry more than one, and
+      // the later one describes the PR as it stands. Falling back to the first tester step opens
+      // the window on its "not run yet" state, which beats the link going nowhere.
+      (instance) => {
+        const candidates = instance.steps
+          .map((s, i) => ({ s, i }))
+          .filter(({ s }) => isTesterKind(s.agentKind))
+        const reported = candidates.filter(({ s }) => s.test?.lastReport)
+        return (reported.at(-1) ?? candidates[0])?.i ?? -1
+      },
+      // Routed through the universal dispatch rather than a fixed view id: a tester step running
+      // as a consensus panel opens the Consensus Session window instead, and this entry point
+      // must not override that.
+      (_instance, idx) => deps.dispatchStepView(instanceId, idx),
+    )
+  }
+
+  return { openFollowUps, openForkDecision, openPrReview, openTestEvidence }
+}

package/app/stores/ui.dispatch.spec.ts

@@ -96,4 +96,42 @@ describe('dispatchStepView routing', () => {
     expect(ui.resultView).toBeNull()
     expect(ui.stepDetail).toEqual({ instanceId: 'e1', stepIndex: 0 })
   })
+
+  // The `test-evidence` deep link the engine puts in every PR verification report knows only the
+  // RUN, so the opener has to resolve which tester step the reviewer was pointed at.
+  describe('openTestEvidence', () => {
+    it('opens the tester step that actually reported, not the first one', () => {
+      execution.hydrate(
+        [
+          instance('e1', 'b1', [
+            { agentKind: 'coder' },
+            { agentKind: 'tester-api' },
+            { agentKind: 'tester-ui', test: { lastReport: { greenlight: true } } },
+          ]),
+        ],
+        'ws1',
+      )
+
+      ui.openTestEvidence('e1')
+
+      expect(ui.resultView).toMatchObject({ view: 'tester', instanceId: 'e1', stepIndex: 2 })
+    })
+
+    it('still opens a tester step that has not reported, rather than going nowhere', () => {
+      execution.hydrate([instance('e1', 'b1', [{ agentKind: 'tester-api' }])], 'ws1')
+
+      ui.openTestEvidence('e1')
+
+      expect(ui.resultView).toMatchObject({ view: 'tester', stepIndex: 0 })
+    })
+
+    it('does nothing when the run carries no tester step at all', () => {
+      execution.hydrate([instance('e1', 'b1', [{ agentKind: 'coder' }])], 'ws1')
+
+      ui.openTestEvidence('e1')
+
+      expect(ui.resultView).toBeNull()
+      expect(ui.stepDetail).toBeNull()
+    })
+  })
 })

package/i18n/locales/de.json

@@ -578,6 +578,7 @@
       "storedAt": "Zuletzt gesetzt am {date}",
       "notStoredWithFallback": "Für dieses Board ist nichts gespeichert. Diese Installation liest den Schlüssel auch aus ihrer eigenen Umgebung, die Fähigkeit funktioniert also möglicherweise trotzdem.",
       "notStored": "Für dieses Board ist nichts gespeichert, und diese Installation hat keinen Rückfallwert aus der Umgebung. Die Fähigkeit kann sich daher nicht authentifizieren.",
+      "notStoredUnknownFallback": "Für dieses Board ist nichts gespeichert. Die Kette der Anmeldedaten dieser Installation lässt sich hier nicht beschreiben, daher ist nicht bekannt, ob der Schlüssel anderswo beantwortet wird.",
       "setValue": "Wert",
       "replaceValue": "Gespeicherten Wert ersetzen",
       "save": "Speichern",

package/i18n/locales/en.json

@@ -2951,6 +2951,7 @@
       "storedAt": "Last set {date}",
       "notStoredWithFallback": "Nothing stored for this board. This deployment also reads the key from its own environment, so the capability may still be working.",
       "notStored": "Nothing stored for this board, and this deployment has no environment fallback, so the capability cannot authenticate.",
+      "notStoredUnknownFallback": "Nothing stored for this board. This deployment's credential chain cannot be described here, so whether this key is answered elsewhere is not known.",
       "setValue": "Value",
       "replaceValue": "Replace the stored value",
       "save": "Save",

package/i18n/locales/es.json

@@ -2719,6 +2719,7 @@
       "storedAt": "Definida por última vez el {date}",
       "notStoredWithFallback": "No hay nada guardado para este tablero. Esta instalación también lee la clave de su propio entorno, así que la capacidad puede seguir funcionando.",
       "notStored": "No hay nada guardado para este tablero y esta instalación no tiene respaldo en el entorno, así que la capacidad no puede autenticarse.",
+      "notStoredUnknownFallback": "No hay nada guardado para este tablero. La cadena de credenciales de esta instalación no se puede describir aquí, así que no se sabe si la clave se responde en otro sitio.",
       "setValue": "Valor",
       "replaceValue": "Sustituir el valor guardado",
       "save": "Guardar",

package/i18n/locales/fr.json

@@ -2719,6 +2719,7 @@
       "storedAt": "Défini le {date}",
       "notStoredWithFallback": "Rien n'est enregistré pour ce tableau. Ce déploiement lit aussi la clé dans son propre environnement, la capacité fonctionne donc peut-être encore.",
       "notStored": "Rien n'est enregistré pour ce tableau et ce déploiement n'a pas de valeur de repli dans l'environnement : la capacité ne peut pas s'authentifier.",
+      "notStoredUnknownFallback": "Rien n'est enregistré pour ce tableau. La chaîne d'identifiants de ce déploiement ne peut pas être décrite ici : on ne sait donc pas si la clé est fournie ailleurs.",
       "setValue": "Valeur",
       "replaceValue": "Remplacer la valeur enregistrée",
       "save": "Enregistrer",

package/i18n/locales/he.json

@@ -2859,6 +2859,7 @@
       "storedAt": "הוגדר לאחרונה ב-{date}",
       "notStoredWithFallback": "לא נשמר דבר עבור הלוח הזה. הפריסה הזו קוראת את המפתח גם מהסביבה שלה, ולכן ייתכן שהיכולת עדיין פועלת.",
       "notStored": "לא נשמר דבר עבור הלוח הזה, ולפריסה הזו אין נפילה לסביבה, ולכן היכולת אינה יכולה לבצע אימות.",
+      "notStoredUnknownFallback": "לא נשמר דבר עבור הלוח הזה. לא ניתן לתאר כאן את שרשרת האישורים של הפריסה הזו, ולכן לא ידוע אם המפתח נענה במקום אחר.",
       "setValue": "ערך",
       "replaceValue": "החלפת הערך השמור",
       "save": "שמירה",

package/i18n/locales/it.json

@@ -578,6 +578,7 @@
       "storedAt": "Impostata l'ultima volta il {date}",
       "notStoredWithFallback": "Per questa board non è salvato nulla. Questo deployment legge la chiave anche dal proprio ambiente, quindi la capacità potrebbe funzionare comunque.",
       "notStored": "Per questa board non è salvato nulla e questo deployment non ha un ripiego sull'ambiente, quindi la capacità non può autenticarsi.",
+      "notStoredUnknownFallback": "Per questa board non è salvato nulla. La catena di credenziali di questo deployment non può essere descritta qui, quindi non si sa se la chiave venga fornita altrove.",
       "setValue": "Valore",
       "replaceValue": "Sostituisci il valore salvato",
       "save": "Salva",

package/i18n/locales/ja.json

@@ -2860,6 +2860,7 @@
       "storedAt": "最終設定: {date}",
       "notStoredWithFallback": "このボードには何も保存されていません。このデプロイは自身の環境からもこのキーを読み取るため、機能は動作している可能性があります。",
       "notStored": "このボードには何も保存されておらず、このデプロイには環境からのフォールバックもないため、機能は認証できません。",
+      "notStoredUnknownFallback": "このボードには何も保存されていません。このデプロイの資格情報チェーンはここでは説明できないため、このキーが別の場所で解決されるかどうかは分かりません。",
       "setValue": "値",
       "replaceValue": "保存済みの値を置き換える",
       "save": "保存",

package/i18n/locales/pl.json

@@ -2719,6 +2719,7 @@
       "storedAt": "Ostatnio ustawione {date}",
       "notStoredWithFallback": "Dla tej tablicy nic nie jest zapisane. To wdrożenie odczytuje klucz również z własnego środowiska, więc funkcja może nadal działać.",
       "notStored": "Dla tej tablicy nic nie jest zapisane, a to wdrożenie nie ma awaryjnego odczytu ze środowiska, więc funkcja nie może się uwierzytelnić.",
+      "notStoredUnknownFallback": "Dla tej tablicy nic nie jest zapisane. Łańcucha poświadczeń tego wdrożenia nie można tutaj opisać, więc nie wiadomo, czy klucz jest obsługiwany gdzie indziej.",
       "setValue": "Wartość",
       "replaceValue": "Zastąp zapisaną wartość",
       "save": "Zapisz",

package/i18n/locales/tr.json

@@ -2860,6 +2860,7 @@
       "storedAt": "Son ayarlanma: {date}",
       "notStoredWithFallback": "Bu pano için hiçbir şey saklanmıyor. Bu kurulum anahtarı kendi ortamından da okuyor, dolayısıyla yetenek hâlâ çalışıyor olabilir.",
       "notStored": "Bu pano için hiçbir şey saklanmıyor ve bu kurulumun ortam yedeği yok, dolayısıyla yetenek kimlik doğrulaması yapamaz.",
+      "notStoredUnknownFallback": "Bu pano için hiçbir şey saklanmıyor. Bu kurulumun kimlik bilgisi zinciri burada tanımlanamıyor, dolayısıyla anahtarın başka bir yerden karşılanıp karşılanmadığı bilinmiyor.",
       "setValue": "Değer",
       "replaceValue": "Saklanan değeri değiştir",
       "save": "Kaydet",

package/i18n/locales/uk.json

@@ -2719,6 +2719,7 @@
       "storedAt": "Востаннє задано {date}",
       "notStoredWithFallback": "Для цієї дошки нічого не збережено. Це розгортання також читає ключ із власного середовища, тож можливість може й далі працювати.",
       "notStored": "Для цієї дошки нічого не збережено, а запасного читання із середовища в цьому розгортанні немає, тож можливість не зможе пройти автентифікацію.",
+      "notStoredUnknownFallback": "Для цієї дошки нічого не збережено. Ланцюг облікових даних цього розгортання неможливо описати тут, тож невідомо, чи ключ надається деінде.",
       "setValue": "Значення",
       "replaceValue": "Замінити збережене значення",
       "save": "Зберегти",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.209.0",
+  "version": "0.210.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",
@@ -40,7 +40,7 @@
     "valibot": "^1.4.2",
     "vue": "3.5.40",
     "wretch": "^3.0.9",
-    "@cat-factory/contracts": "0.217.0"
+    "@cat-factory/contracts": "0.219.0"
   },
   "devDependencies": {
     "@toad-contracts/testing": "0.3.2",