@lota-sdk/core 0.2.2 → 0.3.0

package/src/workers/regular-chat-memory-digest.runner.ts

@@ -20,11 +20,11 @@ import { compactWhitespace } from '../utils/string'
 import { buildDigestTranscript, resolveWorkspaceBootstrapCutoff } from './regular-chat-memory-digest.helpers'
 import {
   compareDigestMessageOrder,
-  listEligibleWorkstreamMessages,
-  listWorkstreamIdsForOrg,
+  listEligibleThreadMessages,
+  listThreadIdsForOrg,
   normalizeBlock,
-} from './utils/workstream-message-query'
-import type { DigestCursor, DigestMessage } from './utils/workstream-message-query'
+} from './utils/thread-message-query'
+import type { DigestCursor, DigestMessage } from './utils/thread-message-query'
 
 // Onboarding extracts memory immediately inside the turn flow. This delayed
 // runner handles the regular-chat path after onboarding so longer transcripts
@@ -54,7 +54,7 @@ const helperModelRuntime = createHelperModelRuntime()
 
 interface RegularChatDigestRunResult {
   skipped: boolean
-  processedWorkstreamMessages: number
+  processedThreadMessages: number
   processedSocialMessages: number
   followUpScheduled: boolean
 }
@@ -100,35 +100,35 @@ function getLastCursor(messages: DigestMessage[]): DigestCursor | null {
   return messages.length > 0 ? messages[messages.length - 1].cursor : null
 }
 
-async function hasNewEligibleWorkstreamMessages(params: {
-  workstreamIds: RecordIdRef[]
+async function hasNewEligibleThreadMessages(params: {
+  threadIds: RecordIdRef[]
   cursor: DigestCursor | null
   onboardingCutoff: Date | null
 }): Promise<boolean> {
-  if (params.workstreamIds.length === 0) return false
+  if (params.threadIds.length === 0) return false
 
   let query: BoundQuery | null = null
   if (params.cursor) {
-    const cursorRowId = ensureRecordId(params.cursor.id, TABLES.WORKSTREAM_MESSAGE)
+    const cursorRowId = ensureRecordId(params.cursor.id, TABLES.THREAD_MESSAGE)
     query = new BoundQuery(
-      `SELECT id, createdAt FROM ${TABLES.WORKSTREAM_MESSAGE}
-       WHERE workstreamId IN $workstreamIds
+      `SELECT id, createdAt FROM ${TABLES.THREAD_MESSAGE}
+       WHERE threadId IN $threadIds
          AND (
            createdAt > $cursorCreatedAt
            OR (createdAt = $cursorCreatedAt AND id > $cursorRowId)
          )
        ORDER BY createdAt ASC, id ASC
        LIMIT 1`,
-      { workstreamIds: params.workstreamIds, cursorCreatedAt: params.cursor.createdAt, cursorRowId },
+      { threadIds: params.threadIds, cursorCreatedAt: params.cursor.createdAt, cursorRowId },
     )
   } else if (params.onboardingCutoff) {
     query = new BoundQuery(
-      `SELECT id, createdAt FROM ${TABLES.WORKSTREAM_MESSAGE}
-       WHERE workstreamId IN $workstreamIds
+      `SELECT id, createdAt FROM ${TABLES.THREAD_MESSAGE}
+       WHERE threadId IN $threadIds
          AND createdAt > $onboardingCutoff
        ORDER BY createdAt ASC, id ASC
        LIMIT 1`,
-      { workstreamIds: params.workstreamIds, onboardingCutoff: params.onboardingCutoff },
+      { threadIds: params.threadIds, onboardingCutoff: params.onboardingCutoff },
     )
   }
 
@@ -160,7 +160,7 @@ export async function runRegularChatMemoryDigest(
   const workspaceProvider = getRuntimeAdapters().workspaceProvider
   if (!workspaceProvider) {
     serverLogger.info`Skipping regular chat memory digest for ${orgId}: workspaceProvider is not configured`
-    return { skipped: true, processedWorkstreamMessages: 0, processedSocialMessages: 0, followUpScheduled: false }
+    return { skipped: true, processedThreadMessages: 0, processedSocialMessages: 0, followUpScheduled: false }
   }
 
   return withConfiguredWorkspaceMemoryLock(orgId, async () => {
@@ -170,28 +170,28 @@ export async function runRegularChatMemoryDigest(
       !workspaceProvider.applyProfileProjection
     ) {
       serverLogger.info`Skipping regular chat memory digest for ${orgId}: workspaceProvider background/profile methods are incomplete`
-      return { skipped: true, processedWorkstreamMessages: 0, processedSocialMessages: 0, followUpScheduled: false }
+      return { skipped: true, processedThreadMessages: 0, processedSocialMessages: 0, followUpScheduled: false }
     }
 
     const workspace = await workspaceProvider.getWorkspace(orgRef)
     const lifecycleState = await workspaceProvider.getLifecycleState?.(workspace)
     if (lifecycleState?.bootstrapActive ?? false) {
       serverLogger.info`Skipping regular chat memory digest for ${orgId}: onboarding is not completed`
-      return { skipped: true, processedWorkstreamMessages: 0, processedSocialMessages: 0, followUpScheduled: false }
+      return { skipped: true, processedThreadMessages: 0, processedSocialMessages: 0, followUpScheduled: false }
     }
     const projectionState = await workspaceProvider.readProfileProjectionState?.(workspace)
 
-    const existingWorkstreamCursor = await workspaceProvider.getBackgroundCursor('regular-chat-digest', orgRef)
-    const workstreamOnboardingCutoff = resolveWorkspaceBootstrapCutoff({
-      hasExistingCursor: existingWorkstreamCursor !== null,
+    const existingThreadCursor = await workspaceProvider.getBackgroundCursor('regular-chat-digest', orgRef)
+    const threadOnboardingCutoff = resolveWorkspaceBootstrapCutoff({
+      hasExistingCursor: existingThreadCursor !== null,
       bootstrapCompletedAt: lifecycleState?.bootstrapCompletedAt,
     })
 
-    const workstreamIds = await listWorkstreamIdsForOrg(orgRef)
-    const workstreamMessages = await listEligibleWorkstreamMessages({
-      workstreamIds,
-      cursor: existingWorkstreamCursor,
-      onboardingCutoff: workstreamOnboardingCutoff,
+    const threadIds = await listThreadIdsForOrg(orgRef)
+    const threadMessages = await listEligibleThreadMessages({
+      threadIds,
+      cursor: existingThreadCursor,
+      onboardingCutoff: threadOnboardingCutoff,
     })
     const existingSocialCursor = await socialChatHistoryService.getBackgroundCursor('regular-chat-digest', orgId)
     const socialOnboardingCutoff = resolveWorkspaceBootstrapCutoff({
@@ -204,12 +204,12 @@ export async function runRegularChatMemoryDigest(
       onboardingCutoff: socialOnboardingCutoff,
     })
 
-    if (workstreamMessages.length === 0 && socialMessages.length === 0) {
+    if (threadMessages.length === 0 && socialMessages.length === 0) {
       serverLogger.info`Skipping regular chat memory digest for ${orgId}: no eligible messages`
-      return { skipped: true, processedWorkstreamMessages: 0, processedSocialMessages: 0, followUpScheduled: false }
+      return { skipped: true, processedThreadMessages: 0, processedSocialMessages: 0, followUpScheduled: false }
     }
 
-    const combinedMessages = [...workstreamMessages, ...socialMessages].sort(compareDigestMessageOrder)
+    const combinedMessages = [...threadMessages, ...socialMessages].sort(compareDigestMessageOrder)
     const { transcript, involvedAgentNames } = buildDigestTranscript({ messages: combinedMessages })
     const existingMemories = await loadExistingOrganizationMemories(orgId)
 
@@ -237,7 +237,7 @@ export async function runRegularChatMemoryDigest(
       throw new Error('Regular chat memory digest returned an empty summaryBlock')
     }
 
-    const processedWorkstreamCursor = getLastCursor(workstreamMessages)
+    const processedThreadCursor = getLastCursor(threadMessages)
     const processedSocialCursor = getLastCursor(socialMessages)
     const digestRunAt = new Date().toISOString()
 
@@ -248,10 +248,10 @@ export async function runRegularChatMemoryDigest(
         source: 'regular_chat_digest',
         sourceMetadata: {
           digestRunAt,
-          ...(processedWorkstreamCursor
+          ...(processedThreadCursor
             ? {
-                digestWorkstreamCursorCreatedAt: processedWorkstreamCursor.createdAt.toISOString(),
-                digestWorkstreamCursorId: processedWorkstreamCursor.id,
+                digestThreadCursorCreatedAt: processedThreadCursor.createdAt.toISOString(),
+                digestThreadCursorId: processedThreadCursor.id,
               }
             : {}),
           ...(processedSocialCursor
@@ -270,18 +270,18 @@ export async function runRegularChatMemoryDigest(
       summaryBlock,
       structuredPatch: synthesis.structuredProfilePatch,
     })
-    if (processedWorkstreamCursor) {
-      await workspaceProvider.setBackgroundCursor('regular-chat-digest', orgRef, processedWorkstreamCursor)
+    if (processedThreadCursor) {
+      await workspaceProvider.setBackgroundCursor('regular-chat-digest', orgRef, processedThreadCursor)
     }
     if (processedSocialCursor) {
       await socialChatHistoryService.setBackgroundCursor('regular-chat-digest', orgId, processedSocialCursor)
     }
 
-    const workstreamBoundaryCursor = processedWorkstreamCursor ?? existingWorkstreamCursor
-    const hasMoreWorkstreamMessages = await hasNewEligibleWorkstreamMessages({
-      workstreamIds,
-      cursor: workstreamBoundaryCursor,
-      onboardingCutoff: workstreamBoundaryCursor ? null : workstreamOnboardingCutoff,
+    const threadBoundaryCursor = processedThreadCursor ?? existingThreadCursor
+    const hasMoreThreadMessages = await hasNewEligibleThreadMessages({
+      threadIds,
+      cursor: threadBoundaryCursor,
+      onboardingCutoff: threadBoundaryCursor ? null : threadOnboardingCutoff,
     })
     const socialBoundaryCursor = processedSocialCursor ?? existingSocialCursor
     const hasMoreSocialMessages = await socialChatHistoryService.hasWorkspaceMessages({
@@ -290,17 +290,17 @@ export async function runRegularChatMemoryDigest(
       onboardingCutoff: socialBoundaryCursor ? null : socialOnboardingCutoff,
     })
 
-    const followUpScheduled = hasMoreWorkstreamMessages || hasMoreSocialMessages
+    const followUpScheduled = hasMoreThreadMessages || hasMoreSocialMessages
     if (followUpScheduled) {
       await clearRegularChatMemoryDigestDeduplicationKey(orgId)
       await enqueueRegularChatMemoryDigest({ orgId })
     }
 
-    serverLogger.info`Regular chat memory digest completed for ${orgId}: workstreamMessages=${workstreamMessages.length}, socialMessages=${socialMessages.length}, facts=${synthesis.facts.length}, followUpScheduled=${followUpScheduled}`
+    serverLogger.info`Regular chat memory digest completed for ${orgId}: threadMessages=${threadMessages.length}, socialMessages=${socialMessages.length}, facts=${synthesis.facts.length}, followUpScheduled=${followUpScheduled}`
 
     return {
       skipped: false,
-      processedWorkstreamMessages: workstreamMessages.length,
+      processedThreadMessages: threadMessages.length,
       processedSocialMessages: socialMessages.length,
       followUpScheduled,
     }

package/src/workers/skill-extraction.runner.ts

@@ -13,9 +13,9 @@ import { createSkillManagerAgent, SkillManagerOutputSchema } from '../system-age
 import { buildDigestTranscript, resolveWorkspaceBootstrapCutoff } from './regular-chat-memory-digest.helpers'
 import {
   compareDigestMessageOrder,
-  listEligibleWorkstreamMessages,
-  listWorkstreamIdsForOrg,
-} from './utils/workstream-message-query'
+  listEligibleThreadMessages,
+  listThreadIdsForOrg,
+} from './utils/thread-message-query'
 
 const SKILL_EXTRACTION_TIMEOUT_MS = 10 * 60 * 1000
 const MIN_MESSAGE_THRESHOLD = 10
@@ -107,18 +107,14 @@ export async function runSkillExtraction(data: SkillExtractionJob): Promise<Skil
       bootstrapCompletedAt: lifecycleState?.bootstrapCompletedAt,
     })
 
-    const workstreamIds = await listWorkstreamIdsForOrg(orgRef)
-    const workstreamMessages = await listEligibleWorkstreamMessages({
-      workstreamIds,
-      cursor: existingCursor,
-      onboardingCutoff,
-    })
+    const threadIds = await listThreadIdsForOrg(orgRef)
+    const threadMessages = await listEligibleThreadMessages({ threadIds, cursor: existingCursor, onboardingCutoff })
     const socialMessages = await socialChatHistoryService.listWorkspaceMessages({
       workspaceId: orgId,
       cursor: existingSocialCursor,
       onboardingCutoff: socialOnboardingCutoff,
     })
-    const messages = [...workstreamMessages, ...socialMessages]
+    const messages = [...threadMessages, ...socialMessages]
 
     if (messages.length < MIN_MESSAGE_THRESHOLD) {
       serverLogger.info`Skipping skill extraction for ${orgId}: only ${messages.length} messages (threshold: ${MIN_MESSAGE_THRESHOLD})`
@@ -241,10 +237,10 @@ export async function runSkillExtraction(data: SkillExtractionJob): Promise<Skil
       }
     }
 
-    const lastWorkstreamMessage = workstreamMessages.at(-1)
+    const lastThreadMessage = threadMessages.at(-1)
     const lastSocialMessage = socialMessages.at(-1)
-    if (lastWorkstreamMessage) {
-      await cursorAwareWorkspaceProvider.setBackgroundCursor('skill-extraction', orgRef, lastWorkstreamMessage.cursor)
+    if (lastThreadMessage) {
+      await cursorAwareWorkspaceProvider.setBackgroundCursor('skill-extraction', orgRef, lastThreadMessage.cursor)
     }
     if (lastSocialMessage) {
       await socialChatHistoryService.setBackgroundCursor('skill-extraction', orgId, lastSocialMessage.cursor)

package/src/workers/utils/{workstream-message-query.ts → thread-message-query.ts}

@@ -6,15 +6,15 @@ import { ensureRecordId, recordIdToString } from '../../db/record-id'
 import type { RecordIdRef } from '../../db/record-id'
 import { databaseService } from '../../db/service'
 import { TABLES } from '../../db/tables'
-import { WorkstreamMessageRowSchema } from '../../db/workstream-message-row'
-import type { WorkstreamMessageRow } from '../../db/workstream-message-row'
+import { ThreadMessageRowSchema } from '../../db/thread-message-row'
+import type { ThreadMessageRow } from '../../db/thread-message-row'
 import { normalizeTextBody } from '../../document/parsing'
 import type { LotaRuntimeBackgroundCursor } from '../../runtime/runtime-extensions'
 
 export type DigestCursor = LotaRuntimeBackgroundCursor
 
 export interface DigestMessage {
-  source: 'workstream' | 'social'
+  source: 'thread' | 'social'
   sourceId: string
   role: 'system' | 'user' | 'assistant'
   parts: Array<Record<string, unknown>>
@@ -22,16 +22,16 @@ export interface DigestMessage {
   cursor: DigestCursor
 }
 
-function mapWorkstreamRow(row: WorkstreamMessageRow): DigestMessage {
+function mapThreadRow(row: ThreadMessageRow): DigestMessage {
   return {
-    source: 'workstream',
-    sourceId: recordIdToString(row.workstreamId, TABLES.WORKSTREAM),
+    source: 'thread',
+    sourceId: recordIdToString(row.threadId, TABLES.THREAD),
     role: row.role,
     parts: row.parts as Array<Record<string, unknown>>,
     metadata: row.metadata ?? undefined,
     cursor: {
       createdAt: new Date(requireTimestamp(row.createdAt)),
-      id: recordIdToString(row.id, TABLES.WORKSTREAM_MESSAGE),
+      id: recordIdToString(row.id, TABLES.THREAD_MESSAGE),
     },
   }
 }
@@ -42,52 +42,52 @@ export function compareDigestMessageOrder(left: DigestMessage, right: DigestMess
   return left.cursor.id.localeCompare(right.cursor.id)
 }
 
-export async function listWorkstreamIdsForOrg(orgRef: RecordIdRef): Promise<RecordIdRef[]> {
+export async function listThreadIdsForOrg(orgRef: RecordIdRef): Promise<RecordIdRef[]> {
   const EntityIdRowSchema = z.string().trim().min(1)
   const ids = await databaseService.query<unknown>(
     new BoundQuery(
-      `SELECT VALUE type::string(id) FROM ${TABLES.WORKSTREAM}
+      `SELECT VALUE type::string(id) FROM ${TABLES.THREAD}
        WHERE organizationId = $organizationId`,
       { organizationId: orgRef },
     ),
   )
-  return ids.map((value) => ensureRecordId(EntityIdRowSchema.parse(value), TABLES.WORKSTREAM))
+  return ids.map((value) => ensureRecordId(EntityIdRowSchema.parse(value), TABLES.THREAD))
 }
 
-export async function listEligibleWorkstreamMessages(params: {
-  workstreamIds: RecordIdRef[]
+export async function listEligibleThreadMessages(params: {
+  threadIds: RecordIdRef[]
   cursor: DigestCursor | null
   onboardingCutoff: Date | null
 }): Promise<DigestMessage[]> {
-  if (params.workstreamIds.length === 0) return []
+  if (params.threadIds.length === 0) return []
 
   let query: BoundQuery | null = null
   if (params.cursor) {
-    const cursorRowId = ensureRecordId(params.cursor.id, TABLES.WORKSTREAM_MESSAGE)
+    const cursorRowId = ensureRecordId(params.cursor.id, TABLES.THREAD_MESSAGE)
     query = new BoundQuery(
-      `SELECT type::string(id) AS id, type::string(workstreamId) AS workstreamId, role, parts, metadata, createdAt FROM ${TABLES.WORKSTREAM_MESSAGE}
-       WHERE workstreamId IN $workstreamIds
+      `SELECT type::string(id) AS id, type::string(threadId) AS threadId, role, parts, metadata, createdAt FROM ${TABLES.THREAD_MESSAGE}
+       WHERE threadId IN $threadIds
          AND (
            createdAt > $cursorCreatedAt
            OR (createdAt = $cursorCreatedAt AND id > $cursorRowId)
          )
        ORDER BY createdAt ASC, id ASC`,
-      { workstreamIds: params.workstreamIds, cursorCreatedAt: params.cursor.createdAt, cursorRowId },
+      { threadIds: params.threadIds, cursorCreatedAt: params.cursor.createdAt, cursorRowId },
     )
   } else if (params.onboardingCutoff) {
     query = new BoundQuery(
-      `SELECT type::string(id) AS id, type::string(workstreamId) AS workstreamId, role, parts, metadata, createdAt FROM ${TABLES.WORKSTREAM_MESSAGE}
-       WHERE workstreamId IN $workstreamIds
+      `SELECT type::string(id) AS id, type::string(threadId) AS threadId, role, parts, metadata, createdAt FROM ${TABLES.THREAD_MESSAGE}
+       WHERE threadId IN $threadIds
          AND createdAt > $onboardingCutoff
        ORDER BY createdAt ASC, id ASC`,
-      { workstreamIds: params.workstreamIds, onboardingCutoff: params.onboardingCutoff },
+      { threadIds: params.threadIds, onboardingCutoff: params.onboardingCutoff },
     )
   }
 
   if (!query) return []
 
   const rows = await databaseService.query<unknown>(query)
-  return rows.map((row) => mapWorkstreamRow(WorkstreamMessageRowSchema.parse(row)))
+  return rows.map((row) => mapThreadRow(ThreadMessageRowSchema.parse(row)))
 }
 
 export function normalizeBlock(value: string): string {

package/infrastructure/schema/00_workstream.surql

@@ -1,64 +0,0 @@
-# Workstream table.
-DEFINE TABLE IF NOT EXISTS workstream SCHEMAFULL;
-DEFINE FIELD IF NOT EXISTS organizationId ON TABLE workstream TYPE record<organization>;
-DEFINE FIELD IF NOT EXISTS userId ON TABLE workstream TYPE record<user>;
-DEFINE FIELD IF NOT EXISTS agentId ON TABLE workstream TYPE option<string>;
-DEFINE FIELD IF NOT EXISTS mode ON TABLE workstream TYPE string DEFAULT 'group';
-DEFINE FIELD IF NOT EXISTS core ON TABLE workstream TYPE bool DEFAULT false;
-DEFINE FIELD IF NOT EXISTS coreType ON TABLE workstream TYPE option<string>;
-DEFINE FIELD IF NOT EXISTS title ON TABLE workstream TYPE option<string>;
-DEFINE FIELD IF NOT EXISTS status ON TABLE workstream TYPE string DEFAULT 'regular';
-DEFINE FIELD IF NOT EXISTS createdAt ON TABLE workstream TYPE datetime DEFAULT time::now() READONLY;
-DEFINE FIELD IF NOT EXISTS updatedAt ON TABLE workstream TYPE datetime VALUE time::now();
-DEFINE FIELD IF NOT EXISTS memoryBlock ON TABLE workstream TYPE option<string>;
-DEFINE FIELD IF NOT EXISTS memoryBlockSummary ON TABLE workstream TYPE option<string>;
-DEFINE FIELD IF NOT EXISTS activeRunId ON TABLE workstream TYPE option<string>;
-DEFINE FIELD IF NOT EXISTS activeStreamId ON TABLE workstream TYPE option<string>;
-DEFINE FIELD IF NOT EXISTS compactionSummary 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 members ON TABLE workstream TYPE option<array<string>> DEFAULT [];
-DEFINE FIELD IF NOT EXISTS turnCount ON TABLE workstream TYPE int DEFAULT 0;
-
-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
-# definition that array<object> creates — this is the only way to allow
-# arbitrary nested object shapes inside the array on SCHEMAFULL tables.
-DEFINE TABLE IF NOT EXISTS workstreamMessage SCHEMAFULL;
-DEFINE FIELD IF NOT EXISTS workstreamId ON TABLE workstreamMessage TYPE record<workstream> REFERENCE ON DELETE CASCADE;
-DEFINE FIELD IF NOT EXISTS messageId ON TABLE workstreamMessage TYPE string;
-DEFINE FIELD IF NOT EXISTS role ON TABLE workstreamMessage TYPE string;
-DEFINE FIELD IF NOT EXISTS parts ON TABLE workstreamMessage TYPE array<object> FLEXIBLE;
-DEFINE FIELD OVERWRITE parts.* ON TABLE workstreamMessage TYPE object FLEXIBLE;
-DEFINE FIELD IF NOT EXISTS metadata ON TABLE workstreamMessage TYPE option<object> FLEXIBLE;
-DEFINE FIELD IF NOT EXISTS createdAt ON TABLE workstreamMessage TYPE datetime DEFAULT time::now() READONLY;
-DEFINE FIELD IF NOT EXISTS updatedAt ON TABLE workstreamMessage TYPE datetime VALUE time::now();
-
-DEFINE INDEX IF NOT EXISTS workstreamMessageWorkstreamIdx ON TABLE workstreamMessage COLUMNS workstreamId;
-DEFINE INDEX IF NOT EXISTS workstreamMessageWorkstreamCreatedIdx ON TABLE workstreamMessage COLUMNS workstreamId, createdAt;
-DEFINE INDEX IF NOT EXISTS workstreamMessageWorkstreamMessageUniqueIdx ON TABLE workstreamMessage COLUMNS workstreamId, messageId UNIQUE;
-
-# Workstream attachments.
-DEFINE TABLE IF NOT EXISTS workstreamAttachment SCHEMAFULL;
-DEFINE FIELD IF NOT EXISTS workstreamId ON TABLE workstreamAttachment TYPE record<workstream> REFERENCE ON DELETE CASCADE;
-DEFINE FIELD IF NOT EXISTS messageId ON TABLE workstreamAttachment TYPE record<workstreamMessage> REFERENCE ON DELETE CASCADE;
-DEFINE FIELD IF NOT EXISTS attachmentType ON TABLE workstreamAttachment TYPE string;
-DEFINE FIELD IF NOT EXISTS name ON TABLE workstreamAttachment TYPE string;
-DEFINE FIELD IF NOT EXISTS contentType ON TABLE workstreamAttachment TYPE string;
-DEFINE FIELD IF NOT EXISTS storageKey ON TABLE workstreamAttachment TYPE option<string>;
-DEFINE FIELD IF NOT EXISTS sizeBytes ON TABLE workstreamAttachment TYPE option<int>;
-DEFINE FIELD IF NOT EXISTS url ON TABLE workstreamAttachment TYPE option<string>;
-DEFINE FIELD IF NOT EXISTS createdAt ON TABLE workstreamAttachment TYPE datetime DEFAULT time::now() READONLY;
-DEFINE FIELD IF NOT EXISTS updatedAt ON TABLE workstreamAttachment TYPE datetime VALUE time::now();
-
-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/src/config/workstream-defaults.ts

@@ -1,72 +0,0 @@
-export interface WorkstreamBootstrapWelcomeConfig {
-  directAgentId: string
-  buildMessageText: (params: { userName?: string | null }) => string
-}
-
-export interface LotaWorkstreamBootstrapConfig {
-  onboardingDirectAgents?: readonly string[]
-  completedDirectAgents?: readonly string[]
-  coreTypesAfterOnboarding?: readonly string[]
-  ensureDefaultGroupOnCompleted?: boolean
-  onboardingWelcome?: WorkstreamBootstrapWelcomeConfig
-}
-
-export interface LotaWorkstreamConfig {
-  bootstrap?: LotaWorkstreamBootstrapConfig
-}
-
-interface ResolvedWorkstreamBootstrapConfig {
-  onboardingDirectAgents: readonly string[]
-  completedDirectAgents: readonly string[]
-  coreTypesAfterOnboarding: readonly string[]
-  ensureDefaultGroupOnCompleted: boolean
-  onboardingWelcome?: WorkstreamBootstrapWelcomeConfig
-}
-
-const DEFAULT_WORKSTREAM_BOOTSTRAP_CONFIG: ResolvedWorkstreamBootstrapConfig = {
-  onboardingDirectAgents: [],
-  completedDirectAgents: [],
-  coreTypesAfterOnboarding: [],
-  ensureDefaultGroupOnCompleted: true,
-}
-
-let resolvedWorkstreamBootstrapConfig: ResolvedWorkstreamBootstrapConfig = DEFAULT_WORKSTREAM_BOOTSTRAP_CONFIG
-
-function withDedupedStrings(values: readonly string[]): string[] {
-  const seen = new Set<string>()
-  const deduped: string[] = []
-
-  for (const value of values) {
-    const normalized = value.trim()
-    if (!normalized || seen.has(normalized)) continue
-    seen.add(normalized)
-    deduped.push(normalized)
-  }
-
-  return deduped
-}
-
-export function configureWorkstreams(params: { agentRoster: readonly string[]; config?: LotaWorkstreamConfig }): void {
-  const bootstrap = params.config?.bootstrap
-  const onboardingWelcome = bootstrap?.onboardingWelcome
-  const onboardingDirectAgents = withDedupedStrings([
-    ...(bootstrap?.onboardingDirectAgents ?? params.agentRoster),
-    ...(onboardingWelcome ? [onboardingWelcome.directAgentId] : []),
-  ])
-
-  resolvedWorkstreamBootstrapConfig = {
-    onboardingDirectAgents,
-    completedDirectAgents: withDedupedStrings(bootstrap?.completedDirectAgents ?? params.agentRoster),
-    coreTypesAfterOnboarding: withDedupedStrings(bootstrap?.coreTypesAfterOnboarding ?? []),
-    ensureDefaultGroupOnCompleted: bootstrap?.ensureDefaultGroupOnCompleted ?? true,
-    ...(onboardingWelcome ? { onboardingWelcome } : {}),
-  }
-}
-
-export function getWorkstreamBootstrapConfig(): ResolvedWorkstreamBootstrapConfig {
-  return resolvedWorkstreamBootstrapConfig
-}
-
-export function resolveOnboardingOwnerAgentId(defaultLeadAgentId: string): string {
-  return resolvedWorkstreamBootstrapConfig.onboardingWelcome?.directAgentId ?? defaultLeadAgentId
-}

package/src/services/workstream-plan-registry.service.ts

@@ -1,22 +0,0 @@
-import type { PlanRunRecord, SerializableExecutionPlan } from '@lota-sdk/shared'
-
-import type { RecordIdInput } from '../db/record-id'
-import { planRunService } from './plan-run.service'
-
-class WorkstreamPlanRegistryService {
-  async listActiveRuns(workstreamId: RecordIdInput): Promise<PlanRunRecord[]> {
-    return planRunService.getActiveRunRecords(workstreamId)
-  }
-
-  async countActiveRuns(workstreamId: RecordIdInput): Promise<number> {
-    const runs = await this.listActiveRuns(workstreamId)
-    return runs.length
-  }
-
-  async listActivePlans(workstreamId: RecordIdInput): Promise<SerializableExecutionPlan[]> {
-    const runs = await this.listActiveRuns(workstreamId)
-    return Promise.all(runs.map((run) => planRunService.toSerializablePlan(run)))
-  }
-}
-
-export const workstreamPlanRegistryService = new WorkstreamPlanRegistryService()

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

@@ -1,42 +0,0 @@
-import { WORKSTREAM } from '@lota-sdk/shared'
-
-import { chatLogger } from '../config/logger'
-import type { RecordIdRef } from '../db/record-id'
-import { createHelperModelRuntime } from '../runtime/helper-model'
-import { deriveTitle, limitTitleWords, normalizeTitle } from '../runtime/title-helpers'
-import {
-  createWorkstreamTitleGeneratorAgent,
-  WORKSTREAM_TITLE_GENERATOR_PROMPT,
-} from '../system-agents/title-generator.agent'
-import { workstreamService } from './workstream.service'
-
-const WORKSTREAM_TITLE_TIMEOUT_MS = 30_000
-
-class WorkstreamTitleService {
-  helperRuntime = createHelperModelRuntime()
-
-  async generateAndPersistTitle(workstreamId: RecordIdRef, sourceText: string): Promise<void> {
-    let title = ''
-    try {
-      title = normalizeTitle(
-        await this.helperRuntime.generateHelperText({
-          tag: 'workstream-title',
-          createAgent: createWorkstreamTitleGeneratorAgent,
-          defaultSystemPrompt: WORKSTREAM_TITLE_GENERATOR_PROMPT,
-          timeoutMs: WORKSTREAM_TITLE_TIMEOUT_MS,
-          messages: [{ role: 'user', content: sourceText }],
-        }),
-      )
-    } catch (error) {
-      chatLogger.warn`Failed to generate workstream title via LLM (non-fatal): ${error}`
-    }
-
-    if (!title) {
-      title = limitTitleWords(deriveTitle(sourceText || WORKSTREAM.DEFAULT_TITLE))
-    }
-
-    await workstreamService.update(workstreamId, { title, nameGenerated: true })
-  }
-}
-
-export const workstreamTitleService = new WorkstreamTitleService()