@cat-factory/app 0.35.0 → 0.37.0

package/app/components/layout/PersonalSetupModal.vue

@@ -0,0 +1,141 @@
+<script setup lang="ts">
+// "My setup": the user-scoped sibling of the Integrations hub. It lists the connections
+// that belong to the SIGNED-IN USER rather than the workspace — a personal GitHub token,
+// own-machine local model runners, and individual-usage (personal) subscriptions — which
+// previously sat, confusingly, among the workspace-wide integrations. Each row reuses the
+// existing per-panel handlers via `ui.openFromPersonal(...)`, so opening one closes this
+// hub, reveals that panel, and gives it a "Back to My setup" control (IntegrationBackTitle).
+const ui = useUiStore()
+const userSecrets = useUserSecretsStore()
+const localModels = useLocalModelsStore()
+const personalSubs = usePersonalSubscriptionsStore()
+
+// Load the cheap user-scoped status whenever the hub opens, so each row's badge is accurate.
+watch(
+  () => ui.personalSetupOpen,
+  (isOpen) => {
+    if (!isOpen) return
+    void userSecrets.load().catch(() => {})
+    void localModels.load().catch(() => {})
+    void personalSubs.load().catch(() => {})
+  },
+)
+
+const open = computed({
+  get: () => ui.personalSetupOpen,
+  set: (v: boolean) => (v ? ui.openPersonalSetup() : ui.closePersonalSetup()),
+})
+
+// One row. `connected` drives the badge; `status` is the connected-state line (a count or
+// "Connected"). Mirrors the Integrations hub's row shape so the two hubs look identical.
+interface PersonalItem {
+  key: string
+  icon: string
+  label: string
+  description: string
+  status?: string
+  connected: boolean
+  onClick: () => void
+}
+
+interface PersonalGroup {
+  title: string
+  items: PersonalItem[]
+}
+
+// Open a user-scoped panel from this hub (sets the "came from My setup" marker).
+function go(fn: () => void) {
+  ui.openFromPersonal(fn)
+}
+
+const groups = computed<PersonalGroup[]>(() => {
+  const out: PersonalGroup[] = []
+
+  // --- Source control --------------------------------------------------------
+  const pat = !!userSecrets.statusFor('github_pat')
+  out.push({
+    title: 'Source control',
+    items: [
+      {
+        key: 'github-pat',
+        icon: 'i-lucide-key-round',
+        label: 'My GitHub token',
+        description: 'A personal access token used for runs you start (pushes, PRs, CI, merge).',
+        status: pat ? 'Connected' : undefined,
+        connected: pat,
+        onClick: () => go(ui.openUserSecrets),
+      },
+    ],
+  })
+
+  // --- Models ----------------------------------------------------------------
+  const runnerCount = localModels.endpoints.length
+  const subCount = personalSubs.subscriptions.length
+  out.push({
+    title: 'Models',
+    items: [
+      {
+        key: 'local-runners',
+        icon: 'i-lucide-server',
+        label: 'My local runners',
+        description: 'Your own-machine model runners (Ollama, LM Studio, vLLM…).',
+        status: runnerCount ? `${runnerCount} connected` : undefined,
+        connected: runnerCount > 0,
+        onClick: () => go(ui.openLocalModels),
+      },
+      {
+        key: 'personal-subs',
+        icon: 'i-lucide-user',
+        label: 'My subscriptions',
+        description:
+          'Individual-usage plans you unlock with a personal password (Claude, GLM, Codex).',
+        status: subCount ? `${subCount} connected` : undefined,
+        connected: subCount > 0,
+        onClick: () => go(() => ui.openVendorCredentials('personal')),
+      },
+    ],
+  })
+
+  return out
+})
+</script>
+
+<template>
+  <UModal v-model:open="open" title="My setup" :ui="{ content: 'max-w-xl' }">
+    <template #body>
+      <div class="space-y-5">
+        <p class="text-xs text-slate-400">
+          Your personal connections — used for runs you start, and visible only to you.
+        </p>
+
+        <section v-for="group in groups" :key="group.title">
+          <h3 class="mb-2 px-1 text-[11px] font-semibold uppercase tracking-wide text-slate-400">
+            {{ group.title }}
+          </h3>
+          <div class="space-y-1.5">
+            <button
+              v-for="item in group.items"
+              :key="item.key"
+              type="button"
+              class="flex w-full items-center gap-3 rounded-lg border border-slate-800 bg-slate-900/50 px-3 py-2.5 text-left transition hover:border-slate-700 hover:bg-slate-900"
+              @click="item.onClick()"
+            >
+              <UIcon :name="item.icon" class="h-5 w-5 shrink-0 text-slate-300" />
+              <div class="min-w-0 flex-1">
+                <div class="flex items-center gap-2">
+                  <span class="truncate text-sm font-medium text-slate-100">{{ item.label }}</span>
+                  <UBadge v-if="item.connected" color="success" variant="subtle" size="sm">
+                    {{ item.status || 'Connected' }}
+                  </UBadge>
+                  <span v-else class="text-[11px] text-slate-500">Not connected</span>
+                </div>
+                <p class="truncate text-xs text-slate-400">{{ item.description }}</p>
+              </div>
+              <UIcon name="i-lucide-chevron-right" class="h-4 w-4 shrink-0 text-slate-500" />
+            </button>
+          </div>
+        </section>
+      </div>
+    </template>
+  </UModal>
+</template>

package/app/components/pipeline/PipelineBuilder.vue

@@ -31,7 +31,7 @@ function toggleGating(i: number) {
   if (!cfg) return
   cfg.gating = cfg.gating?.enabled
     ? { ...cfg.gating, enabled: false }
-    : { enabled: true, minRisk: 0.6, minImpact: 0.6 }
+    : { enabled: true, minRisk: 0.6, minImpact: 0.6, onMissingEstimate: 'consensus' }
 }
 const agents = useAgentsStore()
 const ui = useUiStore()

package/app/components/providers/VendorCredentialsModal.vue

@@ -22,7 +22,9 @@ const back = useIntegrationBack(open)
 
 // Horizontal tabs replace the old long vertical scroll: each credential kind is its own
 // section (pooled subscriptions, direct vendor keys, proxy/gateway keys, personal subs).
-const activeTab = ref('pool')
+// Initialised from the ui store so a caller can deep-link to a tab — the user-scoped
+// "My subscriptions" entry opens straight onto the `personal` tab.
+const activeTab = ref(ui.vendorCredentialsTab)
 const tabs = [
   { value: 'pool', label: 'Workspace pool', icon: 'i-lucide-users', slot: 'pool' },
   { value: 'direct', label: 'Direct providers', icon: 'i-lucide-key-round', slot: 'direct' },
@@ -51,7 +53,10 @@ const token = ref('')
 const busy = ref(false)
 
 watch(open, (isOpen) => {
-  if (isOpen && workspace.workspaceId) void creds.load(workspace.workspaceId)
+  if (!isOpen) return
+  // Honour a deep-linked tab each time the modal opens (e.g. "My subscriptions" → personal).
+  activeTab.value = ui.vendorCredentialsTab
+  if (workspace.workspaceId) void creds.load(workspace.workspaceId)
 })
 
 /** Step-by-step instructions for the selected vendor. */

package/app/components/slack/SlackPanel.vue

@@ -45,6 +45,7 @@ const routes = reactive<Record<NotificationType, SlackRoute>>({
   // In-app only (not in ROUTABLE), but the map is exhaustive over the type.
   decision_required: { enabled: false, channel: '' },
   human_test_ready: { enabled: false, channel: '' },
+  human_review: { enabled: false, channel: '' },
   followup_pending: { enabled: false, channel: '' },
 })
 const mentionsEnabled = ref(false)

package/app/composables/api/accounts.ts

@@ -1,93 +1,78 @@
-import type {
-  Account,
-  AccountInvitation,
-  AccountMember,
-  AccountRole,
-  AddMemberInput,
-  EmailConnection,
-  UpdateAccountInput,
-} from '~/types/domain'
-import type { AccountSettingsView, UpdateAccountSettingsInput } from '~/types/accountSettings'
+import {
+  addAccountMemberContract,
+  connectEmailContract,
+  createAccountContract,
+  createInvitationContract,
+  disconnectEmailContract,
+  getAccountSettingsContract,
+  getEmailConnectionContract,
+  listAccountMembersContract,
+  listAccountsContract,
+  listInvitationsContract,
+  revokeInvitationContract,
+  setMemberRolesContract,
+  testEmailContract,
+  updateAccountContract,
+  updateAccountSettingsContract,
+} from '@cat-factory/contracts'
+import type { AccountRole, UpdateAccountInput } from '~/types/domain'
+import type { UpdateAccountSettingsInput } from '~/types/accountSettings'
 import type { ApiContext } from './context'
 
 /** Account (tenancy) management: orgs, members, invitations + the email sender. */
-export function accountsApi({ http }: ApiContext) {
+export function accountsApi({ send }: ApiContext) {
   return {
     // ---- accounts (tenancy) -----------------------------------------------
     // The accounts the user can switch between (personal + orgs), org creation
     // and membership management. Empty when auth is disabled (dev).
-    listAccounts: () => http<Account[]>('/accounts'),
+    listAccounts: () => send(listAccountsContract, {}),
 
     createAccount: (body: { name: string; githubAccountLogin?: string }) =>
-      http<Account>('/accounts', { method: 'POST', body }),
+      send(createAccountContract, { body }),
 
     updateAccount: (accountId: string, body: UpdateAccountInput) =>
-      http<Account>(`/accounts/${encodeURIComponent(accountId)}`, { method: 'PATCH', body }),
+      send(updateAccountContract, { pathParams: { accountId }, body }),
 
     listAccountMembers: (accountId: string) =>
-      http<AccountMember[]>(`/accounts/${encodeURIComponent(accountId)}/members`),
+      send(listAccountMembersContract, { pathParams: { accountId } }),
 
-    addAccountMember: (accountId: string, body: AddMemberInput) =>
-      http<AccountMember>(`/accounts/${encodeURIComponent(accountId)}/members`, {
-        method: 'POST',
-        body,
-      }),
+    addAccountMember: (accountId: string, body: { userId: string; roles?: AccountRole[] }) =>
+      send(addAccountMemberContract, { pathParams: { accountId }, body }),
 
     setMemberRoles: (accountId: string, userId: string, roles: AccountRole[]) =>
-      http<AccountMember>(
-        `/accounts/${encodeURIComponent(accountId)}/members/${encodeURIComponent(userId)}/roles`,
-        { method: 'PATCH', body: { roles } },
-      ),
+      send(setMemberRolesContract, { pathParams: { accountId, userId }, body: { roles } }),
 
     // Invitations: invite teammates by email into an org account.
     listInvitations: (accountId: string) =>
-      http<AccountInvitation[]>(`/accounts/${encodeURIComponent(accountId)}/invitations`),
+      send(listInvitationsContract, { pathParams: { accountId } }),
 
     createInvitation: (accountId: string, body: { email: string; roles?: AccountRole[] }) =>
-      http<{ invitation: AccountInvitation; acceptUrl: string | null }>(
-        `/accounts/${encodeURIComponent(accountId)}/invitations`,
-        { method: 'POST', body },
-      ),
+      send(createInvitationContract, { pathParams: { accountId }, body }),
 
     revokeInvitation: (accountId: string, invitationId: string) =>
-      http(
-        `/accounts/${encodeURIComponent(accountId)}/invitations/${encodeURIComponent(invitationId)}`,
-        { method: 'DELETE' },
-      ),
+      send(revokeInvitationContract, { pathParams: { accountId, invitationId } }),
 
     // Per-account email sender (UI-onboarded): connect/inspect/disconnect/test.
     getEmailConnection: (accountId: string) =>
-      http<{ connection: EmailConnection | null; configured: boolean }>(
-        `/accounts/${encodeURIComponent(accountId)}/email-connection`,
-      ),
+      send(getEmailConnectionContract, { pathParams: { accountId } }),
 
     connectEmail: (
       accountId: string,
       body: { provider: 'sendgrid' | 'resend'; apiKey: string; fromAddress: string },
-    ) =>
-      http<EmailConnection>(`/accounts/${encodeURIComponent(accountId)}/email-connection`, {
-        method: 'POST',
-        body,
-      }),
+    ) => send(connectEmailContract, { pathParams: { accountId }, body }),
 
     disconnectEmail: (accountId: string) =>
-      http(`/accounts/${encodeURIComponent(accountId)}/email-connection`, { method: 'DELETE' }),
+      send(disconnectEmailContract, { pathParams: { accountId } }),
 
     testEmail: (accountId: string, to: string) =>
-      http<{ ok: boolean }>(`/accounts/${encodeURIComponent(accountId)}/email-connection/test`, {
-        method: 'POST',
-        body: { to },
-      }),
+      send(testEmailContract, { pathParams: { accountId }, body: { to } }),
 
     // Per-account deployment settings (admin only): integration secrets (Slack OAuth +
     // web-search keys), sealed at rest. Read returns config + non-secret summary only.
     getAccountSettings: (accountId: string) =>
-      http<AccountSettingsView>(`/accounts/${encodeURIComponent(accountId)}/settings`),
+      send(getAccountSettingsContract, { pathParams: { accountId } }),
 
     updateAccountSettings: (accountId: string, body: UpdateAccountSettingsInput) =>
-      http<AccountSettingsView>(`/accounts/${encodeURIComponent(accountId)}/settings`, {
-        method: 'PUT',
-        body,
-      }),
+      send(updateAccountSettingsContract, { pathParams: { accountId }, body }),
   }
 }

package/app/composables/api/auth.ts

@@ -1,42 +1,43 @@
-import type { AuthUser } from '~/types/domain'
+import {
+  acceptInvitationContract,
+  authConfigContract,
+  logoutContract,
+  meContract,
+  passwordLoginContract,
+  peekInvitationContract,
+  signupContract,
+} from '@cat-factory/contracts'
 import type { ApiContext } from './context'
 
 /** Auth/session endpoints + the events-WebSocket ticket mint. */
-export function authApi({ http, ws }: ApiContext) {
+export function authApi({ http, send, ws }: ApiContext) {
   return {
     // ---- auth -------------------------------------------------------------
-    getAuthConfig: () =>
-      http<{
-        enabled: boolean
-        providers?: { github: boolean; password: boolean; google: boolean }
-        /** Local-mode signals; present only when the backend is the local facade. */
-        localMode?: { enabled: boolean; githubPatSetupUrl?: string }
-      }>('/auth/config'),
+    // The `/auth/*` JSON endpoints are mounted under the `/auth` prefix; their
+    // contract paths are relative to it.
+    getAuthConfig: () => send(authConfigContract, { pathPrefix: '/auth' }),
 
-    getMe: () => http<{ user: AuthUser | null; enabled: boolean }>('/auth/me'),
+    getMe: () => send(meContract, { pathPrefix: '/auth' }),
 
     signup: (body: { email: string; password: string; name?: string; invite?: string }) =>
-      http<{ token: string; user: AuthUser }>('/auth/signup', { method: 'POST', body }),
+      send(signupContract, { pathPrefix: '/auth', body }),
 
     passwordLogin: (body: { email: string; password: string }) =>
-      http<{ token: string; user: AuthUser }>('/auth/password-login', { method: 'POST', body }),
+      send(passwordLoginContract, { pathPrefix: '/auth', body }),
 
     peekInvite: (token: string) =>
-      http<{ valid: boolean; email?: string; accountName?: string | null }>(
-        `/auth/invitations/${encodeURIComponent(token)}`,
-      ),
+      send(peekInvitationContract, { pathPrefix: '/auth', pathParams: { token } }),
 
     acceptInvite: (token: string) =>
-      http<{ accountId: string }>(`/auth/invitations/${encodeURIComponent(token)}/accept`, {
-        method: 'POST',
-      }),
+      send(acceptInvitationContract, { pathPrefix: '/auth', pathParams: { token } }),
 
-    logout: () => http('/auth/logout', { method: 'POST' }),
+    logout: () => send(logoutContract, { pathPrefix: '/auth' }),
 
     // Mint a short-lived, workspace-scoped ticket for the events WebSocket. A
     // browser can't set Authorization on a WS handshake, so the socket auths from
     // this `?ticket=` instead of the long-lived session token. Empty string when
     // auth is disabled (dev) — the handshake is open in that case.
+    // No route contract exists for this endpoint, so it stays on the raw `http` client.
     mintEventsTicket: (workspaceId: string) =>
       http<{ ticket: string; expiresInMs?: number }>(`${ws(workspaceId)}/events/ticket`, {
         method: 'POST',

package/app/composables/api/board.ts

@@ -1,34 +1,42 @@
-import type { Block, BlockType, CreateTaskType, Pipeline, TaskTypeFields } from '~/types/domain'
-import type { ConsensusStepConfig, StepGating } from '~/types/consensus'
+import {
+  addEpicContract,
+  addFrameContract,
+  addModuleContract,
+  addServiceFromRepoContract,
+  addTaskContract,
+  assignEpicContract,
+  clonePipelineContract,
+  createPipelineContract,
+  deletePipelineContract,
+  listPipelinesContract,
+  moveBlockContract,
+  organizePipelineContract,
+  removeBlockContract,
+  reparentBlockContract,
+  toggleDependencyContract,
+  updateBlockContract,
+  updatePipelineContract,
+} from '@cat-factory/contracts'
+import type {
+  CreatePipelineInput,
+  UpdateBlockInput,
+  UpdatePipelineInput,
+} from '@cat-factory/contracts'
+import type { BlockType, CreateTaskType, TaskTypeFields } from '~/types/domain'
 import type { ApiContext, Position } from './context'
 
-/**
- * Create/update body for a pipeline. `name`+`agentKinds` required on create, all optional on
- * update; the parallel arrays are aligned to `agentKinds` and persisted only when non-default.
- */
-interface PipelineWriteBody {
-  name?: string
-  agentKinds?: string[]
-  gates?: boolean[]
-  thresholds?: (number | null)[]
-  enabled?: boolean[]
-  consensus?: (ConsensusStepConfig | null)[]
-  gating?: (StepGating | null)[]
-  labels?: string[]
-}
-
 /** Board structure: block (frame/module/task) mutations + the pipeline library. */
-export function boardApi({ http, ws }: ApiContext) {
+export function boardApi({ send, ws }: ApiContext) {
   return {
     // ---- blocks -----------------------------------------------------------
     addFrame: (workspaceId: string, body: { type: BlockType; position: Position }) =>
-      http<Block>(`${ws(workspaceId)}/blocks`, { method: 'POST', body }),
+      send(addFrameContract, { pathPrefix: ws(workspaceId), body }),
 
     // Import an existing GitHub repo as a service frame (no bootstrap run).
     addServiceFromRepo: (
       workspaceId: string,
       body: { repoGithubId: number; position?: Position; directory?: string; isMonorepo?: boolean },
-    ) => http<Block>(`${ws(workspaceId)}/blocks/from-repo`, { method: 'POST', body }),
+    ) => send(addServiceFromRepoContract, { pathPrefix: ws(workspaceId), body }),
 
     addTask: (
       workspaceId: string,
@@ -44,54 +52,65 @@ export function boardApi({ http, ws }: ApiContext) {
         agentConfig?: Record<string, string>
         technical?: boolean
       },
-    ) => http<Block>(`${ws(workspaceId)}/blocks/${blockId}/tasks`, { method: 'POST', body }),
+    ) => send(addTaskContract, { pathPrefix: ws(workspaceId), pathParams: { blockId }, body }),
 
     addModule: (
       workspaceId: string,
       blockId: string,
       body: { name: string; position?: Position },
-    ) => http<Block>(`${ws(workspaceId)}/blocks/${blockId}/modules`, { method: 'POST', body }),
+    ) => send(addModuleContract, { pathPrefix: ws(workspaceId), pathParams: { blockId }, body }),
 
     // Create an epic grouping node (optionally placed under a service/module).
     addEpic: (
       workspaceId: string,
       body: { title: string; description?: string; position: Position; parentId?: string },
-    ) => http<Block>(`${ws(workspaceId)}/epics`, { method: 'POST', body }),
+    ) => send(addEpicContract, { pathPrefix: ws(workspaceId), body }),
 
     // Assign a task to an epic, or detach it (epicId: null).
     assignToEpic: (workspaceId: string, blockId: string, body: { epicId: string | null }) =>
-      http<Block>(`${ws(workspaceId)}/blocks/${blockId}/epic`, { method: 'POST', body }),
+      send(assignEpicContract, { pathPrefix: ws(workspaceId), pathParams: { blockId }, body }),
 
-    updateBlock: (workspaceId: string, blockId: string, body: Partial<Block>) =>
-      http<Block>(`${ws(workspaceId)}/blocks/${blockId}`, { method: 'PATCH', body }),
+    updateBlock: (workspaceId: string, blockId: string, body: UpdateBlockInput) =>
+      send(updateBlockContract, { pathPrefix: ws(workspaceId), pathParams: { blockId }, body }),
 
     moveBlock: (workspaceId: string, blockId: string, body: { position: Position }) =>
-      http<Block>(`${ws(workspaceId)}/blocks/${blockId}/move`, { method: 'POST', body }),
+      send(moveBlockContract, { pathPrefix: ws(workspaceId), pathParams: { blockId }, body }),
 
     reparentBlock: (
       workspaceId: string,
       blockId: string,
       body: { parentId: string; position: Position },
-    ) => http<Block>(`${ws(workspaceId)}/blocks/${blockId}/reparent`, { method: 'POST', body }),
+    ) =>
+      send(reparentBlockContract, { pathPrefix: ws(workspaceId), pathParams: { blockId }, body }),
 
     removeBlock: (workspaceId: string, blockId: string) =>
-      http(`${ws(workspaceId)}/blocks/${blockId}`, { method: 'DELETE' }),
+      send(removeBlockContract, { pathPrefix: ws(workspaceId), pathParams: { blockId } }),
 
     toggleDependency: (workspaceId: string, blockId: string, body: { sourceId: string }) =>
-      http<Block>(`${ws(workspaceId)}/blocks/${blockId}/dependencies`, { method: 'POST', body }),
+      send(toggleDependencyContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { blockId },
+        body,
+      }),
 
     // ---- pipelines --------------------------------------------------------
-    listPipelines: (workspaceId: string) => http<Pipeline[]>(`${ws(workspaceId)}/pipelines`),
+    listPipelines: (workspaceId: string) =>
+      send(listPipelinesContract, { pathPrefix: ws(workspaceId) }),
 
-    createPipeline: (workspaceId: string, body: PipelineWriteBody) =>
-      http<Pipeline>(`${ws(workspaceId)}/pipelines`, { method: 'POST', body }),
+    createPipeline: (workspaceId: string, body: CreatePipelineInput) =>
+      send(createPipelineContract, { pathPrefix: ws(workspaceId), body }),
 
-    updatePipeline: (workspaceId: string, pipelineId: string, body: PipelineWriteBody) =>
-      http<Pipeline>(`${ws(workspaceId)}/pipelines/${pipelineId}`, { method: 'PATCH', body }),
+    updatePipeline: (workspaceId: string, pipelineId: string, body: UpdatePipelineInput) =>
+      send(updatePipelineContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { pipelineId },
+        body,
+      }),
 
     clonePipeline: (workspaceId: string, pipelineId: string, body: { name?: string } = {}) =>
-      http<Pipeline>(`${ws(workspaceId)}/pipelines/${pipelineId}/clone`, {
-        method: 'POST',
+      send(clonePipelineContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { pipelineId },
         body,
       }),
 
@@ -102,12 +121,13 @@ export function boardApi({ http, ws }: ApiContext) {
       pipelineId: string,
       body: { labels?: string[]; archived?: boolean },
     ) =>
-      http<Pipeline>(`${ws(workspaceId)}/pipelines/${pipelineId}/organize`, {
-        method: 'PATCH',
+      send(organizePipelineContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { pipelineId },
         body,
       }),
 
     removePipeline: (workspaceId: string, pipelineId: string) =>
-      http(`${ws(workspaceId)}/pipelines/${pipelineId}`, { method: 'DELETE' }),
+      send(deletePipelineContract, { pathPrefix: ws(workspaceId), pathParams: { pipelineId } }),
   }
 }

package/app/composables/api/bootstrap.ts

@@ -1,10 +1,15 @@
+import {
+  createReferenceArchitectureContract,
+  deleteReferenceArchitectureContract,
+  listReferenceArchitecturesContract,
+  retryAgentRunContract,
+  startBootstrapJobContract,
+  stopAgentRunContract,
+  updateReferenceArchitectureContract,
+} from '@cat-factory/contracts'
 import type {
-  AgentRunKind,
-  BootstrapJob,
   BootstrapRepoInput,
   CreateReferenceArchitectureInput,
-  ExecutionInstance,
-  ReferenceArchitecture,
   UpdateReferenceArchitectureInput,
 } from '~/types/domain'
 import type { ApiContext } from './context'
@@ -13,50 +18,48 @@ import type { ApiContext } from './context'
  * Repo bootstrap (reference architectures + bootstrap jobs) and the unified
  * agent-run failure/retry/stop surface shared by bootstrap + execution runs.
  */
-export function bootstrapApi({ http, ws, pwHeaders }: ApiContext) {
+export function bootstrapApi({ send, sendWith, ws, pwHeaders }: ApiContext) {
   return {
     // ---- repo bootstrap ---------------------------------------------------
     listReferenceArchitectures: (workspaceId: string) =>
-      http<ReferenceArchitecture[]>(`${ws(workspaceId)}/bootstrap/reference-architectures`),
+      send(listReferenceArchitecturesContract, { pathPrefix: ws(workspaceId) }),
 
     createReferenceArchitecture: (workspaceId: string, body: CreateReferenceArchitectureInput) =>
-      http<ReferenceArchitecture>(`${ws(workspaceId)}/bootstrap/reference-architectures`, {
-        method: 'POST',
-        body,
-      }),
+      send(createReferenceArchitectureContract, { pathPrefix: ws(workspaceId), body }),
 
     updateReferenceArchitecture: (
       workspaceId: string,
       id: string,
       body: UpdateReferenceArchitectureInput,
     ) =>
-      http<ReferenceArchitecture>(`${ws(workspaceId)}/bootstrap/reference-architectures/${id}`, {
-        method: 'PATCH',
+      send(updateReferenceArchitectureContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { id },
         body,
       }),
 
     deleteReferenceArchitecture: (workspaceId: string, id: string) =>
-      http(`${ws(workspaceId)}/bootstrap/reference-architectures/${id}`, { method: 'DELETE' }),
+      send(deleteReferenceArchitectureContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { id },
+      }),
 
     bootstrapRepo: (workspaceId: string, body: BootstrapRepoInput) =>
-      http<BootstrapJob>(`${ws(workspaceId)}/bootstrap/jobs`, { method: 'POST', body }),
+      send(startBootstrapJobContract, { pathPrefix: ws(workspaceId), body }),
 
     // ---- agent runs (unified failure + retry) -----------------------------
     // Retry any failed run (bootstrap or execution); the backend resolves the
     // kind from the unified `agent_runs` table and re-drives the right flow.
     retryAgentRun: (workspaceId: string, runId: string, password?: string) =>
-      http<{ kind: AgentRunKind; run: ExecutionInstance | BootstrapJob }>(
-        `${ws(workspaceId)}/agent-runs/${encodeURIComponent(runId)}/retry`,
-        { method: 'POST', headers: pwHeaders(password) },
-      ),
+      sendWith(pwHeaders(password), retryAgentRunContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { id: runId },
+      }),
 
     // Explicitly stop a running run (bootstrap or execution): the backend kills the
     // per-run container and tears down the durable driver, then marks the run
     // terminally cancelled so the board stops showing it as running.
     stopAgentRun: (workspaceId: string, runId: string) =>
-      http<{ kind: AgentRunKind; run: ExecutionInstance | BootstrapJob }>(
-        `${ws(workspaceId)}/agent-runs/${encodeURIComponent(runId)}/stop`,
-        { method: 'POST' },
-      ),
+      send(stopAgentRunContract, { pathPrefix: ws(workspaceId), pathParams: { id: runId } }),
   }
 }