@lota-sdk/core 0.1.8 → 0.1.9

package/infrastructure/schema/00_workstream.surql

@@ -13,7 +13,7 @@ DEFINE FIELD IF NOT EXISTS updatedAt ON TABLE workstream TYPE datetime VALUE tim
 DEFINE FIELD IF NOT EXISTS memoryBlock ON TABLE workstream TYPE option<string>;
 DEFINE FIELD IF NOT EXISTS memoryBlockSummary ON TABLE workstream TYPE option<string>;
 DEFINE FIELD IF NOT EXISTS activeRunId ON TABLE workstream TYPE option<string>;
-DEFINE FIELD IF NOT EXISTS chatSummary ON TABLE workstream TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS compactionSummary ON TABLE workstream TYPE option<string>;
 DEFINE FIELD IF NOT EXISTS lastCompactedMessageId ON TABLE workstream TYPE option<string>;
 DEFINE FIELD IF NOT EXISTS nameGenerated ON TABLE workstream TYPE bool DEFAULT false;
 DEFINE FIELD IF NOT EXISTS isCompacting ON TABLE workstream TYPE bool DEFAULT false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lota-sdk/core",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/runtime/turn-lifecycle.ts

@@ -2,7 +2,7 @@ import type { ChatMessage } from '@lota-sdk/shared/schemas/chat-message'
 
 export async function finalizeTurnRun(params: {
   serverRunId: string
-  getEntity: () => Promise<{ lastCompactedMessageId?: string | null; chatSummary?: string | null }>
+  getEntity: () => Promise<{ lastCompactedMessageId?: string | null; compactionSummary?: string | null }>
   getUncompactedMessages: (cursor?: string) => Promise<ChatMessage[]>
   assessCompaction: (summaryText: string, messages: ChatMessage[]) => { shouldCompact: boolean }
   enqueueCompaction: () => Promise<void>
@@ -14,7 +14,7 @@ export async function finalizeTurnRun(params: {
     const entity = await params.getEntity()
     const cursor = typeof entity.lastCompactedMessageId === 'string' ? entity.lastCompactedMessageId : undefined
     const uncompactedMessages = await params.getUncompactedMessages(cursor)
-    const summaryText = typeof entity.chatSummary === 'string' ? entity.chatSummary : ''
+    const summaryText = typeof entity.compactionSummary === 'string' ? entity.compactionSummary : ''
     const { shouldCompact } = params.assessCompaction(summaryText, uncompactedMessages)
 
     if (shouldCompact) {

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

@@ -121,14 +121,14 @@ export function buildAgentHistoryMessages(messages: ChatMessageLike[]): Array<{
     .map((message) => ({ content: message.content, ...(message.agentName ? { agentName: message.agentName } : {}) }))
 }
 
-export function appendCompactionContextToHistoryMessages(
+export function appendPersistedWorkstreamContextToHistoryMessages(
   historyMessages: WorkstreamHistoryMessage[],
-  params: { chatSummary?: string | null; persistedState?: unknown },
+  params: { compactionSummary?: string | null; persistedState?: unknown },
 ): WorkstreamHistoryMessage[] {
   const nextHistoryMessages = [...historyMessages]
-  const chatSummary = typeof params.chatSummary === 'string' ? params.chatSummary.trim() : ''
-  if (chatSummary) {
-    nextHistoryMessages.push({ role: 'agent', content: `Compacted chat summary:\n${chatSummary}` })
+  const compactionSummary = typeof params.compactionSummary === 'string' ? params.compactionSummary.trim() : ''
+  if (compactionSummary) {
+    nextHistoryMessages.push({ role: 'agent', content: `Compacted chat summary:\n${compactionSummary}` })
   }
 
   if (params.persistedState !== undefined && params.persistedState !== null) {

package/src/services/context-compaction.service.ts

@@ -61,7 +61,7 @@ class ContextCompactionService {
     )
 
     const result = await contextCompactionRuntime.compactHistory({
-      summaryText: typeof workstream.chatSummary === 'string' ? workstream.chatSummary : '',
+      summaryText: typeof workstream.compactionSummary === 'string' ? workstream.compactionSummary : '',
       liveMessages,
       tailMessageCount: WORKSTREAM_RAW_TAIL_MESSAGES,
       contextSize: params.contextSize,
@@ -82,7 +82,11 @@ class ContextCompactionService {
     await databaseService.update(
       TABLES.WORKSTREAM,
       params.workstreamId,
-      { chatSummary: result.summaryText, lastCompactedMessageId: result.lastCompactedMessageId, state: result.state },
+      {
+        compactionSummary: result.summaryText,
+        lastCompactedMessageId: result.lastCompactedMessageId,
+        state: result.state,
+      },
       WorkstreamSchema,
     )
 

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

@@ -40,7 +40,7 @@ import { hasApprovalRespondedParts } from '../runtime/approval-continuation'
 import { buildModelInputMessagesWithUploadMetadata, buildReadableUploadMetadataText } from '../runtime/chat-attachments'
 import { hasMessageContent } from '../runtime/chat-message'
 import { waitForCompactionIfNeeded } from '../runtime/chat-run-orchestration'
-import { mergeStateDelta, parseWorkstreamState } from '../runtime/context-compaction'
+import { parseWorkstreamState } from '../runtime/context-compaction'
 import { CONTEXT_SIZE } from '../runtime/context-compaction-constants'
 import { createExecutionPlanInstructionSectionCache } from '../runtime/execution-plan'
 import { mergeInstructionSections } from '../runtime/instruction-sections'
@@ -54,13 +54,12 @@ import { getRuntimeAdapters, getToolProviders, getTurnHooks } from '../runtime/r
 import { shouldEnqueueSkillExtraction } from '../runtime/skill-extraction-policy'
 import { finalizeTurnRun } from '../runtime/turn-lifecycle'
 import {
-  appendCompactionContextToHistoryMessages,
+  appendPersistedWorkstreamContextToHistoryMessages,
   buildAgentHistoryMessages,
   buildConversationSummary,
   buildReadableUploadMetadataContext,
   collectToolOutputErrors,
   extractMessageText,
-  extractTrackerMessageText,
   toHistoryMessages,
   toOptionalTrimmedString,
 } from '../runtime/workstream-chat-helpers'
@@ -69,8 +68,7 @@ import {
   classifyPolicyClasses,
   resolveReasoningProfile,
 } from '../runtime/workstream-routing-policy'
-import { WorkstreamStateSchema } from '../runtime/workstream-state'
-import type { WorkstreamState, WorkstreamStateDelta } from '../runtime/workstream-state'
+import type { WorkstreamState } from '../runtime/workstream-state'
 import { chatRunRegistry } from '../services/chat-run-registry.service'
 import type { NormalizedWorkstream, WorkstreamRecord } from '../services/workstream.types'
 import { createTeamThinkTool } from '../tools/team-think.tool'
@@ -84,7 +82,6 @@ import { executionPlanService } from './execution-plan.service'
 import { learnedSkillService } from './learned-skill.service'
 import { memoryService } from './memory.service'
 import { recentActivityService } from './recent-activity.service'
-import { updateWorkstreamChangeTracker } from './workstream-change-tracker.service'
 import { workstreamMessageService } from './workstream-message.service'
 import { workstreamService } from './workstream.service'
 
@@ -143,60 +140,6 @@ export function parsePersistedWorkstreamState(value: unknown): WorkstreamState |
   return parseWorkstreamState(value)
 }
 
-export function extractFirstAbsoluteUrl(text: string): URL | null {
-  const match = text.match(/https?:\/\/[^\s)]+/i)
-  if (!match) return null
-
-  const normalized = match[0].replace(/[.,;!?]+$/g, '')
-  try {
-    return new URL(normalized)
-  } catch {
-    return null
-  }
-}
-
-export function taskRequestsWebsiteRefresh(task: string, forceRefresh: boolean): boolean {
-  return forceRefresh || /\b(refresh|re-run|rerun|run again|extract again|re-extract|overwrite|recrawl)\b/i.test(task)
-}
-
-export function buildInspectWebsiteTrackerTitle(input: unknown): string {
-  if (!input || typeof input !== 'object') return 'Inspect website intelligence'
-
-  const task = typeof (input as { task?: unknown }).task === 'string' ? (input as { task: string }).task.trim() : ''
-  const forceRefresh = (input as { forceRefresh?: unknown }).forceRefresh === true
-  const hostname = extractFirstAbsoluteUrl(task)?.hostname.replace(/^www\./, '') ?? null
-
-  if (hostname && taskRequestsWebsiteRefresh(task, forceRefresh)) {
-    return `Overwrite website-intelligence artifacts for ${hostname}`
-  }
-  if (hostname) {
-    return `Inspect website intelligence for ${hostname}`
-  }
-  return taskRequestsWebsiteRefresh(task, forceRefresh)
-    ? 'Overwrite website-intelligence artifacts'
-    : 'Inspect website intelligence'
-}
-
-export function emitTransientWorkstreamTrackerState(params: {
-  writer?: UIMessageStreamWriter<ChatMessage>
-  workstreamRecord: WorkstreamRecord
-  existingState: WorkstreamState
-  delta: WorkstreamStateDelta
-}): WorkstreamState {
-  const nextState = mergeStateDelta(params.existingState, params.delta, () => Date.now())
-
-  if (params.writer) {
-    params.writer.write({
-      type: 'data-workstreamTracker',
-      data: workstreamService.toPublicWorkstreamDetail({ ...params.workstreamRecord, state: nextState })
-        .workstreamState as unknown as Record<string, unknown>,
-      transient: true,
-    })
-  }
-
-  return nextState
-}
-
 export async function waitForWorkstreamCompactionIfNeeded(workstreamId: RecordIdRef): Promise<WorkstreamRecord> {
   return await waitForCompactionIfNeeded({
     entityId: recordIdToString(workstreamId, TABLES.WORKSTREAM),
@@ -395,9 +338,10 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
 
   const workspacePromise = workspaceProvider ? workspaceProvider.getWorkspace(orgRef) : Promise.resolve({})
   const initialWorkstreamState = parsePersistedWorkstreamState(workstreamRecord.state)
+  const persistedCompactionCursor = toOptionalTrimmedString(workstreamRecord.lastCompactedMessageId) ?? undefined
   const persistedLiveHistoryPromise = workstreamMessageService.listMessagesAfterCursor(
     workstreamRef,
-    toOptionalTrimmedString(workstreamRecord.lastCompactedMessageId) ?? undefined,
+    persistedCompactionCursor,
   )
   const persistedRecentHistoryPromise = workstreamMessageService.listRecentMessages(workstreamRef, 64)
 
@@ -630,9 +574,12 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
     return section
   }
 
-  const persistedChatSummary = typeof workstreamRecord.chatSummary === 'string' ? workstreamRecord.chatSummary : ''
+  const persistedCompactionSummary =
+    persistedCompactionCursor && typeof workstreamRecord.compactionSummary === 'string'
+      ? workstreamRecord.compactionSummary
+      : ''
   const messagesForContext = userMessage ? upsertChatHistoryMessage(liveHistory, userMessage) : liveHistory
-  let currentMessages = contextCompactionRuntime.prependSummaryMessage(persistedChatSummary, messagesForContext)
+  let currentMessages = contextCompactionRuntime.prependSummaryMessage(persistedCompactionSummary, messagesForContext)
   const referenceUserMessageId = referenceUserMessage?.id ?? ''
   const listReadableUploads = (extraMessages: ChatMessage[] = []) =>
     listReadableUploadsFromChatMessages({
@@ -811,8 +758,6 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
               },
             }) as ReadableStream<ChatStreamChunk>
             const reader = uiStream.getReader()
-            let liveTrackerState: WorkstreamState = workstreamState ?? parseWorkstreamState(null)
-            const liveTrackedToolCalls = new Map<string, string>()
             try {
               for (;;) {
                 const { done, value } = await reader.read()
@@ -820,71 +765,6 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
                 if (streamParams.writer) {
                   streamParams.writer.write(value)
                 }
-                if (value.type === 'tool-input-available' && value.toolName === 'inspectWebsite') {
-                  const title = buildInspectWebsiteTrackerTitle(value.input)
-                  liveTrackedToolCalls.set(value.toolCallId, title)
-                  liveTrackerState = emitTransientWorkstreamTrackerState({
-                    writer: streamParams.writer,
-                    workstreamRecord,
-                    existingState: liveTrackerState,
-                    delta: {
-                      taskUpdates: [
-                        {
-                          title,
-                          status: 'in-progress',
-                          owner: streamParams.agentId,
-                          externalId: value.toolCallId,
-                          sourceMessageIds: [],
-                        },
-                      ],
-                    },
-                  })
-                }
-                if (
-                  value.type === 'tool-output-available' &&
-                  value.preliminary !== true &&
-                  liveTrackedToolCalls.has(value.toolCallId)
-                ) {
-                  liveTrackerState = emitTransientWorkstreamTrackerState({
-                    writer: streamParams.writer,
-                    workstreamRecord,
-                    existingState: liveTrackerState,
-                    delta: {
-                      taskUpdates: [
-                        {
-                          title: liveTrackedToolCalls.get(value.toolCallId) ?? 'Inspect website intelligence',
-                          status: 'done',
-                          owner: streamParams.agentId,
-                          externalId: value.toolCallId,
-                          sourceMessageIds: [],
-                        },
-                      ],
-                    },
-                  })
-                  liveTrackedToolCalls.delete(value.toolCallId)
-                }
-                if (
-                  (value.type === 'tool-output-error' || value.type === 'tool-output-denied') &&
-                  liveTrackedToolCalls.has(value.toolCallId)
-                ) {
-                  liveTrackerState = emitTransientWorkstreamTrackerState({
-                    writer: streamParams.writer,
-                    workstreamRecord,
-                    existingState: liveTrackerState,
-                    delta: {
-                      taskUpdates: [
-                        {
-                          title: liveTrackedToolCalls.get(value.toolCallId) ?? 'Inspect website intelligence',
-                          status: 'blocked',
-                          owner: streamParams.agentId,
-                          externalId: value.toolCallId,
-                          sourceMessageIds: [],
-                        },
-                      ],
-                    },
-                  })
-                  liveTrackedToolCalls.delete(value.toolCallId)
-                }
               }
             } finally {
               reader.releaseLock()
@@ -1141,9 +1021,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
         } finally {
           try {
             const latestWorkstreamRecord = await workstreamService.getById(workstreamRef)
-            const latestPersistedState = WorkstreamStateSchema.safeParse(latestWorkstreamRecord.state).success
-              ? WorkstreamStateSchema.parse(latestWorkstreamRecord.state)
-              : null
+            const latestPersistedState = parsePersistedWorkstreamState(latestWorkstreamRecord.state)
 
             await finalizeTurnRun({
               serverRunId,
@@ -1167,58 +1045,12 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
               disposeAbort: () => runAbort.dispose(),
             })
 
-            let trackerAwareWorkstreamRecord = latestWorkstreamRecord
-            let trackerAwarePersistedState = latestPersistedState
-
-            if (!onboardingActive && allAssistantMessages.length > 0) {
-              const activeExecutionPlan = await executionPlanService.getActivePlanForWorkstream(workstreamRef)
-              const trackerUpdated = await updateWorkstreamChangeTracker({
-                workstreamId: workstreamRef,
-                title: latestWorkstreamRecord.title ?? workstream.title,
-                mode: workstream.mode,
-                ...(workstream.coreType ? { coreType: workstream.coreType } : {}),
-                ...(visibleWorkstreamAgentId ? { visibleAgentId: visibleWorkstreamAgentId } : {}),
-                hasActiveExecutionPlan: activeExecutionPlan !== null,
-                previousSummary:
-                  typeof latestWorkstreamRecord.chatSummary === 'string' ? latestWorkstreamRecord.chatSummary : null,
-                existingState: latestPersistedState,
-                userMessageText: referenceUserMessage ? extractMessageText(referenceUserMessage).trim() : null,
-                assistantMessages: allAssistantMessages
-                  .map((message) => {
-                    const text = extractTrackerMessageText(message).trim()
-                    if (!text) return null
-                    const label =
-                      typeof message.metadata?.agentName === 'string' && message.metadata.agentName.trim().length > 0
-                        ? message.metadata.agentName.trim()
-                        : typeof message.metadata?.agentId === 'string' && message.metadata.agentId.trim().length > 0
-                          ? message.metadata.agentId.trim()
-                          : (visibleWorkstreamAgentId ?? 'Assistant')
-                    return { label, text }
-                  })
-                  .filter((message): message is { label: string; text: string } => Boolean(message)),
-              })
-
-              if (trackerUpdated) {
-                const trackedWorkstreamRecord = await workstreamService.getWorkstreamRecord(workstreamRef)
-                trackerAwareWorkstreamRecord = trackedWorkstreamRecord
-                trackerAwarePersistedState = parsePersistedWorkstreamState(trackedWorkstreamRecord.state)
-                if (writer) {
-                  writer.write({
-                    type: 'data-workstreamTracker',
-                    data: workstreamService.toPublicWorkstreamDetail(trackedWorkstreamRecord)
-                      .workstreamState as unknown as Record<string, unknown>,
-                    transient: true,
-                  })
-                }
-              }
-            }
-
             if (allAssistantMessages.length > 0 && shouldProcessPostRunSideEffects) {
               const turnCount = await workstreamService.incrementTurnCount(workstreamRef)
               const agentMessages = buildAgentHistoryMessages(allAssistantMessages)
-              const historyMessagesForMemory = appendCompactionContextToHistoryMessages(
+              const historyMessagesForMemory = appendPersistedWorkstreamContextToHistoryMessages(
                 toHistoryMessages(recentHistory),
-                { chatSummary: trackerAwareWorkstreamRecord.chatSummary, persistedState: trackerAwarePersistedState },
+                { compactionSummary: latestWorkstreamRecord.compactionSummary, persistedState: latestPersistedState },
               )
 
               const userMessageText = referenceUserMessage ? extractMessageText(referenceUserMessage).trim() : ''
@@ -1283,7 +1115,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
                         agentId: visibleWorkstreamAgentId ?? 'chief',
                         agentName: agentDisplayNames[visibleWorkstreamAgentId ?? 'chief'],
                         workstreamId: workstreamIdString,
-                        workstreamTitle: trackerAwareWorkstreamRecord.title ?? workstream.title,
+                        workstreamTitle: latestWorkstreamRecord.title ?? workstream.title,
                         workstreamMode: workstream.mode,
                         ...(workstream.coreType ? { coreType: workstream.coreType } : {}),
                         userMessageText,
@@ -1350,8 +1182,8 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
                 onboardingActive,
                 referenceUserMessage,
                 assistantMessages: allAssistantMessages,
-                latestWorkstreamRecord: trackerAwareWorkstreamRecord,
-                latestPersistedState: trackerAwarePersistedState,
+                latestWorkstreamRecord,
+                latestPersistedState,
                 context: buildContextResult,
               })
             }

package/src/services/workstream.service.ts

@@ -20,23 +20,12 @@ import {
   parseMemoryBlock,
   serializeMemoryBlock,
 } from '../runtime/memory-block'
-import { toOptionalTrimmedString } from '../runtime/workstream-chat-helpers'
-import { WorkstreamStateSchema } from '../runtime/workstream-state'
-import type { WorkstreamState } from '../runtime/workstream-state'
 import { toIsoDateTimeString } from '../utils/date-time'
 import { chatRunRegistry } from './chat-run-registry.service'
 import { contextCompactionService } from './context-compaction.service'
 import { workstreamMessageService } from './workstream-message.service'
 import { WorkstreamSchema, WorkstreamStatusSchema } from './workstream.types'
-import type {
-  NormalizedWorkstream,
-  PublicWorkstreamApprovalState,
-  PublicWorkstreamDetail,
-  PublicWorkstreamStateFocus,
-  PublicWorkstreamStatePayload,
-  PublicWorkstreamStateProgress,
-  WorkstreamRecord,
-} from './workstream.types'
+import type { NormalizedWorkstream, WorkstreamRecord } from './workstream.types'
 
 // Uses SurrealQL directly to keep pagination/order logic close to queries.
 
@@ -146,155 +135,6 @@ function buildCoreWorkstreamId({
   return new RecordId(TABLES.WORKSTREAM, `core_${typeValue}_user_${userValue}_organization_${orgValue}`)
 }
 
-function toOptionalIsoDateTimeString(value: number | null | undefined): string | null {
-  if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0) return null
-  return toIsoDateTimeString(new Date(value))
-}
-
-function getCompactedSummaryFocus(chatSummary: string | null): string | null {
-  if (!chatSummary) return null
-
-  const lines = chatSummary
-    .split('\n')
-    .map((line) => line.trim())
-    .filter(Boolean)
-
-  for (const line of lines) {
-    if (line.endsWith(':')) continue
-    if (line.startsWith('- ')) {
-      return toOptionalTrimmedString(line.slice(2))
-    }
-    return toOptionalTrimmedString(line)
-  }
-
-  return null
-}
-
-function parsePersistedWorkstreamState(value: unknown): WorkstreamState | null {
-  const parsed = WorkstreamStateSchema.safeParse(value)
-  return parsed.success ? parsed.data : null
-}
-
-function buildEmptyWorkstreamStateProgress(): PublicWorkstreamStateProgress {
-  return {
-    hasState: false,
-    lastUpdated: null,
-    completionRatio: null,
-    tasks: { total: 0, open: 0, inProgress: 0, done: 0, blocked: 0 },
-    constraints: { total: 0, approved: 0, candidate: 0 },
-    keyDecisions: 0,
-    openQuestions: 0,
-    risks: 0,
-    artifacts: 0,
-    agentContributions: 0,
-  }
-}
-
-function buildWorkstreamStateProgress(state: WorkstreamState | null): PublicWorkstreamStateProgress {
-  if (!state) {
-    return buildEmptyWorkstreamStateProgress()
-  }
-
-  const tasks = {
-    total: state.tasks.length,
-    open: state.tasks.filter((task) => task.status === 'open').length,
-    inProgress: state.tasks.filter((task) => task.status === 'in-progress').length,
-    done: state.tasks.filter((task) => task.status === 'done').length,
-    blocked: state.tasks.filter((task) => task.status === 'blocked').length,
-  }
-  const constraintsApproved = state.activeConstraints.filter((constraint) => constraint.approved).length
-
-  return {
-    hasState:
-      state.currentPlan !== null ||
-      state.activeConstraints.length > 0 ||
-      state.keyDecisions.length > 0 ||
-      state.tasks.length > 0 ||
-      state.openQuestions.length > 0 ||
-      state.risks.length > 0 ||
-      state.artifacts.length > 0 ||
-      state.agentContributions.length > 0 ||
-      toOptionalTrimmedString(state.approvedBy) !== null ||
-      typeof state.approvedAt === 'number' ||
-      toOptionalTrimmedString(state.approvalMessageId) !== null ||
-      toOptionalTrimmedString(state.approvalNote) !== null,
-    lastUpdated: toOptionalIsoDateTimeString(state.lastUpdated),
-    completionRatio: tasks.total > 0 ? Number((tasks.done / tasks.total).toFixed(4)) : null,
-    tasks,
-    constraints: {
-      total: state.activeConstraints.length,
-      approved: constraintsApproved,
-      candidate: state.activeConstraints.length - constraintsApproved,
-    },
-    keyDecisions: state.keyDecisions.length,
-    openQuestions: state.openQuestions.length,
-    risks: state.risks.length,
-    artifacts: state.artifacts.length,
-    agentContributions: state.agentContributions.length,
-  }
-}
-
-function buildWorkstreamApprovalState(state: WorkstreamState | null): PublicWorkstreamApprovalState | null {
-  if (!state) return null
-
-  const approvedBy = toOptionalTrimmedString(state.approvedBy)
-  const approvedAt = toOptionalIsoDateTimeString(state.approvedAt)
-  const approvalMessageId = toOptionalTrimmedString(state.approvalMessageId)
-  const approvalNote = toOptionalTrimmedString(state.approvalNote)
-
-  if (!approvedBy && !approvedAt && !approvalMessageId && !approvalNote) {
-    return null
-  }
-
-  return { approvedBy, approvedAt, approvalMessageId, approvalNote }
-}
-
-function buildWorkstreamStateFocus(
-  state: WorkstreamState | null,
-  chatSummary: string | null,
-): PublicWorkstreamStateFocus | null {
-  if (!state) {
-    const compactedSummaryFocus = getCompactedSummaryFocus(chatSummary)
-    return compactedSummaryFocus ? { kind: 'chat-summary', text: compactedSummaryFocus } : null
-  }
-
-  const currentPlan = toOptionalTrimmedString(state.currentPlan?.text)
-  if (currentPlan) {
-    return { kind: 'plan', text: currentPlan }
-  }
-
-  const latestTask =
-    [...state.tasks].reverse().find((task) => task.status === 'blocked') ??
-    [...state.tasks].reverse().find((task) => task.status === 'in-progress') ??
-    [...state.tasks].reverse().find((task) => task.status === 'open')
-  const taskTitle = toOptionalTrimmedString(latestTask?.title)
-  if (taskTitle) {
-    return { kind: 'task', text: taskTitle }
-  }
-
-  const latestQuestion = toOptionalTrimmedString(state.openQuestions.at(-1)?.text)
-  if (latestQuestion) {
-    return { kind: 'question', text: latestQuestion }
-  }
-
-  const latestDecision = toOptionalTrimmedString(state.keyDecisions.at(-1)?.decision)
-  if (latestDecision) {
-    return { kind: 'decision', text: latestDecision }
-  }
-
-  const latestAgentNote = toOptionalTrimmedString(state.agentContributions.at(-1)?.summary)
-  if (latestAgentNote) {
-    return { kind: 'agent-note', text: latestAgentNote }
-  }
-
-  const compactedSummaryFocus = getCompactedSummaryFocus(chatSummary)
-  if (compactedSummaryFocus) {
-    return { kind: 'chat-summary', text: compactedSummaryFocus }
-  }
-
-  return null
-}
-
 class WorkstreamService extends BaseService<typeof WorkstreamSchema> {
   constructor() {
     super(TABLES.WORKSTREAM, WorkstreamSchema)
@@ -664,14 +504,6 @@ class WorkstreamService extends BaseService<typeof WorkstreamSchema> {
     await this.setActiveRunId(workstreamId, null)
   }
 
-  async persistChangeTracker(
-    workstreamId: RecordIdRef,
-    payload: { chatSummary: string; state: WorkstreamState },
-  ): Promise<void> {
-    const workstreamRef = ensureRecordId(workstreamId, TABLES.WORKSTREAM)
-    await this.update(workstreamRef, { chatSummary: payload.chatSummary, state: payload.state })
-  }
-
   async stopActiveRun(workstreamId: RecordIdRef): Promise<boolean> {
     const activeRunId = await this.getActiveRunId(workstreamId)
     if (!activeRunId) return false
@@ -868,22 +700,6 @@ class WorkstreamService extends BaseService<typeof WorkstreamSchema> {
     }
   }
 
-  toPublicWorkstreamDetail(workstream: WorkstreamRecord): PublicWorkstreamDetail {
-    const publicWorkstream = this.toPublicWorkstream(workstream)
-    const snapshot = parsePersistedWorkstreamState(workstream.state)
-    const chatSummary = toOptionalTrimmedString(workstream.chatSummary)
-    const progress = buildWorkstreamStateProgress(snapshot)
-    const workstreamState: PublicWorkstreamStatePayload = {
-      focus: buildWorkstreamStateFocus(snapshot, chatSummary),
-      chatSummary,
-      approval: buildWorkstreamApprovalState(snapshot),
-      progress,
-      snapshot,
-    }
-
-    return { ...publicWorkstream, workstreamState }
-  }
-
   async incrementTurnCount(workstreamId: RecordIdRef): Promise<number> {
     const workstreamRef = ensureRecordId(workstreamId, TABLES.WORKSTREAM)
     const result = await databaseService.query<{ turnCount: number }>(surql`

package/src/services/workstream.types.ts

@@ -1,7 +1,5 @@
 import { z } from 'zod'
 
-import type { WorkstreamState } from '../runtime/workstream-state'
-
 export interface Citation {
   title?: string
   url?: string
@@ -33,68 +31,6 @@ export interface NormalizedWorkstream {
   organizationId: string
 }
 
-export interface PublicWorkstreamStateFocus {
-  kind: 'plan' | 'task' | 'question' | 'decision' | 'agent-note' | 'chat-summary'
-  text: string
-}
-
-export interface PublicWorkstreamTaskProgress {
-  total: number
-  open: number
-  inProgress: number
-  done: number
-  blocked: number
-}
-
-export interface PublicWorkstreamConstraintProgress {
-  total: number
-  approved: number
-  candidate: number
-}
-
-export interface PublicWorkstreamStateProgress {
-  hasState: boolean
-  lastUpdated: string | null
-  completionRatio: number | null
-  tasks: PublicWorkstreamTaskProgress
-  constraints: PublicWorkstreamConstraintProgress
-  keyDecisions: number
-  openQuestions: number
-  risks: number
-  artifacts: number
-  agentContributions: number
-}
-
-export interface PublicWorkstreamApprovalState {
-  approvedBy: string | null
-  approvedAt: string | null
-  approvalMessageId: string | null
-  approvalNote: string | null
-}
-
-export interface PublicWorkstreamStatePayload {
-  focus: PublicWorkstreamStateFocus | null
-  chatSummary: string | null
-  approval: PublicWorkstreamApprovalState | null
-  progress: PublicWorkstreamStateProgress
-  snapshot: WorkstreamState | null
-}
-
-export interface PublicWorkstreamDetail {
-  id: string
-  title: string
-  status: 'regular' | 'archived'
-  mode: 'direct' | 'group'
-  core: boolean
-  coreType?: string
-  isRunning: boolean
-  isCompacting: boolean
-  agentId?: string | null
-  createdAt: string
-  updatedAt: string
-  workstreamState: PublicWorkstreamStatePayload
-}
-
 export const WorkstreamSchema = z.object({
   id: z.any(), // RecordId
   mode: WorkstreamModeSchema.optional().default('group'),
@@ -106,7 +42,7 @@ export const WorkstreamSchema = z.object({
   memoryBlock: z.string().nullish(),
   memoryBlockSummary: z.string().nullish(),
   activeRunId: z.string().nullish(),
-  chatSummary: z.string().nullish(),
+  compactionSummary: z.string().nullish(),
   lastCompactedMessageId: z.string().nullish(),
   nameGenerated: z.boolean().optional().default(false),
   isCompacting: z.boolean().optional(),

package/src/services/workstream-change-tracker.service.ts

@@ -1,313 +0,0 @@
-import { z } from 'zod'
-
-import { aiLogger } from '../config/logger'
-import type { RecordIdRef } from '../db/record-id'
-import { mergeStateDelta } from '../runtime/context-compaction'
-import { createHelperModelRuntime, extractJsonObjectCandidates } from '../runtime/helper-model'
-import { toOptionalTrimmedString } from '../runtime/workstream-chat-helpers'
-import {
-  StructuredWorkstreamStateDeltaSchema,
-  createEmptyStructuredWorkstreamStateDelta,
-  createEmptyWorkstreamState,
-  parseStructuredWorkstreamStateDelta,
-} from '../runtime/workstream-state'
-import type { WorkstreamState, WorkstreamStateDelta } from '../runtime/workstream-state'
-import { createWorkstreamTrackerAgent } from '../system-agents/workstream-tracker.agent'
-import { compactWhitespace, isRecord, truncateText } from '../utils/string'
-import { workstreamService } from './workstream.service'
-
-const helperModelRuntime = createHelperModelRuntime()
-
-const TrackerOutputSchema = z.object({
-  summary: z.string().trim().min(1).max(1_200),
-  stateDelta: StructuredWorkstreamStateDeltaSchema,
-})
-
-type TrackerMessage = { label: string; text: string }
-
-const TRACKER_JSON_WRAPPER_KEYS = ['output', 'result', 'data'] as const
-const TRACKER_SUMMARY_KEYS = ['summary', 'chatSummary', 'summaryText', 'sidebarSummary', 'message'] as const
-const TRACKER_STATE_DELTA_KEYS = ['stateDelta', 'delta', 'workstreamStateDelta', 'trackerStateDelta', 'state'] as const
-const TRACKER_FALLBACK_SECTION_PREFIX =
-  /^(?:#{1,6}\s*)?(?:\*\*)?(?:state delta|current plan|new decisions|resolved questions|new questions|new constraints|new risks|task updates|artifacts|agent note|conflicts|approved by|approved at|approval message id|approval note)(?:\*\*)?\s*:?\s*/i
-
-function renderMessages(messages: TrackerMessage[]): string {
-  if (messages.length === 0) return '- None'
-  return messages
-    .map((message, index) => `### Message ${index + 1}\n- Actor: ${message.label}\n- Content: ${message.text}`)
-    .join('\n\n')
-}
-
-function getRecordStringField(record: Record<string, unknown>, keys: readonly string[]): string | null {
-  for (const key of keys) {
-    const field = toOptionalTrimmedString(typeof record[key] === 'string' ? record[key] : null)
-    if (field) return field
-  }
-
-  return null
-}
-
-function getTrackerJsonObjects(value: unknown): Record<string, unknown>[] {
-  if (!isRecord(value)) return []
-
-  const candidates: Record<string, unknown>[] = [value]
-  for (const key of TRACKER_JSON_WRAPPER_KEYS) {
-    const nested = value[key]
-    if (isRecord(nested)) {
-      candidates.push(nested)
-    }
-  }
-
-  return candidates
-}
-
-function parseTrackerJsonFallback(text: string): z.infer<typeof TrackerOutputSchema> | null {
-  for (const candidateText of extractJsonObjectCandidates(text)) {
-    let parsedJson: unknown
-
-    try {
-      parsedJson = JSON.parse(candidateText) as unknown
-    } catch {
-      continue
-    }
-
-    for (const candidate of getTrackerJsonObjects(parsedJson)) {
-      const summary = getRecordStringField(candidate, TRACKER_SUMMARY_KEYS)
-      if (!summary) continue
-
-      const stateDeltaValue = TRACKER_STATE_DELTA_KEYS.map((key) => candidate[key]).find((value) => value !== undefined)
-      const parsedStateDelta = StructuredWorkstreamStateDeltaSchema.safeParse(stateDeltaValue)
-
-      return {
-        summary: truncateText(summary, 1_200),
-        stateDelta: parsedStateDelta.success ? parsedStateDelta.data : createEmptyStructuredWorkstreamStateDelta(),
-      }
-    }
-  }
-
-  return null
-}
-
-function extractTrackerFallbackSummary(text: string): string | null {
-  const normalized = text.replace(/\r/g, '').trim()
-  if (!normalized) return null
-
-  const summaryLineMatch = normalized.match(/(?:^|\n)(?:#{1,6}\s*)?(?:\*\*)?summary(?:\*\*)?\s*:?\s*(.+?)(?=\n|$)/i)
-  const summaryLine = summaryLineMatch?.[1]?.trim()
-  if (summaryLine && !summaryLine.startsWith('{') && !summaryLine.startsWith('```')) {
-    return truncateText(summaryLine, 1_200)
-  }
-
-  const summarySectionMatch = normalized.match(
-    /(?:^|\n)(?:#{1,6}\s*)?(?:\*\*)?summary(?:\*\*)?\s*:?\s*\n([\s\S]*?)(?=\n(?:#{1,6}\s*)?(?:\*\*)?(?:state delta|summary)(?:\*\*)?\s*:?\s*\n|$)/i,
-  )
-  const summarySource = summarySectionMatch?.[1]?.trim() || normalized
-  const paragraphs = summarySource
-    .split(/\n\s*\n/)
-    .map((paragraph) => paragraph.trim())
-    .filter((paragraph) => paragraph.length > 0)
-
-  for (const paragraph of paragraphs) {
-    const candidate = paragraph.replace(/^(?:#{1,6}\s*)?(?:\*\*)?summary(?:\*\*)?\s*:?\s*/i, '').trim()
-    if (
-      !candidate ||
-      candidate.startsWith('{') ||
-      candidate.startsWith('```') ||
-      TRACKER_FALLBACK_SECTION_PREFIX.test(candidate)
-    ) {
-      continue
-    }
-
-    return truncateText(candidate, 1_200)
-  }
-
-  return null
-}
-
-export function parseTrackerTextFallback(text: string): z.infer<typeof TrackerOutputSchema> | null {
-  const jsonFallback = parseTrackerJsonFallback(text)
-  if (jsonFallback) {
-    return jsonFallback
-  }
-
-  const summary = extractTrackerFallbackSummary(text)
-  if (!summary) return null
-
-  return { summary, stateDelta: createEmptyStructuredWorkstreamStateDelta() }
-}
-
-function extractHeuristicSummaryCandidate(text: string | null | undefined): string | null {
-  const normalized = compactWhitespace(toOptionalTrimmedString(text) ?? '')
-  if (!normalized) return null
-
-  const match = /^(.+?[.!?])(?:\s|$)/.exec(normalized)
-  const candidate = match ? String(match[1]) : normalized
-  return truncateText(candidate, 1_200)
-}
-
-export function buildHeuristicTrackerSummary(params: {
-  previousSummary: string | null
-  userMessageText: string | null
-  assistantMessages: TrackerMessage[]
-}): string | null {
-  for (const message of params.assistantMessages) {
-    const summary = extractHeuristicSummaryCandidate(message.text)
-    if (summary) {
-      return summary
-    }
-  }
-
-  const userSummary = extractHeuristicSummaryCandidate(params.userMessageText)
-  if (userSummary) {
-    return truncateText(`User request: ${userSummary}`, 1_200)
-  }
-
-  return extractHeuristicSummaryCandidate(params.previousSummary)
-}
-
-function formatTrackerPrompt(params: {
-  title: string
-  mode: 'direct' | 'group'
-  coreType?: string
-  visibleAgentId?: string
-  hasActiveExecutionPlan: boolean
-  previousSummary: string | null
-  existingState: WorkstreamState
-  userMessageText: string | null
-  assistantMessages: TrackerMessage[]
-}): string {
-  return [
-    '# Workstream Turn',
-    '',
-    `- Title: ${params.title}`,
-    `- Mode: ${params.mode}`,
-    `- Visible agent: ${params.visibleAgentId ?? 'none'}`,
-    `- Active execution plan: ${params.hasActiveExecutionPlan ? 'yes' : 'no'}`,
-    ...(params.coreType ? [`- Core type: ${params.coreType}`] : []),
-    '',
-    '## Previous Summary',
-    params.previousSummary ?? 'None',
-    '',
-    '## Existing State',
-    JSON.stringify(params.existingState),
-    '',
-    '## User Message',
-    params.userMessageText ?? 'None',
-    '',
-    '## Assistant Messages',
-    renderMessages(params.assistantMessages),
-    ...(params.hasActiveExecutionPlan
-      ? [
-          '',
-          '## Tracker Constraint',
-          'An active execution plan exists. Do not update currentPlan or taskUpdates. Track only decisions, questions, risks, artifacts, approvals, and agent notes.',
-        ]
-      : []),
-  ].join('\n')
-}
-
-export function applyTrackedStateDelta(params: {
-  existingState: WorkstreamState
-  delta: WorkstreamStateDelta
-  hasActiveExecutionPlan: boolean
-  now: () => number
-}): WorkstreamState {
-  const mergedState = mergeStateDelta(params.existingState, params.delta, params.now)
-  if (!params.hasActiveExecutionPlan) {
-    return mergedState
-  }
-
-  return { ...mergedState, currentPlan: null, tasks: [] }
-}
-
-export async function updateWorkstreamChangeTracker(params: {
-  workstreamId: RecordIdRef
-  title: string
-  mode: 'direct' | 'group'
-  coreType?: string
-  visibleAgentId?: string
-  hasActiveExecutionPlan: boolean
-  previousSummary: string | null
-  existingState: WorkstreamState | null
-  userMessageText: string | null
-  assistantMessages: TrackerMessage[]
-}): Promise<boolean> {
-  const assistantMessages = params.assistantMessages
-    .map((message) => ({
-      label: toOptionalTrimmedString(message.label) ?? 'Assistant',
-      text: truncateText(message.text.trim(), 2_400),
-    }))
-    .filter((message) => message.text.length > 0)
-    .slice(0, 6)
-
-  if (!toOptionalTrimmedString(params.userMessageText) && assistantMessages.length === 0) {
-    return false
-  }
-
-  const existingState = params.existingState ?? createEmptyWorkstreamState()
-
-  try {
-    const output = await helperModelRuntime.generateHelperStructured({
-      tag: 'workstream-change-tracker',
-      createAgent: createWorkstreamTrackerAgent,
-      schema: TrackerOutputSchema,
-      maxOutputTokens: 1_400,
-      textFallbackParser: parseTrackerTextFallback,
-      messages: [
-        {
-          role: 'user',
-          content: formatTrackerPrompt({
-            title: params.title,
-            mode: params.mode,
-            ...(params.coreType ? { coreType: params.coreType } : {}),
-            ...(params.visibleAgentId ? { visibleAgentId: params.visibleAgentId } : {}),
-            hasActiveExecutionPlan: params.hasActiveExecutionPlan,
-            previousSummary: params.previousSummary,
-            existingState,
-            userMessageText: toOptionalTrimmedString(params.userMessageText),
-            assistantMessages,
-          }),
-        },
-      ],
-    })
-
-    const sparseStateDelta = parseStructuredWorkstreamStateDelta(output.stateDelta)
-    const nextState = applyTrackedStateDelta({
-      existingState,
-      delta: sparseStateDelta,
-      hasActiveExecutionPlan: params.hasActiveExecutionPlan,
-      now: () => Date.now(),
-    })
-    await workstreamService.persistChangeTracker(params.workstreamId, { chatSummary: output.summary, state: nextState })
-    return true
-  } catch (error) {
-    const fallbackSummary = buildHeuristicTrackerSummary({
-      previousSummary: params.previousSummary,
-      userMessageText: toOptionalTrimmedString(params.userMessageText),
-      assistantMessages,
-    })
-
-    if (!fallbackSummary) {
-      aiLogger.warn`Workstream change tracker update failed: ${error}`
-      return false
-    }
-
-    try {
-      const nextState = applyTrackedStateDelta({
-        existingState,
-        delta: {},
-        hasActiveExecutionPlan: params.hasActiveExecutionPlan,
-        now: () => Date.now(),
-      })
-      await workstreamService.persistChangeTracker(params.workstreamId, {
-        chatSummary: fallbackSummary,
-        state: nextState,
-      })
-      aiLogger.info`Workstream change tracker used heuristic fallback after helper failure`
-      return true
-    } catch (persistError) {
-      aiLogger.warn`Workstream change tracker update failed: ${error}; fallback_persist=${persistError}`
-      return false
-    }
-  }
-}

package/src/system-agents/workstream-tracker.agent.ts

@@ -1,58 +0,0 @@
-import { ToolLoopAgent } from 'ai'
-
-import { bifrostOpenRouterResponseHealingModel } from '../bifrost/bifrost'
-import {
-  OPENROUTER_LOW_REASONING_PROVIDER_OPTIONS,
-  OPENROUTER_STRUCTURED_REASONING_MODEL_ID,
-} from '../config/model-constants'
-import type { CreateHelperToolLoopAgentOptions } from '../runtime/agent-types'
-import { resolveHelperAgentOptions } from './helper-agent-options'
-
-const WORKSTREAM_TRACKER_PROMPT = `<agent-instructions>
-You are the **Workstream Tracker**.
-
-<task>
-Convert one completed workstream turn into:
-- a concise change-tracker summary for the right sidebar
-- a structured workstream state delta containing only the updates implied by this turn
-</task>
-
-<rules>
-- Use only the provided turn evidence and prior state.
-- Keep the summary short, concrete, and focused on what changed or what is blocked now.
-- Prefer durable tracker items over prose: tasks, decisions, questions, risks, artifacts, and agent notes.
-- Do not duplicate existing state unless this turn meaningfully changed it.
-- Never invent analytics, repository facts, customer signals, or business decisions that were not stated.
-</rules>
-
-<state-guidance>
-- Use taskUpdates for concrete next steps, ongoing work, completed work, or blocked work.
-- When the turn includes concrete tool work or operational execution, capture that work as taskUpdates even if it was
-  completed in the same turn.
-- For website inspection or plugin refresh flows, prefer task titles that describe the executed step clearly, such as
-  refreshing website intelligence, overwriting artifacts, or reviewing evidence gaps.
-- If an owner is not explicit, default the task owner to the visible lead agent for the workstream.
-- Use newDecisions only when a clear decision or tradeoff was made.
-- Use newQuestions only for unresolved questions that matter for progress.
-- Use newRisks only for concrete execution or business risks surfaced in this turn.
-- Use agentNote for the main contribution from the lead agent when it is worth retaining.
-- Keep the delta compact. A noisy tracker is worse than a sparse tracker.
-</state-guidance>
-
-<output>
-The caller enforces a structured schema.
-- Return every stateDelta field.
-- Use empty arrays for unchanged list fields.
-- Use null for unchanged nullable fields.
-- For currentPlan, use \`{"action":"unchanged","text":null}\` when nothing changed, \`{"action":"clear","text":null}\` to clear it, and \`{"action":"set","text":"..."}\` to replace it.
-</output>
-</agent-instructions>`
-
-export function createWorkstreamTrackerAgent(options: CreateHelperToolLoopAgentOptions) {
-  return new ToolLoopAgent({
-    id: 'workstream-tracker',
-    model: bifrostOpenRouterResponseHealingModel(OPENROUTER_STRUCTURED_REASONING_MODEL_ID),
-    providerOptions: OPENROUTER_LOW_REASONING_PROVIDER_OPTIONS,
-    ...resolveHelperAgentOptions(options, { instructions: WORKSTREAM_TRACKER_PROMPT }),
-  })
-}