@lota-sdk/core 0.1.46 → 0.1.47

package/src/runtime/context-compaction.ts

@@ -1,4 +1,5 @@
 import type { ChatMessage } from '@lota-sdk/shared'
+import { z } from 'zod'
 
 import { CHARS_PER_TOKEN_ESTIMATE, compactWhitespace, readRecord, readString, stringifyUnknown } from '../utils/string'
 import {
@@ -12,15 +13,6 @@ import {
   CONTEXT_SAFETY_MARGIN_TOKENS,
   SUMMARY_ROLLUP_MAX_TOKENS,
 } from './context-compaction-constants'
-import {
-  StructuredCompactionOutputSchema,
-  WorkstreamStateDeltaSchema,
-  WorkstreamStateSchema,
-  applyWorkstreamStateCaps,
-  createEmptyWorkstreamState,
-  parseStructuredWorkstreamStateDelta,
-} from './workstream-state'
-import type { CompactionOutput, WorkstreamState, WorkstreamStateDelta } from './workstream-state'
 
 export interface ContextMessage {
   role: 'system' | 'user' | 'assistant'
@@ -39,7 +31,6 @@ export interface CompactHistoryParams {
   liveMessages: ChatMessage[]
   tailMessageCount: number
   contextSize?: number
-  existingState: WorkstreamState
 }
 
 export interface CompactHistoryResult {
@@ -52,20 +43,16 @@ export interface CompactHistoryResult {
   estimatedTokens: number
   inputChars: number
   outputChars: number
-  state: WorkstreamState
-  stateDelta: WorkstreamStateDelta
 }
 
 export interface ContextCompactionRunnerParams {
   previousSummary: string
-  existingState: WorkstreamState
   chunk: ContextMessage[]
   transcript: string
 }
 
 export interface ContextCompactionPromptParams {
   previousSummary: string
-  existingState: WorkstreamState
   transcript: string
 }
 
@@ -74,6 +61,12 @@ export interface MemoryBlockCompactionPromptParams {
   newEntriesText: string
 }
 
+export const ContextCompactionOutputSchema = z.object({ summary: z.string().trim().min(1) })
+
+export interface CompactionOutput {
+  summary: string
+}
+
 export type ContextCompactionRunner = (params: ContextCompactionRunnerParams) => Promise<CompactionOutput>
 
 export interface CreateContextCompactionRuntimeOptions {
@@ -89,155 +82,30 @@ export interface CreateContextCompactionRuntimeOptions {
   includedToolPrefixes?: readonly string[]
 }
 
-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
+export interface ContextCompactionRuntime {
+  createSummaryMessage: (summaryText: string) => ChatMessage | null
+  prependSummaryMessage: (summaryText: string, liveMessages: ChatMessage[]) => ChatMessage[]
+  estimateThreshold: (contextSize?: number) => number
+  shouldCompactHistory: (params: {
+    summaryText: string
+    liveMessages: ChatMessage[]
+    contextSize?: number
+  }) => CompactionAssessment
+  compactHistory: (params: CompactHistoryParams) => Promise<CompactHistoryResult>
+}
 
 function estimateTokens(text: string): number {
   return Math.ceil(text.length / CHARS_PER_TOKEN_ESTIMATE)
 }
 
-function sanitizeStateText(value: string | null | undefined): string | null {
-  if (typeof value !== 'string') return null
-  const normalized = compactWhitespace(value)
-  if (!normalized) return null
-  if (PROMPT_INJECTION_PATTERN.test(normalized)) return null
-  return normalized
-}
-
-function sanitizeAndMapStateField<T, U>(items: T[], mapItem: (item: T) => U | null): U[] {
-  return items.map(mapItem).filter((item): item is U => item !== null)
-}
-
-function sanitizeStateStrings(values: Array<string | null | undefined>): string[] {
-  return values.map((value) => sanitizeStateText(value)).filter((value): value is string => Boolean(value))
-}
-
-function sanitizeTextFieldItems<T extends Record<string, unknown>, K extends keyof T>(items: T[], textField: K): T[] {
-  return sanitizeAndMapStateField(items, (item) => {
-    const text = sanitizeStateText(item[textField] as string | null | undefined)
-    if (!text) return null
-    return { ...item, [textField]: text }
-  })
-}
-
-function buildExistingWorkstreamStateForCompactionPrompt(state: WorkstreamState): Record<string, unknown> {
-  const currentPlanText = state.currentPlan ? sanitizeStateText(state.currentPlan.text) : null
-
-  const activeConstraints = sanitizeAndMapStateField(state.activeConstraints, (constraint) => {
-    const text = sanitizeStateText(constraint.text)
-    if (!text) return null
-    return {
-      id: constraint.id,
-      text,
-      source: constraint.source,
-      approved: constraint.approved,
-      sourceMessageIds: constraint.sourceMessageIds,
-    }
-  })
-
-  const keyDecisions = sanitizeAndMapStateField(state.keyDecisions, (decision) => {
-    const normalizedDecision = sanitizeStateText(decision.decision)
-    const rationale = sanitizeStateText(decision.rationale)
-    if (!normalizedDecision || !rationale) return null
-    return {
-      id: decision.id,
-      decision: normalizedDecision,
-      rationale,
-      agent: decision.agent,
-      sourceMessageIds: decision.sourceMessageIds,
-      confidence: decision.confidence,
-    }
-  })
-
-  const tasks = sanitizeAndMapStateField(state.tasks, (task) => {
-    const title = sanitizeStateText(task.title)
-    const owner = sanitizeStateText(task.owner)
-    if (!title || !owner) return null
-    return {
-      id: task.id,
-      title,
-      status: task.status,
-      owner,
-      externalId: task.externalId,
-      source: task.source,
-      sourceMessageIds: task.sourceMessageIds,
-    }
-  })
-
-  const openQuestions = sanitizeAndMapStateField(state.openQuestions, (question) => {
-    const text = sanitizeStateText(question.text)
-    if (!text) return null
-    return { id: question.id, text, source: question.source, sourceMessageIds: question.sourceMessageIds }
-  })
-
-  const artifacts = sanitizeAndMapStateField(state.artifacts, (artifact) => {
-    const name = sanitizeStateText(artifact.name)
-    const pointer = sanitizeStateText(artifact.pointer)
-    if (!name || !pointer) return null
-    return { id: artifact.id, name, type: artifact.type, pointer }
-  })
-
-  const agentContributions = sanitizeAndMapStateField(state.agentContributions, (note) => {
-    const summary = sanitizeStateText(note.summary)
-    if (!summary) return null
-    return { id: note.id, agent: note.agent, summary }
-  })
-
-  return {
-    currentPlan: currentPlanText
-      ? {
-          id: state.currentPlan?.id,
-          text: currentPlanText,
-          source: state.currentPlan?.source,
-          approved: state.currentPlan?.approved,
-          sourceMessageIds: state.currentPlan?.sourceMessageIds ?? [],
-        }
-      : null,
-    activeConstraints,
-    keyDecisions,
-    tasks,
-    openQuestions,
-    risks: sanitizeStateStrings(state.risks),
-    artifacts,
-    agentContributions,
-    approvedBy: state.approvedBy ? sanitizeStateText(state.approvedBy) : undefined,
-    approvalNote: state.approvalNote ? sanitizeStateText(state.approvalNote) : undefined,
-  }
-}
-
-function createStableId(prefix: string, ...parts: Array<string | number | undefined>): string {
-  const payload = parts
-    .map((part) => (part === undefined ? '' : String(part)))
-    .map((part) => compactWhitespace(part))
-    .join('|')
-  const hash = new Bun.CryptoHasher('sha1').update(`${prefix}|${payload}`).digest('hex').slice(0, 20)
-  return `${prefix}_${hash}`
-}
-
-function appendUnique(values: string[], nextValues: string[]): string[] {
-  const seen = new Set(values.map((value) => compactWhitespace(value).toLowerCase()))
-  const merged = [...values]
-
-  for (const value of nextValues) {
-    const normalized = compactWhitespace(value)
-    if (!normalized) continue
-    const key = normalized.toLowerCase()
-    if (seen.has(key)) continue
-    seen.add(key)
-    merged.push(normalized)
-  }
-
-  return merged
+function normalizeSummary(summaryText: string): string {
+  return summaryText.trim()
 }
 
 function formatSummary(summaryText: string): string {
   return `Compacted context summary:\n${summaryText.trim()}`
 }
 
-function normalizeSummary(summaryText: string): string {
-  return summaryText.trim()
-}
-
 function buildSyntheticSummaryPayload(
   summaryText: string,
 ): { role: 'system'; parts: Array<{ type: 'text'; text: string }> } | null {
@@ -263,49 +131,6 @@ function markMessageCompacted(message: ChatMessage, now: () => number): ChatMess
   }
 }
 
-export function parseWorkstreamState(value: unknown): WorkstreamState {
-  const parsed = WorkstreamStateSchema.safeParse(value)
-  return parsed.success ? parsed.data : createEmptyWorkstreamState()
-}
-
-function pickDefined<T extends Record<string, unknown>, K extends keyof T>(
-  next: T,
-  base: T,
-  key: K,
-): Partial<Pick<T, K>> {
-  if (next[key] !== undefined) {
-    return { [key]: next[key] } as Partial<Pick<T, K>>
-  }
-  if (base[key] !== undefined) {
-    return { [key]: base[key] } as Partial<Pick<T, K>>
-  }
-  return {}
-}
-
-export function toStateFieldsUpdated(delta: WorkstreamStateDelta): string[] {
-  const fields: string[] = []
-  if (delta.currentPlan !== undefined) fields.push('currentPlan')
-  if ((delta.newDecisions?.length ?? 0) > 0) fields.push('keyDecisions')
-  if ((delta.resolvedQuestions?.length ?? 0) > 0 || (delta.newQuestions?.length ?? 0) > 0) fields.push('openQuestions')
-  if ((delta.newConstraints?.length ?? 0) > 0) fields.push('activeConstraints')
-  if ((delta.newRisks?.length ?? 0) > 0) fields.push('risks')
-  if ((delta.taskUpdates?.length ?? 0) > 0) fields.push('tasks')
-  if ((delta.artifacts?.length ?? 0) > 0) fields.push('artifacts')
-  if (delta.agentNote) fields.push('agentContributions')
-  if ((delta.conflicts?.length ?? 0) > 0) fields.push('conflicts')
-
-  if (
-    delta.approvedBy !== undefined ||
-    delta.approvedAt !== undefined ||
-    delta.approvalMessageId !== undefined ||
-    delta.approvalNote !== undefined
-  ) {
-    fields.push('approval')
-  }
-
-  return fields
-}
-
 function toCompactionTranscript(messages: ContextMessage[]): string {
   return messages
     .map((message, index) => {
@@ -338,248 +163,11 @@ function splitByCharBudget(messages: ContextMessage[], maxChars: number): Contex
     currentChars += nextChars
   }
 
-  if (current.length > 0) chunks.push(current)
-  return chunks
-}
-
-function mergeDelta(base: WorkstreamStateDelta, next: WorkstreamStateDelta): WorkstreamStateDelta {
-  const mergedConstraints = appendUnique(base.newConstraints ?? [], next.newConstraints ?? [])
-  const mergedRisks = appendUnique(base.newRisks ?? [], next.newRisks ?? [])
-  const mergedQuestions = appendUnique(base.newQuestions ?? [], next.newQuestions ?? [])
-  const mergedResolvedQuestions = appendUnique(base.resolvedQuestions ?? [], next.resolvedQuestions ?? [])
-
-  return {
-    ...(next.currentPlan !== undefined
-      ? { currentPlan: next.currentPlan }
-      : base.currentPlan !== undefined
-        ? { currentPlan: base.currentPlan }
-        : {}),
-    ...(mergedConstraints.length > 0 ? { newConstraints: mergedConstraints } : {}),
-    ...(mergedRisks.length > 0 ? { newRisks: mergedRisks } : {}),
-    ...(mergedQuestions.length > 0 ? { newQuestions: mergedQuestions } : {}),
-    ...(mergedResolvedQuestions.length > 0 ? { resolvedQuestions: mergedResolvedQuestions } : {}),
-    ...((base.newDecisions?.length ?? 0) + (next.newDecisions?.length ?? 0) > 0
-      ? { newDecisions: [...(base.newDecisions ?? []), ...(next.newDecisions ?? [])] }
-      : {}),
-    ...((base.taskUpdates?.length ?? 0) + (next.taskUpdates?.length ?? 0) > 0
-      ? { taskUpdates: [...(base.taskUpdates ?? []), ...(next.taskUpdates ?? [])] }
-      : {}),
-    ...((base.artifacts?.length ?? 0) + (next.artifacts?.length ?? 0) > 0
-      ? { artifacts: [...(base.artifacts ?? []), ...(next.artifacts ?? [])] }
-      : {}),
-    ...(next.agentNote ? { agentNote: next.agentNote } : base.agentNote ? { agentNote: base.agentNote } : {}),
-    ...((base.conflicts?.length ?? 0) + (next.conflicts?.length ?? 0) > 0
-      ? { conflicts: [...(base.conflicts ?? []), ...(next.conflicts ?? [])] }
-      : {}),
-    ...pickDefined(next, base, 'approvedBy'),
-    ...pickDefined(next, base, 'approvedAt'),
-    ...pickDefined(next, base, 'approvalMessageId'),
-    ...pickDefined(next, base, 'approvalNote'),
-  }
-}
-
-export function mergeStateDelta(
-  existingState: WorkstreamState,
-  delta: WorkstreamStateDelta,
-  now: () => number,
-): WorkstreamState {
-  const timestamp = now()
-  const state: WorkstreamState = {
-    ...existingState,
-    currentPlan: existingState.currentPlan ? { ...existingState.currentPlan } : null,
-    activeConstraints: [...existingState.activeConstraints],
-    keyDecisions: [...existingState.keyDecisions],
-    tasks: [...existingState.tasks],
-    openQuestions: [...existingState.openQuestions],
-    risks: [...existingState.risks],
-    artifacts: [...existingState.artifacts],
-    agentContributions: [...existingState.agentContributions],
-    lastUpdated: timestamp,
-  }
-
-  if (delta.currentPlan !== undefined) {
-    if (delta.currentPlan === null) {
-      state.currentPlan = null
-    } else {
-      const planText = sanitizeStateText(delta.currentPlan)
-      if (planText) {
-        const planId = createStableId('plan', planText)
-        const existingPlan = state.currentPlan && state.currentPlan.id === planId ? state.currentPlan : null
-        state.currentPlan = {
-          id: planId,
-          text: planText,
-          source: 'agent',
-          approved: existingPlan?.approved ?? false,
-          timestamp,
-          sourceMessageIds: existingPlan?.sourceMessageIds ?? [],
-        }
-      }
-    }
-  }
-
-  if (delta.newConstraints?.length) {
-    for (const rawConstraint of delta.newConstraints) {
-      const text = sanitizeStateText(rawConstraint)
-      if (!text) continue
-      const constraintId = createStableId('constraint', text)
-      const exists = state.activeConstraints.some((constraint) => constraint.id === constraintId)
-      if (exists) continue
-      state.activeConstraints.push({
-        id: constraintId,
-        text,
-        source: 'agent',
-        approved: false,
-        timestamp,
-        sourceMessageIds: [],
-      })
-    }
-  }
-
-  if (delta.newRisks?.length) {
-    state.risks = appendUnique(state.risks, delta.newRisks)
-  }
-
-  if (delta.resolvedQuestions?.length) {
-    const resolvedIds = new Set(
-      delta.resolvedQuestions
-        .map((question) => sanitizeStateText(question))
-        .filter((question): question is string => Boolean(question))
-        .map((question) => createStableId('question', question)),
-    )
-    state.openQuestions = state.openQuestions.filter((question) => !resolvedIds.has(question.id))
-  }
-
-  if (delta.newQuestions?.length) {
-    for (const rawQuestion of delta.newQuestions) {
-      const text = sanitizeStateText(rawQuestion)
-      if (!text) continue
-      const questionId = createStableId('question', text)
-      const exists = state.openQuestions.some((question) => question.id === questionId)
-      if (exists) continue
-      state.openQuestions.push({ id: questionId, text, source: 'agent', timestamp, sourceMessageIds: [] })
-    }
-  }
-
-  if (delta.newDecisions?.length) {
-    for (const decision of delta.newDecisions) {
-      const normalizedDecision = sanitizeStateText(decision.decision)
-      const normalizedRationale = sanitizeStateText(decision.rationale)
-      if (!normalizedDecision || !normalizedRationale) continue
-
-      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
-      state.keyDecisions.push({
-        id: decisionId,
-        decision: normalizedDecision,
-        rationale: normalizedRationale,
-        agent: compactWhitespace(decision.agent),
-        sourceMessageIds: sourceIds,
-        confidence: decision.confidence,
-        timestamp,
-      })
-    }
-  }
-
-  if (delta.taskUpdates?.length) {
-    for (const update of delta.taskUpdates) {
-      const title = sanitizeStateText(update.title)
-      if (!title) continue
-
-      const externalId = sanitizeStateText(update.externalId ?? '')
-      const owner = compactWhitespace(update.owner)
-      const taskId = externalId ? createStableId('task-external', externalId) : createStableId('task', title, owner)
-      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,
-        title,
-        status: update.status,
-        owner,
-        ...(externalId ? { externalId } : {}),
-        source: 'agent' as const,
-        sourceMessageIds,
-        timestamp,
-      }
-
-      if (existingIndex >= 0) {
-        const existingTask = state.tasks[existingIndex]
-        state.tasks[existingIndex] = {
-          ...nextTask,
-          sourceMessageIds: [...new Set([...existingTask.sourceMessageIds, ...sourceMessageIds])],
-        }
-      } else {
-        state.tasks.push(nextTask)
-      }
-    }
-  }
-
-  if (delta.artifacts?.length) {
-    for (const artifact of delta.artifacts) {
-      const name = sanitizeStateText(artifact.name)
-      const pointer = sanitizeStateText(artifact.pointer)
-      if (!name || !pointer) continue
-
-      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: compactWhitespace(artifact.type), pointer, timestamp })
-    }
-  }
-
-  if (delta.agentNote) {
-    const agent = sanitizeStateText(delta.agentNote.agent)
-    const summary = sanitizeStateText(delta.agentNote.summary)
-    if (agent && summary) {
-      const noteId = createStableId('agent-note', agent, summary)
-      const exists = state.agentContributions.some((note) => note.id === noteId)
-      if (!exists) {
-        state.agentContributions.push({ id: noteId, agent, summary, timestamp })
-      }
-    }
-  }
-
-  if (delta.conflicts?.length) {
-    for (const conflict of delta.conflicts) {
-      const text = sanitizeStateText(`Conflict: ${conflict.recommendation}`)
-      if (!text) continue
-      const questionId = createStableId('question', text)
-      const exists = state.openQuestions.some((question) => question.id === questionId)
-      if (exists) continue
-      state.openQuestions.push({ id: questionId, text, source: 'agent', timestamp, sourceMessageIds: [] })
-    }
-  }
-
-  if (delta.approvedBy !== undefined) {
-    state.approvedBy = sanitizeStateText(delta.approvedBy) ?? undefined
+  if (current.length > 0) {
+    chunks.push(current)
   }
-  if (delta.approvedAt !== undefined) {
-    state.approvedAt = delta.approvedAt ?? undefined
-  }
-  if (delta.approvalMessageId !== undefined) {
-    state.approvalMessageId = sanitizeStateText(delta.approvalMessageId) ?? undefined
-  }
-  if (delta.approvalNote !== undefined) {
-    state.approvalNote = sanitizeStateText(delta.approvalNote) ?? undefined
-  }
-
-  applyWorkstreamStateCaps(state)
-
-  return WorkstreamStateSchema.parse(state)
-}
 
-export interface ContextCompactionRuntime {
-  createSummaryMessage: (summaryText: string) => ChatMessage | null
-  prependSummaryMessage: (summaryText: string, liveMessages: ChatMessage[]) => ChatMessage[]
-  formatWorkstreamStateForPrompt: (state: WorkstreamState | null | undefined) => string | undefined
-  estimateThreshold: (contextSize?: number) => number
-  shouldCompactHistory: (params: {
-    summaryText: string
-    liveMessages: ChatMessage[]
-    contextSize?: number
-  }) => CompactionAssessment
-  compactHistory: (params: CompactHistoryParams) => Promise<CompactHistoryResult>
+  return chunks
 }
 
 export function buildContextCompactionPrompt(params: ContextCompactionPromptParams): string {
@@ -588,24 +176,22 @@ export function buildContextCompactionPrompt(params: ContextCompactionPromptPara
     '<previous-summary>',
     params.previousSummary.trim() || 'None',
     '</previous-summary>',
-    '<existing-workstream-state>',
-    JSON.stringify(buildExistingWorkstreamStateForCompactionPrompt(params.existingState)),
-    '</existing-workstream-state>',
     '<new-messages>',
     params.transcript || 'None',
     '</new-messages>',
     '</context-compaction-input>',
     '',
-    'Produce a concise replacement summary and a structured state delta.',
-    'Only include facts supported by the new messages.',
-    'Summary format is required and must use exactly these sections in order:',
+    'Produce one concise replacement summary for the compacted history.',
+    'Preserve durable facts, decisions, blockers, ownership, numbers, and unresolved questions.',
+    'Do not invent details or preserve filler.',
+    'Return plain JSON with one field: summary.',
+    'Summary format must use these sections in order:',
     'KEY FACTS:',
     '- ...',
     'CONVERSATION FLOW:',
     '- ...',
     'OPEN THREADS:',
     '- ...',
-    'Return every stateDelta field. Use empty arrays for unchanged list fields, null for unchanged nullable fields, and currentPlan.action to signal unchanged, clear, or set.',
   ].join('\n')
 }
 
@@ -683,101 +269,11 @@ export function createContextCompactionRuntime(
     return chunks.join('\n').trim()
   }
 
-  const toContextMessageFromChatMessage = (message: ChatMessage): ContextMessage => {
-    return { role: message.role, text: toContextTextFromChatMessage(message), sourceMessageId: message.id }
-  }
-
-  const formatWorkstreamStateForPrompt = (state: WorkstreamState | null | undefined): string | undefined => {
-    if (!state) return undefined
-
-    // Skip serialization when all fields are empty
-    const hasContent =
-      (state.currentPlan !== null && state.currentPlan !== undefined) ||
-      state.activeConstraints.length > 0 ||
-      state.keyDecisions.length > 0 ||
-      state.openQuestions.length > 0 ||
-      state.risks.length > 0 ||
-      state.tasks.length > 0 ||
-      state.artifacts.length > 0 ||
-      state.agentContributions.length > 0
-    if (!hasContent) return undefined
-
-    const approvedPlan =
-      state.currentPlan && state.currentPlan.approved ? sanitizeStateText(state.currentPlan.text) : null
-    const candidatePlan =
-      state.currentPlan && !state.currentPlan.approved ? sanitizeStateText(state.currentPlan.text) : null
-
-    const approvedConstraints = sanitizeTextFieldItems(
-      state.activeConstraints.filter((constraint) => constraint.approved),
-      'text',
-    )
-
-    const candidateConstraints = sanitizeTextFieldItems(
-      state.activeConstraints.filter((constraint) => !constraint.approved),
-      'text',
-    )
-
-    const openQuestions = sanitizeStateStrings(state.openQuestions.map((question) => question.text))
-
-    const decisions = sanitizeAndMapStateField(state.keyDecisions, (decision) => {
-      const normalizedDecision = sanitizeStateText(decision.decision)
-      const rationale = sanitizeStateText(decision.rationale)
-      if (!normalizedDecision || !rationale) return null
-      return { agent: decision.agent, decision: normalizedDecision, rationale, confidence: decision.confidence }
-    })
-
-    const tasks = sanitizeAndMapStateField(state.tasks, (task) => {
-      const title = sanitizeStateText(task.title)
-      const owner = sanitizeStateText(task.owner)
-      if (!title || !owner) return null
-      return { title, status: task.status, owner, externalId: task.externalId, source: task.source }
-    })
-
-    const artifacts = sanitizeAndMapStateField(state.artifacts, (artifact) => {
-      const name = sanitizeStateText(artifact.name)
-      const pointer = sanitizeStateText(artifact.pointer)
-      if (!name || !pointer) return null
-      return { name, type: artifact.type, pointer }
-    })
-
-    const agentContributions = sanitizeAndMapStateField(state.agentContributions, (note) => {
-      const summary = sanitizeStateText(note.summary)
-      if (!summary) return null
-      return { agent: note.agent, summary }
-    })
-
-    const payload = {
-      policy: { approvedConstraintsAreBinding: true, candidateStateIsAdvisoryOnly: true },
-      approved: {
-        currentPlan: approvedPlan ? { text: approvedPlan, source: state.currentPlan?.source } : null,
-        constraints: approvedConstraints.map((constraint) => ({
-          id: constraint.id,
-          text: constraint.text,
-          source: constraint.source,
-        })),
-      },
-      candidate: {
-        currentPlan: candidatePlan ? { text: candidatePlan, source: state.currentPlan?.source } : null,
-        constraints: candidateConstraints.map((constraint) => ({
-          id: constraint.id,
-          text: constraint.text,
-          source: constraint.source,
-        })),
-      },
-      decisions,
-      openQuestions,
-      risks: sanitizeStateStrings(state.risks),
-      tasks,
-      artifacts,
-      agentContributions,
-      advisory: {
-        approvedBy: state.approvedBy ? sanitizeStateText(state.approvedBy) : null,
-        approvalNote: state.approvalNote ? sanitizeStateText(state.approvalNote) : null,
-      },
-    }
-
-    return ['<workstream-state>', JSON.stringify(payload, null, 2), '</workstream-state>'].join('\n')
-  }
+  const toContextMessageFromChatMessage = (message: ChatMessage): ContextMessage => ({
+    role: message.role,
+    text: toContextTextFromChatMessage(message),
+    sourceMessageId: message.id,
+  })
 
   const createSummaryMessage = (summaryText: string): ChatMessage | null => {
     const summary = normalizeSummary(summaryText)
@@ -818,53 +314,36 @@ export function createContextCompactionRuntime(
 
   const compactContextMessages = async (params: {
     previousSummary: string
-    existingState: WorkstreamState
     newMessages: ContextMessage[]
   }): Promise<CompactionOutput> => {
     const chunks = splitByCharBudget(params.newMessages, compactionChunkMaxChars)
     let summary = normalizeSummary(params.previousSummary)
-    let delta: WorkstreamStateDelta = {}
-    let currentState = params.existingState
 
     for (const chunk of chunks) {
       const transcript = toCompactionTranscript(chunk)
-      const output = await options.runCompacter({
-        previousSummary: summary,
-        existingState: currentState,
-        chunk,
-        transcript,
-      })
+      const output = await options.runCompacter({ previousSummary: summary, chunk, transcript })
       summary = normalizeSummary(output.summary)
-      const parsedDelta = WorkstreamStateDeltaSchema.parse(output.stateDelta)
-      delta = mergeDelta(delta, parsedDelta)
-      currentState = mergeStateDelta(currentState, parsedDelta, now)
     }
 
-    return { summary, stateDelta: delta }
+    return { summary }
   }
 
-  const rollupSummaryIfOversized = async (
-    summary: string,
-    state: WorkstreamState,
-  ): Promise<{ summary: string; state: WorkstreamState; output: CompactionOutput }> => {
+  const rollupSummaryIfOversized = async (summary: string): Promise<string> => {
     if (estimateTokens(summary) <= summaryRollupMaxTokens) {
-      return { summary, state, output: { summary, stateDelta: {} } }
+      return summary
     }
 
     const output = await compactContextMessages({
       previousSummary: '',
-      existingState: state,
       newMessages: [{ role: 'assistant', text: summary, sourceMessageId: 'summary-rollup' }],
     })
 
-    return { summary: normalizeSummary(output.summary), state: mergeStateDelta(state, output.stateDelta, now), output }
+    return normalizeSummary(output.summary)
   }
 
   const compactHistory = async (params: CompactHistoryParams): Promise<CompactHistoryResult> => {
     let summaryText = normalizeSummary(params.summaryText)
     let remainingMessages = [...params.liveMessages]
-    let state = params.existingState
-    let mergedDelta: WorkstreamStateDelta = {}
     let compactedMessages: ChatMessage[] = []
     let lastCompactedMessageId: string | undefined
     const summaryPayload = buildSyntheticSummaryPayload(summaryText)
@@ -884,8 +363,6 @@ export function createContextCompactionRuntime(
         estimatedTokens,
         inputChars,
         outputChars: outputPayload.length,
-        state,
-        stateDelta: mergedDelta,
       }
     }
 
@@ -907,36 +384,25 @@ export function createContextCompactionRuntime(
 
       const candidatePrefix = remainingMessages.slice(0, boundary)
       const messagesToCompact = candidatePrefix.filter((message) => !readIsCompacted(message))
-      const contextMessages = messagesToCompact.map(toContextMessageFromChatMessage)
+      const contextMessages = messagesToCompact
+        .map(toContextMessageFromChatMessage)
+        .filter((message) => compactWhitespace(message.text).length > 0)
       const sourceText = toCompactionTranscript(contextMessages)
 
       if (!compactWhitespace(sourceText)) {
         return buildEarlyExitResult(assessment.estimatedTokens)
       }
 
-      let compactionOutput = await compactContextMessages({
-        previousSummary: summaryText,
-        existingState: state,
-        newMessages: contextMessages,
-      })
-
-      let nextSummary = normalizeSummary(compactionOutput.summary)
-      let nextState = mergeStateDelta(state, compactionOutput.stateDelta, now)
-
-      if (estimateTokens(nextSummary) > summaryRollupMaxTokens) {
-        const rollup = await rollupSummaryIfOversized(nextSummary, nextState)
-        nextSummary = rollup.summary
-        nextState = rollup.state
-        compactionOutput = rollup.output
-      }
+      let nextSummary = normalizeSummary(
+        (await compactContextMessages({ previousSummary: summaryText, newMessages: contextMessages })).summary,
+      )
+      nextSummary = await rollupSummaryIfOversized(nextSummary)
 
       if (nextSummary.length >= sourceText.length) {
         throw new Error('Compaction summary is not shorter than compacted source')
       }
 
       summaryText = nextSummary
-      state = nextState
-      mergedDelta = mergeDelta(mergedDelta, compactionOutput.stateDelta)
       compactedMessages = [
         ...compactedMessages,
         ...candidatePrefix.map((message) => markMessageCompacted(message, now)),
@@ -950,18 +416,10 @@ export function createContextCompactionRuntime(
     }
   }
 
-  return {
-    createSummaryMessage,
-    prependSummaryMessage,
-    formatWorkstreamStateForPrompt,
-    estimateThreshold,
-    shouldCompactHistory,
-    compactHistory,
-  }
+  return { createSummaryMessage, prependSummaryMessage, estimateThreshold, shouldCompactHistory, compactHistory }
 }
 
 export function parseCompactionOutput(value: unknown): CompactionOutput {
-  const parsed = StructuredCompactionOutputSchema.parse(value)
-
-  return { summary: parsed.summary, stateDelta: parseStructuredWorkstreamStateDelta(parsed.stateDelta) }
+  const parsed = ContextCompactionOutputSchema.parse(value)
+  return { summary: parsed.summary }
 }