@lota-sdk/core 0.1.24 → 0.1.25

package/src/queues/plan-agent-heartbeat.queue.ts

@@ -25,6 +25,12 @@ export interface PlanAgentHeartbeatSweepJob {
 export type PlanAgentHeartbeatJob = PlanAgentHeartbeatWakeJob | PlanAgentHeartbeatSweepJob
 
 export const PLAN_AGENT_HEARTBEAT_QUEUE = 'plan-agent-heartbeat'
+const PLAN_AGENT_HEARTBEAT_SWEEP_INTERVAL_MS = 30_000
+const PLAN_AGENT_HEARTBEAT_SWEEP_JOB_ID = 'plan-agent-heartbeat-sweep'
+
+async function enqueueDelayedPlanAgentHeartbeatSweep(delayMs = PLAN_AGENT_HEARTBEAT_SWEEP_INTERVAL_MS): Promise<void> {
+  await planAgentHeartbeatQueue.enqueue({ type: 'sweep' }, { delay: delayMs, jobId: PLAN_AGENT_HEARTBEAT_SWEEP_JOB_ID })
+}
 
 async function processPlanAgentHeartbeatJob(job: Job<PlanAgentHeartbeatJob>): Promise<void> {
   await databaseService.connect()
@@ -35,6 +41,9 @@ async function processPlanAgentHeartbeatJob(job: Job<PlanAgentHeartbeatJob>): Pr
   }
 
   await planAgentHeartbeatService.sweep({ organizationId: job.data.organizationId })
+  if (!job.data.organizationId) {
+    await enqueueDelayedPlanAgentHeartbeatSweep()
+  }
 }
 
 const planAgentHeartbeatQueue = createQueueFactory<PlanAgentHeartbeatJob>({
@@ -43,8 +52,6 @@ const planAgentHeartbeatQueue = createQueueFactory<PlanAgentHeartbeatJob>({
   jobName: 'plan-agent-heartbeat-job',
   concurrency: 2,
   lockDuration: LONG_JOB_LOCK_DURATION_MS,
-  stalledInterval: 120_000,
-  maxStalledCount: 5,
   defaultJobOptions: { ...DEFAULT_JOB_RETENTION, attempts: 3, backoff: { type: 'exponential', delay: 5_000 } },
   processor: processPlanAgentHeartbeatJob,
 })
@@ -72,23 +79,10 @@ export async function enqueuePlanAgentHeartbeatWake(params: {
   await planAgentHeartbeatQueue.enqueue({ type: 'wake-node', ...params }, { jobId: buildWakeJobId(params) })
 }
 
-const PLAN_AGENT_HEARTBEAT_SCHEDULER_ID = 'plan-agent-heartbeat-sweep'
-
-export async function schedulePlanAgentHeartbeatSweep(params?: { everyMs?: number }): Promise<void> {
-  const everyMs = params?.everyMs ?? 30_000
-  await planAgentHeartbeatQueue
-    .getQueue()
-    .upsertJobScheduler(
-      PLAN_AGENT_HEARTBEAT_SCHEDULER_ID,
-      { every: everyMs },
-      { name: 'plan-agent-heartbeat-job', data: { type: 'sweep' }, opts: { ...DEFAULT_JOB_RETENTION } },
-    )
-}
-
 export function startPlanAgentHeartbeatWorker(options: { registerSignals?: boolean } = {}): WorkerHandle {
   const handle = planAgentHeartbeatQueue.startWorker(options)
 
-  schedulePlanAgentHeartbeatSweep().catch((error: unknown) => {
+  enqueueDelayedPlanAgentHeartbeatSweep().catch((error: unknown) => {
     serverLogger.error`Plan agent heartbeat scheduler setup failed: ${error}`
   })
 

package/src/queues/title-generation.queue.ts

@@ -0,0 +1,62 @@
+import type { Job } from 'bullmq'
+
+import { ensureRecordId } from '../db/record-id'
+import { databaseService } from '../db/service'
+import { recentActivityTitleService } from '../services/recent-activity-title.service'
+import { workstreamTitleService } from '../services/workstream-title.service'
+import { createQueueFactory } from './queue-factory'
+
+export const TITLE_GENERATION_QUEUE = 'title-generation'
+
+// This queue merges workstream title generation and recent-activity title
+// refinement because both are short-lived title synthesis jobs with the same
+// operational shape.
+
+interface WorkstreamTitleGenerationJob {
+  kind: 'workstream-title'
+  workstreamId: string
+  sourceText: string
+}
+
+interface RecentActivityTitleRefinementJob {
+  kind: 'recent-activity-title'
+  activityId: string
+}
+
+type TitleGenerationJob = WorkstreamTitleGenerationJob | RecentActivityTitleRefinementJob
+
+async function processTitleGenerationJob(job: Job<TitleGenerationJob>): Promise<void> {
+  await databaseService.connect()
+  if (job.data.kind === 'workstream-title') {
+    await workstreamTitleService.generateAndPersistTitle(ensureRecordId(job.data.workstreamId), job.data.sourceText)
+    return
+  }
+
+  await recentActivityTitleService.refineRecentActivityTitle(job.data.activityId)
+}
+
+const titleGeneration = createQueueFactory<TitleGenerationJob>({
+  name: TITLE_GENERATION_QUEUE,
+  displayName: 'Title generation',
+  jobName: 'title-generation',
+  concurrency: 10,
+  lockDuration: 300_000,
+  defaultJobOptions: { attempts: 3, backoff: { type: 'exponential', delay: 2_000 } },
+  processor: processTitleGenerationJob,
+})
+
+export function enqueueWorkstreamTitleGeneration(job: Omit<WorkstreamTitleGenerationJob, 'kind'>) {
+  return titleGeneration.enqueue(
+    { kind: 'workstream-title', ...job },
+    { jobId: `workstream-title:${job.workstreamId}` },
+  )
+}
+
+export function enqueueRecentActivityTitleRefinement(job: Omit<RecentActivityTitleRefinementJob, 'kind'>) {
+  return titleGeneration.enqueue(
+    { kind: 'recent-activity-title', ...job },
+    { jobId: `recent-activity-title:${job.activityId}` },
+  )
+}
+
+export const startTitleGenerationWorker = titleGeneration.startWorker

package/src/runtime/agent-prompt-context.ts

@@ -1,7 +1,5 @@
 import { toOptionalIsoDateTimeString } from '../utils/date-time'
 
-type StructuredProfile = Record<string, unknown>
-
 interface AgentPromptContext {
   systemWorkspaceDetails: string
 }
@@ -18,7 +16,6 @@ interface DomainEventLike {
 interface BuildAgentPromptContextParams {
   workspaceName?: string
   summaryBlock?: string
-  structuredProfile?: StructuredProfile
   promptSummary?: string
   userName?: string | null
   recentDomainEvents: DomainEventLike[]
@@ -39,18 +36,6 @@ function normalizeWorkspaceName(name?: string): string {
   return normalized && normalized.length > 0 ? normalized : 'Workspace'
 }
 
-function hasStructuredProfileData(profile?: StructuredProfile): boolean {
-  return Boolean(profile && Object.keys(profile).length > 0)
-}
-
-function formatStructuredProfile(profile?: StructuredProfile): string {
-  if (!hasStructuredProfileData(profile)) {
-    return 'No structured workspace profile has been recorded yet.'
-  }
-
-  return JSON.stringify(profile, null, 2)
-}
-
 function formatDomainEvent(event: DomainEventLike, index: number): string {
   const summary = typeof event.summary === 'string' && event.summary.trim().length > 0 ? event.summary.trim() : null
   if (summary) {
@@ -95,7 +80,6 @@ function formatRecentDomainEvents(events: DomainEventLike[]): string {
 export function buildAgentPromptContext(params: BuildAgentPromptContextParams): AgentPromptContext {
   const workspaceName = normalizeWorkspaceName(params.workspaceName)
   const summaryBlock = normalizeSummaryBlock(params.summaryBlock)
-  const structuredProfile = formatStructuredProfile(params.structuredProfile)
   const promptSummary = params.promptSummary?.trim()
   const userName = normalizeUserName(params.userName)
   const recentDomainEvents = formatRecentDomainEvents(params.recentDomainEvents)
@@ -105,8 +89,6 @@ export function buildAgentPromptContext(params: BuildAgentPromptContextParams):
     `name=${workspaceName}`,
     'summary-block:',
     summaryBlock,
-    'structured-profile-json:',
-    structuredProfile,
     ...(promptSummary ? ['prompt-summary:', promptSummary] : []),
     '</workspace-profile>',
   ].join('\n')

package/src/runtime/agent-runtime-policy.ts

@@ -17,6 +17,12 @@ export interface AgentRuntimeConfig<TAgent extends string> {
   maxSteps: number
 }
 
+export interface AgentRuntimeRuleOptions {
+  includeExecutionPlanRule?: boolean
+  includeMemr3Rule?: boolean
+  includeDomainReasoningFallbackRule?: boolean
+}
+
 export interface AgentToolPolicy<TSkill extends PropertyKey> {
   resolvedMode: ChatMode
   skills: TSkill[]
@@ -129,13 +135,14 @@ export function buildAgentRuntimeConfig<TAgent extends string, TSkill extends Pr
   responseGuardSection?: string
   learnedSkillsSection?: string
   additionalInstructionSections?: string[]
+  ruleOptions?: AgentRuntimeRuleOptions
   getAgentSkills: (agentId: TAgent, mode: ChatMode) => TSkill[]
-  buildGlobalRuleInstructionSection: () => string
+  buildGlobalRuleInstructionSection: (options?: AgentRuntimeRuleOptions) => string
   buildSkillInstructionSection: (skills: TSkill[]) => string
   buildOnboardingPromptSection: () => string
 }): AgentRuntimeConfig<TAgent> {
   const mode = params.mode ?? toChatMode(params.workstreamMode)
-  const rulesSection = params.buildGlobalRuleInstructionSection()
+  const rulesSection = params.buildGlobalRuleInstructionSection(params.ruleOptions)
   const skillsSection =
     params.skills && params.skills.length > 0 ? params.buildSkillInstructionSection(params.skills) : ''
   const onboardingPromptSection = params.onboardingActive ? params.buildOnboardingPromptSection() : ''

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

@@ -1,11 +1,13 @@
 export const CONTEXT_COMPACTION_THRESHOLD_RATIO = 0.7
 export const CONTEXT_OUTPUT_RESERVE_TOKENS = 32_000
 export const CONTEXT_SAFETY_MARGIN_TOKENS = 8_000
+// Cap the output reserve against the model context window so oversized windows do not over-reserve.
+export const CONTEXT_OUTPUT_RESERVE_MAX_RATIO = 0.35
+// Keep a fixed guard band for provider-side overhead without letting it dominate larger context windows.
+export const CONTEXT_SAFETY_MARGIN_MAX_RATIO = 0.1
 export const COMPACTION_CHUNK_MAX_CHARS = 120_000
 export const SUMMARY_ROLLUP_MAX_TOKENS = 80_000
 export const CONTEXT_COMPACTION_INCLUDED_TOOL_NAMES = ['userQuestions', 'proceedInOnboarding'] as const
 export const CONTEXT_COMPACTION_INCLUDED_TOOL_PREFIXES = ['linear'] as const
-export const MEMORY_BLOCK_COMPACTION_TRIGGER_ENTRIES = 15
-export const MEMORY_BLOCK_COMPACTION_CHUNK_ENTRIES = 10
 export const CONTEXT_WINDOW_TOKENS = 200_000
 export const WORKSTREAM_RAW_TAIL_MESSAGES = 6

package/src/runtime/context-compaction.ts

@@ -5,8 +5,10 @@ import {
   COMPACTION_CHUNK_MAX_CHARS,
   CONTEXT_COMPACTION_INCLUDED_TOOL_NAMES,
   CONTEXT_COMPACTION_INCLUDED_TOOL_PREFIXES,
+  CONTEXT_OUTPUT_RESERVE_MAX_RATIO,
   CONTEXT_COMPACTION_THRESHOLD_RATIO,
   CONTEXT_OUTPUT_RESERVE_TOKENS,
+  CONTEXT_SAFETY_MARGIN_MAX_RATIO,
   CONTEXT_SAFETY_MARGIN_TOKENS,
   SUMMARY_ROLLUP_MAX_TOKENS,
 } from './context-compaction-constants'
@@ -94,74 +96,92 @@ function estimateTokens(text: string): number {
   return Math.ceil(text.length / CHARS_PER_TOKEN_ESTIMATE)
 }
 
-function sanitizeStateText(value: string): string | null {
+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 = state.activeConstraints
-    .map((constraint) => ({
+  const activeConstraints = sanitizeAndMapStateField(state.activeConstraints, (constraint) => {
+    const text = sanitizeStateText(constraint.text)
+    if (!text) return null
+    return {
       id: constraint.id,
-      text: sanitizeStateText(constraint.text),
+      text,
       source: constraint.source,
       approved: constraint.approved,
       sourceMessageIds: constraint.sourceMessageIds,
-    }))
-    .filter((constraint): constraint is typeof constraint & { text: string } => Boolean(constraint.text))
+    }
+  })
 
-  const keyDecisions = state.keyDecisions
-    .map((decision) => ({
+  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: sanitizeStateText(decision.decision),
-      rationale: sanitizeStateText(decision.rationale),
+      decision: normalizedDecision,
+      rationale,
       agent: decision.agent,
       sourceMessageIds: decision.sourceMessageIds,
       confidence: decision.confidence,
-    }))
-    .filter((decision): decision is typeof decision & { decision: string; rationale: string } =>
-      Boolean(decision.decision && decision.rationale),
-    )
+    }
+  })
 
-  const tasks = state.tasks
-    .map((task) => ({
+  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: sanitizeStateText(task.title),
+      title,
       status: task.status,
-      owner: sanitizeStateText(task.owner),
+      owner,
       externalId: task.externalId,
       source: task.source,
       sourceMessageIds: task.sourceMessageIds,
-    }))
-    .filter((task): task is typeof task & { title: string; owner: string } => Boolean(task.title && task.owner))
-
-  const openQuestions = state.openQuestions
-    .map((question) => ({
-      id: question.id,
-      text: sanitizeStateText(question.text),
-      source: question.source,
-      sourceMessageIds: question.sourceMessageIds,
-    }))
-    .filter((question): question is typeof question & { text: string } => Boolean(question.text))
-
-  const artifacts = state.artifacts
-    .map((artifact) => ({
-      id: artifact.id,
-      name: sanitizeStateText(artifact.name),
-      type: artifact.type,
-      pointer: sanitizeStateText(artifact.pointer),
-    }))
-    .filter((artifact): artifact is typeof artifact & { name: string; pointer: string } =>
-      Boolean(artifact.name && artifact.pointer),
-    )
-
-  const agentContributions = state.agentContributions
-    .map((note) => ({ id: note.id, agent: note.agent, summary: sanitizeStateText(note.summary) }))
-    .filter((note): note is typeof note & { summary: string } => Boolean(note.summary))
+    }
+  })
+
+  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
@@ -177,7 +197,7 @@ function buildExistingWorkstreamStateForCompactionPrompt(state: WorkstreamState)
     keyDecisions,
     tasks,
     openQuestions,
-    risks: state.risks.map((risk) => sanitizeStateText(risk)).filter((risk): risk is string => Boolean(risk)),
+    risks: sanitizeStateStrings(state.risks),
     artifacts,
     agentContributions,
     approvedBy: state.approvedBy ? sanitizeStateText(state.approvedBy) : undefined,
@@ -323,24 +343,21 @@ function splitByCharBudget(messages: ContextMessage[], maxChars: number): Contex
 }
 
 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 }
         : {}),
-    ...(appendUnique(base.newConstraints ?? [], next.newConstraints ?? []).length > 0
-      ? { newConstraints: appendUnique(base.newConstraints ?? [], next.newConstraints ?? []) }
-      : {}),
-    ...(appendUnique(base.newRisks ?? [], next.newRisks ?? []).length > 0
-      ? { newRisks: appendUnique(base.newRisks ?? [], next.newRisks ?? []) }
-      : {}),
-    ...(appendUnique(base.newQuestions ?? [], next.newQuestions ?? []).length > 0
-      ? { newQuestions: appendUnique(base.newQuestions ?? [], next.newQuestions ?? []) }
-      : {}),
-    ...(appendUnique(base.resolvedQuestions ?? [], next.resolvedQuestions ?? []).length > 0
-      ? { resolvedQuestions: appendUnique(base.resolvedQuestions ?? [], next.resolvedQuestions ?? []) }
-      : {}),
+    ...(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 ?? [])] }
       : {}),
@@ -538,7 +555,7 @@ export function mergeStateDelta(
     state.approvedBy = sanitizeStateText(delta.approvedBy) ?? undefined
   }
   if (delta.approvedAt !== undefined) {
-    state.approvedAt = delta.approvedAt
+    state.approvedAt = delta.approvedAt ?? undefined
   }
   if (delta.approvalMessageId !== undefined) {
     state.approvalMessageId = sanitizeStateText(delta.approvalMessageId) ?? undefined
@@ -678,54 +695,44 @@ export function createContextCompactionRuntime(
     const candidatePlan =
       state.currentPlan && !state.currentPlan.approved ? sanitizeStateText(state.currentPlan.text) : null
 
-    const approvedConstraints = state.activeConstraints
-      .filter((constraint) => constraint.approved)
-      .map((constraint) => ({ ...constraint, text: sanitizeStateText(constraint.text) }))
-      .filter((constraint): constraint is typeof constraint & { text: string } => Boolean(constraint.text))
-
-    const candidateConstraints = state.activeConstraints
-      .filter((constraint) => !constraint.approved)
-      .map((constraint) => ({ ...constraint, text: sanitizeStateText(constraint.text) }))
-      .filter((constraint): constraint is typeof constraint & { text: string } => Boolean(constraint.text))
-
-    const openQuestions = state.openQuestions
-      .map((question) => sanitizeStateText(question.text))
-      .filter((question): question is string => Boolean(question))
-
-    const decisions = state.keyDecisions
-      .map((decision) => ({
-        agent: decision.agent,
-        decision: sanitizeStateText(decision.decision),
-        rationale: sanitizeStateText(decision.rationale),
-        confidence: decision.confidence,
-      }))
-      .filter((decision): decision is typeof decision & { decision: string; rationale: string } =>
-        Boolean(decision.decision && decision.rationale),
-      )
-
-    const tasks = state.tasks
-      .map((task) => ({
-        title: sanitizeStateText(task.title),
-        status: task.status,
-        owner: sanitizeStateText(task.owner),
-        externalId: task.externalId,
-        source: task.source,
-      }))
-      .filter((task): task is typeof task & { title: string; owner: string } => Boolean(task.title && task.owner))
-
-    const artifacts = state.artifacts
-      .map((artifact) => ({
-        name: sanitizeStateText(artifact.name),
-        type: artifact.type,
-        pointer: sanitizeStateText(artifact.pointer),
-      }))
-      .filter((artifact): artifact is typeof artifact & { name: string; pointer: string } =>
-        Boolean(artifact.name && artifact.pointer),
-      )
-
-    const agentContributions = state.agentContributions
-      .map((note) => ({ agent: note.agent, summary: sanitizeStateText(note.summary) }))
-      .filter((note): note is typeof note & { summary: string } => Boolean(note.summary))
+    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 },
@@ -747,7 +754,7 @@ export function createContextCompactionRuntime(
       },
       decisions,
       openQuestions,
-      risks: state.risks.map((risk) => sanitizeStateText(risk)).filter((risk): risk is string => Boolean(risk)),
+      risks: sanitizeStateStrings(state.risks),
       tasks,
       artifacts,
       agentContributions,
@@ -777,9 +784,6 @@ 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 * CONTEXT_OUTPUT_RESERVE_MAX_RATIO))
     const safetyMargin = Math.min(safetyMarginTokens, Math.floor(contextSize * CONTEXT_SAFETY_MARGIN_MAX_RATIO))
@@ -827,6 +831,23 @@ export function createContextCompactionRuntime(
     return { summary, stateDelta: delta }
   }
 
+  const rollupSummaryIfOversized = async (
+    summary: string,
+    state: WorkstreamState,
+  ): Promise<{ summary: string; state: WorkstreamState; output: CompactionOutput }> => {
+    if (estimateTokens(summary) <= summaryRollupMaxTokens) {
+      return { summary, state, output: { summary, stateDelta: {} } }
+    }
+
+    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 }
+  }
+
   const compactHistory = async (params: CompactHistoryParams): Promise<CompactHistoryResult> => {
     let summaryText = normalizeSummary(params.summaryText)
     let remainingMessages = [...params.liveMessages]
@@ -891,14 +912,10 @@ export function createContextCompactionRuntime(
       let nextState = mergeStateDelta(state, compactionOutput.stateDelta, now)
 
       if (estimateTokens(nextSummary) > summaryRollupMaxTokens) {
-        const rollupOutput = await compactContextMessages({
-          previousSummary: '',
-          existingState: nextState,
-          newMessages: [{ role: 'assistant', text: nextSummary, sourceMessageId: 'summary-rollup' }],
-        })
-        nextSummary = normalizeSummary(rollupOutput.summary)
-        nextState = mergeStateDelta(nextState, rollupOutput.stateDelta, now)
-        compactionOutput = rollupOutput
+        const rollup = await rollupSummaryIfOversized(nextSummary, nextState)
+        nextSummary = rollup.summary
+        nextState = rollup.state
+        compactionOutput = rollup.output
       }
 
       if (nextSummary.length >= sourceText.length) {