@cat-factory/app 0.36.0 → 0.37.0

package/app/composables/api/reviews.ts

@@ -1,44 +1,69 @@
-import type { ClarityReview, ResolveClarityExceededChoice } from '~/types/clarity'
+import {
+  acceptRequirementRecommendationContract,
+  getBrainstormContract,
+  getClarityReviewContract,
+  getConsensusSessionContract,
+  getRequirementReviewContract,
+  incorporateBrainstormContract,
+  incorporateClarityContract,
+  incorporateRequirementsContract,
+  proceedBrainstormContract,
+  proceedClarityContract,
+  proceedRequirementsContract,
+  reRequestRequirementRecommendationContract,
+  reReviewBrainstormContract,
+  reReviewClarityContract,
+  reReviewRequirementsContract,
+  rejectRequirementRecommendationContract,
+  replyBrainstormItemContract,
+  replyClarityItemContract,
+  replyRequirementItemContract,
+  requestRequirementRecommendationsContract,
+  resolveBrainstormExceededContract,
+  resolveClarityExceededContract,
+  resolveRequirementsExceededContract,
+  updateBrainstormItemStatusContract,
+  updateClarityItemStatusContract,
+  updateRequirementItemStatusContract,
+} from '@cat-factory/contracts'
 import type {
-  BrainstormSession,
-  BrainstormStage,
-  ResolveBrainstormExceededChoice,
-} from '~/types/brainstorm'
-import type { ConsensusSession } from '~/types/consensus'
-import type {
-  RequirementReview,
-  ResolveRequirementsExceededChoice,
-  ReviewItemStatus,
-} from '~/types/requirements'
+  UpdateBrainstormItemStatusInput,
+  UpdateClarityItemStatusInput,
+} from '@cat-factory/contracts'
+import type { ResolveClarityExceededChoice } from '~/types/clarity'
+import type { BrainstormStage, ResolveBrainstormExceededChoice } from '~/types/brainstorm'
+import type { ResolveRequirementsExceededChoice, ReviewItemStatus } from '~/types/requirements'
 import type { ApiContext } from './context'
 
+// The clarity/brainstorm item-status routes accept a narrower set than the full
+// requirements `ReviewItemStatus` (no `recommend_requested`).
+type ClarityItemStatus = UpdateClarityItemStatusInput['status']
+type BrainstormItemStatus = UpdateBrainstormItemStatusInput['status']
+
 /**
  * The two iterative gate reviewers (requirements + clarity) and the consensus
  * session read. Each reviewer follows the same answer → incorporate → re-review
  * → proceed/resolve-exceeded loop.
  */
-export function reviewsApi({ http, ws }: ApiContext) {
+export function reviewsApi({ send, ws }: ApiContext) {
   return {
     // ---- requirements review (stateless reviewer agent) ------------------
     // The current review for a block (null when none has been run). A 503 means
     // the feature is unconfigured (the panel hides on any error here).
     getRequirementReview: (workspaceId: string, blockId: string) =>
-      http<RequirementReview | null>(
-        `${ws(workspaceId)}/blocks/${encodeURIComponent(blockId)}/requirement-review`,
-      ),
+      send(getRequirementReviewContract, { pathPrefix: ws(workspaceId), pathParams: { blockId } }),
 
     // The latest consensus session for a block (`{ session: null }` when none / consensus
     // off). The live transcript also arrives via the `consensus` stream event.
     getConsensusSession: (workspaceId: string, blockId: string) =>
-      http<{ session: ConsensusSession | null }>(
-        `${ws(workspaceId)}/blocks/${encodeURIComponent(blockId)}/consensus-session`,
-      ),
+      send(getConsensusSessionContract, { pathPrefix: ws(workspaceId), pathParams: { blockId } }),
 
     replyRequirementItem: (workspaceId: string, reviewId: string, itemId: string, reply: string) =>
-      http<RequirementReview>(
-        `${ws(workspaceId)}/requirement-reviews/${encodeURIComponent(reviewId)}/items/${encodeURIComponent(itemId)}/reply`,
-        { method: 'POST', body: { reply } },
-      ),
+      send(replyRequirementItemContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { reviewId, itemId },
+        body: { reply },
+      }),
 
     setRequirementItemStatus: (
       workspaceId: string,
@@ -46,35 +71,31 @@ export function reviewsApi({ http, ws }: ApiContext) {
       itemId: string,
       status: ReviewItemStatus,
     ) =>
-      http<RequirementReview>(
-        `${ws(workspaceId)}/requirement-reviews/${encodeURIComponent(reviewId)}/items/${encodeURIComponent(itemId)}`,
-        { method: 'PATCH', body: { status } },
-      ),
+      send(updateRequirementItemStatusContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { reviewId, itemId },
+        body: { status },
+      }),
 
     // Incorporate the answers ASYNCHRONOUSLY (every finding must be answered or dismissed).
     // The durable driver folds them and re-reviews in the background. Optional `feedback` is
     // the "do it differently" lever when redoing a merge. Returns the `incorporating` review
     // at once; a notification calls the user back only if the re-review needs input.
     incorporateRequirements: (workspaceId: string, blockId: string, feedback?: string) =>
-      http<RequirementReview>(
-        `${ws(workspaceId)}/blocks/${encodeURIComponent(blockId)}/requirement-review/incorporate`,
-        { method: 'POST', body: feedback ? { feedback } : {} },
-      ),
+      send(incorporateRequirementsContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { blockId },
+        body: feedback ? { feedback } : {},
+      }),
 
     // Re-review the incorporated document (one more reviewer pass). On convergence the
     // parked run advances; otherwise the response carries the next cycle / cap state.
     reReviewRequirements: (workspaceId: string, blockId: string) =>
-      http<RequirementReview>(
-        `${ws(workspaceId)}/blocks/${encodeURIComponent(blockId)}/requirement-review/re-review`,
-        { method: 'POST' },
-      ),
+      send(reReviewRequirementsContract, { pathPrefix: ws(workspaceId), pathParams: { blockId } }),
 
     // Proceed: settle the requirements and advance the parked run (all findings dismissed).
     proceedRequirements: (workspaceId: string, blockId: string) =>
-      http<RequirementReview>(
-        `${ws(workspaceId)}/blocks/${encodeURIComponent(blockId)}/requirement-review/proceed`,
-        { method: 'POST' },
-      ),
+      send(proceedRequirementsContract, { pathPrefix: ws(workspaceId), pathParams: { blockId } }),
 
     // Resolve a review that hit its iteration cap: extra-round / proceed / stop-reset.
     resolveRequirementsExceeded: (
@@ -82,10 +103,11 @@ export function reviewsApi({ http, ws }: ApiContext) {
       blockId: string,
       choice: ResolveRequirementsExceededChoice,
     ) =>
-      http<RequirementReview>(
-        `${ws(workspaceId)}/blocks/${encodeURIComponent(blockId)}/requirement-review/resolve-exceeded`,
-        { method: 'POST', body: { choice } },
-      ),
+      send(resolveRequirementsExceededContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { blockId },
+        body: { choice },
+      }),
 
     // Ask the Requirement Writer to recommend grounded answers for a batch of findings (by
     // item id). Returns the review with `pending` placeholder recommendations; they fill in
@@ -96,80 +118,77 @@ export function reviewsApi({ http, ws }: ApiContext) {
       itemIds: string[],
       note?: string,
     ) =>
-      http<RequirementReview | null>(
-        `${ws(workspaceId)}/blocks/${encodeURIComponent(blockId)}/requirement-review/recommend`,
-        { method: 'POST', body: { itemIds, ...(note ? { note } : {}) } },
-      ),
+      send(requestRequirementRecommendationsContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { blockId },
+        body: { itemIds, ...(note ? { note } : {}) },
+      }),
 
     // Accept a recommendation (becomes the finding's answer), reject it, or re-request it
     // with a "do it differently" note.
     acceptRecommendation: (workspaceId: string, reviewId: string, recId: string) =>
-      http<RequirementReview>(
-        `${ws(workspaceId)}/requirement-reviews/${encodeURIComponent(reviewId)}/recommendations/${encodeURIComponent(recId)}/accept`,
-        { method: 'POST' },
-      ),
+      send(acceptRequirementRecommendationContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { reviewId, recId },
+      }),
 
     rejectRecommendation: (workspaceId: string, reviewId: string, recId: string) =>
-      http<RequirementReview>(
-        `${ws(workspaceId)}/requirement-reviews/${encodeURIComponent(reviewId)}/recommendations/${encodeURIComponent(recId)}/reject`,
-        { method: 'POST' },
-      ),
+      send(rejectRequirementRecommendationContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { reviewId, recId },
+      }),
 
     reRequestRecommendation: (workspaceId: string, reviewId: string, recId: string, note: string) =>
-      http<RequirementReview>(
-        `${ws(workspaceId)}/requirement-reviews/${encodeURIComponent(reviewId)}/recommendations/${encodeURIComponent(recId)}/re-request`,
-        { method: 'POST', body: { note } },
-      ),
+      send(reRequestRequirementRecommendationContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { reviewId, recId },
+        body: { note },
+      }),
 
     // ---- clarity review (bug-report triage reviewer agent) ---------------
     // The current review for a block (null when none has been run). A 503 means
     // the feature is unconfigured (the panel hides on any error here).
     getClarityReview: (workspaceId: string, blockId: string) =>
-      http<ClarityReview | null>(
-        `${ws(workspaceId)}/blocks/${encodeURIComponent(blockId)}/clarity-review`,
-      ),
+      send(getClarityReviewContract, { pathPrefix: ws(workspaceId), pathParams: { blockId } }),
 
     replyClarityItem: (workspaceId: string, reviewId: string, itemId: string, reply: string) =>
-      http<ClarityReview>(
-        `${ws(workspaceId)}/clarity-reviews/${encodeURIComponent(reviewId)}/items/${encodeURIComponent(itemId)}/reply`,
-        { method: 'POST', body: { reply } },
-      ),
+      send(replyClarityItemContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { reviewId, itemId },
+        body: { reply },
+      }),
 
     setClarityItemStatus: (
       workspaceId: string,
       reviewId: string,
       itemId: string,
-      status: ReviewItemStatus,
+      status: ClarityItemStatus,
     ) =>
-      http<ClarityReview>(
-        `${ws(workspaceId)}/clarity-reviews/${encodeURIComponent(reviewId)}/items/${encodeURIComponent(itemId)}`,
-        { method: 'PATCH', body: { status } },
-      ),
+      send(updateClarityItemStatusContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { reviewId, itemId },
+        body: { status },
+      }),
 
     // Incorporate the answers ASYNCHRONOUSLY (every finding must be answered or dismissed).
     // The durable driver folds them and re-reviews in the background. Optional `feedback` is
     // the "do it differently" lever when redoing a merge. Returns the `incorporating` review
     // at once; a notification calls the user back only if the re-review needs input.
     incorporateClarity: (workspaceId: string, blockId: string, feedback?: string) =>
-      http<ClarityReview>(
-        `${ws(workspaceId)}/blocks/${encodeURIComponent(blockId)}/clarity-review/incorporate`,
-        { method: 'POST', body: feedback ? { feedback } : {} },
-      ),
+      send(incorporateClarityContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { blockId },
+        body: feedback ? { feedback } : {},
+      }),
 
     // Re-review the clarified report (one more reviewer pass). On convergence the parked run
     // advances; otherwise the response carries the next cycle / cap state.
     reReviewClarity: (workspaceId: string, blockId: string) =>
-      http<ClarityReview>(
-        `${ws(workspaceId)}/blocks/${encodeURIComponent(blockId)}/clarity-review/re-review`,
-        { method: 'POST' },
-      ),
+      send(reReviewClarityContract, { pathPrefix: ws(workspaceId), pathParams: { blockId } }),
 
     // Proceed: settle the clarity review and advance the parked run (all findings dismissed).
     proceedClarity: (workspaceId: string, blockId: string) =>
-      http<ClarityReview>(
-        `${ws(workspaceId)}/blocks/${encodeURIComponent(blockId)}/clarity-review/proceed`,
-        { method: 'POST' },
-      ),
+      send(proceedClarityContract, { pathPrefix: ws(workspaceId), pathParams: { blockId } }),
 
     // Resolve a review that hit its iteration cap: extra-round / proceed / stop-reset.
     resolveClarityExceeded: (
@@ -177,35 +196,36 @@ export function reviewsApi({ http, ws }: ApiContext) {
       blockId: string,
       choice: ResolveClarityExceededChoice,
     ) =>
-      http<ClarityReview>(
-        `${ws(workspaceId)}/blocks/${encodeURIComponent(blockId)}/clarity-review/resolve-exceeded`,
-        { method: 'POST', body: { choice } },
-      ),
+      send(resolveClarityExceededContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { blockId },
+        body: { choice },
+      }),
 
     // ---- brainstorm (structured-dialogue agent, stage-scoped) ------------
     // The current session for a block + stage (null when none has been run). A 503 means
     // the feature is unconfigured (the panel hides on any error here).
     getBrainstorm: (workspaceId: string, blockId: string, stage: BrainstormStage) =>
-      http<BrainstormSession | null>(
-        `${ws(workspaceId)}/blocks/${encodeURIComponent(blockId)}/brainstorm/${stage}`,
-      ),
+      send(getBrainstormContract, { pathPrefix: ws(workspaceId), pathParams: { blockId, stage } }),
 
     replyBrainstormItem: (workspaceId: string, sessionId: string, itemId: string, reply: string) =>
-      http<BrainstormSession>(
-        `${ws(workspaceId)}/brainstorm-sessions/${encodeURIComponent(sessionId)}/items/${encodeURIComponent(itemId)}/reply`,
-        { method: 'POST', body: { reply } },
-      ),
+      send(replyBrainstormItemContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { sessionId, itemId },
+        body: { reply },
+      }),
 
     setBrainstormItemStatus: (
       workspaceId: string,
       sessionId: string,
       itemId: string,
-      status: ReviewItemStatus,
+      status: BrainstormItemStatus,
     ) =>
-      http<BrainstormSession>(
-        `${ws(workspaceId)}/brainstorm-sessions/${encodeURIComponent(sessionId)}/items/${encodeURIComponent(itemId)}`,
-        { method: 'PATCH', body: { status } },
-      ),
+      send(updateBrainstormItemStatusContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { sessionId, itemId },
+        body: { status },
+      }),
 
     // Incorporate the picks ASYNCHRONOUSLY (the durable driver folds + re-runs).
     incorporateBrainstorm: (
@@ -214,24 +234,25 @@ export function reviewsApi({ http, ws }: ApiContext) {
       stage: BrainstormStage,
       feedback?: string,
     ) =>
-      http<BrainstormSession>(
-        `${ws(workspaceId)}/blocks/${encodeURIComponent(blockId)}/brainstorm/${stage}/incorporate`,
-        { method: 'POST', body: feedback ? { feedback } : {} },
-      ),
+      send(incorporateBrainstormContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { blockId, stage },
+        body: feedback ? { feedback } : {},
+      }),
 
     // Re-run the brainstorm against the converged direction (one more pass).
     reReviewBrainstorm: (workspaceId: string, blockId: string, stage: BrainstormStage) =>
-      http<BrainstormSession>(
-        `${ws(workspaceId)}/blocks/${encodeURIComponent(blockId)}/brainstorm/${stage}/re-review`,
-        { method: 'POST' },
-      ),
+      send(reReviewBrainstormContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { blockId, stage },
+      }),
 
     // Proceed: settle the brainstorm and advance the parked run (all options dismissed).
     proceedBrainstorm: (workspaceId: string, blockId: string, stage: BrainstormStage) =>
-      http<BrainstormSession>(
-        `${ws(workspaceId)}/blocks/${encodeURIComponent(blockId)}/brainstorm/${stage}/proceed`,
-        { method: 'POST' },
-      ),
+      send(proceedBrainstormContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { blockId, stage },
+      }),
 
     // Resolve a session that hit its iteration cap: extra-round / proceed / stop-reset.
     resolveBrainstormExceeded: (
@@ -240,9 +261,10 @@ export function reviewsApi({ http, ws }: ApiContext) {
       stage: BrainstormStage,
       choice: ResolveBrainstormExceededChoice,
     ) =>
-      http<BrainstormSession>(
-        `${ws(workspaceId)}/blocks/${encodeURIComponent(blockId)}/brainstorm/${stage}/resolve-exceeded`,
-        { method: 'POST', body: { choice } },
-      ),
+      send(resolveBrainstormExceededContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { blockId, stage },
+        body: { choice },
+      }),
   }
 }

package/app/composables/api/sandbox.ts

@@ -1,57 +1,75 @@
-import type {
-  CloneSandboxPromptInput,
-  CreateSandboxExperimentInput,
-  SandboxExperiment,
-  SandboxExperimentDetail,
-  SandboxFixture,
-  SandboxOverview,
-  SandboxPromptVersion,
-  SaveSandboxVersionInput,
-} from '~/types/sandbox'
+import {
+  archiveSandboxPromptContract,
+  cloneSandboxPromptContract,
+  createSandboxExperimentContract,
+  createSandboxFixtureContract,
+  getSandboxExperimentContract,
+  launchSandboxExperimentContract,
+  removeSandboxFixtureContract,
+  sandboxOverviewContract,
+  saveSandboxPromptContract,
+  setSandboxPromptLabelsContract,
+} from '@cat-factory/contracts'
+import type { SendParams } from './client'
 import type { ApiContext } from './context'
 
+// Request bodies are typed from the contract's INPUT shape (`SendParams[...]['body']`),
+// so valibot-defaulted fields (labels / repeats / budgetTokens) stay optional for callers —
+// the contract's exported `*Input` types are the post-default OUTPUT shape and would force
+// callers to supply them.
+type CloneSandboxPromptBody = NonNullable<SendParams<typeof cloneSandboxPromptContract>['body']>
+type SaveSandboxVersionBody = NonNullable<SendParams<typeof saveSandboxPromptContract>['body']>
+type CreateSandboxFixtureBody = NonNullable<SendParams<typeof createSandboxFixtureContract>['body']>
+type CreateSandboxExperimentBody = NonNullable<
+  SendParams<typeof createSandboxExperimentContract>['body']
+>
+
 /**
  * The Sandbox API (the parallel prompt/model testing surface): manage versioned prompt
  * candidates + the fixture library, define experiments (prompt × model × fixture), and
  * launch one to run + grade every cell. Opt-in: every endpoint 503s when the deployment
  * hasn't wired the Sandbox (its dedicated DB / schema).
  */
-export function sandboxApi({ http, ws }: ApiContext) {
-  const base = (workspaceId: string) => `${ws(workspaceId)}/sandbox`
+export function sandboxApi({ send, ws }: ApiContext) {
   return {
     getSandboxOverview: (workspaceId: string) =>
-      http<SandboxOverview>(`${base(workspaceId)}/overview`),
+      send(sandboxOverviewContract, { pathPrefix: ws(workspaceId) }),
 
     // ---- prompt versions -------------------------------------------------
-    cloneSandboxPrompt: (workspaceId: string, body: CloneSandboxPromptInput) =>
-      http<SandboxPromptVersion>(`${base(workspaceId)}/prompts/clone`, { method: 'POST', body }),
-    saveSandboxVersion: (workspaceId: string, body: SaveSandboxVersionInput) =>
-      http<SandboxPromptVersion>(`${base(workspaceId)}/prompts`, { method: 'POST', body }),
+    cloneSandboxPrompt: (workspaceId: string, body: CloneSandboxPromptBody) =>
+      send(cloneSandboxPromptContract, { pathPrefix: ws(workspaceId), body }),
+    saveSandboxVersion: (workspaceId: string, body: SaveSandboxVersionBody) =>
+      send(saveSandboxPromptContract, { pathPrefix: ws(workspaceId), body }),
     setSandboxPromptLabels: (workspaceId: string, promptId: string, labels: string[]) =>
-      http<SandboxPromptVersion>(
-        `${base(workspaceId)}/prompts/${encodeURIComponent(promptId)}/labels`,
-        { method: 'PATCH', body: { labels } },
-      ),
+      send(setSandboxPromptLabelsContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { promptId },
+        body: { labels },
+      }),
     archiveSandboxPrompt: (workspaceId: string, promptId: string) =>
-      http(`${base(workspaceId)}/prompts/${encodeURIComponent(promptId)}`, { method: 'DELETE' }),
+      send(archiveSandboxPromptContract, { pathPrefix: ws(workspaceId), pathParams: { promptId } }),
 
     // ---- fixtures --------------------------------------------------------
-    createSandboxFixture: (workspaceId: string, body: Partial<SandboxFixture>) =>
-      http<SandboxFixture>(`${base(workspaceId)}/fixtures`, { method: 'POST', body }),
+    createSandboxFixture: (workspaceId: string, body: CreateSandboxFixtureBody) =>
+      send(createSandboxFixtureContract, { pathPrefix: ws(workspaceId), body }),
     deleteSandboxFixture: (workspaceId: string, fixtureId: string) =>
-      http(`${base(workspaceId)}/fixtures/${encodeURIComponent(fixtureId)}`, { method: 'DELETE' }),
+      send(removeSandboxFixtureContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { fixtureId },
+      }),
 
     // ---- experiments -----------------------------------------------------
-    createSandboxExperiment: (workspaceId: string, body: CreateSandboxExperimentInput) =>
-      http<SandboxExperiment>(`${base(workspaceId)}/experiments`, { method: 'POST', body }),
+    createSandboxExperiment: (workspaceId: string, body: CreateSandboxExperimentBody) =>
+      send(createSandboxExperimentContract, { pathPrefix: ws(workspaceId), body }),
     getSandboxExperiment: (workspaceId: string, experimentId: string) =>
-      http<SandboxExperimentDetail>(
-        `${base(workspaceId)}/experiments/${encodeURIComponent(experimentId)}`,
-      ),
+      send(getSandboxExperimentContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { experimentId },
+      }),
     launchSandboxExperiment: (workspaceId: string, experimentId: string) =>
-      http<SandboxExperimentDetail>(
-        `${base(workspaceId)}/experiments/${encodeURIComponent(experimentId)}/launch`,
-        { method: 'POST' },
-      ),
+      send(launchSandboxExperimentContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { experimentId },
+      }),
   }
 }

package/app/composables/api/slack.ts

@@ -1,54 +1,51 @@
-import type {
-  SlackChannel,
-  SlackConnection,
-  SlackMemberMappingEntry,
-  SlackNotificationSettings,
-} from '~/types/slack'
+import {
+  connectSlackContract,
+  disconnectSlackContract,
+  getSlackConnectionContract,
+  getSlackInstallUrlContract,
+  getSlackMemberMappingContract,
+  getSlackSettingsContract,
+  listSlackChannelsContract,
+  updateSlackMemberMappingContract,
+  updateSlackSettingsContract,
+} from '@cat-factory/contracts'
+import type { SlackMemberMappingEntry, SlackNotificationSettings } from '~/types/slack'
 import type { ApiContext } from './context'
 
 /** Slack integration: per-account connection, per-workspace routing + member map. */
-export function slackApi({ http, ws }: ApiContext) {
+export function slackApi({ send, ws }: ApiContext) {
   return {
     // ---- slack integration (extra notification transport) -----------------
     // Per-account connection (manual bot-token paste + the OAuth "Add to Slack"
     // URL), per-workspace routing, and the per-account member map. A 503 from
     // `getSlackConnection` means the integration is off (the store hides its UI).
     getSlackConnection: (workspaceId: string) =>
-      http<{ connection: SlackConnection | null; oauthEnabled: boolean }>(
-        `${ws(workspaceId)}/slack/connection`,
-      ),
+      send(getSlackConnectionContract, { pathPrefix: ws(workspaceId) }),
 
     getSlackInstallUrl: (workspaceId: string) =>
-      http<{ url: string }>(`${ws(workspaceId)}/slack/install-url`),
+      send(getSlackInstallUrlContract, { pathPrefix: ws(workspaceId) }),
 
     connectSlack: (workspaceId: string, token: string) =>
-      http<SlackConnection>(`${ws(workspaceId)}/slack/connect`, {
-        method: 'POST',
-        body: { token },
-      }),
+      send(connectSlackContract, { pathPrefix: ws(workspaceId), body: { token } }),
 
     disconnectSlack: (workspaceId: string) =>
-      http(`${ws(workspaceId)}/slack/connection`, { method: 'DELETE' }),
+      send(disconnectSlackContract, { pathPrefix: ws(workspaceId) }),
 
     listSlackChannels: (workspaceId: string) =>
-      http<{ channels: SlackChannel[] }>(`${ws(workspaceId)}/slack/channels`),
+      send(listSlackChannelsContract, { pathPrefix: ws(workspaceId) }),
 
     getSlackSettings: (workspaceId: string) =>
-      http<SlackNotificationSettings>(`${ws(workspaceId)}/slack/settings`),
+      send(getSlackSettingsContract, { pathPrefix: ws(workspaceId) }),
 
     updateSlackSettings: (
       workspaceId: string,
       body: { routes: SlackNotificationSettings['routes']; mentionsEnabled: boolean },
-    ) =>
-      http<SlackNotificationSettings>(`${ws(workspaceId)}/slack/settings`, { method: 'PUT', body }),
+    ) => send(updateSlackSettingsContract, { pathPrefix: ws(workspaceId), body }),
 
     getSlackMemberMapping: (workspaceId: string) =>
-      http<{ entries: SlackMemberMappingEntry[] }>(`${ws(workspaceId)}/slack/member-mapping`),
+      send(getSlackMemberMappingContract, { pathPrefix: ws(workspaceId) }),
 
     updateSlackMemberMapping: (workspaceId: string, entries: SlackMemberMappingEntry[]) =>
-      http<{ entries: SlackMemberMappingEntry[] }>(`${ws(workspaceId)}/slack/member-mapping`, {
-        method: 'PUT',
-        body: { entries },
-      }),
+      send(updateSlackMemberMappingContract, { pathPrefix: ws(workspaceId), body: { entries } }),
   }
 }

package/app/composables/api/spec.ts

@@ -1,4 +1,4 @@
-import type { ServiceSpecView } from '~/types/spec'
+import { getServiceSpecContract } from '@cat-factory/contracts'
 import type { ApiContext } from './context'
 
 /**
@@ -6,9 +6,9 @@ import type { ApiContext } from './context'
  * sharded `spec/` artifact from the service repo's default branch. Always 200: a service
  * with no spec on main (or no GitHub connected) returns `{ present: false }`.
  */
-export function specApi({ http, ws }: ApiContext) {
+export function specApi({ send, ws }: ApiContext) {
   return {
     getServiceSpec: (workspaceId: string, blockId: string) =>
-      http<ServiceSpecView>(`${ws(workspaceId)}/blocks/${encodeURIComponent(blockId)}/spec`),
+      send(getServiceSpecContract, { pathPrefix: ws(workspaceId), pathParams: { blockId } }),
   }
 }