@kelpie/server 0.5.2 → 0.7.0

package/src/modules/agent-tasks/prompt.ts

@@ -3,12 +3,22 @@ import type { AgentTaskDefinition, AgentTaskTargetType } from '@kelpie/schemas'
 /**
  * Renders the markdown prompt a ResolvedTask carries. Pure: every fact arrives
  * as an argument, so the template is unit-testable and Copy and Run cannot
- * drift — both read the one string this produces.
+ * drift — both read the strings this file produces.
  *
- * The shape is the mockup's (`mockups/src/data/agentTasks.ts`), with two
- * server-era changes: workspace-scoped tasks are pointed at `GET /v1/dashboard`
- * instead of a single record, and the sweep tasks carry a "Workspace signals"
- * section computed at resolve time.
+ * Two renderers, one shared body.
+ *
+ *   - {@link renderBasePrompt} returns the general request: the task title,
+ *     the target, the required reads, the handbook pages, related ids,
+ *     workspace signals, the task instructions, and the write policy. It
+ *     says nothing about *how* the receiver should apply the changes.
+ *   - {@link renderExternalAgentPrompt} wraps the base with framing for an
+ *     agent that calls the CRM itself — the opening line about MCP / the
+ *     public API and the closing "Done when… applied allowed updates" tail.
+ *
+ * The resolved-task and dispatch payloads carry both. The copy-prompt UI
+ * flow serves the external-agent version by default; the hosted AI in the
+ * cloud reads the base and adds its own structured-output framing. Two
+ * consumers, two wrappers, one body.
  */
 
 /** A handbook page the task requires, resolved to this workspace's own copy. */
@@ -99,7 +109,13 @@ function firstRead(targetType: AgentTaskTargetType): string {
   return 'Load the target record and agent fields.'
 }
 
-export function renderPrompt(
+/**
+ * The shared body. Renders everything a receiver needs to *understand* the
+ * task, without telling it how to apply results. Callers wrap this with an
+ * opening and closing that matches how the receiver will execute (call the
+ * CRM, or return structured data for a caller to apply).
+ */
+export function renderBasePrompt(
   definition: AgentTaskDefinition,
   targetType: AgentTaskTargetType,
   targetId: string,
@@ -107,9 +123,6 @@ export function renderPrompt(
 ): string {
   return `# Agent task: ${definition.label}
 
-You are operating on the Kelpie workspace **${inputs.workspaceName}** via MCP / the public API.
-Bring your own model. Kelpie does not bundle AI.
-
 ## Task
 - **Id:** \`${definition.id}\`
 - **Intent:** ${definition.description}
@@ -133,8 +146,43 @@ ${definition.instructions}
 
 ## Write policy
 ${definition.writePolicy}
+`
+}
 
+/**
+ * The external-agent-framed prompt. Adds the opening line about MCP / the
+ * public API and the closing "Done when" tail to the base. This is what the
+ * Copy button hands to the user and what dispatch sends by default; an
+ * agent that runs its own tool loop against the CRM reads this and works
+ * from it directly.
+ */
+export function renderExternalAgentPrompt(
+  definition: AgentTaskDefinition,
+  targetType: AgentTaskTargetType,
+  targetId: string,
+  inputs: PromptInputs,
+): string {
+  const opening = `# Agent task: ${definition.label}
+
+You are operating on the Kelpie workspace **${inputs.workspaceName}** via MCP / the public API.
+Bring your own model. Kelpie does not bundle AI.
+`
+
+  // The base opens with its own `# Agent task:` header; strip it so the
+  // combined prompt has one heading rather than two.
+  const base = renderBasePrompt(definition, targetType, targetId, inputs)
+  const bodyWithoutHeading = base.replace(/^# Agent task:[^\n]*\n\n?/u, '')
+
+  return `${opening}
+${bodyWithoutHeading}
 ## Done when
 You have applied allowed updates via MCP/API (or asked the human when blocked), and summarised what changed.
 `
 }
+
+/**
+ * Backwards-compatible alias for the pre-split renderer. Existing callers
+ * that produced the "wrapped" prompt keep working. New callers pick
+ * {@link renderBasePrompt} or {@link renderExternalAgentPrompt} directly.
+ */
+export const renderPrompt = renderExternalAgentPrompt

package/src/modules/agent-tasks/service.ts

@@ -14,7 +14,7 @@ import { requireWorkspaceId } from '../auth/actor.ts'
 import { roleAllows } from '../workspace/roles.ts'
 import { AGENT_TASK_DEFINITIONS, findTask, tasksFor } from './catalog.ts'
 import type { DispatchEngine } from './dispatch.ts'
-import { renderPrompt } from './prompt.ts'
+import { renderBasePrompt, renderExternalAgentPrompt } from './prompt.ts'
 import * as repository from './repository.ts'
 import { AGENT_SORTS, DEFAULT_AGENT_SORT, DEFAULT_RUN_SORT, RUN_SORTS } from './repository.ts'
 import type { AgentRecord, RunFilters, RunRecord } from './repository.ts'
@@ -184,7 +184,8 @@ export function createAgentTasksService(dependencies: AgentTasksDependencies): A
       taskId: definition.id,
       targetType: target.targetType,
       targetId: target.targetId,
-      prompt: renderPrompt(definition, target.targetType, target.targetId, inputs),
+      prompt: renderExternalAgentPrompt(definition, target.targetType, target.targetId, inputs),
+      basePrompt: renderBasePrompt(definition, target.targetType, target.targetId, inputs),
       context: {
         targetLabel: inputs.targetLabel,
         deepLink: inputs.deepLink,

package/src/modules/agent-tasks/wire.ts

@@ -21,7 +21,18 @@ export interface ResolvedTaskView {
   readonly taskId: string
   readonly targetType: AgentTaskTargetType
   readonly targetId: string
+  /**
+   * The external-agent-framed prompt: opens with "operating via MCP / the
+   * public API", ends with "Done when… applied allowed updates". This is
+   * what Copy hands to a user and what a customer agent reads.
+   */
   readonly prompt: string
+  /**
+   * The shared body without the framing. What an agent that returns
+   * structured data (the hosted AI is the one that ships) reads before
+   * adding its own instructions.
+   */
+  readonly basePrompt: string
   readonly context: ContextPackView
 }
 
@@ -31,6 +42,7 @@ export function resolvedTaskResponse(resolved: ResolvedTaskView): Record<string,
     target_type: resolved.targetType,
     target_id: resolved.targetId,
     prompt: resolved.prompt,
+    base_prompt: resolved.basePrompt,
     context: {
       target_label: resolved.context.targetLabel,
       deep_link: resolved.context.deepLink,

package/src/modules/auth/index.ts

@@ -13,12 +13,10 @@ import { createAuthService } from './service.ts'
  * `users`.
  */
 
-const authConfigSchema = z
-  .object({
-    /** Cookies go out `Secure` everywhere except development. */
-    NODE_ENV: z.enum(['development', 'test', 'production']),
-  })
-  .merge(appUrlConfigSchema)
+const nodeEnvSchema = z.object({
+  /** Cookies go out `Secure` everywhere except development. */
+  NODE_ENV: z.enum(['development', 'test', 'production']),
+})
 
 export function createAuthModule(migrationsDirectory: string): KelpieModule {
   return {
@@ -26,14 +24,18 @@ export function createAuthModule(migrationsDirectory: string): KelpieModule {
     structural: true,
 
     register(context) {
-      const config = context.config(authConfigSchema)
+      const { NODE_ENV } = context.config(nodeEnvSchema)
+      // Prefer the top-level `appBaseUrl` from the assembly's kelpie.config.ts;
+      // fall back to the schema read for older assemblies that don't declare it.
+      const appBaseUrl = context.appBaseUrl ?? context.config(appUrlConfigSchema).APP_BASE_URL
+
       const service = createAuthService({
         db: context.db,
         transaction: context.transaction,
         email: context.email,
         createId: context.createId,
         now: context.now,
-        appBaseUrl: config.APP_BASE_URL,
+        appBaseUrl,
       })
 
       context.schema(schema, migrationsDirectory)
@@ -46,7 +48,7 @@ export function createAuthModule(migrationsDirectory: string): KelpieModule {
           // `Secure` everywhere except development. A test host reaches the API
           // over http through a test client, which stores the cookie regardless
           // of the flag, so test is not excluded.
-          cookie: { secure: config.NODE_ENV !== 'development' },
+          cookie: { secure: NODE_ENV !== 'development' },
         })
       })
 

package/src/modules/companies/events.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod'
+
+import type { ModuleEventCatalog } from '../../runtime/module.ts'
+
+/** Domain events published by the companies module. */
+
+export const companiesEvents = {
+  'companies.company.created': z.object({}).strict(),
+  'companies.company.updated': z.object({ changed: z.array(z.string()).readonly() }),
+  'companies.company.deleted': z.object({}).strict(),
+} satisfies ModuleEventCatalog
+
+export type CompanyCreatedData = Record<string, never>
+export interface CompanyUpdatedData {
+  readonly changed: readonly string[]
+}
+export type CompanyDeletedData = Record<string, never>
+
+declare module '../../runtime/events.ts' {
+  interface KelpieEventMap {
+    'companies.company.created': CompanyCreatedData
+    'companies.company.updated': CompanyUpdatedData
+    'companies.company.deleted': CompanyDeletedData
+  }
+}

package/src/modules/companies/index.ts

@@ -1,5 +1,6 @@
 import type { KelpieModule } from '../../runtime/module.ts'
 import { createActivityRecorder } from '../activities/index.ts'
+import { companiesEvents } from './events.ts'
 import { mountCompaniesRoutes } from './routes.ts'
 import * as schema from './schema.ts'
 import { createCompaniesService } from './service.ts'
@@ -16,6 +17,7 @@ export function createCompaniesModule(migrationsDirectory: string): KelpieModule
     id: 'companies',
     requires: ['workspace', 'activities'],
     structural: true,
+    events: companiesEvents,
 
     register(context) {
       const service = createCompaniesService({

package/src/modules/companies/service.ts

@@ -10,8 +10,10 @@ import type { TransactionScope } from '../../runtime/transaction.ts'
 import type { ActivityRecorder } from '../activities/recorder.ts'
 import { describeCreation, describeUpdate } from '../activities/wording.ts'
 import type { FieldLabels } from '../activities/wording.ts'
+import { toEventActor } from '../../lib/actor.ts'
 import type { Actor } from '../auth/actor.ts'
 import { requireWorkspaceId } from '../auth/actor.ts'
+import './events.ts'
 import { deleteRecordsAttachedTo } from '../attachedRecords.ts'
 import { referencedElsewhere } from '../references.ts'
 import * as repository from './repository.ts'
@@ -185,10 +187,10 @@ export function createCompaniesService(dependencies: CompaniesDependencies): Com
           ...describeCreation('Company'),
         })
 
-        events.emit('record.created', { workspaceId, objectType: 'company', recordId: created.id })
+        events.emit('companies.company.created', { type: 'company', id: created.id }, {})
 
         return toView(created)
-      })
+      }, { workspaceId, actor: toEventActor(actor) })
     },
 
     async update(actor, id, changes) {
@@ -228,15 +230,10 @@ export function createCompaniesService(dependencies: CompaniesDependencies): Com
           ...describeUpdate(changed, COMPANY_FIELD_LABELS, existing, columns),
         })
 
-        events.emit('record.updated', {
-          workspaceId,
-          objectType: 'company',
-          recordId: id,
-          changedFields: changed,
-        })
+        events.emit('companies.company.updated', { type: 'company', id }, { changed })
 
         return toView(updated)
-      })
+      }, { workspaceId, actor: toEventActor(actor) })
     },
 
     async remove(actor, id) {
@@ -260,8 +257,8 @@ export function createCompaniesService(dependencies: CompaniesDependencies): Com
           throw error
         }
 
-        events.emit('record.deleted', { workspaceId, objectType: 'company', recordId: id })
-      })
+        events.emit('companies.company.deleted', { type: 'company', id }, {})
+      }, { workspaceId, actor: toEventActor(actor) })
     },
   }
 }

package/src/modules/core.ts

@@ -22,6 +22,7 @@ import { createPlansModule } from './plans/index.ts'
 import { createPositionsModule } from './positions/index.ts'
 import { createRaisesModule } from './raises/index.ts'
 import { createSearchModule } from './search/index.ts'
+import { createSmtpEmailModule } from './smtp-email/index.ts'
 import { createWebhooksModule } from './webhooks/index.ts'
 import { createWorkspaceModule } from './workspace/index.ts'
 
@@ -65,4 +66,7 @@ export const coreModules: readonly KelpieModule[] = [
   createImportExportModule(coreMigrationsDirectory),
   createAgentTasksModule(coreMigrationsDirectory),
   createWebhooksModule(coreMigrationsDirectory),
+  // 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/deals/events.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod'
+
+import type { ModuleEventCatalog } from '../../runtime/module.ts'
+
+/** Domain events published by the deals module. */
+
+export const dealsEvents = {
+  'deals.deal.created': z.object({}).strict(),
+  'deals.deal.updated': z.object({ changed: z.array(z.string()).readonly() }),
+  'deals.deal.deleted': z.object({}).strict(),
+  'deals.deal.stage_changed': z.object({
+    fromStageId: z.string().nullable(),
+    toStageId: z.string(),
+  }),
+} satisfies ModuleEventCatalog
+
+export type DealCreatedData = Record<string, never>
+export interface DealUpdatedData {
+  readonly changed: readonly string[]
+}
+export type DealDeletedData = Record<string, never>
+export interface DealStageChangedData {
+  readonly fromStageId: string | null
+  readonly toStageId: string
+}
+
+declare module '../../runtime/events.ts' {
+  interface KelpieEventMap {
+    'deals.deal.created': DealCreatedData
+    'deals.deal.updated': DealUpdatedData
+    'deals.deal.deleted': DealDeletedData
+    'deals.deal.stage_changed': DealStageChangedData
+  }
+}

package/src/modules/deals/index.ts

@@ -1,5 +1,6 @@
 import type { KelpieModule } from '../../runtime/module.ts'
 import { createActivityRecorder } from '../activities/index.ts'
+import { dealsEvents } from './events.ts'
 import { mountDealsRoutes } from './routes.ts'
 import * as schema from './schema.ts'
 import { createDealsService } from './service.ts'
@@ -17,6 +18,7 @@ export function createDealsModule(migrationsDirectory: string): KelpieModule {
   return {
     id: 'deals',
     requires: ['companies', 'people', 'pipelines', 'activities'],
+    events: dealsEvents,
 
     register(context) {
       const service = createDealsService({

package/src/modules/deals/service.ts

@@ -14,8 +14,10 @@ import {
   describeUpdate,
 } from '../activities/wording.ts'
 import type { FieldLabels } from '../activities/wording.ts'
+import { toEventActor } from '../../lib/actor.ts'
 import type { Actor } from '../auth/actor.ts'
 import { actorMemberId, requireWorkspaceId } from '../auth/actor.ts'
+import './events.ts'
 import { deleteRecordsAttachedTo } from '../attachedRecords.ts'
 import * as companyRepository from '../companies/repository.ts'
 import * as pipelineRepository from '../pipelines/repository.ts'
@@ -297,10 +299,10 @@ export function createDealsService(dependencies: DealsDependencies): DealsServic
           })
         }
 
-        events.emit('record.created', { workspaceId, objectType: 'deal', recordId: id })
+        events.emit('deals.deal.created', { type: 'deal', id }, {})
 
         return toView(created, personIds)
-      })
+      }, { workspaceId, actor: toEventActor(actor) })
     },
 
     async update(actor, id, changes) {
@@ -393,25 +395,22 @@ export function createDealsService(dependencies: DealsDependencies): DealsServic
           })
         }
 
-        events.emit('record.updated', {
-          workspaceId,
-          objectType: 'deal',
-          recordId: id,
-          changedFields: linksChanged ? [...changed, 'personIds'] : changed,
-        })
+        events.emit(
+          'deals.deal.updated',
+          { type: 'deal', id },
+          { changed: linksChanged ? [...changed, 'personIds'] : changed },
+        )
 
         if (stageMove !== undefined) {
-          events.emit('stage.changed', {
-            workspaceId,
-            objectType: 'deal',
-            recordId: id,
-            fromStageId: stageMove.from.id,
-            toStageId: stageMove.to.id,
-          })
+          events.emit(
+            'deals.deal.stage_changed',
+            { type: 'deal', id },
+            { fromStageId: stageMove.from.id, toStageId: stageMove.to.id },
+          )
         }
 
         return toView(updated, nextPeople ?? currentPeople)
-      })
+      }, { workspaceId, actor: toEventActor(actor) })
     },
 
     async remove(actor, id) {
@@ -426,8 +425,8 @@ export function createDealsService(dependencies: DealsDependencies): DealsServic
         await deleteRecordsAttachedTo(tx, workspaceId, 'deal', id)
         await repository.deleteDeal(tx, workspaceId, id)
 
-        events.emit('record.deleted', { workspaceId, objectType: 'deal', recordId: id })
-      })
+        events.emit('deals.deal.deleted', { type: 'deal', id }, {})
+      }, { workspaceId, actor: toEventActor(actor) })
     },
   }
 }

package/src/modules/decisions/events.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod'
+
+import type { ModuleEventCatalog } from '../../runtime/module.ts'
+
+/**
+ * Domain events published by the decisions module.
+ *
+ * `target` is the record the decision attaches to; the decision's own id lives
+ * in `data`.
+ */
+
+export const decisionsEvents = {
+  'decisions.decision.added': z.object({ decisionId: z.string() }),
+} satisfies ModuleEventCatalog
+
+export interface DecisionAddedData {
+  readonly decisionId: string
+}
+
+declare module '../../runtime/events.ts' {
+  interface KelpieEventMap {
+    'decisions.decision.added': DecisionAddedData
+  }
+}

package/src/modules/decisions/index.ts

@@ -1,4 +1,5 @@
 import type { KelpieModule } from '../../runtime/module.ts'
+import { decisionsEvents } from './events.ts'
 import { mountDecisionsRoutes } from './routes.ts'
 import * as schema from './schema.ts'
 import { createDecisionsService } from './service.ts'
@@ -17,6 +18,7 @@ export function createDecisionsModule(migrationsDirectory: string): KelpieModule
     id: 'decisions',
     requires: ['workspace'],
     structural: true,
+    events: decisionsEvents,
 
     register(context) {
       const service = createDecisionsService({

package/src/modules/decisions/service.ts

@@ -5,8 +5,10 @@ import type { IdFactory } from '../../lib/ids.ts'
 import { mapPage, readListWindow, toPage } from '../../lib/pagination.ts'
 import type { ListQueryParameters, Page } from '../../lib/pagination.ts'
 import type { TransactionScope } from '../../runtime/transaction.ts'
+import { toEventActor } from '../../lib/actor.ts'
 import type { Actor } from '../auth/actor.ts'
 import { actorMemberId, requireWorkspaceId } from '../auth/actor.ts'
+import './events.ts'
 import { targetExists } from '../recordTargets.ts'
 import type { RecordTargetType } from '../recordTargets.ts'
 import * as repository from './repository.ts'
@@ -158,15 +160,14 @@ export function createDecisionsService(dependencies: DecisionsDependencies): Dec
         // decisions their own event, carrying the target, because a consumer
         // watching a record wants the commitment without a second lookup to
         // find out what it is attached to.
-        events.emit('decision.added', {
-          workspaceId,
-          decisionId: created.id,
-          targetType: created.targetType,
-          targetId: created.targetId,
-        })
+        events.emit(
+          'decisions.decision.added',
+          { type: created.targetType, id: created.targetId },
+          { decisionId: created.id },
+        )
 
         return toView(created)
-      })
+      }, { workspaceId, actor: toEventActor(actor) })
     },
 
     async update(actor, id, changes) {

package/src/modules/eventCatalogs.ts

@@ -0,0 +1,35 @@
+/**
+ * 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 './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'

package/src/modules/forms/events.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod'
+
+import type { ModuleEventCatalog } from '../../runtime/module.ts'
+
+/**
+ * Domain events published by the forms module.
+ *
+ * `forms.form.*` cover the form definition CRUD. `forms.submission.submitted`
+ * fires once per submission; the webhooks bridge translates it to the wire
+ * `form.submitted` event (the ids live in `data`).
+ */
+
+export const formsEvents = {
+  'forms.form.created': z.object({}).strict(),
+  'forms.form.updated': z.object({ changed: z.array(z.string()).readonly() }),
+  'forms.form.deleted': z.object({}).strict(),
+  'forms.submission.submitted': z.object({ formId: z.string(), submissionId: z.string() }),
+} satisfies ModuleEventCatalog
+
+export type FormCreatedData = Record<string, never>
+export interface FormUpdatedData {
+  readonly changed: readonly string[]
+}
+export type FormDeletedData = Record<string, never>
+export interface FormSubmissionData {
+  readonly formId: string
+  readonly submissionId: string
+}
+
+declare module '../../runtime/events.ts' {
+  interface KelpieEventMap {
+    'forms.form.created': FormCreatedData
+    'forms.form.updated': FormUpdatedData
+    'forms.form.deleted': FormDeletedData
+    'forms.submission.submitted': FormSubmissionData
+  }
+}

package/src/modules/forms/index.ts

@@ -1,5 +1,6 @@
 import type { KelpieModule } from '../../runtime/module.ts'
 import { createActivityRecorder } from '../activities/index.ts'
+import { formsEvents } from './events.ts'
 import { mountPublicFormRoutes } from './publicRoutes.ts'
 import { mountFormsRoutes } from './routes.ts'
 import * as schema from './schema.ts'
@@ -23,6 +24,7 @@ export function createFormsModule(migrationsDirectory: string): KelpieModule {
   return {
     id: 'forms',
     requires: ['people', 'companies', 'positions', 'pipelines', 'deals', 'activities'],
+    events: formsEvents,
 
     register(context) {
       const service = createFormsService({

package/src/modules/forms/service.ts

@@ -6,8 +6,10 @@ import { mapPage, readListWindow, toPage } from '../../lib/pagination.ts'
 import type { ListQueryParameters, Page } from '../../lib/pagination.ts'
 import { generateToken } from '../../lib/tokens.ts'
 import type { Transaction, 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 './events.ts'
 import * as pipelineRepository from '../pipelines/repository.ts'
 import { fieldsDiffer, findFieldProblems, storedOptions } from './fields.ts'
 import type { FieldDraft, FieldShape } from './fields.ts'
@@ -253,10 +255,10 @@ export function createFormsService(dependencies: FormsDependencies): FormsServic
         })
         const fields = await writeFields(tx, workspaceId, id, input.fields)
 
-        events.emit('record.created', { workspaceId, objectType: 'form', recordId: id })
+        events.emit('forms.form.created', { type: 'form', id }, {})
 
         return toView(created, fields)
-      })
+      }, { workspaceId, actor: toEventActor(actor) })
     },
 
     async update(actor, id, changes) {
@@ -310,15 +312,14 @@ export function createFormsService(dependencies: FormsDependencies): FormsServic
           return writeFields(tx, workspaceId, id, changes.fields)
         })()
 
-        events.emit('record.updated', {
-          workspaceId,
-          objectType: 'form',
-          recordId: id,
-          changedFields: rewritesFields ? [...written, 'fields'] : written,
-        })
+        events.emit(
+          'forms.form.updated',
+          { type: 'form', id },
+          { changed: rewritesFields ? [...written, 'fields'] : written },
+        )
 
         return toView(updated, fields)
-      })
+      }, { workspaceId, actor: toEventActor(actor) })
     },
 
     /**
@@ -339,8 +340,8 @@ export function createFormsService(dependencies: FormsDependencies): FormsServic
           throw AppError.notFound('Form not found')
         }
 
-        events.emit('record.deleted', { workspaceId, objectType: 'form', recordId: id })
-      })
+        events.emit('forms.form.deleted', { type: 'form', id }, {})
+      }, { workspaceId, actor: toEventActor(actor) })
     },
 
     async listSubmissions(actor, formId, query) {