@lota-sdk/core 0.2.3 → 0.3.1

package/src/services/thread.types.ts

@@ -0,0 +1,17 @@
+import { sdkPublicThreadSchema, sdkThreadRecordSchema, sdkThreadSchema } from '@lota-sdk/shared'
+import type { SdkPublicThread, SdkThreadRecord } from '@lota-sdk/shared'
+import { z } from 'zod'
+
+export const ThreadSchema = sdkThreadRecordSchema
+export type ThreadRecord = SdkThreadRecord
+
+export const NormalizedThreadSchema = sdkThreadSchema.extend({
+  agentId: z.string().optional(),
+  threadType: z.string().optional(),
+  memoryBlock: z.string(),
+})
+
+export type NormalizedThread = z.infer<typeof NormalizedThreadSchema>
+export type PublicThread = SdkPublicThread
+
+export { sdkPublicThreadSchema as PublicThreadSchema }

package/src/storage/attachment-storage.service.ts

@@ -26,7 +26,7 @@ import {
 
 const READ_FILE_PARTS_PAGES_PER_PART = 25
 
-export type UploadedWorkstreamAttachment = {
+export type UploadedThreadAttachment = {
   filename: string
   mediaType: string
   sizeBytes: number
@@ -86,7 +86,7 @@ export class AttachmentStorageService {
     orgId: string
     namespace: string
     relativePath: string
-  }): Promise<UploadedWorkstreamAttachment> {
+  }): Promise<UploadedThreadAttachment> {
     const filename = file.name || 'document'
     const mediaType = file.type || inferContentType(filename)
     const storageKey = buildOrganizationDocumentStorageKey({
@@ -107,7 +107,7 @@ export class AttachmentStorageService {
     }
   }
 
-  async uploadWorkstreamAttachment({
+  async uploadThreadAttachment({
     file,
     orgId,
     userId,
@@ -115,7 +115,7 @@ export class AttachmentStorageService {
     file: File
     orgId: string
     userId: string
-  }): Promise<UploadedWorkstreamAttachment> {
+  }): Promise<UploadedThreadAttachment> {
     const filename = file.name || 'attachment'
     const mediaType = file.type || inferContentType(filename)
     const sizeBytes = file.size

package/src/system-agents/index.ts

@@ -10,4 +10,4 @@ export * from './researcher.agent'
 export * from './skill-extractor.agent'
 export * from './skill-manager.agent'
 export * from './title-generator.agent'
-export * from './workstream-router.agent'
+export * from './thread-router.agent'

package/src/system-agents/memory.agent.ts

@@ -40,7 +40,7 @@ Extract organization-relevant facts from the conversation.
 - User personal preferences
 - Transient requests
 - General knowledge questions
-- Temporary discussion workstreams
+- Temporary discussion threads
 </ignore>
 
 <format>

package/src/system-agents/recent-activity-title-refiner.agent.ts

@@ -27,7 +27,7 @@ Turn recent activity context into a short label that helps the user quickly reco
 - Prefer concrete task language over generic labels.
 - Mention the agent only when it adds useful context.
 - Focus on what the user was trying to accomplish.
-- Avoid generic phrases like "Chat", "Conversation", "Recent activity", "Task", or "Workstream update".
+- Avoid generic phrases like "Chat", "Conversation", "Recent activity", "Task", or "Thread update".
 - Avoid punctuation at the end.
 - Do not invent details that are not present in the input.
 - If the input is too weak for improvement, return the current system title.
@@ -58,7 +58,7 @@ Turn recent activity context into a short label that helps the user quickly reco
 - Prefer concrete task language over generic labels.
 - Mention the agent only when it adds useful context.
 - Focus on what the user was trying to accomplish.
-- Avoid generic phrases like "Chat", "Conversation", "Recent activity", "Task", or "Workstream update".
+- Avoid generic phrases like "Chat", "Conversation", "Recent activity", "Task", or "Thread update".
 - Avoid punctuation at the end.
 - Do not invent details that are not present in the input.
 - If the input is too weak for improvement, return the current system title.

package/src/system-agents/regular-chat-memory-digest.agent.ts

@@ -16,7 +16,7 @@ Synthesize an updated workspace profile summary and durable memory facts from co
 
 <rules>
 - Evidence-grounded only. Do not invent details. Exclude routing/tool chatter.
-- Treat [workstream:...] prefixes as thread context only.
+- Treat [thread:...] prefixes as thread context only.
 - Preserve existing profile format. Merge corrections; remove stale claims only when contradicted.
 - Facts must be standalone, one concrete claim each, understandable without transcript context.
 - If no durable updates exist, return current summary unchanged and empty facts.

package/src/system-agents/researcher.agent.ts

@@ -2,12 +2,12 @@ export const RESEARCHER_PROMPT = `<agent-instructions>
 You are a **Research Agent** that gathers accurate, up-to-date information from the web and synthesizes it into a clear markdown report.
 
 <workflow>
-1. Break the research task into 2-5 independent search queries.
+1. Break the research task into 2-3 focused search queries.
 2. If the task is time-sensitive, choose a matching recency window first and use \`searchWeb\` with \`tbs\` filters. Start narrow (\`qdr:d\`, \`qdr:w\`, \`qdr:m\`, \`qdr:y\`, or a custom date range), then widen only if needed.
 3. Run all searchWeb calls in parallel.
-4. Review results and identify the 3-5 most authoritative/relevant URLs.
+4. Review results and identify the 2-3 most authoritative/relevant URLs.
 5. Fetch those pages in parallel using fetchWebpage.
-6. If initial results are insufficient, reformulate queries and repeat (max 2 additional rounds).
+6. If initial results are insufficient, reformulate 1-2 queries and retry once.
 7. Synthesize findings into a structured markdown report.
 </workflow>
 

package/src/system-agents/{workstream-router.agent.ts → thread-router.agent.ts}

@@ -1,30 +1,23 @@
-import { ToolLoopAgent } from 'ai'
+import { generateObject } from 'ai'
 import { z } from 'zod'
 
 import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
 import { buildAiGatewayDirectCacheHeaders } from '../ai-gateway/cache-headers'
 import { agentDescriptions, agentDisplayNames, agentShortDisplayNames, routerModelId } from '../config/agent-defaults'
-
-// ---------------------------------------------------------------------------
-// Schemas
-// ---------------------------------------------------------------------------
+import { chatLogger } from '../config/logger'
+import { withTimeout } from '../utils/async'
 
 const TriageResultSchema = z.object({ agentId: z.string(), routingContext: z.string() })
 
-const CheckResultSchema = z.object({
+const CheckResultObjectSchema = z.object({
   done: z.boolean(),
-  agentId: z.string().optional(),
-  routingContext: z.string().optional(),
+  agentId: z.string().nullable(),
+  routingContext: z.string().nullable(),
 })
-
-const ROUTER_OUTPUT_PREVIEW_CHARS = 300
+type RouterCheckContinueResult = { done: false; agentId: string; routingContext: string | null }
 
 export type RouterTriageResult = z.infer<typeof TriageResultSchema>
-export type RouterCheckResult = z.infer<typeof CheckResultSchema>
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
+export type RouterCheckResult = { done: true } | RouterCheckContinueResult
 
 interface RouterDisplayOptions {
   displayNamesById?: Partial<Record<string, string>>
@@ -136,56 +129,13 @@ function extractExplicitAgentTargets(
     })
 }
 
-function extractJson(text: string): unknown {
-  const match = text.match(/\{[\s\S]*\}/)
-  if (!match) return null
-  try {
-    return JSON.parse(match[0])
-  } catch {
-    return null
-  }
-}
-
-/** Extract usable text from agent result — reasoning-only models put output in reasoning tokens */
-function extractResultText(result: { text?: string; reasoning?: unknown }): string {
-  const text = typeof result.text === 'string' ? result.text : ''
-  if (text.trim()) return text
-  // Reasoning can be a string or an array of { type, text } objects
-  const reasoning = result.reasoning
-  if (typeof reasoning === 'string') return reasoning
-  if (Array.isArray(reasoning)) {
-    return reasoning
-      .map((r) => {
-        if (typeof r === 'string') return r
-        if (typeof r !== 'object' || r === null || !('text' in r)) return ''
-
-        const text = (r as { text?: unknown }).text
-        return typeof text === 'string' ? text : ''
-      })
-      .join('')
-  }
-  return ''
-}
-
-function logRouterRaw(label: 'triage' | 'check', text: string): void {
-  const preview = text.trim().slice(0, ROUTER_OUTPUT_PREVIEW_CHARS)
-  if (!preview) return
-  console.log(`[workstream-router] ${label} raw:`, preview)
-}
-
-// ---------------------------------------------------------------------------
-// Prompts
-// ---------------------------------------------------------------------------
-
-const TRIAGE_SYSTEM_PROMPT = `You are a workstream message router. Decide which team member should respond FIRST to the user message.
+const TRIAGE_SYSTEM_PROMPT = `You are a thread message router. Decide which team member should respond FIRST to the user message.
 
 Rules:
 - Pick the single best-fit agent from the members list based on domain expertise.
 - If the user explicitly addresses an agent by name or role (e.g. "CTO: ..." or "CMO: ..."), route to that agent.
 - If no specialist clearly matches (general chat, greetings, coordination), respond with agentId "".
-- Be decisive. Reply with ONLY a JSON object, no other text.
-
-Format: {"agentId":"<id>","routingContext":"<1-sentence instruction>"}`
+- Be decisive.`
 
 const CHECK_SYSTEM_PROMPT = `You decide if another team member should ALSO respond after the previous agent's response.
 
@@ -199,29 +149,41 @@ Rules:
 - If the user explicitly addressed multiple agents (e.g. "CTO: ... CMO: ...") and one hasn't responded yet, they MUST respond. Return done:false.
 - If the last agent's response explicitly defers to or recommends another specialist, that specialist SHOULD respond. Return done:false.
 - If there is a clearly separate dimension of the user's question not yet covered by any responded agent, add the best-fit remaining agent.
-- Do NOT add agents just for agreement, acknowledgement, or minor additions.
-- Reply with ONLY a JSON object, no other text.
+- Do NOT add agents just for agreement, acknowledgement, or minor additions.`
 
-Format: {"done":true} or {"done":false,"agentId":"<id>","routingContext":"<1-sentence>"}`
+const THREAD_ROUTER_TIMEOUT_MS = 30_000
 
-// ---------------------------------------------------------------------------
-// Agent functions
-// ---------------------------------------------------------------------------
-
-function createRouterAgent(systemPrompt: string) {
+async function generateRouterObject<TSchema extends z.ZodTypeAny>(params: {
+  schema: TSchema
+  system: string
+  prompt: string
+  label: 'triage' | 'check'
+}): Promise<z.infer<TSchema> | null> {
   const modelId = routerModelId ?? 'openai/gpt-5.4-nano'
-  return new ToolLoopAgent({
-    id: 'workstream-router',
-    model: aiGatewayChatModel(modelId),
-    headers: buildAiGatewayDirectCacheHeaders('workstream-router'),
-    providerOptions: { openai: { reasoningEffort: 'low' } },
-    instructions: systemPrompt,
-    maxOutputTokens: 256,
-  })
+
+  try {
+    const { object } = await withTimeout(
+      generateObject({
+        model: aiGatewayChatModel(modelId),
+        headers: buildAiGatewayDirectCacheHeaders('thread-router'),
+        providerOptions: { openai: { reasoningEffort: 'low' } },
+        schema: params.schema,
+        system: params.system,
+        prompt: params.prompt,
+        maxOutputTokens: 256,
+      }),
+      THREAD_ROUTER_TIMEOUT_MS,
+      `thread-router ${params.label}`,
+    )
+    return params.schema.parse(object)
+  } catch (error) {
+    chatLogger.error`[thread-router] ${params.label} failed: ${error instanceof Error ? error.message : String(error)}`
+    return null
+  }
 }
 
-export async function triageWorkstreamMessage(params: {
-  workstreamTitle: string
+export async function triageThreadMessage(params: {
+  threadTitle: string
   members: readonly string[]
   messageText: string
   recentContext?: string
@@ -245,7 +207,7 @@ export async function triageWorkstreamMessage(params: {
 
   const membersDesc = buildMembersDescription(params.members, displayOptions)
   const prompt = [
-    `Workstream: "${params.workstreamTitle}"`,
+    `Thread: "${params.threadTitle}"`,
     `Members:\n${membersDesc}`,
     params.recentContext ? `Recent context:\n${params.recentContext}` : '',
     `User message: "${params.messageText}"`,
@@ -253,44 +215,31 @@ export async function triageWorkstreamMessage(params: {
     .filter(Boolean)
     .join('\n\n')
 
-  const agent = createRouterAgent(TRIAGE_SYSTEM_PROMPT)
-  let result: Awaited<ReturnType<typeof agent.generate>>
-  try {
-    result = await agent.generate({ messages: [{ role: 'user', content: prompt }], timeout: { totalMs: 30_000 } })
-  } catch (error) {
-    console.error('[workstream-router] triage failed:', error instanceof Error ? error.message : error)
-    return null
-  }
+  const parsed = await generateRouterObject({
+    schema: TriageResultSchema,
+    system: TRIAGE_SYSTEM_PROMPT,
+    prompt,
+    label: 'triage',
+  })
 
-  const effectiveText = extractResultText(result as { text?: string; reasoning?: unknown })
-  logRouterRaw('triage', effectiveText)
-  const json = extractJson(effectiveText)
-  if (json === null) {
-    if (effectiveText.trim()) {
-      console.log('[workstream-router] triage ignored non-json output')
-    }
-    return null
-  }
-  const parsed = TriageResultSchema.safeParse(json)
-  if (!parsed.success) {
-    console.log('[workstream-router] triage parse failed:', JSON.stringify(parsed.error.issues))
+  if (!parsed) {
     return null
   }
-  if (!parsed.data.agentId) {
-    console.log('[workstream-router] triage returned empty agentId — fallback to owner')
+  if (!parsed.agentId) {
+    chatLogger.debug`[thread-router] triage returned empty agentId`
     return null
   }
-  if (!params.members.includes(parsed.data.agentId)) {
-    console.log('[workstream-router] triage returned unknown agent:', parsed.data.agentId)
+  if (!params.members.includes(parsed.agentId)) {
+    chatLogger.warn`[thread-router] triage returned unknown agent: ${parsed.agentId}`
     return null
   }
 
-  console.log('[workstream-router] triage routed to:', parsed.data.agentId)
-  return parsed.data
+  chatLogger.debug`[thread-router] triage routed to ${parsed.agentId}`
+  return parsed
 }
 
 export async function checkForNextAgent(params: {
-  workstreamTitle: string
+  threadTitle: string
   members: readonly string[]
   messageText: string
   respondedAgents: string[]
@@ -321,45 +270,29 @@ export async function checkForNextAgent(params: {
   const respondedList = params.respondedAgents.map((id) => readDisplayName(id, displayOptions)).join(', ')
 
   const prompt = [
-    `Workstream: "${params.workstreamTitle}"`,
+    `Thread: "${params.threadTitle}"`,
     `Remaining members:\n${membersDesc}`,
     `Already responded: ${respondedList}`,
     `User message: "${params.messageText}"`,
     `Last agent response:\n"${params.lastResponseSummary}"`,
   ].join('\n\n')
 
-  const agent = createRouterAgent(CHECK_SYSTEM_PROMPT)
-  let result: Awaited<ReturnType<typeof agent.generate>>
-  try {
-    result = await agent.generate({ messages: [{ role: 'user', content: prompt }], timeout: { totalMs: 30_000 } })
-  } catch (error) {
-    console.error('[workstream-router] check failed:', error instanceof Error ? error.message : error)
-    return { done: true }
-  }
+  const parsed = await generateRouterObject({
+    schema: CheckResultObjectSchema,
+    system: CHECK_SYSTEM_PROMPT,
+    prompt,
+    label: 'check',
+  })
 
-  const effectiveText = extractResultText(result as { text?: string; reasoning?: unknown })
-  logRouterRaw('check', effectiveText)
-  const json = extractJson(effectiveText)
-  if (json === null) {
-    if (effectiveText.trim()) {
-      console.log('[workstream-router] check ignored non-json output')
-    }
-    return { done: true }
-  }
-  const parsed = CheckResultSchema.safeParse(json)
-  if (!parsed.success) {
-    console.log('[workstream-router] check parse failed:', JSON.stringify(parsed.error.issues))
-    return { done: true }
-  }
-  if (parsed.data.done) {
-    console.log('[workstream-router] check: done, no more agents needed')
+  if (!parsed || parsed.done) {
+    chatLogger.debug`[thread-router] check finished without another agent`
     return { done: true }
   }
-  if (!parsed.data.agentId || !remainingMembers.includes(parsed.data.agentId)) {
-    console.log('[workstream-router] check: invalid agentId:', parsed.data.agentId)
+  if (!parsed.agentId || !remainingMembers.includes(parsed.agentId)) {
+    chatLogger.warn`[thread-router] check returned invalid agent: ${parsed.agentId ?? 'missing'}`
     return { done: true }
   }
 
-  console.log('[workstream-router] check: next agent:', parsed.data.agentId)
-  return parsed.data
+  chatLogger.debug`[thread-router] check selected ${parsed.agentId}`
+  return { done: false, agentId: parsed.agentId, routingContext: parsed.routingContext ?? null }
 }

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

@@ -9,9 +9,9 @@ import {
 import type { CreateHelperToolLoopAgentOptions } from '../runtime/agent-types'
 import { resolveHelperAgentOptions } from './helper-agent-options'
 
-const WORKSTREAM_TITLE_MAX_TOKENS = 512
+const THREAD_TITLE_MAX_TOKENS = 512
 
-export const WORKSTREAM_TITLE_GENERATOR_PROMPT = `<agent-instructions>
+export const THREAD_TITLE_GENERATOR_PROMPT = `<agent-instructions>
 You are a **Title Generator** that creates concise chat titles.
 
 <task>
@@ -20,7 +20,7 @@ Generate a chat title based only on the user's message.
 
 <constraints>
 - Maximum 3-4 words
-- Capture the core workstream or intent
+- Capture the core thread or intent
 - Use natural, readable language
 - No punctuation at the end
 </constraints>
@@ -30,15 +30,15 @@ Return only the title text. No quotes, no labels, no explanation.
 </output-format>
 </agent-instructions>`
 
-export function createWorkstreamTitleGeneratorAgent(options: CreateHelperToolLoopAgentOptions) {
+export function createThreadTitleGeneratorAgent(options: CreateHelperToolLoopAgentOptions) {
   return new ToolLoopAgent({
-    id: 'workstream-title-generator',
+    id: 'thread-title-generator',
     model: aiGatewayModel(OPENROUTER_FAST_REASONING_MODEL_ID),
-    headers: buildAiGatewayDirectCacheHeaders('workstream-title-generator'),
+    headers: buildAiGatewayDirectCacheHeaders('thread-title-generator'),
     providerOptions: OPENROUTER_MINIMAL_REASONING_PROVIDER_OPTIONS,
     ...resolveHelperAgentOptions(options, {
-      instructions: WORKSTREAM_TITLE_GENERATOR_PROMPT,
-      maxOutputTokens: WORKSTREAM_TITLE_MAX_TOKENS,
+      instructions: THREAD_TITLE_GENERATOR_PROMPT,
+      maxOutputTokens: THREAD_TITLE_MAX_TOKENS,
     }),
   })
 }

package/src/tools/execution-plan.tool.ts

@@ -5,19 +5,16 @@ import {
   expandAgentPlanDraft,
   getLatestExecutionPlanResult,
 } from '@lota-sdk/shared'
-import type { ExecutionPlanAction, ExecutionPlanArgs, CreateProjectWithPlanResultData } from '@lota-sdk/shared'
+import type { CreateProjectWithPlanResultData, ExecutionPlanAction, ExecutionPlanArgs } from '@lota-sdk/shared'
 import { tool } from 'ai'
 
 import type { RecordIdRef } from '../db/record-id'
 import { recordIdToString } from '../db/record-id'
 import { TABLES } from '../db/tables'
 import { executionPlanService } from '../services/execution-plan.service'
-import { workstreamService } from '../services/workstream.service'
+import { threadService } from '../services/thread.service'
 
-type ExecutionPlanWorkstreamService = Pick<
-  typeof workstreamService,
-  'createWorkstream' | 'deleteWorkstream' | 'getWorkstream'
->
+type ExecutionPlanThreadService = Pick<typeof threadService, 'createThread' | 'deleteThread' | 'getThread'>
 
 type ExecutionPlanExecutionPlanService = Pick<
   typeof executionPlanService,
@@ -26,90 +23,92 @@ type ExecutionPlanExecutionPlanService = Pick<
   | 'resumeRun'
   | 'listActivePlanSummaries'
   | 'getActivePlanToolResult'
-  | 'getActivePlansForWorkstream'
+  | 'getActivePlansForThread'
 >
 
 function extractDraft(input: ExecutionPlanArgs) {
-  const { action, projectTitle, targetWorkstreamId, runId, reason, ...draftInput } = input
-  return { action, projectTitle, targetWorkstreamId, runId, reason, draft: expandAgentPlanDraft(draftInput) }
+  const { action, projectTitle, targetThreadId, runId, reason, ...draftInput } = input
+  return { action, projectTitle, targetThreadId, runId, reason, draft: expandAgentPlanDraft(draftInput) }
 }
 
 export function createExecutionPlanTool(params: {
   orgId: RecordIdRef
   userId: RecordIdRef
-  workstreamId: RecordIdRef
+  threadId: RecordIdRef
   agentId: string
   executionPlanService?: ExecutionPlanExecutionPlanService
-  workstreamService?: ExecutionPlanWorkstreamService
+  threadService?: ExecutionPlanThreadService
   onPlanChanged?: () => void
   validateInlinePlan?: (draft: ReturnType<typeof expandAgentPlanDraft>) => void
 }) {
   const resolvedEpService = params.executionPlanService ?? executionPlanService
-  const resolvedWsService = params.workstreamService ?? workstreamService
+  const resolvedWsService = params.threadService ?? threadService
 
   return tool({
     description:
-      'Manage execution plans. Actions: create (inline, 1-2 nodes), create-project (dedicated project workstream, 3+ nodes), replace (swap active plan), resume (resume interrupted plan).',
+      'Manage execution plans. Actions: create (inline, 1-2 nodes), create-project (dedicated project thread, 3+ nodes), replace (swap active plan), resume (resume interrupted plan).',
     inputSchema: ExecutionPlanArgsSchema,
     execute: async (input) => {
-      const { action, projectTitle, targetWorkstreamId, runId, reason, draft } = extractDraft(input)
+      const { action, projectTitle, targetThreadId, runId, reason, draft } = extractDraft(input)
 
       const handler: Record<ExecutionPlanAction, () => Promise<unknown>> = {
         create: async () => {
           params.validateInlinePlan?.(draft)
           return await resolvedEpService.createPlan({
             organizationId: params.orgId,
-            workstreamId: targetWorkstreamId ?? params.workstreamId,
+            threadId: targetThreadId ?? params.threadId,
             leadAgentId: params.agentId,
             input: draft,
           })
         },
 
         'create-project': async () => {
-          const targetWorkstream = targetWorkstreamId
-            ? await resolvedWsService.getWorkstream(targetWorkstreamId)
+          const targetThread = targetThreadId
+            ? await resolvedWsService.getThread(targetThreadId)
             : await (() => {
                 if (!projectTitle) {
                   throw new Error('projectTitle is required when action is "create-project".')
                 }
 
-                return resolvedWsService.createWorkstream(params.userId, params.orgId, {
+                return resolvedWsService.createThread({
+                  userId: params.userId,
+                  organizationId: params.orgId,
                   title: projectTitle,
-                  mode: 'group',
+                  type: 'group',
                 })
               })()
 
-          if (targetWorkstream.organizationId !== recordIdToString(params.orgId, TABLES.ORGANIZATION)) {
-            throw new Error('Target workstream belongs to a different organization.')
+          if (targetThread.organizationId !== recordIdToString(params.orgId, TABLES.ORGANIZATION)) {
+            throw new Error('Target thread belongs to a different organization.')
           }
-          if (targetWorkstream.userId !== recordIdToString(params.userId, TABLES.USER)) {
-            throw new Error('Target workstream belongs to a different user.')
+          if (targetThread.userId !== recordIdToString(params.userId, TABLES.USER)) {
+            throw new Error('Target thread belongs to a different user.')
           }
 
-          const existingPlans = await resolvedEpService.getActivePlansForWorkstream(targetWorkstream.id)
-          if (!targetWorkstream.core && existingPlans.length > 0) {
+          const existingPlans = await resolvedEpService.getActivePlansForThread(targetThread.id)
+          if (targetThread.type !== 'thread' && existingPlans.length > 0) {
             throw new Error(
-              'This workstream already has an active execution plan. Use action "replace" or target a core workstream.',
+              'This thread already has an active execution plan. Use action "replace" or target a core thread.',
             )
           }
 
-          const createdWorkstream = !targetWorkstreamId
+          const createdThread = !targetThreadId
           try {
             const result = await resolvedEpService.createPlan({
               organizationId: params.orgId,
-              workstreamId: targetWorkstream.id,
+              threadId: targetThread.id,
               leadAgentId: params.agentId,
               input: draft,
             })
             return {
               ...result,
-              workstreamId: targetWorkstream.id,
-              workstreamTitle: targetWorkstream.title,
-              createdWorkstream,
+              threadId: targetThread.id,
+              threadTitle: targetThread.title,
+              createdThread,
             } satisfies CreateProjectWithPlanResultData
           } catch (error) {
-            if (createdWorkstream) {
-              await resolvedWsService.deleteWorkstream(targetWorkstream.id).catch(() => {})
+            if (createdThread) {
+              await resolvedWsService.deleteThread(targetThread.id).catch(() => {})
             }
             throw error
           }
@@ -122,7 +121,7 @@ export function createExecutionPlanTool(params: {
 
           return await resolvedEpService.replacePlan({
             organizationId: params.orgId,
-            workstreamId: params.workstreamId,
+            threadId: params.threadId,
             leadAgentId: params.agentId,
             input: { runId, reason, ...draft },
           })
@@ -134,7 +133,7 @@ export function createExecutionPlanTool(params: {
           }
 
           return await resolvedEpService.resumeRun({
-            workstreamId: params.workstreamId,
+            threadId: params.threadId,
             emittedBy: params.agentId,
             input: { runId },
           })
@@ -148,17 +147,17 @@ export function createExecutionPlanTool(params: {
   })
 }
 
-export function createExecutionPlanQueryTool(params: { workstreamId: RecordIdRef }) {
+export function createExecutionPlanQueryTool(params: { threadId: RecordIdRef }) {
   return tool({
     description:
       'Query execution plans. Omit runId to list all active plans. Provide runId to load a specific plan run.',
     inputSchema: ExecutionPlanQueryArgsSchema,
     execute: async (input) => {
       if (!input.runId) {
-        return await executionPlanService.listActivePlanSummaries(params.workstreamId)
+        return await executionPlanService.listActivePlanSummaries(params.threadId)
       }
       return await executionPlanService.getActivePlanToolResult({
-        workstreamId: params.workstreamId,
+        threadId: params.threadId,
         runId: input.runId,
         includeEvents: input.includeEvents,
         includeArtifacts: input.includeArtifacts,
@@ -171,7 +170,7 @@ export function createExecutionPlanQueryTool(params: { workstreamId: RecordIdRef
 }
 
 export function createSubmitExecutionNodeResultTool(params: {
-  workstreamId: RecordIdRef
+  threadId: RecordIdRef
   agentId: string
   onPlanChanged?: () => void
 }) {
@@ -181,7 +180,7 @@ export function createSubmitExecutionNodeResultTool(params: {
     inputSchema: SubmitExecutionNodeResultArgsSchema,
     execute: async (input) => {
       const result = await executionPlanService.submitNodeResult({
-        workstreamId: params.workstreamId,
+        threadId: params.threadId,
         emittedBy: params.agentId,
         input,
       })