@cat-factory/app 0.36.0 → 0.37.1

package/app/composables/api/tasks.ts

@@ -1,61 +1,69 @@
-import type {
-  Block,
-  SourceTask,
-  TaskConnection,
-  TaskSearchResult,
-  TaskSourceDiagnostic,
-  TaskSourceKind,
-  TaskSourceState,
-} from '~/types/domain'
-import type { PutTrackerSettingsInput, TrackerSettings } from '~/types/tracker'
+import {
+  connectTaskSourceContract,
+  createTaskFromIssueContract,
+  diagnoseTaskSourceContract,
+  disconnectTaskSourceContract,
+  getTrackerSettingsContract,
+  importTaskContract,
+  linkTaskContract,
+  listTaskConnectionsContract,
+  listTaskSourcesContract,
+  listTasksContract,
+  putTrackerSettingsContract,
+  searchTasksContract,
+  setTaskSourceEnabledContract,
+  spawnEpicContract,
+} from '@cat-factory/contracts'
+import type { TaskSourceKind } from '~/types/domain'
+import type { PutTrackerSettingsInput } from '~/types/tracker'
 import type { ApiContext } from './context'
 
 /** Task sources (Jira, …): connect/import/search/link + the workspace tracker selection. */
-export function tasksApi({ http, ws }: ApiContext) {
+export function tasksApi({ send, ws }: ApiContext) {
   return {
     // ---- task sources (Jira, …) ------------------------------------------
     // The configured trackers + their connect/import metadata + the workspace's
     // per-source state (available + enabled). A 503 means the integration is off
     // (the store hides its UI on any error here).
     listTaskSources: (workspaceId: string) =>
-      http<{ sources: TaskSourceState[] }>(`${ws(workspaceId)}/task-sources`),
+      send(listTaskSourcesContract, { pathPrefix: ws(workspaceId) }),
 
     setTaskSourceEnabled: (workspaceId: string, source: TaskSourceKind, enabled: boolean) =>
-      http(`${ws(workspaceId)}/task-sources/${source}/enabled`, {
-        method: 'PUT',
+      send(setTaskSourceEnabledContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { source },
         body: { enabled },
       }),
 
     listTaskConnections: (workspaceId: string) =>
-      http<{ connections: TaskConnection[] }>(`${ws(workspaceId)}/task-sources/connections`),
+      send(listTaskConnectionsContract, { pathPrefix: ws(workspaceId) }),
 
     connectTaskSource: (
       workspaceId: string,
       source: TaskSourceKind,
       credentials: Record<string, string>,
     ) =>
-      http<TaskConnection>(`${ws(workspaceId)}/task-sources/${source}/connect`, {
-        method: 'POST',
+      send(connectTaskSourceContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { source },
         body: { credentials },
       }),
 
     disconnectTaskSource: (workspaceId: string, source: TaskSourceKind) =>
-      http(`${ws(workspaceId)}/task-sources/${source}/connection`, { method: 'DELETE' }),
+      send(disconnectTaskSourceContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { source },
+      }),
 
     // Live "check setup" probe: authenticates against the source and reads a slice
     // of its issues API, returning a classified verdict the panel renders verbatim.
     checkTaskSource: (workspaceId: string, source: TaskSourceKind) =>
-      http<TaskSourceDiagnostic>(`${ws(workspaceId)}/task-sources/${source}/diagnostics`, {
-        method: 'POST',
-      }),
+      send(diagnoseTaskSourceContract, { pathPrefix: ws(workspaceId), pathParams: { source } }),
 
-    listTasks: (workspaceId: string) => http<SourceTask[]>(`${ws(workspaceId)}/tasks`),
+    listTasks: (workspaceId: string) => send(listTasksContract, { pathPrefix: ws(workspaceId) }),
 
     importTask: (workspaceId: string, source: TaskSourceKind, body: { ref: string }) =>
-      http<SourceTask>(`${ws(workspaceId)}/task-sources/${source}/import`, {
-        method: 'POST',
-        body,
-      }),
+      send(importTaskContract, { pathPrefix: ws(workspaceId), pathParams: { source }, body }),
 
     searchTaskSource: (
       workspaceId: string,
@@ -63,24 +71,21 @@ export function tasksApi({ http, ws }: ApiContext) {
       query: string,
       blockId?: string,
     ) =>
-      http<{ results: TaskSearchResult[] }>(`${ws(workspaceId)}/task-sources/${source}/search`, {
-        method: 'POST',
+      send(searchTasksContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { source },
         body: { query, ...(blockId ? { blockId } : {}) },
       }),
 
     linkTask: (
       workspaceId: string,
       body: { source: TaskSourceKind; externalId: string; blockId: string },
-    ) => http<SourceTask>(`${ws(workspaceId)}/tasks/link`, { method: 'POST', body }),
+    ) => send(linkTaskContract, { pathPrefix: ws(workspaceId), body }),
 
     createTaskFromIssue: (
       workspaceId: string,
       body: { source: TaskSourceKind; externalId: string; containerId: string },
-    ) =>
-      http<{ block: Block; task: SourceTask }>(`${ws(workspaceId)}/tasks/create-block`, {
-        method: 'POST',
-        body,
-      }),
+    ) => send(createTaskFromIssueContract, { pathPrefix: ws(workspaceId), body }),
 
     // Spawn an epic + its children as an epic node + child tasks, with dependency edges
     // seeded from the issues' blocked-by/depends-on links.
@@ -88,17 +93,13 @@ export function tasksApi({ http, ws }: ApiContext) {
       workspaceId: string,
       source: TaskSourceKind,
       body: { ref: string; containerId: string; position?: { x: number; y: number } },
-    ) =>
-      http<{ epic: Block; tasks: Block[] }>(
-        `${ws(workspaceId)}/task-sources/${source}/epics/spawn`,
-        { method: 'POST', body },
-      ),
+    ) => send(spawnEpicContract, { pathPrefix: ws(workspaceId), pathParams: { source }, body }),
 
     // ---- issue-tracker selection (workspace-level) ------------------------
     getTrackerSettings: (workspaceId: string) =>
-      http<TrackerSettings>(`${ws(workspaceId)}/tracker-settings`),
+      send(getTrackerSettingsContract, { pathPrefix: ws(workspaceId) }),
 
     putTrackerSettings: (workspaceId: string, body: PutTrackerSettingsInput) =>
-      http<TrackerSettings>(`${ws(workspaceId)}/tracker-settings`, { method: 'PUT', body }),
+      send(putTrackerSettingsContract, { pathPrefix: ws(workspaceId), body }),
   }
 }

package/app/composables/api/userSecrets.ts

@@ -1,31 +1,26 @@
-import type {
-  ConnectionTestResult,
-  StoreUserSecretInput,
-  TestUserSecretInput,
-  UserSecretDescriptor,
-  UserSecretKind,
-  UserSecretStatus,
-} from '~/types/userSecrets'
+import {
+  listUserSecretsContract,
+  removeUserSecretContract,
+  storeUserSecretContract,
+  testUserSecretContract,
+} from '@cat-factory/contracts'
+import type { StoreUserSecretInput, TestUserSecretInput, UserSecretKind } from '~/types/userSecrets'
 import type { ApiContext } from './context'
 
 // Per-USER generic secrets (a GitHub PAT today). User-scoped (no workspace); the secret
 // is write-only server-side and never returned — only status metadata + a `hasSecret`
 // flag. `descriptors` drive the generic connect form; `test` probes before save.
-export function userSecretsApi({ http }: ApiContext) {
+export function userSecretsApi({ send }: ApiContext) {
   return {
-    listUserSecrets: () =>
-      http<{ secrets: UserSecretStatus[]; descriptors: UserSecretDescriptor[] }>('/user-secrets'),
+    listUserSecrets: () => send(listUserSecretsContract, {}),
 
     storeUserSecret: (kind: UserSecretKind, body: StoreUserSecretInput) =>
-      http<UserSecretStatus>(`/user-secrets/${encodeURIComponent(kind)}`, { method: 'POST', body }),
+      send(storeUserSecretContract, { pathParams: { kind }, body }),
 
     deleteUserSecret: (kind: UserSecretKind) =>
-      http(`/user-secrets/${encodeURIComponent(kind)}`, { method: 'DELETE' }),
+      send(removeUserSecretContract, { pathParams: { kind } }),
 
     testUserSecret: (kind: UserSecretKind, body: TestUserSecretInput) =>
-      http<ConnectionTestResult>(`/user-secrets/${encodeURIComponent(kind)}/test`, {
-        method: 'POST',
-        body,
-      }),
+      send(testUserSecretContract, { pathParams: { kind }, body }),
   }
 }

package/app/composables/api/workspaces.ts

@@ -1,36 +1,42 @@
-import type {
-  UpdateWorkspaceSettingsInput,
-  Workspace,
-  WorkspaceSettings,
-  WorkspaceSnapshot,
-} from '~/types/domain'
+import {
+  createWorkspaceContract,
+  deleteWorkspaceContract,
+  getWorkspaceContract,
+  getWorkspaceSettingsContract,
+  listWorkspacesContract,
+  updateWorkspaceContract,
+  updateWorkspaceSettingsContract,
+} from '@cat-factory/contracts'
+import type { UpdateWorkspaceSettingsInput } from '~/types/domain'
 import type { ApiContext } from './context'
 
 /** Workspace CRUD + the full snapshot read. */
-export function workspacesApi({ http, ws }: ApiContext) {
+export function workspacesApi({ send, ws }: ApiContext) {
   return {
     // ---- workspaces -------------------------------------------------------
-    listWorkspaces: () => http<Workspace[]>('/workspaces'),
+    listWorkspaces: () => send(listWorkspacesContract, {}),
 
     createWorkspace: (
       body: { name?: string; description?: string; seed?: boolean; accountId?: string } = {},
-    ) => http<WorkspaceSnapshot>('/workspaces', { method: 'POST', body }),
+    ) => send(createWorkspaceContract, { body }),
 
-    getWorkspace: (workspaceId: string) => http<WorkspaceSnapshot>(ws(workspaceId)),
+    getWorkspace: (workspaceId: string) =>
+      send(getWorkspaceContract, { pathParams: { workspaceId } }),
 
     updateWorkspace: (workspaceId: string, body: { name?: string; description?: string | null }) =>
-      http<Workspace>(ws(workspaceId), { method: 'PATCH', body }),
+      send(updateWorkspaceContract, { pathParams: { workspaceId }, body }),
 
     renameWorkspace: (workspaceId: string, name: string) =>
-      http<Workspace>(ws(workspaceId), { method: 'PATCH', body: { name } }),
+      send(updateWorkspaceContract, { pathParams: { workspaceId }, body: { name } }),
 
-    deleteWorkspace: (workspaceId: string) => http(ws(workspaceId), { method: 'DELETE' }),
+    deleteWorkspace: (workspaceId: string) =>
+      send(deleteWorkspaceContract, { pathParams: { workspaceId } }),
 
     // ---- workspace runtime settings (human-wait escalation + per-service task limit) --
     getWorkspaceSettings: (workspaceId: string) =>
-      http<WorkspaceSettings>(`${ws(workspaceId)}/settings`),
+      send(getWorkspaceSettingsContract, { pathPrefix: ws(workspaceId) }),
 
     updateWorkspaceSettings: (workspaceId: string, body: UpdateWorkspaceSettingsInput) =>
-      http<WorkspaceSettings>(`${ws(workspaceId)}/settings`, { method: 'PUT', body }),
+      send(updateWorkspaceSettingsContract, { pathPrefix: ws(workspaceId), body }),
   }
 }

package/app/composables/useApi.ts

@@ -1,4 +1,5 @@
 import type { FragmentOwnerKind } from '~/types/domain'
+import { createApiClient, createSend, createSendWith } from './api/client'
 import type { ApiContext } from './api/context'
 import { accountsApi } from './api/accounts'
 import { authApi } from './api/auth'
@@ -75,7 +76,14 @@ export function useApi() {
       ? `/accounts/${encodeURIComponent(id)}`
       : `/workspaces/${encodeURIComponent(id)}`
 
-  const ctx: ApiContext = { http, ws, scope, pwHeaders }
+  // The contract-driven client (wretch + sendByApiContract): one source of truth for
+  // path/method/request/response, shared with the backend via @cat-factory/contracts.
+  // API groups are migrated onto `send` incrementally; the rest still use `http`.
+  const client = createApiClient()
+  const send = createSend(client)
+  const sendWith = createSendWith(client)
+
+  const ctx: ApiContext = { http, client, send, sendWith, ws, scope, pwHeaders }
 
   return {
     ...authApi(ctx),

package/app/composables/useIntegrationBack.ts

@@ -1,20 +1,26 @@
 import type { Ref, WritableComputedRef } from 'vue'
 
 /**
- * The shared "back to Integrations" handler for an integration sub-panel's modal header.
- * Every panel reached from the Integrations hub closes itself and reopens the hub when its
+ * The shared "back to the hub" handler for an integration sub-panel's modal header.
+ * Every panel reached from a hub closes itself and reopens that hub when its
  * {@link IntegrationBackTitle} Back control fires `@back`. Centralising it keeps the ~13
  * panels from each re-implementing the two-step close-then-reopen inline — which also
  * dodges a Vue SFC-compiler trap: a multi-statement inline template handler
  * (`open = false` ⏎ `ui.openIntegrations()`) is rejected at build time, so callers had to
  * resort to an obscure comma-operator expression. A named handler reads clearly instead.
  *
+ * Returns to whichever hub the panel was reached from: the user-scoped "My setup" hub when
+ * `cameFromPersonal` is set, else the workspace Integrations hub. A shared panel (e.g. the
+ * vendor-credentials modal, reachable from both) thus lands the user back where they were.
+ *
  * Pass the panel's `open` model (the writable ref/computed bound to its `UModal`).
  */
 export function useIntegrationBack(open: Ref<boolean> | WritableComputedRef<boolean>) {
   const ui = useUiStore()
   return () => {
+    const toPersonal = ui.cameFromPersonal
     open.value = false
-    ui.openIntegrations()
+    if (toPersonal) ui.openPersonalSetup()
+    else ui.openIntegrations()
   }
 }

package/app/composables/useSourceIntegration.ts

@@ -0,0 +1,107 @@
+import { type ComputedRef, type Ref, computed, ref } from 'vue'
+import { useUpsertList } from '~/composables/useUpsertList'
+
+/**
+ * The source-integration lifecycle shared by the document-source and task-source stores:
+ * the opt-in `available` gate, the per-source `connections` list, the `descriptorFor` /
+ * `connectionFor` / `isConnected` lookups, and a `probe()` that resolves all of it (hiding
+ * the UI when the integration is off). Both stores previously hand-rolled this, with
+ * inconsistent error handling — one captured the probe failure, the other swallowed it.
+ * Standardising here means every integration now records WHY a probe failed
+ * (`probeError`: a 503 "turned off on this deployment" vs a 500 "the backend errored"), so
+ * a settings panel can explain the empty state instead of a blanket "install it first".
+ *
+ * The store supplies only what differs: how to fetch its sources + connections, and the
+ * connect/disconnect calls (which feed `upsertConnection` / `removeConnection`). Source-
+ * specific extras (diagnostics, per-source enable toggles, plan/spawn) stay in the store.
+ */
+export function useSourceIntegration<
+  Source extends string,
+  Conn extends { source: Source },
+  Desc extends { source: Source },
+>(opts: {
+  /** Fetch the configured sources + live connections; throws when the integration is off. */
+  fetch: () => Promise<{ sources: Desc[]; connections: Conn[] }>
+  /** Gate the probe (e.g. skip until a workspace is selected). */
+  enabled?: () => boolean
+}): {
+  available: Ref<boolean | null>
+  probeError: Ref<{ status: number | null; message: string } | null>
+  sources: Ref<Desc[]>
+  connections: Ref<Conn[]>
+  connectedSources: ComputedRef<Desc[]>
+  anyConnected: ComputedRef<boolean>
+  descriptorFor: (source: Source) => Desc | undefined
+  connectionFor: (source: Source) => Conn | undefined
+  isConnected: (source: Source) => boolean
+  upsertConnection: (conn: Conn) => void
+  removeConnection: (source: Source) => void
+  probe: () => Promise<void>
+} {
+  /** null = unknown (not probed yet), true/false = integration on/off. */
+  const available = ref<boolean | null>(null)
+  /** Why the last probe failed, when it did (kept rather than swallowed). */
+  const probeError = ref<{ status: number | null; message: string } | null>(null)
+  const sources = ref<Desc[]>([]) as Ref<Desc[]>
+  const { items: connections, upsert: upsertConnection } = useUpsertList<Conn>({
+    key: (c) => c.source,
+  })
+
+  const connectedSources = computed(() =>
+    sources.value.filter((s) => connections.value.some((c) => c.source === s.source)),
+  )
+  const anyConnected = computed(() => connections.value.length > 0)
+
+  function descriptorFor(source: Source): Desc | undefined {
+    return sources.value.find((s) => s.source === source)
+  }
+  function connectionFor(source: Source): Conn | undefined {
+    return connections.value.find((c) => c.source === source)
+  }
+  function isConnected(source: Source): boolean {
+    return connectionFor(source) !== undefined
+  }
+  function removeConnection(source: Source) {
+    connections.value = connections.value.filter((c) => c.source !== source)
+  }
+
+  /** Probe the integration: resolves `available`, the sources and connections. */
+  async function probe() {
+    if (opts.enabled && !opts.enabled()) return
+    try {
+      const { sources: srcs, connections: conns } = await opts.fetch()
+      available.value = true
+      probeError.value = null
+      sources.value = srcs
+      connections.value = conns
+    } catch (e) {
+      // 503 (integration disabled) or any error → hide the UI entry points, but keep the
+      // reason so a panel can explain it (503 = off here; 500 = the backend errored, e.g. an
+      // unapplied migration).
+      available.value = false
+      const err = e as { statusCode?: number; data?: { error?: { message?: string } } }
+      const serverMessage = err?.data?.error?.message
+      probeError.value = {
+        status: err?.statusCode ?? null,
+        message: serverMessage || (e instanceof Error ? e.message : String(e)),
+      }
+      sources.value = []
+      connections.value = []
+    }
+  }
+
+  return {
+    available,
+    probeError,
+    sources,
+    connections,
+    connectedSources,
+    anyConnected,
+    descriptorFor,
+    connectionFor,
+    isConnected,
+    upsertConnection,
+    removeConnection,
+    probe,
+  }
+}

package/app/composables/useUpsertList.spec.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from 'vitest'
+import { useUpsertList } from '~/composables/useUpsertList'
+
+interface Item {
+  id: string
+  v: number
+}
+
+describe('useUpsertList', () => {
+  it('appends new items by default and replaces in place by key', () => {
+    const { items, upsert } = useUpsertList<Item>({ key: (x) => x.id })
+    upsert({ id: 'a', v: 1 })
+    upsert({ id: 'b', v: 2 })
+    upsert({ id: 'a', v: 9 }) // replace, not duplicate
+    expect(items.value).toEqual([
+      { id: 'a', v: 9 },
+      { id: 'b', v: 2 },
+    ])
+  })
+
+  it('prepends new items when prepend is set (newest-first)', () => {
+    const { items, upsert } = useUpsertList<Item>({ key: (x) => x.id, prepend: true })
+    upsert({ id: 'a', v: 1 })
+    upsert({ id: 'b', v: 2 })
+    expect(items.value.map((x) => x.id)).toEqual(['b', 'a'])
+  })
+
+  it('removes by key and looks up by key', () => {
+    const { items, upsert, remove, get } = useUpsertList<Item>({ key: (x) => x.id })
+    upsert({ id: 'a', v: 1 })
+    upsert({ id: 'b', v: 2 })
+    expect(get('b')).toEqual({ id: 'b', v: 2 })
+    remove('a')
+    expect(items.value.map((x) => x.id)).toEqual(['b'])
+    remove('missing') // no-op
+    expect(items.value).toHaveLength(1)
+  })
+
+  it('supports composite keys and hydrate-from-snapshot', () => {
+    interface Doc {
+      source: string
+      externalId: string
+    }
+    const { items, upsert, hydrate } = useUpsertList<Doc>({
+      key: (d) => `${d.source}:${d.externalId}`,
+    })
+    hydrate([{ source: 'jira', externalId: '1' }])
+    upsert({ source: 'jira', externalId: '1' }) // same composite key → replace
+    upsert({ source: 'gh', externalId: '1' }) // different source → new
+    expect(items.value).toHaveLength(2)
+  })
+
+  it('seeds from initial without aliasing the caller array', () => {
+    const seed: Item[] = [{ id: 'a', v: 1 }]
+    const { items, upsert } = useUpsertList<Item>({ key: (x) => x.id, initial: seed })
+    upsert({ id: 'b', v: 2 })
+    expect(items.value).toHaveLength(2)
+    expect(seed).toHaveLength(1) // original untouched
+  })
+})

package/app/composables/useUpsertList.ts

@@ -0,0 +1,57 @@
+import { type Ref, ref } from 'vue'
+
+/**
+ * A keyed list with find-by-key upsert — the pattern reimplemented in ~13 stores
+ * (`const i = list.findIndex((x) => x.id === item.id); if (i >= 0) list[i] = item else …`).
+ * Wraps a reactive `T[]` and exposes `upsert` (replace-in-place or insert), `remove`,
+ * `get`, and `hydrate` (replace from a server snapshot), all keyed by a caller-supplied
+ * `key` function. New items append by default, or `prepend: true` for newest-first inboxes.
+ *
+ * The returned `items` ref stays directly assignable, so a store can expose it under a
+ * domain name (`const { items: documents, upsert } = useUpsertList(...)`) and callers /
+ * tests can still do `store.documents = [...]`.
+ */
+export function useUpsertList<T>(opts: {
+  /** Stable identity for an item (e.g. `(x) => x.id`, or `(x) => `${x.source}:${x.externalId}``). */
+  key: (item: T) => unknown
+  /** Insert position for a brand-new item: `true` ⇒ unshift (newest-first), else push. */
+  prepend?: boolean
+  /** Seed contents (copied, not aliased). */
+  initial?: T[]
+}): {
+  items: Ref<T[]>
+  upsert: (item: T) => void
+  remove: (keyValue: unknown) => void
+  get: (keyValue: unknown) => T | undefined
+  hydrate: (next: T[]) => void
+  indexOf: (keyValue: unknown) => number
+} {
+  const items = ref<T[]>(opts.initial ? [...opts.initial] : []) as Ref<T[]>
+
+  function indexOf(keyValue: unknown): number {
+    return items.value.findIndex((x) => opts.key(x) === keyValue)
+  }
+
+  function upsert(item: T) {
+    const i = indexOf(opts.key(item))
+    if (i >= 0) items.value[i] = item
+    else if (opts.prepend) items.value.unshift(item)
+    else items.value.push(item)
+  }
+
+  function remove(keyValue: unknown) {
+    const i = indexOf(keyValue)
+    if (i >= 0) items.value.splice(i, 1)
+  }
+
+  function get(keyValue: unknown): T | undefined {
+    const i = indexOf(keyValue)
+    return i >= 0 ? items.value[i] : undefined
+  }
+
+  function hydrate(next: T[]) {
+    items.value = [...next]
+  }
+
+  return { items, upsert, remove, get, hydrate, indexOf }
+}

package/app/pages/index.vue

@@ -28,6 +28,7 @@ import GitHubOnboarding from '~/components/github/GitHubOnboarding.vue'
 import FragmentLibraryPanel from '~/components/fragments/FragmentLibraryPanel.vue'
 import CommandBar from '~/components/layout/CommandBar.vue'
 import IntegrationsHub from '~/components/layout/IntegrationsHub.vue'
+import PersonalSetupModal from '~/components/layout/PersonalSetupModal.vue'
 import WorkspaceSettingsPanel from '~/components/settings/WorkspaceSettingsPanel.vue'
 import AccountSettingsPanel from '~/components/settings/AccountSettingsPanel.vue'
 import ObservabilityConnectionPanel from '~/components/settings/ObservabilityConnectionPanel.vue'
@@ -189,6 +190,7 @@ watch(
       <FragmentLibraryPanel />
       <CommandBar />
       <IntegrationsHub />
+      <PersonalSetupModal />
       <WorkspaceSettingsPanel />
       <AccountSettingsPanel />
       <ObservabilityConnectionPanel />

package/app/stores/auth.ts

@@ -1,3 +1,4 @@
+import type { LocalModeConfig } from '@cat-factory/contracts'
 import { defineStore } from 'pinia'
 import { computed, ref } from 'vue'
 import type { AuthUser } from '~/types/domain'
@@ -29,7 +30,7 @@ export const useAuthStore = defineStore(
      * `githubPatSetupUrl` is set when local mode has no GitHub PAT configured (drives the
      * setup banner). Null on every other facade.
      */
-    const localMode = ref<{ enabled: boolean; githubPatSetupUrl?: string } | null>(null)
+    const localMode = ref<LocalModeConfig | null>(null)
     /** True once the initial auth handshake has settled. */
     const ready = ref(false)
 

package/app/stores/board.ts

@@ -1,5 +1,6 @@
 import { defineStore } from 'pinia'
 import { ref } from 'vue'
+import type { UpdateBlockInput } from '@cat-factory/contracts'
 import type { Block, BlockType, CreateTaskType, TaskTypeFields } from '~/types/domain'
 import { useServicesStore } from '~/stores/services'
 import { useWorkspaceStore } from '~/stores/workspace'
@@ -295,7 +296,7 @@ export const useBoardStore = defineStore('board', () => {
   }
 
   /** Patch the user-editable fields of a block (title, features, threshold…). */
-  async function updateBlock(id: string, patch: Partial<Block>) {
+  async function updateBlock(id: string, patch: UpdateBlockInput) {
     const b = getBlock(id)
     if (!b) return
     Object.assign(b, patch) // optimistic

package/app/stores/brainstorm.ts

@@ -1,10 +1,10 @@
 import { defineStore } from 'pinia'
 import { ref } from 'vue'
 import type {
+  BrainstormItemStatus,
   BrainstormSession,
   BrainstormStage,
   ResolveBrainstormExceededChoice,
-  ReviewItemStatus,
 } from '~/types/brainstorm'
 import { useWorkspaceStore } from '~/stores/workspace'
 
@@ -123,7 +123,7 @@ export const useBrainstormStore = defineStore('brainstorm', () => {
   async function setItemStatus(
     session: BrainstormSession,
     itemId: string,
-    status: ReviewItemStatus,
+    status: BrainstormItemStatus,
   ) {
     store(await api.setBrainstormItemStatus(workspace.requireId(), session.id, itemId, status))
   }

package/app/stores/clarity.ts

@@ -1,6 +1,10 @@
 import { defineStore } from 'pinia'
 import { ref } from 'vue'
-import type { ClarityReview, ResolveClarityExceededChoice, ReviewItemStatus } from '~/types/clarity'
+import type {
+  ClarityItemStatus,
+  ClarityReview,
+  ResolveClarityExceededChoice,
+} from '~/types/clarity'
 import { useWorkspaceStore } from '~/stores/workspace'
 
 /**
@@ -120,7 +124,7 @@ export const useClarityStore = defineStore('clarity', () => {
   }
 
   /** Set an item's status (dismiss / reopen). */
-  async function setItemStatus(review: ClarityReview, itemId: string, status: ReviewItemStatus) {
+  async function setItemStatus(review: ClarityReview, itemId: string, status: ClarityItemStatus) {
     store(await api.setClarityItemStatus(workspace.requireId(), review.id, itemId, status))
   }