@lota-sdk/core 0.2.3 → 0.3.0

package/src/runtime/context-compaction-constants.ts

@@ -10,4 +10,4 @@ export const SUMMARY_ROLLUP_MAX_TOKENS = 80_000
 export const CONTEXT_COMPACTION_INCLUDED_TOOL_NAMES = ['userQuestions', 'proceedInOnboarding'] as const
 export const CONTEXT_COMPACTION_INCLUDED_TOOL_PREFIXES = ['linear'] as const
 export const CONTEXT_WINDOW_TOKENS = 200_000
-export const WORKSTREAM_RAW_TAIL_MESSAGES = 6
+export const THREAD_RAW_TAIL_MESSAGES = 6

package/src/runtime/context-compaction.ts

@@ -198,7 +198,7 @@ export function buildContextCompactionPrompt(params: ContextCompactionPromptPara
 export function buildMemoryBlockCompactionPrompt(params: MemoryBlockCompactionPromptParams): string {
   return [
     '<memory-block-compaction>',
-    'Produce a compact replacement summary for the workstream memory block.',
+    'Produce a compact replacement summary for the thread memory block.',
     'Preserve constraints, commitments, unresolved risks, and ownership.',
     'Blend the previous summary with the new raw entries into one updated summary.',
     'Return plain text only.',

package/src/runtime/execution-plan.ts

@@ -7,7 +7,7 @@ const EXECUTION_PLAN_AGENT_PROTOCOL_PROMPT = `<execution-plan-protocol>
 - The active execution runs in <execution-plan-state> are a summary inventory only. They list runId and title, not node-level state.
 - The runtime executor owns lifecycle truth. Do not claim node completion until the executor confirms.
 - Do not invent or restate run/node lifecycle details that are not present in the prompt or tool results.
-- During plan-triggered turns, use the dedicated result-submission tool. Include handoffContext.
+- During plan-triggered turns, use the dedicated result-submission tool.
 - Treat the active execution runs in <execution-plan-state> as authoritative for whether a plan already exists.
 - If contracts or criteria materially change, replace the plan.
 </execution-plan-protocol>`

package/src/runtime/index.ts

@@ -24,4 +24,4 @@ export * from './social-chat'
 export * from './team-consultation-orchestrator'
 export * from './team-consultation-prompts'
 export * from './turn-lifecycle'
-export * from './workstream-chat-helpers'
+export * from './thread-chat-helpers'

package/src/runtime/memory-digest-policy.ts

@@ -11,7 +11,7 @@ export function shouldEnqueueOnboardingPostChatMemory(params: {
   return params.userMessageText.trim().length > 0 || params.hasAttachmentContext
 }
 
-export function shouldEnqueueRegularDigestForWorkstream(params: {
+export function shouldEnqueueRegularDigestForThread(params: {
   onboardingActive: boolean
   turnCount?: number
 }): boolean {

package/src/runtime/plugin-types.ts

@@ -9,7 +9,7 @@ export interface LotaPluginContributions {
 
 export interface PluginNodeExecutorContext {
   organizationId: string
-  workstreamId: string
+  threadId: string
   planId: string
   nodeId: string
   userId?: RecordIdRef

package/src/runtime/post-turn-side-effects.ts

@@ -10,22 +10,22 @@ import {
   shouldEnqueueMemoryConsolidation,
   shouldEnqueueMemoryExtraction,
   shouldEnqueueOnboardingPostChatMemory,
-  shouldEnqueueRegularDigestForWorkstream,
+  shouldEnqueueRegularDigestForThread,
 } from '../runtime/memory-digest-policy'
 import { getRuntimeAdapters } from '../runtime/runtime-extensions'
 import { shouldEnqueueSkillExtraction } from '../runtime/skill-extraction-policy'
 import {
-  appendPersistedWorkstreamContextToHistoryMessages,
+  appendPersistedThreadContextToHistoryMessages,
   buildAgentHistoryMessages,
   buildConversationSummary,
   buildReadableUploadMetadataContext,
   extractMessageText,
   readOptionalString,
   toHistoryMessages,
-} from '../runtime/workstream-chat-helpers'
+} from '../runtime/thread-chat-helpers'
 import { recentActivityService } from '../services/recent-activity.service'
-import { workstreamService } from '../services/workstream.service'
-import type { NormalizedWorkstream, WorkstreamRecord } from '../services/workstream.types'
+import { threadService } from '../services/thread.service'
+import type { NormalizedThread, ThreadRecord } from '../services/thread.types'
 import { safeEnqueue } from '../utils/async'
 import { toIsoDateTimeString } from '../utils/date-time'
 
@@ -41,37 +41,37 @@ function resolveDisplayName(agentId: string, overrides?: Partial<Record<string,
 }
 
 function buildRecentActivityChatDeepLink(params: {
-  workstream: NormalizedWorkstream
-  workstreamId: string
+  thread: NormalizedThread
+  threadId: string
   visibleAgentId: string
 }): { route: string; search: Record<string, string> } {
-  if (params.workstream.mode === 'direct') {
-    return { route: 'direct-workstream', search: { workstreamId: params.workstreamId, agentId: params.visibleAgentId } }
+  if (params.thread.type === 'default') {
+    return { route: 'direct-thread', search: { threadId: params.threadId, agentId: params.visibleAgentId } }
   }
 
-  return { route: 'group-workstream', search: { workstreamId: params.workstreamId } }
+  return { route: 'group-thread', search: { threadId: params.threadId } }
 }
 
 function buildRecentActivityChatSystemTitle(params: {
-  workstream: NormalizedWorkstream
+  thread: NormalizedThread
   visibleAgentId: string
   agentDisplayNamesById?: Partial<Record<string, string>>
 }): string {
-  if (params.workstream.mode === 'direct') {
+  if (params.thread.type === 'default') {
     return `Conversation with ${resolveDisplayName(params.visibleAgentId, params.agentDisplayNamesById)}`
   }
 
-  return params.workstream.title.trim() || 'Workstream update'
+  return params.thread.title.trim() || 'Thread update'
 }
 
 interface PostTurnSideEffectsParams {
-  workstream: NormalizedWorkstream
-  workstreamRef: RecordIdRef
+  thread: NormalizedThread
+  threadRef: RecordIdRef
   orgRef: RecordIdRef
   userRef: RecordIdRef
   userName?: string | null
   orgIdString: string
-  workstreamIdString: string
+  threadIdString: string
   onboardingActive: boolean
   workspace: unknown
   allAssistantMessages: ChatMessage[]
@@ -85,19 +85,19 @@ interface PostTurnSideEffectsParams {
     storageKey: string
   }>
   memoryBlock: string
-  visibleWorkstreamAgentId: string | null | undefined
+  visibleThreadAgentId: string | null | undefined
   defaultLeadAgentId: string
-  latestWorkstreamRecord: WorkstreamRecord
+  latestThreadRecord: ThreadRecord
   isUserTurn: boolean
   agentDisplayNamesById?: Partial<Record<string, string>>
 }
 
 export async function runPostTurnSideEffects(params: PostTurnSideEffectsParams): Promise<void> {
   const recentHistory = await params.loadRecentHistory()
-  const turnCount = await workstreamService.incrementTurnCount(params.workstreamRef)
+  const turnCount = await threadService.incrementTurnCount(params.threadRef)
   const agentMessages = buildAgentHistoryMessages(params.allAssistantMessages)
-  const historyMessagesForMemory = appendPersistedWorkstreamContextToHistoryMessages(toHistoryMessages(recentHistory), {
-    compactionSummary: params.latestWorkstreamRecord.compactionSummary,
+  const historyMessagesForMemory = appendPersistedThreadContextToHistoryMessages(toHistoryMessages(recentHistory), {
+    compactionSummary: params.latestThreadRecord.compactionSummary,
   })
 
   const userMessageText = params.referenceUserMessage ? extractMessageText(params.referenceUserMessage).trim() : ''
@@ -120,7 +120,7 @@ export async function runPostTurnSideEffects(params: PostTurnSideEffectsParams):
       () =>
         enqueuePostChatMemory({
           orgId: params.orgIdString,
-          workstreamId: params.workstreamIdString,
+          threadId: params.threadIdString,
           sourceId: params.referenceUserMessageId,
           onboardStatus: readOptionalString((params.workspace as { onboardStatus?: unknown }).onboardStatus),
           userMessage: memoryUserMessage,
@@ -139,7 +139,7 @@ export async function runPostTurnSideEffects(params: PostTurnSideEffectsParams):
       assistantMessages: params.allAssistantMessages,
     })
     if (conversationSummary) {
-      const effectiveAgentId = params.visibleWorkstreamAgentId ?? params.defaultLeadAgentId
+      const effectiveAgentId = params.visibleThreadAgentId ?? params.defaultLeadAgentId
       const recentActivityResult = await recentActivityService.recordEvent({
         orgId: params.orgRef,
         userId: params.userRef,
@@ -147,27 +147,27 @@ export async function runPostTurnSideEffects(params: PostTurnSideEffectsParams):
         event: {
           sourceEventId: `chat-turn:${params.referenceUserMessageId}`,
           kind: 'chat.turn.completed',
-          targetKind: 'workstream',
-          targetId: params.workstreamIdString,
-          mergeKey: `workstream:${params.workstreamIdString}`,
+          targetKind: 'thread',
+          targetId: params.threadIdString,
+          mergeKey: `thread:${params.threadIdString}`,
           title: buildRecentActivityChatSystemTitle({
-            workstream: params.workstream,
+            thread: params.thread,
             visibleAgentId: effectiveAgentId,
             agentDisplayNamesById: params.agentDisplayNamesById,
           }),
           sourceLabel: resolveDisplayName(effectiveAgentId, params.agentDisplayNamesById),
           deepLink: buildRecentActivityChatDeepLink({
-            workstream: params.workstream,
-            workstreamId: params.workstreamIdString,
+            thread: params.thread,
+            threadId: params.threadIdString,
             visibleAgentId: effectiveAgentId,
           }),
           metadata: {
             agentId: effectiveAgentId,
             agentName: resolveDisplayName(effectiveAgentId, params.agentDisplayNamesById),
-            workstreamId: params.workstreamIdString,
-            workstreamTitle: params.latestWorkstreamRecord.title ?? params.workstream.title,
-            workstreamMode: params.workstream.mode,
-            ...(params.workstream.coreType ? { coreType: params.workstream.coreType } : {}),
+            threadId: params.threadIdString,
+            threadTitle: params.latestThreadRecord.title ?? params.thread.title,
+            threadType: params.thread.type,
+            ...(params.thread.threadType ? { coreType: params.thread.threadType } : {}),
             userMessageText,
             assistantSummary: conversationSummary,
             messageId: params.referenceUserMessageId,
@@ -186,7 +186,7 @@ export async function runPostTurnSideEffects(params: PostTurnSideEffectsParams):
 
           await enqueuePostChatOrgAction({
             orgId: params.orgIdString,
-            workstreamId: params.workstreamIdString,
+            threadId: params.threadIdString,
             sourceId: params.referenceUserMessageId,
             sourceCreatedAt,
             conversationSummary,
@@ -203,7 +203,7 @@ export async function runPostTurnSideEffects(params: PostTurnSideEffectsParams):
     }
   }
 
-  if (shouldEnqueueRegularDigestForWorkstream({ onboardingActive: params.onboardingActive, turnCount })) {
+  if (shouldEnqueueRegularDigestForThread({ onboardingActive: params.onboardingActive, turnCount })) {
     await safeEnqueue(() => enqueueRegularChatMemoryDigest({ orgId: params.orgIdString }), {
       operationName: 'regular chat memory digest enqueue',
     })

package/src/runtime/runtime-config.ts

@@ -1,9 +1,9 @@
 import type { ToolSet } from 'ai'
 import { z } from 'zod'
 
-import type { CoreWorkstreamProfile } from '../config/agent-defaults'
+import type { CoreThreadProfile } from '../config/agent-defaults'
 import type { AgentFactory, AgentRuntimeConfigProvider, AgentToolBuilder } from '../config/agent-types'
-import type { LotaWorkstreamConfig, WorkstreamBootstrapWelcomeConfig } from '../config/workstream-defaults'
+import type { LotaThreadConfig, ThreadBootstrapWelcomeConfig } from '../config/thread-defaults'
 import type { RecordIdRef } from '../db/record-id'
 import type { NotificationService } from '../services/notification.service'
 import { isRecord } from '../utils/string'
@@ -144,21 +144,21 @@ function isSocialChatConfig(value: unknown): value is LotaRuntimeSocialChatConfi
   return true
 }
 
-const workstreamBootstrapWelcomeConfigSchema = z.object({
-  directAgentId: z.string().trim().min(1),
-  buildMessageText: z.custom<WorkstreamBootstrapWelcomeConfig['buildMessageText']>(isFunction, {
+const threadBootstrapWelcomeConfigSchema = z.object({
+  defaultAgentId: z.string().trim().min(1),
+  buildMessageText: z.custom<ThreadBootstrapWelcomeConfig['buildMessageText']>(isFunction, {
     error: 'onboardingWelcome.buildMessageText must be a function',
   }),
 })
 
-const workstreamConfigSchema = z.object({
+const threadConfigSchema = z.object({
   bootstrap: z
     .object({
       onboardingDirectAgents: z.array(z.string().trim().min(1)).optional(),
       completedDirectAgents: z.array(z.string().trim().min(1)).optional(),
       coreTypesAfterOnboarding: z.array(z.string().trim().min(1)).optional(),
       ensureDefaultGroupOnCompleted: z.boolean().optional(),
-      onboardingWelcome: workstreamBootstrapWelcomeConfigSchema.optional(),
+      onboardingWelcome: threadBootstrapWelcomeConfigSchema.optional(),
     })
     .optional(),
 })
@@ -178,9 +178,9 @@ const agentsConfigSchema = z
       .optional(),
     routerModelId: z.string().trim().min(1).optional(),
     teamConsultParticipants: z.array(z.string().trim().min(1)),
-    getCoreWorkstreamProfile: z
-      .custom<(coreType: string) => CoreWorkstreamProfile>(isFunction, {
-        error: 'agents.getCoreWorkstreamProfile must be a function',
+    getCoreThreadProfile: z
+      .custom<(coreType: string) => CoreThreadProfile>(isFunction, {
+        error: 'agents.getCoreThreadProfile must be a function',
       })
       .optional(),
     createAgent: z
@@ -249,7 +249,7 @@ export const LotaRuntimeConfigSchema = z.object({
       embeddingCacheTtlSeconds: z.coerce.number().int().positive().default(7200),
     })
     .default({ searchK: 6, embeddingCacheTtlSeconds: 7200 }),
-  workstreams: workstreamConfigSchema.default({}),
+  threads: threadConfigSchema.default({}),
   agents: agentsConfigSchema,
   toolProviders: z.custom<Record<string, unknown>>(isToolProviderRecord).optional(),
   extraSchemaFiles: z.array(z.custom<string | URL>(isStringOrUrl)).optional(),
@@ -319,4 +319,4 @@ export function parseWorkerBootstrapEnv(env: Record<string, string | undefined>)
   return WORKER_BOOTSTRAP_ENV_SCHEMA.parse(env)
 }
 
-export type { LotaWorkstreamConfig }
+export type { LotaThreadConfig }

package/src/runtime/runtime-extensions.ts

@@ -74,7 +74,7 @@ export interface LotaRuntimeTeamThinkToolsParams {
   workspaceId: RecordIdRef
   userId: RecordIdRef
   workspaceIdString: string
-  workstreamId: RecordIdRef
+  threadId: RecordIdRef
   githubInstalled: boolean
   provideRepoTool: boolean
   availableUploads: ReadableUploadMetadata[]
@@ -90,7 +90,7 @@ export interface LotaRuntimePlanEventEnvelope {
   nodeSpec?: PlanNodeSpecRecord
   nodeRun?: PlanNodeRunRecord
   organizationId: string
-  workstreamId: string
+  threadId: string
   runId: string
   planSpecId: string
   userId?: string
@@ -102,8 +102,8 @@ export interface LotaRuntimePlanEventAdapter {
 }
 
 export interface BuildContextParams {
-  workstream: unknown
-  workstreamRef: RecordIdRef
+  thread: unknown
+  threadRef: RecordIdRef
   orgRef: RecordIdRef
   userRef: RecordIdRef
   userName?: string | null
@@ -123,15 +123,15 @@ export interface BuildContextParams {
 }
 
 export interface AfterTurnParams {
-  workstream: unknown
-  workstreamRef: RecordIdRef
+  thread: unknown
+  threadRef: RecordIdRef
   orgRef: RecordIdRef
   userRef: RecordIdRef
   userName?: string | null
   onboardingActive: boolean
   referenceUserMessage: unknown
   assistantMessages: unknown[]
-  latestWorkstreamRecord: unknown
+  latestThreadRecord: unknown
   context: Record<string, unknown> | null
   [key: string]: unknown
 }
@@ -139,8 +139,8 @@ export interface AfterTurnParams {
 export interface ResolveAgentParams {
   agentId: string
   mode: string
-  workstream: unknown
-  workstreamRef: RecordIdRef
+  thread: unknown
+  threadRef: RecordIdRef
   orgRef: RecordIdRef
   userRef: RecordIdRef
   userName?: string | null
@@ -154,8 +154,8 @@ export interface ResolveAgentParams {
 }
 
 export interface BuildExtraInstructionSectionsParams {
-  workstream: unknown
-  workstreamRef: RecordIdRef
+  thread: unknown
+  threadRef: RecordIdRef
   orgRef: RecordIdRef
   userRef: RecordIdRef
   userName?: string | null

package/src/runtime/social-chat-agent-runner.ts

@@ -59,8 +59,8 @@ export function withLoggedSocialToolSet(
 
 export async function runSocialAgentTurn(params: {
   agentId: string
-  mode: 'fixedWorkstreamMode' | 'workstreamMode'
-  workstreamMode: 'group'
+  mode: 'fixedThreadMode' | 'threadMode'
+  threadType: 'group'
   onboardingActive: boolean
   linearInstalled: boolean
   systemWorkspaceDetails?: string
@@ -75,7 +75,7 @@ export async function runSocialAgentTurn(params: {
 }): Promise<{ text: string; displayName: string }> {
   const runtimeConfig = getAgentRuntimeConfig({
     agentId: params.agentId,
-    workstreamMode: params.workstreamMode,
+    threadType: params.threadType,
     mode: params.mode,
     onboardingActive: params.onboardingActive,
     linearInstalled: params.linearInstalled,

package/src/runtime/social-chat-history.ts

@@ -2,7 +2,7 @@ import { stripSlackToolExecutionNoticeMarkdown } from '@lota-sdk/shared'
 import type { Message, Thread } from 'chat'
 
 import type { SocialChatHistoryMessage } from '../services/social-chat-history.service'
-import { toHistoryMessages, toOptionalTrimmedString } from './workstream-chat-helpers'
+import { toHistoryMessages, toOptionalTrimmedString } from './thread-chat-helpers'
 
 export function readSlackAuthorName(message: Message): string | undefined {
   return (

package/src/runtime/social-chat.ts

@@ -48,7 +48,7 @@ import {
   extractMessageText,
   toHistoryMessages,
   toOptionalTrimmedString,
-} from './workstream-chat-helpers'
+} from './thread-chat-helpers'
 
 const DEFAULT_SOCIAL_CHAT_AGENT_ID = 'socialChat'
 const DEFAULT_SOCIAL_CHAT_AGENT_DISPLAY_NAME = 'Lota'
@@ -362,8 +362,8 @@ export function createSocialChatRuntime(params: {
 
             return await runSocialAgentTurn({
               agentId,
-              mode: 'fixedWorkstreamMode',
-              workstreamMode: 'group',
+              mode: 'fixedThreadMode',
+              threadType: 'group',
               onboardingActive: lifecycleState?.bootstrapActive ?? false,
               linearInstalled: false,
               systemWorkspaceDetails: promptContext.systemWorkspaceDetails,
@@ -407,8 +407,8 @@ export function createSocialChatRuntime(params: {
     aiLogger.info`Slack social-chat generating reply: channelId=${messageContext.channelId}, threadId=${messageContext.threadId}`
     const leadRun = await runSocialAgentTurn({
       agentId: socialAgentId,
-      mode: 'workstreamMode',
-      workstreamMode: 'group',
+      mode: 'threadMode',
+      threadType: 'group',
       onboardingActive: lifecycleState?.bootstrapActive ?? false,
       linearInstalled: false,
       systemWorkspaceDetails: promptContext.systemWorkspaceDetails,
@@ -453,7 +453,7 @@ export function createSocialChatRuntime(params: {
           enqueuePostChatMemory(
             {
               orgId: workspaceIdString,
-              workstreamId: `social:slack:${messageContext.threadId}`,
+              threadId: `social:slack:${messageContext.threadId}`,
               sourceId: createSocialChatCursorId({
                 workspaceId: workspaceIdString,
                 threadId: messageContext.threadId,

package/src/runtime/team-consultation-orchestrator.ts

@@ -8,7 +8,7 @@ import { buildModelInputMessagesWithUploadMetadata, buildReadableUploadMetadataT
 import type { ReadableUploadMetadataLike } from './chat-attachments'
 import type { RepoSectionName } from './indexed-repositories-policy'
 import { buildTeamConsultationFailureMessage } from './team-consultation-prompts'
-import { extractMessageText } from './workstream-chat-helpers'
+import { extractMessageText } from './thread-chat-helpers'
 
 export type DefaultRepoSections = RepoSectionName[]
 const TEAM_CONSULTATION_TIMEOUT_MS = 90_000

package/src/runtime/{workstream-chat-helpers.ts → thread-chat-helpers.ts}

@@ -1,7 +1,7 @@
 import { agentDisplayNames, resolveAgentNameAlias } from '../config/agent-defaults'
 import type { ChatMessageLike, ReadableUploadMetadataLike } from './chat-types'
 
-export interface WorkstreamHistoryMessage {
+export interface ThreadHistoryMessage {
   role: 'user' | 'agent'
   content: string
   agentName?: string
@@ -42,9 +42,9 @@ export function extractMessageText(message: ChatMessageLike): string {
     .trim()
 }
 
-export function toHistoryMessages(messages: ChatMessageLike[], maxItems = 24): WorkstreamHistoryMessage[] {
+export function toHistoryMessages(messages: ChatMessageLike[], maxItems = 24): ThreadHistoryMessage[] {
   return messages
-    .map((message): WorkstreamHistoryMessage | null => {
+    .map((message): ThreadHistoryMessage | null => {
       const content = extractMessageText(message)
       if (!content) return null
 
@@ -57,7 +57,7 @@ export function toHistoryMessages(messages: ChatMessageLike[], maxItems = 24): W
       }
       return null
     })
-    .filter((message): message is WorkstreamHistoryMessage => message !== null)
+    .filter((message): message is ThreadHistoryMessage => message !== null)
     .slice(-maxItems)
 }
 
@@ -86,10 +86,10 @@ export function buildAgentHistoryMessages(messages: ChatMessageLike[]): Array<{
     .map((message) => ({ content: message.content, ...(message.agentName ? { agentName: message.agentName } : {}) }))
 }
 
-export function appendPersistedWorkstreamContextToHistoryMessages(
-  historyMessages: WorkstreamHistoryMessage[],
+export function appendPersistedThreadContextToHistoryMessages(
+  historyMessages: ThreadHistoryMessage[],
   params: { compactionSummary?: string | null },
-): WorkstreamHistoryMessage[] {
+): ThreadHistoryMessage[] {
   const nextHistoryMessages = [...historyMessages]
   const compactionSummary = typeof params.compactionSummary === 'string' ? params.compactionSummary.trim() : ''
   if (compactionSummary) {

package/src/runtime/{workstream-plan-turn.ts → thread-plan-turn.ts}

@@ -1,11 +1,5 @@
 import { SUBMIT_PLAN_TURN_RESULT_TOOL_NAME, withMessageCreatedAt } from '@lota-sdk/shared'
-import type {
-  ChatMessage,
-  PlanArtifactSubmission,
-  PlanNodeHandoffContext,
-  PlanNodeRunRecord,
-  PlanNodeSpecRecord,
-} from '@lota-sdk/shared'
+import type { ChatMessage, PlanArtifactSubmission, PlanNodeRunRecord, PlanNodeSpecRecord } from '@lota-sdk/shared'
 
 import { buildCompletionCheckStructuredOutputHints } from './agent-runtime-policy'
 import { mergeInstructionSections } from './instruction-sections'
@@ -15,10 +9,10 @@ export interface PlanTurnUpstreamHandoff {
   label: string
   ownerRef: string
   ownerType: PlanNodeSpecRecord['owner']['executorType']
-  handoffContext: PlanNodeHandoffContext
+  summary?: string
 }
 
-export interface WorkstreamPlanTurnContext {
+export interface ThreadPlanTurnContext {
   runId: string
   nodeId: string
   planTitle: string
@@ -29,7 +23,7 @@ export interface WorkstreamPlanTurnContext {
   upstreamHandoffs: PlanTurnUpstreamHandoff[]
 }
 
-function buildPlanTurnExecutionSection(planTurn: WorkstreamPlanTurnContext): string {
+function buildPlanTurnExecutionSection(planTurn: ThreadPlanTurnContext): string {
   const requiredDeliverables = planTurn.nodeSpec.deliverables.filter((deliverable) => deliverable.required)
   const completionCheckOutputHints = buildCompletionCheckStructuredOutputHints(planTurn.nodeSpec)
   const payload = {
@@ -55,11 +49,11 @@ function buildPlanTurnExecutionSection(planTurn: WorkstreamPlanTurnContext): str
   return [
     '<plan-turn-execution>',
     `Complete node "${planTurn.nodeSpec.label}" for plan "${planTurn.planTitle}".`,
-    'Use only the node contract, resolved input, input artifacts, and upstream handoff context.',
+    'Use only the node contract, resolved input, input artifacts, and upstream summaries.',
     'Before submitting, satisfy every required deliverable, success criterion, and completion check.',
     `Call ${SUBMIT_PLAN_TURN_RESULT_TOOL_NAME} exactly once when done.`,
     `Required artifacts: ${requiredDeliverables.length > 0 ? requiredDeliverables.map((d) => d.name).join(', ') : 'none'}.`,
-    'Include notes with a concise completion summary. Include handoffContext with summary, key decisions, open questions, risks, and recommendations for downstream nodes.',
+    'notes is required. Include a concise summary of what was done, key decisions, and any context downstream nodes need.',
     ...(completionCheckOutputHints.length > 0
       ? ['Structured output fields required by completion checks:', ...completionCheckOutputHints]
       : []),
@@ -81,7 +75,7 @@ function buildUpstreamHandoffSection(upstreamHandoffs: PlanTurnUpstreamHandoff[]
         label: handoff.label,
         ownerRef: handoff.ownerRef,
         ownerType: handoff.ownerType,
-        handoffContext: handoff.handoffContext,
+        ...(handoff.summary ? { summary: handoff.summary } : {}),
       })),
       null,
       2,
@@ -90,7 +84,7 @@ function buildUpstreamHandoffSection(upstreamHandoffs: PlanTurnUpstreamHandoff[]
   ].join('\n')
 }
 
-export function buildPlanTurnInstructionSections(planTurn: WorkstreamPlanTurnContext): string[] {
+export function buildPlanTurnInstructionSections(planTurn: ThreadPlanTurnContext): string[] {
   const upstreamHandoffSection = buildUpstreamHandoffSection(planTurn.upstreamHandoffs)
   return (
     mergeInstructionSections(
@@ -100,7 +94,7 @@ export function buildPlanTurnInstructionSections(planTurn: WorkstreamPlanTurnCon
   )
 }
 
-export function buildPlanTurnSubmitToolDescription(planTurn: WorkstreamPlanTurnContext): string {
+export function buildPlanTurnSubmitToolDescription(planTurn: ThreadPlanTurnContext): string {
   const requiredArtifacts =
     planTurn.nodeSpec.deliverables
       .filter((deliverable) => deliverable.required)
@@ -114,11 +108,11 @@ export function buildPlanTurnSubmitToolDescription(planTurn: WorkstreamPlanTurnC
     `Structured output: ${
       planTurn.nodeSpec.outputSchemaRef ? `must satisfy ${planTurn.nodeSpec.outputSchemaRef}` : 'optional'
     }.`,
-    'Do not submit partial results. Include durable handoffContext for downstream nodes.',
+    'Do not submit partial results. notes is required — include a concise summary for downstream nodes.',
   ].join(' ')
 }
 
-export function buildPlanTurnPromptMessage(planTurn: WorkstreamPlanTurnContext): ChatMessage {
+export function buildPlanTurnPromptMessage(planTurn: ThreadPlanTurnContext): ChatMessage {
   return withMessageCreatedAt(
     {
       id: Bun.randomUUIDv7(),

package/src/runtime/{workstream-turn-context.ts → thread-turn-context.ts}

@@ -8,13 +8,13 @@ import type {
   LotaRuntimeWorkspaceProjectionState,
   LotaRuntimeWorkspaceProvider,
 } from './runtime-extensions'
-import { asRecord, readInstructionSections, readOptionalString } from './workstream-chat-helpers'
+import { asRecord, readInstructionSections, readOptionalString } from './thread-chat-helpers'
 
 function readOptionalBoolean(value: unknown): boolean | undefined {
   return typeof value === 'boolean' ? value : undefined
 }
 
-interface AssembledWorkstreamTurnContext {
+interface AssembledThreadTurnContext {
   workspace: Record<string, unknown>
   workspaceLifecycleState: LotaRuntimeWorkspaceLifecycleState | undefined
   workspaceProfileState: LotaRuntimeWorkspaceProjectionState | undefined
@@ -28,9 +28,9 @@ interface AssembledWorkstreamTurnContext {
   hookInstructionSections: string[]
 }
 
-export async function assembleWorkstreamTurnContext(params: {
-  workstream: unknown
-  workstreamRef: RecordIdRef
+export async function assembleThreadTurnContext(params: {
+  thread: unknown
+  threadRef: RecordIdRef
   orgRef: RecordIdRef
   userRef: RecordIdRef
   userName?: string | null
@@ -41,7 +41,7 @@ export async function assembleWorkstreamTurnContext(params: {
   workspaceProvider?: LotaRuntimeWorkspaceProvider
   turnHooks: LotaRuntimeTurnHooks
   onStep?: (name: string) => void
-}): Promise<AssembledWorkstreamTurnContext> {
+}): Promise<AssembledThreadTurnContext> {
   const workspace = await params.workspacePromise
   params.onStep?.('fetch-workspace')
 
@@ -104,8 +104,8 @@ export async function assembleWorkstreamTurnContext(params: {
 
   const buildContextResult = asRecord(
     await params.turnHooks.buildContext?.({
-      workstream: params.workstream,
-      workstreamRef: params.workstreamRef,
+      thread: params.thread,
+      threadRef: params.threadRef,
       orgRef: params.orgRef,
       userRef: params.userRef,
       userName: params.userName,
@@ -144,8 +144,8 @@ export async function assembleWorkstreamTurnContext(params: {
 
   const hookInstructionSections = readInstructionSections(
     await params.turnHooks.buildExtraInstructionSections?.({
-      workstream: params.workstream,
-      workstreamRef: params.workstreamRef,
+      thread: params.thread,
+      threadRef: params.threadRef,
       orgRef: params.orgRef,
       userRef: params.userRef,
       userName: params.userName,