@kelpie/server 0.9.0 → 0.11.0

package/src/modules/lists/index.ts

@@ -1,5 +1,11 @@
+import type { EventActor } from '@kelpie/schemas'
+
+import type { Database } from '../../lib/database.ts'
 import type { KelpieModule } from '../../runtime/module.ts'
+import type { TransactionScope } from '../../runtime/transaction.ts'
+import type { RecordTargetType } from '../recordTargets.ts'
 import { listsEvents } from './events.ts'
+import * as repository from './repository.ts'
 import { mountListsRoutes } from './routes.ts'
 import * as schema from './schema.ts'
 import { createListsService } from './service.ts'
@@ -39,3 +45,68 @@ export function createListsModule(migrationsDirectory: string): KelpieModule {
     },
   }
 }
+
+/** Dependencies a caller outside the lists module already holds. */
+export interface RemoveListMemberByTargetDependencies {
+  readonly db: Database
+  readonly transaction: TransactionScope
+}
+
+export interface RemoveListMemberByTargetInput {
+  readonly workspaceId: string
+  readonly listId: string
+  readonly targetType: RecordTargetType
+  readonly targetId: string
+  /**
+   * The event actor to stamp on `lists.member.removed`. An integration webhook
+   * that has no signed-in user passes `{ kind: 'system' }`; a module acting on
+   * behalf of a user passes `{ kind: 'user', id: userId }`.
+   */
+  readonly actor: EventActor
+}
+
+/**
+ * Removes a person (or any record) from a list by target, from outside the lists module.
+ *
+ * The path an integration takes when a signal from an external system removes
+ * membership — a Resend unsubscribe removing the person from every mapped list,
+ * a compliance sweep evicting a record — and there is no signed-in user to
+ * hang a normal `removeMember(actor, listId, id)` call on. Every safeguard the
+ * REST route enforces (workspace membership, ownership of the list, presence
+ * of the member row) is skipped here on purpose: the caller has already
+ * decided, and the input is trusted because it comes from another module in
+ * the same assembly rather than a request body.
+ *
+ * @returns `true` if the row was on the list and is now gone (emits
+ *   `lists.member.removed`), `false` if the target was not a member — a no-op
+ *   so a delivery redelivered by an at-least-once webhook is safe.
+ */
+export async function removeListMemberByTarget(
+  dependencies: RemoveListMemberByTargetDependencies,
+  input: RemoveListMemberByTargetInput,
+): Promise<boolean> {
+  return dependencies.transaction(
+    async ({ tx, events }) => {
+      const deleted = await repository.deleteListMemberByTarget(
+        tx,
+        input.workspaceId,
+        input.listId,
+        input.targetType,
+        input.targetId,
+      )
+
+      if (deleted === undefined) {
+        return false
+      }
+
+      events.emit(
+        'lists.member.removed',
+        { type: input.targetType, id: input.targetId },
+        { listId: input.listId },
+      )
+
+      return true
+    },
+    { workspaceId: input.workspaceId, actor: input.actor },
+  )
+}

package/src/modules/lists/repository.ts

@@ -111,7 +111,6 @@ export async function findList(
 export interface ListIdRow {
   readonly id: string
   readonly targetType: string
-  readonly consentPurposeId: string | null
 }
 
 export async function listListsById(
@@ -127,7 +126,6 @@ export async function listListsById(
     .select({
       id: lists.id,
       targetType: lists.targetType,
-      consentPurposeId: lists.consentPurposeId,
     })
     .from(lists)
     .where(and(eq(lists.workspaceId, workspaceId), inArray(lists.id, ids)))
@@ -270,6 +268,40 @@ export async function deleteListMember(
   return deleted.length
 }
 
+/**
+ * Removes the membership that points at a given target, if one is on the list.
+ *
+ * The addressed-by-target counterpart to `deleteListMember`, which addresses a
+ * row by its own id. An inbound integration webhook (Resend unsubscribe, for
+ * example) knows the person, not the list_member row that ties them to a list,
+ * and reading the row just to delete it is a round trip that adds nothing.
+ *
+ * @returns The removed row's id, or undefined if no member of that list points
+ *   at that target — the same shape a caller wanting to decide whether to emit
+ *   `lists.member.removed` needs.
+ */
+export async function deleteListMemberByTarget(
+  db: Queryable,
+  workspaceId: string,
+  listId: string,
+  targetType: string,
+  targetId: string,
+): Promise<{ id: string } | undefined> {
+  const [deleted] = await db
+    .delete(listMembers)
+    .where(
+      and(
+        eq(listMembers.workspaceId, workspaceId),
+        eq(listMembers.listId, listId),
+        eq(listMembers.targetType, targetType),
+        eq(listMembers.targetId, targetId),
+      ),
+    )
+    .returning({ id: listMembers.id })
+
+  return deleted
+}
+
 /** A membership row enriched with the list it points at. */
 export interface MembershipWithList {
   readonly id: string

package/src/modules/lists/routes.ts

@@ -31,14 +31,12 @@ export const createBody = z.strictObject({
   name: z.string().min(1),
   target_type: z.enum(RECORD_TARGET_TYPES),
   description: z.string().nullable().default(null),
-  consent_purpose_id: z.string().min(1).nullable().default(null),
 })
 
 export const updateBody = z
   .strictObject({
     name: z.string().min(1),
     description: z.string().nullable(),
-    consent_purpose_id: z.string().min(1).nullable(),
   })
   .partial()
 
@@ -56,7 +54,6 @@ export function toCreateInput(body: z.infer<typeof createBody>): CreateListInput
     name: body.name,
     targetType: body.target_type,
     description: body.description,
-    consentPurposeId: body.consent_purpose_id,
   }
 }
 
@@ -64,9 +61,6 @@ export function toUpdateInput(body: z.infer<typeof updateBody>): UpdateListInput
   return {
     ...(body.name === undefined ? {} : { name: body.name }),
     ...(body.description === undefined ? {} : { description: body.description }),
-    ...(body.consent_purpose_id === undefined
-      ? {}
-      : { consentPurposeId: body.consent_purpose_id }),
   }
 }
 
@@ -84,8 +78,6 @@ export function listResponse(list: ListView): Record<string, unknown> {
     description: list.description,
     target_type: list.targetType,
     member_count: list.memberCount,
-    consent_purpose_id: list.consentPurposeId,
-    consent_purpose_slug: list.consentPurposeSlug,
     created_at: list.createdAt.toISOString(),
     updated_at: list.updatedAt.toISOString(),
   }

package/src/modules/lists/schema.ts

@@ -2,7 +2,6 @@ import { RECORD_TARGET_TYPES } from '@kelpie/schemas'
 import { foreignKey, index, pgTable, text, timestamp, unique } from 'drizzle-orm/pg-core'
 
 import { checkOneOf, createdAt, primaryId, updatedAt } from '../../lib/columns.ts'
-import { consentPurposes } from '../consent-purposes/schema.ts'
 import { workspaces } from '../workspace/schema.ts'
 
 /**
@@ -35,15 +34,6 @@ export const lists = pgTable(
     name: text('name').notNull(),
     description: text('description'),
     targetType: text('target_type').notNull(),
-    /**
-     * The consent purpose captured when a form submit adds a person to this
-     * list. Person lists only — the service refuses a non-null value on any
-     * other target type. `restrict` on delete so a purpose in use is not
-     * silently unset behind the list's back.
-     */
-    consentPurposeId: text('consent_purpose_id').references(() => consentPurposes.id, {
-      onDelete: 'restrict',
-    }),
     createdAt: createdAt(),
     updatedAt: updatedAt(),
   },

package/src/modules/lists/service.ts

@@ -9,7 +9,6 @@ import type { TransactionScope } from '../../runtime/transaction.ts'
 import { toEventActor } from '../../lib/actor.ts'
 import type { Actor } from '../auth/actor.ts'
 import { requireWorkspaceId } from '../auth/actor.ts'
-import * as consentPurposesRepository from '../consent-purposes/repository.ts'
 import { missingTargets, resolveTargetNames, targetKey } from '../recordTargets.ts'
 import type { RecordTargetType } from '../recordTargets.ts'
 import './events.ts'
@@ -44,14 +43,8 @@ export interface ListsDependencies {
   readonly now: () => Date
 }
 
-/**
- * A list as the API returns one: the stored row minus the tenancy column,
- * plus the denormalised slug of the consent purpose (when set) so a reader
- * needs no second call.
- */
-export type ListView = Omit<ListWithCount, 'workspaceId'> & {
-  readonly consentPurposeSlug: string | null
-}
+/** A list as the API returns one: the stored row minus the tenancy column. */
+export type ListView = Omit<ListWithCount, 'workspaceId'>
 
 /** A membership plus the list it points at, as `/v1/list-memberships` returns one. */
 export interface ListMembershipView {
@@ -78,18 +71,12 @@ export interface CreateListInput {
   readonly name: string
   readonly targetType: RecordTargetType
   readonly description: string | null
-  /**
-   * Optional consent purpose captured on form-driven adds. Person lists only.
-   * A non-null value on any other target type is refused at 422.
-   */
-  readonly consentPurposeId: string | null
 }
 
 /** PATCH semantics: an absent field is left alone. The type never moves. */
 export interface UpdateListInput {
   readonly name?: string | undefined
   readonly description?: string | null | undefined
-  readonly consentPurposeId?: string | null | undefined
 }
 
 export interface AddListMemberInput {
@@ -117,10 +104,10 @@ export interface ListsService {
   ): Promise<readonly ListMembershipView[]>
 }
 
-function toView(record: ListWithCount, consentPurposeSlug: string | null): ListView {
+function toView(record: ListWithCount): ListView {
   const { workspaceId: _workspaceId, ...view } = record
 
-  return { ...view, consentPurposeSlug }
+  return view
 }
 
 function toMembershipView(row: MembershipWithList): ListMembershipView {
@@ -170,13 +157,6 @@ function alreadyMember(): AppError {
   ])
 }
 
-function purposeNotPersonList(): AppError {
-  return AppError.validationFailed(
-    'Only person lists capture consent — remove consent_purpose_id or change the list type',
-    [{ field: 'consent_purpose_id', message: 'Person lists only' }],
-  )
-}
-
 export function createListsService(dependencies: ListsDependencies): ListsService {
   async function require(workspaceId: string, id: string): Promise<ListWithCount> {
     const list = await repository.findList(dependencies.db, workspaceId, id)
@@ -200,77 +180,25 @@ export function createListsService(dependencies: ListsDependencies): ListsServic
     }
   }
 
-  async function resolveConsentPurposeSlug(
-    workspaceId: string,
-    purposeId: string | null,
-  ): Promise<string | null> {
-    if (purposeId === null) return null
-    const [row] = await consentPurposesRepository.listPurposesByIds(
-      dependencies.db,
-      workspaceId,
-      [purposeId],
-    )
-    return row?.slug ?? null
-  }
-
-  async function requireConsentPurposeExists(
-    workspaceId: string,
-    purposeId: string,
-  ): Promise<void> {
-    const rows = await consentPurposesRepository.listPurposesByIds(
-      dependencies.db,
-      workspaceId,
-      [purposeId],
-    )
-    if (rows.length === 0) {
-      throw AppError.validationFailed('That consent purpose was not found', [
-        { field: 'consent_purpose_id', message: `No purpose ${purposeId} here` },
-      ])
-    }
-  }
-
   return {
     async list(actor, filters, query) {
       const workspaceId = requireWorkspaceId(actor)
       const window = readListWindow(query, LIST_SORTS, DEFAULT_LIST_SORT)
       const rows = await repository.listLists(dependencies.db, workspaceId, filters, window)
-      const purposeIds = Array.from(
-        new Set(
-          rows
-            .map((row) => row.consentPurposeId)
-            .filter((id): id is string => id !== null),
-        ),
-      )
-      const purposes = await consentPurposesRepository.listPurposesByIds(
-        dependencies.db,
-        workspaceId,
-        purposeIds,
-      )
-      const slugByPurpose = new Map(purposes.map((purpose) => [purpose.id, purpose.slug]))
 
-      return mapPage(toPage(rows, window, (row) => row.id), (row) =>
-        toView(row, row.consentPurposeId === null ? null : (slugByPurpose.get(row.consentPurposeId) ?? null)),
-      )
+      return mapPage(toPage(rows, window, (row) => row.id), (row) => toView(row))
     },
 
     async get(actor, id) {
       const workspaceId = requireWorkspaceId(actor)
       const record = await require(workspaceId, id)
-      const slug = await resolveConsentPurposeSlug(workspaceId, record.consentPurposeId)
-      return toView(record, slug)
+      return toView(record)
     },
 
     async create(actor, input) {
       const workspaceId = requireWorkspaceId(actor)
       const id = dependencies.createId('list')
 
-      if (input.consentPurposeId !== null) {
-        if (input.targetType !== 'person') {
-          throw purposeNotPersonList()
-        }
-        await requireConsentPurposeExists(workspaceId, input.consentPurposeId)
-      }
-
       return dependencies.transaction(
         async ({ tx, events }) => {
           let created
@@ -281,7 +209,6 @@ export function createListsService(dependencies: ListsDependencies): ListsServic
               name: input.name,
               description: input.description,
               targetType: input.targetType,
-              consentPurposeId: input.consentPurposeId,
             })
           } catch (error: unknown) {
             if (postgresErrorCode(error) === UNIQUE_VIOLATION) {
@@ -293,12 +220,7 @@ export function createListsService(dependencies: ListsDependencies): ListsServic
 
           events.emit('lists.list.created', { type: 'list', id: created.id }, {})
 
-          const slug = await resolveConsentPurposeSlug(
-            workspaceId,
-            created.consentPurposeId,
-          )
-
-          return toView({ ...created, memberCount: 0 }, slug)
+          return toView({ ...created, memberCount: 0 })
         },
         { workspaceId, actor: toEventActor(actor) },
       )
@@ -308,32 +230,14 @@ export function createListsService(dependencies: ListsDependencies): ListsServic
       const workspaceId = requireWorkspaceId(actor)
       const existing = await require(workspaceId, id)
 
-      if (
-        changes.consentPurposeId !== undefined &&
-        changes.consentPurposeId !== null &&
-        existing.targetType !== 'person'
-      ) {
-        throw purposeNotPersonList()
-      }
-      if (
-        changes.consentPurposeId !== undefined &&
-        changes.consentPurposeId !== null
-      ) {
-        await requireConsentPurposeExists(workspaceId, changes.consentPurposeId)
-      }
-
       const columns: Partial<repository.ListColumns> = {
         ...(changes.name === undefined ? {} : { name: changes.name }),
         ...(changes.description === undefined ? {} : { description: changes.description }),
-        ...(changes.consentPurposeId === undefined
-          ? {}
-          : { consentPurposeId: changes.consentPurposeId }),
       }
       const changed = changedKeys(existing, columns)
 
       if (changed.length === 0) {
-        const slug = await resolveConsentPurposeSlug(workspaceId, existing.consentPurposeId)
-        return toView(existing, slug)
+        return toView(existing)
       }
 
       return dependencies.transaction(
@@ -358,9 +262,7 @@ export function createListsService(dependencies: ListsDependencies): ListsServic
 
           events.emit('lists.list.updated', { type: 'list', id }, { changed })
 
-          const slug = await resolveConsentPurposeSlug(workspaceId, updated.consentPurposeId)
-
-          return toView({ ...updated, memberCount: existing.memberCount }, slug)
+          return toView({ ...updated, memberCount: existing.memberCount })
         },
         { workspaceId, actor: toEventActor(actor) },
       )

package/src/modules/lists/starters.ts

@@ -0,0 +1,16 @@
+import type { RecordTargetType } from '@kelpie/schemas'
+
+/**
+ * The lists a new workspace starts with. Data, not migrations: a workspace
+ * owner may rename or delete them, and add any others they need.
+ */
+
+export interface StarterList {
+  readonly slug: string
+  readonly name: string
+  readonly targetType: RecordTargetType
+}
+
+export const STARTER_LISTS: readonly StarterList[] = [
+  { slug: 'newsletter', name: 'Newsletter', targetType: 'person' },
+]

package/src/modules/mcp/protocol.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod'
 
 import type { Actor } from '../../lib/actor.ts'
+import { requireApiKeyScope, resolveMcpScope } from '../../lib/apiKeyScopes.ts'
 import { AppError, describeThrown, internalErrorBody, toErrorBody } from '../../lib/errors.ts'
 import type { Logger } from '../../lib/logger.ts'
 import type { McpTool } from '../../runtime/module.ts'
@@ -317,6 +318,23 @@ async function callTool(
     return failure(id, INVALID_PARAMS, `Unknown tool "${parsed.data.name}"`)
   }
 
+  const requiredScope = resolveMcpScope(parsed.data.name)
+
+  if (requiredScope !== null) {
+    try {
+      requireApiKeyScope(actor, requiredScope)
+    } catch (error: unknown) {
+      if (error instanceof AppError && error.code === 'forbidden') {
+        return success(
+          id,
+          completeResult(dependencies, era, toolFailure(dependencies.logger, tool.name, error)),
+        )
+      }
+
+      throw error
+    }
+  }
+
   try {
     // `arguments` is optional on the wire and every tool schema is an object, so
     // an absent one is an empty object rather than a validation failure the

package/src/modules/notes/repository.ts

@@ -128,3 +128,27 @@ export async function deleteForTarget(
 
   return deleted.length
 }
+
+/** Moves every note from one target to another inside a conversion transaction. */
+export async function repointForTarget(
+  db: Queryable,
+  workspaceId: string,
+  fromType: string,
+  fromId: string,
+  toType: string,
+  toId: string,
+): Promise<number> {
+  const updated = await db
+    .update(notes)
+    .set({ targetType: toType, targetId: toId })
+    .where(
+      and(
+        eq(notes.workspaceId, workspaceId),
+        eq(notes.targetType, fromType),
+        eq(notes.targetId, fromId),
+      ),
+    )
+    .returning({ id: notes.id })
+
+  return updated.length
+}

package/src/modules/opportunities/events.ts

@@ -12,6 +12,10 @@ export const opportunitiesEvents = {
     fromStageId: z.string().nullable(),
     toStageId: z.string(),
   }),
+  'opportunities.opportunity.converted': z.object({
+    targetType: z.string(),
+    targetId: z.string(),
+  }),
 } satisfies ModuleEventCatalog
 
 export type OpportunityCreatedData = Record<string, never>
@@ -23,6 +27,10 @@ export interface OpportunityStageChangedData {
   readonly fromStageId: string | null
   readonly toStageId: string
 }
+export interface OpportunityConvertedData {
+  readonly targetType: string
+  readonly targetId: string
+}
 
 declare module '../../runtime/events.ts' {
   interface KelpieEventMap {
@@ -30,5 +38,6 @@ declare module '../../runtime/events.ts' {
     'opportunities.opportunity.updated': OpportunityUpdatedData
     'opportunities.opportunity.deleted': OpportunityDeletedData
     'opportunities.opportunity.stage_changed': OpportunityStageChangedData
+    'opportunities.opportunity.converted': OpportunityConvertedData
   }
 }

package/src/modules/opportunities/index.ts

@@ -1,5 +1,6 @@
 import type { KelpieModule } from '../../runtime/module.ts'
 import { createActivityRecorder } from '../activities/index.ts'
+import { createConversionsFromContext } from '../conversions/index.ts'
 import { createCustomFieldValues } from '../custom-fields/index.ts'
 import { opportunitiesEvents } from './events.ts'
 import { mountOpportunitiesRoutes } from './routes.ts'
@@ -22,6 +23,7 @@ export function createOpportunitiesModule(migrationsDirectory: string): KelpieMo
     events: opportunitiesEvents,
 
     register(context) {
+      const conversions = createConversionsFromContext(context)
       const service = createOpportunitiesService({
         db: context.db,
         transaction: context.transaction,
@@ -37,10 +39,10 @@ export function createOpportunitiesModule(migrationsDirectory: string): KelpieMo
       context.schema(schema, migrationsDirectory)
 
       context.routes((router) => {
-        mountOpportunitiesRoutes(router, { db: context.db, now: context.now, service })
+        mountOpportunitiesRoutes(router, { db: context.db, now: context.now, service, conversions })
       })
 
-      registerOpportunitiesTools(context.mcp, service)
+      registerOpportunitiesTools(context.mcp, service, conversions)
 
       return Promise.resolve()
     },

package/src/modules/opportunities/routes.ts

@@ -1,4 +1,4 @@
-import { customFieldsPatchShape } from '@kelpie/schemas'
+import { convertPipelineRecordBody, convertedToResponse, customFieldsPatchShape } from '@kelpie/schemas'
 import type { Context, Hono } from 'hono'
 import { z } from 'zod'
 
@@ -8,6 +8,8 @@ import type { Actor } from '../auth/actor.ts'
 import { resolveActorFrom } from '../auth/credentials.ts'
 import type { CredentialDependencies } from '../auth/credentials.ts'
 import { renderCustomFieldsForWire } from '../custom-fields/wire.ts'
+import { mountPipelineConvertRoute } from '../conversions/routes.ts'
+import type { ConversionsService } from '../conversions/index.ts'
 import type {
   CreateOpportunityInput,
   OpportunitiesService,
@@ -55,6 +57,7 @@ export const updateBody = z.strictObject(opportunityShape).partial()
 
 export interface OpportunitiesRoutesDependencies extends CredentialDependencies {
   readonly service: OpportunitiesService
+  readonly conversions: ConversionsService
 }
 
 export function toCreateInput(body: z.infer<typeof createBody>): CreateOpportunityInput {
@@ -99,6 +102,7 @@ export function opportunityResponse(opportunity: OpportunityView): Record<string
     person_ids: opportunity.personIds,
     summary: opportunity.summary,
     tags: opportunity.tags,
+    converted_to: convertedToResponse(opportunity.convertedTargetType, opportunity.convertedTargetId),
     custom_fields: renderCustomFieldsForWire(opportunity.customFields),
     created_at: opportunity.createdAt.toISOString(),
     updated_at: opportunity.updatedAt.toISOString(),
@@ -162,4 +166,10 @@ export function mountOpportunitiesRoutes(
 
     return context.body(null, 204)
   })
+
+  mountPipelineConvertRoute(router, '/opportunities/:id/convert', {
+    ...dependencies,
+    sourceKind: 'opportunity',
+    bodySchema: convertPipelineRecordBody,
+  })
 }

package/src/modules/opportunities/schema.ts

@@ -1,7 +1,9 @@
+import { sql } from 'drizzle-orm'
+import { check, date, index, jsonb, pgTable, text } from 'drizzle-orm/pg-core'
+import { PIPELINE_KINDS } from '@kelpie/schemas'
 import type { CustomFieldValue } from '@kelpie/schemas'
-import { date, index, jsonb, pgTable, text } from 'drizzle-orm/pg-core'
 
-import { createdAt, primaryId, searchVector, updatedAt } from '../../lib/columns.ts'
+import { createdAt, oneOf, primaryId, searchVector, updatedAt } from '../../lib/columns.ts'
 import type { SearchVectorPart } from '../../lib/columns.ts'
 import { companies } from '../companies/schema.ts'
 import { pipelineStages } from '../pipelines/schema.ts'
@@ -31,6 +33,8 @@ export const opportunities = pgTable(
     expectedClose: date('expected_close'),
     summary: text('summary').notNull().default(''),
     tags: text('tags').array().notNull().default([]),
+    convertedTargetType: text('converted_target_type'),
+    convertedTargetId: text('converted_target_id'),
     // Workspace-defined fields, keyed by definition key. See people/schema.ts.
     customFields: jsonb('custom_fields')
       .$type<Readonly<Record<string, CustomFieldValue>>>()
@@ -49,5 +53,9 @@ export const opportunities = pgTable(
     index('opportunities_workspace_idx').on(table.workspaceId),
     index('opportunities_stage_idx').on(table.stageId),
     index('opportunities_search_idx').using('gin', table.searchVector),
+    check(
+      'opportunities_converted_target_type_check',
+      sql`${table.convertedTargetType} is null or ${oneOf('opportunities_converted_target_type_check', table.convertedTargetType, PIPELINE_KINDS)}`,
+    ),
   ],
 )

package/src/modules/opportunities/service.ts

@@ -21,6 +21,7 @@ import type { Actor } from '../auth/actor.ts'
 import { actorMemberId, requireWorkspaceId } from '../auth/actor.ts'
 import './events.ts'
 import { deleteRecordsAttachedTo } from '../attachedRecords.ts'
+import { clearConversionPointersToTarget } from '../conversions/clearPointers.ts'
 import * as companyRepository from '../companies/repository.ts'
 import type { CustomFieldValuesValidator } from '../custom-fields/values.ts'
 import * as personLinks from '../personLinks.ts'
@@ -494,6 +495,8 @@ export function createOpportunitiesService(
       await dependencies.transaction(async ({ tx, events }) => {
         await require(workspaceId, id)
 
+        await clearConversionPointersToTarget(tx, workspaceId, 'opportunity', id)
+
         // Notes, activities, decisions, plan items, and person_links have no
         // foreign key to their target, so the deleting service removes them
         // here, in the same transaction. Nothing else references an opportunity.

package/src/modules/opportunities/tools.ts

@@ -2,6 +2,8 @@ import { z } from 'zod'
 
 import type { McpToolRegistry } from '../../runtime/module.ts'
 import { idArg, idSetArg, listWindowShape, registerCrudTools, termArg, toSet } from '../crudTools.ts'
+import type { ConversionsService } from '../conversions/index.ts'
+import { registerPipelineConvertTool } from '../conversions/mcp.ts'
 import { createBody, opportunityResponse, toCreateInput, toUpdateInput, updateBody } from './routes.ts'
 import type { OpportunitiesService } from './service.ts'
 
@@ -16,7 +18,11 @@ const listArgs = z.strictObject({
   person_id: idSetArg.optional().describe('Only opportunities any of these people are on.'),
 })
 
-export function registerOpportunitiesTools(mcp: McpToolRegistry, service: OpportunitiesService): void {
+export function registerOpportunitiesTools(
+  mcp: McpToolRegistry,
+  service: OpportunitiesService,
+  conversions: ConversionsService,
+): void {
   registerCrudTools(mcp, {
     resource: 'opportunities',
     subject: 'opportunity',
@@ -38,4 +44,6 @@ export function registerOpportunitiesTools(mcp: McpToolRegistry, service: Opport
     updateArgs: updateBody.extend({ id: idArg }),
     toUpdateInput,
   })
+
+  registerPipelineConvertTool(mcp, conversions, 'opportunity')
 }