@cat-factory/app 0.153.3 → 0.153.4

package/app/stores/initiative/planning.ts

@@ -0,0 +1,121 @@
+import type { Ref } from 'vue'
+import { ref } from 'vue'
+import type { Initiative } from '~/types/domain'
+import { useWorkspaceStore } from '~/stores/workspace'
+
+/**
+ * Shared reactive state + injected dependencies the initiatives-store action factories close
+ * over. Created once in the `initiatives` store setup and threaded into
+ * {@link createInitiativePlanningActions} / {@link createInitiativeCurationActions} so the split
+ * operations stay behaviourally identical to the original single-closure store — a size-only
+ * extraction mirroring `stores/board/` and `stores/pipelines/`, not a new seam.
+ */
+export interface InitiativeActionContext {
+  api: ReturnType<typeof useApi>
+  workspace: ReturnType<typeof useWorkspaceStore>
+  /** Patch an entity a call returned into the by-block cache (newest rev wins). */
+  upsert: (initiative: Initiative) => void
+}
+
+/**
+ * The planning-window actions: answering / dismissing the interviewer's questions, asking it to
+ * recommend an answer, and the two loop-resuming controls (continue / proceed). Owns the
+ * in-flight flags the window renders its spinners from.
+ */
+export function createInitiativePlanningActions(ctx: InitiativeActionContext) {
+  const { api, workspace, upsert } = ctx
+
+  /** True while a planning-window action (continue/proceed) is resuming the run. */
+  const resuming = ref(false)
+  /** Question ids the interviewer is currently drafting a recommendation for (window spinner). */
+  const recommending: Ref<Set<string>> = ref(new Set())
+
+  /** Record the human's answer to one pending interview question (no run resume). */
+  async function answerQuestion(blockId: string, questionId: string, answer: string) {
+    if (!workspace.workspaceId) throw new Error('No active workspace')
+    const updated = await api.answerInitiativeQuestion(
+      workspace.workspaceId,
+      blockId,
+      questionId,
+      answer,
+    )
+    upsert(updated)
+    return updated
+  }
+
+  /** Mark a planning question not-relevant (`dismissed`) or reopen it (no run resume). */
+  async function setQuestionStatus(
+    blockId: string,
+    questionId: string,
+    status: 'open' | 'dismissed',
+  ) {
+    if (!workspace.workspaceId) throw new Error('No active workspace')
+    const updated = await api.setInitiativeQuestionStatus(
+      workspace.workspaceId,
+      blockId,
+      questionId,
+      status,
+    )
+    upsert(updated)
+    return updated
+  }
+
+  /**
+   * Ask the interviewer to recommend a suggested answer for one pending question. Runs the
+   * interviewer LLM inline server-side; the returned entity carries the suggestion on the question.
+   * Tracks the in-flight id so the window can show a per-question spinner.
+   */
+  async function recommendAnswer(blockId: string, questionId: string) {
+    if (!workspace.workspaceId) throw new Error('No active workspace')
+    recommending.value = new Set(recommending.value).add(questionId)
+    try {
+      const updated = await api.recommendInitiativeAnswer(
+        workspace.workspaceId,
+        blockId,
+        questionId,
+      )
+      upsert(updated)
+      return updated
+    } finally {
+      const next = new Set(recommending.value)
+      next.delete(questionId)
+      recommending.value = next
+    }
+  }
+
+  /** Submit the answers and resume the interview (the interviewer re-runs, may ask more). */
+  async function continuePlanning(blockId: string) {
+    if (!workspace.workspaceId) throw new Error('No active workspace')
+    resuming.value = true
+    try {
+      const updated = await api.continueInitiativePlanning(workspace.workspaceId, blockId)
+      upsert(updated)
+      return updated
+    } finally {
+      resuming.value = false
+    }
+  }
+
+  /** Skip remaining questions: the interviewer converges and the run advances. */
+  async function proceedPlanning(blockId: string) {
+    if (!workspace.workspaceId) throw new Error('No active workspace')
+    resuming.value = true
+    try {
+      const updated = await api.proceedInitiativePlanning(workspace.workspaceId, blockId)
+      upsert(updated)
+      return updated
+    } finally {
+      resuming.value = false
+    }
+  }
+
+  return {
+    resuming,
+    recommending,
+    answerQuestion,
+    setQuestionStatus,
+    recommendAnswer,
+    continuePlanning,
+    proceedPlanning,
+  }
+}

package/app/stores/initiative.ts

@@ -1,16 +1,14 @@
 import { defineStore } from 'pinia'
 import { computed, ref } from 'vue'
-import type {
-  Initiative,
-  InitiativeExecutionPolicy,
-  InitiativePresetDescriptor,
-  InitiativePresetInputs,
-  PromoteInitiativeFollowUpInput,
-  UpdateInitiativeItemInput,
-} from '~/types/domain'
+import type { Initiative, InitiativePresetDescriptor, InitiativePresetInputs } from '~/types/domain'
 
 import { useWorkspaceStore } from '~/stores/workspace'
 import { useBoardStore } from '~/stores/board'
+import {
+  createInitiativePlanningActions,
+  type InitiativeActionContext,
+} from '~/stores/initiative/planning'
+import { createInitiativeCurationActions } from '~/stores/initiative/curation'
 
 /** The built-in generic preset id (mirrors kernel's `GENERIC_INITIATIVE_PRESET_ID`). */
 export const GENERIC_PRESET_ID = 'preset_generic'
@@ -165,91 +163,6 @@ export const useInitiativesStore = defineStore('initiatives', () => {
     }
   }
 
-  /** True while a planning-window action (continue/proceed) is resuming the run. */
-  const resuming = ref(false)
-
-  /** Record the human's answer to one pending interview question (no run resume). */
-  async function answerQuestion(blockId: string, questionId: string, answer: string) {
-    if (!workspace.workspaceId) throw new Error('No active workspace')
-    const updated = await api.answerInitiativeQuestion(
-      workspace.workspaceId,
-      blockId,
-      questionId,
-      answer,
-    )
-    upsert(updated)
-    return updated
-  }
-
-  /** Question ids the interviewer is currently drafting a recommendation for (window spinner). */
-  const recommending = ref<Set<string>>(new Set())
-
-  /** Mark a planning question not-relevant (`dismissed`) or reopen it (no run resume). */
-  async function setQuestionStatus(
-    blockId: string,
-    questionId: string,
-    status: 'open' | 'dismissed',
-  ) {
-    if (!workspace.workspaceId) throw new Error('No active workspace')
-    const updated = await api.setInitiativeQuestionStatus(
-      workspace.workspaceId,
-      blockId,
-      questionId,
-      status,
-    )
-    upsert(updated)
-    return updated
-  }
-
-  /**
-   * Ask the interviewer to recommend a suggested answer for one pending question. Runs the
-   * interviewer LLM inline server-side; the returned entity carries the suggestion on the question.
-   * Tracks the in-flight id so the window can show a per-question spinner.
-   */
-  async function recommendAnswer(blockId: string, questionId: string) {
-    if (!workspace.workspaceId) throw new Error('No active workspace')
-    recommending.value = new Set(recommending.value).add(questionId)
-    try {
-      const updated = await api.recommendInitiativeAnswer(
-        workspace.workspaceId,
-        blockId,
-        questionId,
-      )
-      upsert(updated)
-      return updated
-    } finally {
-      const next = new Set(recommending.value)
-      next.delete(questionId)
-      recommending.value = next
-    }
-  }
-
-  /** Submit the answers and resume the interview (the interviewer re-runs, may ask more). */
-  async function continuePlanning(blockId: string) {
-    if (!workspace.workspaceId) throw new Error('No active workspace')
-    resuming.value = true
-    try {
-      const updated = await api.continueInitiativePlanning(workspace.workspaceId, blockId)
-      upsert(updated)
-      return updated
-    } finally {
-      resuming.value = false
-    }
-  }
-
-  /** Skip remaining questions: the interviewer converges and the run advances. */
-  async function proceedPlanning(blockId: string) {
-    if (!workspace.workspaceId) throw new Error('No active workspace')
-    resuming.value = true
-    try {
-      const updated = await api.proceedInitiativePlanning(workspace.workspaceId, blockId)
-      upsert(updated)
-      return updated
-    } finally {
-      resuming.value = false
-    }
-  }
-
   /** True while a loop control (pause/resume/cancel) is in flight. */
   const controlling = ref(false)
 
@@ -272,76 +185,12 @@ export const useInitiativesStore = defineStore('initiatives', () => {
     }
   }
 
-  /** True while a curation action (promote/dismiss/edit item/edit policy) is in flight. */
-  const curating = ref(false)
-
-  async function curate<T>(fn: () => Promise<T>): Promise<T> {
-    if (!workspace.workspaceId) throw new Error('No active workspace')
-    curating.value = true
-    try {
-      return await fn()
-    } finally {
-      curating.value = false
-    }
-  }
-
-  /** Promote an `open` harvested follow-up into a new pending tracker item. */
-  async function promoteFollowUp(
-    initiativeId: string,
-    followUpId: string,
-    input: PromoteInitiativeFollowUpInput,
-  ) {
-    return curate(async () => {
-      const updated = await api.promoteInitiativeFollowUp(
-        workspace.workspaceId!,
-        initiativeId,
-        followUpId,
-        input,
-      )
-      upsert(updated)
-      return updated
-    })
-  }
-
-  /** Dismiss a harvested follow-up. */
-  async function dismissFollowUp(initiativeId: string, followUpId: string) {
-    return curate(async () => {
-      const updated = await api.dismissInitiativeFollowUp(
-        workspace.workspaceId!,
-        initiativeId,
-        followUpId,
-      )
-      upsert(updated)
-      return updated
-    })
-  }
-
-  /** Edit one tracker item and/or drive its status (retry a blocked item / skip it). */
-  async function updateItem(
-    initiativeId: string,
-    itemId: string,
-    input: UpdateInitiativeItemInput,
-  ) {
-    return curate(async () => {
-      const updated = await api.updateInitiativeItem(
-        workspace.workspaceId!,
-        initiativeId,
-        itemId,
-        input,
-      )
-      upsert(updated)
-      return updated
-    })
-  }
-
-  /** Replace the execution policy (concurrency + pipeline rules). */
-  async function updatePolicy(initiativeId: string, policy: InitiativeExecutionPolicy) {
-    return curate(async () => {
-      const updated = await api.updateInitiativePolicy(workspace.workspaceId!, initiativeId, policy)
-      upsert(updated)
-      return updated
-    })
-  }
+  // The planning-window + tracker-curation actions, split into cohesive factories sharing the
+  // state above (a size-only extraction mirroring `stores/board/` — behaviour is identical to the
+  // former in-closure functions). Each owns the in-flight flags its window renders.
+  const context: InitiativeActionContext = { api, workspace, upsert }
+  const planning = createInitiativePlanningActions(context)
+  const curation = createInitiativeCurationActions(context)
 
   function reset() {
     byBlock.value = {}
@@ -353,10 +202,7 @@ export const useInitiativesStore = defineStore('initiatives', () => {
     presets,
     all,
     creating,
-    resuming,
     controlling,
-    curating,
-    recommending,
     forBlock,
     presetById,
     planningPipelineIdFor,
@@ -366,16 +212,9 @@ export const useInitiativesStore = defineStore('initiatives', () => {
     create,
     probePreset,
     load,
-    answerQuestion,
-    setQuestionStatus,
-    recommendAnswer,
-    continuePlanning,
-    proceedPlanning,
     control,
-    promoteFollowUp,
-    dismissFollowUp,
-    updateItem,
-    updatePolicy,
+    ...planning,
+    ...curation,
     reset,
   }
 })

package/app/stores/workspace/hydrate.ts

@@ -0,0 +1,105 @@
+import type { WorkspaceSnapshot } from '~/types/domain'
+import { useAgentConfigStore } from '~/stores/agentConfig'
+import { useAgentRunsStore } from '~/stores/agentRuns'
+import { useAgentsStore } from '~/stores/agents'
+import { useBoardStore } from '~/stores/board'
+import { useBrainstormStore } from '~/stores/brainstorm'
+import { useClarityStore } from '~/stores/clarity'
+import { useConsensusStore } from '~/stores/consensus'
+import { useEnvironmentTestStore } from '~/stores/environmentTest'
+import { useExecutionStore } from '~/stores/execution'
+import { useFragmentsStore } from '~/stores/fragments'
+import { useGitHubStore } from '~/stores/github'
+import { useInitiativesStore } from '~/stores/initiative'
+import { useModelPresetsStore } from '~/stores/modelPresets'
+import { useNotificationsStore } from '~/stores/notifications'
+import { usePipelinesStore } from '~/stores/pipelines'
+import { useProviderConnectionsStore } from '~/stores/providerConnections'
+import { useRecurringPipelinesStore } from '~/stores/recurringPipelines'
+import { useRequirementsStore } from '~/stores/requirements'
+import { useRiskPoliciesStore } from '~/stores/riskPolicies'
+import { useServiceFragmentDefaultsStore } from '~/stores/serviceFragmentDefaults'
+import { useServicesStore } from '~/stores/services'
+import { useSharedStacksStore } from '~/stores/sharedStacks'
+import { useSkillsStore } from '~/stores/skills'
+import { useTaskTypesStore } from '~/stores/taskTypes'
+import { useTrackerStore } from '~/stores/tracker'
+import { useWorkspaceSettingsStore } from '~/stores/workspaceSettings'
+import { buildWorkspaceCapabilitiesManifest } from '~/modular/capabilities'
+
+/**
+ * Drop the per-block caches that are NOT part of the snapshot (reviews, brainstorm/consensus
+ * sessions, the GitHub projection) so a switched-to board never shows the previous one's stale
+ * state. These are lazily reloaded/re-probed per board, so clearing on a same-board refresh
+ * would needlessly wipe an open review window — hence only on an actual id change.
+ */
+export function resetPerBoardCaches() {
+  useRequirementsStore().reset()
+  useClarityStore().reset()
+  useBrainstormStore().reset()
+  useConsensusStore().reset()
+  useGitHubStore().reset()
+  useInitiativesStore().reset()
+  useDocInterviewStore().reset()
+  // The fragment picker catalog is per-board (the merged tenant catalog), so drop
+  // it too — the next inspector open re-fetches it for the switched-to board rather
+  // than showing the previous board's (or a raw-id placeholder for) fragments.
+  useFragmentsStore().invalidate()
+}
+
+/**
+ * Fan a workspace snapshot out into the per-feature data stores. Extracted verbatim from the
+ * `workspace` store's `hydrate` (which keeps the workspace-scoped state it owns + the
+ * board-switch cache reset) so the ordering of the hydrate calls is preserved exactly — a
+ * size-only split, not a new seam.
+ *
+ * `boardSince` (captured BEFORE this snapshot's fetch) lets the board store preserve any block
+ * live-`upsert`ed while the fetch was in flight, so a slower refresh can't clobber a newer live
+ * status (see `useBoardStore().hydrate`).
+ */
+export function applySnapshotToStores(snapshot: WorkspaceSnapshot, boardSince?: number) {
+  useUserSettingsStore().hydrate(snapshot.userSettings ?? null)
+  useBoardStore().hydrate(snapshot.blocks, boardSince)
+  useBoardStore().hydrateArchived(snapshot.archivedServices ?? [])
+  usePipelinesStore().hydrate(snapshot.pipelines, snapshot.pipelineCatalogVersions)
+  useExecutionStore().hydrate(snapshot.executions, snapshot.workspace.id)
+  useAgentRunsStore().hydrate(snapshot.bootstrapJobs ?? [], snapshot.workspace.id)
+  useAgentRunsStore().hydrateEnvConfigRepair(snapshot.envConfigRepairJobs ?? [])
+  useEnvironmentTestStore().hydrate(snapshot.environmentTestRuns ?? [], snapshot.workspace.id)
+  useNotificationsStore().hydrate(snapshot.notifications ?? [])
+  useRiskPoliciesStore().hydrate(snapshot.riskPolicies ?? [], snapshot.riskPolicyCatalogVersions)
+  useSharedStacksStore().hydrate(snapshot.sharedStacks ?? [])
+  useWorkspaceSettingsStore().hydrate(snapshot.settings)
+  useAgentConfigStore().hydrate(snapshot.agentConfigCatalog ?? [])
+  useModelPresetsStore().hydrate(snapshot.modelPresets ?? [], snapshot.modelPresetCatalogVersions)
+  useServiceFragmentDefaultsStore().hydrate(snapshot.serviceFragmentDefaults?.fragmentIds)
+  useRecurringPipelinesStore().hydrate(snapshot.recurringPipelines ?? [])
+  useInitiativesStore().hydrate(snapshot.initiatives)
+  // Registered initiative presets (built-in generic + any a deployment mixed in): drive the
+  // create picker and which planning pipeline "Run planning" starts. Workspace-independent.
+  useInitiativesStore().hydratePresets(snapshot.initiativePresets)
+  useTrackerStore().hydrate(snapshot.trackerSettings)
+  useServicesStore().hydrate(snapshot.mounts ?? [], snapshot.serviceCatalog ?? [])
+  // Hydrate the deployment's backend-registered capabilities from ONE shared per-workspace
+  // remote capability manifest carrying BOTH custom agent kinds AND custom task types (its
+  // version covers both, so an unchanged snapshot no-ops both stores). Each store reads its
+  // own slot off it, so a proprietary agent kind renders as a first-class palette block +
+  // result view and a proprietary task type as a first-class create-task choice + card badge.
+  // Swapped wholesale per workspace (no global-catalog mutation).
+  const capabilities = buildWorkspaceCapabilitiesManifest(
+    snapshot.customAgentKinds ?? [],
+    snapshot.customTaskTypes ?? [],
+  )
+  useAgentsStore().hydrateCapabilities(capabilities)
+  useTaskTypesStore().hydrateCapabilities(capabilities)
+  // The account's repo-sourced Claude Skills catalog (shared across its workspaces), so the
+  // pipeline builder's per-step skill picker has its options. A straight replace.
+  useSkillsStore().hydrate(snapshot.skills ?? [])
+  // Seed the connect form's backend-kind selectors (built-in + any custom backend a
+  // deployment registered), so a programmatically-registered env/runner backend is a
+  // first-class connect option instead of a hardcoded manifest/kubernetes list.
+  useProviderConnectionsStore().registerBackendKinds({
+    environment: snapshot.environmentBackendKinds,
+    'runner-pool': snapshot.runnerBackendKinds,
+  })
+}

package/app/stores/workspace.ts

@@ -10,32 +10,7 @@ import type {
 } from '~/types/domain'
 import { useAccountsStore } from '~/stores/accounts'
 import { useBoardStore } from '~/stores/board'
-import { usePipelinesStore } from '~/stores/pipelines'
-import { useExecutionStore } from '~/stores/execution'
-import { useAgentRunsStore } from '~/stores/agentRuns'
-import { useEnvironmentTestStore } from '~/stores/environmentTest'
-import { useNotificationsStore } from '~/stores/notifications'
-import { useRiskPoliciesStore } from '~/stores/riskPolicies'
-import { useSharedStacksStore } from '~/stores/sharedStacks'
-import { useWorkspaceSettingsStore } from '~/stores/workspaceSettings'
-import { useAgentConfigStore } from '~/stores/agentConfig'
-import { useModelPresetsStore } from '~/stores/modelPresets'
-import { useServiceFragmentDefaultsStore } from '~/stores/serviceFragmentDefaults'
-import { useRecurringPipelinesStore } from '~/stores/recurringPipelines'
-import { useInitiativesStore } from '~/stores/initiative'
-import { useServicesStore } from '~/stores/services'
-import { useAgentsStore } from '~/stores/agents'
-import { useTaskTypesStore } from '~/stores/taskTypes'
-import { buildWorkspaceCapabilitiesManifest } from '~/modular/capabilities'
-import { useSkillsStore } from '~/stores/skills'
-import { useTrackerStore } from '~/stores/tracker'
-import { useRequirementsStore } from '~/stores/requirements'
-import { useClarityStore } from '~/stores/clarity'
-import { useBrainstormStore } from '~/stores/brainstorm'
-import { useConsensusStore } from '~/stores/consensus'
-import { useGitHubStore } from '~/stores/github'
-import { useFragmentsStore } from '~/stores/fragments'
-import { useProviderConnectionsStore } from '~/stores/providerConnections'
+import { applySnapshotToStores, resetPerBoardCaches } from '~/stores/workspace/hydrate'
 import { markBoot } from '~/utils/bootMarks'
 import { retryWhileBackendUnreachable } from '~/utils/backendReady'
 
@@ -109,30 +84,14 @@ export const useWorkspaceStore = defineStore(
      * fresh loads (init/switch/create), where there is no in-flight-upsert race to guard.
      */
     function hydrate(snapshot: WorkspaceSnapshot, boardSince?: number) {
-      // A change of active board (or the first load) — drop the per-block caches that are
-      // NOT part of the snapshot (reviews, brainstorm/consensus sessions, the GitHub
-      // projection) so a switched-to board never shows the previous one's stale state.
-      // These are lazily reloaded/re-probed per board, so clearing on a same-board refresh
-      // would needlessly wipe an open review window — hence only on an actual id change.
-      if (workspaceId.value !== snapshot.workspace.id) {
-        useRequirementsStore().reset()
-        useClarityStore().reset()
-        useBrainstormStore().reset()
-        useConsensusStore().reset()
-        useGitHubStore().reset()
-        useInitiativesStore().reset()
-        useDocInterviewStore().reset()
-        // The fragment picker catalog is per-board (the merged tenant catalog), so drop
-        // it too — the next inspector open re-fetches it for the switched-to board rather
-        // than showing the previous board's (or a raw-id placeholder for) fragments.
-        useFragmentsStore().invalidate()
-      }
+      // A change of active board (or the first load) drops the per-block caches that are NOT
+      // part of the snapshot; a same-board refresh keeps them (see `resetPerBoardCaches`).
+      if (workspaceId.value !== snapshot.workspace.id) resetPerBoardCaches()
       workspaceId.value = snapshot.workspace.id
       spend.value = snapshot.spend ?? null
       accountSpend.value = snapshot.accountSpend ?? null
       userSpend.value = snapshot.userSpend ?? null
       budgetCaps.value = snapshot.budgetCaps ?? null
-      useUserSettingsStore().hydrate(snapshot.userSettings ?? null)
       infraSetup.value = snapshot.infraSetup ?? null
       access.value = snapshot.access ?? null
       // Keep the board list in step (e.g. a freshly created board, or a rename). The
@@ -144,55 +103,8 @@ export const useWorkspaceStore = defineStore(
       } else {
         workspaces.value.unshift(snapshot.workspace)
       }
-      useBoardStore().hydrate(snapshot.blocks, boardSince)
-      useBoardStore().hydrateArchived(snapshot.archivedServices ?? [])
-      usePipelinesStore().hydrate(snapshot.pipelines, snapshot.pipelineCatalogVersions)
-      useExecutionStore().hydrate(snapshot.executions, snapshot.workspace.id)
-      useAgentRunsStore().hydrate(snapshot.bootstrapJobs ?? [], snapshot.workspace.id)
-      useAgentRunsStore().hydrateEnvConfigRepair(snapshot.envConfigRepairJobs ?? [])
-      useEnvironmentTestStore().hydrate(snapshot.environmentTestRuns ?? [], snapshot.workspace.id)
-      useNotificationsStore().hydrate(snapshot.notifications ?? [])
-      useRiskPoliciesStore().hydrate(
-        snapshot.riskPolicies ?? [],
-        snapshot.riskPolicyCatalogVersions,
-      )
-      useSharedStacksStore().hydrate(snapshot.sharedStacks ?? [])
-      useWorkspaceSettingsStore().hydrate(snapshot.settings)
-      useAgentConfigStore().hydrate(snapshot.agentConfigCatalog ?? [])
-      useModelPresetsStore().hydrate(
-        snapshot.modelPresets ?? [],
-        snapshot.modelPresetCatalogVersions,
-      )
-      useServiceFragmentDefaultsStore().hydrate(snapshot.serviceFragmentDefaults?.fragmentIds)
-      useRecurringPipelinesStore().hydrate(snapshot.recurringPipelines ?? [])
-      useInitiativesStore().hydrate(snapshot.initiatives)
-      // Registered initiative presets (built-in generic + any a deployment mixed in): drive the
-      // create picker and which planning pipeline "Run planning" starts. Workspace-independent.
-      useInitiativesStore().hydratePresets(snapshot.initiativePresets)
-      useTrackerStore().hydrate(snapshot.trackerSettings)
-      useServicesStore().hydrate(snapshot.mounts ?? [], snapshot.serviceCatalog ?? [])
-      // Hydrate the deployment's backend-registered capabilities from ONE shared per-workspace
-      // remote capability manifest carrying BOTH custom agent kinds AND custom task types (its
-      // version covers both, so an unchanged snapshot no-ops both stores). Each store reads its
-      // own slot off it, so a proprietary agent kind renders as a first-class palette block +
-      // result view and a proprietary task type as a first-class create-task choice + card badge.
-      // Swapped wholesale per workspace (no global-catalog mutation).
-      const capabilities = buildWorkspaceCapabilitiesManifest(
-        snapshot.customAgentKinds ?? [],
-        snapshot.customTaskTypes ?? [],
-      )
-      useAgentsStore().hydrateCapabilities(capabilities)
-      useTaskTypesStore().hydrateCapabilities(capabilities)
-      // The account's repo-sourced Claude Skills catalog (shared across its workspaces), so the
-      // pipeline builder's per-step skill picker has its options. A straight replace.
-      useSkillsStore().hydrate(snapshot.skills ?? [])
-      // Seed the connect form's backend-kind selectors (built-in + any custom backend a
-      // deployment registered), so a programmatically-registered env/runner backend is a
-      // first-class connect option instead of a hardcoded manifest/kubernetes list.
-      useProviderConnectionsStore().registerBackendKinds({
-        environment: snapshot.environmentBackendKinds,
-        'runner-pool': snapshot.runnerBackendKinds,
-      })
+      // Fan the rest of the snapshot out into the per-feature data stores.
+      applySnapshotToStores(snapshot, boardSince)
     }
 
     /** Resolve accounts + boards, then open the right board for the active account. */

package/package.json

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