@lota-sdk/core 0.1.5 → 0.1.7

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

@@ -24,10 +24,12 @@ import type { RecordIdRef } from '../db/record-id'
 import { recordIdToString } from '../db/record-id'
 import { TABLES } from '../db/tables'
 import { enqueueContextCompaction } from '../queues/context-compaction.queue'
+import { enqueueMemoryConsolidation } from '../queues/memory-consolidation.queue'
 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,
@@ -43,6 +45,8 @@ import { CONTEXT_SIZE } from '../runtime/context-compaction-constants'
 import { createExecutionPlanInstructionSectionCache } from '../runtime/execution-plan'
 import { mergeInstructionSections } from '../runtime/instruction-sections'
 import {
+  shouldEnqueueMemoryConsolidation,
+  shouldEnqueueMemoryExtraction,
   shouldEnqueueOnboardingPostChatMemory,
   shouldEnqueueRegularDigestForWorkstream,
 } from '../runtime/memory-digest-policy'
@@ -445,6 +449,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)
@@ -1196,6 +1214,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
             }
 
             if (allAssistantMessages.length > 0 && shouldProcessPostRunSideEffects) {
+              const turnCount = await workstreamService.incrementTurnCount(workstreamRef)
               const agentMessages = buildAgentHistoryMessages(allAssistantMessages)
               const historyMessagesForMemory = appendCompactionContextToHistoryMessages(
                 toHistoryMessages(recentHistory),
@@ -1206,14 +1225,16 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
               const readableUploads = listReadableUploads()
               const attachmentMetadataContext = buildReadableUploadMetadataContext(readableUploads)
               const hasAttachmentContext = Boolean(attachmentMetadataContext)
-              if (
-                shouldEnqueueOnboardingPostChatMemory({
-                  onboardingActive,
-                  userMessageText,
-                  hasAttachmentContext,
-                  agentMessageCount: agentMessages.length,
-                })
-              ) {
+              const shouldExtractMemory = onboardingActive
+                ? shouldEnqueueOnboardingPostChatMemory({
+                    onboardingActive,
+                    userMessageText,
+                    hasAttachmentContext,
+                    agentMessageCount: agentMessages.length,
+                  })
+                : shouldEnqueueMemoryExtraction({ onboardingActive, turnCount }) && userMessageText.length > 0
+
+              if (shouldExtractMemory) {
                 const memoryUserMessage = userMessageText || 'User uploaded attachment(s).'
                 await safeEnqueue(
                   () =>
@@ -1300,17 +1321,23 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
                 }
               }
 
-              if (shouldEnqueueRegularDigestForWorkstream({ onboardingActive })) {
+              if (shouldEnqueueRegularDigestForWorkstream({ onboardingActive, turnCount })) {
                 await safeEnqueue(() => enqueueRegularChatMemoryDigest({ orgId: orgIdString }), {
                   operationName: 'regular chat memory digest enqueue',
                 })
               }
 
-              if (shouldEnqueueSkillExtraction({ onboardingActive })) {
+              if (shouldEnqueueSkillExtraction({ onboardingActive, turnCount })) {
                 await safeEnqueue(() => enqueueSkillExtraction({ orgId: orgIdString }), {
                   operationName: 'skill extraction enqueue',
                 })
               }
+
+              if (shouldEnqueueMemoryConsolidation({ onboardingActive, turnCount })) {
+                await safeEnqueue(() => enqueueMemoryConsolidation({ scopeId: orgIdString }), {
+                  operationName: 'memory consolidation enqueue',
+                })
+              }
             }
 
             if (allAssistantMessages.length > 0) {

package/src/services/workstream-turn.ts

@@ -2,10 +2,12 @@ import type { ChatMessage } from '@lota-sdk/shared/schemas/chat-message'
 import { createUIMessageStream } from 'ai'
 
 import { hasApprovalRespondedParts, isApprovalContinuationRequest } from '../runtime/approval-continuation'
+import { wrapResponseWithKeepalive } from '../utils/sse-keepalive'
 import { prepareWorkstreamRunCore } from './workstream-turn-preparation'
 import type { WorkstreamTurnParams, WorkstreamApprovalContinuationParams } from './workstream-turn-preparation'
 
 export { hasApprovalRespondedParts, isApprovalContinuationRequest }
+export { wrapResponseWithKeepalive }
 
 export async function createWorkstreamApprovalContinuationStream(params: WorkstreamApprovalContinuationParams) {
   const prepared = await prepareWorkstreamRunCore({ ...params, kind: 'approvalContinuation' })

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,
         )
@@ -567,6 +568,48 @@ class WorkstreamService extends BaseService<typeof WorkstreamSchema> {
     return { workstreams: sliced.map((workstream) => this.normalizeWorkstream(workstream)), hasMore }
   }
 
+  async listOrganizationWorkstreams(params: {
+    orgId: RecordIdRef
+    mode?: 'direct' | 'group'
+    agentId?: string
+    core?: boolean
+    includeArchived?: boolean
+  }): Promise<NormalizedWorkstream[]> {
+    const whereClauses = ['organizationId = $orgId']
+    const variables: Record<string, unknown> = { orgId: params.orgId }
+
+    if (params.mode) {
+      whereClauses.push('mode = $mode')
+      variables.mode = params.mode
+    }
+
+    if (typeof params.core === 'boolean') {
+      whereClauses.push('core = $core')
+      variables.core = params.core
+    }
+
+    if (params.agentId) {
+      whereClauses.push('agentId = $agentId')
+      variables.agentId = params.agentId
+    }
+
+    if (params.includeArchived !== true) {
+      whereClauses.push('status = "regular"')
+    }
+
+    const workstreams = await databaseService.queryMany<typeof WorkstreamSchema>(
+      new BoundQuery(
+        `SELECT * FROM ${TABLES.WORKSTREAM}
+         WHERE ${whereClauses.join('\n           AND ')}
+         ORDER BY createdAt ASC, id ASC`,
+        variables,
+      ),
+      WorkstreamSchema,
+    )
+
+    return workstreams.map((workstream) => this.normalizeWorkstream(workstream))
+  }
+
   async getWorkstream(workstreamId: RecordIdRef): Promise<NormalizedWorkstream> {
     const workstream = await this.getById(workstreamId)
     return this.normalizeWorkstream(workstream)
@@ -781,6 +824,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 +851,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 +860,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 +884,20 @@ class WorkstreamService extends BaseService<typeof WorkstreamSchema> {
     return { ...publicWorkstream, workstreamState }
   }
 
+  async incrementTurnCount(workstreamId: RecordIdRef): Promise<number> {
+    const workstreamRef = ensureRecordId(workstreamId, TABLES.WORKSTREAM)
+    const result = await databaseService.query<{ turnCount: number }>(surql`
+      UPDATE ONLY ${workstreamRef}
+      SET turnCount += 1
+      RETURN turnCount
+    `)
+    return result[0]?.turnCount ?? 0
+  }
+
+  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,8 +108,10 @@ 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(),
+  turnCount: z.number().int().optional().default(0),
   createdAt: z.coerce.date(),
   updatedAt: z.coerce.date(),
   userId: z.any(), // RecordId

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/tools/research-topic.tool.ts

@@ -1,5 +1,8 @@
 import { bifrostChatModel } from '../bifrost/bifrost'
-import { OPENROUTER_WEB_RESEARCH_MODEL_ID } from '../config/model-constants'
+import {
+  OPENROUTER_MEDIUM_REASONING_PROVIDER_OPTIONS,
+  OPENROUTER_WEB_RESEARCH_MODEL_ID,
+} from '../config/model-constants'
 import { createDelegatedAgentTool } from '../system-agents/delegated-agent-factory'
 import { RESEARCHER_PROMPT } from '../system-agents/researcher.agent'
 import { fetchWebpageTool } from './fetch-webpage.tool'
@@ -10,6 +13,7 @@ export const researchTopicTool = createDelegatedAgentTool({
   description:
     'Delegate a research task to a dedicated research agent that searches the web, fetches pages, and returns a synthesized markdown report. Call multiple instances in parallel for broad research across different topics.',
   model: bifrostChatModel(OPENROUTER_WEB_RESEARCH_MODEL_ID),
+  providerOptions: OPENROUTER_MEDIUM_REASONING_PROVIDER_OPTIONS,
   instructions: RESEARCHER_PROMPT,
   tools: { searchWeb: searchWebTool.create(), fetchWebpage: fetchWebpageTool.create() },
 })