@cat-factory/app 0.298.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/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/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/package.json

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