@lota-sdk/core 0.1.15 → 0.1.17

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

@@ -0,0 +1,105 @@
+import type { OwnershipDispatchContext, PlanNodeResult, PlanNodeSpec, SystemPlanNodeOwner } from '@lota-sdk/shared'
+
+import type { SystemNodeExecutor, PluginNodeExecutionParams } from '../runtime/plugin-types'
+import { getRuntimeConfig } from '../runtime/runtime-config'
+import type { PlanValidationIssueInput } from './plan-validator.service'
+
+const BUILT_IN_SYSTEM_EXECUTORS = Object.freeze({
+  'plan-runtime': {
+    supportedOperations: ['echo-input'],
+    async executeNode(params: PluginNodeExecutionParams): Promise<PlanNodeResult> {
+      return { structuredOutput: structuredClone(params.inputs), artifacts: [] }
+    },
+  } satisfies SystemNodeExecutor,
+})
+
+export function getBuiltInSystemExecutors(): Record<string, SystemNodeExecutor> {
+  return Object.fromEntries(Object.entries(BUILT_IN_SYSTEM_EXECUTORS))
+}
+
+function getSystemExecutors() {
+  return (getRuntimeConfig().systemExecutors ?? getBuiltInSystemExecutors()) as Record<
+    string,
+    SystemNodeExecutor | undefined
+  >
+}
+
+function buildSystemExecutionParams(params: {
+  owner: SystemPlanNodeOwner
+  nodeSpec: PlanNodeSpec
+  resolvedInput: Record<string, unknown>
+  context: OwnershipDispatchContext
+}): PluginNodeExecutionParams {
+  return {
+    operation: params.owner.operation,
+    nodeSpec: params.nodeSpec,
+    inputs: params.resolvedInput,
+    context: {
+      organizationId: params.context.organizationId,
+      workstreamId: params.context.workstreamId,
+      planId: params.context.planId,
+      nodeId: params.context.nodeId,
+      ...(params.context.userId ? { userId: params.context.userId } : {}),
+      ...(params.context.userName ? { userName: params.context.userName } : {}),
+    },
+  }
+}
+
+class SystemExecutorService {
+  validateOwner(owner: SystemPlanNodeOwner, nodeId: string): PlanValidationIssueInput[] {
+    const executor = getSystemExecutors()[owner.ref]
+    if (!executor) {
+      return [
+        {
+          severity: 'blocking',
+          code: 'system_executor_missing',
+          message: `Node "${nodeId}" references unknown system executor "${owner.ref}".`,
+          nodeId,
+          detail: { systemRef: owner.ref },
+        },
+      ]
+    }
+
+    if (!executor.supportedOperations.includes(owner.operation)) {
+      return [
+        {
+          severity: 'blocking',
+          code: 'system_operation_missing',
+          message: `System executor "${owner.ref}" does not support operation "${owner.operation}".`,
+          nodeId,
+          detail: { systemRef: owner.ref, operation: owner.operation },
+        },
+      ]
+    }
+
+    return []
+  }
+
+  async executeNode(params: {
+    nodeSpec: PlanNodeSpec
+    resolvedInput: Record<string, unknown>
+    context: OwnershipDispatchContext
+  }): Promise<PlanNodeResult> {
+    if (params.nodeSpec.owner.executorType !== 'system') {
+      throw new Error(`SystemExecutor cannot execute owner type "${params.nodeSpec.owner.executorType}".`)
+    }
+
+    const executor = getSystemExecutors()[params.nodeSpec.owner.ref]
+    if (!executor || !executor.supportedOperations.includes(params.nodeSpec.owner.operation)) {
+      throw new Error(
+        `System executor ${params.nodeSpec.owner.ref}.${params.nodeSpec.owner.operation} is not registered.`,
+      )
+    }
+
+    return executor.executeNode(
+      buildSystemExecutionParams({
+        owner: params.nodeSpec.owner,
+        nodeSpec: params.nodeSpec,
+        resolvedInput: params.resolvedInput,
+        context: params.context,
+      }),
+    )
+  }
+}
+
+export const systemExecutorService = new SystemExecutorService()

package/src/services/workstream-message.service.ts

@@ -1,6 +1,4 @@
-import { createHash } from 'node:crypto'
-
-import { parseRowMetadata, toTimestamp, withCreatedAtMetadata } from '@lota-sdk/shared'
+import { parseRowMetadata, recordIdSchema, requireTimestamp, withCreatedAtMetadata } from '@lota-sdk/shared'
 import type { ChatMessage } from '@lota-sdk/shared'
 import { RecordId, surql } from 'surrealdb'
 import { z } from 'zod'
@@ -12,24 +10,10 @@ import { recordIdToString } from '../db/record-id'
 import type { RecordIdRef } from '../db/record-id'
 import { databaseService } from '../db/service'
 import { TABLES } from '../db/tables'
+import { WorkstreamMessageRowSchema } from '../db/workstream-message-row'
+import type { WorkstreamMessageRow } from '../db/workstream-message-row'
 
-const WorkstreamMessageRowSchema = z.object({
-  id: z.unknown(),
-  workstreamId: z.unknown(),
-  messageId: z.string(),
-  role: z.enum(['system', 'user', 'assistant']),
-  parts: z.array(z.record(z.string(), z.unknown())).optional(),
-  metadata: z.record(z.string(), z.unknown()).nullish(),
-  createdAt: z.union([z.date(), z.string(), z.number()]),
-  updatedAt: z.union([z.date(), z.string(), z.number()]).optional(),
-})
-
-type WorkstreamMessageRow = z.infer<typeof WorkstreamMessageRowSchema>
-
-const WorkstreamMessageExistingRowSchema = z.object({
-  id: z.unknown(),
-  createdAt: z.union([z.date(), z.string(), z.number()]),
-})
+const WorkstreamMessageExistingRowSchema = z.object({ id: recordIdSchema, createdAt: z.coerce.date() })
 
 function toMessageId(value: string | RecordIdRef): string {
   return recordIdToString(value, TABLES.WORKSTREAM_MESSAGE)
@@ -44,15 +28,15 @@ function toMessageId(value: string | RecordIdRef): string {
  */
 function toWorkstreamMessageRowId(workstreamId: RecordIdRef, messageId: string): RecordId {
   const workstreamStr = recordIdToString(workstreamId, TABLES.WORKSTREAM)
-  const digest = createHash('sha256').update(`${workstreamStr}\0${messageId}`).digest('hex').slice(0, 32)
+  const digest = new Bun.CryptoHasher('sha256').update(`${workstreamStr}\0${messageId}`).digest('hex').slice(0, 32)
   return new RecordId(TABLES.WORKSTREAM_MESSAGE, digest)
 }
 
 function toChatMessage(row: WorkstreamMessageRow): ChatMessage {
-  const rowCreatedAt = toTimestamp(row.createdAt) ?? Date.now()
+  const rowCreatedAt = requireTimestamp(row.createdAt)
   const metadata = withCreatedAtMetadata(parseRowMetadata(row.metadata), rowCreatedAt)
 
-  return { id: row.messageId, role: row.role, parts: (row.parts ?? []) as ChatMessage['parts'], metadata }
+  return { id: row.messageId, role: row.role, parts: row.parts as ChatMessage['parts'], metadata }
 }
 
 const workstreamPaginationConfig: CursorPaginationConfig = {
@@ -102,9 +86,7 @@ class WorkstreamMessageService {
         WorkstreamMessageExistingRowSchema,
       )
       const persistedCreatedAt =
-        existingRow === null
-          ? (toTimestamp(message.metadata?.createdAt) ?? Date.now())
-          : (toTimestamp(existingRow.createdAt) ?? Date.now())
+        existingRow === null ? requireTimestamp(message.metadata?.createdAt) : requireTimestamp(existingRow.createdAt)
       const metadata = withCreatedAtMetadata({ ...message.metadata, createdAt: persistedCreatedAt })
 
       await databaseService.upsert(
@@ -116,9 +98,7 @@ class WorkstreamMessageService {
           role,
           parts,
           metadata,
-          createdAt: existingRow
-            ? new Date(toTimestamp(existingRow.createdAt) ?? Date.now())
-            : new Date(persistedCreatedAt),
+          createdAt: existingRow ? existingRow.createdAt : new Date(persistedCreatedAt),
         },
         WorkstreamMessageRowSchema,
         { mutation: 'content' },
@@ -152,7 +132,7 @@ class WorkstreamMessageService {
   async listMessagesAfterCursor(workstreamId: RecordIdRef, afterMessageId?: string): Promise<ChatMessage[]> {
     const cursorMessageId = afterMessageId?.trim()
     if (!cursorMessageId) {
-      return await this.listMessages(workstreamId)
+      return this.listMessages(workstreamId)
     }
 
     const cursorRow = await databaseService.findOne(
@@ -165,7 +145,7 @@ class WorkstreamMessageService {
       throw new Error(`Workstream cursor message not found: ${cursorMessageId}`)
     }
 
-    const cursorCreatedAt = new Date(toTimestamp(cursorRow.createdAt) ?? Date.now())
+    const cursorCreatedAt = cursorRow.createdAt
     const cursorId = toWorkstreamMessageRowId(workstreamId, cursorMessageId)
     const rows = await databaseService.query<unknown>(surql`
       SELECT * FROM workstreamMessage
@@ -209,7 +189,7 @@ class WorkstreamMessageService {
       .map((message) => ({
         id: message.id,
         role: message.role as 'user' | 'assistant',
-        createdAt: new Date(toTimestamp(message.metadata?.createdAt) ?? Date.now()).toISOString(),
+        createdAt: new Date(requireTimestamp(message.metadata?.createdAt)).toISOString(),
         content: message.parts
           .flatMap((part) => (part.type === 'text' && typeof part.text === 'string' ? [part.text] : []))
           .join('\n')
@@ -245,7 +225,7 @@ class WorkstreamMessageService {
       id: toMessageId(params.messageId),
       role: 'assistant',
       parts: params.parts,
-      metadata: withCreatedAtMetadata(params.metadata),
+      metadata: withCreatedAtMetadata(params.metadata, Date.now()),
     }
 
     await this.upsertMessages({ workstreamId: params.workstreamId, messages: [message] })
@@ -283,10 +263,6 @@ class WorkstreamMessageService {
       ],
     })
   }
-
-  async listAllMessages(workstreamId: RecordIdRef): Promise<ChatMessage[]> {
-    return await this.listMessages(workstreamId)
-  }
 }
 
 export const workstreamMessageService = new WorkstreamMessageService()

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

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

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

@@ -10,6 +10,8 @@ import {
 } from '../system-agents/title-generator.agent'
 import { workstreamService } from './workstream.service'
 
+const WORKSTREAM_TITLE_TIMEOUT_MS = 5_000
+
 class WorkstreamTitleService {
   helperRuntime = createHelperModelRuntime()
 
@@ -21,7 +23,7 @@ class WorkstreamTitleService {
           tag: 'workstream-title',
           createAgent: createWorkstreamTitleGeneratorAgent,
           defaultSystemPrompt: WORKSTREAM_TITLE_GENERATOR_PROMPT,
-          timeoutMs: 30_000,
+          timeoutMs: WORKSTREAM_TITLE_TIMEOUT_MS,
           messages: [{ role: 'user', content: sourceText }],
         }),
       )

package/src/services/workstream-turn-preparation.service.ts

@@ -1,4 +1,5 @@
 import {
+  WORKSTREAM,
   baseChatMessageSchema,
   CONSULT_SPECIALIST_TOOL_NAME,
   CONSULT_TEAM_TOOL_NAME,
@@ -10,7 +11,7 @@ import {
 } from '@lota-sdk/shared'
 import type { ChatMessage, MessageMetadata } from '@lota-sdk/shared'
 import { convertToModelMessages, readUIMessageStream, stepCountIs, tool as createTool, validateUIMessages } from 'ai'
-import type { PrepareStepFunction, StopCondition, ToolSet, UIMessageStreamWriter } from 'ai'
+import type { PrepareStepFunction, StopCondition, ToolLoopAgent, ToolSet, UIMessageStreamWriter } from 'ai'
 import type { z } from 'zod'
 
 import type { CoreWorkstreamProfile } from '../config/agent-defaults'
@@ -21,7 +22,6 @@ import {
   getLeadAgentId,
   getCoreWorkstreamProfile,
   getAgentRuntimeConfig,
-  pluginRuntime,
 } from '../config/agent-defaults'
 import { lotaDebugLogger } from '../config/debug-logger'
 import { aiLogger } from '../config/logger'
@@ -55,6 +55,7 @@ import {
   shouldEnqueueOnboardingPostChatMemory,
   shouldEnqueueRegularDigestForWorkstream,
 } from '../runtime/memory-digest-policy'
+import { buildIndexedRepositoriesContext, getPluginService } from '../runtime/plugin-resolution'
 import { getRuntimeAdapters, getToolProviders, getTurnHooks } from '../runtime/runtime-extensions'
 import { shouldEnqueueSkillExtraction } from '../runtime/skill-extraction-policy'
 import { finalizeTurnRun } from '../runtime/turn-lifecycle'
@@ -68,11 +69,6 @@ import {
   toHistoryMessages,
   toOptionalTrimmedString,
 } from '../runtime/workstream-chat-helpers'
-import {
-  classifyHighImpactResponse,
-  classifyPolicyClasses,
-  resolveReasoningProfile,
-} from '../runtime/workstream-routing-policy'
 import type { WorkstreamState } from '../runtime/workstream-state'
 import { chatRunRegistry } from '../services/chat-run-registry.service'
 import type { NormalizedWorkstream, WorkstreamRecord } from '../services/workstream.types'
@@ -86,12 +82,11 @@ import { contextCompactionRuntime } from './context-compaction-runtime.singleton
 import { executionPlanService } from './execution-plan.service'
 import { learnedSkillService } from './learned-skill.service'
 import { memoryService } from './memory.service'
+import { planRunService } from './plan-run.service'
 import { recentActivityService } from './recent-activity.service'
 import { workstreamMessageService } from './workstream-message.service'
 import { workstreamService } from './workstream.service'
 
-type AgentRuntimeConfig = Record<string, unknown>
-type AgentFactory = Record<string, (...args: unknown[]) => Record<string, (...args: unknown[]) => unknown>>
 type ChatStreamChunk = Parameters<UIMessageStreamWriter<ChatMessage>['write']>[0]
 
 interface UIMessageStreamResult {
@@ -106,45 +101,8 @@ function hasUIMessageStream(value: unknown): value is UIMessageStreamResult {
   )
 }
 
-function getPluginService(path: string[]): ((...args: unknown[]) => unknown) | undefined {
-  let current: unknown = pluginRuntime
-  let owner: unknown = undefined
-  for (const key of path) {
-    if (current === null || current === undefined || typeof current !== 'object') return undefined
-    owner = current
-    current = (current as Record<string, unknown>)[key]
-  }
-  if (typeof current !== 'function') {
-    return undefined
-  }
-
-  return owner && typeof owner === 'object'
-    ? (current as (...args: unknown[]) => unknown).bind(owner)
-    : (current as (...args: unknown[]) => unknown)
-}
-
-async function buildIndexedRepositoriesContext(
-  workspaceId: string,
-): Promise<{ provideRepoTool: boolean; defaultSectionsByAgent: Record<string, unknown>; context: string }> {
-  const buildContext = getRuntimeAdapters().workstream?.buildIndexedRepositoriesContext
-  if (!buildContext) {
-    return { provideRepoTool: false, defaultSectionsByAgent: {}, context: '' }
-  }
-
-  const context = await buildContext(workspaceId)
-  return {
-    provideRepoTool: context.provideRepoTool,
-    defaultSectionsByAgent: context.defaultSectionsByAgent,
-    context: context.context ?? '',
-  }
-}
-
 const PRESEEDED_MEMORY_LOOKUP_LIMIT = 3
 
-function parsePersistedWorkstreamState(value: unknown): WorkstreamState | null {
-  return parseWorkstreamState(value)
-}
-
 function stripExecutionPlanFieldsFromWorkstreamState(
   state: WorkstreamState | null | undefined,
   hasExecutionPlan: boolean,
@@ -155,7 +113,7 @@ function stripExecutionPlanFieldsFromWorkstreamState(
 }
 
 async function waitForWorkstreamCompactionIfNeeded(workstreamId: RecordIdRef): Promise<WorkstreamRecord> {
-  return await waitForCompactionIfNeeded({
+  return waitForCompactionIfNeeded({
     entityId: recordIdToString(workstreamId, TABLES.WORKSTREAM),
     entityLabel: 'Workstream',
     loadEntity: () => workstreamService.getById(workstreamId),
@@ -311,7 +269,6 @@ interface StreamAgentResponseContext {
   onboardingActive: boolean
   linearInstalled: boolean
   githubInstalled: boolean
-  reasoningProfileName: string
   buildContextResult: Record<string, unknown> | null
   getExecutionPlanInstructionSections: () => Promise<string[] | undefined>
   getPreSeededMemoriesSection: (agentId: string) => Promise<string | undefined>
@@ -361,7 +318,6 @@ async function streamAgentResponse(
       onboardingActive: ctx.onboardingActive,
       linearInstalled: ctx.linearInstalled,
       githubInstalled: ctx.githubInstalled,
-      reasoningProfile: ctx.reasoningProfileName,
       skills: streamParams.skills,
       additionalInstructionSections: streamParams.additionalInstructionSections,
       context: ctx.buildContextResult,
@@ -382,7 +338,6 @@ async function streamAgentResponse(
     skills: streamParams.skills,
     onboardingActive: ctx.onboardingActive,
     linearInstalled: ctx.linearInstalled,
-    reasoningProfile: ctx.reasoningProfileName,
     systemWorkspaceDetails: ctx.promptContext.systemWorkspaceDetails,
     preSeededMemoriesSection,
     retrievedKnowledgeSection: ctx.retrievedKnowledgeSection,
@@ -397,18 +352,18 @@ async function streamAgentResponse(
       optionalInstructionSection(agentResolution?.extraInstructions),
     ),
     context: ctx.buildContextResult,
-  }) as AgentRuntimeConfig
+  }) as Record<string, unknown>
   agentTimer.step('build-agent-config')
   const modelMessages = await convertToModelMessages(streamParams.messages, { ignoreIncompleteToolCalls: true })
   agentTimer.step('convert-model-messages')
-  const agent = (createAgent as unknown as AgentFactory)[config.id as string]({
+  const agent = createAgent[config.id as string]({
     mode: streamParams.mode,
     tools: streamParams.tools,
     extraInstructions: config.extraInstructions,
     stopWhen: (agentResolution?.stopWhen as StopCondition<ToolSet> | Array<StopCondition<ToolSet>> | undefined) ??
       streamParams.stopWhen ?? [stepCountIs(config.maxSteps as number)],
     prepareStep: (agentResolution?.prepareStep as PrepareStepFunction<ToolSet> | undefined) ?? streamParams.prepareStep,
-  })
+  }) as ToolLoopAgent<never, ToolSet>
   const agentAbortSignal = streamParams.abortSignal ?? ctx.runAbortSignal
   agentTimer.step('agent-construction')
 
@@ -443,7 +398,7 @@ async function streamAgentResponse(
     sendSources: true,
     messageMetadata: createAgentMessageMetadata({ agentId: resolvedAgentId, agentName: config.displayName as string }),
     onFinish: ({ responseMessage: finishedResponseMessage }: { responseMessage: ChatMessage }) => {
-      responseMessage = withMessageCreatedAt(finishedResponseMessage)
+      responseMessage = withMessageCreatedAt(finishedResponseMessage, Date.now())
       resolveFinishedStream()
     },
   }) as ReadableStream<ChatStreamChunk>
@@ -474,7 +429,7 @@ async function streamAgentResponse(
   }
 
   for (const toolError of collectToolOutputErrors({ responseMessage: responseMessage })) {
-    aiLogger.warn`Tool execution failed (agent=${resolvedAgentId}, tool=${toolError.toolName}, toolCallId=${toolError.toolCallId}): ${toolError.errorText}`
+    aiLogger.error`Tool execution failed (agent=${resolvedAgentId}, tool=${toolError.toolName}, toolCallId=${toolError.toolCallId}): ${toolError.errorText}`
   }
 
   return responseMessage
@@ -657,7 +612,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
   const shouldProcessPostRunSideEffects =
     params.kind === 'approvalContinuation' || params.kind === 'nativeToolApprovalTurn' || shouldPersistInputMessage
   if (params.kind === 'userTurn') {
-    inputMessage = hydrateMessageFileUrls(withMessageCreatedAt(params.inputMessage))
+    inputMessage = hydrateMessageFileUrls(withMessageCreatedAt(params.inputMessage, Date.now()))
     if (inputMessage.role !== 'user') {
       throw new WorkstreamTurnError('Only user messages can be submitted to the workstream runtime.', 400)
     }
@@ -691,7 +646,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
     timer.step('persist-approval-message')
   }
 
-  const initialWorkstreamState = parsePersistedWorkstreamState(workstreamRecord.state)
+  const initialWorkstreamState = parseWorkstreamState(workstreamRecord.state)
   const persistedCompactionCursor = toOptionalTrimmedString(workstreamRecord.lastCompactedMessageId) ?? undefined
   const persistedLiveHistoryPromise = workstreamMessageService.listMessagesAfterCursor(
     workstreamRef,
@@ -703,10 +658,10 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
   if (inputMessage) {
     userMessage = {
       ...inputMessage,
-      id: inputMessage.id || Bun.randomUUIDv7(),
+      id: inputMessage.id,
       role: 'user',
       parts: inputMessage.parts,
-      metadata: { ...inputMessage.metadata, createdAt: toTimestamp(inputMessage.metadata?.createdAt) ?? Date.now() },
+      metadata: { ...inputMessage.metadata, createdAt: toTimestamp(inputMessage.metadata?.createdAt) },
     }
   }
 
@@ -758,6 +713,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
     workstream.mode === 'group' &&
     !workstream.core &&
     workstreamRecord.nameGenerated !== true &&
+    workstreamRecord.title === WORKSTREAM.DEFAULT_TITLE &&
     messageText.length > 0
   ) {
     void safeEnqueue(
@@ -789,15 +745,6 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
     'getInstallationForOrganization',
   ])
 
-  const highImpactAssessment = classifyHighImpactResponse({ message: messageText })
-  const policyAssessment = classifyPolicyClasses({ message: messageText })
-  const reasoningProfile = resolveReasoningProfile({
-    message: messageText,
-    forceDeep: highImpactAssessment.classes.length > 0 || policyAssessment.classes.length > 0,
-    explicitProfile: onboardingActive ? 'standard' : undefined,
-  })
-  timer.step('reasoning-classification')
-
   const [linearInstallation, githubInstallation, indexedRepoContext, recentDomainEvents, promptSummary] =
     await Promise.all([
       getLinearInstallationByOrgId ? (getLinearInstallationByOrgId(orgRef) as Promise<unknown>) : Promise.resolve(null),
@@ -896,18 +843,21 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
   let workstreamState = initialWorkstreamState
   const executionPlanInstructionSectionCache = createExecutionPlanInstructionSectionCache({
     disabled: onboardingActive,
-    loadPlan: async () => await executionPlanService.getActivePlanForWorkstream(workstreamRef),
+    loadPlans: async () => {
+      const runs = await planRunService.getActiveRunRecords(workstreamRef)
+      return Promise.all(runs.map((run) => planRunService.toSerializablePlan(run)))
+    },
   })
-  const getExecutionPlan = async () => await executionPlanInstructionSectionCache.getPlan()
+  const getExecutionPlans = async () => await executionPlanInstructionSectionCache.getPlans()
   const getExecutionPlanInstructionSections = async (): Promise<string[] | undefined> =>
     await executionPlanInstructionSectionCache.getSections()
   const invalidateExecutionPlanInstructionSections = () => {
     executionPlanInstructionSectionCache.invalidate()
   }
   const getWorkstreamStateSection = async (): Promise<string | undefined> => {
-    const executionPlan = await getExecutionPlan()
+    const executionPlans = await getExecutionPlans()
     return contextCompactionRuntime.formatWorkstreamStateForPrompt(
-      stripExecutionPlanFieldsFromWorkstreamState(workstreamState, Boolean(executionPlan)),
+      stripExecutionPlanFieldsFromWorkstreamState(workstreamState, executionPlans.length > 0),
     )
   }
   const respondedBy = recordIdToString(userRef, TABLES.USER)
@@ -1001,9 +951,6 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
           const buildAgentMetadataPatch = (agentId: string, agentName: string): NonNullable<MessageMetadata> => ({
             agentId,
             agentName,
-            reasoningProfile: reasoningProfile.name,
-            highImpactClasses: highImpactAssessment.classes,
-            policyClasses: policyAssessment.classes,
             semanticTerminationReason: 'none',
           })
 
@@ -1018,10 +965,10 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
           })
 
           const commitAssistantResponse = async (response: ChatMessage, agentId: string, agentName: string) => {
-            const committed = withMessageCreatedAt({
-              ...response,
-              metadata: { ...response.metadata, ...buildAgentMetadataPatch(agentId, agentName) },
-            })
+            const committed = withMessageCreatedAt(
+              { ...response, metadata: { ...response.metadata, ...buildAgentMetadataPatch(agentId, agentName) } },
+              Date.now(),
+            )
 
             await workstreamMessageService.upsertMessages({ workstreamId: workstreamRef, messages: [committed] })
             currentMessages = upsertChatHistoryMessage(currentMessages, committed)
@@ -1040,7 +987,6 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
             onboardingActive,
             linearInstalled,
             githubInstalled,
-            reasoningProfileName: reasoningProfile.name,
             buildContextResult,
             getExecutionPlanInstructionSections,
             getPreSeededMemoriesSection,
@@ -1063,6 +1009,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
           }): Promise<ChatMessage> => {
             const visibleTimer = lotaDebugLogger.timer(`visible:${runParams.agentId}`)
             let runMemoryBlock = memoryBlock
+            const includeExecutionPlanTools = runParams.mode !== 'fixedWorkstreamMode' && !onboardingActive
             const tools: ToolSet = {
               ...((await buildAgentTools({
                 agentId: runParams.agentId,
@@ -1084,7 +1031,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
                   runMemoryBlock = value
                 },
                 availableUploads: listReadableUploads(runParams.extraMessages),
-                includeExecutionPlanTools: runParams.mode !== 'fixedWorkstreamMode',
+                includeExecutionPlanTools,
                 onExecutionPlanChanged: invalidateExecutionPlanInstructionSections,
                 context: buildContextResult,
               })) as ToolSet),
@@ -1107,7 +1054,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
             visibleTimer.step('stream-agent-response')
             memoryBlock = runMemoryBlock
 
-            return await commitAssistantResponse(
+            return commitAssistantResponse(
               responseMessage,
               runParams.agentId,
               agentDisplayNames[runParams.agentId] ?? runParams.agentId,
@@ -1169,7 +1116,6 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
                 mode: 'fixedWorkstreamMode',
                 onboardingActive,
                 linearInstalled,
-                reasoningProfile: reasoningProfile.name,
                 systemWorkspaceDetails: promptContext.systemWorkspaceDetails,
                 preSeededMemoriesSection: specialistPreSeededMemories,
                 retrievedKnowledgeSection,
@@ -1182,14 +1128,14 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
                   hookInstructionSections,
                 ),
                 context: buildContextResult,
-              }) as AgentRuntimeConfig
+              }) as Record<string, unknown>
               const observer = createObserver(agentId)
-              const agent = (createAgent as unknown as AgentFactory)[specialistConfig.id as string]({
+              const agent = createAgent[specialistConfig.id as string]({
                 mode: 'fixedWorkstreamMode',
                 tools: { ...(specialistTools as ToolSet), ...toolProviders },
                 extraInstructions: specialistConfig.extraInstructions,
                 stopWhen: [stepCountIs(specialistConfig.maxSteps as number)],
-              })
+              }) as ToolLoopAgent<never, ToolSet>
               const modelMessages = await convertToModelMessages(buildRunInputMessages([specialistTaskMessage]), {
                 ignoreIncompleteToolCalls: true,
               })
@@ -1225,7 +1171,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
                   }),
                 }) as ReadableStream<never>,
               })) {
-                finalMessage = withMessageCreatedAt(message)
+                finalMessage = withMessageCreatedAt(message, Date.now())
                 yield finalMessage
               }
 
@@ -1266,7 +1212,6 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
                   availableUploads: listReadableUploads(),
                   provideRepoTool: indexedRepoContext.provideRepoTool,
                   defaultRepoSectionsByAgent: indexedRepoContext.defaultSectionsByAgent as never,
-                  reasoningProfile: reasoningProfile.name,
                   systemWorkspaceDetails: promptContext.systemWorkspaceDetails,
                   getPreSeededMemoriesSection,
                   retrievedKnowledgeSection,
@@ -1301,7 +1246,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
         } finally {
           try {
             const latestWorkstreamRecord = await workstreamService.getById(workstreamRef)
-            const latestPersistedState = parsePersistedWorkstreamState(latestWorkstreamRecord.state)
+            const latestPersistedState = parseWorkstreamState(latestWorkstreamRecord.state)
 
             await finalizeTurnRun({
               serverRunId,