@cat-factory/app 0.6.0

package/app/stores/github.ts

@@ -0,0 +1,305 @@
+import { defineStore } from 'pinia'
+import { computed, ref } from 'vue'
+import type {
+  CreateBranchInput,
+  CreateRepoRequest,
+  GitHubAvailableRepo,
+  GitHubBranch,
+  GitHubConnection,
+  GitHubInstallationOption,
+  GitHubIssue,
+  GitHubPullRequest,
+  GitHubRepo,
+  MergePullRequestInput,
+  OpenPullRequestInput,
+  ResyncRequest,
+} from '~/types/domain'
+import { useWorkspaceStore } from '~/stores/workspace'
+
+/**
+ * GitHub integration state: the workspace's App installation, the projected
+ * repos/branches/pull-requests/issues the backend caches in D1, and the actions
+ * that connect/resync and write against the repo. `available` mirrors the
+ * backend's opt-in gate — a 503 from the connection probe means the integration
+ * is off, and the UI hides its entry points (exactly as the documents store
+ * gates on its source probe, and `auth.required` gates the login UI). Per
+ * workspace, like the board itself; nothing is persisted client-side.
+ */
+export const useGitHubStore = defineStore('github', () => {
+  const api = useApi()
+  const workspace = useWorkspaceStore()
+
+  /** null = unknown (not probed yet), true/false = integration on/off. */
+  const available = ref<boolean | null>(null)
+  /** The workspace's App installation, or null when not yet connected. */
+  const connection = ref<GitHubConnection | null>(null)
+  /** Discovered App installations for the connect picker; loaded on demand. */
+  const installations = ref<GitHubInstallationOption[]>([])
+  const loadingInstallations = ref(false)
+  const repos = ref<GitHubRepo[]>([])
+  /** Repos the installation can access, for the per-workspace link picker. */
+  const availableRepos = ref<GitHubAvailableRepo[]>([])
+  const loadingAvailable = ref(false)
+  const savingRepos = ref(false)
+  const pulls = ref<GitHubPullRequest[]>([])
+  const issues = ref<GitHubIssue[]>([])
+  /** Branches loaded lazily per repo (by GitHub numeric id). */
+  const branches = ref<Record<number, GitHubBranch[]>>({})
+  const loading = ref(false)
+  const syncing = ref(false)
+
+  const connected = computed(() => connection.value !== null)
+  /** Whether cat-factory can create repos under the connected account itself. */
+  const canCreateRepos = computed(() => connection.value?.canCreateRepos === true)
+  /**
+   * True when connected but the install is MISSING `workflows: write` — agent
+   * pushes that touch `.github/workflows/*` will be rejected until it's granted.
+   */
+  const missingWorkflowsPermission = computed(
+    () => connection.value !== null && connection.value.canManageWorkflows !== true,
+  )
+
+  function repoFor(repoGithubId: number): GitHubRepo | undefined {
+    return repos.value.find((r) => r.githubId === repoGithubId)
+  }
+
+  /** The repo linked to a board block (its backing service repo), if any. */
+  function repoForBlock(blockId: string): GitHubRepo | undefined {
+    return repos.value.find((r) => r.blockId === blockId)
+  }
+
+  function pullsForRepo(repoGithubId: number): GitHubPullRequest[] {
+    return pulls.value.filter((p) => p.repoGithubId === repoGithubId)
+  }
+
+  function issuesForRepo(repoGithubId: number): GitHubIssue[] {
+    return issues.value.filter((i) => i.repoGithubId === repoGithubId)
+  }
+
+  /** Build the github.com URL for a repo / PR / issue from the projection row. */
+  function repoUrl(repoGithubId: number): string | null {
+    const r = repoFor(repoGithubId)
+    return r ? `https://github.com/${r.owner}/${r.name}` : null
+  }
+  function pullUrl(pr: GitHubPullRequest): string | null {
+    const base = repoUrl(pr.repoGithubId)
+    return base ? `${base}/pull/${pr.number}` : null
+  }
+  function issueUrl(issue: GitHubIssue): string | null {
+    const base = repoUrl(issue.repoGithubId)
+    return base ? `${base}/issues/${issue.number}` : null
+  }
+
+  /** Probe the integration: resolves `available` and the current connection. */
+  async function probe() {
+    if (!workspace.workspaceId) return
+    try {
+      const { connection: conn } = await api.getGitHubConnection(workspace.requireId())
+      available.value = true
+      connection.value = conn
+    } catch {
+      // 503 (integration disabled) or any error → hide the UI entry points.
+      available.value = false
+      connection.value = null
+    }
+  }
+
+  /** Load the cached repos, pull requests and issues for the workspace. */
+  async function load() {
+    if (!connected.value) return
+    loading.value = true
+    try {
+      const [r, p, i] = await Promise.all([
+        api.listGitHubRepos(workspace.requireId()),
+        api.listGitHubPullRequests(workspace.requireId()),
+        api.listGitHubIssues(workspace.requireId()),
+      ])
+      repos.value = r
+      pulls.value = p
+      issues.value = i
+    } finally {
+      loading.value = false
+    }
+  }
+
+  /**
+   * Ensure the projection (repos/PRs/issues) is loaded at least once — for views
+   * that need it without opening the GitHub panel (e.g. the inspector's repo link).
+   * Probes the integration first if it hasn't been yet.
+   */
+  async function ensureLoaded() {
+    if (available.value === null) await probe()
+    if (connected.value && repos.value.length === 0) await load()
+  }
+
+  /** Load the repos the installation can access, with this workspace's link state. */
+  async function loadAvailableRepos() {
+    if (!connected.value) return
+    loadingAvailable.value = true
+    try {
+      availableRepos.value = await api.listGitHubAvailableRepos(workspace.requireId())
+    } finally {
+      loadingAvailable.value = false
+    }
+  }
+
+  /** Set the exact set of repos this workspace links, then refresh projections. */
+  async function setLinkedRepos(repoGithubIds: number[]) {
+    savingRepos.value = true
+    try {
+      repos.value = await api.setGitHubLinkedRepos(workspace.requireId(), repoGithubIds)
+      // Reflect the new link state in the picker and refresh PRs/issues.
+      const linked = new Set(repoGithubIds)
+      availableRepos.value = availableRepos.value.map((r) => ({
+        ...r,
+        linked: linked.has(r.githubId),
+      }))
+      await load()
+    } finally {
+      savingRepos.value = false
+    }
+  }
+
+  /** Lazily load (and cache) the branches for a single repo. */
+  async function loadBranches(repoGithubId: number): Promise<GitHubBranch[]> {
+    const list = await api.listGitHubBranches(workspace.requireId(), repoGithubId)
+    branches.value = { ...branches.value, [repoGithubId]: list }
+    return list
+  }
+
+  /** List one level of a (monorepo) repo's tree, for the service-directory picker. */
+  function loadRepoTree(repoGithubId: number, path = '') {
+    return api.listGitHubRepoTree(workspace.requireId(), repoGithubId, path)
+  }
+
+  /** The URL a workspace owner visits to install the App against this workspace. */
+  function getInstallUrl(): Promise<string> {
+    return api.getGitHubInstallUrl(workspace.requireId()).then((r) => r.url)
+  }
+
+  /** Discover the App's installations so the user can connect one without typing an id. */
+  async function loadInstallations() {
+    loadingInstallations.value = true
+    try {
+      const { installations: list } = await api.listGitHubInstallations(workspace.requireId())
+      installations.value = list
+    } finally {
+      loadingInstallations.value = false
+    }
+  }
+
+  /** Programmatic bind by installation id (the browser flow uses the redirect). */
+  async function connect(installationId: number) {
+    connection.value = await api.connectGitHub(workspace.requireId(), installationId)
+    available.value = true
+    await load()
+  }
+
+  async function disconnect() {
+    await api.disconnectGitHub(workspace.requireId())
+    connection.value = null
+    repos.value = []
+    availableRepos.value = []
+    pulls.value = []
+    issues.value = []
+    branches.value = {}
+  }
+
+  /** Trigger a resync, then refresh projections (no-op for queued/backfill). */
+  async function resync(body: ResyncRequest = {}) {
+    syncing.value = true
+    try {
+      const res = await api.resyncGitHub(workspace.requireId(), body)
+      await load()
+      return res
+    } finally {
+      syncing.value = false
+    }
+  }
+
+  // ---- repo writes ----------------------------------------------------------
+
+  /**
+   * Create a repository under the connected account (privileged App tier). Only
+   * meaningful when `canCreateRepos`; the backend 409s otherwise. Returns the
+   * created repo so the caller can confirm/link it.
+   */
+  function createRepo(input: CreateRepoRequest) {
+    return api.createGitHubRepo(workspace.requireId(), input)
+  }
+
+  async function createBranch(repoGithubId: number, input: CreateBranchInput) {
+    const branch = await api.createGitHubBranch(workspace.requireId(), repoGithubId, input)
+    const next = branches.value[repoGithubId] ?? []
+    branches.value = { ...branches.value, [repoGithubId]: [branch, ...next] }
+    return branch
+  }
+
+  async function openPullRequest(repoGithubId: number, input: OpenPullRequestInput) {
+    const pr = await api.openGitHubPullRequest(workspace.requireId(), repoGithubId, input)
+    const i = pulls.value.findIndex(
+      (p) => p.repoGithubId === pr.repoGithubId && p.number === pr.number,
+    )
+    if (i >= 0) pulls.value[i] = pr
+    else pulls.value.unshift(pr)
+    return pr
+  }
+
+  async function mergePullRequest(
+    repoGithubId: number,
+    number: number,
+    input: MergePullRequestInput = {},
+  ) {
+    await api.mergeGitHubPullRequest(workspace.requireId(), repoGithubId, number, input)
+    // Optimistically reflect the merge until the next sync confirms it.
+    const i = pulls.value.findIndex((p) => p.repoGithubId === repoGithubId && p.number === number)
+    if (i >= 0) pulls.value[i] = { ...pulls.value[i]!, state: 'closed', merged: true }
+  }
+
+  function comment(repoGithubId: number, number: number, body: string) {
+    return api.commentGitHubIssue(workspace.requireId(), repoGithubId, number, body)
+  }
+
+  return {
+    available,
+    connection,
+    installations,
+    loadingInstallations,
+    repos,
+    availableRepos,
+    loadingAvailable,
+    savingRepos,
+    pulls,
+    issues,
+    branches,
+    loading,
+    syncing,
+    connected,
+    canCreateRepos,
+    missingWorkflowsPermission,
+    repoFor,
+    repoForBlock,
+    pullsForRepo,
+    issuesForRepo,
+    repoUrl,
+    pullUrl,
+    issueUrl,
+    probe,
+    load,
+    ensureLoaded,
+    loadAvailableRepos,
+    setLinkedRepos,
+    loadRepoTree,
+    loadBranches,
+    getInstallUrl,
+    loadInstallations,
+    connect,
+    disconnect,
+    resync,
+    createRepo,
+    createBranch,
+    openPullRequest,
+    mergePullRequest,
+    comment,
+  }
+})

package/app/stores/localModels.ts

@@ -0,0 +1,51 @@
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
+import type {
+  LocalModelEndpoint,
+  LocalModelEndpointTestResult,
+  LocalRunner,
+  TestLocalModelEndpointInput,
+  UpsertLocalModelEndpointInput,
+} from '~/types/localModels'
+
+// The signed-in user's local model runner endpoints — Ollama / LM Studio / llama.cpp /
+// vLLM / a custom OpenAI-compatible server running on their OWN machine. A runner lives
+// on a person's box (`localhost:11434` means something different per member), so these are
+// stored PER USER, not pooled on the workspace. The API key is write-only server-side and
+// never returned; this store only carries the metadata (+ the enabled model ids). Loaded
+// INDEPENDENTLY (not from the workspace snapshot) — like personal subscriptions.
+export const useLocalModelsStore = defineStore('localModels', () => {
+  const api = useApi()
+  const endpoints = ref<LocalModelEndpoint[]>([])
+  const loading = ref(false)
+
+  async function load() {
+    loading.value = true
+    try {
+      const { endpoints: list } = await api.listLocalModelEndpoints()
+      endpoints.value = list
+    } catch {
+      // Auth disabled / not signed in / feature off → no local runners surface.
+      endpoints.value = []
+    } finally {
+      loading.value = false
+    }
+  }
+
+  async function upsert(input: UpsertLocalModelEndpointInput) {
+    const endpoint = await api.upsertLocalModelEndpoint(input.provider, input)
+    endpoints.value = [...endpoints.value.filter((e) => e.provider !== endpoint.provider), endpoint]
+    return endpoint
+  }
+
+  async function remove(provider: LocalRunner) {
+    await api.deleteLocalModelEndpoint(provider)
+    endpoints.value = endpoints.value.filter((e) => e.provider !== provider)
+  }
+
+  async function test(input: TestLocalModelEndpointInput): Promise<LocalModelEndpointTestResult> {
+    return await api.testLocalModelEndpoint(input)
+  }
+
+  return { endpoints, loading, load, upsert, remove, test }
+})

package/app/stores/mergePresets.ts

@@ -0,0 +1,58 @@
+import { defineStore } from 'pinia'
+import { computed, ref } from 'vue'
+import type {
+  CreateMergePresetInput,
+  MergeThresholdPreset,
+  UpdateMergePresetInput,
+} from '~/types/domain'
+import { useWorkspaceStore } from '~/stores/workspace'
+
+/**
+ * The workspace's merge threshold presets — the library a task picks its
+ * auto-merge policy from (the `merger` step compares the PR assessment against the
+ * resolved preset). Hydrated from the workspace snapshot; managed via a small
+ * settings UI. The backend always keeps at least one default preset.
+ */
+export const useMergePresetsStore = defineStore('mergePresets', () => {
+  const api = useApi()
+
+  const presets = ref<MergeThresholdPreset[]>([])
+
+  function hydrate(list: MergeThresholdPreset[]) {
+    presets.value = [...list].sort((a, b) => a.createdAt - b.createdAt)
+  }
+
+  /** The workspace default (fallback for a task that picks none). */
+  const defaultPreset = computed(() => presets.value.find((p) => p.isDefault) ?? null)
+
+  /** Resolve a task's effective preset by id, falling back to the default. */
+  function resolve(presetId: string | undefined): MergeThresholdPreset | null {
+    if (presetId) {
+      const picked = presets.value.find((p) => p.id === presetId)
+      if (picked) return picked
+    }
+    return defaultPreset.value
+  }
+
+  async function create(input: CreateMergePresetInput) {
+    const ws = useWorkspaceStore()
+    const created = await api.createMergePreset(ws.requireId(), input)
+    await ws.refresh()
+    return created
+  }
+
+  async function update(presetId: string, patch: UpdateMergePresetInput) {
+    const ws = useWorkspaceStore()
+    const updated = await api.updateMergePreset(ws.requireId(), presetId, patch)
+    await ws.refresh()
+    return updated
+  }
+
+  async function remove(presetId: string) {
+    const ws = useWorkspaceStore()
+    await api.deleteMergePreset(ws.requireId(), presetId)
+    await ws.refresh()
+  }
+
+  return { presets, defaultPreset, resolve, hydrate, create, update, remove }
+})

package/app/stores/modelDefaults.ts

@@ -0,0 +1,76 @@
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
+import { useWorkspaceStore } from '~/stores/workspace'
+
+/**
+ * The workspace's per-agent-kind default model overrides — the map an agent step
+ * resolves its model from when the task pins none (a block-pinned model still
+ * wins; a kind absent from the map falls back to the deployment's env routing).
+ * Hydrated from the workspace snapshot; edited via the Default-models settings
+ * panel, which replaces the whole map on save.
+ */
+export const useModelDefaultsStore = defineStore('modelDefaults', () => {
+  const api = useApi()
+
+  /** agentKind → model catalog id. */
+  const defaults = ref<Record<string, string>>({})
+
+  /**
+   * The deployment's env-routing defaults as `provider:model` refs — what a kind
+   * runs on when neither the task nor this workspace pins a model. `default` is the
+   * global fallback; `byKind` carries kinds the operator routed specifically. Used
+   * only to NAME the fallback in the settings panel; it never overrides a pin.
+   */
+  const deployment = ref<{ default: string; byKind: Record<string, string> }>({
+    default: '',
+    byKind: {},
+  })
+
+  function hydrate(map: Record<string, string> | undefined) {
+    defaults.value = { ...map }
+  }
+
+  function hydrateDeployment(
+    next: { default: string; byKind: Record<string, string> } | undefined,
+  ) {
+    deployment.value = next
+      ? { default: next.default, byKind: { ...next.byKind } }
+      : {
+          default: '',
+          byKind: {},
+        }
+  }
+
+  /** The model id chosen for a kind, or undefined when it falls back to routing. */
+  function forKind(kind: string): string | undefined {
+    return defaults.value[kind]
+  }
+
+  /** The deployment-routing model ref a kind falls back to (`byKind[kind] ?? default`). */
+  function deploymentRefForKind(kind: string): string | undefined {
+    return deployment.value.byKind[kind] || deployment.value.default || undefined
+  }
+
+  /**
+   * Set (or, with `null`, clear) the default model for a single agent kind, then
+   * persist the whole map. The backend replaces the stored set on every write.
+   */
+  async function set(kind: string, modelId: string | null) {
+    const next = { ...defaults.value }
+    if (modelId) next[kind] = modelId
+    else delete next[kind]
+    const ws = useWorkspaceStore()
+    const saved = await api.setModelDefaults(ws.requireId(), next)
+    defaults.value = { ...saved.defaults }
+  }
+
+  return {
+    defaults,
+    deployment,
+    hydrate,
+    hydrateDeployment,
+    forKind,
+    deploymentRefForKind,
+    set,
+  }
+})

package/app/stores/models.ts

@@ -0,0 +1,134 @@
+import { defineStore } from 'pinia'
+import { ref, computed } from 'vue'
+import type { ModelCost, ModelOption, SubscriptionVendor } from '~/types/domain'
+
+/** The flavour of a model to actually display/run, given configured subscriptions. */
+export interface DisplayFlavor {
+  providerLabel: string
+  provider: string
+  model: string
+  contextTokens?: number
+  cost?: ModelCost
+  /** True ⇒ flat-rate quota; its cost is a quota burn rate, not budget spend. */
+  quotaBased: boolean
+  vendor?: SubscriptionVendor
+}
+
+/**
+ * The flavour a model resolves to in the picker given the workspace's configured
+ * subscription vendors. A dual-mode model (GLM/Kimi) collapses to its subscription
+ * flavour once that vendor is connected ("subscriptions always win"); otherwise the
+ * base (cloudflare/direct, or the subscription itself for subscription-only models).
+ */
+export function displayFlavor(m: ModelOption, configured: Set<SubscriptionVendor>): DisplayFlavor {
+  if (m.subscription && configured.has(m.subscription.vendor)) {
+    return {
+      providerLabel: m.subscription.providerLabel,
+      provider: m.subscription.provider,
+      model: m.subscription.model,
+      contextTokens: m.subscription.contextTokens,
+      cost: m.subscription.cost,
+      quotaBased: true,
+      vendor: m.subscription.vendor,
+    }
+  }
+  return {
+    providerLabel: m.providerLabel,
+    provider: m.provider,
+    model: m.model,
+    contextTokens: m.contextTokens,
+    cost: m.cost,
+    quotaBased: m.quotaBased ?? false,
+    vendor: m.vendor,
+  }
+}
+
+/**
+ * Whether a model is selectable. On the per-workspace catalog the backend already
+ * computes `available` from the configured API keys / subscriptions / Cloudflare opt-in,
+ * so honour it directly. On the deployment catalog (`available` absent) fall back to the
+ * subscription-token heuristic so the picker still gates subscription-only models.
+ */
+export function isSelectable(m: ModelOption, configured: Set<SubscriptionVendor>): boolean {
+  if (m.available !== undefined) return m.available
+  if (m.flavor === 'subscription' && m.vendor) return configured.has(m.vendor)
+  return true
+}
+
+/** Compact context-window label, e.g. `200K`. */
+export function contextLabel(tokens: number | undefined): string | undefined {
+  if (!tokens) return undefined
+  return tokens >= 1000 ? `${Math.round(tokens / 1000)}K` : `${tokens}`
+}
+
+/** One-line cost/quota suffix for the picker. */
+export function costLabel(flavor: DisplayFlavor): string | undefined {
+  if (!flavor.cost) return undefined
+  const { inputPerMillion, outputPerMillion, currency } = flavor.cost
+  const body = `${inputPerMillion}/${outputPerMillion} ${currency} per Mtok`
+  return flavor.quotaBased ? `quota burn ~${body}` : body
+}
+
+/**
+ * The model picker catalog. Served by `GET /models`, where each model is already
+ * resolved to the flavour in use for this deployment (direct when the provider's
+ * key is configured, else the Cloudflare fallback). Fetched once and cached for
+ * the per-block picker, and used to label which model produced a step's output.
+ */
+export const useModelsStore = defineStore('models', () => {
+  const api = useApi()
+  const models = ref<ModelOption[]>([])
+  const loaded = ref(false)
+  const loadedWorkspaceId = ref<string | null>(null)
+
+  /**
+   * Fetch the catalog. Pass a `workspaceId` for the per-workspace catalog (selectability
+   * reflects that workspace's configured keys/subscriptions); re-fetches when the
+   * workspace changes. Without one, the deployment-level catalog is loaded once.
+   */
+  async function ensureLoaded(workspaceId?: string) {
+    if (workspaceId) {
+      if (loaded.value && loadedWorkspaceId.value === workspaceId) return
+      models.value = await api.getWorkspaceModels(workspaceId)
+      loadedWorkspaceId.value = workspaceId
+      loaded.value = true
+      return
+    }
+    if (loaded.value) return
+    models.value = await api.getModels()
+    loaded.value = true
+  }
+
+  /** Force a re-fetch of the per-workspace catalog (e.g. after adding an API key). */
+  async function refresh(workspaceId: string) {
+    models.value = await api.getWorkspaceModels(workspaceId)
+    loadedWorkspaceId.value = workspaceId
+    loaded.value = true
+  }
+
+  const byId = computed(() => {
+    const map = new Map<string, ModelOption>()
+    for (const m of models.value) map.set(m.id, m)
+    return map
+  })
+
+  function getModel(id: string | undefined) {
+    return id ? byId.value.get(id) : undefined
+  }
+
+  /**
+   * Friendly label for a recorded `provider:model` identifier (as carried on a
+   * pipeline step). Matches it against the catalog's effective refs; falls back
+   * to the bare model id for anything not in the catalog (e.g. a pinned override).
+   */
+  function labelForRef(ref: string | undefined): string | undefined {
+    if (!ref) return undefined
+    const idx = ref.indexOf(':')
+    const provider = idx === -1 ? ref : ref.slice(0, idx)
+    const model = idx === -1 ? '' : ref.slice(idx + 1)
+    const hit = models.value.find((m) => m.provider === provider && m.model === model)
+    return hit ? `${hit.label} · ${hit.providerLabel}` : model || ref
+  }
+
+  return { models, loaded, ensureLoaded, refresh, byId, getModel, labelForRef }
+})

package/app/stores/notifications.ts

@@ -0,0 +1,70 @@
+import { defineStore } from 'pinia'
+import { computed, ref } from 'vue'
+import type { Notification } from '~/types/domain'
+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`.
+ */
+export const useNotificationsStore = defineStore('notifications', () => {
+  const api = useApi()
+
+  /** All open notifications, newest-first. */
+  const open = ref<Notification[]>([])
+
+  /** Replace the cache from a server snapshot. */
+  function hydrate(notifications: Notification[]) {
+    open.value = [...notifications]
+      .filter((n) => n.status === 'open')
+      .sort((a, b) => b.createdAt - a.createdAt)
+  }
+
+  /**
+   * Patch one notification from a real-time event: an `open` one is inserted /
+   * replaced in place; a resolved one (acted/dismissed) is removed from the inbox.
+   */
+  function upsert(notification: Notification) {
+    const i = open.value.findIndex((n) => n.id === notification.id)
+    if (notification.status !== 'open') {
+      if (i >= 0) open.value.splice(i, 1)
+      return
+    }
+    if (i >= 0) open.value[i] = notification
+    else open.value.unshift(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
+  })
+
+  /** Total open count, for the toolbar badge. */
+  const count = computed(() => open.value.length)
+
+  /** Act on a notification (merge / confirm / retry); the board patches via the event. */
+  async function act(id: string) {
+    const ws = useWorkspaceStore()
+    const resolved = await api.actNotification(ws.requireId(), id)
+    upsert(resolved)
+    // The action (merge/confirm/retry) changed block/run state — reconcile fully.
+    await ws.refresh()
+  }
+
+  /** Dismiss a notification without acting. */
+  async function dismiss(id: string) {
+    const ws = useWorkspaceStore()
+    const resolved = await api.dismissNotification(ws.requireId(), id)
+    upsert(resolved)
+  }
+
+  return { open, hydrate, upsert, byBlock, count, act, dismiss }
+})