@lota-sdk/core 0.1.15 → 0.1.16

package/src/queues/regular-chat-memory-digest.queue.ts

@@ -1,16 +1,5 @@
-import { Queue, Worker } from 'bullmq'
-
-import { serverLogger } from '../config/logger'
-import { getRedisConnectionForBullMQ } from '../redis'
-import {
-  attachWorkerEvents,
-  DEFAULT_JOB_RETENTION,
-  getWorkerPath,
-  LONG_JOB_LOCK_DURATION_MS,
-  createWorkerShutdown,
-  registerShutdownSignals,
-} from '../workers/worker-utils'
-import type { WorkerHandle } from '../workers/worker-utils'
+import { getWorkerPath, LONG_JOB_LOCK_DURATION_MS } from '../workers/worker-utils'
+import { createQueueFactory } from './queue-factory'
 import {
   buildRegularChatMemoryDigestDeduplicationId,
   buildRegularChatMemoryDigestJobOptions,
@@ -20,50 +9,25 @@ export interface RegularChatMemoryDigestJob {
   orgId: string
 }
 
-const REGULAR_CHAT_MEMORY_DIGEST_QUEUE = 'regular-chat-memory-digest'
-
-let _regularChatMemoryDigestQueue: Queue<RegularChatMemoryDigestJob> | null = null
-function getRegularChatMemoryDigestQueue(): Queue<RegularChatMemoryDigestJob> {
-  if (!_regularChatMemoryDigestQueue) {
-    _regularChatMemoryDigestQueue = new Queue<RegularChatMemoryDigestJob>(REGULAR_CHAT_MEMORY_DIGEST_QUEUE, {
-      connection: getRedisConnectionForBullMQ(),
-      defaultJobOptions: { ...DEFAULT_JOB_RETENTION, attempts: 2, backoff: { type: 'exponential', delay: 5000 } },
-    })
-  }
-  return _regularChatMemoryDigestQueue
-}
-
-export async function enqueueRegularChatMemoryDigest(job: RegularChatMemoryDigestJob) {
-  return await getRegularChatMemoryDigestQueue().add(
-    'run-digest',
-    job,
-    buildRegularChatMemoryDigestJobOptions(job.orgId),
-  )
+const regularChatMemoryDigest = createQueueFactory<RegularChatMemoryDigestJob>({
+  name: 'regular-chat-memory-digest',
+  displayName: 'Regular chat memory digest',
+  jobName: 'run-digest',
+  concurrency: 1,
+  lockDuration: LONG_JOB_LOCK_DURATION_MS,
+  defaultJobOptions: { attempts: 2, backoff: { type: 'exponential', delay: 5000 } },
+  processorPath: getWorkerPath('regular-chat-memory-digest.worker.ts'),
+})
+
+export function enqueueRegularChatMemoryDigest(job: RegularChatMemoryDigestJob) {
+  return regularChatMemoryDigest.enqueue(job, buildRegularChatMemoryDigestJobOptions(job.orgId))
 }
 
 export async function clearRegularChatMemoryDigestDeduplicationKey(orgId: string): Promise<void> {
-  await getRegularChatMemoryDigestQueue().removeDeduplicationKey(buildRegularChatMemoryDigestDeduplicationId(orgId))
+  await regularChatMemoryDigest.getQueue().removeDeduplicationKey(buildRegularChatMemoryDigestDeduplicationId(orgId))
 }
 
-export function startRegularChatMemoryDigestWorker(options: { registerSignals?: boolean } = {}): WorkerHandle {
-  const { registerSignals = import.meta.main } = options
-  const processorPath = getWorkerPath('regular-chat-memory-digest.worker.ts')
-  const worker = new Worker(REGULAR_CHAT_MEMORY_DIGEST_QUEUE, processorPath, {
-    connection: getRedisConnectionForBullMQ(),
-    concurrency: 1,
-    lockDuration: LONG_JOB_LOCK_DURATION_MS,
-  })
-
-  attachWorkerEvents(worker, 'Regular chat memory digest', serverLogger)
-
-  const shutdown = createWorkerShutdown(worker, 'Regular chat memory digest', serverLogger)
-
-  if (registerSignals) {
-    registerShutdownSignals({ name: 'Regular chat memory digest', shutdown, logger: serverLogger })
-  }
-
-  return { worker, shutdown }
-}
+export const startRegularChatMemoryDigestWorker = regularChatMemoryDigest.startWorker
 
 if (import.meta.main) {
   startRegularChatMemoryDigestWorker()

package/src/queues/skill-extraction.queue.ts

@@ -1,58 +1,26 @@
-import { Queue, Worker } from 'bullmq'
-
-import { serverLogger } from '../config/logger'
-import { getRedisConnectionForBullMQ } from '../redis'
-import {
-  attachWorkerEvents,
-  DEFAULT_JOB_RETENTION,
-  getWorkerPath,
-  LONG_JOB_LOCK_DURATION_MS,
-  createWorkerShutdown,
-  registerShutdownSignals,
-} from '../workers/worker-utils'
-import type { WorkerHandle } from '../workers/worker-utils'
+import { getWorkerPath } from '../workers/worker-utils'
+import { createQueueFactory } from './queue-factory'
 import { buildSkillExtractionJobOptions } from './skill-extraction.config'
 
 export interface SkillExtractionJob {
   orgId: string
 }
 
-const SKILL_EXTRACTION_QUEUE = 'skill-extraction'
-
-let _skillExtractionQueue: Queue<SkillExtractionJob> | null = null
-function getSkillExtractionQueue(): Queue<SkillExtractionJob> {
-  if (!_skillExtractionQueue) {
-    _skillExtractionQueue = new Queue<SkillExtractionJob>(SKILL_EXTRACTION_QUEUE, {
-      connection: getRedisConnectionForBullMQ(),
-      defaultJobOptions: { ...DEFAULT_JOB_RETENTION, attempts: 2, backoff: { type: 'exponential', delay: 5000 } },
-    })
-  }
-  return _skillExtractionQueue
+const skillExtraction = createQueueFactory<SkillExtractionJob>({
+  name: 'skill-extraction',
+  displayName: 'Skill extraction',
+  jobName: 'run-extraction',
+  concurrency: 1,
+  lockDuration: 600_000,
+  defaultJobOptions: { attempts: 2, backoff: { type: 'exponential', delay: 5000 } },
+  processorPath: getWorkerPath('skill-extraction.worker.ts'),
+})
+
+export function enqueueSkillExtraction(job: SkillExtractionJob) {
+  return skillExtraction.enqueue(job, buildSkillExtractionJobOptions(job.orgId))
 }
 
-export async function enqueueSkillExtraction(job: SkillExtractionJob) {
-  return await getSkillExtractionQueue().add('run-extraction', job, buildSkillExtractionJobOptions(job.orgId))
-}
-
-export function startSkillExtractionWorker(options: { registerSignals?: boolean } = {}): WorkerHandle {
-  const { registerSignals = import.meta.main } = options
-  const processorPath = getWorkerPath('skill-extraction.worker.ts')
-  const worker = new Worker(SKILL_EXTRACTION_QUEUE, processorPath, {
-    connection: getRedisConnectionForBullMQ(),
-    concurrency: 1,
-    lockDuration: LONG_JOB_LOCK_DURATION_MS,
-  })
-
-  attachWorkerEvents(worker, 'Skill extraction', serverLogger)
-
-  const shutdown = createWorkerShutdown(worker, 'Skill extraction', serverLogger)
-
-  if (registerSignals) {
-    registerShutdownSignals({ name: 'Skill extraction', shutdown, logger: serverLogger })
-  }
-
-  return { worker, shutdown }
-}
+export const startSkillExtractionWorker = skillExtraction.startWorker
 
 if (import.meta.main) {
   startSkillExtractionWorker()

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

@@ -1,65 +1,33 @@
-import { Queue, Worker } from 'bullmq'
 import type { Job } from 'bullmq'
 
-import { serverLogger } from '../config/logger'
 import { ensureRecordId } from '../db/record-id'
 import { databaseService } from '../db/service'
-import { getRedisConnectionForBullMQ } from '../redis'
 import { workstreamTitleService } from '../services/workstream-title.service'
-import {
-  attachWorkerEvents,
-  createTracedWorkerProcessor,
-  createWorkerShutdown,
-  DEFAULT_JOB_RETENTION,
-  registerShutdownSignals,
-} from '../workers/worker-utils'
-import type { WorkerHandle } from '../workers/worker-utils'
+import { createQueueFactory } from './queue-factory'
 
 interface WorkstreamTitleGenerationJob {
   workstreamId: string
   sourceText: string
 }
 
-const WORKSTREAM_TITLE_GENERATION_QUEUE = 'workstream-title-generation'
-
-let _workstreamTitleGenerationQueue: Queue<WorkstreamTitleGenerationJob> | null = null
-function getWorkstreamTitleGenerationQueue(): Queue<WorkstreamTitleGenerationJob> {
-  if (!_workstreamTitleGenerationQueue) {
-    _workstreamTitleGenerationQueue = new Queue<WorkstreamTitleGenerationJob>(WORKSTREAM_TITLE_GENERATION_QUEUE, {
-      connection: getRedisConnectionForBullMQ(),
-      defaultJobOptions: { ...DEFAULT_JOB_RETENTION, attempts: 2, backoff: { type: 'exponential', delay: 2_000 } },
-    })
-  }
-  return _workstreamTitleGenerationQueue
-}
-
-export async function enqueueWorkstreamTitleGeneration(job: WorkstreamTitleGenerationJob) {
-  return await getWorkstreamTitleGenerationQueue().add('generate-workstream-title', job, {
-    jobId: `workstream-title:${job.workstreamId}`,
-  })
-}
-
 async function processWorkstreamTitleGenerationJob(job: Job<WorkstreamTitleGenerationJob>): Promise<void> {
   await databaseService.connect()
   const workstreamRef = ensureRecordId(job.data.workstreamId)
   await workstreamTitleService.generateAndPersistTitle(workstreamRef, job.data.sourceText)
 }
 
-export function startWorkstreamTitleGenerationWorker(options: { registerSignals?: boolean } = {}): WorkerHandle {
-  const { registerSignals = import.meta.main } = options
-  const worker = new Worker(
-    WORKSTREAM_TITLE_GENERATION_QUEUE,
-    createTracedWorkerProcessor(WORKSTREAM_TITLE_GENERATION_QUEUE, processWorkstreamTitleGenerationJob),
-    { connection: getRedisConnectionForBullMQ(), concurrency: 2, lockDuration: 60_000 },
-  )
-
-  attachWorkerEvents(worker, 'Workstream title generation', serverLogger)
-
-  const shutdown = createWorkerShutdown(worker, 'Workstream title generation', serverLogger)
-
-  if (registerSignals) {
-    registerShutdownSignals({ name: 'Workstream title generation', shutdown, logger: serverLogger })
-  }
-
-  return { worker, shutdown }
+const workstreamTitleGeneration = createQueueFactory<WorkstreamTitleGenerationJob>({
+  name: 'workstream-title-generation',
+  displayName: 'Workstream title generation',
+  jobName: 'generate-workstream-title',
+  concurrency: 2,
+  lockDuration: 60_000,
+  defaultJobOptions: { attempts: 2, backoff: { type: 'exponential', delay: 2_000 } },
+  processor: processWorkstreamTitleGenerationJob,
+})
+
+export function enqueueWorkstreamTitleGeneration(job: WorkstreamTitleGenerationJob) {
+  return workstreamTitleGeneration.enqueue(job, { jobId: `workstream-title:${job.workstreamId}` })
 }
+
+export const startWorkstreamTitleGenerationWorker = workstreamTitleGeneration.startWorker

package/src/redis/connection.ts

@@ -58,6 +58,7 @@ class RedisConnectionManagerImpl implements RedisConnectionManager {
   private healthCheckInterval: ReturnType<typeof setInterval> | null = null
   private isInitialized = false
   private isClosing = false
+  private isHealthCheckRunning = false
 
   constructor(private readonly options: CreateRedisConnectionManagerOptions) {
     this.initializeConnection()
@@ -128,6 +129,8 @@ class RedisConnectionManagerImpl implements RedisConnectionManager {
 
     const intervalMs = this.options.healthCheckIntervalMs ?? DEFAULT_HEALTH_CHECK_INTERVAL_MS
     this.healthCheckInterval = setInterval(async () => {
+      if (this.isHealthCheckRunning) return
+      this.isHealthCheckRunning = true
       try {
         if (this.redis && this.redis.status === 'ready') {
           await this.redis.ping()
@@ -136,8 +139,11 @@ class RedisConnectionManagerImpl implements RedisConnectionManager {
       } catch (error) {
         log(this.options.logger, 'warn', `Redis health check failed: ${getErrorMessage(error)}`)
         this.isHealthy = false
+      } finally {
+        this.isHealthCheckRunning = false
       }
     }, intervalMs)
+    this.healthCheckInterval.unref()
   }
 
   getConnection(): IORedis {

package/src/redis/index.ts

@@ -9,7 +9,7 @@ export {
 } from './connection-accessor'
 export { withOrgMemoryLock } from './org-memory-lock'
 export { LeaseLockLostError, withRedisLeaseLock } from './redis-lease-lock'
-export { createWorkstreamResumableContext } from './stream-context'
+export { closeSharedSubscriber, createWorkstreamResumableContext } from './stream-context'
 
 export { createRedisConnectionManager }
 export type { RedisConnectionManager }

package/src/redis/stream-context.ts

@@ -44,6 +44,17 @@ function getSharedSubscriber(): Subscriber {
   return sharedSubscriber.subscriber
 }
 
+export async function closeSharedSubscriber(): Promise<void> {
+  if (!sharedSubscriber) return
+  const { client } = sharedSubscriber
+  sharedSubscriber = undefined
+  try {
+    await client.quit()
+  } catch {
+    client.disconnect()
+  }
+}
+
 export function createWorkstreamResumableContext() {
   const redis = getRedisConnection()
   return createResumableStreamContext({

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

@@ -1,3 +1,5 @@
+import type { ExecutionMode, PlanArtifactSubmission, PlanNodeSpec } from '@lota-sdk/shared'
+
 import { getLeadAgentId } from '../config/agent-defaults'
 import { resolveOnboardingOwnerAgentId } from '../config/workstream-defaults'
 import type { ChatMode } from './agent-types'
@@ -31,6 +33,30 @@ export interface AgentToolPolicy<TSkill extends PropertyKey> {
   includeIndexedRepository: boolean
 }
 
+export const OWNERSHIP_DISPATCH_BLOCKED_TOOL_NAMES = Object.freeze([
+  'conversationSearch',
+  'createExecutionPlan',
+  'replaceExecutionPlan',
+  'submitExecutionNodeResult',
+  'listExecutionPlans',
+  'getExecutionPlanDetails',
+  'resumeExecutionPlanRun',
+  'consultSpecialist',
+  'consultTeam',
+  'teamThink',
+])
+
+function buildOwnershipDispatchArtifactPayload(artifacts: PlanArtifactSubmission[]) {
+  return artifacts.map((artifact) => ({
+    name: artifact.name,
+    kind: artifact.kind,
+    pointer: artifact.pointer,
+    ...(artifact.schemaRef ? { schemaRef: artifact.schemaRef } : {}),
+    ...(artifact.description ? { description: artifact.description } : {}),
+    ...(artifact.payload !== undefined ? { payload: artifact.payload } : {}),
+  }))
+}
+
 export function toChatMode(workstreamMode: 'direct' | 'group'): ChatMode {
   return workstreamMode === 'direct' ? 'fixedWorkstreamMode' : 'workstreamMode'
 }
@@ -160,37 +186,96 @@ export function buildWorkstreamAgentToolPolicy<TAgent extends string, TSkill ext
   }
 }
 
-export function buildTeamConsultationAgentToolPolicy<TAgent extends string, TSkill extends PropertyKey>(params: {
-  agentId: TAgent
-  blockedSkills: readonly TSkill[]
+export function buildTeamConsultationAgentToolPolicy({
+  githubInstalled,
+  provideRepoTool,
+  blockedToolNames,
+}: {
   blockedToolNames: readonly string[]
   githubInstalled: boolean
   provideRepoTool: boolean
-  getAgentSkills: (agentId: TAgent, mode: ChatMode) => TSkill[]
-}): AgentToolPolicy<TSkill> & { blockedToolNames: Set<string> } {
-  const skills = resolveActiveAgentSkills({
-    agentId: params.agentId,
-    workstreamMode: 'group',
-    mode: 'fixedWorkstreamMode',
-    onboardingActive: false,
-    linearInstalled: false,
-    getAgentSkills: params.getAgentSkills,
-  }).filter((skill) => !params.blockedSkills.includes(skill))
-
+}): AgentToolPolicy<string> & { blockedToolNames: Set<string> } {
   return {
     resolvedMode: 'fixedWorkstreamMode',
-    skills,
-    includeMemorySearch: true,
-    includeConversationSearch: true,
+    skills: [],
+    includeMemorySearch: false,
+    includeConversationSearch: false,
     includeMemoryRemember: false,
-    includeOrgActionSearch: true,
+    includeOrgActionSearch: false,
     includeMemoryBlockAppend: false,
-    includeReadFileParts: true,
+    includeReadFileParts: false,
     includeInspectWebsite: false,
     includeProceedInOnboarding: false,
     includeGithubIntegration: false,
     includeIndexRepositoryByURL: false,
-    includeIndexedRepository: params.githubInstalled && params.provideRepoTool,
-    blockedToolNames: new Set(params.blockedToolNames),
+    includeIndexedRepository: githubInstalled && provideRepoTool,
+    blockedToolNames: new Set(blockedToolNames),
+  }
+}
+
+export function buildOwnershipDispatchContextSection(params: {
+  node: PlanNodeSpec
+  resolvedInput: Record<string, unknown>
+  inputArtifacts: PlanArtifactSubmission[]
+}): string {
+  const payload = {
+    node: {
+      id: params.node.id,
+      label: params.node.label,
+      owner: params.node.owner,
+      objective: params.node.objective,
+      instructions: params.node.instructions,
+      outputSchemaRef: params.node.outputSchemaRef ?? null,
+      deliverables: params.node.deliverables,
+      successCriteria: params.node.successCriteria,
+      completionChecks: params.node.completionChecks,
+      toolPolicy: params.node.toolPolicy,
+      contextPolicy: params.node.contextPolicy,
+    },
+    resolvedInput: params.resolvedInput,
+    inputArtifacts: buildOwnershipDispatchArtifactPayload(params.inputArtifacts),
   }
+
+  return [
+    '<ownership-dispatch-execution>',
+    'You are executing a single isolated execution-plan node.',
+    'Do not ask the user questions. Do not reference any hidden or prior workstream chat history.',
+    'Use only the provided node context, resolved input, and input artifacts.',
+    'Return only the final structured node result that satisfies the required output contract.',
+    JSON.stringify(payload, null, 2),
+    '</ownership-dispatch-execution>',
+  ].join('\n')
+}
+
+export function buildOwnershipDispatchResponseGuard(params: {
+  node: PlanNodeSpec
+  executionMode?: ExecutionMode
+}): string {
+  const mode = params.executionMode ?? 'linear'
+
+  if (mode === 'linear') {
+    return [
+      '<ownership-dispatch-result-contract>',
+      'Return a single JSON object with this exact shape:',
+      '{"structuredOutput"?: object, "artifacts": Array<{ "name": string, "kind": "json"|"markdown"|"file"|"external-ref"|"record", "pointer": string, "schemaRef"?: string, "description"?: string, "payload"?: object|array }>, "notes"?: string}',
+      'Do not wrap the JSON in markdown or code fences.',
+      `Node label: ${params.node.label}`,
+      `Required deliverables: ${params.node.deliverables.length > 0 ? params.node.deliverables.map((item) => item.name).join(', ') : 'none'}`,
+      '</ownership-dispatch-result-contract>',
+    ].join('\n')
+  }
+
+  return [
+    '<ownership-dispatch-result-contract>',
+    'Produce outputs by calling the writeIntent tool for each deliverable.',
+    `Required deliverables: ${
+      params.node.deliverables
+        .filter((d) => d.required)
+        .map((d) => d.name)
+        .join(', ') || 'none'
+    }`,
+    'If writeIntent returns validation_failed, correct and re-call.',
+    'After all writes, return a brief summary.',
+    '</ownership-dispatch-result-contract>',
+  ].join('\n')
 }

package/src/runtime/approval-continuation.ts

@@ -45,21 +45,27 @@ export function readApprovalContinuationResponse(message: ChatMessage): Approval
 }
 
 export function isApprovalContinuationRequest(messages: ChatMessage[]): boolean {
-  const lastAssistant = [...messages].reverse().find((message) => message.role === 'assistant')
-  if (!lastAssistant) return false
+  let lastAssistantIndex = -1
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === 'assistant') {
+      lastAssistantIndex = i
+      break
+    }
+  }
+  if (lastAssistantIndex < 0) return false
 
-  const lastMessageIndex = messages.lastIndexOf(lastAssistant)
-  const hasUserAfter = messages.slice(lastMessageIndex + 1).some((message) => message.role === 'user')
+  const hasUserAfter = messages.slice(lastAssistantIndex + 1).some((message) => message.role === 'user')
   if (hasUserAfter) return false
 
-  return hasApprovalRespondedParts(lastAssistant)
+  return hasApprovalRespondedParts(messages[lastAssistantIndex])
 }
 
 const PLAN_TOOL_NAMES = new Set([
   'createExecutionPlan',
   'replaceExecutionPlan',
   'submitExecutionNodeResult',
-  'getActiveExecutionPlan',
+  'listExecutionPlans',
+  'getExecutionPlanDetails',
   'resumeExecutionPlanRun',
 ])
 

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

@@ -76,7 +76,7 @@ export function createWiredContextCompactionRuntime(deps: CreateContextCompactio
     const newEntriesText = params.newEntriesText.trim()
     if (!previousSummary && !newEntriesText) return ''
 
-    return await helperModelRuntime.generateHelperText({
+    return helperModelRuntime.generateHelperText({
       tag: 'memory-block-compaction',
       createAgent: createContextCompactionAgent,
       messages: [{ role: 'user', content: buildMemoryBlockCompactionPrompt({ previousSummary, newEntriesText }) }],

package/src/runtime/context-compaction.ts

@@ -2,7 +2,7 @@ import { createHash, randomUUID } from 'node:crypto'
 
 import type { ChatMessage } from '@lota-sdk/shared'
 
-import { CHARS_PER_TOKEN_ESTIMATE, compactWhitespace, readRecord, readString } from '../utils/string'
+import { CHARS_PER_TOKEN_ESTIMATE, compactWhitespace, readRecord, readString, stringifyUnknown } from '../utils/string'
 import {
   COMPACTION_CHUNK_MAX_CHARS,
   CONTEXT_COMPACTION_INCLUDED_TOOL_NAMES,
@@ -112,20 +112,6 @@ function createStableId(prefix: string, ...parts: Array<string | number | undefi
   return `${prefix}_${hash}`
 }
 
-function stringifyUnknown(value: unknown): string | null {
-  if (value === undefined) return null
-  if (typeof value === 'string') {
-    const normalized = value.trim()
-    return normalized.length > 0 ? normalized : null
-  }
-
-  try {
-    return JSON.stringify(value)
-  } catch {
-    return null
-  }
-}
-
 function appendUnique(values: string[], nextValues: string[]): string[] {
   const seen = new Set(values.map((value) => compactWhitespace(value).toLowerCase()))
   const merged = [...values]
@@ -766,6 +752,24 @@ export function createContextCompactionRuntime(
     const initialPayload = JSON.stringify([...(summaryPayload ? [summaryPayload] : []), ...remainingMessages])
     const inputChars = initialPayload.length
 
+    const buildEarlyExitResult = (estimatedTokens: number): CompactHistoryResult => {
+      const exitSummaryPayload = buildSyntheticSummaryPayload(summaryText)
+      const outputPayload = JSON.stringify([...(exitSummaryPayload ? [exitSummaryPayload] : []), ...remainingMessages])
+      return {
+        compacted: compactedMessages.length > 0,
+        summaryText,
+        ...(lastCompactedMessageId ? { lastCompactedMessageId } : {}),
+        compactedMessages,
+        compactedMessageCount: compactedMessages.length,
+        remainingMessageCount: remainingMessages.length,
+        estimatedTokens,
+        inputChars,
+        outputChars: outputPayload.length,
+        state,
+        stateDelta: mergedDelta,
+      }
+    }
+
     for (;;) {
       const assessment = shouldCompactHistory({
         summaryText,
@@ -774,40 +778,12 @@ export function createContextCompactionRuntime(
       })
 
       if (!assessment.shouldCompact) {
-        const summaryPayload = buildSyntheticSummaryPayload(summaryText)
-        const outputPayload = JSON.stringify([...(summaryPayload ? [summaryPayload] : []), ...remainingMessages])
-        return {
-          compacted: compactedMessages.length > 0,
-          summaryText,
-          ...(lastCompactedMessageId ? { lastCompactedMessageId } : {}),
-          compactedMessages,
-          compactedMessageCount: compactedMessages.length,
-          remainingMessageCount: remainingMessages.length,
-          estimatedTokens: assessment.estimatedTokens,
-          inputChars,
-          outputChars: outputPayload.length,
-          state,
-          stateDelta: mergedDelta,
-        }
+        return buildEarlyExitResult(assessment.estimatedTokens)
       }
 
       const boundary = Math.max(0, remainingMessages.length - params.tailMessageCount)
       if (boundary <= 0) {
-        const summaryPayload = buildSyntheticSummaryPayload(summaryText)
-        const outputPayload = JSON.stringify([...(summaryPayload ? [summaryPayload] : []), ...remainingMessages])
-        return {
-          compacted: compactedMessages.length > 0,
-          summaryText,
-          ...(lastCompactedMessageId ? { lastCompactedMessageId } : {}),
-          compactedMessages,
-          compactedMessageCount: compactedMessages.length,
-          remainingMessageCount: remainingMessages.length,
-          estimatedTokens: assessment.estimatedTokens,
-          inputChars,
-          outputChars: outputPayload.length,
-          state,
-          stateDelta: mergedDelta,
-        }
+        return buildEarlyExitResult(assessment.estimatedTokens)
       }
 
       const candidatePrefix = remainingMessages.slice(0, boundary)
@@ -816,21 +792,7 @@ export function createContextCompactionRuntime(
       const sourceText = toCompactionTranscript(contextMessages)
 
       if (!compactWhitespace(sourceText)) {
-        const summaryPayload = buildSyntheticSummaryPayload(summaryText)
-        const outputPayload = JSON.stringify([...(summaryPayload ? [summaryPayload] : []), ...remainingMessages])
-        return {
-          compacted: compactedMessages.length > 0,
-          summaryText,
-          ...(lastCompactedMessageId ? { lastCompactedMessageId } : {}),
-          compactedMessages,
-          compactedMessageCount: compactedMessages.length,
-          remainingMessageCount: remainingMessages.length,
-          estimatedTokens: assessment.estimatedTokens,
-          inputChars,
-          outputChars: outputPayload.length,
-          state,
-          stateDelta: mergedDelta,
-        }
+        return buildEarlyExitResult(assessment.estimatedTokens)
       }
 
       let compactionOutput = await compactContextMessages({