@lota-sdk/core 0.1.5 → 0.1.6

package/infrastructure/schema/00_identity.surql

@@ -0,0 +1,26 @@
+# SDK identity tables.
+DEFINE TABLE IF NOT EXISTS organization SCHEMAFULL;
+DEFINE FIELD IF NOT EXISTS name ON TABLE organization TYPE string;
+DEFINE FIELD IF NOT EXISTS regularChatDigestLastWorkstreamCursorCreatedAt ON TABLE organization TYPE option<datetime>;
+DEFINE FIELD IF NOT EXISTS regularChatDigestLastWorkstreamCursorId ON TABLE organization TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS skillExtractionLastCursorId ON TABLE organization TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS skillExtractionLastCursorCreatedAt ON TABLE organization TYPE option<datetime>;
+DEFINE FIELD IF NOT EXISTS createdAt ON TABLE organization TYPE datetime DEFAULT time::now() READONLY;
+DEFINE FIELD IF NOT EXISTS updatedAt ON TABLE organization TYPE datetime VALUE time::now();
+
+DEFINE TABLE IF NOT EXISTS user SCHEMAFULL;
+DEFINE FIELD IF NOT EXISTS name ON TABLE user TYPE string;
+DEFINE FIELD IF NOT EXISTS email ON TABLE user TYPE string;
+DEFINE FIELD IF NOT EXISTS createdAt ON TABLE user TYPE datetime DEFAULT time::now() READONLY;
+DEFINE FIELD IF NOT EXISTS updatedAt ON TABLE user TYPE datetime VALUE time::now();
+
+DEFINE INDEX IF NOT EXISTS sdkUserEmailIdx ON TABLE user COLUMNS email;
+
+DEFINE TABLE IF NOT EXISTS organizationMember SCHEMAFULL TYPE RELATION IN user OUT organization;
+DEFINE FIELD IF NOT EXISTS in ON TABLE organizationMember TYPE record<user>;
+DEFINE FIELD IF NOT EXISTS out ON TABLE organizationMember TYPE record<organization>;
+DEFINE FIELD IF NOT EXISTS role ON TABLE organizationMember TYPE string;
+DEFINE FIELD IF NOT EXISTS createdAt ON TABLE organizationMember TYPE datetime DEFAULT time::now() READONLY;
+
+DEFINE INDEX IF NOT EXISTS organizationMemberUniqueIdx ON TABLE organizationMember COLUMNS in, out UNIQUE;
+DEFINE INDEX IF NOT EXISTS organizationMemberOutIdx ON TABLE organizationMember COLUMNS out, createdAt;

package/infrastructure/schema/00_workstream.surql

@@ -15,10 +15,16 @@ DEFINE FIELD IF NOT EXISTS memoryBlockSummary ON TABLE workstream TYPE option<st
 DEFINE FIELD IF NOT EXISTS activeRunId ON TABLE workstream TYPE option<string>;
 DEFINE FIELD IF NOT EXISTS chatSummary ON TABLE workstream TYPE option<string>;
 DEFINE FIELD IF NOT EXISTS lastCompactedMessageId ON TABLE workstream TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS nameGenerated ON TABLE workstream TYPE bool DEFAULT false;
 DEFINE FIELD IF NOT EXISTS isCompacting ON TABLE workstream TYPE bool DEFAULT false;
 DEFINE FIELD IF NOT EXISTS state ON TABLE workstream TYPE option<object> FLEXIBLE;
 
 DEFINE INDEX IF NOT EXISTS workstreamOrgIdx ON TABLE workstream COLUMNS organizationId;
+DEFINE INDEX IF NOT EXISTS workstreamUserIdx ON TABLE workstream COLUMNS userId;
+DEFINE INDEX IF NOT EXISTS workstreamUserOrgModeUpdatedIdx ON TABLE workstream COLUMNS userId, organizationId, mode, updatedAt;
+DEFINE INDEX IF NOT EXISTS workstreamUserOrgStatusModeUpdatedIdx ON TABLE workstream COLUMNS userId, organizationId, status, mode, updatedAt;
+DEFINE INDEX IF NOT EXISTS workstreamUserOrgCoreModeUpdatedIdx ON TABLE workstream COLUMNS userId, organizationId, core, mode, updatedAt;
+DEFINE INDEX IF NOT EXISTS workstreamUserOrgStatusCoreModeUpdatedIdx ON TABLE workstream COLUMNS userId, organizationId, status, core, mode, updatedAt;
 
 # Workstream Message table (AI SDK UIMessage persistence).
 # parts uses OVERWRITE on the wildcard to override the implicit non-FLEXIBLE
@@ -53,3 +59,4 @@ DEFINE FIELD IF NOT EXISTS updatedAt ON TABLE workstreamAttachment TYPE datetime
 
 DEFINE INDEX IF NOT EXISTS workstreamAttachmentWorkstreamIdx ON TABLE workstreamAttachment COLUMNS workstreamId;
 DEFINE INDEX IF NOT EXISTS workstreamAttachmentMessageIdx ON TABLE workstreamAttachment COLUMNS messageId;
+DEFINE INDEX IF NOT EXISTS workstreamAttachmentWorkstreamMessageIdx ON TABLE workstreamAttachment COLUMNS workstreamId, messageId;

package/infrastructure/schema/05_recent_activity.surql

@@ -0,0 +1,48 @@
+# SDK recent activity tables.
+DEFINE TABLE IF NOT EXISTS recentActivityEvent SCHEMAFULL;
+DEFINE FIELD IF NOT EXISTS organizationId ON TABLE recentActivityEvent TYPE record<organization>;
+DEFINE FIELD IF NOT EXISTS userId ON TABLE recentActivityEvent TYPE record<user>;
+DEFINE FIELD IF NOT EXISTS sourceEventId ON TABLE recentActivityEvent TYPE string;
+DEFINE FIELD IF NOT EXISTS source ON TABLE recentActivityEvent TYPE string;
+DEFINE FIELD IF NOT EXISTS kind ON TABLE recentActivityEvent TYPE string;
+DEFINE FIELD IF NOT EXISTS targetKind ON TABLE recentActivityEvent TYPE string;
+DEFINE FIELD IF NOT EXISTS targetId ON TABLE recentActivityEvent TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS mergeKey ON TABLE recentActivityEvent TYPE string;
+DEFINE FIELD IF NOT EXISTS title ON TABLE recentActivityEvent TYPE string;
+DEFINE FIELD IF NOT EXISTS sourceLabel ON TABLE recentActivityEvent TYPE string;
+DEFINE FIELD IF NOT EXISTS deepLink ON TABLE recentActivityEvent TYPE object FLEXIBLE;
+DEFINE FIELD IF NOT EXISTS metadata ON TABLE recentActivityEvent TYPE option<object> FLEXIBLE;
+DEFINE FIELD IF NOT EXISTS occurredAt ON TABLE recentActivityEvent TYPE datetime;
+DEFINE FIELD IF NOT EXISTS createdAt ON TABLE recentActivityEvent TYPE datetime DEFAULT time::now() READONLY;
+
+DEFINE INDEX IF NOT EXISTS recentActivityEventSourceUniqueIdx
+  ON TABLE recentActivityEvent COLUMNS organizationId, userId, sourceEventId UNIQUE;
+DEFINE INDEX IF NOT EXISTS recentActivityEventRecentIdx
+  ON TABLE recentActivityEvent COLUMNS organizationId, userId, occurredAt;
+DEFINE INDEX IF NOT EXISTS recentActivityEventMergeIdx
+  ON TABLE recentActivityEvent COLUMNS organizationId, userId, mergeKey, occurredAt;
+
+DEFINE TABLE IF NOT EXISTS recentActivity SCHEMAFULL;
+DEFINE FIELD IF NOT EXISTS organizationId ON TABLE recentActivity TYPE record<organization>;
+DEFINE FIELD IF NOT EXISTS userId ON TABLE recentActivity TYPE record<user>;
+DEFINE FIELD IF NOT EXISTS mergeKey ON TABLE recentActivity TYPE string;
+DEFINE FIELD IF NOT EXISTS kind ON TABLE recentActivity TYPE string;
+DEFINE FIELD IF NOT EXISTS targetKind ON TABLE recentActivity TYPE string;
+DEFINE FIELD IF NOT EXISTS targetId ON TABLE recentActivity TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS title ON TABLE recentActivity TYPE string;
+DEFINE FIELD IF NOT EXISTS systemTitle ON TABLE recentActivity TYPE string;
+DEFINE FIELD IF NOT EXISTS titleSource ON TABLE recentActivity TYPE string;
+DEFINE FIELD IF NOT EXISTS sourceLabel ON TABLE recentActivity TYPE string;
+DEFINE FIELD IF NOT EXISTS deepLink ON TABLE recentActivity TYPE object FLEXIBLE;
+DEFINE FIELD IF NOT EXISTS metadata ON TABLE recentActivity TYPE option<object> FLEXIBLE;
+DEFINE FIELD IF NOT EXISTS latestEventId ON TABLE recentActivity TYPE option<record<recentActivityEvent>>;
+DEFINE FIELD IF NOT EXISTS latestSourceEventId ON TABLE recentActivity TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS latestEventAt ON TABLE recentActivity TYPE datetime;
+DEFINE FIELD IF NOT EXISTS titleRefinedAt ON TABLE recentActivity TYPE option<datetime>;
+DEFINE FIELD IF NOT EXISTS createdAt ON TABLE recentActivity TYPE datetime DEFAULT time::now() READONLY;
+DEFINE FIELD IF NOT EXISTS updatedAt ON TABLE recentActivity TYPE datetime VALUE time::now();
+
+DEFINE INDEX IF NOT EXISTS recentActivityMergeUniqueIdx
+  ON TABLE recentActivity COLUMNS organizationId, userId, mergeKey UNIQUE;
+DEFINE INDEX IF NOT EXISTS recentActivityRecentIdx
+  ON TABLE recentActivity COLUMNS organizationId, userId, latestEventAt;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lota-sdk/core",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -104,7 +104,8 @@
     "lint": "node ../node_modules/oxlint/bin/oxlint --fix -c ../oxlint.config.ts src",
     "format": "bunx oxfmt src",
     "typecheck": "bunx tsgo --noEmit",
-    "test:unit": "bun test ../tests/unit/core"
+    "test:unit": "bun test ../tests/unit/core",
+    "test:coverage": "bun test --coverage ../tests/unit/core"
   },
   "publishConfig": {
     "access": "public",
@@ -113,7 +114,7 @@
   "dependencies": {
     "@ai-sdk/openai": "^3.0.41",
     "@logtape/logtape": "^2.0.4",
-    "@lota-sdk/shared": "0.1.0",
+    "@lota-sdk/shared": "file:../shared",
     "@mendable/firecrawl-js": "^4.16.0",
     "@surrealdb/node": "^3.0.3",
     "ai": "^6.0.116",

package/src/config/env-shapes.ts

@@ -14,7 +14,6 @@ export const surrealDbEnvShape = {
   SURREALDB_USER: z.string().min(1, 'SurrealDB user is required'),
   SURREALDB_PASSWORD: z.string().min(1, 'SurrealDB password is required'),
   SURREALDB_NAMESPACE: z.string().min(1, 'SurrealDB namespace is required'),
-  SURREALDB_DATABASE: z.string().min(1, 'SurrealDB database is required'),
 } as const satisfies Record<string, ZodTypeAny>
 
 export const betterAuthEnvShape = {

package/src/db/schema-fingerprint.ts

@@ -0,0 +1,21 @@
+import { createHash } from 'node:crypto'
+
+function toSchemaFilePath(value: string | URL): string {
+  return value instanceof URL ? value.pathname : value
+}
+
+export async function computeSchemaFingerprint(schemaFiles: readonly (string | URL)[]): Promise<string> {
+  const hash = createHash('sha256')
+
+  for (const schemaFile of schemaFiles) {
+    const sortKey = toSchemaFilePath(schemaFile)
+    const file = schemaFile instanceof URL ? Bun.file(schemaFile.pathname) : Bun.file(schemaFile)
+
+    hash.update(sortKey)
+    hash.update('\0')
+    hash.update((await file.text()).trim())
+    hash.update('\0')
+  }
+
+  return hash.digest('hex')
+}

package/src/db/sdk-database.ts

@@ -0,0 +1 @@
+export const LOTA_SDK_DATABASE_NAME = 'lotasdk'

package/src/db/service.ts

@@ -926,7 +926,3 @@ export function setDatabaseService(db: SurrealDBService): void {
 
   currentDatabaseService = db
 }
-
-export function getDatabaseService(): SurrealDBService | undefined {
-  return currentDatabaseService
-}

package/src/db/tables.ts

@@ -11,8 +11,8 @@ export const TABLES = {
   PLAN_TASK: 'planTask',
   PLAN_EVENT: 'planEvent',
   ORGANIZATION: 'organization',
+  ORGANIZATION_MEMBER: 'organizationMember',
   USER: 'user',
-  ORG_ACTION: 'orgAction',
   RECENT_ACTIVITY_EVENT: 'recentActivityEvent',
   RECENT_ACTIVITY: 'recentActivity',
 } as const

package/src/index.ts

@@ -1,6 +1,8 @@
 import type { CoreWorkstreamProfile } from './config/agent-defaults'
 import type { LotaWorkstreamConfig } from './config/workstream-defaults'
+import { ensureRecordId } from './db/record-id'
 import type { SurrealDBService } from './db/service'
+import { TABLES } from './db/tables'
 import type { startContextCompactionWorker } from './queues/context-compaction.queue'
 import type {
   scheduleRecurringConsolidation,
@@ -10,16 +12,21 @@ import type { startPostChatMemoryWorker } from './queues/post-chat-memory.queue'
 import type { startRecentActivityTitleRefinementWorker } from './queues/recent-activity-title-refinement.queue'
 import type { startRegularChatMemoryDigestWorker } from './queues/regular-chat-memory-digest.queue'
 import type { startSkillExtractionWorker } from './queues/skill-extraction.queue'
+import type { startWorkstreamTitleGenerationWorker } from './queues/workstream-title-generation.queue'
 import type { RedisConnectionManager } from './redis/connection'
 import type { isApprovalContinuationRequest } from './runtime/approval-continuation'
+import type { routeWorkstreamChatMessages } from './runtime/chat-request-routing'
 import type { LotaPlugin } from './runtime/plugin-types'
 import type { LotaRuntimeAdapters, LotaRuntimeTurnHooks } from './runtime/runtime-extensions'
 import type { attachmentService } from './services/attachment.service'
 import type { executionPlanService } from './services/execution-plan.service'
 import type { memoryService } from './services/memory.service'
 import type { verifyMutatingApproval } from './services/mutating-approval.service'
+import type { organizationMemberService } from './services/organization-member.service'
+import type { organizationService } from './services/organization.service'
 import type { recentActivityTitleService } from './services/recent-activity-title.service'
 import type { recentActivityService } from './services/recent-activity.service'
+import type { userService } from './services/user.service'
 import type { workstreamMessageService } from './services/workstream-message.service'
 import type { workstreamTitleService } from './services/workstream-title.service'
 import type {
@@ -39,11 +46,22 @@ interface LotaRuntimeBuiltInWorkers {
   startRecentActivityTitleRefinementWorker: typeof startRecentActivityTitleRefinementWorker
   startRegularChatMemoryDigestWorker: typeof startRegularChatMemoryDigestWorker
   startSkillExtractionWorker: typeof startSkillExtractionWorker
+  startWorkstreamTitleGenerationWorker: typeof startWorkstreamTitleGenerationWorker
   scheduleRecurringConsolidation: typeof scheduleRecurringConsolidation
 }
 
+type ArchiveSdkWorkstream = (
+  workstreamId: Parameters<typeof workstreamService.updateStatus>[0],
+  status?: 'archived',
+) => ReturnType<typeof workstreamService.updateStatus>
+
+type UnarchiveSdkWorkstream = (
+  workstreamId: Parameters<typeof workstreamService.updateStatus>[0],
+  status?: 'regular',
+) => ReturnType<typeof workstreamService.updateStatus>
+
 export interface LotaRuntimeConfig {
-  database: { url: string; namespace: string; database: string; username: string; password: string }
+  database: { url: string; namespace: string; username: string; password: string }
   redis: { url: string }
   aiGateway: { url: string; key: string; admin?: string; pass?: string; embeddingModel?: string }
   s3: {
@@ -88,6 +106,9 @@ export interface LotaRuntime {
     generatedDocumentStorageService: typeof generatedDocumentStorageService
     memoryService: typeof memoryService
     verifyMutatingApproval: typeof verifyMutatingApproval
+    organizationService: typeof organizationService
+    organizationMemberService: typeof organizationMemberService
+    userService: typeof userService
     recentActivityService: typeof recentActivityService
     recentActivityTitleService: typeof recentActivityTitleService
     executionPlanService: typeof executionPlanService
@@ -99,6 +120,57 @@ export interface LotaRuntime {
     isApprovalContinuationRequest: typeof isApprovalContinuationRequest
     runWorkstreamTurnInBackground: typeof runWorkstreamTurnInBackground
   }
+  lota: {
+    organizations: {
+      create: typeof organizationService.createOrganization
+      upsert: typeof organizationService.upsertOrganization
+      get: typeof organizationService.getOrganization
+      list: typeof organizationService.listOrganizations
+      update: typeof organizationService.updateOrganization
+      delete: typeof organizationService.deleteOrganization
+    }
+    users: {
+      upsert: typeof userService.upsertUser
+      get: typeof userService.getUser
+      list: typeof userService.listUsers
+      update: typeof userService.updateUser
+      delete: typeof userService.deleteUser
+    }
+    memberships: {
+      add: typeof organizationMemberService.addMembership
+      listForOrganization: typeof organizationMemberService.listMembershipsForOrganization
+      listForUser: typeof organizationMemberService.listMembershipsForUser
+      remove: typeof organizationMemberService.removeMembership
+      isMember: typeof organizationMemberService.isMember
+    }
+    workstreams: {
+      create: typeof workstreamService.createWorkstream
+      list: typeof workstreamService.listWorkstreams
+      get: typeof workstreamService.getWorkstream
+      update: typeof workstreamService.updateTitle
+      archive: ArchiveSdkWorkstream
+      unarchive: UnarchiveSdkWorkstream
+      delete: typeof workstreamService.deleteWorkstream
+      stop: typeof workstreamService.stopActiveRun
+      listMessages: typeof workstreamMessageService.listMessageHistoryPage
+      getMessage: (params: { workstreamId: string; messageId: string }) => Promise<unknown>
+      sendMessage: (params: {
+        workstreamId: string
+        organizationId: string
+        userId: string
+        userName: string
+        messages: Parameters<typeof routeWorkstreamChatMessages>[0]
+      }) => Promise<Awaited<ReturnType<typeof createWorkstreamTurnStream>>>
+      continueApproval: (params: {
+        workstreamId: string
+        organizationId: string
+        userId: string
+        userName: string
+        messages: Parameters<typeof routeWorkstreamChatMessages>[0]
+      }) => Promise<Awaited<ReturnType<typeof createWorkstreamApprovalContinuationStream>>>
+      uploadAttachment: typeof attachmentService.uploadWorkstreamAttachment
+    }
+  }
   redis: {
     manager: RedisConnectionManager
     getConnection: () => ReturnType<RedisConnectionManager['getConnection']>
@@ -118,12 +190,16 @@ export interface LotaRuntime {
 export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<LotaRuntime> {
   const { lotaSdkEnvKeys, setEnv } = await import('./config/env-shapes')
   const { configureLogger } = await import('./config/logger')
+  const { publishDatabaseBootstrap } = await import('./db/startup')
+  const { computeSchemaFingerprint } = await import('./db/schema-fingerprint')
+  const { LOTA_SDK_DATABASE_NAME } = await import('./db/sdk-database')
   const { SurrealDBService: SurrealDBServiceClass, setDatabaseService } = await import('./db/service')
   const { createRedisConnectionManager } = await import('./redis/connection')
   const { setRedisConnectionManager } = await import('./redis/index')
   const { configureAgents, configureAgentFactory } = await import('./config/agent-defaults')
   const { configureWorkstreams } = await import('./config/workstream-defaults')
   const { configureRuntimeExtensions } = await import('./runtime/runtime-extensions')
+  const { routeWorkstreamChatMessages } = await import('./runtime/chat-request-routing')
 
   setEnv({
     AI_GATEWAY_URL: config.aiGateway.url,
@@ -149,7 +225,7 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
   const db = new SurrealDBServiceClass({
     url: config.database.url,
     namespace: config.database.namespace,
-    database: config.database.database,
+    database: LOTA_SDK_DATABASE_NAME,
     username: config.database.username,
     password: config.database.password,
   })
@@ -182,6 +258,9 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
   const { executionPlanService } = await import('./services/execution-plan.service')
   const { memoryService } = await import('./services/memory.service')
   const { verifyMutatingApproval } = await import('./services/mutating-approval.service')
+  const { organizationMemberService } = await import('./services/organization-member.service')
+  const { organizationService } = await import('./services/organization.service')
+  const { userService } = await import('./services/user.service')
   const { workstreamMessageService } = await import('./services/workstream-message.service')
   const { workstreamService } = await import('./services/workstream.service')
   const { workstreamTitleService } = await import('./services/workstream-title.service')
@@ -199,6 +278,7 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
   const { startRecentActivityTitleRefinementWorker } = await import('./queues/recent-activity-title-refinement.queue')
   const { startRegularChatMemoryDigestWorker } = await import('./queues/regular-chat-memory-digest.queue')
   const { startSkillExtractionWorker } = await import('./queues/skill-extraction.queue')
+  const { startWorkstreamTitleGenerationWorker } = await import('./queues/workstream-title-generation.queue')
 
   configureRuntimeExtensions({
     adapters: config.runtimeAdapters,
@@ -209,11 +289,8 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
 
   const pluginRuntime = config.pluginRuntime ?? {}
   const pluginContributions = Object.values(pluginRuntime).map((plugin) => plugin.contributions)
-  const schemaFiles = [
-    ...getBuiltInSchemaFiles(),
-    ...pluginContributions.flatMap((plugin) => plugin.schemaFiles),
-    ...(config.extraSchemaFiles ?? []),
-  ]
+  const schemaFiles = [...getBuiltInSchemaFiles(), ...(config.extraSchemaFiles ?? [])]
+  const hostContributionSchemaFiles = pluginContributions.flatMap((plugin) => plugin.schemaFiles)
   const contributionEnvKeys = [...lotaSdkEnvKeys, ...pluginContributions.flatMap((plugin) => plugin.envKeys)]
   const connectPluginDatabases = createPluginDatabaseConnector(pluginRuntime)
   const builtInWorkers = {
@@ -223,9 +300,91 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
     startRecentActivityTitleRefinementWorker,
     startRegularChatMemoryDigestWorker,
     startSkillExtractionWorker,
+    startWorkstreamTitleGenerationWorker,
     scheduleRecurringConsolidation,
   } satisfies LotaRuntimeBuiltInWorkers
 
+  const lota = {
+    organizations: {
+      create: organizationService.createOrganization.bind(organizationService),
+      upsert: organizationService.upsertOrganization.bind(organizationService),
+      get: organizationService.getOrganization.bind(organizationService),
+      list: organizationService.listOrganizations.bind(organizationService),
+      update: organizationService.updateOrganization.bind(organizationService),
+      delete: organizationService.deleteOrganization.bind(organizationService),
+    },
+    users: {
+      upsert: userService.upsertUser.bind(userService),
+      get: userService.getUser.bind(userService),
+      list: userService.listUsers.bind(userService),
+      update: userService.updateUser.bind(userService),
+      delete: userService.deleteUser.bind(userService),
+    },
+    memberships: {
+      add: organizationMemberService.addMembership.bind(organizationMemberService),
+      listForOrganization: organizationMemberService.listMembershipsForOrganization.bind(organizationMemberService),
+      listForUser: organizationMemberService.listMembershipsForUser.bind(organizationMemberService),
+      remove: organizationMemberService.removeMembership.bind(organizationMemberService),
+      isMember: organizationMemberService.isMember.bind(organizationMemberService),
+    },
+    workstreams: {
+      create: workstreamService.createWorkstream.bind(workstreamService),
+      list: workstreamService.listWorkstreams.bind(workstreamService),
+      get: workstreamService.getWorkstream.bind(workstreamService),
+      update: workstreamService.updateTitle.bind(workstreamService),
+      archive: async (workstreamId, status = 'archived') => await workstreamService.updateStatus(workstreamId, status),
+      unarchive: async (workstreamId, status = 'regular') => await workstreamService.updateStatus(workstreamId, status),
+      delete: workstreamService.deleteWorkstream.bind(workstreamService),
+      stop: workstreamService.stopActiveRun.bind(workstreamService),
+      listMessages: workstreamMessageService.listMessageHistoryPage.bind(workstreamMessageService),
+      getMessage: async ({ workstreamId, messageId }) => {
+        const messages = await workstreamMessageService.listMessages(ensureRecordId(workstreamId, TABLES.WORKSTREAM))
+        const message = messages.find((candidate) => candidate.id === messageId)
+        if (!message) {
+          throw new Error(`Workstream message not found: ${messageId}`)
+        }
+        return message
+      },
+      sendMessage: async ({ workstreamId, organizationId, userId, userName, messages }) => {
+        const workstreamRef = ensureRecordId(workstreamId, TABLES.WORKSTREAM)
+        const workstream = await workstreamService.getWorkstream(workstreamRef)
+        const routed = routeWorkstreamChatMessages(messages)
+        if (routed.kind !== 'turn') {
+          throw new Error(routed.kind === 'invalid' ? routed.message : 'Expected a user turn payload.')
+        }
+
+        return await createWorkstreamTurnStream({
+          workstream,
+          workstreamRef,
+          orgRef: ensureRecordId(organizationId, TABLES.ORGANIZATION),
+          userRef: ensureRecordId(userId, TABLES.USER),
+          userName,
+          inputMessage: routed.inputMessage,
+        })
+      },
+      continueApproval: async ({ workstreamId, organizationId, userId, userName, messages }) => {
+        const workstreamRef = ensureRecordId(workstreamId, TABLES.WORKSTREAM)
+        const workstream = await workstreamService.getWorkstream(workstreamRef)
+        const routed = routeWorkstreamChatMessages(messages)
+        if (routed.kind !== 'approval-continuation') {
+          throw new Error(
+            routed.kind === 'invalid' ? routed.message : 'Expected approval continuation messages payload.',
+          )
+        }
+
+        return await createWorkstreamApprovalContinuationStream({
+          workstream,
+          workstreamRef,
+          orgRef: ensureRecordId(organizationId, TABLES.ORGANIZATION),
+          userRef: ensureRecordId(userId, TABLES.USER),
+          userName,
+          approvalMessages: routed.approvalMessages,
+        })
+      },
+      uploadAttachment: attachmentService.uploadWorkstreamAttachment.bind(attachmentService),
+    },
+  } satisfies LotaRuntime['lota']
+
   return {
     services: {
       database: db,
@@ -236,6 +395,9 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
       generatedDocumentStorageService,
       memoryService,
       verifyMutatingApproval,
+      organizationService,
+      organizationMemberService,
+      userService,
       recentActivityService,
       recentActivityTitleService,
       executionPlanService,
@@ -247,6 +409,7 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
       isApprovalContinuationRequest,
       runWorkstreamTurnInBackground,
     },
+    lota,
     redis: {
       manager: redisManager,
       getConnection: () => redisManager.getConnection(),
@@ -255,7 +418,7 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
     },
     workers: { ...builtInWorkers, ...config.extraWorkers },
     schemaFiles,
-    contributions: { envKeys: [...new Set(contributionEnvKeys)], schemaFiles },
+    contributions: { envKeys: [...new Set(contributionEnvKeys)], schemaFiles: hostContributionSchemaFiles },
     config,
     plugins: pluginRuntime,
     async connectPluginDatabases() {
@@ -263,6 +426,12 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
     },
     async connect() {
       await db.connect()
+      const bunFiles = schemaFiles.map((schemaFile) =>
+        schemaFile instanceof URL ? Bun.file(schemaFile.pathname) : Bun.file(schemaFile),
+      )
+      await db.applySchemaAndMigrations(bunFiles)
+      const schemaFingerprint = await computeSchemaFingerprint(schemaFiles)
+      await publishDatabaseBootstrap({ databaseService: db, schemaFingerprint })
     },
     async disconnect() {
       await db.disconnect()
@@ -273,10 +442,12 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
 
 function getBuiltInSchemaFiles(): URL[] {
   return [
+    new URL('../infrastructure/schema/00_identity.surql', import.meta.url),
     new URL('../infrastructure/schema/00_workstream.surql', import.meta.url),
     new URL('../infrastructure/schema/01_memory.surql', import.meta.url),
     new URL('../infrastructure/schema/02_execution_plan.surql', import.meta.url),
     new URL('../infrastructure/schema/03_learned_skill.surql', import.meta.url),
+    new URL('../infrastructure/schema/05_recent_activity.surql', import.meta.url),
     new URL('../infrastructure/schema/04_runtime_bootstrap.surql', import.meta.url),
   ]
 }

package/src/queues/workstream-title-generation.queue.ts

@@ -0,0 +1,69 @@
+import { Queue, Worker } from 'bullmq'
+import type { Job } from 'bullmq'
+
+import { serverLogger } from '../config/logger'
+import { ensureRecordId } from '../db/record-id'
+import { databaseService } from '../db/service'
+import { getRedisConnectionForBullMQ } from '../redis'
+import { workstreamTitleService } from '../services/workstream-title.service'
+import {
+  attachWorkerEvents,
+  createTracedWorkerProcessor,
+  createWorkerShutdown,
+  registerShutdownSignals,
+} from '../workers/worker-utils'
+import type { WorkerHandle } from '../workers/worker-utils'
+
+interface WorkstreamTitleGenerationJob {
+  workstreamId: string
+  sourceText: string
+}
+
+const WORKSTREAM_TITLE_GENERATION_QUEUE = 'workstream-title-generation'
+
+let _workstreamTitleGenerationQueue: Queue<WorkstreamTitleGenerationJob> | null = null
+function getWorkstreamTitleGenerationQueue(): Queue<WorkstreamTitleGenerationJob> {
+  if (!_workstreamTitleGenerationQueue) {
+    _workstreamTitleGenerationQueue = new Queue<WorkstreamTitleGenerationJob>(WORKSTREAM_TITLE_GENERATION_QUEUE, {
+      connection: getRedisConnectionForBullMQ(),
+      defaultJobOptions: {
+        removeOnComplete: 200,
+        removeOnFail: 200,
+        attempts: 2,
+        backoff: { type: 'exponential', delay: 2_000 },
+      },
+    })
+  }
+  return _workstreamTitleGenerationQueue
+}
+
+export async function enqueueWorkstreamTitleGeneration(job: WorkstreamTitleGenerationJob) {
+  return await getWorkstreamTitleGenerationQueue().add('generate-workstream-title', job, {
+    jobId: `workstream-title:${job.workstreamId}`,
+  })
+}
+
+async function processWorkstreamTitleGenerationJob(job: Job<WorkstreamTitleGenerationJob>): Promise<void> {
+  await databaseService.connect()
+  const workstreamRef = ensureRecordId(job.data.workstreamId)
+  await workstreamTitleService.generateAndPersistTitle(workstreamRef, job.data.sourceText)
+}
+
+export function startWorkstreamTitleGenerationWorker(options: { registerSignals?: boolean } = {}): WorkerHandle {
+  const { registerSignals = import.meta.main } = options
+  const worker = new Worker(
+    WORKSTREAM_TITLE_GENERATION_QUEUE,
+    createTracedWorkerProcessor(WORKSTREAM_TITLE_GENERATION_QUEUE, processWorkstreamTitleGenerationJob),
+    { connection: getRedisConnectionForBullMQ(), concurrency: 2, lockDuration: 60_000 },
+  )
+
+  attachWorkerEvents(worker, 'Workstream title generation', serverLogger)
+
+  const shutdown = createWorkerShutdown(worker, 'Workstream title generation', serverLogger)
+
+  if (registerSignals) {
+    registerShutdownSignals({ name: 'Workstream title generation', shutdown, logger: serverLogger })
+  }
+
+  return { worker, shutdown }
+}

package/src/runtime/helper-model.ts

@@ -48,6 +48,7 @@ export interface GenerateHelperStructuredParams<T> extends Omit<GenerateHelperTe
   tag: string
   schema: ZodSchema<T>
   textFallbackParser?: (text: string) => T | null
+  normalizeCandidate?: (candidate: unknown) => unknown
 }
 
 function isObject(value: unknown): value is Record<string, unknown> {
@@ -358,6 +359,14 @@ export function createHelperModelRuntime() {
         return parsed.data
       }
 
+      if (params.normalizeCandidate && isObject(result.output)) {
+        const normalized = params.normalizeCandidate(result.output)
+        const normalizedParsed = parseStructuredCandidate({ schema: params.schema, candidate: normalized })
+        if (normalizedParsed) {
+          return normalizedParsed.data
+        }
+      }
+
       if (typeof result.text === 'string' && result.text.trim().length > 0) {
         return parseStructuredTextWithFallbacks({
           schema: params.schema,
@@ -401,5 +410,3 @@ export function createHelperModelRuntime() {
 
   return { generateHelperText, generateHelperStructured }
 }
-
-export const llmHelperService = createHelperModelRuntime()

package/src/services/organization-member.service.ts

@@ -0,0 +1,114 @@
+import { recordIdStringSchema } from '@lota-sdk/shared/schemas/common'
+import { z } from 'zod'
+
+import { BaseService } from '../db/base.service'
+import { ensureRecordId, recordIdToString } from '../db/record-id'
+import type { RecordIdInput, RecordIdRef } from '../db/record-id'
+import { TABLES } from '../db/tables'
+import { toIsoDateTimeString } from '../utils/date-time'
+
+const organizationMemberRecordSchema = z.object({
+  id: z.unknown(),
+  in: z.unknown(),
+  out: z.unknown(),
+  role: z.string(),
+  createdAt: z.coerce.date(),
+})
+
+const sdkOrganizationMemberSchema = z.object({
+  id: recordIdStringSchema,
+  userId: recordIdStringSchema,
+  organizationId: recordIdStringSchema,
+  role: z.string(),
+  createdAt: z.iso.datetime(),
+})
+
+export type SdkOrganizationMemberRecord = z.infer<typeof organizationMemberRecordSchema>
+export type SdkOrganizationMember = z.infer<typeof sdkOrganizationMemberSchema>
+
+class OrganizationMemberService extends BaseService<typeof organizationMemberRecordSchema> {
+  constructor() {
+    super(TABLES.ORGANIZATION_MEMBER, organizationMemberRecordSchema)
+  }
+
+  toPublic(record: SdkOrganizationMemberRecord): SdkOrganizationMember {
+    return sdkOrganizationMemberSchema.parse({
+      id: recordIdToString(
+        ensureRecordId(record.id as RecordIdInput, TABLES.ORGANIZATION_MEMBER),
+        TABLES.ORGANIZATION_MEMBER,
+      ),
+      userId: recordIdToString(ensureRecordId(record.in as RecordIdInput, TABLES.USER), TABLES.USER),
+      organizationId: recordIdToString(
+        ensureRecordId(record.out as RecordIdInput, TABLES.ORGANIZATION),
+        TABLES.ORGANIZATION,
+      ),
+      role: record.role,
+      createdAt: toIsoDateTimeString(record.createdAt),
+    })
+  }
+
+  async addMembership(params: {
+    userId: RecordIdInput
+    organizationId: RecordIdInput
+    role: 'owner' | 'member'
+  }): Promise<SdkOrganizationMember> {
+    const userRef = ensureRecordId(params.userId, TABLES.USER)
+    const organizationRef = ensureRecordId(params.organizationId, TABLES.ORGANIZATION)
+    const existing = (await this.findAll({ in: userRef, out: organizationRef }, { limit: 1 })).at(0)
+
+    if (existing) {
+      return this.toPublic(await this.update(existing.id, { role: params.role }))
+    }
+
+    const related = await this.databaseService.relate(userRef, TABLES.ORGANIZATION_MEMBER, organizationRef, {
+      role: params.role,
+    })
+    if (!related) {
+      throw new Error(
+        `Failed to create membership for ${recordIdToString(userRef, TABLES.USER)} in ${recordIdToString(
+          organizationRef,
+          TABLES.ORGANIZATION,
+        )}`,
+      )
+    }
+
+    const record = organizationMemberRecordSchema.parse(related)
+
+    return this.toPublic(record)
+  }
+
+  async listMembershipsForOrganization(organizationId: RecordIdRef): Promise<SdkOrganizationMember[]> {
+    const organizationRef = ensureRecordId(organizationId, TABLES.ORGANIZATION)
+    return (await this.findAll({ out: organizationRef }, { orderBy: 'createdAt', orderDir: 'ASC' })).map((record) =>
+      this.toPublic(record),
+    )
+  }
+
+  async listMembershipsForUser(userId: RecordIdRef): Promise<SdkOrganizationMember[]> {
+    const userRef = ensureRecordId(userId, TABLES.USER)
+    return (await this.findAll({ in: userRef }, { orderBy: 'createdAt', orderDir: 'ASC' })).map((record) =>
+      this.toPublic(record),
+    )
+  }
+
+  async isMember(userId: RecordIdInput, organizationId: RecordIdInput): Promise<boolean> {
+    const userRef = ensureRecordId(userId, TABLES.USER)
+    const organizationRef = ensureRecordId(organizationId, TABLES.ORGANIZATION)
+    const existing = await this.findAll({ in: userRef, out: organizationRef }, { limit: 1 })
+    return existing.length > 0
+  }
+
+  async removeMembership(params: { userId: RecordIdInput; organizationId: RecordIdInput }): Promise<void> {
+    const userRef = ensureRecordId(params.userId, TABLES.USER)
+    const organizationRef = ensureRecordId(params.organizationId, TABLES.ORGANIZATION)
+    const existing = await this.findAll({ in: userRef, out: organizationRef }, { limit: 1 })
+    const record = existing.at(0)
+    if (!record) {
+      return
+    }
+
+    await this.delete(record.id)
+  }
+}
+
+export const organizationMemberService = new OrganizationMemberService()

package/src/services/organization.service.ts

@@ -0,0 +1,117 @@
+import { recordIdStringSchema } from '@lota-sdk/shared/schemas/common'
+import { z } from 'zod'
+
+import { BaseService } from '../db/base.service'
+import { ensureRecordId, recordIdToString } from '../db/record-id'
+import type { RecordIdInput, RecordIdRef } from '../db/record-id'
+import { databaseService } from '../db/service'
+import { TABLES } from '../db/tables'
+import { toIsoDateTimeString, toOptionalIsoDateTimeString } from '../utils/date-time'
+
+const organizationRecordSchema = z.object({
+  id: z.unknown(),
+  name: z.string(),
+  regularChatDigestLastWorkstreamCursorCreatedAt: z.union([z.date(), z.string(), z.number()]).optional(),
+  regularChatDigestLastWorkstreamCursorId: z.string().optional(),
+  skillExtractionLastCursorId: z.string().optional(),
+  skillExtractionLastCursorCreatedAt: z.union([z.date(), z.string(), z.number()]).optional(),
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+})
+
+const sdkOrganizationSchema = z.object({
+  id: recordIdStringSchema,
+  name: z.string(),
+  regularChatDigestLastWorkstreamCursorCreatedAt: z.iso.datetime().nullable().optional(),
+  regularChatDigestLastWorkstreamCursorId: z.string().nullable().optional(),
+  skillExtractionLastCursorId: z.string().nullable().optional(),
+  skillExtractionLastCursorCreatedAt: z.iso.datetime().nullable().optional(),
+  createdAt: z.iso.datetime(),
+  updatedAt: z.iso.datetime(),
+})
+
+export type SdkOrganizationRecord = z.infer<typeof organizationRecordSchema>
+export type SdkOrganization = z.infer<typeof sdkOrganizationSchema>
+
+interface BackgroundCursor {
+  createdAt: Date
+  id: string
+}
+
+function toOptionalCursorTimestamp(value: unknown): string | null {
+  return toOptionalIsoDateTimeString(value) ?? null
+}
+
+class OrganizationService extends BaseService<typeof organizationRecordSchema> {
+  constructor() {
+    super(TABLES.ORGANIZATION, organizationRecordSchema)
+  }
+
+  toPublic(record: SdkOrganizationRecord): SdkOrganization {
+    return sdkOrganizationSchema.parse({
+      id: recordIdToString(ensureRecordId(record.id as RecordIdInput, TABLES.ORGANIZATION), TABLES.ORGANIZATION),
+      name: record.name,
+      regularChatDigestLastWorkstreamCursorCreatedAt: toOptionalCursorTimestamp(
+        record.regularChatDigestLastWorkstreamCursorCreatedAt,
+      ),
+      regularChatDigestLastWorkstreamCursorId: record.regularChatDigestLastWorkstreamCursorId ?? null,
+      skillExtractionLastCursorId: record.skillExtractionLastCursorId ?? null,
+      skillExtractionLastCursorCreatedAt: toOptionalCursorTimestamp(record.skillExtractionLastCursorCreatedAt),
+      createdAt: toIsoDateTimeString(record.createdAt),
+      updatedAt: toIsoDateTimeString(record.updatedAt),
+    })
+  }
+
+  async createOrganization(params: { name: string }): Promise<SdkOrganization> {
+    return this.toPublic(await this.create({ name: params.name }))
+  }
+
+  async upsertOrganization(params: { id: RecordIdInput; name: string }): Promise<SdkOrganization> {
+    const organizationRef = ensureRecordId(params.id, TABLES.ORGANIZATION)
+    const record = await databaseService.upsert(
+      TABLES.ORGANIZATION,
+      organizationRef,
+      { name: params.name },
+      organizationRecordSchema,
+    )
+    return this.toPublic(record)
+  }
+
+  async listOrganizations(): Promise<SdkOrganization[]> {
+    return (await this.findAll({}, { orderBy: 'createdAt', orderDir: 'ASC' })).map((record) => this.toPublic(record))
+  }
+
+  async getOrganization(organizationId: RecordIdInput): Promise<SdkOrganization> {
+    return this.toPublic(await this.getById(ensureRecordId(organizationId, TABLES.ORGANIZATION)))
+  }
+
+  async getOrganizationRecord(organizationId: RecordIdRef): Promise<SdkOrganizationRecord> {
+    return await this.getById(ensureRecordId(organizationId, TABLES.ORGANIZATION))
+  }
+
+  async updateOrganization(organizationId: RecordIdInput, params: { name: string }): Promise<SdkOrganization> {
+    return this.toPublic(await this.update(ensureRecordId(organizationId, TABLES.ORGANIZATION), { name: params.name }))
+  }
+
+  async deleteOrganization(organizationId: RecordIdInput): Promise<void> {
+    const organizationRef = ensureRecordId(organizationId, TABLES.ORGANIZATION)
+    await databaseService.deleteWhere(TABLES.ORGANIZATION_MEMBER, { out: organizationRef })
+    await this.delete(organizationRef)
+  }
+
+  async updateRegularChatDigestCursor(organizationId: RecordIdRef, cursor: BackgroundCursor): Promise<void> {
+    await this.update(organizationId, {
+      regularChatDigestLastWorkstreamCursorCreatedAt: cursor.createdAt,
+      regularChatDigestLastWorkstreamCursorId: cursor.id,
+    })
+  }
+
+  async updateSkillExtractionCursor(organizationId: RecordIdRef, cursor: BackgroundCursor): Promise<void> {
+    await this.update(organizationId, {
+      skillExtractionLastCursorCreatedAt: cursor.createdAt,
+      skillExtractionLastCursorId: cursor.id,
+    })
+  }
+}
+
+export const organizationService = new OrganizationService()

package/src/services/user.service.ts

@@ -0,0 +1,56 @@
+import type { SdkUser, SdkUserRecord } from '@lota-sdk/shared/schemas/user'
+import { sdkUserRecordSchema, sdkUserSchema } from '@lota-sdk/shared/schemas/user'
+
+import { BaseService } from '../db/base.service'
+import { ensureRecordId, recordIdToString } from '../db/record-id'
+import type { RecordIdInput } from '../db/record-id'
+import { databaseService } from '../db/service'
+import { TABLES } from '../db/tables'
+import { toIsoDateTimeString } from '../utils/date-time'
+
+class UserService extends BaseService<typeof sdkUserRecordSchema> {
+  constructor() {
+    super(TABLES.USER, sdkUserRecordSchema)
+  }
+
+  toPublic(record: SdkUserRecord): SdkUser {
+    return sdkUserSchema.parse({
+      id: recordIdToString(ensureRecordId(record.id as RecordIdInput, TABLES.USER), TABLES.USER),
+      name: record.name,
+      email: record.email,
+      createdAt: toIsoDateTimeString(record.createdAt),
+      updatedAt: toIsoDateTimeString(record.updatedAt),
+    })
+  }
+
+  async upsertUser(params: { id: RecordIdInput; name: string; email: string }): Promise<SdkUser> {
+    const userRef = ensureRecordId(params.id, TABLES.USER)
+    const record = await databaseService.upsert(
+      TABLES.USER,
+      userRef,
+      { name: params.name, email: params.email },
+      sdkUserRecordSchema,
+    )
+    return this.toPublic(record)
+  }
+
+  async getUser(userId: RecordIdInput): Promise<SdkUser> {
+    return this.toPublic(await this.getById(ensureRecordId(userId, TABLES.USER)))
+  }
+
+  async listUsers(): Promise<SdkUser[]> {
+    return (await this.findAll({}, { orderBy: 'createdAt', orderDir: 'ASC' })).map((record) => this.toPublic(record))
+  }
+
+  async updateUser(userId: RecordIdInput, params: { name?: string; email?: string }): Promise<SdkUser> {
+    return this.toPublic(await this.update(ensureRecordId(userId, TABLES.USER), params))
+  }
+
+  async deleteUser(userId: RecordIdInput): Promise<void> {
+    const userRef = ensureRecordId(userId, TABLES.USER)
+    await databaseService.deleteWhere(TABLES.ORGANIZATION_MEMBER, { in: userRef })
+    await this.delete(userRef)
+  }
+}
+
+export const userService = new UserService()

package/src/services/workstream-title.service.ts

@@ -2,56 +2,46 @@ import { WORKSTREAM } from '@lota-sdk/shared/constants/workstream'
 
 import { chatLogger } from '../config/logger'
 import type { RecordIdRef } from '../db/record-id'
-import { recordIdToString } from '../db/record-id'
-import { TABLES } from '../db/tables'
-import type { HelperAgent } from '../runtime/helper-model'
-import { llmHelperService } from '../runtime/helper-model'
+import { createHelperModelRuntime } from '../runtime/helper-model'
 import { deriveTitle, limitTitleWords } from '../runtime/title-helpers'
+import {
+  createWorkstreamTitleGeneratorAgent,
+  WORKSTREAM_TITLE_GENERATOR_PROMPT,
+} from '../system-agents/title-generator.agent'
+import { compactWhitespace } from '../utils/string'
 import { workstreamService } from './workstream.service'
 
-const titlePromises = new Map<string, Promise<string>>()
+function normalizeTitle(value: string): string {
+  const normalized = compactWhitespace(value)
+    .replace(/^["'`]+|["'`]+$/g, '')
+    .replace(/[.!?,;:]+$/g, '')
+  return normalized.length <= 80 ? normalized : normalized.slice(0, 80).trim()
+}
 
 class WorkstreamTitleService {
-  async ensureTitle(workstreamId: RecordIdRef, existingTitle: string, sourceText: string): Promise<string> {
-    const trimmedSource = sourceText.trim()
-    if (!trimmedSource) return existingTitle
-    if (existingTitle && existingTitle.trim() !== WORKSTREAM.DEFAULT_TITLE) {
-      return existingTitle
-    }
-
-    const key = recordIdToString(workstreamId, TABLES.WORKSTREAM)
-    const existingPromise = titlePromises.get(key)
-    if (existingPromise) {
-      return existingPromise
-    }
-
-    const promise = this.generateAndPersistTitle(workstreamId, trimmedSource).finally(() => {
-      titlePromises.delete(key)
-    })
-    titlePromises.set(key, promise)
-
-    return promise
-  }
+  helperRuntime = createHelperModelRuntime()
 
-  private async generateAndPersistTitle(workstreamId: RecordIdRef, sourceText: string): Promise<string> {
+  async generateAndPersistTitle(workstreamId: RecordIdRef, sourceText: string): Promise<void> {
     let title = ''
     try {
-      title = await llmHelperService.generateHelperText({
-        tag: 'workstream-title',
-        createAgent: (_opts: unknown) => ({ generate: async () => ({ text: '' }) }) as unknown as HelperAgent,
-        messages: [{ role: 'user' as const, content: `Generate a concise 4-5 word title for: ${sourceText}` }],
-      })
+      title = normalizeTitle(
+        await this.helperRuntime.generateHelperText({
+          tag: 'workstream-title',
+          createAgent: createWorkstreamTitleGeneratorAgent,
+          defaultSystemPrompt: WORKSTREAM_TITLE_GENERATOR_PROMPT,
+          timeoutMs: 30_000,
+          messages: [{ role: 'user', content: sourceText }],
+        }),
+      )
     } catch (error) {
-      chatLogger.warn`Failed to generate workstream title (non-fatal): ${error}`
-      title = ''
+      chatLogger.warn`Failed to generate workstream title via LLM (non-fatal): ${error}`
     }
 
     if (!title) {
       title = limitTitleWords(deriveTitle(sourceText || WORKSTREAM.DEFAULT_TITLE))
     }
 
-    await workstreamService.updateTitle(workstreamId, title)
-    return title
+    await workstreamService.persistGeneratedTitle(workstreamId, title)
   }
 }
 

package/src/services/workstream-turn-preparation.ts

@@ -28,6 +28,7 @@ import { enqueuePostChatMemory } from '../queues/post-chat-memory.queue'
 import { enqueueRecentActivityTitleRefinement } from '../queues/recent-activity-title-refinement.queue'
 import { enqueueRegularChatMemoryDigest } from '../queues/regular-chat-memory-digest.queue'
 import { enqueueSkillExtraction } from '../queues/skill-extraction.queue'
+import { enqueueWorkstreamTitleGeneration } from '../queues/workstream-title-generation.queue'
 import { buildAgentPromptContext } from '../runtime/agent-prompt-context'
 import {
   buildSpecialistTaskMessage,
@@ -445,6 +446,20 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
       ? [...liveHistory].reverse().find((m) => m.role === 'user')
       : (userMessage ?? [...liveHistory].reverse().find((m) => m.role === 'user'))
   const messageText = referenceUserMessage ? extractMessageText(referenceUserMessage).trim() : ''
+
+  if (
+    params.kind === 'userTurn' &&
+    workstream.mode === 'group' &&
+    !workstream.core &&
+    workstreamRecord.nameGenerated !== true &&
+    messageText.length > 0
+  ) {
+    void safeEnqueue(
+      () => enqueueWorkstreamTitleGeneration({ workstreamId: workstreamIdString, sourceText: messageText }),
+      { operationName: 'workstream-title-generation' },
+    )
+  }
+
   const onboardingActive = workspaceLifecycleState?.bootstrapActive ?? false
   if (workstream.core && !workstream.coreType) {
     throw new WorkstreamTurnError('Core workstreams require a core type.', 400)

package/src/services/workstream.service.ts

@@ -356,7 +356,7 @@ class WorkstreamService extends BaseService<typeof WorkstreamSchema> {
         .createWithId(
           TABLES.WORKSTREAM,
           directWorkstreamId,
-          { userId, organizationId: orgId, mode, core: false, agentId, title, status: 'regular' },
+          { userId, organizationId: orgId, mode, core: false, agentId, title, status: 'regular', nameGenerated: true },
           WorkstreamSchema,
         )
         .catch((error) => {
@@ -402,6 +402,7 @@ class WorkstreamService extends BaseService<typeof WorkstreamSchema> {
             agentId: coreProfile.config.agentId,
             title,
             status: 'regular',
+            nameGenerated: true,
           },
           WorkstreamSchema,
         )
@@ -781,6 +782,7 @@ class WorkstreamService extends BaseService<typeof WorkstreamSchema> {
       mode,
       core,
       ...(coreType ? { coreType } : {}),
+      nameGenerated: workstream.nameGenerated === true,
       isRunning: activeRunId !== null,
       isCompacting,
       ...(isAgentName(workstream.agentId) ? { agentId: workstream.agentId } : {}),
@@ -807,6 +809,7 @@ class WorkstreamService extends BaseService<typeof WorkstreamSchema> {
     const mode = typeof workstream.mode === 'string' ? workstream.mode : 'group'
     const core = workstream.core === true
     const coreType = core && typeof workstream.coreType === 'string' ? workstream.coreType : undefined
+    const nameGenerated = 'nameGenerated' in workstream ? workstream.nameGenerated === true : false
     return {
       id,
       mode,
@@ -815,6 +818,7 @@ class WorkstreamService extends BaseService<typeof WorkstreamSchema> {
       ...(isAgentName(workstream.agentId) ? { agentId: workstream.agentId } : {}),
       title: workstream.title ?? this.getDefaultTitle(workstream),
       status: workstream.status ?? 'regular',
+      nameGenerated,
       isRunning,
       isCompacting,
       createdAt,
@@ -838,6 +842,10 @@ class WorkstreamService extends BaseService<typeof WorkstreamSchema> {
     return { ...publicWorkstream, workstreamState }
   }
 
+  async persistGeneratedTitle(workstreamId: RecordIdRef, title: string): Promise<void> {
+    await this.update(workstreamId, { title, nameGenerated: true })
+  }
+
   private assertMutableWorkstream(
     workstream: WorkstreamRecord,
     action: 'rename' | 'archive' | 'unarchive' | 'delete',

package/src/services/workstream.types.ts

@@ -22,6 +22,7 @@ export interface NormalizedWorkstream {
   mode: 'direct' | 'group'
   core: boolean
   coreType?: string
+  nameGenerated: boolean
   isRunning: boolean
   isCompacting: boolean
   agentId?: string | null
@@ -107,6 +108,7 @@ export const WorkstreamSchema = z.object({
   activeRunId: z.string().nullish(),
   chatSummary: z.string().nullish(),
   lastCompactedMessageId: z.string().nullish(),
+  nameGenerated: z.boolean().optional().default(false),
   isCompacting: z.boolean().optional(),
   state: z.unknown().optional(),
   createdAt: z.coerce.date(),

package/src/system-agents/title-generator.agent.ts

@@ -8,9 +8,9 @@ import {
 import type { CreateHelperToolLoopAgentOptions } from '../runtime/agent-types'
 import { resolveHelperAgentOptions } from './helper-agent-options'
 
-const TITLE_MAX_TOKENS = 500
+const WORKSTREAM_TITLE_MAX_TOKENS = 64
 
-const WORKSTREAM_TITLE_GENERATOR_PROMPT = `<agent-instructions>
+export const WORKSTREAM_TITLE_GENERATOR_PROMPT = `<agent-instructions>
 You are a **Title Generator** that creates concise chat titles.
 
 <task>
@@ -29,14 +29,14 @@ Return only the title text. No quotes, no labels, no explanation.
 </output-format>
 </agent-instructions>`
 
-export function createTitleGeneratorAgent(options: CreateHelperToolLoopAgentOptions) {
+export function createWorkstreamTitleGeneratorAgent(options: CreateHelperToolLoopAgentOptions) {
   return new ToolLoopAgent({
-    id: 'title-generator',
+    id: 'workstream-title-generator',
     model: bifrostModel(OPENROUTER_FAST_REASONING_MODEL_ID),
     providerOptions: OPENROUTER_MINIMAL_REASONING_PROVIDER_OPTIONS,
     ...resolveHelperAgentOptions(options, {
       instructions: WORKSTREAM_TITLE_GENERATOR_PROMPT,
-      maxOutputTokens: TITLE_MAX_TOKENS,
+      maxOutputTokens: WORKSTREAM_TITLE_MAX_TOKENS,
     }),
   })
 }

package/src/workers/bootstrap.ts

@@ -1,8 +1,31 @@
 import { configureLogger, serverLogger } from '../config/logger'
-import { databaseService } from '../db/service'
+import { LOTA_SDK_DATABASE_NAME } from '../db/sdk-database'
+import { SurrealDBService, databaseService, setDatabaseService } from '../db/service'
 import { connectWithStartupRetry, waitForDatabaseBootstrap } from '../db/startup'
 import { getConfiguredPluginDatabaseConnector } from '../runtime/runtime-extensions'
 
+/**
+ * Sandboxed BullMQ workers run in separate child processes where createLotaRuntime
+ * was never called, so the global databaseService proxy has no backing instance.
+ * Create one from env vars so the proxy resolves.
+ */
+function getRequiredEnv(key: string): string {
+  const value = process.env[key]
+  if (!value) throw new Error(`Missing required env var: ${key}`)
+  return value
+}
+
+function ensureDatabaseServiceConfigured(): void {
+  const db = new SurrealDBService({
+    url: getRequiredEnv('SURREALDB_URL'),
+    namespace: getRequiredEnv('SURREALDB_NAMESPACE'),
+    database: LOTA_SDK_DATABASE_NAME,
+    username: process.env.SURREALDB_USER,
+    password: process.env.SURREALDB_PASSWORD,
+  })
+  setDatabaseService(db)
+}
+
 let sandboxedWorkerRuntimePromise: Promise<void> | null = null
 
 export async function initializeSandboxedWorkerRuntime(): Promise<void> {
@@ -14,6 +37,8 @@ export async function initializeSandboxedWorkerRuntime(): Promise<void> {
   sandboxedWorkerRuntimePromise = (async () => {
     await configureLogger()
 
+    ensureDatabaseServiceConfigured()
+
     await connectWithStartupRetry({
       connect: () => databaseService.connect(),
       label: 'sandboxed worker AI database runtime',

package/src/workers/memory-consolidation.worker.ts

@@ -276,13 +276,6 @@ async function cleanupOrphanedRelations(): Promise<number> {
   return result[0]?.count ?? 0
 }
 
-async function pruneOldOrgActions(): Promise<number> {
-  const result = await databaseService.query<{ count: number }>(
-    new BoundQuery(`DELETE ${TABLES.ORG_ACTION} WHERE createdAt < time::now() - 90d RETURN count() AS count`),
-  )
-  return result[0]?.count ?? 0
-}
-
 const handler = async (job: SandboxedJob<MemoryConsolidationJob>) => {
   const targetScope = job.data.scopeId
 
@@ -305,9 +298,8 @@ const handler = async (job: SandboxedJob<MemoryConsolidationJob>) => {
     const collapsed = await collapseSupersedeCh()
     const decayed = await decayImportance()
     const orphaned = await cleanupOrphanedRelations()
-    const prunedActions = await pruneOldOrgActions()
 
-    serverLogger.info`Memory consolidation complete (merged: ${totalMerged}, pruned: ${pruned}, collapsed: ${collapsed}, decayed: ${decayed}, orphaned relations: ${orphaned}, pruned actions: ${prunedActions})`
+    serverLogger.info`Memory consolidation complete (merged: ${totalMerged}, pruned: ${pruned}, collapsed: ${collapsed}, decayed: ${decayed}, orphaned relations: ${orphaned})`
   } catch (error) {
     const serialized = toSandboxedWorkerError(error, 'Memory consolidation job failed')
     serverLogger.error`${serialized.message}`