@cat-factory/app 0.297.0 → 0.299.0

package/README.md

@@ -1091,9 +1091,23 @@ event left to restore it.
   swaps that in. A missing trigger and an in-place patch are both SILENT, so
   `stores/execution.spec.ts` pins each write shape twice: once on the array, once through the
   `getInstance` chain a window actually reads.
+- **A record keyed by block id is written PER KEY, never replaced.** The review-family caches
+  (`requirements`, `clarity`, `brainstorm`, `consensus`, `docInterview`, `initiative`) are deep
+  reactive refs holding a `Record<blockId, T>`, so `x.value = { ...x.value, [id]: v }` is a write
+  to the REF: a dependency every reader shares, whatever key it reads. One review event therefore
+  woke every card on the board. `x.value[id] = v` keeps the invalidation on the key that changed,
+  and Vue still tracks a key read before it exists, so a first write reaches its waiting reader.
+  The exception is a HYDRATE, which replaces the record wholesale on purpose: a snapshot is
+  authoritative for EXISTENCE, so anything it omits has been deleted. This is the opposite rule
+  from `execution.instances` above, and for the opposite reason: that one is a `shallowRef`.
 - **Pin it with a store-level unit test** (`stores/workspace.spec.ts` for refreshes,
   `stores/workspace/refreshFunnel.spec.ts` for the funnel's own rules, `stores/execution.spec.ts`
-  for echoes): drive the two orderings and assert the fresher one wins.
+  for echoes): drive the two orderings and assert the fresher one wins. The per-key rule above has
+  one table for the whole family, `stores/perKeyWrites.spec.ts`: a store joining it is a row there,
+  and each row counts a `computed`'s evaluations across an event for a DIFFERENT block, plus the
+  first write to a key a reader read while it was absent. What the record is keyed BY is per store
+  (`stores/requirements.spec.ts` also covers the stage read, whose pending-recommendation half has
+  to answer off the block's own review object rather than a computed over the record).
 
 ## Internationalization (i18n) authoring
 

package/app/components/panels/inspector/ServiceSelfTests.vue

@@ -117,6 +117,7 @@ const CONFLICT_KEYS: Record<Extract<ConflictReason, `env_test_${string}`>, strin
   env_test_no_vcs: 'errors.conflict.title.env_test_no_vcs',
   env_test_connection_failed: 'errors.conflict.title.env_test_connection_failed',
   env_test_probe_unavailable: 'errors.conflict.title.env_test_probe_unavailable',
+  env_test_probe_model_unavailable: 'errors.conflict.title.env_test_probe_model_unavailable',
   env_test_already_running: 'errors.conflict.title.env_test_already_running',
   env_test_over_budget: 'errors.conflict.title.env_test_over_budget',
 }

package/app/composables/api/environments.ts

@@ -9,7 +9,7 @@ import type { EnvironmentTestMode, ProvisionEnvironmentInput } from '@cat-factor
 import type { ApiContext } from './context'
 
 /** Ephemeral environments: the workspace's live env handles (used to resolve frontend bindings). */
-export function environmentsApi({ send, ws }: ApiContext) {
+export function environmentsApi({ send, sendWith, ws, pwHeaders }: ApiContext) {
   return {
     listEnvironments: (workspaceId: string) =>
       send(listEnvironmentsContract, { pathPrefix: ws(workspaceId) }),
@@ -22,8 +22,18 @@ export function environmentsApi({ send, ws }: ApiContext) {
     // Ephemeral-environment self-test: start a full create-branch → provision → tear-down →
     // delete-branch cycle against a service frame, then read / stop its run. `mode` picks what it
     // exercises: the provisioning alone, or that plus an agent dry run against the environment.
-    startEnvironmentTest: (workspaceId: string, blockId: string, mode: EnvironmentTestMode) =>
-      send(startEnvironmentTestContract, {
+    //
+    // Carries the personal unlock password, because an `agent-probe` run spends a model call and
+    // the model comes from the workspace's preset, which can name a personal subscription
+    // (Claude). The backend only consults it when the resolved model needs one, so a provisioning
+    // self-test is unaffected.
+    startEnvironmentTest: (
+      workspaceId: string,
+      blockId: string,
+      mode: EnvironmentTestMode,
+      password?: string,
+    ) =>
+      sendWith(pwHeaders(password), startEnvironmentTestContract, {
         pathPrefix: ws(workspaceId),
         pathParams: { blockId },
         body: { mode },

package/app/composables/usePipelineErrorToast.ts

@@ -277,6 +277,15 @@ const CONFLICT_INFO: Record<Exclude<ConflictReason, BespokeConflictReason>, Conf
     titleKey: 'errors.conflict.title.env_test_probe_unavailable',
     descriptionKey: 'errors.conflict.description.env_test_probe_unavailable',
   },
+  // The frame's RESOLVED model cannot be dispatched: a provider the LLM proxy cannot serve, or a
+  // subscription-only model with no connected credential. Distinct from the reason above, whose
+  // gap is a container prerequisite: this deployment is wired and the workspace's own model preset
+  // names something unrunnable, so the remedy is in the model settings and the jump is worth
+  // offering. The specific cause rides `details.modelIssue`, which the funnel surfaces as detail.
+  env_test_probe_model_unavailable: {
+    titleKey: 'errors.conflict.title.env_test_probe_model_unavailable',
+    descriptionKey: 'errors.conflict.description.env_test_probe_model_unavailable',
+  },
   // A second self-test on a frame that already has one running. No ACTION: the remedy is to wait
   // for the run showing in the same panel, or to stop it with the button beside it.
   env_test_already_running: {

package/app/stores/brainstorm.ts

@@ -80,8 +80,13 @@ export const useBrainstormStore = defineStore('brainstorm', () => {
     return allSettled(session) && answeredCount(session) === 0
   }
 
+  /**
+   * Write one block+stage session into the cache, IN PLACE: per-key, never a whole-record clone.
+   * `sessions` is a deep reactive ref, so replacing the record retriggered every consumer keyed on
+   * an UNCHANGED key; assigning the key retriggers only the session that actually changed.
+   */
   function store(session: BrainstormSession) {
-    sessions.value = { ...sessions.value, [key(session.blockId, session.stage)]: session }
+    sessions.value[key(session.blockId, session.stage)] = session
   }
 
   /** Patch the cache from a live `brainstorm` stream event (newest wins per block+stage). */
@@ -122,7 +127,9 @@ export const useBrainstormStore = defineStore('brainstorm', () => {
       try {
         const session = await api.getBrainstorm(workspace.requireId(), blockId, stage)
         available.value = true
-        sessions.value = { ...sessions.value, [k]: session }
+        // By key like `store()`, and directly because a load resolving to "none exists" caches a
+        // null the getter reads as "fetched, absent".
+        sessions.value[k] = session
       } catch {
         available.value = false
       } finally {

package/app/stores/clarity.ts

@@ -83,8 +83,13 @@ export const useClarityStore = defineStore('clarity', () => {
     return allSettled(review) && answeredCount(review) === 0
   }
 
+  /**
+   * Write one block's review into the cache, IN PLACE: per-key, never a whole-record clone.
+   * `reviews` is a deep reactive ref, so replacing the record retriggered every consumer keyed on
+   * an UNCHANGED block; assigning the key retriggers only the block that actually changed.
+   */
   function store(review: ClarityReview) {
-    reviews.value = { ...reviews.value, [review.blockId]: review }
+    reviews.value[review.blockId] = review
   }
 
   /** Patch the cache from a live `clarity` stream event (newest wins per block). */
@@ -125,7 +130,9 @@ export const useClarityStore = defineStore('clarity', () => {
       try {
         const review = await api.getClarityReview(workspace.requireId(), blockId)
         available.value = true
-        reviews.value = { ...reviews.value, [blockId]: review }
+        // By key like `store()`, and directly because a load resolving to "none exists" caches a
+        // null the getter reads as "fetched, absent".
+        reviews.value[blockId] = review
       } catch {
         // 503 (feature off) or any error → hide the UI entry points.
         available.value = false

package/app/stores/consensus.ts

@@ -30,8 +30,13 @@ export const useConsensusStore = defineStore('consensus', () => {
     return loading.value.has(blockId)
   }
 
+  /**
+   * Write one block's session into the cache, IN PLACE: per-key, never a whole-record clone.
+   * `sessions` is a deep reactive ref, so replacing the record retriggered every consumer keyed on
+   * an UNCHANGED block; assigning the key retriggers only the block that actually changed.
+   */
   function store(session: ConsensusSession) {
-    sessions.value = { ...sessions.value, [session.blockId]: session }
+    sessions.value[session.blockId] = session
   }
 
   /** Patch the cache from a live `consensus` stream event (newest wins per block). */
@@ -62,7 +67,7 @@ export const useConsensusStore = defineStore('consensus', () => {
       if (session) {
         if (!existing || session.updatedAt >= existing.updatedAt) store(session)
       } else if (existing === undefined) {
-        sessions.value = { ...sessions.value, [blockId]: null }
+        sessions.value[blockId] = null
       }
     } catch {
       // Consensus off / no session — leave the cache as-is; the window shows its empty state.

package/app/stores/docInterview.ts

@@ -30,7 +30,9 @@ export const useDocInterviewStore = defineStore('docInterview', () => {
   function upsert(session: DocInterviewSession) {
     const existing = byBlock.value[session.blockId]
     if (existing && existing.updatedAt > session.updatedAt) return
-    byBlock.value = { ...byBlock.value, [session.blockId]: session }
+    // Per-key, never a whole-record clone: `byBlock` is a deep reactive ref, so replacing the
+    // record retriggered every consumer keyed on an UNCHANGED block.
+    byBlock.value[session.blockId] = session
   }
 
   /** Re-fetch one block's session (the interview window's load path). */

package/app/stores/environmentTest.spec.ts

@@ -1,10 +1,12 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest'
 import type { EnvironmentTestRun } from '~/types/domain'
 import { useEnvironmentTestStore } from '~/stores/environmentTest'
+import { usePersonalSubscriptionsStore } from '~/stores/personalSubscriptions'
+import { useWorkspaceStore } from '~/stores/workspace'
 
 // The store resolves `useApi()` at setup; override the inert global stub from
 // `test/setup.ts` with a per-suite mock so the hydrate reconcile point-read is observable.
-const apiMock = { getEnvironmentTest: vi.fn() }
+const apiMock = { getEnvironmentTest: vi.fn(), startEnvironmentTest: vi.fn() }
 vi.stubGlobal('useApi', () => apiMock)
 
 /** Minimal EnvironmentTestRun factory — only the fields the store's reconcile logic touches. */
@@ -28,6 +30,46 @@ function run(id: string, over: Partial<EnvironmentTestRun> = {}): EnvironmentTes
   }
 }
 
+describe('environmentTest store: starting a run that may need a personal credential', () => {
+  let store: ReturnType<typeof useEnvironmentTestStore>
+  let withCredential: ReturnType<typeof vi.fn>
+
+  beforeEach(() => {
+    useWorkspaceStore().workspaceId = 'ws_test'
+    // The gate's contract, stubbed on the real store: run the action with the cached password, and
+    // resolve `false` when the person cancels the unlock prompt.
+    withCredential = vi.fn(async (action: (password?: string) => Promise<void>) => {
+      await action('cached-password')
+      return true
+    })
+    usePersonalSubscriptionsStore().withCredential = withCredential as unknown as ReturnType<
+      typeof usePersonalSubscriptionsStore
+    >['withCredential']
+    apiMock.startEnvironmentTest = vi.fn(async () => run('envtest_1', { mode: 'agent-probe' }))
+    store = useEnvironmentTestStore()
+  })
+
+  it('rides the unlock password, so a preset-resolved Claude dry run can lease it', async () => {
+    // Ungated, an `agent-probe` start 428s and the person is never asked for anything: the
+    // failure they see is a dry run that provisioned an environment and then could not open a
+    // credential nobody unlocked.
+    const started = await store.start('blk_1', 'agent-probe')
+    expect(apiMock.startEnvironmentTest).toHaveBeenCalledWith(
+      'ws_test',
+      'blk_1',
+      'agent-probe',
+      'cached-password',
+    )
+    expect(started?.id).toBe('envtest_1')
+    expect(store.runById('envtest_1')).toBeTruthy()
+  })
+
+  it('reports a cancelled unlock as no run, so the caller stops waiting for one', async () => {
+    withCredential.mockImplementation(async () => false)
+    expect(await store.start('blk_1', 'agent-probe')).toBeNull()
+  })
+})
+
 describe('environmentTest store — monotonic run reconcile', () => {
   let store: ReturnType<typeof useEnvironmentTestStore>
   beforeEach(() => {

package/app/stores/environmentTest.ts

@@ -3,6 +3,7 @@ import { ref } from 'vue'
 import type { EnvironmentTestMode } from '@cat-factory/contracts'
 import type { EnvironmentTestRun } from '~/types/domain'
 import { useWorkspaceStore } from '~/stores/workspace'
+import { usePersonalSubscriptionsStore } from '~/stores/personalSubscriptions'
 
 /**
  * Ephemeral-environment self-test runs, in both modes: the provisioning self-test and the AGENT
@@ -129,12 +130,31 @@ export const useEnvironmentTestStore = defineStore('environmentTest', () => {
     return runs.value.find((r) => r.blockId === blockId && r.mode === mode)
   }
 
-  /** Start a self-test against a service frame; the returned run is tracked immediately. */
-  async function start(blockId: string, mode: EnvironmentTestMode): Promise<EnvironmentTestRun> {
+  /**
+   * Start a self-test against a service frame; the returned run is tracked immediately.
+   *
+   * Gated through `withCredential`, like every other surface that starts agent work: an AGENT DRY
+   * RUN resolves its model from the workspace's model preset, which can name an individual-usage
+   * subscription (Claude), and such a credential is only leasable with the owner's unlock
+   * password. The cached password rides the first attempt and a `428` opens the modal; the
+   * provisioning self-test spends no model call, so the backend never consults it there.
+   *
+   * `null` when the person cancels the prompt: the run never started, so the caller reverts its
+   * spinner rather than waiting for a run that is not coming.
+   */
+  async function start(
+    blockId: string,
+    mode: EnvironmentTestMode,
+  ): Promise<EnvironmentTestRun | null> {
     const ws = useWorkspaceStore()
-    const run = await api.startEnvironmentTest(ws.requireId(), blockId, mode)
-    upsert(run)
-    return run
+    const personal = usePersonalSubscriptionsStore()
+    let started: EnvironmentTestRun | null = null
+    const ok = await personal.withCredential(async (password) => {
+      const run = await api.startEnvironmentTest(ws.requireId(), blockId, mode, password)
+      upsert(run)
+      started = run
+    })
+    return ok ? started : null
   }
 
   /** Stop a running self-test (best-effort cleanup, then failed). */

package/app/stores/initiative.ts

@@ -96,7 +96,10 @@ export const useInitiativesStore = defineStore('initiatives', () => {
   function upsert(initiative: Initiative) {
     const existing = byBlock.value[initiative.blockId]
     if (existing && existing.rev > initiative.rev) return
-    byBlock.value = { ...byBlock.value, [initiative.blockId]: initiative }
+    // Per-key, never a whole-record clone: `byBlock` is a deep reactive ref, so replacing the
+    // record retriggered every consumer keyed on an UNCHANGED block. {@link hydrate} still
+    // replaces it wholesale, because a snapshot is authoritative for EXISTENCE.
+    byBlock.value[initiative.blockId] = initiative
   }
 
   /**

package/app/stores/notifications.ts

@@ -16,8 +16,8 @@ import { useWorkspaceStore } from '~/stores/workspace'
  * Open, human-actionable notifications surfaced on the board (a PR awaiting a
  * merge decision, a completed pipeline awaiting confirmation, CI that gave up).
  * Hydrated from the workspace snapshot and patched live by the `notification`
- * WorkspaceEvent (see `useWorkspaceStream`). The board renders an inbox + a
- * per-block badge from `open` / `byBlock`.
+ * WorkspaceEvent (see `useWorkspaceStream`). The board renders an inbox from `open`, and the
+ * per-block review-wait stamps the swimlanes need from {@link reviewDebtByBlock}.
  */
 export const useNotificationsStore = defineStore('notifications', () => {
   const api = useApi()
@@ -110,16 +110,6 @@ export const useNotificationsStore = defineStore('notifications', () => {
     upsertOpen(notification)
   }
 
-  /** Open notifications for a given block (for the board card badge). */
-  const byBlock = computed<Record<string, Notification[]>>(() => {
-    const map: Record<string, Notification[]> = {}
-    for (const n of open.value) {
-      if (!n.blockId) continue
-      ;(map[n.blockId] ??= []).push(n)
-    }
-    return map
-  })
-
   /**
    * Per-block "waiting since", derived from the open review-wait cards by the same
    * `collectReviewDebt` the backend's friction check uses. It is the fallback source for the park
@@ -213,7 +203,6 @@ export const useNotificationsStore = defineStore('notifications', () => {
     hydrate,
     hydrateBaseline,
     upsert,
-    byBlock,
     reviewDebtByBlock,
     count,
     act,

package/app/stores/perKeyWrites.spec.ts

@@ -0,0 +1,168 @@
+import { describe, it, expect } from 'vitest'
+import { computed } from 'vue'
+import type { BrainstormSession } from '~/types/brainstorm'
+import type { ClarityReview } from '~/types/clarity'
+import type { ConsensusSession } from '~/types/consensus'
+import type { DocInterviewSession, Initiative } from '~/types/domain'
+import type { RequirementReview } from '~/types/requirements'
+import { useBrainstormStore } from '~/stores/brainstorm'
+import { useClarityStore } from '~/stores/clarity'
+import { useConsensusStore } from '~/stores/consensus'
+import { useDocInterviewStore } from '~/stores/docInterview'
+import { useInitiativesStore } from '~/stores/initiative'
+import { useRequirementsStore } from '~/stores/requirements'
+
+// The review-family stores all hold a `Record<blockId, T>` in a DEEP reactive ref and all patch it
+// from a live stream event. `x.value = { ...x.value, [id]: v }` is a write to the REF, a dependency
+// every reader shares whatever key it reads, so one event woke every card on the board;
+// `x.value[id] = v` keeps the invalidation on the key that changed. The rule is stated once in
+// `frontend/app/README.md` ("A record keyed by block id is written PER KEY, never replaced").
+//
+// One table rather than six near-identical specs, because the property is one property and a store
+// that JOINS this family should have exactly one obvious place to be added. Each row asserts the
+// two halves that can regress independently: an event for another block does not invalidate this
+// block's reader, and a FIRST write still reaches a reader that read the key while it was absent
+// (Vue tracks a missing-key read, which is what makes the in-place write safe at all).
+
+interface StoreCase {
+  name: string
+  /** Patch the store from a live event for `blockId`, tagged with `mark` so the read can see it. */
+  write: (blockId: string, mark: string) => void
+  /** What a card renders off that block: the tag, or null when the store holds nothing. */
+  read: (blockId: string) => string | null
+}
+
+const cases: StoreCase[] = [
+  {
+    name: 'requirements',
+    write: (blockId, mark) => {
+      useRequirementsStore().upsert({
+        id: mark,
+        blockId,
+        status: 'ready',
+        iteration: 1,
+        maxIterations: 3,
+        items: [],
+        updatedAt: 1,
+      } as unknown as RequirementReview)
+    },
+    read: (blockId) => useRequirementsStore().reviewFor(blockId)?.id ?? null,
+  },
+  {
+    name: 'clarity',
+    write: (blockId, mark) => {
+      useClarityStore().upsert({
+        id: mark,
+        blockId,
+        status: 'ready',
+        items: [],
+        updatedAt: 1,
+      } as unknown as ClarityReview)
+    },
+    read: (blockId) => useClarityStore().reviewFor(blockId)?.id ?? null,
+  },
+  {
+    name: 'brainstorm',
+    // Keyed by block+STAGE, so a block legitimately holds one live session per stage; the
+    // invalidation still has to land on the one composite key that changed.
+    write: (blockId, mark) => {
+      useBrainstormStore().upsert({
+        id: mark,
+        blockId,
+        stage: 'requirements',
+        status: 'ready',
+        options: [],
+        updatedAt: 1,
+      } as unknown as BrainstormSession)
+    },
+    read: (blockId) => useBrainstormStore().sessionFor(blockId, 'requirements')?.id ?? null,
+  },
+  {
+    name: 'consensus',
+    write: (blockId, mark) => {
+      useConsensusStore().upsert({
+        id: mark,
+        blockId,
+        status: 'complete',
+        participants: [],
+        rounds: [],
+        synthesis: null,
+        createdAt: 1,
+        updatedAt: 1,
+      } as unknown as ConsensusSession)
+    },
+    read: (blockId) => useConsensusStore().sessionFor(blockId)?.id ?? null,
+  },
+  {
+    name: 'docInterview',
+    write: (blockId, mark) => {
+      useDocInterviewStore().upsert({
+        id: mark,
+        blockId,
+        status: 'awaiting_answers',
+        round: 1,
+        maxRounds: 3,
+        qa: [],
+        createdAt: 1,
+        updatedAt: 1,
+      } as unknown as DocInterviewSession)
+    },
+    read: (blockId) => useDocInterviewStore().forBlock(blockId)?.id ?? null,
+  },
+  {
+    name: 'initiative',
+    write: (blockId, mark) => {
+      useInitiativesStore().upsert({
+        id: mark,
+        blockId,
+        slug: 'i',
+        title: 'I',
+        rev: 1,
+      } as unknown as Initiative)
+    },
+    read: (blockId) => useInitiativesStore().forBlock(blockId)?.id ?? null,
+  },
+]
+
+describe.each(cases)('$name store per-key writes', ({ write, read }) => {
+  it('an event for one block does not invalidate a consumer reading another', () => {
+    write('blk-a', 'a1')
+
+    let evaluations = 0
+    const forA = computed(() => {
+      evaluations++
+      return read('blk-a')
+    })
+    expect(forA.value).toBe('a1')
+    expect(evaluations).toBe(1)
+
+    // A brand-new key, then a rewrite of that existing one: neither is about `blk-a`.
+    write('blk-b', 'b1')
+    expect(forA.value).toBe('a1')
+    write('blk-b', 'b2')
+    expect(forA.value).toBe('a1')
+    expect(evaluations).toBe(1)
+
+    // The block's OWN event still reaches it.
+    write('blk-a', 'a2')
+    expect(forA.value).toBe('a2')
+    expect(evaluations).toBe(2)
+  })
+
+  it('a FIRST write reaches a reader that read the key while it was absent', () => {
+    // The half an in-place write could plausibly lose: the reader tracked a key that did not
+    // exist. Vue tracks a missing-key read, so ADDING the key notifies it. Without this the
+    // window a card opens before its first event would render its empty state forever.
+    let evaluations = 0
+    const forC = computed(() => {
+      evaluations++
+      return read('blk-c')
+    })
+    expect(forC.value).toBeNull()
+    expect(evaluations).toBe(1)
+
+    write('blk-c', 'c1')
+    expect(forC.value).toBe('c1')
+    expect(evaluations).toBe(2)
+  })
+})

package/app/stores/requirements/recommendations.ts

@@ -20,6 +20,31 @@ export interface RecommendationCommandContext {
   hasPendingRecommendations: (blockId: string) => boolean
 }
 
+/**
+ * Whether the Requirement Writer is still producing recommendations for THIS review: a `pending`
+ * placeholder exists. Server-derived, so the "Recommending…" state survives the window closing
+ * and a page reload; the client-local `recommending` set only covers the request round-trip.
+ *
+ * Memoised on the review OBJECT, like the settlement tallies next door, and for the same reason:
+ * the store REPLACES the review on every write, so identity self-invalidates and a superseded
+ * review is collected along with its answer.
+ *
+ * Per REVIEW rather than per record, which is the whole point. `backgroundStage` asks this on the
+ * per-CARD path, and a `computed` over the `reviews` record tracks the ref plus every key in it,
+ * so one review event would re-evaluate every card's stage, the fan-out the per-key write exists
+ * to remove. Reading one key depends on one key.
+ */
+const pendingByReview = new WeakMap<RequirementReview, boolean>()
+
+export function awaitsRecommendations(review: RequirementReview): boolean {
+  let pending = pendingByReview.get(review)
+  if (pending === undefined) {
+    pending = (review.recommendations ?? []).some((r) => r.status === 'pending')
+    pendingByReview.set(review, pending)
+  }
+  return pending
+}
+
 /** Ask for, accept, reject and re-request the Requirement Writer's suggested answers. */
 export function createRecommendationCommands(ctx: RecommendationCommandContext) {
   const { api, workspace, recommending, withFlag, store, hasPendingRecommendations } = ctx

package/app/stores/requirements.spec.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest'
-import type { RequirementReview } from '~/types/requirements'
+import { computed } from 'vue'
+import type { RequirementRecommendation, RequirementReview } from '~/types/requirements'
 import { useRequirementsStore } from '~/stores/requirements'
 import { useWorkspaceStore } from '~/stores/workspace'
 
@@ -18,6 +19,20 @@ function review(over: Partial<RequirementReview> = {}): RequirementReview {
   } as RequirementReview
 }
 
+/** A `pending` Writer placeholder: the state `backgroundStage` reads as "recommending". */
+function pendingRecommendation(id: string): RequirementRecommendation {
+  return {
+    id,
+    sourceFinding: { title: 'f', detail: 'd', itemId: 'i1' },
+    recommendedText: '',
+    status: 'pending',
+    note: null,
+    groundedInFragment: null,
+    createdAt: 1,
+    updatedAt: 1,
+  } as RequirementRecommendation
+}
+
 describe('requirements store load() loading flag', () => {
   beforeEach(() => {
     // The store resolves its workspace id from the workspace store at call time.
@@ -113,3 +128,76 @@ describe('requirements store live-event upsert guard', () => {
     expect(store.reviewFor('b1')?.id).toBe('rr2')
   })
 })
+
+describe('requirements store per-key writes', () => {
+  it('an event for one block does not invalidate a consumer reading another', () => {
+    // Every card on the board reads its OWN block's review (the "Recommending…"/gate badge), so
+    // one review event used to wake every card: the store replaced the whole record, which is a
+    // write to the ref itself and therefore a dependency every reader shares. Writing the key
+    // keeps the invalidation on the block that changed.
+    const store = useRequirementsStore()
+    store.upsert(review({ id: 'rr-a', blockId: 'blk-a', updatedAt: 1 }))
+
+    let evaluations = 0
+    const forA = computed(() => {
+      evaluations++
+      return store.reviewFor('blk-a')?.id ?? null
+    })
+    expect(forA.value).toBe('rr-a')
+    expect(evaluations).toBe(1)
+
+    // A brand-new key, then a rewrite of an existing one: neither is about `blk-a`.
+    store.upsert(review({ id: 'rr-b', blockId: 'blk-b', updatedAt: 1 }))
+    expect(forA.value).toBe('rr-a')
+    store.upsert(review({ id: 'rr-b', blockId: 'blk-b', updatedAt: 2 }))
+    expect(forA.value).toBe('rr-a')
+    expect(evaluations).toBe(1)
+
+    // The block's OWN event still reaches it.
+    store.upsert(review({ id: 'rr-a2', blockId: 'blk-a', updatedAt: 2 }))
+    expect(forA.value).toBe('rr-a2')
+    expect(evaluations).toBe(2)
+  })
+
+  it('the per-card STAGE read depends on one block too, pending recommendations included', () => {
+    // `backgroundStage` is the read every card actually makes (TaskCard/BlockNode via
+    // `useReviewStage`), and it is the one the per-key write alone does not fix: while the pending
+    // -recommendation answer came from a `computed` over the whole `reviews` record, that computed
+    // tracked every key, so one event still re-evaluated the stage of every card on the board.
+    // Answering off the block's own review object is what closes it.
+    const store = useRequirementsStore()
+    store.upsert(review({ id: 'rr-a', blockId: 'blk-a', updatedAt: 1 }))
+
+    let evaluations = 0
+    const stageForA = computed(() => {
+      evaluations++
+      return store.backgroundStage('blk-a')
+    })
+    expect(stageForA.value).toBeNull()
+    expect(evaluations).toBe(1)
+
+    // Another block starts recommending: not this card's business.
+    store.upsert(
+      review({
+        id: 'rr-b',
+        blockId: 'blk-b',
+        updatedAt: 1,
+        recommendations: [pendingRecommendation('rec-1')],
+      }),
+    )
+    expect(stageForA.value).toBeNull()
+    expect(evaluations).toBe(1)
+
+    // This block's own placeholder still surfaces the working state.
+    store.upsert(
+      review({
+        id: 'rr-a2',
+        blockId: 'blk-a',
+        updatedAt: 2,
+        recommendations: [pendingRecommendation('rec-2')],
+      }),
+    )
+    expect(stageForA.value).toBe('recommending')
+    expect(evaluations).toBe(2)
+  })
+})

package/app/stores/requirements.ts

@@ -1,5 +1,5 @@
 import { defineStore } from 'pinia'
-import { computed, ref } from 'vue'
+import { ref } from 'vue'
 import type {
   RequirementReview,
   ResolveRequirementsExceededChoice,
@@ -16,7 +16,10 @@ import {
   canProceed,
   openCount,
 } from '~/stores/requirements/settlement'
-import { createRecommendationCommands } from '~/stores/requirements/recommendations'
+import {
+  awaitsRecommendations,
+  createRecommendationCommands,
+} from '~/stores/requirements/recommendations'
 
 /**
  * Requirements-review state. On the pipeline path the reviewer runs as the first gate
@@ -55,24 +58,16 @@ export const useRequirementsStore = defineStore('requirements', () => {
   function reviewFor(blockId: string): RequirementReview | null {
     return reviews.value[blockId] ?? null
   }
-  /** Whether the Requirement Writer is still producing recommendations for a block (a `pending`
-   * placeholder exists). Server-derived, so the "Recommending…" state survives the window closing
-   * and a page reload — the client-local `recommending` set only covers the request round-trip. */
   /**
-   * Blocks whose stored review still carries a `pending` recommendation placeholder, derived once
-   * per change to `reviews` rather than per call. {@link backgroundStage} asks this on the per-CARD
-   * path, so as a function it re-scanned one review's recommendation list for every card on the
-   * board on every event.
+   * Whether the Requirement Writer is still producing recommendations for a block. Reads ONE key
+   * and answers off the review object itself ({@link awaitsRecommendations} memoises the scan on
+   * that object), so a card asking about its own block depends only on its own block. A `computed`
+   * over the whole record would be the fan-out again: it tracks every key, so one review event
+   * would re-evaluate the stage of every card on the board.
    */
-  const blocksAwaitingRecommendations = computed(() => {
-    const blocks = new Set<string>()
-    for (const [blockId, review] of Object.entries(reviews.value)) {
-      if ((review?.recommendations ?? []).some((r) => r.status === 'pending')) blocks.add(blockId)
-    }
-    return blocks
-  })
   function hasPendingRecommendations(blockId: string): boolean {
-    return blocksAwaitingRecommendations.value.has(blockId)
+    const review = reviews.value[blockId]
+    return review ? awaitsRecommendations(review) : false
   }
   /**
    * The async background stage a block's review is in, or null. While the driver folds the
@@ -96,8 +91,16 @@ export const useRequirementsStore = defineStore('requirements', () => {
     return incorporating.value.has(reviewId)
   }
 
+  /**
+   * Write one block's review into the cache, IN PLACE.
+   *
+   * Per-key, never a whole-record clone: `reviews` is a deep reactive ref, so a consumer reading
+   * `reviews[someBlockId]` depends on THAT key. Replacing the record retriggered every one of
+   * them (a card, a badge, an inspector panel for an untouched block) on every event; assigning
+   * the key retriggers only the consumers of the block that actually changed.
+   */
   function store(review: RequirementReview) {
-    reviews.value = { ...reviews.value, [review.blockId]: review }
+    reviews.value[review.blockId] = review
   }
 
   /** Patch the cache from a live `requirements` stream event (newest wins per block). */
@@ -139,7 +142,9 @@ export const useRequirementsStore = defineStore('requirements', () => {
       try {
         const review = await api.getRequirementReview(workspace.requireId(), blockId)
         available.value = true
-        reviews.value = { ...reviews.value, [blockId]: review }
+        // Written by key like `store()`, and directly because a load resolving to "none exists"
+        // caches a null the getter reads as "fetched, absent".
+        reviews.value[blockId] = review
       } catch {
         // 503 (feature off) or any error → hide the UI entry points.
         available.value = false

package/i18n/locales/de.json

@@ -6200,6 +6200,7 @@
         "env_test_no_vcs": "Git-Anbieter nicht verbunden",
         "env_test_connection_failed": "Umgebungsverbindung fehlgeschlagen",
         "env_test_probe_unavailable": "Agenten-Probeläufe hier nicht verfügbar",
+        "env_test_probe_model_unavailable": "Modell für den Probelauf nicht ausführbar",
         "env_test_already_running": "Selbsttest läuft bereits",
         "env_test_over_budget": "Ausgabenbudget erreicht",
         "prompt_revision_conflict": "Prompt von jemand anderem geändert",
@@ -6251,7 +6252,8 @@
         "env_test_no_vcs": "Der Selbsttest benötigt einen Git-Anbieter, um seinen Wegwerf-Branch zu erstellen und zu löschen, aber dieser Workspace ist mit keinem verbunden.",
         "env_test_connection_failed": "Der Umgebungs-Handler dieses Dienstes hat seinen Verbindungstest nicht bestanden. Prüfen Sie Endpunkt, Anmeldedaten und Projekteinstellungen und testen Sie die Verbindung erneut.",
         "env_test_connection_failed_detail": "Der Umgebungs-Handler dieses Dienstes hat seinen Verbindungstest nicht bestanden: {detail}. Prüfen Sie Endpunkt, Anmeldedaten und Projekteinstellungen und testen Sie die Verbindung erneut.",
-        "env_test_probe_unavailable": "Ein Agenten-Probelauf benötigt einen Container-Runner, ein verbundenes Repository und ein Modell, das der LLM-Proxy dieses Deployments bereitstellen kann. Hier fehlt eines davon, daher lässt sich nur der Bereitstellungs-Selbsttest ausführen.",
+        "env_test_probe_unavailable": "Ein Agenten-Probelauf benötigt einen Container-Runner und ein verbundenes Repository. Hier fehlt eines davon, daher lässt sich nur der Bereitstellungs-Selbsttest ausführen.",
+        "env_test_probe_model_unavailable": "Der Probelauf dieses Dienstes verweist auf ein Modell, das diese Installation nicht ausführen kann: entweder kann der LLM-Proxy dessen Anbieter nicht bedienen, oder es braucht ein Abonnement, das niemand verbunden hat. Ändern Sie das Modell-Preset für den Prüfagenten (oder das am Rahmen fixierte Modell), oder verbinden Sie das Abonnement. Der Bereitstellungs-Selbsttest braucht kein Modell und läuft weiterhin.",
         "env_test_already_running": "Für diesen Dienst läuft bereits ein Selbsttest. Jeder stellt seine eigene Wegwerf-Umgebung bereit, daher läuft immer nur einer. Warten Sie, bis er fertig ist, oder stoppen Sie ihn zuerst.",
         "env_test_over_budget": "Ein Agenten-Probelauf ist ein kostenpflichtiger Modellaufruf, und dieser Workspace hat sein Ausgabenbudget erreicht. Erhöhen Sie das Budget oder warten Sie auf den nächsten Abrechnungszeitraum. Der Bereitstellungs-Selbsttest kostet nichts und läuft weiterhin.",
         "prompt_revision_conflict": "Eine andere Änderung an diesem Prompt war zuerst da. Laden Sie ihn neu und wenden Sie Ihre Änderung darauf erneut an.",

package/i18n/locales/en.json

@@ -767,6 +767,7 @@
         "env_test_no_vcs": "Git provider not connected",
         "env_test_connection_failed": "Environment connection failed",
         "env_test_probe_unavailable": "Agent dry runs not available here",
+        "env_test_probe_model_unavailable": "Dry run model cannot run",
         "env_test_already_running": "Self-test already running",
         "env_test_over_budget": "Spend budget reached",
         "prompt_revision_conflict": "Prompt changed by someone else",
@@ -818,7 +819,8 @@
         "env_test_no_vcs": "The self-test needs a git provider to create and delete its throwaway branch, but this workspace isn't connected to one.",
         "env_test_connection_failed": "The environment handler for this service failed its connection test. Check its endpoint, credentials and project settings, then re-test the connection.",
         "env_test_connection_failed_detail": "The environment handler for this service failed its connection test: {detail}. Check its endpoint, credentials and project settings, then re-test the connection.",
-        "env_test_probe_unavailable": "An agent dry run needs a container runner, a connected repository and a model this deployment's LLM proxy can serve. One of them is missing here, so only the provisioning self-test can run.",
+        "env_test_probe_unavailable": "An agent dry run needs a container runner and a connected repository. One of them is missing here, so only the provisioning self-test can run.",
+        "env_test_probe_model_unavailable": "This service's dry run resolves to a model this deployment cannot dispatch: either the LLM proxy cannot serve its provider, or it needs a subscription no one has connected. Change the model preset for the prober (or the frame's own pinned model), or connect the subscription. The provisioning self-test needs no model and still runs.",
         "env_test_already_running": "A self-test is already running for this service. Each one provisions its own throwaway environment, so only one runs at a time. Wait for it to finish, or stop it first.",
         "env_test_over_budget": "An agent dry run is a billable model call, and this workspace has reached a spend budget. Raise the budget or wait for the billing period to reset. The provisioning self-test costs nothing and still runs.",
         "@env_test_connection_failed_detail": {

package/i18n/locales/es.json

@@ -689,6 +689,7 @@
         "env_test_no_vcs": "Proveedor de Git no conectado",
         "env_test_connection_failed": "Fallo de conexión del entorno",
         "env_test_probe_unavailable": "Las ejecuciones en seco del agente no están disponibles aquí",
+        "env_test_probe_model_unavailable": "El modelo del ensayo no puede ejecutarse",
         "env_test_already_running": "Ya hay una autoprueba en curso",
         "env_test_over_budget": "Presupuesto de gasto alcanzado",
         "prompt_revision_conflict": "Otra persona cambió el prompt",
@@ -740,7 +741,8 @@
         "env_test_no_vcs": "La autoprueba necesita un proveedor de Git para crear y eliminar su rama desechable, pero este espacio de trabajo no está conectado a ninguno.",
         "env_test_connection_failed": "El gestor de entornos de este servicio no superó su prueba de conexión. Revisa su endpoint, sus credenciales y la configuración del proyecto, y vuelve a probar la conexión.",
         "env_test_connection_failed_detail": "El gestor de entornos de este servicio no superó su prueba de conexión: {detail}. Revisa su endpoint, sus credenciales y la configuración del proyecto, y vuelve a probar la conexión.",
-        "env_test_probe_unavailable": "Una ejecución en seco del agente necesita un ejecutor de contenedores, un repositorio conectado y un modelo que el proxy LLM de este despliegue pueda servir. Aquí falta uno de ellos, así que solo puede ejecutarse la autoprueba de aprovisionamiento.",
+        "env_test_probe_unavailable": "Una ejecución en seco del agente necesita un ejecutor de contenedores y un repositorio conectado. Aquí falta uno de ellos, así que solo puede ejecutarse la autoprueba de aprovisionamiento.",
+        "env_test_probe_model_unavailable": "El ensayo de este servicio resuelve a un modelo que este despliegue no puede lanzar: o el proxy de LLM no puede atender a su proveedor, o necesita una suscripción que nadie ha conectado. Cambie el preajuste de modelo del sondeador (o el modelo fijado en el marco), o conecte la suscripción. La autoprueba de aprovisionamiento no necesita modelo y sigue funcionando.",
         "env_test_already_running": "Ya se está ejecutando una autoprueba para este servicio. Cada una aprovisiona su propio entorno desechable, así que solo se ejecuta una a la vez. Espera a que termine o deténla primero.",
         "env_test_over_budget": "Una prueba de agente es una llamada de modelo facturable y este espacio de trabajo ha alcanzado su presupuesto de gasto. Aumenta el presupuesto o espera al siguiente periodo de facturación. La autoprueba de aprovisionamiento no cuesta nada y sigue funcionando.",
         "prompt_revision_conflict": "Otra edición de este prompt llegó primero. Recárgalo y vuelve a aplicar tu cambio encima.",

package/i18n/locales/fr.json

@@ -689,6 +689,7 @@
         "env_test_no_vcs": "Fournisseur Git non connecté",
         "env_test_connection_failed": "Échec de la connexion à l'environnement",
         "env_test_probe_unavailable": "Essais à blanc d'agent indisponibles ici",
+        "env_test_probe_model_unavailable": "Le modèle du test à blanc ne peut pas être exécuté",
         "env_test_already_running": "Auto-test déjà en cours",
         "env_test_over_budget": "Budget de dépenses atteint",
         "prompt_revision_conflict": "Invite modifiée par quelqu'un d'autre",
@@ -740,7 +741,8 @@
         "env_test_no_vcs": "L'auto-test a besoin d'un fournisseur Git pour créer et supprimer sa branche jetable, mais cet espace de travail n'est connecté à aucun.",
         "env_test_connection_failed": "Le gestionnaire d'environnement de ce service a échoué à son test de connexion. Vérifiez son point de terminaison, ses identifiants et les paramètres du projet, puis retestez la connexion.",
         "env_test_connection_failed_detail": "Le gestionnaire d'environnement de ce service a échoué à son test de connexion : {detail}. Vérifiez son point de terminaison, ses identifiants et les paramètres du projet, puis retestez la connexion.",
-        "env_test_probe_unavailable": "Un essai à blanc d'agent nécessite un exécuteur de conteneurs, un dépôt connecté et un modèle que le proxy LLM de ce déploiement peut servir. L'un d'eux manque ici, donc seul l'autotest de provisionnement peut s'exécuter.",
+        "env_test_probe_unavailable": "Un essai à blanc d'agent nécessite un exécuteur de conteneurs et un dépôt connecté. L'un d'eux manque ici, donc seul l'autotest de provisionnement peut s'exécuter.",
+        "env_test_probe_model_unavailable": "Le test à blanc de ce service pointe vers un modèle que ce déploiement ne peut pas lancer : soit le proxy LLM ne prend pas en charge son fournisseur, soit il faut un abonnement que personne n'a connecté. Changez le préréglage de modèle du sondeur (ou le modèle épinglé sur le cadre), ou connectez l'abonnement. L'autotest de provisionnement n'a besoin d'aucun modèle et continue de fonctionner.",
         "env_test_already_running": "Un auto-test est déjà en cours pour ce service. Chacun provisionne son propre environnement jetable, donc un seul s'exécute à la fois. Attendez qu'il se termine ou arrêtez-le d'abord.",
         "env_test_over_budget": "Un essai à blanc d'agent est un appel de modèle facturé, et cet espace de travail a atteint son budget de dépenses. Augmentez le budget ou attendez la prochaine période de facturation. L'auto-test de provisionnement ne coûte rien et reste disponible.",
         "prompt_revision_conflict": "Une autre modification de cette invite est arrivée en premier. Rechargez-la et réappliquez la vôtre par-dessus.",

package/i18n/locales/he.json

@@ -689,6 +689,7 @@
         "env_test_no_vcs": "ספק Git אינו מחובר",
         "env_test_connection_failed": "החיבור לסביבה נכשל",
         "env_test_probe_unavailable": "הרצות יבשות של סוכן אינן זמינות כאן",
+        "env_test_probe_model_unavailable": "לא ניתן להריץ את המודל של הרצת היובש",
         "env_test_already_running": "בדיקה עצמית כבר פועלת",
         "env_test_over_budget": "הגעתם לתקרת התקציב",
         "prompt_revision_conflict": "ההנחיה שונתה על ידי מישהו אחר",
@@ -740,7 +741,8 @@
         "env_test_no_vcs": "הבדיקה העצמית זקוקה לספק Git כדי ליצור ולמחוק את הענף החד-פעמי שלה, אך סביבת עבודה זו אינה מחוברת לאף אחד.",
         "env_test_connection_failed": "מנהל הסביבה של שירות זה נכשל בבדיקת החיבור. בדקו את נקודת הקצה, פרטי ההזדהות והגדרות הפרויקט, ולאחר מכן בדקו שוב את החיבור.",
         "env_test_connection_failed_detail": "מנהל הסביבה של שירות זה נכשל בבדיקת החיבור: {detail}. בדקו את נקודת הקצה, פרטי ההזדהות והגדרות הפרויקט, ולאחר מכן בדקו שוב את החיבור.",
-        "env_test_probe_unavailable": "הרצה יבשה של סוכן דורשת מריץ קונטיינרים, מאגר מחובר ומודל שפרוקסי ה-LLM של הפריסה הזו יכול לשרת. כאן חסר אחד מהם, ולכן אפשר להריץ רק את הבדיקה העצמית של הקמת הסביבה.",
+        "env_test_probe_unavailable": "הרצה יבשה של סוכן דורשת מריץ קונטיינרים ומאגר מחובר. כאן חסר אחד מהם, ולכן אפשר להריץ רק את הבדיקה העצמית של הקמת הסביבה.",
+        "env_test_probe_model_unavailable": "הרצת היובש של השירות הזה מפנה למודל שהפריסה הזאת אינה יכולה להריץ: או שפרוקסי ה-LLM אינו מסוגל לשרת את הספק שלו, או שנדרש מנוי שאף אחד לא חיבר. שנו את פריסט המודל של הבודק (או את המודל המוצמד למסגרת), או חברו את המנוי. הבדיקה העצמית של ההקצאה אינה זקוקה למודל וממשיכה לרוץ.",
         "env_test_already_running": "בדיקה עצמית כבר פועלת עבור שירות זה. כל בדיקה מקצה סביבה זמנית משלה, ולכן רק אחת פועלת בכל רגע. המתינו לסיומה או עצרו אותה תחילה.",
         "env_test_over_budget": "הרצת ניסיון של סוכן היא קריאת מודל בתשלום, וסביבת העבודה הזו הגיעה לתקרת התקציב. הגדילו את התקציב או המתינו לתקופת החיוב הבאה. הבדיקה העצמית של ההקצאה אינה עולה דבר וממשיכה לפעול.",
         "prompt_revision_conflict": "עריכה אחרת של ההנחיה הזו נקלטה קודם. טענו אותה מחדש והחילו את השינוי שלכם מעליה.",

package/i18n/locales/it.json

@@ -6200,6 +6200,7 @@
         "env_test_no_vcs": "Provider Git non connesso",
         "env_test_connection_failed": "Connessione all'ambiente non riuscita",
         "env_test_probe_unavailable": "Prove a vuoto dell'agente non disponibili qui",
+        "env_test_probe_model_unavailable": "Il modello della prova a vuoto non è eseguibile",
         "env_test_already_running": "Autotest già in esecuzione",
         "env_test_over_budget": "Budget di spesa raggiunto",
         "prompt_revision_conflict": "Prompt modificato da qualcun altro",
@@ -6251,7 +6252,8 @@
         "env_test_no_vcs": "L'autotest ha bisogno di un provider Git per creare ed eliminare il suo branch usa e getta, ma questo workspace non è collegato a nessuno.",
         "env_test_connection_failed": "Il gestore dell'ambiente di questo servizio non ha superato il test di connessione. Controlla endpoint, credenziali e impostazioni del progetto, poi ripeti il test della connessione.",
         "env_test_connection_failed_detail": "Il gestore dell'ambiente di questo servizio non ha superato il test di connessione: {detail}. Controlla endpoint, credenziali e impostazioni del progetto, poi ripeti il test della connessione.",
-        "env_test_probe_unavailable": "Una prova a vuoto dell’agente richiede un runner di container, un repository collegato e un modello che il proxy LLM di questo deployment possa servire. Qui ne manca uno, quindi può essere eseguito solo l’autotest di provisioning.",
+        "env_test_probe_unavailable": "Una prova a vuoto dell’agente richiede un runner di container e un repository collegato. Qui ne manca uno, quindi può essere eseguito solo l’autotest di provisioning.",
+        "env_test_probe_model_unavailable": "La prova a vuoto di questo servizio punta a un modello che questa installazione non può avviare: il proxy LLM non supporta il suo provider, oppure serve un abbonamento che nessuno ha collegato. Cambia il preset del modello per il sondatore (o il modello fissato sul riquadro), oppure collega l’abbonamento. L’autotest di provisioning non richiede alcun modello e continua a funzionare.",
         "env_test_already_running": "È già in esecuzione un autotest per questo servizio. Ognuno effettua il provisioning del proprio ambiente temporaneo, quindi ne viene eseguito uno alla volta. Attendi che finisca oppure interrompilo.",
         "env_test_over_budget": "Una prova a vuoto dell'agente è una chiamata al modello a pagamento e questo workspace ha raggiunto il budget di spesa. Aumenta il budget o attendi il prossimo periodo di fatturazione. L'autotest di provisioning non ha costi e resta disponibile.",
         "prompt_revision_conflict": "Un'altra modifica a questo prompt è arrivata prima. Ricaricalo e riapplica la tua sopra.",

package/i18n/locales/ja.json

@@ -689,6 +689,7 @@
         "env_test_no_vcs": "Git プロバイダーが未接続です",
         "env_test_connection_failed": "環境への接続に失敗しました",
         "env_test_probe_unavailable": "ここではエージェントのドライランを利用できません",
+        "env_test_probe_model_unavailable": "ドライランのモデルを実行できません",
         "env_test_already_running": "セルフテストは既に実行中です",
         "env_test_over_budget": "利用予算の上限に達しました",
         "prompt_revision_conflict": "別のユーザーがプロンプトを変更しました",
@@ -740,7 +741,8 @@
         "env_test_no_vcs": "セルフテストは使い捨てブランチの作成と削除のために Git プロバイダーを必要としますが、このワークスペースはいずれにも接続されていません。",
         "env_test_connection_failed": "このサービスの環境ハンドラーが接続テストに失敗しました。エンドポイント、認証情報、プロジェクト設定を確認してから、接続を再テストしてください。",
         "env_test_connection_failed_detail": "このサービスの環境ハンドラーが接続テストに失敗しました: {detail}。エンドポイント、認証情報、プロジェクト設定を確認してから、接続を再テストしてください。",
-        "env_test_probe_unavailable": "エージェントのドライランには、コンテナーランナー、接続済みのリポジトリ、そしてこのデプロイの LLM プロキシが提供できるモデルが必要です。いずれかが欠けているため、ここではプロビジョニングの自己テストのみ実行できます。",
+        "env_test_probe_unavailable": "エージェントのドライランには、コンテナーランナーと接続済みのリポジトリが必要です。いずれかが欠けているため、ここではプロビジョニングの自己テストのみ実行できます。",
+        "env_test_probe_model_unavailable": "このサービスのドライランは、このデプロイでは実行できないモデルに解決されます。LLM プロキシがそのプロバイダーに対応していないか、誰も接続していないサブスクリプションが必要です。プローブ用のモデルプリセット（またはフレームに固定されたモデル）を変更するか、サブスクリプションを接続してください。プロビジョニングのセルフテストはモデルを必要とせず、引き続き実行できます。",
         "env_test_already_running": "このサービスではすでにセルフテストが実行中です。各テストは独自の使い捨て環境をプロビジョニングするため、同時に実行できるのは 1 つだけです。終了を待つか、先に停止してください。",
         "env_test_over_budget": "エージェントのドライランは課金対象のモデル呼び出しであり、このワークスペースは利用予算の上限に達しています。予算を引き上げるか、次の請求期間までお待ちください。プロビジョニングのセルフテストは無料で、引き続き実行できます。",
         "prompt_revision_conflict": "このプロンプトへの別の編集が先に反映されました。読み込み直して、その上に変更をやり直してください。",

package/i18n/locales/pl.json

@@ -689,6 +689,7 @@
         "env_test_no_vcs": "Dostawca Git nie jest połączony",
         "env_test_connection_failed": "Połączenie ze środowiskiem nie powiodło się",
         "env_test_probe_unavailable": "Próbne przebiegi agenta są tu niedostępne",
+        "env_test_probe_model_unavailable": "Nie można uruchomić modelu próbnego przebiegu",
         "env_test_already_running": "Autotest już trwa",
         "env_test_over_budget": "Osiągnięto limit wydatków",
         "prompt_revision_conflict": "Prompt zmieniony przez kogoś innego",
@@ -740,7 +741,8 @@
         "env_test_no_vcs": "Autotest potrzebuje dostawcy Git, aby utworzyć i usunąć swoją jednorazową gałąź, ale ta przestrzeń robocza nie jest połączona z żadnym.",
         "env_test_connection_failed": "Obsługa środowiska dla tej usługi nie przeszła testu połączenia. Sprawdź jej punkt końcowy, poświadczenia i ustawienia projektu, a następnie ponownie przetestuj połączenie.",
         "env_test_connection_failed_detail": "Obsługa środowiska dla tej usługi nie przeszła testu połączenia: {detail}. Sprawdź jej punkt końcowy, poświadczenia i ustawienia projektu, a następnie ponownie przetestuj połączenie.",
-        "env_test_probe_unavailable": "Próbny przebieg agenta wymaga runnera kontenerów, podłączonego repozytorium i modelu, który potrafi obsłużyć proxy LLM tego wdrożenia. Brakuje tu jednego z nich, więc można uruchomić tylko autotest przydzielania środowiska.",
+        "env_test_probe_unavailable": "Próbny przebieg agenta wymaga runnera kontenerów i podłączonego repozytorium. Brakuje tu jednego z nich, więc można uruchomić tylko autotest przydzielania środowiska.",
+        "env_test_probe_model_unavailable": "Próbny przebieg tej usługi wskazuje model, którego to wdrożenie nie może uruchomić: albo proxy LLM nie obsługuje jego dostawcy, albo potrzebna jest subskrypcja, której nikt nie podłączył. Zmień preset modelu dla sondy (lub model przypięty do ramki) albo podłącz subskrypcję. Autotest udostępniania nie potrzebuje modelu i nadal działa.",
         "env_test_already_running": "Dla tej usługi już trwa autotest. Każdy z nich udostępnia własne środowisko jednorazowe, więc naraz działa tylko jeden. Poczekaj na zakończenie albo najpierw go zatrzymaj.",
         "env_test_over_budget": "Próbny przebieg agenta to płatne wywołanie modelu, a ten obszar roboczy osiągnął limit wydatków. Zwiększ limit albo poczekaj na nowy okres rozliczeniowy. Autotest aprowizacji nic nie kosztuje i nadal działa.",
         "prompt_revision_conflict": "Inna zmiana tego promptu trafiła pierwsza. Wczytaj go ponownie i nanieś swoją zmianę na wierzch.",

package/i18n/locales/tr.json

@@ -689,6 +689,7 @@
         "env_test_no_vcs": "Git sağlayıcısı bağlı değil",
         "env_test_connection_failed": "Ortam bağlantısı başarısız",
         "env_test_probe_unavailable": "Aracı prova çalışmaları burada kullanılamıyor",
+        "env_test_probe_model_unavailable": "Prova çalıştırmasının modeli çalıştırılamıyor",
         "env_test_already_running": "Kendi kendine test zaten çalışıyor",
         "env_test_over_budget": "Harcama bütçesine ulaşıldı",
         "prompt_revision_conflict": "İstem başka biri tarafından değiştirildi",
@@ -740,7 +741,8 @@
         "env_test_no_vcs": "Öz test, tek kullanımlık dalını oluşturup silmek için bir Git sağlayıcısına ihtiyaç duyar ancak bu çalışma alanı hiçbirine bağlı değil.",
         "env_test_connection_failed": "Bu hizmetin ortam işleyicisi bağlantı testini geçemedi. Uç noktasını, kimlik bilgilerini ve proje ayarlarını kontrol edin, ardından bağlantıyı yeniden test edin.",
         "env_test_connection_failed_detail": "Bu hizmetin ortam işleyicisi bağlantı testini geçemedi: {detail}. Uç noktasını, kimlik bilgilerini ve proje ayarlarını kontrol edin, ardından bağlantıyı yeniden test edin.",
-        "env_test_probe_unavailable": "Aracı prova çalışması bir konteyner çalıştırıcısı, bağlı bir depo ve bu kurulumun LLM proxy'sinin sunabileceği bir model gerektirir. Burada bunlardan biri eksik, bu yüzden yalnızca ortam hazırlama öz testi çalıştırılabilir.",
+        "env_test_probe_unavailable": "Aracı prova çalışması bir konteyner çalıştırıcısı ve bağlı bir depo gerektirir. Burada bunlardan biri eksik, bu yüzden yalnızca ortam hazırlama öz testi çalıştırılabilir.",
+        "env_test_probe_model_unavailable": "Bu servisin prova çalıştırması, bu kurulumun başlatamayacağı bir modele çözümleniyor: ya LLM proxy’si sağlayıcısını sunamıyor ya da kimsenin bağlamadığı bir abonelik gerekiyor. Sonda için model ön ayarını (ya da çerçeveye sabitlenmiş modeli) değiştirin veya aboneliği bağlayın. Sağlama öz testi model gerektirmez ve çalışmaya devam eder.",
         "env_test_already_running": "Bu hizmet için zaten bir kendi kendine test çalışıyor. Her biri kendi tek kullanımlık ortamını hazırladığı için aynı anda yalnızca biri çalışır. Bitmesini bekleyin veya önce durdurun.",
         "env_test_over_budget": "Aracı deneme çalıştırması ücretli bir model çağrısıdır ve bu çalışma alanı harcama bütçesine ulaşmıştır. Bütçeyi artırın veya yeni faturalandırma dönemini bekleyin. Sağlama kendi kendine testi ücretsizdir ve çalışmaya devam eder.",
         "prompt_revision_conflict": "Bu isteme yapılan başka bir düzenleme önce ulaştı. Yeniden yükleyip değişikliğinizi onun üzerine uygulayın.",

package/i18n/locales/uk.json

@@ -689,6 +689,7 @@
         "env_test_no_vcs": "Провайдер Git не підключено",
         "env_test_connection_failed": "Не вдалося підключитися до середовища",
         "env_test_probe_unavailable": "Пробні запуски агента тут недоступні",
+        "env_test_probe_model_unavailable": "Модель пробного запуску неможливо запустити",
         "env_test_already_running": "Самоперевірка вже виконується",
         "env_test_over_budget": "Досягнуто ліміт витрат",
         "prompt_revision_conflict": "Промпт змінив хтось інший",
@@ -740,7 +741,8 @@
         "env_test_no_vcs": "Самоперевірці потрібен постачальник Git, щоб створити та видалити свою тимчасову гілку, але цей робочий простір не під'єднано до жодного.",
         "env_test_connection_failed": "Обробник середовища для цієї служби не пройшов перевірку підключення. Перевірте його кінцеву точку, облікові дані та налаштування проєкту, а потім повторіть перевірку підключення.",
         "env_test_connection_failed_detail": "Обробник середовища для цієї служби не пройшов перевірку підключення: {detail}. Перевірте його кінцеву точку, облікові дані та налаштування проєкту, а потім повторіть перевірку підключення.",
-        "env_test_probe_unavailable": "Пробний запуск агента потребує виконавця контейнерів, підключеного репозиторію та моделі, яку може обслужити LLM-проксі цього розгортання. Тут чогось із цього бракує, тому можна виконати лише самоперевірку створення середовища.",
+        "env_test_probe_unavailable": "Пробний запуск агента потребує виконавця контейнерів і підключеного репозиторія. Тут чогось із цього бракує, тому можна виконати лише самоперевірку створення середовища.",
+        "env_test_probe_model_unavailable": "Пробний запуск цієї служби вказує на модель, яку це розгортання не може запустити: або LLM-проксі не обслуговує її постачальника, або потрібна підписка, яку ніхто не підключив. Змініть пресет моделі для зонда (або модель, закріплену за рамкою), або підключіть підписку. Самоперевірка розгортання не потребує моделі й продовжує працювати.",
         "env_test_already_running": "Для цієї служби вже виконується самоперевірка. Кожна створює власне тимчасове середовище, тому одночасно виконується лише одна. Дочекайтеся завершення або спершу зупиніть її.",
         "env_test_over_budget": "Пробний запуск агента є платним викликом моделі, а цей робочий простір досяг ліміту витрат. Збільште ліміт або дочекайтеся нового платіжного періоду. Самоперевірка створення середовища нічого не коштує і працює далі.",
         "prompt_revision_conflict": "Інша правка цього промпту надійшла першою. Перезавантажте його й накладіть свою зміну зверху.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.297.0",
+  "version": "0.299.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",
@@ -18,14 +18,14 @@
     "access": "public"
   },
   "dependencies": {
-    "@cat-factory/contracts": "0.348.0",
+    "@cat-factory/contracts": "0.349.0",
     "@modular-frontend/core": "0.6.0",
     "@modular-vue/core": "^1.5.0",
     "@modular-vue/journeys": "^1.4.0",
     "@modular-vue/nuxt": "^0.4.1",
     "@modular-vue/runtime": "^1.4.1",
     "@modular-vue/vue": "^1.4.1",
-    "@nuxt/ui": "^4.11.0",
+    "@nuxt/ui": "^4.11.1",
     "@nuxtjs/i18n": "^10.6.0",
     "@pinia/nuxt": "^1.0.2",
     "@toad-contracts/core": "0.4.0",