@kelpie/server 0.6.0 → 0.8.0

package/src/modules/auth/preferences.ts

@@ -1,4 +1,4 @@
-import type { ThemePreference } from '@kelpie/schemas'
+import type { ListViewPreference, ThemePreference } from '@kelpie/schemas'
 
 /**
  * What an account's preferences are before anyone has saved any, and how a
@@ -17,12 +17,17 @@ export interface PreferenceValues {
   readonly emailDigest: boolean
   readonly mentionEmails: boolean
   readonly productUpdates: boolean
+  readonly listViews: Readonly<Record<string, ListViewPreference>>
 }
 
 /**
  * UTC, not the workspace's zone. An account is global and may belong to several
  * workspaces in different zones, so deriving from one of them would be picking
  * arbitrarily and calling it the person's answer.
+ *
+ * `listViews` starts empty. Each list page falls back to its own default when
+ * the map holds no entry for it, so the person sees the page's built-in shape
+ * until they change it.
  */
 export const DEFAULT_PREFERENCES: PreferenceValues = {
   timezone: 'UTC',
@@ -30,6 +35,7 @@ export const DEFAULT_PREFERENCES: PreferenceValues = {
   emailDigest: true,
   mentionEmails: true,
   productUpdates: false,
+  listViews: {},
 }
 
 export type PreferenceChanges = Partial<PreferenceValues>
@@ -40,6 +46,11 @@ export type PreferenceChanges = Partial<PreferenceValues>
  * The result is always a complete row, which is what makes the write an upsert
  * with no read-modify-write hazard in the caller: the same request applied twice
  * produces the same row.
+ *
+ * `listViews` is treated as one field, so the caller replaces the whole map
+ * rather than merging by key. The UI already holds the current map in the
+ * account-preferences query, so a per-view change becomes a PATCH of the merged
+ * map — the merge lives where the choice was made.
  */
 export function applyPreferenceChanges(
   stored: PreferenceValues | undefined,
@@ -53,5 +64,6 @@ export function applyPreferenceChanges(
     emailDigest: changes.emailDigest ?? current.emailDigest,
     mentionEmails: changes.mentionEmails ?? current.mentionEmails,
     productUpdates: changes.productUpdates ?? current.productUpdates,
+    listViews: changes.listViews ?? current.listViews,
   }
 }

package/src/modules/auth/routes.ts

@@ -1,4 +1,5 @@
 import { THEME_PREFERENCES } from '@kelpie/schemas'
+import type { ListViewPreference } from '@kelpie/schemas'
 import type { Context, Hono } from 'hono'
 import { z } from 'zod'
 
@@ -59,6 +60,24 @@ const updateAccountBody = z
     path: ['current_password'],
   })
 
+const listViewBody: z.ZodType<ListViewPreference, unknown> = z
+  .strictObject({
+    columns: z.array(z.string()).optional(),
+    mode: z.enum(['list', 'columns']).optional(),
+    grouping: z.string().optional(),
+    scope: z.string().optional(),
+    sort: z.string().optional(),
+  })
+  .transform(
+    (wire): ListViewPreference => ({
+      ...(wire.columns === undefined ? {} : { columns: wire.columns }),
+      ...(wire.mode === undefined ? {} : { mode: wire.mode }),
+      ...(wire.grouping === undefined ? {} : { grouping: wire.grouping }),
+      ...(wire.scope === undefined ? {} : { scope: wire.scope }),
+      ...(wire.sort === undefined ? {} : { sort: wire.sort }),
+    }),
+  )
+
 const updatePreferencesBody = z
   .strictObject({
     timezone: timezoneSchema,
@@ -66,6 +85,7 @@ const updatePreferencesBody = z
     email_digest: z.boolean(),
     mention_emails: z.boolean(),
     product_updates: z.boolean(),
+    list_views: z.record(z.string(), listViewBody),
   })
   .partial()
 
@@ -118,6 +138,7 @@ function preferencesResponse(preferences: PreferenceValues): Record<string, unkn
     email_digest: preferences.emailDigest,
     mention_emails: preferences.mentionEmails,
     product_updates: preferences.productUpdates,
+    list_views: preferences.listViews,
   }
 }
 
@@ -213,6 +234,7 @@ export function mountAuthRoutes(router: Hono, dependencies: AuthRoutesDependenci
       ...(body.email_digest === undefined ? {} : { emailDigest: body.email_digest }),
       ...(body.mention_emails === undefined ? {} : { mentionEmails: body.mention_emails }),
       ...(body.product_updates === undefined ? {} : { productUpdates: body.product_updates }),
+      ...(body.list_views === undefined ? {} : { listViews: body.list_views }),
     })
 
     return context.json(preferencesResponse(preferences))

package/src/modules/auth/schema.ts

@@ -1,6 +1,6 @@
 import { THEME_PREFERENCES } from '@kelpie/schemas'
-import type { ThemePreference } from '@kelpie/schemas'
-import { boolean, pgTable, text } from 'drizzle-orm/pg-core'
+import type { ListViewPreference, ThemePreference } from '@kelpie/schemas'
+import { boolean, jsonb, pgTable, text } from 'drizzle-orm/pg-core'
 
 import { checkOneOf, citext, createdAt, moment, primaryId, updatedAt } from '../../lib/columns.ts'
 
@@ -57,6 +57,16 @@ export const userPreferences = pgTable(
     emailDigest: boolean('email_digest').notNull(),
     mentionEmails: boolean('mention_emails').notNull(),
     productUpdates: boolean('product_updates').notNull(),
+    /**
+     * Per-list column choices, keyed on a stable view id (`people`, `deals`, …).
+     * A view id the client no longer recognises stays untouched here rather than
+     * being cleaned up: the map is small, and the write path is the client
+     * merging its current choice into what it read.
+     */
+    listViews: jsonb('list_views')
+      .$type<Readonly<Record<string, ListViewPreference>>>()
+      .notNull()
+      .default({}),
     updatedAt: updatedAt(),
   },
   (table) => [checkOneOf('user_preferences_theme_check', table.theme, THEME_PREFERENCES)],

package/src/modules/auth/service.ts

@@ -1,5 +1,6 @@
 import { APP_LINK_PATHS, buildAppLink } from '../../lib/appUrl.ts'
 import type { EmailSender } from '../../lib/email.ts'
+import { renderEmail } from '../../lib/emailContent.ts'
 import { AppError } from '../../lib/errors.ts'
 import type { IdFactory } from '../../lib/ids.ts'
 import { UNIQUE_VIOLATION, postgresErrorCode } from '../../lib/database.ts'
@@ -95,6 +96,7 @@ function toPreferenceValues(record: repository.UserPreferencesRecord): Preferenc
     emailDigest: record.emailDigest,
     mentionEmails: record.mentionEmails,
     productUpdates: record.productUpdates,
+    listViews: record.listViews,
   }
 }
 
@@ -192,11 +194,23 @@ export function createAuthService(dependencies: AuthDependencies): AuthService {
 
   function sendVerificationEmail(to: string, token: string): Promise<void> {
     const link = buildAppLink(dependencies.appBaseUrl, APP_LINK_PATHS.verifyEmail, token)
+    const { text, html } = renderEmail(
+      {
+        action: {
+          instructions: 'Confirm this address to finish setting up your account:',
+          buttonText: 'Verify email address',
+          link,
+        },
+        outro: 'The link expires in 24 hours.',
+      },
+      dependencies.appBaseUrl,
+    )
 
     return dependencies.email.send({
       to,
       subject: 'Verify your Kelpie email address',
-      body: `Confirm this address to finish setting up your account:\n\n${link}\n\nThe link expires in 24 hours.`,
+      body: text,
+      html,
     })
   }
 
@@ -320,10 +334,18 @@ export function createAuthService(dependencies: AuthDependencies): AuthService {
         })
 
         if (changes.email !== undefined) {
+          const { text, html } = renderEmail(
+            {
+              intro: `Your Kelpie sign-in email changed from ${previousEmail} to ${updated.email}. If you did not make this change, reset your password right away.`,
+            },
+            dependencies.appBaseUrl,
+          )
+
           await dependencies.email.send({
             to: previousEmail,
             subject: 'Your Kelpie sign-in email changed',
-            body: `Your Kelpie sign-in email changed from ${previousEmail} to ${updated.email}. If you did not make this change, reset your password right away.`,
+            body: text,
+            html,
           })
         }
 
@@ -418,11 +440,23 @@ export function createAuthService(dependencies: AuthDependencies): AuthService {
       })
 
       const link = buildAppLink(dependencies.appBaseUrl, APP_LINK_PATHS.passwordReset, token)
+      const { text, html } = renderEmail(
+        {
+          action: {
+            instructions: 'Use this link within the hour to choose a new password:',
+            buttonText: 'Reset password',
+            link,
+          },
+          outro: 'If you did not ask for this, ignore it.',
+        },
+        dependencies.appBaseUrl,
+      )
 
       await dependencies.email.send({
         to: user.email,
         subject: 'Reset your Kelpie password',
-        body: `Use this link within the hour to choose a new password:\n\n${link}\n\nIf you did not ask for this, ignore it.`,
+        body: text,
+        html,
       })
     },
 

package/src/modules/companies/repository.ts

@@ -27,6 +27,8 @@ export interface CompanyFilters {
   readonly term?: string | undefined
   /** `?person_id=`, repeatable: companies where any of these people holds a position. */
   readonly personIds?: readonly string[] | undefined
+  /** `?is_own=true` returns only the workspace's own companies; `false` returns everything else. */
+  readonly isOwn?: boolean | undefined
 }
 
 /**
@@ -64,6 +66,7 @@ function conditionsFor(workspaceId: string, filters: CompanyFilters): (SQL | und
     eq(companies.workspaceId, workspaceId),
     filters.term === undefined ? undefined : matchesTerm(filters.term),
     filters.personIds === undefined ? undefined : employsAnyOf(filters.personIds),
+    filters.isOwn === undefined ? undefined : eq(companies.isOwn, filters.isOwn),
   ]
 }
 

package/src/modules/companies/routes.ts

@@ -30,6 +30,7 @@ const companyShape = {
   tech_stack: z.array(z.string().min(1)),
   summary: z.string(),
   tags: z.array(z.string().min(1)),
+  is_own: z.boolean(),
 }
 
 /**
@@ -51,6 +52,7 @@ export const createBody = z.strictObject({
   tech_stack: companyShape.tech_stack.default([]),
   summary: companyShape.summary.default(''),
   tags: companyShape.tags.default([]),
+  is_own: companyShape.is_own.default(false),
 })
 
 export const updateBody = z.strictObject(companyShape).partial()
@@ -74,6 +76,7 @@ export function toCreateInput(body: z.infer<typeof createBody>): CreateCompanyIn
     techStack: body.tech_stack,
     summary: body.summary,
     tags: body.tags,
+    isOwn: body.is_own,
   }
 }
 
@@ -92,6 +95,7 @@ export function toUpdateInput(body: z.infer<typeof updateBody>): UpdateCompanyIn
     ...(body.tech_stack === undefined ? {} : { techStack: body.tech_stack }),
     ...(body.summary === undefined ? {} : { summary: body.summary }),
     ...(body.tags === undefined ? {} : { tags: body.tags }),
+    ...(body.is_own === undefined ? {} : { isOwn: body.is_own }),
   }
 }
 
@@ -111,6 +115,7 @@ export function companyResponse(company: CompanyView): Record<string, unknown> {
     tech_stack: company.techStack,
     summary: company.summary,
     tags: company.tags,
+    is_own: company.isOwn,
     created_at: company.createdAt.toISOString(),
     updated_at: company.updatedAt.toISOString(),
   }
@@ -120,11 +125,19 @@ export function mountCompaniesRoutes(router: Hono, dependencies: CompaniesRoutes
   const requireActor = (context: Context): Promise<Actor> => resolveActorFrom(dependencies, context)
 
   router.get('/companies', async (context) => {
+    // `?is_own=true|false` narrows to the workspace's own companies (or the
+    // rest). Anything else is treated as absent, so an unknown value never
+    // returns an accidental "everything".
+    const isOwnParam = context.req.query('is_own')
+    const isOwn =
+      isOwnParam === 'true' ? true : isOwnParam === 'false' ? false : undefined
+
     const page = await dependencies.service.list(
       await requireActor(context),
       {
         term: context.req.query('q'),
         personIds: readIdFilter(context, 'person_id'),
+        isOwn,
       },
       readListParameters(context),
     )

package/src/modules/companies/schema.ts

@@ -1,5 +1,5 @@
 import { ACCOUNT_TYPES, COMPANY_STAGES, ICP_FITS, SIZE_BANDS } from '@kelpie/schemas'
-import { index, pgTable, text, unique } from 'drizzle-orm/pg-core'
+import { boolean, index, pgTable, text, unique } from 'drizzle-orm/pg-core'
 
 import {
   checkOneOf,
@@ -42,6 +42,10 @@ export const companies = pgTable(
     techStack: text('tech_stack').array().notNull().default([]),
     summary: text('summary').notNull().default(''),
     tags: text('tags').array().notNull().default([]),
+    // "This is us": a workspace marks its own company (or several, e.g. parent
+    // and subsidiary) so downstream views can distinguish self from prospects.
+    // Loose semantics on purpose — zero or many rows may carry it.
+    isOwn: boolean('is_own').notNull().default(false),
     createdAt: createdAt(),
     updatedAt: updatedAt(),
     searchVector: searchVector((): readonly SearchVectorPart[] => [

package/src/modules/companies/service.ts

@@ -1,6 +1,7 @@
 import { changedKeys } from '../../lib/changes.ts'
 import { UNIQUE_VIOLATION, isReferenceViolation, postgresErrorCode } from '../../lib/database.ts'
 import type { Database } from '../../lib/database.ts'
+import { autoLinkCompanyByDomain } from '../../lib/emailDomainAutoLink.ts'
 import { AppError } from '../../lib/errors.ts'
 import type { IdFactory } from '../../lib/ids.ts'
 import { normaliseDomain } from '../../lib/normalisation.ts'
@@ -51,6 +52,7 @@ const COMPANY_FIELD_LABELS: FieldLabels = {
   techStack: 'Tech stack',
   summary: 'Summary',
   tags: 'Tags',
+  isOwn: 'Own company',
 }
 
 /** A company as the API returns one: the stored row minus the tenancy column. */
@@ -70,6 +72,7 @@ export interface CreateCompanyInput {
   readonly techStack: readonly string[]
   readonly summary: string
   readonly tags: readonly string[]
+  readonly isOwn: boolean
 }
 
 /** PATCH semantics: an absent field is left alone, and null clears a nullable one. */
@@ -112,6 +115,7 @@ function toStoredColumns(input: UpdateCompanyInput): Partial<repository.CompanyC
     ...(input.techStack === undefined ? {} : { techStack: [...input.techStack] }),
     ...(input.summary === undefined ? {} : { summary: input.summary }),
     ...(input.tags === undefined ? {} : { tags: [...input.tags] }),
+    ...(input.isOwn === undefined ? {} : { isOwn: input.isOwn }),
   }
 }
 
@@ -171,6 +175,7 @@ export function createCompaniesService(dependencies: CompaniesDependencies): Com
             techStack: [...input.techStack],
             summary: input.summary,
             tags: [...input.tags],
+            isOwn: input.isOwn,
           })
         } catch (error: unknown) {
           if (postgresErrorCode(error) === UNIQUE_VIOLATION) {
@@ -189,6 +194,15 @@ export function createCompaniesService(dependencies: CompaniesDependencies): Com
 
         events.emit('companies.company.created', { type: 'company', id: created.id }, {})
 
+        // Sync sweep of the workspace's people: everyone whose email domain
+        // matches this Company gets a titleless Position where none exists yet.
+        // Inside the same transaction so a follow-up read sees the new links.
+        await autoLinkCompanyByDomain(tx, events, workspaceId, created, {
+          createId: dependencies.createId,
+          now: dependencies.now,
+          recordActivity: dependencies.recordActivity,
+        })
+
         return toView(created)
       }, { workspaceId, actor: toEventActor(actor) })
     },
@@ -232,6 +246,17 @@ export function createCompaniesService(dependencies: CompaniesDependencies): Com
 
         events.emit('companies.company.updated', { type: 'company', id }, { changed })
 
+        // Sync sweep when the domain moved. A newly-set domain gains matches;
+        // a changed domain gains new matches without touching the old links
+        // (never-remove — a person may still work at the previous domain).
+        if (changed.includes('domain')) {
+          await autoLinkCompanyByDomain(tx, events, workspaceId, updated, {
+            createId: dependencies.createId,
+            now: dependencies.now,
+            recordActivity: dependencies.recordActivity,
+          })
+        }
+
         return toView(updated)
       }, { workspaceId, actor: toEventActor(actor) })
     },

package/src/modules/core.ts

@@ -9,10 +9,12 @@ import { createCompaniesModule } from './companies/index.ts'
 import { createDashboardModule } from './dashboard/index.ts'
 import { createDealsModule } from './deals/index.ts'
 import { createDecisionsModule } from './decisions/index.ts'
+import { createEmailDomainLinkerModule } from './email-domain-linker/index.ts'
 import { createFormsModule } from './forms/index.ts'
 import { createHandbookModule } from './handbook/index.ts'
 import { createHiringModule } from './hiring/index.ts'
 import { createImportExportModule } from './import-export/index.ts'
+import { createListsModule } from './lists/index.ts'
 import { createNotesModule } from './notes/index.ts'
 import { createOpportunitiesModule } from './opportunities/index.ts'
 import { createPartnershipsModule } from './partnerships/index.ts'
@@ -21,6 +23,7 @@ import { createPipelinesModule } from './pipelines/index.ts'
 import { createPlansModule } from './plans/index.ts'
 import { createPositionsModule } from './positions/index.ts'
 import { createRaisesModule } from './raises/index.ts'
+import { createSampleDataModule } from './sample-data/index.ts'
 import { createSearchModule } from './search/index.ts'
 import { createSmtpEmailModule } from './smtp-email/index.ts'
 import { createWebhooksModule } from './webhooks/index.ts'
@@ -57,6 +60,7 @@ export const coreModules: readonly KelpieModule[] = [
   createHiringModule(coreMigrationsDirectory),
   createPlansModule(coreMigrationsDirectory),
   createDecisionsModule(coreMigrationsDirectory),
+  createListsModule(coreMigrationsDirectory),
   createHandbookModule(coreMigrationsDirectory),
   // Neither of these takes a migrations directory: they own no tables and read
   // other modules'.
@@ -66,6 +70,13 @@ export const coreModules: readonly KelpieModule[] = [
   createImportExportModule(coreMigrationsDirectory),
   createAgentTasksModule(coreMigrationsDirectory),
   createWebhooksModule(coreMigrationsDirectory),
+  // Owns no tables. One-shot fixture install for a new workspace, called from
+  // the setup wizard's checkbox and the admin data page.
+  createSampleDataModule(),
+  // Owns no tables. Admin action that reruns the email-domain sweep across
+  // every workspace Company — backfills links for data that predates the
+  // auto-linker, or after a bulk import.
+  createEmailDomainLinkerModule(),
   // Owns no tables. Registers a `'smtp'` provider with core's email runtime;
   // the factory only runs if the assembly's `email.provider` picks it.
   createSmtpEmailModule(),

package/src/modules/email-domain-linker/index.ts

@@ -0,0 +1,40 @@
+import type { KelpieModule } from '../../runtime/module.ts'
+import { createActivityRecorder } from '../activities/index.ts'
+import { mountEmailDomainLinkerRoutes } from './routes.ts'
+import { createEmailDomainLinkerService } from './service.ts'
+
+/**
+ * Rebuild every email-domain link across the workspace.
+ *
+ * Owns no tables. Requires the modules whose data the sweep reads and writes.
+ * The sweep is the same one the companies service runs on a domain change,
+ * applied to every workspace Company at once — used to backfill links for
+ * data that predates the auto-linker, or after a bulk import.
+ */
+export function createEmailDomainLinkerModule(): KelpieModule {
+  return {
+    id: 'email-domain-linker',
+    requires: ['workspace', 'companies', 'people', 'positions', 'activities'],
+
+    register(context) {
+      const service = createEmailDomainLinkerService({
+        db: context.db,
+        transaction: context.transaction,
+        createId: context.createId,
+        now: context.now,
+        recordActivity: createActivityRecorder({
+          createId: context.createId,
+          now: context.now,
+        }),
+      })
+
+      context.routes((router) => {
+        mountEmailDomainLinkerRoutes(router, { db: context.db, now: context.now, service })
+      })
+
+      return Promise.resolve()
+    },
+  }
+}
+
+export type { EmailDomainLinkerService, RelinkCounts } from './service.ts'

package/src/modules/email-domain-linker/routes.ts

@@ -0,0 +1,40 @@
+import type { Context, Hono } from 'hono'
+
+import type { Actor } from '../auth/actor.ts'
+import { resolveActorFrom } from '../auth/credentials.ts'
+import type { CredentialDependencies } from '../auth/credentials.ts'
+import type { EmailDomainLinkerService, RelinkCounts } from './service.ts'
+
+/**
+ * Wire shape for `POST /v1/workspaces/:id/relink-email-domains`.
+ *
+ * No request body. The response counts what the sweep did.
+ */
+
+export interface EmailDomainLinkerRoutesDependencies extends CredentialDependencies {
+  readonly service: EmailDomainLinkerService
+}
+
+export function relinkResponse(counts: RelinkCounts): Record<string, unknown> {
+  return {
+    companies_scanned: counts.companiesScanned,
+    positions_created: counts.positionsCreated,
+  }
+}
+
+export function mountEmailDomainLinkerRoutes(
+  router: Hono,
+  dependencies: EmailDomainLinkerRoutesDependencies,
+): void {
+  const requireActor = (context: Context): Promise<Actor> =>
+    resolveActorFrom(dependencies, context)
+
+  router.post('/workspaces/:id/relink-email-domains', async (context) => {
+    const counts = await dependencies.service.relink(
+      await requireActor(context),
+      context.req.param('id'),
+    )
+
+    return context.json(relinkResponse(counts))
+  })
+}

package/src/modules/email-domain-linker/service.ts

@@ -0,0 +1,122 @@
+import { and, eq, isNotNull } from 'drizzle-orm'
+
+import { toEventActor } from '../../lib/actor.ts'
+import type { Database } from '../../lib/database.ts'
+import { autoLinkCompanyByDomain } from '../../lib/emailDomainAutoLink.ts'
+import { AppError } from '../../lib/errors.ts'
+import type { IdFactory } from '../../lib/ids.ts'
+import type { TransactionScope } from '../../runtime/transaction.ts'
+import type { ActivityRecorder } from '../activities/recorder.ts'
+import type { Actor } from '../auth/actor.ts'
+import { requireWorkspaceId } from '../auth/actor.ts'
+import * as authRepository from '../auth/repository.ts'
+import { companies } from '../companies/schema.ts'
+import { parseMemberRole, roleAllows } from '../workspace/roles.ts'
+
+/**
+ * Rebuild every email-domain link across the workspace.
+ *
+ * Iterates each Company that carries a domain and runs the same sweep the
+ * companies service runs on a domain change — every workspace Person whose
+ * email is at that domain gets a titleless Position where none exists yet.
+ *
+ * Idempotent: a follow-up run adds nothing. Add-only, consumer-host-skipping,
+ * and workspace-scoped, same as the inline auto-linker.
+ *
+ * One transaction per Company, not one for the whole sweep. A workspace can
+ * carry thousands of Companies, and a single transaction that long would
+ * hold row-share locks against every write elsewhere for the whole run.
+ */
+
+export interface EmailDomainLinkerDependencies {
+  readonly db: Database
+  readonly transaction: TransactionScope
+  readonly createId: IdFactory
+  readonly now: () => Date
+  readonly recordActivity: ActivityRecorder
+}
+
+export interface RelinkCounts {
+  /** Companies with a non-null domain that were considered. Consumer hosts are counted but skipped. */
+  readonly companiesScanned: number
+  /** New Positions the sweep inserted this run. */
+  readonly positionsCreated: number
+}
+
+export interface EmailDomainLinkerService {
+  relink(actor: Actor, workspaceId: string): Promise<RelinkCounts>
+}
+
+export function createEmailDomainLinkerService(
+  dependencies: EmailDomainLinkerDependencies,
+): EmailDomainLinkerService {
+  async function requireAdmin(actor: Actor, workspaceId: string): Promise<void> {
+    if (actor.workspaceId !== workspaceId) {
+      throw AppError.notFound('Workspace not found')
+    }
+
+    if (actor.kind === 'api_key' && actor.userId === null) {
+      if (!roleAllows(actor.role, 'admin')) {
+        throw new AppError('forbidden', 'This action needs the admin role')
+      }
+      return
+    }
+
+    const userId = actor.userId
+
+    if (userId === null) {
+      throw AppError.notFound('Workspace not found')
+    }
+
+    const membership = await authRepository.findMembership(dependencies.db, workspaceId, userId)
+
+    if (membership === undefined) {
+      throw AppError.notFound('Workspace not found')
+    }
+
+    const role = parseMemberRole(membership.role)
+
+    if (role === undefined) {
+      throw new Error(`workspace_members.role holds "${membership.role}", which its check forbids`)
+    }
+
+    if (!roleAllows(role, 'admin')) {
+      throw new AppError('forbidden', 'This action needs the admin role')
+    }
+  }
+
+  return {
+    async relink(actor, workspaceId) {
+      requireWorkspaceId(actor)
+      await requireAdmin(actor, workspaceId)
+
+      // Every workspace Company that carries a domain — the ones the sweep
+      // can match against. Pooled read outside the per-company transactions:
+      // the work-list is one query, each write opens its own scope.
+      const rows = await dependencies.db
+        .select()
+        .from(companies)
+        .where(and(eq(companies.workspaceId, workspaceId), isNotNull(companies.domain)))
+
+      let created = 0
+
+      // One transaction per Company, not one for the whole sweep. A workspace
+      // can carry thousands of Companies; a single transaction that long would
+      // hold row-share locks against every write elsewhere for the whole run.
+      for (const company of rows) {
+        const inserted = await dependencies.transaction(
+          async ({ tx, events }) =>
+            autoLinkCompanyByDomain(tx, events, workspaceId, company, {
+              createId: dependencies.createId,
+              now: dependencies.now,
+              recordActivity: dependencies.recordActivity,
+            }),
+          { workspaceId, actor: toEventActor(actor) },
+        )
+        created += inserted.length
+      }
+
+      return { companiesScanned: rows.length, positionsCreated: created }
+    },
+  }
+}

package/src/modules/eventCatalogs.ts

@@ -0,0 +1,36 @@
+/**
+ * Loads every core module's `KelpieEventMap` augmentation at the package entry.
+ *
+ * Each module declares its event payload types in `<module>/events.ts` through
+ * `declare module '../../runtime/events.ts'`. Inside the monorepo those merge
+ * because the source graph reaches every file. A consumer that installs
+ * `@kelpie/server` from npm typechecks against `dist`, and declaration emit
+ * keeps only the imports a file actually references. Nothing in `dist/index.d.ts`
+ * referenced the per-module `events.d.ts` files, so `KelpieEventMap` stayed empty
+ * for consumers and every `subscribe` handler saw `event.data: unknown`.
+ *
+ * These side-effect imports give `index.ts` one reference into each catalog. The
+ * emitted `index.d.ts` carries them, so a consumer loads the augmentations and
+ * gets a typed `event.data` without a cast at the read site.
+ *
+ * List only modules whose `events.ts` augments `KelpieEventMap`. A module that
+ * publishes no events has no `events.ts` and does not belong here. Order mirrors
+ * `coreModules` in `core.ts` for readability; it has no runtime effect.
+ */
+
+import './workspace/events.ts'
+import './people/events.ts'
+import './companies/events.ts'
+import './positions/events.ts'
+import './notes/events.ts'
+import './lists/events.ts'
+import './deals/events.ts'
+import './opportunities/events.ts'
+import './partnerships/events.ts'
+import './raises/events.ts'
+import './hiring/events.ts'
+import './plans/events.ts'
+import './decisions/events.ts'
+import './handbook/events.ts'
+import './forms/events.ts'
+import './import-export/events.ts'