@lota-sdk/core 0.1.13 → 0.1.15

package/src/redis/redis-lease-lock.ts

@@ -3,7 +3,7 @@ import { setTimeout as delay } from 'node:timers/promises'
 
 import type IORedis from 'ioredis'
 
-import { getErrorMessage } from '../utils/error'
+import { getErrorMessage } from '../utils/errors'
 
 interface RedisLeaseLockLogger {
   debug?: (message: string) => void
@@ -95,16 +95,30 @@ async function releaseLeaseLock(options: RedisLeaseLockOptions & { lockValue: st
   await options.redis.eval(RELEASE_LOCK_SCRIPT, 1, options.lockKey, options.lockValue)
 }
 
+export class LeaseLockLostError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'LeaseLockLostError'
+  }
+}
+
 function startLeaseLockRefreshLoop(
   options: Required<Pick<RedisLeaseLockOptions, 'refreshIntervalMs'>> &
     RedisLeaseLockOptions & { lockValue: string; label: string },
+  ac: AbortController,
 ): () => void {
   let stopped = false
 
   const timer = setInterval(() => {
     if (stopped) return
     void refreshLeaseLock(options).catch((error: unknown) => {
-      log(options.logger, 'warn', `Failed to refresh ${options.label} (${options.lockKey}): ${getErrorMessage(error)}`)
+      stopped = true
+      clearInterval(timer)
+      const message = `Failed to refresh ${options.label} (${options.lockKey}): ${getErrorMessage(error)}`
+      log(options.logger, 'warn', message)
+      if (!ac.signal.aborted) {
+        ac.abort(new LeaseLockLostError(message))
+      }
     })
   }, options.refreshIntervalMs)
 
@@ -116,7 +130,10 @@ function startLeaseLockRefreshLoop(
   }
 }
 
-export async function withRedisLeaseLock<T>(options: RedisLeaseLockOptions, fn: () => Promise<T>): Promise<T> {
+export async function withRedisLeaseLock<T>(
+  options: RedisLeaseLockOptions,
+  fn: (signal: AbortSignal) => Promise<T>,
+): Promise<T> {
   const lockKey = options.lockKey.trim()
   if (!lockKey) {
     throw new Error('Redis lease lock requires a non-empty lock key')
@@ -138,17 +155,33 @@ export async function withRedisLeaseLock<T>(options: RedisLeaseLockOptions, fn:
     log(options.logger, 'info', `Acquired ${label} (${lockKey}) after waiting waitedMs=${waitedMs}`)
   }
 
-  const stopRefreshLoop = startLeaseLockRefreshLoop({ ...options, lockKey, lockValue, label, refreshIntervalMs })
+  const ac = new AbortController()
+  const stopRefreshLoop = startLeaseLockRefreshLoop({ ...options, lockKey, lockValue, label, refreshIntervalMs }, ac)
   const holdStart = Date.now()
 
   try {
-    return await fn()
+    const abortPromise = new Promise<never>((_, reject) => {
+      if (ac.signal.aborted) {
+        reject(ac.signal.reason as Error)
+        return
+      }
+      ac.signal.addEventListener(
+        'abort',
+        () => {
+          reject(ac.signal.reason as Error)
+        },
+        { once: true },
+      )
+    })
+    return await Promise.race([fn(ac.signal), abortPromise])
   } finally {
     stopRefreshLoop()
     const heldMs = Date.now() - holdStart
-    await releaseLeaseLock({ ...options, lockKey, lockValue }).catch((error: unknown) => {
-      log(options.logger, 'warn', `Failed to release ${label} (${lockKey}): ${getErrorMessage(error)}`)
-    })
+    if (!ac.signal.aborted) {
+      await releaseLeaseLock({ ...options, lockKey, lockValue }).catch((error: unknown) => {
+        log(options.logger, 'warn', `Failed to release ${label} (${lockKey}): ${getErrorMessage(error)}`)
+      })
+    }
     if (heldMs >= heldInfoThresholdMs) {
       log(options.logger, 'info', `Released ${label} (${lockKey}) heldMs=${heldMs}`)
     } else {

package/src/runtime/agent-stream-helpers.ts

@@ -2,13 +2,14 @@ import type { ChatMessage } from '@lota-sdk/shared'
 import type { LanguageModelUsage, UIMessageStreamOptions } from 'ai'
 
 import { agentDisplayNames, getLeadAgentDisplayName } from '../config/agent-defaults'
+import { readRecord as _readRecord } from '../utils/string'
 
 export function readFiniteNumber(value: unknown): number | undefined {
   return typeof value === 'number' && Number.isFinite(value) ? value : undefined
 }
 
 export function readRecord(value: unknown): Record<string, unknown> | undefined {
-  return value && typeof value === 'object' && !Array.isArray(value) ? (value as Record<string, unknown>) : undefined
+  return _readRecord(value) ?? undefined
 }
 
 export function readOpenRouterUsageCost(usage: LanguageModelUsage): { cost?: number; upstreamInferenceCost?: number } {

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

@@ -7,5 +7,5 @@ export const CONTEXT_COMPACTION_INCLUDED_TOOL_NAMES = ['userQuestions', 'proceed
 export const CONTEXT_COMPACTION_INCLUDED_TOOL_PREFIXES = ['linear'] as const
 export const MEMORY_BLOCK_COMPACTION_TRIGGER_ENTRIES = 15
 export const MEMORY_BLOCK_COMPACTION_CHUNK_ENTRIES = 10
-export const CONTEXT_SIZE = 200_000
+export const CONTEXT_WINDOW_TOKENS = 200_000
 export const WORKSTREAM_RAW_TAIL_MESSAGES = 6

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

@@ -1,4 +1,4 @@
-import { createContextCompacterAgent } from '../system-agents/context-compacter.agent'
+import { createContextCompactionAgent } from '../system-agents/context-compaction.agent'
 import {
   buildContextCompactionPrompt,
   buildMemoryBlockCompactionPrompt,
@@ -18,6 +18,8 @@ import {
 import type { GenerateHelperStructuredParams, GenerateHelperTextParams } from './helper-model'
 import { StructuredCompactionOutputSchema } from './workstream-state'
 
+const CONTEXT_COMPACTION_MAX_OUTPUT_TOKENS = 512
+
 interface HelperModelRuntime {
   generateHelperStructured<T>(params: GenerateHelperStructuredParams<T>): Promise<T>
   generateHelperText(params: GenerateHelperTextParams): Promise<string>
@@ -32,7 +34,7 @@ interface CreateContextCompactionRuntimeDeps {
 async function runContextCompacter(helperModelRuntime: HelperModelRuntime, params: ContextCompactionRunnerParams) {
   const output = await helperModelRuntime.generateHelperStructured({
     tag: 'context-compaction',
-    createAgent: createContextCompacterAgent,
+    createAgent: createContextCompactionAgent,
     messages: [
       {
         role: 'user',
@@ -76,9 +78,9 @@ export function createWiredContextCompactionRuntime(deps: CreateContextCompactio
 
     return await helperModelRuntime.generateHelperText({
       tag: 'memory-block-compaction',
-      createAgent: createContextCompacterAgent,
+      createAgent: createContextCompactionAgent,
       messages: [{ role: 'user', content: buildMemoryBlockCompactionPrompt({ previousSummary, newEntriesText }) }],
-      maxOutputTokens: 512,
+      maxOutputTokens: CONTEXT_COMPACTION_MAX_OUTPUT_TOKENS,
     })
   }
 

package/src/runtime/context-compaction.ts

@@ -2,7 +2,7 @@ import { createHash, randomUUID } from 'node:crypto'
 
 import type { ChatMessage } from '@lota-sdk/shared'
 
-import { readString } from '../utils/string'
+import { CHARS_PER_TOKEN_ESTIMATE, compactWhitespace, readRecord, readString } from '../utils/string'
 import {
   COMPACTION_CHUNK_MAX_CHARS,
   CONTEXT_COMPACTION_INCLUDED_TOOL_NAMES,
@@ -15,14 +15,8 @@ import {
 import {
   StructuredCompactionOutputSchema,
   WorkstreamStateDeltaSchema,
-  WORKSTREAM_STATE_MAX_ACTIVE_CONSTRAINTS,
-  WORKSTREAM_STATE_MAX_AGENT_CONTRIBUTIONS,
-  WORKSTREAM_STATE_MAX_ARTIFACTS,
-  WORKSTREAM_STATE_MAX_KEY_DECISIONS,
-  WORKSTREAM_STATE_MAX_OPEN_QUESTIONS,
-  WORKSTREAM_STATE_MAX_RISKS,
-  WORKSTREAM_STATE_MAX_TASKS,
   WorkstreamStateSchema,
+  applyWorkstreamStateCaps,
   createEmptyWorkstreamState,
   parseStructuredWorkstreamStateDelta,
 } from './workstream-state'
@@ -99,15 +93,11 @@ const PROMPT_INJECTION_PATTERN =
   /\b(ignore (all )?(previous|prior|system|developer)? instructions?|system prompt|developer prompt|tool override|jailbreak|role ?override|do not follow|bypass)\b/i
 
 function estimateTokens(text: string): number {
-  return Math.ceil(text.length / 3)
-}
-
-function normalizeWhitespace(value: string): string {
-  return value.replace(/\s+/g, ' ').trim()
+  return Math.ceil(text.length / CHARS_PER_TOKEN_ESTIMATE)
 }
 
 function sanitizeStateText(value: string): string | null {
-  const normalized = normalizeWhitespace(value)
+  const normalized = compactWhitespace(value)
   if (!normalized) return null
   if (PROMPT_INJECTION_PATTERN.test(normalized)) return null
   return normalized
@@ -116,16 +106,12 @@ function sanitizeStateText(value: string): string | null {
 function createStableId(prefix: string, ...parts: Array<string | number | undefined>): string {
   const payload = parts
     .map((part) => (part === undefined ? '' : String(part)))
-    .map((part) => normalizeWhitespace(part))
+    .map((part) => compactWhitespace(part))
     .join('|')
   const hash = createHash('sha1').update(`${prefix}|${payload}`).digest('hex').slice(0, 20)
   return `${prefix}_${hash}`
 }
 
-function readRecord(value: unknown): Record<string, unknown> | null {
-  return value && typeof value === 'object' && !Array.isArray(value) ? (value as Record<string, unknown>) : null
-}
-
 function stringifyUnknown(value: unknown): string | null {
   if (value === undefined) return null
   if (typeof value === 'string') {
@@ -141,11 +127,11 @@ function stringifyUnknown(value: unknown): string | null {
 }
 
 function appendUnique(values: string[], nextValues: string[]): string[] {
-  const seen = new Set(values.map((value) => normalizeWhitespace(value).toLowerCase()))
+  const seen = new Set(values.map((value) => compactWhitespace(value).toLowerCase()))
   const merged = [...values]
 
   for (const value of nextValues) {
-    const normalized = normalizeWhitespace(value)
+    const normalized = compactWhitespace(value)
     if (!normalized) continue
     const key = normalized.toLowerCase()
     if (seen.has(key)) continue
@@ -395,7 +381,7 @@ export function mergeStateDelta(
       const normalizedRationale = sanitizeStateText(decision.rationale)
       if (!normalizedDecision || !normalizedRationale) continue
 
-      const sourceIds = [...new Set(decision.sourceMessageIds.map((id) => normalizeWhitespace(id)).filter(Boolean))]
+      const sourceIds = [...new Set(decision.sourceMessageIds.map((id) => compactWhitespace(id)).filter(Boolean))]
       const decisionId = createStableId('decision', normalizedDecision, normalizedRationale, sourceIds.sort().join('|'))
       const alreadyExists = state.keyDecisions.some((item) => item.id === decisionId)
       if (alreadyExists) continue
@@ -403,7 +389,7 @@ export function mergeStateDelta(
         id: decisionId,
         decision: normalizedDecision,
         rationale: normalizedRationale,
-        agent: normalizeWhitespace(decision.agent),
+        agent: compactWhitespace(decision.agent),
         sourceMessageIds: sourceIds,
         confidence: decision.confidence,
         timestamp,
@@ -417,11 +403,9 @@ export function mergeStateDelta(
       if (!title) continue
 
       const externalId = sanitizeStateText(update.externalId ?? '')
-      const owner = normalizeWhitespace(update.owner)
+      const owner = compactWhitespace(update.owner)
       const taskId = externalId ? createStableId('task-external', externalId) : createStableId('task', title, owner)
-      const sourceMessageIds = [
-        ...new Set(update.sourceMessageIds.map((id) => normalizeWhitespace(id)).filter(Boolean)),
-      ]
+      const sourceMessageIds = [...new Set(update.sourceMessageIds.map((id) => compactWhitespace(id)).filter(Boolean))]
       const existingIndex = state.tasks.findIndex((task) => task.id === taskId)
       const nextTask = {
         id: taskId,
@@ -455,7 +439,7 @@ export function mergeStateDelta(
       const artifactId = createStableId('artifact', name, pointer)
       const exists = state.artifacts.some((item) => item.id === artifactId)
       if (exists) continue
-      state.artifacts.push({ id: artifactId, name, type: normalizeWhitespace(artifact.type), pointer, timestamp })
+      state.artifacts.push({ id: artifactId, name, type: compactWhitespace(artifact.type), pointer, timestamp })
     }
   }
 
@@ -495,13 +479,7 @@ export function mergeStateDelta(
     state.approvalNote = sanitizeStateText(delta.approvalNote) ?? undefined
   }
 
-  state.keyDecisions = state.keyDecisions.slice(-WORKSTREAM_STATE_MAX_KEY_DECISIONS)
-  state.activeConstraints = state.activeConstraints.slice(-WORKSTREAM_STATE_MAX_ACTIVE_CONSTRAINTS)
-  state.tasks = state.tasks.slice(-WORKSTREAM_STATE_MAX_TASKS)
-  state.openQuestions = state.openQuestions.slice(-WORKSTREAM_STATE_MAX_OPEN_QUESTIONS)
-  state.risks = state.risks.slice(-WORKSTREAM_STATE_MAX_RISKS)
-  state.artifacts = state.artifacts.slice(-WORKSTREAM_STATE_MAX_ARTIFACTS)
-  state.agentContributions = state.agentContributions.slice(-WORKSTREAM_STATE_MAX_AGENT_CONTRIBUTIONS)
+  applyWorkstreamStateCaps(state)
 
   return WorkstreamStateSchema.parse(state)
 }
@@ -727,9 +705,12 @@ export function createContextCompactionRuntime(
     return summaryMessage ? [summaryMessage, ...liveMessages] : [...liveMessages]
   }
 
+  const CONTEXT_OUTPUT_RESERVE_MAX_RATIO = 0.35
+  const CONTEXT_SAFETY_MARGIN_MAX_RATIO = 0.1
+
   const estimateThreshold = (contextSize = 256_000): number => {
-    const reservedOutput = Math.min(outputReserveTokens, Math.floor(contextSize * 0.35))
-    const safetyMargin = Math.min(safetyMarginTokens, Math.floor(contextSize * 0.1))
+    const reservedOutput = Math.min(outputReserveTokens, Math.floor(contextSize * CONTEXT_OUTPUT_RESERVE_MAX_RATIO))
+    const safetyMargin = Math.min(safetyMarginTokens, Math.floor(contextSize * CONTEXT_SAFETY_MARGIN_MAX_RATIO))
     const reservedThreshold = contextSize - (reservedOutput + safetyMargin)
     const ratioThreshold = Math.floor(contextSize * thresholdRatio)
     return Math.max(1_000, Math.min(contextSize - 1, Math.min(reservedThreshold, ratioThreshold)))
@@ -834,7 +815,7 @@ export function createContextCompactionRuntime(
       const contextMessages = messagesToCompact.map(toContextMessageFromChatMessage)
       const sourceText = toCompactionTranscript(contextMessages)
 
-      if (!normalizeWhitespace(sourceText)) {
+      if (!compactWhitespace(sourceText)) {
         const summaryPayload = buildSyntheticSummaryPayload(summaryText)
         const outputPayload = JSON.stringify([...(summaryPayload ? [summaryPayload] : []), ...remainingMessages])
         return {

package/src/runtime/execution-plan.ts

@@ -1,6 +1,6 @@
 import type { SerializableExecutionPlan } from '@lota-sdk/shared'
 
-export const EXECUTION_PLAN_AGENT_PROTOCOL_PROMPT = `<execution-plan-protocol>
+const EXECUTION_PLAN_AGENT_PROTOCOL_PROMPT = `<execution-plan-protocol>
 - Before doing multi-step work, create a contract-driven execution plan instead of tracking steps only in prose.
 - Plans are graph-capable workflow contracts. Every execution node must define objective, instructions, deliverables, success criteria, completion checks, retry policy, failure policy, and tool/context policy.
 - The runtime executor owns lifecycle truth. Do not claim that a node is complete until submitExecutionNodeResult succeeds.
@@ -10,7 +10,7 @@ export const EXECUTION_PLAN_AGENT_PROTOCOL_PROMPT = `<execution-plan-protocol>
 - If the graph, contracts, or success criteria materially change, replace the plan instead of silently drifting.
 </execution-plan-protocol>`
 
-export function formatExecutionPlanForPrompt(plan: SerializableExecutionPlan | null | undefined): string | undefined {
+function formatExecutionPlanForPrompt(plan: SerializableExecutionPlan | null | undefined): string | undefined {
   if (!plan) return undefined
 
   const payload = {

package/src/runtime/helper-model.ts

@@ -7,6 +7,8 @@ import type {
 } from 'ai'
 import type { ZodSchema } from 'zod'
 
+import { compactWhitespace } from '../utils/string'
+
 export interface HelperToolLoopAgentOptions {
   instructions?: string
   maxOutputTokens?: number
@@ -102,7 +104,7 @@ function stringifyUnknown(value: unknown, maxChars: number): string | null {
     }
   })()
 
-  const normalized = raw.replace(/\s+/g, ' ').trim()
+  const normalized = compactWhitespace(raw)
   if (!normalized) return null
   return normalized.length > maxChars ? `${normalized.slice(0, maxChars)}...` : normalized
 }

package/src/runtime/index.ts

@@ -23,4 +23,15 @@ export * from './team-consultation-prompts'
 export * from './turn-lifecycle'
 export * from './workstream-chat-helpers'
 export * from './workstream-routing-policy'
-export * from './workstream-state'
+export {
+  WorkstreamStateSchema,
+  type WorkstreamState,
+  type WorkstreamStateDelta,
+  StructuredWorkstreamStateDeltaSchema,
+  type StructuredWorkstreamStateDelta,
+  createEmptyStructuredWorkstreamStateDelta,
+  parseStructuredWorkstreamStateDelta,
+  StructuredCompactionOutputSchema,
+  type CompactionOutput,
+  createEmptyWorkstreamState,
+} from './workstream-state'

package/src/runtime/memory-block.ts

@@ -1,4 +1,5 @@
 import { agentDisplayNames, agentShortDisplayNames, resolveAgentNameAlias } from '../config/agent-defaults'
+import { compactWhitespace } from '../utils/string'
 
 function escapeRegex(value: string): string {
   return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
@@ -173,8 +174,7 @@ export function createMemoryBlockRuntime(options: CreateMemoryBlockRuntimeOption
       )
       .filter(Boolean)
 
-    const candidate = normalizedLines.join(' ').trim()
-    const collapsed = candidate.replace(/\s+/g, ' ').trim()
+    const collapsed = compactWhitespace(normalizedLines.join(' '))
     if (!collapsed) return ''
     return collapsed
   }
@@ -186,6 +186,7 @@ export function createMemoryBlockRuntime(options: CreateMemoryBlockRuntimeOption
     try {
       const parsed: unknown = JSON.parse(trimmed)
       if (!Array.isArray(parsed)) return []
+      if (!parsed.every((item: unknown) => typeof item === 'object' && item !== null)) return []
       return parsed as MemoryBlockEntry[]
     } catch {
       return []

package/src/runtime/memory-pipeline.ts

@@ -1,3 +1,11 @@
+import { compactWhitespace } from '../utils/string'
+
+const SCORE_WEIGHTS = {
+  durability: { core: 0.35, standard: 0.2, weak: 0.05 },
+  type: { decision: 0.25, preference: 0.18, default: 0.1 },
+  maxContentLength: 120,
+} as const
+
 interface MemoryFactInput {
   content: string
   confidence: number
@@ -117,9 +125,20 @@ function scoreFact<T extends MemoryFactInput>(fact: T): number {
   const durability = fact.durability ?? 'standard'
   const type = fact.type ?? 'fact'
 
-  const durabilityWeight = durability === 'core' ? 0.35 : durability === 'standard' ? 0.2 : 0.05
-  const typeWeight = type === 'decision' ? 0.25 : type === 'fact' ? 0.18 : 0.1
-  const lengthWeight = Math.min(fact.content.length, 120) / 120 / 10
+  const durabilityWeight =
+    durability === 'core'
+      ? SCORE_WEIGHTS.durability.core
+      : durability === 'standard'
+        ? SCORE_WEIGHTS.durability.standard
+        : SCORE_WEIGHTS.durability.weak
+  const typeWeight =
+    type === 'decision'
+      ? SCORE_WEIGHTS.type.decision
+      : type === 'fact'
+        ? SCORE_WEIGHTS.type.preference
+        : SCORE_WEIGHTS.type.default
+  const lengthWeight =
+    Math.min(fact.content.length, SCORE_WEIGHTS.maxContentLength) / SCORE_WEIGHTS.maxContentLength / 10
 
   return confidence + durabilityWeight + typeWeight + lengthWeight
 }
@@ -160,7 +179,7 @@ export function postProcessMemoryFacts<T extends MemoryFactInput>(
   const deduped = new Map<string, T>()
 
   for (const fact of rawFacts) {
-    const content = typeof fact.content === 'string' ? fact.content.replace(/\s+/g, ' ').trim() : ''
+    const content = typeof fact.content === 'string' ? compactWhitespace(fact.content) : ''
     if (!content || content.length < minChars || content.length > maxChars) continue
     const normalizedFact = { ...fact, content }
     const key = normalizeFactForDedupe(content)
@@ -464,7 +483,7 @@ export function createMemoryActionPlan<TRelation extends string = string>(params
   }
 
   for (const [index, item] of params.updates.memory.entries()) {
-    const text = typeof item.text === 'string' ? item.text.replace(/\s+/g, ' ').trim() : ''
+    const text = typeof item.text === 'string' ? compactWhitespace(item.text) : ''
     const itemId = typeof item.id === 'string' ? item.id.trim() : ''
 
     switch (item.event) {

package/src/runtime/plugin-types.ts

@@ -3,7 +3,7 @@ export interface LotaPluginContributions {
   schemaFiles: readonly (string | URL)[]
 }
 
-export interface LotaPlugin<TServices = unknown, TTools = unknown> {
+export interface LotaPlugin<TServices = Record<string, unknown>, TTools = Record<string, unknown>> {
   services: TServices
   tools?: TTools
   contributions: LotaPluginContributions

package/src/runtime/runtime-extensions.ts

@@ -1,7 +1,7 @@
 import type { ToolSet } from 'ai'
 
 import type { RecordIdRef } from '../db/record-id'
-import type { ReadableUploadMetadata } from '../services/attachment.service'
+import type { ReadableUploadMetadata } from '../storage/attachment-types'
 import type { LotaRuntimeWorkerExtensions } from './runtime-worker-registry'
 
 export interface LotaRuntimeBackgroundCursor {
@@ -34,7 +34,7 @@ export interface LotaRuntimeWorkspaceProvider {
   ): Promise<LotaRuntimeWorkspaceLifecycleState> | LotaRuntimeWorkspaceLifecycleState
   readProfileProjectionState?(
     workspace: Record<string, unknown>,
-  ): Promise<LotaRuntimeWorkspaceProjectionState | void> | LotaRuntimeWorkspaceProjectionState | void
+  ): Promise<LotaRuntimeWorkspaceProjectionState | undefined> | LotaRuntimeWorkspaceProjectionState | undefined
   buildPromptSummary?(workspaceId: RecordIdRef): Promise<string | undefined>
   listRecentDomainEvents?(workspaceId: RecordIdRef, limit?: number): Promise<Array<Record<string, unknown>>>
   hasActiveKnowledgeSources?(workspaceId: string): Promise<boolean>
@@ -76,11 +76,87 @@ export interface LotaRuntimeTeamThinkToolsParams {
   toolProviders?: ToolSet
 }
 
+export interface BuildContextParams {
+  workstream: unknown
+  workstreamRef: RecordIdRef
+  orgRef: RecordIdRef
+  userRef: RecordIdRef
+  userName?: string | null
+  workspace: Record<string, unknown>
+  onboardingActive: boolean
+  messageText: string
+  linearInstalled: boolean
+  githubInstalled: boolean
+  indexedRepoContext: unknown
+  promptContext: unknown
+  workspaceLifecycleState: unknown
+  workspaceProfileState: unknown
+  promptSummary: string | undefined
+  recentDomainEvents: Array<Record<string, unknown>>
+  retrievedKnowledgeSection: string | undefined
+  [key: string]: unknown
+}
+
+export interface AfterTurnParams {
+  workstream: unknown
+  workstreamRef: RecordIdRef
+  orgRef: RecordIdRef
+  userRef: RecordIdRef
+  userName?: string | null
+  onboardingActive: boolean
+  referenceUserMessage: unknown
+  assistantMessages: unknown[]
+  latestWorkstreamRecord: unknown
+  latestPersistedState: unknown
+  context: Record<string, unknown> | null
+  [key: string]: unknown
+}
+
+export interface ResolveAgentParams {
+  agentId: string
+  mode: string
+  workstream: unknown
+  workstreamRef: RecordIdRef
+  orgRef: RecordIdRef
+  userRef: RecordIdRef
+  userName?: string | null
+  onboardingActive: boolean
+  linearInstalled: boolean
+  githubInstalled: boolean
+  reasoningProfile: string
+  skills?: string[]
+  additionalInstructionSections?: string[]
+  context: Record<string, unknown> | null
+  [key: string]: unknown
+}
+
+export interface BuildExtraInstructionSectionsParams {
+  workstream: unknown
+  workstreamRef: RecordIdRef
+  orgRef: RecordIdRef
+  userRef: RecordIdRef
+  userName?: string | null
+  workspace: Record<string, unknown>
+  onboardingActive: boolean
+  messageText: string
+  linearInstalled: boolean
+  githubInstalled: boolean
+  indexedRepoContext: unknown
+  promptContext: unknown
+  workspaceLifecycleState: unknown
+  workspaceProfileState: unknown
+  promptSummary: string | undefined
+  recentDomainEvents: Array<Record<string, unknown>>
+  retrievedKnowledgeSection: string | undefined
+  context: Record<string, unknown> | null
+  [key: string]: unknown
+}
+
 export interface LotaRuntimeTurnHooks {
-  buildContext?: (params: Record<string, unknown>) => Promise<Record<string, unknown> | void>
-  afterTurn?: (params: Record<string, unknown>) => Promise<void>
-  resolveAgent?: (params: Record<string, unknown>) => Promise<Record<string, unknown> | void>
-  buildExtraInstructionSections?: (params: Record<string, unknown>) => Promise<string[] | void>
+  buildContext?: (params: BuildContextParams) => Promise<Record<string, unknown> | void>
+  afterTurn?: (params: AfterTurnParams) => Promise<void>
+  resolveAgent?: (params: ResolveAgentParams) => Promise<Record<string, unknown> | void>
+  buildExtraInstructionSections?: (params: BuildExtraInstructionSectionsParams) => Promise<string[] | void>
 }
 
 export interface LotaRuntimeAdapters {
@@ -90,8 +166,8 @@ export interface LotaRuntimeAdapters {
     buildTeamThinkAgentTools?: (params: LotaRuntimeTeamThinkToolsParams) => Promise<{ tools: ToolSet }>
   }
   queues?: {
-    enqueuePostChatOrgAction?: (job: Record<string, unknown>) => Promise<void> | void
-    enqueueOnboardingRepoIndexFollowUp?: (job: Record<string, unknown>) => Promise<void> | void
+    enqueuePostChatOrgAction?: (job: Record<string, unknown>) => Promise<void>
+    enqueueOnboardingRepoIndexFollowUp?: (job: Record<string, unknown>) => Promise<void>
   }
   workers?: {
     connectPluginDatabases?: () => Promise<void>
@@ -115,17 +191,17 @@ let runtimeExtensionsState: RuntimeExtensionsState = {
   extraWorkers: {},
 }
 
-export function configureRuntimeExtensions(params?: {
+export function configureRuntimeExtensions(params: {
   adapters?: LotaRuntimeAdapters
   turnHooks?: LotaRuntimeTurnHooks
   toolProviders?: ToolSet
   extraWorkers?: LotaRuntimeWorkerExtensions
 }): void {
   runtimeExtensionsState = {
-    adapters: params?.adapters ?? {},
-    turnHooks: params?.turnHooks ?? {},
-    toolProviders: params?.toolProviders ?? EMPTY_TOOLS,
-    extraWorkers: params?.extraWorkers ?? {},
+    adapters: params.adapters ?? {},
+    turnHooks: params.turnHooks ?? {},
+    toolProviders: params.toolProviders ?? EMPTY_TOOLS,
+    extraWorkers: params.extraWorkers ?? {},
   }
 }
 

package/src/runtime/title-helpers.ts

@@ -1,12 +1,21 @@
+import { compactWhitespace } from '../utils/string'
+
 const TITLE_WORD_LIMIT = 5
 
 export function limitTitleWords(text: string): string {
-  const words = text.replace(/\s+/g, ' ').trim().split(' ').filter(Boolean)
+  const words = compactWhitespace(text).split(' ').filter(Boolean)
   return words.slice(0, TITLE_WORD_LIMIT).join(' ')
 }
 
 export function deriveTitle(text: string): string {
-  const trimmed = text.replace(/\s+/g, ' ').trim()
+  const trimmed = compactWhitespace(text)
   if (trimmed.length <= 60) return trimmed
   return `${trimmed.slice(0, 57)}...`
 }
+
+export function normalizeTitle(value: string): string {
+  const normalized = compactWhitespace(value)
+    .replace(/^["'`]+|["'`]+$/g, '')
+    .replace(/[.!?,;:]+$/g, '')
+  return normalized.length <= 80 ? normalized : normalized.slice(0, 80).trim()
+}

package/src/runtime/workstream-chat-helpers.ts

@@ -114,14 +114,13 @@ export function collectToolOutputErrors(params: {
     if (typeof part !== 'object') continue
     if (part.type !== undefined && typeof part.type !== 'string') continue
     if (!part.type?.startsWith('tool-')) continue
-    if ((part as Record<string, unknown>).state !== 'output-error') continue
+
+    const p = part as Record<string, unknown>
+    if (p.state !== 'output-error') continue
 
     const toolName = part.type.slice('tool-'.length) || 'unknown'
-    const toolCallId =
-      typeof (part as Record<string, unknown>).toolCallId === 'string' && (part as Record<string, unknown>).toolCallId
-        ? ((part as Record<string, unknown>).toolCallId as string)
-        : 'unknown'
-    const errorTextRaw = (part as Record<string, unknown>).errorText
+    const toolCallId = typeof p.toolCallId === 'string' && p.toolCallId ? p.toolCallId : 'unknown'
+    const errorTextRaw = p.errorText
     const errorText =
       typeof errorTextRaw === 'string' && errorTextRaw.trim()
         ? errorTextRaw.trim()