@lota-sdk/core 0.2.3 → 0.3.0

package/src/services/plan-run-data.ts

@@ -1,4 +1,4 @@
-import type { ExecutionPlanToolResultData, PlanRunRecord } from '@lota-sdk/shared'
+import type { ExecutionPlanToolResultData, PlanRunRecord, SerializableExecutionPlan } from '@lota-sdk/shared'
 
 import type { RecordIdInput } from '../db/record-id'
 import { ensureRecordId } from '../db/record-id'
@@ -21,7 +21,7 @@ export function toRunData(run: PlanRunRecord, patch: PlanRunUpdate) {
   return {
     planSpecId: ensureRecordId(run.planSpecId, TABLES.PLAN_SPEC),
     organizationId: ensureRecordId(run.organizationId, TABLES.ORGANIZATION),
-    workstreamId: ensureRecordId(run.workstreamId, TABLES.WORKSTREAM),
+    threadId: ensureRecordId(run.threadId, TABLES.THREAD),
     leadAgentId: patch.leadAgentId ?? run.leadAgentId,
     status: patch.status ?? run.status,
     ...(patch.currentNodeId === null
@@ -71,18 +71,37 @@ export function toRunData(run: PlanRunRecord, patch: PlanRunUpdate) {
   }
 }
 
+function toSlimPlanSummary(plan: SerializableExecutionPlan): NonNullable<ExecutionPlanToolResultData['plan']> {
+  const completed = plan.progress.completed + plan.progress.partial
+  return {
+    runId: plan.runId,
+    title: plan.title,
+    objective: plan.objective,
+    status: plan.status,
+    progress: { completed, total: plan.progress.total },
+    nodes: plan.nodes.map((node) => ({
+      id: node.id,
+      label: node.label,
+      type: node.type,
+      status: node.status,
+      ownerRef: node.owner.ref,
+    })),
+    activeNodeIds: plan.activeNodeIds,
+    readyNodeIds: plan.readyNodeIds,
+  }
+}
+
 export function buildExecutionPlanToolResult(params: {
   action: ExecutionPlanToolResultData['action']
-  plan: ExecutionPlanToolResultData['plan'] | null
+  plan: SerializableExecutionPlan | null
   message: string
-  changedNodeId?: string
 }): ExecutionPlanToolResultData {
+  const slim = params.plan ? toSlimPlanSummary(params.plan) : null
   return {
     action: params.action,
     message: params.message,
-    ...(params.changedNodeId ? { changedNodeId: params.changedNodeId } : {}),
-    ...(params.plan ? { plan: params.plan } : {}),
-    hasPlan: params.plan !== null,
-    status: params.plan?.status,
+    ...(slim ? { plan: slim } : {}),
+    hasPlan: slim !== null,
+    status: slim?.status,
   }
 }

package/src/services/plan-run.service.ts

@@ -168,10 +168,10 @@ class PlanRunService {
     return spec
   }
 
-  async listPlanSpecsByWorkstream(workstreamId: RecordIdInput): Promise<PlanSpecRecord[]> {
+  async listPlanSpecsByThread(threadId: RecordIdInput): Promise<PlanSpecRecord[]> {
     return databaseService.findMany(
       TABLES.PLAN_SPEC,
-      { workstreamId: ensureRecordId(workstreamId, TABLES.WORKSTREAM) },
+      { threadId: ensureRecordId(threadId, TABLES.THREAD) },
       PlanSpecSchema,
       { orderBy: 'createdAt', orderDir: 'DESC' },
     )
@@ -219,15 +219,15 @@ class PlanRunService {
     return run
   }
 
-  async getActiveRunRecord(workstreamId: RecordIdInput): Promise<PlanRunRecord | null> {
-    const runs = await this.getActiveRunRecords(workstreamId)
+  async getActiveRunRecord(threadId: RecordIdInput): Promise<PlanRunRecord | null> {
+    const runs = await this.getActiveRunRecords(threadId)
     return runs[0] ?? null
   }
 
-  async getActiveRunRecords(workstreamId: RecordIdInput): Promise<PlanRunRecord[]> {
+  async getActiveRunRecords(threadId: RecordIdInput): Promise<PlanRunRecord[]> {
     const runs = await databaseService.findMany(
       TABLES.PLAN_RUN,
-      { workstreamId: ensureRecordId(workstreamId, TABLES.WORKSTREAM) },
+      { threadId: ensureRecordId(threadId, TABLES.THREAD) },
       PlanRunSchema,
       { orderBy: 'updatedAt', orderDir: 'DESC' },
     )
@@ -379,7 +379,6 @@ class PlanRunService {
           status: nodeRun.status,
           upstreamNodeIds: [...nodeSpec.upstreamNodeIds],
           downstreamNodeIds: [...nodeSpec.downstreamNodeIds],
-          ...(nodeRun.handoffContext ? { handoffContext: nodeRun.handoffContext } : {}),
           ...(nodeRun.completedAt ? { completedAt: toOptionalIsoDateTimeString(nodeRun.completedAt) } : {}),
         } as SerializablePlanNode
       }
@@ -418,7 +417,6 @@ class PlanRunService {
         resolvedInput: nodeRun.resolvedInput,
         latestStructuredOutput: nodeRun.latestStructuredOutput,
         latestNotes: nodeRun.latestNotes,
-        handoffContext: nodeRun.handoffContext,
         blockedReason: nodeRun.blockedReason,
         failureClass: nodeRun.failureClass,
         upstreamNodeIds: [...nodeSpec.upstreamNodeIds],
@@ -432,7 +430,7 @@ class PlanRunService {
     return {
       specId: recordIdToString(spec.id, TABLES.PLAN_SPEC),
       runId: recordIdToString(run.id, TABLES.PLAN_RUN),
-      workstreamId: recordIdToString(run.workstreamId, TABLES.WORKSTREAM),
+      threadId: recordIdToString(run.threadId, TABLES.THREAD),
       organizationId: recordIdToString(run.organizationId, TABLES.ORGANIZATION),
       title: spec.title,
       objective: spec.objective,

package/src/services/plan-scheduler.service.ts

@@ -41,7 +41,7 @@ class PlanSchedulerService {
 
   async createSchedule(params: {
     organizationId: RecordIdInput
-    workstreamId: RecordIdInput
+    threadId: RecordIdInput
     planSpecId?: RecordIdInput
     runId?: RecordIdInput
     nodeId?: string
@@ -54,7 +54,7 @@ class PlanSchedulerService {
       TABLES.PLAN_SCHEDULE,
       {
         organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
-        workstreamId: ensureRecordId(params.workstreamId, TABLES.WORKSTREAM),
+        threadId: ensureRecordId(params.threadId, TABLES.THREAD),
         planSpecId: params.planSpecId ? ensureRecordId(params.planSpecId, TABLES.PLAN_SPEC) : undefined,
         runId: params.runId ? ensureRecordId(params.runId, TABLES.PLAN_RUN) : undefined,
         nodeId: params.nodeId,
@@ -227,10 +227,10 @@ class PlanSchedulerService {
     }
   }
 
-  async listSchedules(workstreamId: RecordIdInput): Promise<PlanScheduleRecord[]> {
+  async listSchedules(threadId: RecordIdInput): Promise<PlanScheduleRecord[]> {
     return databaseService.findMany(
       TABLES.PLAN_SCHEDULE,
-      { workstreamId: ensureRecordId(workstreamId, TABLES.WORKSTREAM) },
+      { threadId: ensureRecordId(threadId, TABLES.THREAD) },
       PlanScheduleRecordSchema,
       { orderBy: 'createdAt', orderDir: 'ASC' },
     )

package/src/services/plan-template.service.ts

@@ -87,7 +87,7 @@ class PlanTemplateService {
   async instantiate(params: {
     templateId: RecordIdInput
     organizationId: RecordIdInput
-    workstreamId: RecordIdInput
+    threadId: RecordIdInput
     leadAgentId: string
     overrides?: Partial<PlanDraft>
     carryForwardArtifacts?: PlanArtifactRecord[]
@@ -106,7 +106,7 @@ class PlanTemplateService {
 
     return executionPlanService.createPlan({
       organizationId: params.organizationId,
-      workstreamId: params.workstreamId,
+      threadId: params.threadId,
       leadAgentId: params.leadAgentId,
       input: draft,
     })

package/src/services/plan-validator.service.ts

@@ -582,16 +582,6 @@ class PlanValidatorService {
       }
 
       if (deliverable.schemaRef) {
-        if (artifact.schemaRef !== deliverable.schemaRef) {
-          blocking.push(
-            createIssue({
-              code: 'artifact_schema_mismatch',
-              message: `Artifact "${deliverable.name}" must declare schemaRef "${deliverable.schemaRef}".`,
-              nodeId: params.node.id,
-            }),
-          )
-        }
-
         const artifactSchema = resolveSchemaRef(params.draft, deliverable.schemaRef)
         if (!artifact.payload) {
           blocking.push(
@@ -658,7 +648,6 @@ class PlanValidatorService {
     if (check.type === 'schema') {
       const schemaRef =
         (typeof check.config.schemaRef === 'string' ? check.config.schemaRef : undefined) ??
-        artifact?.schemaRef ??
         (artifactName ? node.deliverables.find((candidate) => candidate.name === artifactName)?.schemaRef : undefined)
       if (!schemaRef) {
         return createIssue({

package/src/services/plugin-executor.service.ts

@@ -20,7 +20,7 @@ function buildPluginExecutionParams(params: {
     inputs: params.resolvedInput,
     context: {
       organizationId: params.context.organizationId,
-      workstreamId: params.context.workstreamId,
+      threadId: params.context.threadId,
       planId: params.context.planId,
       nodeId: params.context.nodeId,
       ...(params.context.userId ? { userId: params.context.userId } : {}),

package/src/services/queue-job.service.ts

@@ -141,7 +141,7 @@ function extractJobContext(data: unknown): Record<string, unknown> | undefined {
 
   const context = compactRecord({
     organizationId: readStringField(record, 'organizationId') ?? readStringField(record, 'orgId'),
-    workstreamId: readStringField(record, 'workstreamId'),
+    threadId: readStringField(record, 'threadId'),
     userId: readStringField(record, 'userId'),
     agentId: readStringField(record, 'agentId'),
     sourceId: readStringField(record, 'sourceId'),

package/src/services/recent-activity-title.service.ts

@@ -18,7 +18,7 @@ function buildRefinementPromptInput(
     `sourceLabel=${candidate.sourceLabel}`,
     `systemTitle=${candidate.systemTitle}`,
     metadata.agentName ? `agentName=${metadata.agentName}` : null,
-    metadata.workstreamTitle ? `workstreamTitle=${metadata.workstreamTitle}` : null,
+    metadata.threadTitle ? `threadTitle=${metadata.threadTitle}` : null,
     metadata.userMessageText ? `userMessage=${metadata.userMessageText}` : null,
     metadata.assistantSummary ? `assistantSummary=${metadata.assistantSummary}` : null,
   ].filter((line): line is string => Boolean(line))

package/src/services/recent-activity.service.ts

@@ -79,9 +79,9 @@ function shouldKeepExistingAgentTitle(existing: RecentActivityRow | null): boole
 function buildRecentActivityAreaKey(
   row: Pick<RecentActivityRow, 'targetKind' | 'targetId' | 'kind' | 'mergeKey' | 'metadata'>,
 ): string {
-  const workstreamId = row.metadata?.workstreamId
-  if (workstreamId) {
-    return `workstream:${compactWhitespace(workstreamId)}`
+  const threadId = row.metadata?.threadId
+  if (threadId) {
+    return `thread:${compactWhitespace(threadId)}`
   }
 
   if (row.targetId) {
@@ -373,7 +373,7 @@ class RecentActivityService {
       'chat',
       'agent task',
       'recent activity',
-      'workstream update',
+      'thread update',
     ])
 
     return !bannedTitles.has(normalizedCandidate)

package/src/services/system-executor.service.ts

@@ -8,7 +8,7 @@ const BUILT_IN_SYSTEM_EXECUTORS = Object.freeze({
   'plan-runtime': {
     supportedOperations: ['echo-input'],
     async executeNode(params: PluginNodeExecutionParams): Promise<PlanNodeResult> {
-      return { structuredOutput: structuredClone(params.inputs), artifacts: [] }
+      return { notes: 'System echo-input completed.', structuredOutput: structuredClone(params.inputs), artifacts: [] }
     },
   } satisfies SystemNodeExecutor,
 })
@@ -36,7 +36,7 @@ function buildSystemExecutionParams(params: {
     inputs: params.resolvedInput,
     context: {
       organizationId: params.context.organizationId,
-      workstreamId: params.context.workstreamId,
+      threadId: params.context.threadId,
       planId: params.context.planId,
       nodeId: params.context.nodeId,
       ...(params.context.userId ? { userId: params.context.userId } : {}),

package/src/services/{workstream-message.service.ts → thread-message.service.ts}

@@ -10,54 +10,54 @@ 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'
 
-const WorkstreamMessageExistingRowSchema = z.object({ id: recordIdSchema, createdAt: z.coerce.date() })
+const ThreadMessageExistingRowSchema = z.object({ id: recordIdSchema, createdAt: z.coerce.date() })
 
 function toMessageId(value: string | RecordIdRef): string {
-  return recordIdToString(value, TABLES.WORKSTREAM_MESSAGE)
+  return recordIdToString(value, TABLES.THREAD_MESSAGE)
 }
 
 /**
- * Builds a collision-free row id by hashing the workstream + message id pair.
+ * Builds a collision-free row id by hashing the thread + message id pair.
  * Previous implementation replaced non-alphanumeric chars with '_', which was
  * lossy (e.g. "msg:foo" and "msg_foo" mapped to the same row id).
  * Now uses a 32-char SHA-256 hex prefix -- short enough for ergonomic ids,
  * long enough (128 bits) to make collisions negligible.
  */
-function toWorkstreamMessageRowId(workstreamId: RecordIdRef, messageId: string): RecordId {
-  const workstreamStr = recordIdToString(workstreamId, TABLES.WORKSTREAM)
-  const digest = new Bun.CryptoHasher('sha256').update(`${workstreamStr}\0${messageId}`).digest('hex').slice(0, 32)
-  return new RecordId(TABLES.WORKSTREAM_MESSAGE, digest)
+function toThreadMessageRowId(threadId: RecordIdRef, messageId: string): RecordId {
+  const threadStr = recordIdToString(threadId, TABLES.THREAD)
+  const digest = new Bun.CryptoHasher('sha256').update(`${threadStr}\0${messageId}`).digest('hex').slice(0, 32)
+  return new RecordId(TABLES.THREAD_MESSAGE, digest)
 }
 
-function toWorkstreamRef(workstreamId: RecordIdRef): RecordId {
-  return ensureRecordId(workstreamId, TABLES.WORKSTREAM)
+function toThreadRef(threadId: RecordIdRef): RecordId {
+  return ensureRecordId(threadId, TABLES.THREAD)
 }
 
-function toChatMessage(row: WorkstreamMessageRow): ChatMessage {
+function toChatMessage(row: ThreadMessageRow): ChatMessage {
   const rowCreatedAt = requireTimestamp(row.createdAt)
   const metadata = withCreatedAtMetadata(parseRowMetadata(row.metadata), rowCreatedAt)
 
   return { id: row.messageId, role: row.role, parts: row.parts as ChatMessage['parts'], metadata }
 }
 
-const workstreamPaginationConfig: CursorPaginationConfig = {
-  table: TABLES.WORKSTREAM_MESSAGE,
-  parentFilterField: 'workstreamId',
-  toRowId: toWorkstreamMessageRowId,
-  parseRow: (row: unknown) => WorkstreamMessageRowSchema.parse(row),
-  toMessage: (row: unknown) => toChatMessage(WorkstreamMessageRowSchema.parse(row)),
+const threadPaginationConfig: CursorPaginationConfig = {
+  table: TABLES.THREAD_MESSAGE,
+  parentFilterField: 'threadId',
+  toRowId: toThreadMessageRowId,
+  parseRow: (row: unknown) => ThreadMessageRowSchema.parse(row),
+  toMessage: (row: unknown) => toChatMessage(ThreadMessageRowSchema.parse(row)),
   queryLatest: (parentId, limit) => surql`
-    SELECT * FROM workstreamMessage
-    WHERE workstreamId = ${parentId}
+    SELECT * FROM threadMessage
+    WHERE threadId = ${parentId}
     ORDER BY createdAt DESC, id DESC
     LIMIT ${limit}
   `,
   queryBefore: (parentId, cursorCreatedAt, cursorId, limit) => surql`
-    SELECT * FROM workstreamMessage
-    WHERE workstreamId = ${parentId}
+    SELECT * FROM threadMessage
+    WHERE threadId = ${parentId}
       AND (
         createdAt < ${cursorCreatedAt}
         OR (createdAt = ${cursorCreatedAt} AND id < ${cursorId})
@@ -67,9 +67,9 @@ const workstreamPaginationConfig: CursorPaginationConfig = {
   `,
 }
 
-class WorkstreamMessageService {
-  async upsertMessages(params: { workstreamId: RecordIdRef; messages: ChatMessage[] }): Promise<void> {
-    const workstreamId = toWorkstreamRef(params.workstreamId)
+class ThreadMessageService {
+  async upsertMessages(params: { threadId: RecordIdRef; messages: ChatMessage[] }): Promise<void> {
+    const threadId = toThreadRef(params.threadId)
 
     const upsertPromises = params.messages.map(async (message) => {
       const messageId = message.id.trim()
@@ -81,82 +81,82 @@ class WorkstreamMessageService {
         : []
       if (parts.length === 0) {
         if (role === 'assistant') return
-        throw new Error(`Refusing to persist workstream message "${messageId}" with empty parts`)
+        throw new Error(`Refusing to persist thread message "${messageId}" with empty parts`)
       }
-      const rowId = toWorkstreamMessageRowId(workstreamId, messageId)
+      const rowId = toThreadMessageRowId(threadId, messageId)
       const existingRow = await databaseService.findOne(
-        TABLES.WORKSTREAM_MESSAGE,
-        { workstreamId, messageId },
-        WorkstreamMessageExistingRowSchema,
+        TABLES.THREAD_MESSAGE,
+        { threadId, messageId },
+        ThreadMessageExistingRowSchema,
       )
       const persistedCreatedAt =
         existingRow === null ? requireTimestamp(message.metadata?.createdAt) : requireTimestamp(existingRow.createdAt)
       const metadata = withCreatedAtMetadata({ ...message.metadata, createdAt: persistedCreatedAt })
 
       await databaseService.upsert(
-        TABLES.WORKSTREAM_MESSAGE,
+        TABLES.THREAD_MESSAGE,
         rowId,
         {
-          workstreamId,
+          threadId,
           messageId,
           role,
           parts,
           metadata,
           createdAt: existingRow ? existingRow.createdAt : new Date(persistedCreatedAt),
         },
-        WorkstreamMessageRowSchema,
+        ThreadMessageRowSchema,
         { mutation: 'content' },
       )
     })
     await Promise.all(upsertPromises)
   }
 
-  async listMessages(workstreamId: RecordIdRef): Promise<ChatMessage[]> {
-    const workstreamRef = toWorkstreamRef(workstreamId)
+  async listMessages(threadId: RecordIdRef): Promise<ChatMessage[]> {
+    const threadRef = toThreadRef(threadId)
     const rows = await databaseService.query<unknown>(surql`
-      SELECT * FROM workstreamMessage
-      WHERE workstreamId = ${workstreamRef}
+      SELECT * FROM threadMessage
+      WHERE threadId = ${threadRef}
       ORDER BY createdAt ASC, id ASC
     `)
 
-    return rows.map((row) => WorkstreamMessageRowSchema.parse(row)).map((row) => toChatMessage(row))
+    return rows.map((row) => ThreadMessageRowSchema.parse(row)).map((row) => toChatMessage(row))
   }
 
   async listMessageHistoryPage(params: {
-    workstreamId: RecordIdRef
+    threadId: RecordIdRef
     take: number
     beforeMessageId?: string
   }): Promise<MessageHistoryPage> {
-    const workstreamRef = toWorkstreamRef(params.workstreamId)
-    return listMessageHistoryPage(workstreamPaginationConfig, {
-      parentId: workstreamRef,
+    const threadRef = toThreadRef(params.threadId)
+    return listMessageHistoryPage(threadPaginationConfig, {
+      parentId: threadRef,
       take: params.take,
       beforeMessageId: params.beforeMessageId,
     })
   }
 
-  async listMessagesAfterCursor(workstreamId: RecordIdRef, afterMessageId?: string): Promise<ChatMessage[]> {
-    const workstreamRef = toWorkstreamRef(workstreamId)
+  async listMessagesAfterCursor(threadId: RecordIdRef, afterMessageId?: string): Promise<ChatMessage[]> {
+    const threadRef = toThreadRef(threadId)
     const cursorMessageId = afterMessageId?.trim()
     if (!cursorMessageId) {
-      return this.listMessages(workstreamRef)
+      return this.listMessages(threadRef)
     }
 
     const cursorRow = await databaseService.findOne(
-      TABLES.WORKSTREAM_MESSAGE,
-      { workstreamId: workstreamRef, messageId: cursorMessageId },
+      TABLES.THREAD_MESSAGE,
+      { threadId: threadRef, messageId: cursorMessageId },
       CursorRowSchema,
     )
 
     if (!cursorRow) {
-      throw new Error(`Workstream cursor message not found: ${cursorMessageId}`)
+      throw new Error(`Thread cursor message not found: ${cursorMessageId}`)
     }
 
     const cursorCreatedAt = cursorRow.createdAt
-    const cursorId = toWorkstreamMessageRowId(workstreamRef, cursorMessageId)
+    const cursorId = toThreadMessageRowId(threadRef, cursorMessageId)
     const rows = await databaseService.query<unknown>(surql`
-      SELECT * FROM workstreamMessage
-      WHERE workstreamId = ${workstreamRef}
+      SELECT * FROM threadMessage
+      WHERE threadId = ${threadRef}
         AND (
           createdAt > ${cursorCreatedAt}
           OR (createdAt = ${cursorCreatedAt} AND id > ${cursorId})
@@ -164,26 +164,26 @@ class WorkstreamMessageService {
       ORDER BY createdAt ASC, id ASC
     `)
 
-    return rows.map((row) => WorkstreamMessageRowSchema.parse(row)).map((row) => toChatMessage(row))
+    return rows.map((row) => ThreadMessageRowSchema.parse(row)).map((row) => toChatMessage(row))
   }
 
-  async listRecentMessages(workstreamId: RecordIdRef, limit: number): Promise<ChatMessage[]> {
-    const workstreamRef = toWorkstreamRef(workstreamId)
+  async listRecentMessages(threadId: RecordIdRef, limit: number): Promise<ChatMessage[]> {
+    const threadRef = toThreadRef(threadId)
     const rows = await databaseService.query<unknown>(surql`
-      SELECT * FROM workstreamMessage
-      WHERE workstreamId = ${workstreamRef}
+      SELECT * FROM threadMessage
+      WHERE threadId = ${threadRef}
       ORDER BY createdAt DESC, id DESC
       LIMIT ${Math.max(1, limit)}
     `)
 
     return rows
-      .map((row) => WorkstreamMessageRowSchema.parse(row))
+      .map((row) => ThreadMessageRowSchema.parse(row))
       .reverse()
       .map((row) => toChatMessage(row))
   }
 
   async searchMessages(params: {
-    workstreamId: RecordIdRef
+    threadId: RecordIdRef
     role: 'user' | 'assistant'
     query: string
     limit: number
@@ -191,7 +191,7 @@ class WorkstreamMessageService {
     const normalizedQuery = params.query.trim().toLowerCase()
     if (!normalizedQuery) return []
 
-    const messages = await this.listMessages(toWorkstreamRef(params.workstreamId))
+    const messages = await this.listMessages(toThreadRef(params.threadId))
     return messages
       .filter((message) => message.role === params.role)
       .map((message) => ({
@@ -209,10 +209,10 @@ class WorkstreamMessageService {
 
   async addUserMessage(params: {
     messageId: RecordIdRef
-    workstreamId: RecordIdRef
+    threadId: RecordIdRef
     content: string
   }): Promise<ChatMessage> {
-    const workstreamRef = toWorkstreamRef(params.workstreamId)
+    const threadRef = toThreadRef(params.threadId)
     const message: ChatMessage = {
       id: toMessageId(params.messageId),
       role: 'user',
@@ -220,17 +220,17 @@ class WorkstreamMessageService {
       metadata: { createdAt: Date.now() },
     }
 
-    await this.upsertMessages({ workstreamId: workstreamRef, messages: [message] })
+    await this.upsertMessages({ threadId: threadRef, messages: [message] })
     return message
   }
 
   async addAgentMessage(params: {
     messageId: RecordIdRef
-    workstreamId: RecordIdRef
+    threadId: RecordIdRef
     parts: ChatMessage['parts']
     metadata?: ChatMessage['metadata']
   }): Promise<ChatMessage> {
-    const workstreamRef = toWorkstreamRef(params.workstreamId)
+    const threadRef = toThreadRef(params.threadId)
     const message: ChatMessage = {
       id: toMessageId(params.messageId),
       role: 'assistant',
@@ -238,20 +238,16 @@ class WorkstreamMessageService {
       metadata: withCreatedAtMetadata(params.metadata, Date.now()),
     }
 
-    await this.upsertMessages({ workstreamId: workstreamRef, messages: [message] })
+    await this.upsertMessages({ threadId: threadRef, messages: [message] })
     return message
   }
 
-  async ensureBootstrapWelcomeMessage(params: {
-    workstreamId: RecordIdRef
-    agentId: string
-    text: string
-  }): Promise<void> {
-    const workstreamRef = toWorkstreamRef(params.workstreamId)
+  async ensureBootstrapWelcomeMessage(params: { threadId: RecordIdRef; agentId: string; text: string }): Promise<void> {
+    const threadRef = toThreadRef(params.threadId)
     const existingRow = await databaseService.findOne(
-      TABLES.WORKSTREAM_MESSAGE,
-      { workstreamId: workstreamRef },
-      WorkstreamMessageExistingRowSchema,
+      TABLES.THREAD_MESSAGE,
+      { threadId: threadRef },
+      ThreadMessageExistingRowSchema,
     )
     if (existingRow) return
 
@@ -259,7 +255,7 @@ class WorkstreamMessageService {
     if (!messageText) return
 
     await this.upsertMessages({
-      workstreamId: workstreamRef,
+      threadId: threadRef,
       messages: [
         {
           id: Bun.randomUUIDv7(),
@@ -276,4 +272,4 @@ class WorkstreamMessageService {
   }
 }
 
-export const workstreamMessageService = new WorkstreamMessageService()
+export const threadMessageService = new ThreadMessageService()

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

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

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

@@ -0,0 +1,39 @@
+import { THREAD } 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 { createThreadTitleGeneratorAgent, THREAD_TITLE_GENERATOR_PROMPT } from '../system-agents/title-generator.agent'
+import { threadService } from './thread.service'
+
+const THREAD_TITLE_TIMEOUT_MS = 30_000
+
+class ThreadTitleService {
+  helperRuntime = createHelperModelRuntime()
+
+  async generateAndPersistTitle(threadId: RecordIdRef, sourceText: string): Promise<void> {
+    let title = ''
+    try {
+      title = normalizeTitle(
+        await this.helperRuntime.generateHelperText({
+          tag: 'thread-title',
+          createAgent: createThreadTitleGeneratorAgent,
+          defaultSystemPrompt: THREAD_TITLE_GENERATOR_PROMPT,
+          timeoutMs: THREAD_TITLE_TIMEOUT_MS,
+          messages: [{ role: 'user', content: sourceText }],
+        }),
+      )
+    } catch (error) {
+      chatLogger.warn`Failed to generate thread title via LLM (non-fatal): ${error}`
+    }
+
+    if (!title) {
+      title = limitTitleWords(deriveTitle(sourceText || THREAD.DEFAULT_TITLE))
+    }
+
+    await threadService.update(threadId, { title, nameGenerated: true })
+  }
+}
+
+export const threadTitleService = new ThreadTitleService()