@lota-sdk/core 0.2.2 → 0.3.0

package/src/services/workstream.service.ts

@@ -1,803 +0,0 @@
-import { WORKSTREAM, sdkWorkstreamStatusSchema } from '@lota-sdk/shared'
-import { BoundQuery, RecordId, StringRecordId, surql } from 'surrealdb'
-
-import { agentDisplayNames, agentRoster, getCoreWorkstreamProfile, isAgentName } from '../config/agent-defaults'
-import { serverLogger } from '../config/logger'
-import { getWorkstreamBootstrapConfig } from '../config/workstream-defaults'
-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 type { DatabaseTable } from '../db/tables'
-import { TABLES } from '../db/tables'
-import { getRedisConnection, withRedisLeaseLock } from '../redis'
-import {
-  appendToMemoryBlock,
-  compactMemoryBlockEntries,
-  formatPersistedMemoryBlockForPrompt,
-  parseMemoryBlock,
-  serializeMemoryBlock,
-} from '../runtime/memory-block'
-import { toIsoDateTimeString } from '../utils/date-time'
-import { chatRunRegistry } from './chat-run-registry.service'
-import { contextCompactionService } from './context-compaction.service'
-import { MEMORY_BLOCK_COMPACTION_CHUNK_ENTRIES, MEMORY_BLOCK_COMPACTION_TRIGGER_ENTRIES } from './workstream-constants'
-import { workstreamMessageService } from './workstream-message.service'
-import { NormalizedWorkstreamSchema, PublicWorkstreamSchema, WorkstreamSchema } from './workstream.types'
-import type { NormalizedWorkstream, PublicWorkstream, WorkstreamRecord } from './workstream.types'
-
-// Uses SurrealQL directly to keep pagination/order logic close to queries.
-
-const WORKSTREAM_ACTIVE_RUN_LOCK_TTL_MS = 90_000
-const WORKSTREAM_ACTIVE_RUN_LOCK_MAX_WAIT_MS = 750
-const WORKSTREAM_ACTIVE_RUN_LOCK_RETRY_DELAY_MS = 75
-
-function toSafeDirectIdSegment(value: string): string {
-  return value.replace(/[^a-zA-Z0-9_-]/g, '_')
-}
-
-function toRecordIdValueString(value: RecordIdRef, fallbackTable: string): string {
-  const canonical = recordIdToString(ensureRecordId(value, fallbackTable), fallbackTable)
-  const prefix = `${fallbackTable}:`
-  const withoutTable = canonical.startsWith(prefix) ? canonical.slice(prefix.length) : canonical
-  const wrappedMatch = withoutTable.match(/^⟨(.+)⟩$/)
-  return wrappedMatch ? wrappedMatch[1] : withoutTable
-}
-
-function isRecordIdInput(value: unknown): value is RecordIdInput {
-  if (typeof value === 'string' || value instanceof RecordId || value instanceof StringRecordId) {
-    return true
-  }
-
-  if (!value || typeof value !== 'object') {
-    return false
-  }
-
-  const record = value as { tb?: unknown; id?: unknown }
-  return typeof record.tb === 'string' && record.id !== undefined
-}
-
-function getAgentDisplayName(agentId: string): string {
-  return agentDisplayNames[agentId] ?? agentId
-}
-
-function requireDirectAgentId(agentId: string | undefined): string {
-  if (!agentId) {
-    throw new Error('Direct workstreams require an agentId')
-  }
-
-  return agentId
-}
-
-function requireString(coreType: string | undefined): string {
-  if (!coreType) {
-    throw new Error('Core workstreams require a coreType')
-  }
-
-  return coreType
-}
-
-function buildActiveRunLockKey(workstreamId: RecordIdRef): string {
-  return `workstream-active-run:${recordIdToString(ensureRecordId(workstreamId, TABLES.WORKSTREAM), TABLES.WORKSTREAM)}`
-}
-
-function buildListWorkstreamsQuery(options: { includeArchived: boolean; paginate: boolean }): string {
-  const clauses = [
-    `SELECT * FROM ${TABLES.WORKSTREAM}`,
-    'WHERE userId = $userId',
-    '  AND organizationId = $orgId',
-    '  AND mode = $mode',
-    '  AND core = $core',
-  ]
-  if (!options.includeArchived) {
-    clauses.push('  AND status = "regular"')
-  }
-  clauses.push('ORDER BY updatedAt DESC')
-  if (options.paginate) {
-    clauses.push('LIMIT $limit START $offset')
-  }
-  return clauses.join('\n')
-}
-
-function normalizeActiveTurnValue(value: unknown): string | null {
-  if (typeof value !== 'string') {
-    return null
-  }
-
-  const normalized = value.trim()
-  return normalized.length > 0 ? normalized : null
-}
-
-export class ActiveWorkstreamRunConflictError extends Error {
-  constructor() {
-    super('A chat run is already active.')
-    this.name = 'ActiveWorkstreamRunConflictError'
-  }
-}
-
-function buildDirectWorkstreamId({
-  userId,
-  orgId,
-  agentId,
-}: {
-  userId: RecordIdRef
-  orgId: RecordIdRef
-  agentId: string
-}): RecordId {
-  const userValue = toSafeDirectIdSegment(toRecordIdValueString(userId, TABLES.USER))
-  const orgValue = toSafeDirectIdSegment(toRecordIdValueString(orgId, TABLES.ORGANIZATION))
-  return new RecordId(TABLES.WORKSTREAM, `direct_${agentId}_user_${userValue}_organization_${orgValue}`)
-}
-
-function buildCoreWorkstreamId({
-  userId,
-  orgId,
-  coreType,
-}: {
-  userId: RecordIdRef
-  orgId: RecordIdRef
-  coreType: string
-}): RecordId {
-  const userValue = toSafeDirectIdSegment(toRecordIdValueString(userId, TABLES.USER))
-  const orgValue = toSafeDirectIdSegment(toRecordIdValueString(orgId, TABLES.ORGANIZATION))
-  const typeValue = toSafeDirectIdSegment(coreType)
-  return new RecordId(TABLES.WORKSTREAM, `core_${typeValue}_user_${userValue}_organization_${orgValue}`)
-}
-
-class WorkstreamService extends BaseService<typeof WorkstreamSchema> {
-  constructor() {
-    super(TABLES.WORKSTREAM, WorkstreamSchema)
-  }
-
-  async createWorkstream(
-    userId: RecordIdRef,
-    orgId: RecordIdRef,
-    options?: {
-      title?: string
-      mode?: string
-      agentId?: string
-      core?: boolean
-      coreType?: string
-      members?: string[]
-    },
-  ): Promise<NormalizedWorkstream> {
-    const mode = options?.mode ?? 'group'
-    const directAgentId = options?.agentId
-    const core = options?.core === true
-    const coreType = options?.coreType
-
-    if (mode === 'direct' && !directAgentId) {
-      throw new Error('Direct workstreams require an agentId')
-    }
-    if (mode === 'group' && directAgentId) {
-      throw new Error('Group workstreams cannot set agentId')
-    }
-    if (mode === 'direct' && core) {
-      throw new Error('Direct workstreams cannot be core workstreams')
-    }
-    if (core && mode !== 'group') {
-      throw new Error('Core workstreams must use group mode')
-    }
-    if (core && !coreType) {
-      throw new Error('Core workstreams require a coreType')
-    }
-    if (!core && coreType) {
-      throw new Error('Only core workstreams can set a coreType')
-    }
-    const title = (() => {
-      if (options?.title) {
-        return options.title
-      }
-      if (core) {
-        return getCoreWorkstreamProfile(requireString(coreType)).config.title
-      }
-      if (mode === 'direct') {
-        return getAgentDisplayName(requireDirectAgentId(directAgentId))
-      }
-      return WORKSTREAM.DEFAULT_TITLE
-    })()
-
-    if (mode === 'direct') {
-      const agentId = requireDirectAgentId(directAgentId)
-      const directWorkstreamId = buildDirectWorkstreamId({ userId, orgId, agentId })
-      const workstream = await this.upsertDeterministicWorkstream(directWorkstreamId, {
-        userId,
-        organizationId: orgId,
-        mode,
-        core: false,
-        agentId,
-        members: [agentId],
-        title,
-        status: 'regular',
-        nameGenerated: true,
-      })
-      return await this.toNormalizedWorkstream(workstream)
-    }
-
-    if (core) {
-      const resolvedCoreType = requireString(coreType)
-      const coreProfile = getCoreWorkstreamProfile(resolvedCoreType)
-      const coreWorkstreamId = buildCoreWorkstreamId({ userId, orgId, coreType: resolvedCoreType })
-      const workstream = await this.upsertDeterministicWorkstream(coreWorkstreamId, {
-        userId,
-        organizationId: orgId,
-        mode,
-        core: true,
-        coreType: resolvedCoreType,
-        agentId: coreProfile.config.agentId,
-        members: [...coreProfile.members],
-        title,
-        status: 'regular',
-        nameGenerated: true,
-      })
-      return await this.toNormalizedWorkstream(workstream)
-    }
-
-    const groupWorkstream = await this.create({
-      userId,
-      organizationId: orgId,
-      mode,
-      core: false,
-      members: options?.members ?? [...agentRoster],
-      title,
-      status: 'regular',
-      nameGenerated: options?.title !== undefined && options.title !== WORKSTREAM.DEFAULT_TITLE,
-    })
-
-    return await this.toNormalizedWorkstream(groupWorkstream)
-  }
-
-  async ensureBootstrapWorkstreams(
-    userId: RecordIdRef,
-    orgId: RecordIdRef,
-    options?: { onboardStatus?: string; userName?: string | null },
-  ): Promise<void> {
-    const onboardStatus = options?.onboardStatus ?? 'completed'
-    const onboardingCompleted = onboardStatus === 'completed'
-    const bootstrapConfig = getWorkstreamBootstrapConfig()
-
-    const existingWorkstreams = await databaseService.findMany(
-      TABLES.WORKSTREAM,
-      { userId, organizationId: orgId },
-      WorkstreamSchema,
-    )
-
-    const hasStandardGroupWorkstream = existingWorkstreams.some(
-      (workstream) => workstream.mode === 'group' && !workstream.core,
-    )
-    const directWorkstreamsByAgent = new Map<string, WorkstreamRecord>()
-    const coreWorkstreamsByType = new Map<string, WorkstreamRecord>()
-    for (const workstream of existingWorkstreams) {
-      if (workstream.mode !== 'direct' || !workstream.agentId) continue
-      directWorkstreamsByAgent.set(workstream.agentId, workstream)
-    }
-    for (const workstream of existingWorkstreams) {
-      if (workstream.mode !== 'group' || !workstream.core) continue
-      if (typeof workstream.coreType !== 'string') continue
-      coreWorkstreamsByType.set(workstream.coreType, workstream)
-    }
-
-    const requiredDirectAgents = onboardingCompleted
-      ? bootstrapConfig.completedDirectAgents
-      : bootstrapConfig.onboardingDirectAgents
-    const creations: Promise<NormalizedWorkstream>[] = []
-    for (const agentId of requiredDirectAgents) {
-      if (directWorkstreamsByAgent.has(agentId)) continue
-      creations.push(
-        this.createWorkstream(userId, orgId, { mode: 'direct', agentId, title: getAgentDisplayName(agentId) }),
-      )
-    }
-
-    if (onboardingCompleted && bootstrapConfig.ensureDefaultGroupOnCompleted && !hasStandardGroupWorkstream) {
-      creations.push(
-        this.createWorkstream(userId, orgId, { mode: 'group', core: false, title: WORKSTREAM.DEFAULT_TITLE }),
-      )
-    }
-
-    if (onboardingCompleted) {
-      for (const coreType of bootstrapConfig.coreTypesAfterOnboarding) {
-        if (coreWorkstreamsByType.has(coreType)) continue
-        creations.push(
-          this.createWorkstream(userId, orgId, {
-            mode: 'group',
-            core: true,
-            coreType,
-            title: getCoreWorkstreamProfile(coreType).config.title,
-          }),
-        )
-      }
-    }
-
-    let createdWorkstreams: NormalizedWorkstream[] = []
-    if (creations.length > 0) {
-      createdWorkstreams = await Promise.all(creations)
-    }
-
-    const onboardingWelcome = bootstrapConfig.onboardingWelcome
-    if (!onboardingCompleted && onboardingWelcome) {
-      const createdOnboardingOwnerWorkstream = createdWorkstreams.find(
-        (workstream) => workstream.mode === 'direct' && workstream.agentId === onboardingWelcome.directAgentId,
-      )
-      const existingOnboardingOwnerWorkstream = directWorkstreamsByAgent.get(onboardingWelcome.directAgentId)
-
-      const onboardingOwnerWorkstreamId =
-        createdOnboardingOwnerWorkstream?.id ??
-        (existingOnboardingOwnerWorkstream ? this.normalizeWorkstreamId(existingOnboardingOwnerWorkstream.id) : null)
-
-      if (onboardingOwnerWorkstreamId) {
-        const onboardingOwnerWorkstreamRef = ensureRecordId(onboardingOwnerWorkstreamId, TABLES.WORKSTREAM)
-        await workstreamMessageService.ensureBootstrapWelcomeMessage({
-          workstreamId: onboardingOwnerWorkstreamRef,
-          agentId: onboardingWelcome.directAgentId,
-          text: onboardingWelcome.buildMessageText({ userName: options?.userName }),
-        })
-      }
-    }
-  }
-
-  async listWorkstreams(
-    userId: RecordIdRef,
-    orgId: RecordIdRef,
-    options: { mode: string; core?: boolean; take?: number; page?: number; includeArchived?: boolean },
-  ): Promise<{ workstreams: NormalizedWorkstream[]; hasMore: boolean }> {
-    const core = options.core === true
-    const includeArchived = options.includeArchived ?? false
-    if (options.mode === 'direct' && core) {
-      throw new Error('Direct workstreams cannot be queried as core workstreams')
-    }
-
-    if (options.mode === 'direct' || core) {
-      const workstreams = await databaseService.queryMany<typeof WorkstreamSchema>(
-        new BoundQuery(buildListWorkstreamsQuery({ includeArchived, paginate: false }), {
-          userId,
-          orgId,
-          mode: options.mode,
-          core,
-        }),
-        WorkstreamSchema,
-      )
-
-      return { workstreams: await this.toNormalizedWorkstreams(workstreams, { checkLease: false }), hasMore: false }
-    }
-
-    const take = options.take ?? WORKSTREAM.DEFAULT_PAGE_LIMIT
-    const page = options.page ?? 1
-    const workstreams = await databaseService.queryMany<typeof WorkstreamSchema>(
-      new BoundQuery(buildListWorkstreamsQuery({ includeArchived, paginate: true }), {
-        userId,
-        orgId,
-        mode: options.mode,
-        core: false,
-        limit: take + 1,
-        offset: (page - 1) * take,
-      }),
-      WorkstreamSchema,
-    )
-
-    const hasMore = workstreams.length > take
-    const sliced = hasMore ? workstreams.slice(0, take) : workstreams
-
-    return { workstreams: await this.toNormalizedWorkstreams(sliced, { checkLease: false }), 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 await this.toNormalizedWorkstreams(workstreams, { checkLease: false })
-  }
-
-  async getWorkstream(workstreamId: RecordIdRef): Promise<NormalizedWorkstream> {
-    const workstream = await this.getById(workstreamId)
-    return await this.toNormalizedWorkstream(workstream)
-  }
-
-  async updateTitle(workstreamId: RecordIdRef, title: string): Promise<NormalizedWorkstream> {
-    const existing = await this.getById(workstreamId)
-    this.assertMutableWorkstream(existing, 'rename')
-    const workstream = await this.update(workstreamId, { title, nameGenerated: true })
-    return await this.toNormalizedWorkstream(workstream)
-  }
-
-  async updateStatus(workstreamId: RecordIdRef, status: string): Promise<NormalizedWorkstream> {
-    const validStatus = sdkWorkstreamStatusSchema.parse(status)
-    const existing = await this.getById(workstreamId)
-    this.assertMutableWorkstream(existing, validStatus === 'archived' ? 'archive' : 'unarchive')
-    const workstream = await this.update(workstreamId, { status: validStatus })
-    return await this.toNormalizedWorkstream(workstream)
-  }
-
-  async setActiveTurn(workstreamId: RecordIdRef, runId: string, streamId?: string | null): Promise<void> {
-    const workstreamRef = ensureRecordId(workstreamId, TABLES.WORKSTREAM)
-    if (streamId === null || streamId === undefined) {
-      await databaseService.query<unknown>(surql`
-        UPDATE ONLY ${workstreamRef}
-        SET activeRunId = ${runId},
-            activeStreamId = NONE
-      `)
-      return
-    }
-
-    await databaseService.query<unknown>(surql`
-      UPDATE ONLY ${workstreamRef}
-      SET activeRunId = ${runId},
-          activeStreamId = ${streamId}
-    `)
-  }
-
-  async getActiveTurn(workstreamId: RecordIdRef): Promise<{ runId: string | null; streamId: string | null }> {
-    const workstream = await this.getById(workstreamId)
-    return {
-      runId: normalizeActiveTurnValue(workstream.activeRunId),
-      streamId: normalizeActiveTurnValue(workstream.activeStreamId),
-    }
-  }
-
-  async getActiveRunId(workstreamId: RecordIdRef): Promise<string | null> {
-    const { runId } = await this.getActiveTurn(workstreamId)
-    return runId
-  }
-
-  async hasActiveRunLease(workstreamId: RecordIdRef): Promise<boolean> {
-    const count = await getRedisConnection().exists(buildActiveRunLockKey(workstreamId))
-    return count > 0
-  }
-
-  async withActiveRunLease<T>(workstreamId: RecordIdRef, fn: (signal: AbortSignal) => Promise<T>): Promise<T> {
-    try {
-      return await withRedisLeaseLock(
-        {
-          redis: getRedisConnection(),
-          lockKey: buildActiveRunLockKey(workstreamId),
-          lockTtlMs: WORKSTREAM_ACTIVE_RUN_LOCK_TTL_MS,
-          retryDelayMs: WORKSTREAM_ACTIVE_RUN_LOCK_RETRY_DELAY_MS,
-          maxWaitMs: WORKSTREAM_ACTIVE_RUN_LOCK_MAX_WAIT_MS,
-          label: 'workstream active run',
-          logger: serverLogger,
-        },
-        fn,
-      )
-    } catch (error) {
-      if (error instanceof Error && error.message.startsWith('Timed out waiting for workstream active run')) {
-        throw new ActiveWorkstreamRunConflictError()
-      }
-      throw error
-    }
-  }
-
-  async getActiveStreamId(workstreamId: RecordIdRef): Promise<string | null> {
-    const { streamId } = await this.getActiveTurn(workstreamId)
-    return streamId
-  }
-
-  async clearActiveTurn(workstreamId: RecordIdRef, params: { runId: string; streamId?: string | null }): Promise<void> {
-    const workstreamRef = ensureRecordId(workstreamId, TABLES.WORKSTREAM)
-    const currentStreamId = params.streamId ?? null
-    if (currentStreamId === null) {
-      await databaseService.query(
-        surql`UPDATE ONLY ${workstreamRef} SET activeRunId = NONE, activeStreamId = NONE WHERE activeRunId = ${params.runId}`,
-      )
-      return
-    }
-
-    await databaseService.query(surql`
-      UPDATE ONLY ${workstreamRef}
-      SET activeRunId = NONE,
-          activeStreamId = NONE
-      WHERE activeRunId = ${params.runId} AND activeStreamId = ${currentStreamId}
-    `)
-  }
-
-  async clearStaleActiveRunIfMissingFromRegistry(workstreamId: RecordIdRef): Promise<boolean> {
-    const { runId: activeRunId, streamId: activeStreamId } = await this.getActiveTurn(workstreamId)
-    if (!activeRunId || (await this.hasActiveRunLease(workstreamId))) {
-      return false
-    }
-
-    await this.clearActiveTurn(workstreamId, { runId: activeRunId, streamId: activeStreamId })
-
-    serverLogger.warn`Cleared stale workstream run after lease expired: workstream=${recordIdToString(ensureRecordId(workstreamId, TABLES.WORKSTREAM), TABLES.WORKSTREAM)} run=${activeRunId}`
-    return true
-  }
-
-  async stopActiveRun(workstreamId: RecordIdRef): Promise<boolean> {
-    const { runId: activeRunId } = await this.getActiveTurn(workstreamId)
-    if (!activeRunId) return false
-
-    const stopped = chatRunRegistry.stop(activeRunId, new DOMException('Run stopped by user.', 'AbortError'))
-    if (stopped) {
-      return true
-    }
-
-    await this.clearStaleActiveRunIfMissingFromRegistry(workstreamId)
-    return false
-  }
-
-  async setCompacting(workstreamId: RecordIdRef, value: boolean): Promise<void> {
-    const workstreamRef = ensureRecordId(workstreamId, TABLES.WORKSTREAM)
-    await databaseService.query<unknown>(surql`
-      UPDATE ONLY ${workstreamRef}
-      SET isCompacting = ${value}
-    `)
-  }
-
-  async appendMemoryBlock(workstreamId: RecordIdRef, entry: string): Promise<string> {
-    const workstreamRef = ensureRecordId(workstreamId, TABLES.WORKSTREAM)
-    const workstream = await this.getById(workstreamRef)
-    const entries = parseMemoryBlock(workstream.memoryBlock)
-
-    const labelMatch = entry.match(/^(\w+):\s*/i)
-    const role = labelMatch ? labelMatch[1].toLowerCase() : 'system'
-    const content = labelMatch ? entry.slice(labelMatch[0].length).trim() : entry.trim()
-
-    const updatedEntries = appendToMemoryBlock(entries, role, content)
-    const serialized = serializeMemoryBlock(updatedEntries)
-
-    await this.update(workstreamRef, { memoryBlock: serialized })
-
-    if (updatedEntries.length >= MEMORY_BLOCK_COMPACTION_TRIGGER_ENTRIES) {
-      void this.compactMemoryBlock(workstreamRef).catch((err: unknown) => {
-        serverLogger.warn`Memory block compaction failed for ${workstreamRef}: ${err}`
-      })
-    }
-
-    return this.formatMemoryBlockForPrompt({
-      memoryBlock: serialized,
-      memoryBlockSummary: workstream.memoryBlockSummary,
-    })
-  }
-
-  async compactMemoryBlock(workstreamId: RecordIdRef): Promise<boolean> {
-    const workstreamRef = ensureRecordId(workstreamId, TABLES.WORKSTREAM)
-    const workstream = await this.getById(workstreamRef)
-    const result = await compactMemoryBlockEntries({
-      previousSummary: workstream.memoryBlockSummary,
-      entries: parseMemoryBlock(workstream.memoryBlock),
-      triggerEntries: MEMORY_BLOCK_COMPACTION_TRIGGER_ENTRIES,
-      chunkEntries: MEMORY_BLOCK_COMPACTION_CHUNK_ENTRIES,
-      compact: (params) => contextCompactionService.compactMemoryBlock(params),
-    })
-
-    if (!result.compacted) return false
-
-    await this.update(workstreamRef, {
-      memoryBlockSummary: result.summary || '',
-      memoryBlock: serializeMemoryBlock(result.entries),
-    })
-
-    return true
-  }
-
-  async deleteWorkstream(workstreamId: RecordIdRef): Promise<void> {
-    const existing = await this.getById(workstreamId)
-    this.assertMutableWorkstream(existing, 'delete')
-    await this.delete(workstreamId)
-  }
-
-  async listRecentWorkstreams({
-    userId,
-    orgId,
-    excludeWorkstreamId,
-    limit,
-  }: {
-    userId: RecordIdRef
-    orgId: RecordIdRef
-    excludeWorkstreamId?: RecordIdRef
-    limit: number
-  }): Promise<NormalizedWorkstream[]> {
-    let excludeCondition = ''
-    const vars: Record<string, unknown> = { userId, orgId, limit }
-
-    if (excludeWorkstreamId) {
-      excludeCondition = 'AND id != $excludeWorkstreamId'
-      vars.excludeWorkstreamId = excludeWorkstreamId
-    }
-
-    const workstreams = await databaseService.queryMany<typeof WorkstreamSchema>(
-      new BoundQuery(
-        `SELECT * FROM ${TABLES.WORKSTREAM}
-	       WHERE userId = $userId
-	         AND organizationId = $orgId
-	         ${excludeCondition}
-	         AND status != "archived"
-	       ORDER BY updatedAt DESC
-	       LIMIT $limit`,
-        vars,
-      ),
-      WorkstreamSchema,
-    )
-
-    return await this.toNormalizedWorkstreams(workstreams, { checkLease: false })
-  }
-
-  private normalizeWorkstreamId(id: unknown): string {
-    return this.normalizeRecordIdString(id, TABLES.WORKSTREAM)
-  }
-
-  private normalizeRecordIdString(id: unknown, table: DatabaseTable): string {
-    if (!isRecordIdInput(id)) {
-      throw new Error(`Invalid record id for table ${table}`)
-    }
-
-    return recordIdToString(id, table)
-  }
-
-  formatMemoryBlockForPrompt(workstream: Pick<WorkstreamRecord, 'memoryBlock' | 'memoryBlockSummary'>): string {
-    return formatPersistedMemoryBlockForPrompt({
-      summary: workstream.memoryBlockSummary,
-      entries: parseMemoryBlock(workstream.memoryBlock),
-    })
-  }
-
-  private getDefaultTitle(workstream: Pick<WorkstreamRecord, 'core' | 'coreType'>): string {
-    if (workstream.core && typeof workstream.coreType === 'string') {
-      return getCoreWorkstreamProfile(workstream.coreType).config.title
-    }
-
-    return WORKSTREAM.DEFAULT_TITLE
-  }
-
-  private async computeIsRunning(
-    workstream: Pick<WorkstreamRecord, 'id' | 'activeRunId'>,
-    options: { checkLease: boolean },
-  ): Promise<boolean> {
-    const activeRunId =
-      typeof workstream.activeRunId === 'string' && workstream.activeRunId.trim().length > 0
-        ? workstream.activeRunId
-        : null
-
-    if (activeRunId === null) {
-      return false
-    }
-
-    if (chatRunRegistry.has(activeRunId)) {
-      return true
-    }
-
-    if (!options.checkLease) {
-      return true
-    }
-
-    return await this.hasActiveRunLease(ensureRecordId(workstream.id, TABLES.WORKSTREAM))
-  }
-
-  private async toNormalizedWorkstream(
-    workstream: WorkstreamRecord,
-    options: { checkLease?: boolean } = {},
-  ): Promise<NormalizedWorkstream> {
-    const isRunning = await this.computeIsRunning(workstream, { checkLease: options.checkLease ?? true })
-    const isCompacting = workstream.isCompacting === true
-    const mode = workstream.mode
-    const core = workstream.core
-    const coreType = core && typeof workstream.coreType === 'string' ? workstream.coreType : undefined
-    const status = workstream.status
-    return NormalizedWorkstreamSchema.parse({
-      id: this.normalizeWorkstreamId(workstream.id),
-      userId: this.normalizeRecordIdString(workstream.userId, TABLES.USER),
-      organizationId: this.normalizeRecordIdString(workstream.organizationId, TABLES.ORGANIZATION),
-      mode,
-      core,
-      ...(coreType ? { coreType } : {}),
-      nameGenerated: workstream.nameGenerated,
-      isRunning,
-      isCompacting,
-      ...(isAgentName(workstream.agentId) ? { agentId: workstream.agentId } : {}),
-      title: workstream.title ?? this.getDefaultTitle(workstream),
-      status,
-      memoryBlock: this.formatMemoryBlockForPrompt(workstream),
-      createdAt: toIsoDateTimeString(workstream.createdAt),
-      updatedAt: toIsoDateTimeString(workstream.updatedAt),
-    })
-  }
-
-  private async toNormalizedWorkstreams(
-    workstreams: WorkstreamRecord[],
-    options: { checkLease?: boolean } = {},
-  ): Promise<NormalizedWorkstream[]> {
-    return await Promise.all(
-      workstreams.map(async (workstream) => await this.toNormalizedWorkstream(workstream, options)),
-    )
-  }
-
-  toPublicWorkstream(workstream: NormalizedWorkstream): PublicWorkstream {
-    const {
-      organizationId: _organizationId,
-      userId: _userId,
-      memoryBlock: _memoryBlock,
-      ...publicWorkstream
-    } = workstream
-    return PublicWorkstreamSchema.parse(publicWorkstream)
-  }
-
-  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
-  }
-
-  private assertMutableWorkstream(
-    workstream: WorkstreamRecord,
-    action: 'rename' | 'archive' | 'unarchive' | 'delete',
-  ): void {
-    if (workstream.mode === 'direct') {
-      throw new Error(`Direct workstreams cannot be ${action}d`)
-    }
-    if (workstream.core) {
-      throw new Error(`Core workstreams cannot be ${action}d`)
-    }
-  }
-
-  private async upsertDeterministicWorkstream(
-    workstreamId: RecordIdRef,
-    data: Record<string, unknown>,
-  ): Promise<WorkstreamRecord> {
-    const workstreamRef = ensureRecordId(workstreamId, TABLES.WORKSTREAM)
-    const existing = await this.findById(workstreamRef)
-    if (existing) {
-      return existing
-    }
-
-    let createError: unknown = null
-    let workstream = await databaseService
-      .createWithId(TABLES.WORKSTREAM, workstreamRef, data, WorkstreamSchema)
-      .catch((error) => {
-        createError = error
-        return null
-      })
-
-    if (!workstream) {
-      workstream = await this.findById(workstreamRef)
-    }
-
-    if (workstream) {
-      return workstream
-    }
-
-    if (createError instanceof Error) {
-      throw createError
-    }
-
-    throw new Error('Failed to create or load deterministic workstream')
-  }
-}
-
-export const workstreamService = new WorkstreamService()