@cat-factory/app 0.6.0

package/app/composables/api/bootstrap.ts

@@ -0,0 +1,62 @@
+import type {
+  AgentRunKind,
+  BootstrapJob,
+  BootstrapRepoInput,
+  CreateReferenceArchitectureInput,
+  ExecutionInstance,
+  ReferenceArchitecture,
+  UpdateReferenceArchitectureInput,
+} from '~/types/domain'
+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) {
+  return {
+    // ---- repo bootstrap ---------------------------------------------------
+    listReferenceArchitectures: (workspaceId: string) =>
+      http<ReferenceArchitecture[]>(`${ws(workspaceId)}/bootstrap/reference-architectures`),
+
+    createReferenceArchitecture: (workspaceId: string, body: CreateReferenceArchitectureInput) =>
+      http<ReferenceArchitecture>(`${ws(workspaceId)}/bootstrap/reference-architectures`, {
+        method: 'POST',
+        body,
+      }),
+
+    updateReferenceArchitecture: (
+      workspaceId: string,
+      id: string,
+      body: UpdateReferenceArchitectureInput,
+    ) =>
+      http<ReferenceArchitecture>(`${ws(workspaceId)}/bootstrap/reference-architectures/${id}`, {
+        method: 'PATCH',
+        body,
+      }),
+
+    deleteReferenceArchitecture: (workspaceId: string, id: string) =>
+      http(`${ws(workspaceId)}/bootstrap/reference-architectures/${id}`, { method: 'DELETE' }),
+
+    bootstrapRepo: (workspaceId: string, body: BootstrapRepoInput) =>
+      http<BootstrapJob>(`${ws(workspaceId)}/bootstrap/jobs`, { method: 'POST', 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) },
+      ),
+
+    // 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' },
+      ),
+  }
+}

package/app/composables/api/context.ts

@@ -0,0 +1,25 @@
+import type { FragmentOwnerKind } from '~/types/domain'
+
+/** The authed `$fetch` instance type — Nuxt's augmented client, as returned by `$fetch.create`. */
+export type ApiHttp = ReturnType<typeof $fetch.create>
+
+/**
+ * Shared plumbing handed to every grouped API module. `useApi()` builds one of
+ * these (the authed `$fetch` client + the path/header helpers) and passes it to
+ * each `*Api(ctx)` factory; the factories return the endpoint methods that
+ * `useApi()` spreads into its single flat client object. Splitting the client
+ * this way keeps call sites unchanged (`useApi().someMethod(...)`) while the
+ * ~100 endpoints live in cohesive per-domain files.
+ */
+export interface ApiContext {
+  /** The authed `$fetch` instance (bearer token + 401 handling pre-wired). */
+  http: ApiHttp
+  /** `/workspaces/:id` path prefix (id encoded). */
+  ws: (workspaceId: string) => string
+  /** Prompt-fragment library prefix, resolved from the owner scope (ADR 0006 §8). */
+  scope: (kind: FragmentOwnerKind, id: string) => string
+  /** The ambient personal-unlock password header (individual-usage vendors). */
+  pwHeaders: (password?: string) => Record<string, string> | undefined
+}
+
+export type Position = { x: number; y: number }

package/app/composables/api/documents.ts

@@ -0,0 +1,74 @@
+import type {
+  DocumentBoardPlan,
+  DocumentConnection,
+  DocumentSearchResult,
+  DocumentSourceDescriptor,
+  DocumentSourceKind,
+  SourceDocument,
+  SpawnResult,
+} from '~/types/domain'
+import type { ApiContext } from './context'
+
+/** Document sources (Confluence, Notion, …): connect, import, search, board-spawn. */
+export function documentsApi({ http, ws }: ApiContext) {
+  return {
+    // ---- document sources (Confluence, Notion, …) -------------------------
+    // The configured sources + their connect/import metadata. A 503 means the
+    // integration is off (the store hides its UI on any error here).
+    listDocumentSources: (workspaceId: string) =>
+      http<{ sources: DocumentSourceDescriptor[] }>(`${ws(workspaceId)}/document-sources`),
+
+    listDocumentConnections: (workspaceId: string) =>
+      http<{ connections: DocumentConnection[] }>(
+        `${ws(workspaceId)}/document-sources/connections`,
+      ),
+
+    connectDocumentSource: (
+      workspaceId: string,
+      source: DocumentSourceKind,
+      credentials: Record<string, string>,
+    ) =>
+      http<DocumentConnection>(`${ws(workspaceId)}/document-sources/${source}/connect`, {
+        method: 'POST',
+        body: { credentials },
+      }),
+
+    disconnectDocumentSource: (workspaceId: string, source: DocumentSourceKind) =>
+      http(`${ws(workspaceId)}/document-sources/${source}/connection`, { method: 'DELETE' }),
+
+    listDocuments: (workspaceId: string) => http<SourceDocument[]>(`${ws(workspaceId)}/documents`),
+
+    importDocument: (workspaceId: string, source: DocumentSourceKind, body: { ref: string }) =>
+      http<SourceDocument>(`${ws(workspaceId)}/document-sources/${source}/import`, {
+        method: 'POST',
+        body,
+      }),
+
+    searchDocumentSource: (workspaceId: string, source: DocumentSourceKind, query: string) =>
+      http<{ results: DocumentSearchResult[] }>(
+        `${ws(workspaceId)}/document-sources/${source}/search`,
+        { method: 'POST', body: { query } },
+      ),
+
+    planDocument: (workspaceId: string, source: DocumentSourceKind, externalId: string) =>
+      http<DocumentBoardPlan>(`${ws(workspaceId)}/document-sources/${source}/plan`, {
+        method: 'POST',
+        body: { externalId },
+      }),
+
+    spawnDocument: (
+      workspaceId: string,
+      source: DocumentSourceKind,
+      body: { externalId: string; frameId?: string },
+    ) =>
+      http<{ plan: DocumentBoardPlan; result: SpawnResult }>(
+        `${ws(workspaceId)}/document-sources/${source}/spawn`,
+        { method: 'POST', body },
+      ),
+
+    linkDocument: (
+      workspaceId: string,
+      body: { source: DocumentSourceKind; externalId: string; blockId: string },
+    ) => http<SourceDocument>(`${ws(workspaceId)}/documents/link`, { method: 'POST', body }),
+  }
+}

package/app/composables/api/execution.ts

@@ -0,0 +1,127 @@
+import type { Block, ExecutionInstance } from '~/types/domain'
+import type {
+  IterationCapChoice,
+  LlmCallMetric,
+  LlmMetricsExport,
+  ReviewComment,
+} from '~/types/execution'
+import type { ApiContext } from './context'
+
+/** Run lifecycle (start/cancel/decisions/approvals/restart) + LLM metrics + spend. */
+export function executionApi({ http, ws, pwHeaders }: ApiContext) {
+  return {
+    // ---- executions -------------------------------------------------------
+    startExecution: (
+      workspaceId: string,
+      blockId: string,
+      body: { pipelineId: string },
+      password?: string,
+    ) =>
+      http<ExecutionInstance>(`${ws(workspaceId)}/blocks/${blockId}/executions`, {
+        method: 'POST',
+        body,
+        headers: pwHeaders(password),
+      }),
+
+    cancelExecution: (workspaceId: string, blockId: string) =>
+      http<Block>(`${ws(workspaceId)}/blocks/${blockId}/executions`, { method: 'DELETE' }),
+
+    mergeBlock: (workspaceId: string, blockId: string) =>
+      http<Block>(`${ws(workspaceId)}/blocks/${blockId}/merge`, { method: 'POST' }),
+
+    resolveDecision: (
+      workspaceId: string,
+      executionId: string,
+      decisionId: string,
+      body: { choice: string },
+      password?: string,
+    ) =>
+      http<ExecutionInstance>(
+        `${ws(workspaceId)}/executions/${executionId}/decisions/${decisionId}`,
+        { method: 'POST', body, headers: pwHeaders(password) },
+      ),
+
+    approveStep: (
+      workspaceId: string,
+      executionId: string,
+      approvalId: string,
+      body: { proposal?: string },
+      password?: string,
+    ) =>
+      http<ExecutionInstance>(
+        `${ws(workspaceId)}/executions/${executionId}/steps/${approvalId}/approve`,
+        { method: 'POST', body, headers: pwHeaders(password) },
+      ),
+
+    requestStepChanges: (
+      workspaceId: string,
+      executionId: string,
+      approvalId: string,
+      body: { feedback?: string; comments?: ReviewComment[] },
+      password?: string,
+    ) =>
+      http<ExecutionInstance>(
+        `${ws(workspaceId)}/executions/${executionId}/steps/${approvalId}/request-changes`,
+        { method: 'POST', body, headers: pwHeaders(password) },
+      ),
+
+    rejectStep: (
+      workspaceId: string,
+      executionId: string,
+      approvalId: string,
+      body: { reason?: string },
+    ) =>
+      http<ExecutionInstance>(
+        `${ws(workspaceId)}/executions/${executionId}/steps/${approvalId}/reject`,
+        { method: 'POST', body },
+      ),
+
+    // Resolve a companion step parked at its rework cap: one more round / proceed /
+    // stop & reset (the companion analogue of resolveRequirementsExceeded).
+    resolveCompanionExceeded: (
+      workspaceId: string,
+      executionId: string,
+      approvalId: string,
+      body: { choice: IterationCapChoice },
+      password?: string,
+    ) =>
+      http<ExecutionInstance>(
+        `${ws(workspaceId)}/executions/${executionId}/steps/${approvalId}/resolve-exceeded`,
+        { method: 'POST', body, headers: pwHeaders(password) },
+      ),
+
+    // Restart a run from a chosen step: re-run from `fromStepIndex` onward (resetting
+    // that step + later steps' iteration counters) while keeping the earlier steps'
+    // outputs as handoff context. Like retry it may need the initiator's personal
+    // password for an individual-usage (Claude) block, prompted + retried on a 428.
+    restartFromStep: (
+      workspaceId: string,
+      executionId: string,
+      fromStepIndex: number,
+      password?: string,
+    ) =>
+      http<ExecutionInstance>(`${ws(workspaceId)}/executions/${executionId}/restart`, {
+        method: 'POST',
+        body: { fromStepIndex },
+        headers: pwHeaders(password),
+      }),
+
+    // ---- LLM observability (per-run model-call metrics) -------------------
+    // The full per-call detail behind the board's step rollups. Empty when the
+    // observability sink is not wired.
+    getLlmMetrics: (workspaceId: string, executionId: string) =>
+      http<{ executionId: string; calls: LlmCallMetric[] }>(
+        `${ws(workspaceId)}/executions/${encodeURIComponent(executionId)}/llm-metrics`,
+      ),
+
+    // The LLM-friendly export bundle (totals + per-agent insights + every call).
+    exportLlmMetrics: (workspaceId: string, executionId: string) =>
+      http<LlmMetricsExport>(
+        `${ws(workspaceId)}/executions/${encodeURIComponent(executionId)}/llm-metrics/export`,
+      ),
+
+    // ---- spend safeguard --------------------------------------------------
+    resumeSpend: (workspaceId: string) =>
+      http<ExecutionInstance[]>(`${ws(workspaceId)}/spend/resume`, { method: 'POST' }),
+  }
+}

package/app/composables/api/fragments.ts

@@ -0,0 +1,71 @@
+import type {
+  CreatePromptFragmentInput,
+  FragmentOwnerKind,
+  FragmentSource,
+  FragmentSourceStatus,
+  FragmentSyncResult,
+  LinkFragmentSourceInput,
+  PromptFragment,
+  ResolvedFragment,
+  UpdatePromptFragmentInput,
+} from '~/types/domain'
+import type { ApiContext } from './context'
+
+/** Best-practice prompt-fragment catalog + the managed, tenant-scoped library. */
+export function fragmentsApi({ http, ws, scope }: ApiContext) {
+  return {
+    // ---- prompt fragments (best-practice catalog) -------------------------
+    getPromptFragments: () => http<PromptFragment[]>('/prompt-fragments'),
+
+    // ---- prompt-fragment library (managed, tenant-scoped; ADR 0006) -------
+    // The merged catalog an agent actually sees for a board (builtin∪account∪ws).
+    getResolvedFragments: (workspaceId: string) =>
+      http<ResolvedFragment[]>(`${ws(workspaceId)}/prompt-fragments/resolved`),
+
+    // Per-tier management (scope = account or workspace).
+    listFragments: (kind: FragmentOwnerKind, id: string) =>
+      http<PromptFragment[]>(`${scope(kind, id)}/prompt-fragments`),
+
+    createFragment: (kind: FragmentOwnerKind, id: string, body: CreatePromptFragmentInput) =>
+      http<PromptFragment>(`${scope(kind, id)}/prompt-fragments`, { method: 'POST', body }),
+
+    updateFragment: (
+      kind: FragmentOwnerKind,
+      id: string,
+      fragmentId: string,
+      body: UpdatePromptFragmentInput,
+    ) =>
+      http<PromptFragment>(
+        `${scope(kind, id)}/prompt-fragments/${encodeURIComponent(fragmentId)}`,
+        { method: 'PATCH', body },
+      ),
+
+    deleteFragment: (kind: FragmentOwnerKind, id: string, fragmentId: string) =>
+      http(`${scope(kind, id)}/prompt-fragments/${encodeURIComponent(fragmentId)}`, {
+        method: 'DELETE',
+      }),
+
+    // Repo sources of guideline Markdown.
+    listFragmentSources: (kind: FragmentOwnerKind, id: string) =>
+      http<FragmentSource[]>(`${scope(kind, id)}/fragment-sources`),
+
+    linkFragmentSource: (kind: FragmentOwnerKind, id: string, body: LinkFragmentSourceInput) =>
+      http<FragmentSource>(`${scope(kind, id)}/fragment-sources`, { method: 'POST', body }),
+
+    unlinkFragmentSource: (kind: FragmentOwnerKind, id: string, sourceId: string) =>
+      http(`${scope(kind, id)}/fragment-sources/${encodeURIComponent(sourceId)}`, {
+        method: 'DELETE',
+      }),
+
+    fragmentSourceStatus: (kind: FragmentOwnerKind, id: string, sourceId: string) =>
+      http<FragmentSourceStatus>(
+        `${scope(kind, id)}/fragment-sources/${encodeURIComponent(sourceId)}/status`,
+      ),
+
+    syncFragmentSource: (kind: FragmentOwnerKind, id: string, sourceId: string) =>
+      http<FragmentSyncResult>(
+        `${scope(kind, id)}/fragment-sources/${encodeURIComponent(sourceId)}/sync`,
+        { method: 'POST' },
+      ),
+  }
+}

package/app/composables/api/github.ts

@@ -0,0 +1,131 @@
+import type {
+  CommitFilesInput,
+  CreateBranchInput,
+  CreatedRepo,
+  CreateRepoRequest,
+  GitHubAvailableRepo,
+  GitHubBranch,
+  GitHubConnection,
+  GitHubInstallationOption,
+  GitHubIssue,
+  GitHubPullRequest,
+  GitHubRepo,
+  MergePullRequestInput,
+  OpenPullRequestInput,
+  RepoTreeEntry,
+  ResyncRequest,
+} from '~/types/domain'
+import type { ApiContext } from './context'
+
+/**
+ * GitHub integration: connection management, the D1-served projection reads
+ * (fast, rate-limit-free) and the repo writes (branches/commits/PRs/merges).
+ */
+export function githubApi({ http, ws }: ApiContext) {
+  return {
+    // ---- github integration ----------------------------------------------
+    // Connection management, projection reads (served from D1 — fast and
+    // rate-limit-free) and repo writes. A 503 from `getGitHubConnection` means
+    // the integration is off (the store hides its UI on any error there).
+    getGitHubInstallUrl: (workspaceId: string) =>
+      http<{ url: string }>(`${ws(workspaceId)}/github/install-url`),
+
+    getGitHubConnection: (workspaceId: string) =>
+      http<{ connection: GitHubConnection | null }>(`${ws(workspaceId)}/github/connection`),
+
+    listGitHubInstallations: (workspaceId: string) =>
+      http<{ installations: GitHubInstallationOption[] }>(
+        `${ws(workspaceId)}/github/installations`,
+      ),
+
+    connectGitHub: (workspaceId: string, installationId: number) =>
+      http<GitHubConnection>(`${ws(workspaceId)}/github/connect`, {
+        method: 'POST',
+        body: { installationId },
+      }),
+
+    disconnectGitHub: (workspaceId: string) =>
+      http(`${ws(workspaceId)}/github/connection`, { method: 'DELETE' }),
+
+    resyncGitHub: (workspaceId: string, body: ResyncRequest = {}) =>
+      http<{ status: string }>(`${ws(workspaceId)}/github/resync`, { method: 'POST', body }),
+
+    listGitHubRepos: (workspaceId: string) => http<GitHubRepo[]>(`${ws(workspaceId)}/github/repos`),
+
+    // Programmatic repo creation (privileged App tier). Only called when the
+    // connection reports `canCreateRepos`; otherwise the UI opens GitHub directly.
+    createGitHubRepo: (workspaceId: string, body: CreateRepoRequest) =>
+      http<CreatedRepo>(`${ws(workspaceId)}/github/repos`, { method: 'POST', body }),
+
+    // Repos the connected installation can access, annotated with whether this
+    // workspace links each (drives the per-workspace repo picker).
+    listGitHubAvailableRepos: (workspaceId: string) =>
+      http<GitHubAvailableRepo[]>(`${ws(workspaceId)}/github/available-repos`),
+
+    // Set the exact set of repos this workspace links.
+    setGitHubLinkedRepos: (workspaceId: string, repoGithubIds: number[]) =>
+      http<GitHubRepo[]>(`${ws(workspaceId)}/github/repos`, {
+        method: 'PUT',
+        body: { repoGithubIds },
+      }),
+
+    // Browse one level of a (monorepo) repo's tree to pin a service to a subdirectory.
+    listGitHubRepoTree: (workspaceId: string, repoGithubId: number, path = '') =>
+      http<RepoTreeEntry[]>(`${ws(workspaceId)}/github/repos/${repoGithubId}/tree`, {
+        query: { path },
+      }),
+
+    listGitHubBranches: (workspaceId: string, repoGithubId: number) =>
+      http<GitHubBranch[]>(`${ws(workspaceId)}/github/repos/${repoGithubId}/branches`),
+
+    listGitHubPullRequests: (workspaceId: string) =>
+      http<GitHubPullRequest[]>(`${ws(workspaceId)}/github/pulls`),
+
+    listGitHubIssues: (workspaceId: string) =>
+      http<GitHubIssue[]>(`${ws(workspaceId)}/github/issues`),
+
+    createGitHubBranch: (workspaceId: string, repoGithubId: number, body: CreateBranchInput) =>
+      http<GitHubBranch>(`${ws(workspaceId)}/github/repos/${repoGithubId}/branches`, {
+        method: 'POST',
+        body,
+      }),
+
+    commitGitHubFiles: (workspaceId: string, repoGithubId: number, body: CommitFilesInput) =>
+      http<{ sha: string }>(`${ws(workspaceId)}/github/repos/${repoGithubId}/commits`, {
+        method: 'POST',
+        body,
+      }),
+
+    openGitHubPullRequest: (
+      workspaceId: string,
+      repoGithubId: number,
+      body: OpenPullRequestInput,
+    ) =>
+      http<GitHubPullRequest>(`${ws(workspaceId)}/github/repos/${repoGithubId}/pulls`, {
+        method: 'POST',
+        body,
+      }),
+
+    mergeGitHubPullRequest: (
+      workspaceId: string,
+      repoGithubId: number,
+      number: number,
+      body: MergePullRequestInput = {},
+    ) =>
+      http(`${ws(workspaceId)}/github/repos/${repoGithubId}/pulls/${number}/merge`, {
+        method: 'PUT',
+        body,
+      }),
+
+    commentGitHubIssue: (
+      workspaceId: string,
+      repoGithubId: number,
+      number: number,
+      bodyText: string,
+    ) =>
+      http(`${ws(workspaceId)}/github/repos/${repoGithubId}/issues/${number}/comments`, {
+        method: 'POST',
+        body: { body: bodyText },
+      }),
+  }
+}

package/app/composables/api/models.ts

@@ -0,0 +1,127 @@
+import type {
+  AddApiKeyInput,
+  ApiKey,
+  ModelDefaults,
+  ModelOption,
+  PersonalSubscriptionStatus,
+  ServiceFragmentDefaults,
+  StorePersonalSubscriptionInput,
+  SubscriptionVendor,
+  VendorCredential,
+} from '~/types/domain'
+import type {
+  LocalModelEndpoint,
+  LocalModelEndpointTestResult,
+  LocalRunner,
+  TestLocalModelEndpointInput,
+  UpsertLocalModelEndpointInput,
+} from '~/types/localModels'
+import type { ApiContext } from './context'
+
+/**
+ * Model catalog + the credential pools that gate selectability (direct-provider
+ * API keys, vendor subscription tokens, per-user personal subscriptions + local
+ * runners) + the per-workspace routing/selection defaults.
+ */
+export function modelsApi({ http, ws }: ApiContext) {
+  return {
+    // ---- model picker catalog (effective per-deployment flavours) ---------
+    getModels: () => http<ModelOption[]>('/models'),
+    // Per-workspace catalog: selectability reflects the workspace's (+ account's +
+    // caller's) configured API keys and subscription tokens (`available` flag).
+    getWorkspaceModels: (workspaceId: string) => http<ModelOption[]>(`${ws(workspaceId)}/models`),
+
+    // ---- direct-provider API keys (the DB-backed pool) --------------------
+    // Onboarded via UI, stored encrypted, pooled + rotated. Scoped to a workspace,
+    // its owning account, or the signed-in user. Keys are write-only (never returned).
+    listWorkspaceApiKeys: (workspaceId: string) =>
+      http<{ keys: ApiKey[] }>(`${ws(workspaceId)}/api-keys`),
+    addWorkspaceApiKey: (workspaceId: string, body: AddApiKeyInput) =>
+      http<ApiKey>(`${ws(workspaceId)}/api-keys`, { method: 'POST', body }),
+    removeWorkspaceApiKey: (workspaceId: string, id: string) =>
+      http(`${ws(workspaceId)}/api-keys/${encodeURIComponent(id)}`, { method: 'DELETE' }),
+    listMyApiKeys: () => http<{ keys: ApiKey[] }>('/me/api-keys'),
+    addMyApiKey: (body: AddApiKeyInput) => http<ApiKey>('/me/api-keys', { method: 'POST', body }),
+    removeMyApiKey: (id: string) =>
+      http(`/me/api-keys/${encodeURIComponent(id)}`, { method: 'DELETE' }),
+    // Account-scoped keys (shared by every workspace in the account); admin-only.
+    listAccountApiKeys: (accountId: string) =>
+      http<{ keys: ApiKey[] }>(`/accounts/${encodeURIComponent(accountId)}/api-keys`),
+    addAccountApiKey: (accountId: string, body: AddApiKeyInput) =>
+      http<ApiKey>(`/accounts/${encodeURIComponent(accountId)}/api-keys`, { method: 'POST', body }),
+    removeAccountApiKey: (accountId: string, id: string) =>
+      http(`/accounts/${encodeURIComponent(accountId)}/api-keys/${encodeURIComponent(id)}`, {
+        method: 'DELETE',
+      }),
+
+    // ---- LLM vendor subscription credentials (the token pool) -------------
+    listVendorCredentials: (workspaceId: string) =>
+      http<{ credentials: VendorCredential[] }>(`${ws(workspaceId)}/vendor-credentials`),
+    addVendorCredential: (
+      workspaceId: string,
+      body: { vendor: SubscriptionVendor; label: string; token: string },
+    ) => http<VendorCredential>(`${ws(workspaceId)}/vendor-credentials`, { method: 'POST', body }),
+    removeVendorCredential: (workspaceId: string, id: string) =>
+      http(`${ws(workspaceId)}/vendor-credentials/${encodeURIComponent(id)}`, { method: 'DELETE' }),
+
+    // ---- personal (individual-usage) subscriptions (per-user, e.g. Claude) ----
+    // Stored per signed-in user, double-encrypted under their personal password.
+    // Metadata only is returned (never the token). User-scoped (no workspace).
+    listPersonalSubscriptions: () =>
+      http<{ subscriptions: PersonalSubscriptionStatus[] }>('/personal-subscriptions'),
+
+    storePersonalSubscription: (body: StorePersonalSubscriptionInput) =>
+      http<PersonalSubscriptionStatus>('/personal-subscriptions', { method: 'POST', body }),
+
+    removePersonalSubscription: (vendor: SubscriptionVendor) =>
+      http(`/personal-subscriptions/${encodeURIComponent(vendor)}`, { method: 'DELETE' }),
+
+    // ---- local model runners (per-user, e.g. Ollama / LM Studio) ----------
+    // A developer's own-machine LLM endpoints, stored per signed-in user (the API
+    // key is write-only, never returned). User-scoped (no workspace). The enabled
+    // models then surface automatically in the per-workspace `/models` catalog.
+    listLocalModelEndpoints: () =>
+      http<{ endpoints: LocalModelEndpoint[] }>('/local-model-endpoints'),
+
+    upsertLocalModelEndpoint: (provider: LocalRunner, body: UpsertLocalModelEndpointInput) =>
+      http<LocalModelEndpoint>(`/local-model-endpoints/${encodeURIComponent(provider)}`, {
+        method: 'PUT',
+        body,
+      }),
+
+    deleteLocalModelEndpoint: (provider: LocalRunner) =>
+      http(`/local-model-endpoints/${encodeURIComponent(provider)}`, { method: 'DELETE' }),
+
+    // Probe a runner endpoint for reachability + the models it currently serves
+    // (no persistence — drives the "Test connection" model multi-select).
+    testLocalModelEndpoint: (body: TestLocalModelEndpointInput) =>
+      http<LocalModelEndpointTestResult>('/local-model-endpoints/test', {
+        method: 'POST',
+        body,
+      }),
+
+    // ---- per-agent-kind default models (workspace routing overrides) ------
+    // The workspace's map of agentKind → model id; a kind absent from the map
+    // falls back to the deployment's env routing. `setModelDefaults` replaces the
+    // whole map (the settings panel sends the full set on every change).
+    getModelDefaults: (workspaceId: string) =>
+      http<ModelDefaults>(`${ws(workspaceId)}/model-defaults`),
+
+    setModelDefaults: (workspaceId: string, defaults: Record<string, string>) =>
+      http<ModelDefaults>(`${ws(workspaceId)}/model-defaults`, {
+        method: 'PUT',
+        body: { defaults },
+      }),
+
+    // The workspace's default service-fragment selection (the fragment ids new
+    // services inherit). `setServiceFragmentDefaults` replaces the whole list.
+    getServiceFragmentDefaults: (workspaceId: string) =>
+      http<ServiceFragmentDefaults>(`${ws(workspaceId)}/service-fragment-defaults`),
+
+    setServiceFragmentDefaults: (workspaceId: string, fragmentIds: string[]) =>
+      http<ServiceFragmentDefaults>(`${ws(workspaceId)}/service-fragment-defaults`, {
+        method: 'PUT',
+        body: { fragmentIds },
+      }),
+  }
+}

package/app/composables/api/notifications.ts

@@ -0,0 +1,23 @@
+import type { Notification } from '~/types/notifications'
+import type { ApiContext } from './context'
+
+/** The human-actionable notification inbox (act / dismiss). */
+export function notificationsApi({ http, ws }: ApiContext) {
+  return {
+    // ---- notifications (human-actionable board items) ---------------------
+    listNotifications: (workspaceId: string) =>
+      http<Notification[]>(`${ws(workspaceId)}/notifications`),
+
+    // Act on a notification (merge the PR / confirm / retry), then resolve it.
+    actNotification: (workspaceId: string, id: string) =>
+      http<Notification>(`${ws(workspaceId)}/notifications/${encodeURIComponent(id)}/act`, {
+        method: 'POST',
+      }),
+
+    // Dismiss a notification without acting.
+    dismissNotification: (workspaceId: string, id: string) =>
+      http<Notification>(`${ws(workspaceId)}/notifications/${encodeURIComponent(id)}/dismiss`, {
+        method: 'POST',
+      }),
+  }
+}

package/app/composables/api/presets.ts

@@ -0,0 +1,29 @@
+import type {
+  CreateMergePresetInput,
+  MergeThresholdPreset,
+  UpdateMergePresetInput,
+} from '~/types/merge'
+import type { ApiContext } from './context'
+
+/** The per-workspace merge-threshold preset library (per-task auto-merge policy). */
+export function presetsApi({ http, ws }: ApiContext) {
+  return {
+    // ---- merge threshold presets (per-task auto-merge policy library) -----
+    listMergePresets: (workspaceId: string) =>
+      http<MergeThresholdPreset[]>(`${ws(workspaceId)}/merge-presets`),
+
+    createMergePreset: (workspaceId: string, body: CreateMergePresetInput) =>
+      http<MergeThresholdPreset>(`${ws(workspaceId)}/merge-presets`, { method: 'POST', body }),
+
+    updateMergePreset: (workspaceId: string, presetId: string, body: UpdateMergePresetInput) =>
+      http<MergeThresholdPreset>(
+        `${ws(workspaceId)}/merge-presets/${encodeURIComponent(presetId)}`,
+        { method: 'PATCH', body },
+      ),
+
+    deleteMergePreset: (workspaceId: string, presetId: string) =>
+      http(`${ws(workspaceId)}/merge-presets/${encodeURIComponent(presetId)}`, {
+        method: 'DELETE',
+      }),
+  }
+}