@lota-sdk/core 0.4.8 → 0.4.10

package/src/services/background-work.service.ts

@@ -0,0 +1,54 @@
+import { Context, Effect, FiberSet, Layer, Schema } from 'effect'
+
+/**
+ * Tagged error for the BackgroundWorkService surface. The service itself
+ * never returns this — it's reserved for future API extensions.
+ */
+export class BackgroundWorkError extends Schema.TaggedErrorClass<BackgroundWorkError>()(
+  '@lota-sdk/core/BackgroundWorkError',
+  { message: Schema.String, cause: Schema.optional(Schema.Defect) },
+) {}
+
+/**
+ * Supervised fire-and-forget fork pool.
+ *
+ * `run` schedules an effect on a process-wide FiberSet that is interrupted
+ * when the runtime scope closes — replaces ad-hoc `Effect.runFork`,
+ * `Effect.runForkWith`, and `Effect.forkDetach` call sites that would
+ * otherwise leak fibers across shutdown.
+ *
+ * Both methods accept any `Effect.Effect<A, E>`; failures are logged via
+ * `Effect.logError` and never propagate to the caller. `runForget` ignores
+ * both the result and the cause — use it for best-effort metrics, cache
+ * touches, and other strictly cosmetic side effects.
+ */
+export class BackgroundWorkService extends Context.Service<
+  BackgroundWorkService,
+  {
+    readonly run: <A, E>(effect: Effect.Effect<A, E>, label?: string) => Effect.Effect<void>
+    readonly runForget: <A, E>(effect: Effect.Effect<A, E>, label?: string) => Effect.Effect<void>
+  }
+>()('@lota-sdk/core/BackgroundWorkService') {}
+
+export const BackgroundWorkServiceLive = Layer.effect(
+  BackgroundWorkService,
+  Effect.gen(function* () {
+    const set = yield* FiberSet.make<unknown, unknown>()
+
+    const run = <A, E>(effect: Effect.Effect<A, E>, label?: string): Effect.Effect<void> =>
+      Effect.asVoid(
+        FiberSet.run(
+          set,
+          effect.pipe(
+            Effect.withLogSpan(label ?? 'background'),
+            Effect.catchCause((cause) => Effect.logError(cause)),
+          ),
+        ),
+      )
+
+    const runForget = <A, E>(effect: Effect.Effect<A, E>, label?: string): Effect.Effect<void> =>
+      Effect.asVoid(FiberSet.run(set, effect.pipe(Effect.withLogSpan(label ?? 'background-forget'), Effect.ignore)))
+
+    return { run, runForget } as const
+  }),
+)

package/src/services/chat-run-registry.service.ts

@@ -1,3 +1,15 @@
+import { Context, Effect, FiberMap, Layer } from 'effect'
+
 import { ChatRunRegistry } from '../runtime/chat-run-registry'
 
-export const chatRunRegistry = new ChatRunRegistry()
+export class ChatRunRegistryTag extends Context.Service<ChatRunRegistryTag, ChatRunRegistry>()(
+  '@lota-sdk/core/ChatRunRegistry',
+) {}
+
+export const ChatRunRegistryLive = Layer.effect(
+  ChatRunRegistryTag,
+  Effect.gen(function* () {
+    const trackedRuns = yield* FiberMap.make<string>()
+    return new ChatRunRegistry(trackedRuns)
+  }),
+)

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

@@ -1,16 +1,26 @@
 import type { ChatMessage } from '@lota-sdk/shared'
+import { Context, Effect, Layer } from 'effect'
 
 import { chatLogger } from '../config/logger'
 import type { RecordIdRef } from '../db/record-id'
 import { recordIdToString } from '../db/record-id'
-import { databaseService } from '../db/service'
+import type { SurrealDBService } from '../db/service'
 import { TABLES } from '../db/tables'
-import { getRedisConnection } from '../redis/connection-accessor'
-import { withRedisLeaseLock } from '../redis/redis-lease-lock'
-import { CONTEXT_WINDOW_TOKENS, THREAD_RAW_TAIL_MESSAGES } from '../runtime/context-compaction-constants'
-import { contextCompactionRuntime, compactMemoryBlockSummary } from './context-compaction-runtime.singleton'
-import { threadMessageService } from './thread-message.service'
-import { ThreadSchema } from './thread.types'
+import { BadRequestError } from '../effect/errors'
+import { DatabaseServiceTag, RedisServiceTag } from '../effect/services'
+import type { RedisConnectionManager } from '../redis/connection'
+import { withLeaseLock } from '../redis/redis-lease-lock'
+import {
+  CONTEXT_WINDOW_TOKENS,
+  THREAD_RAW_TAIL_MESSAGES,
+} from '../runtime/context-compaction/context-compaction-constants'
+import { createWiredContextCompactionRuntime } from '../runtime/context-compaction/context-compaction-runtime'
+import type { HelperModelRuntime } from '../runtime/helper-model'
+import { HelperModelTag } from '../runtime/helper-model'
+import { nowEpochMillis } from '../utils/date-time'
+import type { makeThreadMessageService } from './thread/thread-message.service'
+import { ThreadMessageServiceTag } from './thread/thread-message.service'
+import { ThreadSchema } from './thread/thread.types'
 
 interface PersistedCompactionMetrics {
   domain: 'thread'
@@ -24,87 +34,127 @@ interface PersistedCompactionMetrics {
   estimatedTokens: number
 }
 
-class ContextCompactionService {
-  createSummaryMessage(summaryText: string) {
-    return contextCompactionRuntime.createSummaryMessage(summaryText)
-  }
-
-  estimateThreshold(contextSize = CONTEXT_WINDOW_TOKENS): number {
-    return contextCompactionRuntime.estimateThreshold(contextSize)
-  }
-
-  shouldCompactHistory(params: { summaryText: string; liveMessages: ChatMessage[]; contextSize?: number }) {
-    return contextCompactionRuntime.shouldCompactHistory(params)
-  }
-
-  async compactThreadHistory(params: { threadId: RecordIdRef; contextSize?: number }): Promise<{ compacted: boolean }> {
-    const entityId = recordIdToString(params.threadId, TABLES.THREAD)
-
-    return withRedisLeaseLock(
-      {
-        redis: getRedisConnection(),
-        lockKey: `compaction:lock:${entityId}`,
-        lockTtlMs: 120_000,
-        maxWaitMs: 30_000,
-        label: 'context-compaction',
-      },
-      async () => {
-        const thread = await databaseService.findOne(TABLES.THREAD, { id: params.threadId }, ThreadSchema)
-        if (!thread) {
-          throw new Error(`Thread not found for compaction: ${entityId}`)
-        }
-
-        const liveMessages = await threadMessageService.listMessagesAfterCursor(
-          params.threadId,
-          typeof thread.lastCompactedMessageId === 'string' ? thread.lastCompactedMessageId : undefined,
-        )
-
-        const result = await contextCompactionRuntime.compactHistory({
-          summaryText: typeof thread.compactionSummary === 'string' ? thread.compactionSummary : '',
-          liveMessages,
-          tailMessageCount: THREAD_RAW_TAIL_MESSAGES,
-          contextSize: params.contextSize,
-        })
-
-        if (!result.compacted || !result.lastCompactedMessageId) {
-          return { compacted: false }
-        }
-
-        if (result.compactedMessages.length > 0) {
-          await threadMessageService.upsertMessages({ threadId: params.threadId, messages: result.compactedMessages })
-        }
-
-        await databaseService.update(
-          TABLES.THREAD,
-          params.threadId,
-          { compactionSummary: result.summaryText, lastCompactedMessageId: result.lastCompactedMessageId },
-          ThreadSchema,
-        )
-
-        this.logCompactionMetrics({
-          domain: 'thread',
-          entityId,
-          inputChars: result.inputChars,
-          outputChars: result.outputChars,
-          savedChars: Math.max(0, result.inputChars - result.outputChars),
-          summaryLength: result.summaryText.length,
-          compactedMessageCount: result.compactedMessageCount,
-          remainingMessageCount: result.remainingMessageCount,
-          estimatedTokens: result.estimatedTokens,
-        })
-
-        return { compacted: true }
-      },
-    )
-  }
+function logCompactionMetrics(metrics: PersistedCompactionMetrics): void {
+  chatLogger.info`Persisted chat compaction applied metrics=${JSON.stringify(metrics)}`
+}
 
-  async compactMemoryBlock(params: { previousSummary: string; newEntriesText: string }): Promise<string> {
-    return compactMemoryBlockSummary(params)
-  }
+interface ContextCompactionDeps {
+  db: SurrealDBService
+  redis: RedisConnectionManager
+  threadMessageService: ReturnType<typeof makeThreadMessageService>
+  helperModelRuntime: HelperModelRuntime
+}
 
-  private logCompactionMetrics(metrics: PersistedCompactionMetrics): void {
-    chatLogger.info`Persisted chat compaction applied metrics=${JSON.stringify(metrics)}`
+export function makeContextCompactionService(deps: ContextCompactionDeps) {
+  const { db, redis, threadMessageService, helperModelRuntime } = deps
+  const contextCompactionRuntime = createWiredContextCompactionRuntime({
+    helperModelRuntime,
+    now: nowEpochMillis,
+    randomId: () => Bun.randomUUIDv7(),
+  })
+
+  const compactThreadHistoryEffect = (params: { threadId: RecordIdRef; contextSize?: number }) =>
+    Effect.gen(function* () {
+      const entityId = recordIdToString(params.threadId, TABLES.THREAD)
+
+      return yield* withLeaseLock(
+        {
+          redis: redis.getConnection(),
+          lockKey: `compaction:lock:${entityId}`,
+          lockTtlMs: 120_000,
+          maxWaitMs: 30_000,
+          label: 'context-compaction',
+        },
+        () =>
+          Effect.gen(function* () {
+            const thread = yield* db.findOne(TABLES.THREAD, { id: params.threadId }, ThreadSchema)
+            if (!thread) {
+              return yield* new BadRequestError({ message: `Thread not found for compaction: ${entityId}` })
+            }
+
+            const liveMessages = yield* threadMessageService.listMessagesAfterCursorEffect(
+              params.threadId,
+              typeof thread.lastCompactedMessageId === 'string' ? thread.lastCompactedMessageId : undefined,
+            )
+
+            const result = yield* Effect.tryPromise(() =>
+              contextCompactionRuntime.compactHistory({
+                summaryText: typeof thread.compactionSummary === 'string' ? thread.compactionSummary : '',
+                liveMessages,
+                tailMessageCount: THREAD_RAW_TAIL_MESSAGES,
+                contextSize: params.contextSize,
+              }),
+            )
+
+            if (!result.compacted || !result.lastCompactedMessageId) {
+              return { compacted: false }
+            }
+
+            if (result.compactedMessages.length > 0) {
+              yield* threadMessageService.upsertMessagesEffect({
+                threadId: params.threadId,
+                messages: result.compactedMessages,
+              })
+            }
+
+            yield* db.update(
+              TABLES.THREAD,
+              params.threadId,
+              { compactionSummary: result.summaryText, lastCompactedMessageId: result.lastCompactedMessageId },
+              ThreadSchema,
+            )
+
+            logCompactionMetrics({
+              domain: 'thread',
+              entityId,
+              inputChars: result.inputChars,
+              outputChars: result.outputChars,
+              savedChars: Math.max(0, result.inputChars - result.outputChars),
+              summaryLength: result.summaryText.length,
+              compactedMessageCount: result.compactedMessageCount,
+              remainingMessageCount: result.remainingMessageCount,
+              estimatedTokens: result.estimatedTokens,
+            })
+
+            return { compacted: true }
+          }),
+      )
+    })
+
+  const compactMemoryBlockEffect = (params: { previousSummary: string; newEntriesText: string }) =>
+    Effect.tryPromise(() => contextCompactionRuntime.compactMemoryBlockSummary(params))
+
+  return {
+    createSummaryMessage(summaryText: string) {
+      return contextCompactionRuntime.createSummaryMessage(summaryText)
+    },
+
+    estimateThreshold(contextSize = CONTEXT_WINDOW_TOKENS): number {
+      return contextCompactionRuntime.estimateThreshold(contextSize)
+    },
+
+    shouldCompactHistory(params: { summaryText: string; liveMessages: ChatMessage[]; contextSize?: number }) {
+      return contextCompactionRuntime.shouldCompactHistory(params)
+    },
+
+    compactThreadHistory: compactThreadHistoryEffect,
+
+    compactMemoryBlock: compactMemoryBlockEffect,
   }
 }
 
-export const contextCompactionService = new ContextCompactionService()
+export class ContextCompactionServiceTag extends Context.Service<
+  ContextCompactionServiceTag,
+  ReturnType<typeof makeContextCompactionService>
+>()('@lota-sdk/core/ContextCompactionService') {}
+
+export const ContextCompactionServiceLive = Layer.effect(
+  ContextCompactionServiceTag,
+  Effect.gen(function* () {
+    const db = yield* DatabaseServiceTag
+    const redis = yield* RedisServiceTag
+    const threadMessageService = yield* ThreadMessageServiceTag
+    const helperModelRuntime = yield* HelperModelTag
+    return makeContextCompactionService({ db, redis, threadMessageService, helperModelRuntime })
+  }),
+)

package/src/services/document-chunk.service.ts

@@ -1,6 +1,11 @@
+import { Context, Schema, Effect, Layer } from 'effect'
+
 import { chunkMarkdownDocument, chunkPagedDocument, chunkPlainTextDocument } from '../document/org-document-chunking'
 import type { ParsedDocumentChunk } from '../document/org-document-chunking'
-import { getDefaultEmbeddings } from '../embeddings/provider'
+import { makeEffectTryPromiseWithMessage } from '../effect/helpers'
+import { RuntimeConfigServiceTag } from '../effect/services'
+import { ProviderEmbeddings } from '../embeddings/provider'
+import { sha256Hex } from '../utils/crypto'
 import { CHARS_PER_TOKEN_ESTIMATE } from '../utils/string'
 
 type DocumentChunkEmbeddings = {
@@ -8,15 +13,19 @@ type DocumentChunkEmbeddings = {
   embedQuery(query: string): Promise<number[]>
 }
 
-function createDocumentChunkEmbeddings(): DocumentChunkEmbeddings {
-  const embeddings = getDefaultEmbeddings()
+function createDocumentChunkEmbeddings(embeddingModel: string, openRouterApiKey?: string): DocumentChunkEmbeddings {
+  const embeddings = new ProviderEmbeddings({ modelId: embeddingModel, openRouterApiKey })
 
   return {
-    embedDocuments: async (documents) => await embeddings.embedDocuments(documents),
-    embedQuery: async (query) => await embeddings.embedQuery(query),
+    embedDocuments: (documents) => embeddings.embedDocuments(documents),
+    embedQuery: (query) => embeddings.embedQuery(query),
   }
 }
 
+function estimateDocumentChunkTokenCount(content: string): number {
+  return Math.max(1, Math.ceil(content.length / (CHARS_PER_TOKEN_ESTIMATE + 1)))
+}
+
 export interface VersionedDocumentChunkRecordShape {
   chunkKey: string
   chunkIndex: number
@@ -28,46 +37,20 @@ export interface VersionedDocumentChunkRecordShape {
   archivedAt?: string | number | Date | null
 }
 
-export class DocumentChunkService {
-  constructor(private readonly embeddings: DocumentChunkEmbeddings = createDocumentChunkEmbeddings()) {}
-
+export interface DocumentChunkService {
   buildChunks(params: {
     source: string
     renderMode: 'markdown' | 'text' | 'pdf'
     text: string
     sectionPath?: string
     pages?: Array<{ pageNumber: number; text: string }>
-  }): ParsedDocumentChunk[] {
-    if (
-      params.source === 'indexedOutcome' ||
-      params.source === 'websiteIntelligence' ||
-      params.renderMode === 'markdown'
-    ) {
-      return chunkMarkdownDocument({ text: params.text, baseSectionPath: params.sectionPath })
-    }
-
-    if (params.renderMode === 'pdf' && params.pages && params.pages.length > 0) {
-      return chunkPagedDocument({ pages: params.pages })
-    }
-
-    return chunkPlainTextDocument({ text: params.text, sectionPath: params.sectionPath })
-  }
-
-  hashContent(content: string): string {
-    return new Bun.CryptoHasher('sha256').update(content).digest('hex')
-  }
-
+  }): ParsedDocumentChunk[]
+  hashContent(content: string): string
   // Uses 4 chars/token (conservative estimate for document content which tends
   // to have longer words than conversational text where 3 chars/token is used).
-  estimateTokenCount(content: string): number {
-    return Math.max(1, Math.ceil(content.length / (CHARS_PER_TOKEN_ESTIMATE + 1)))
-  }
-
-  async embedQuery(query: string): Promise<number[]> {
-    return this.embeddings.embedQuery(query)
-  }
-
-  async syncVersionedChunks<TRecord, TPayload>(params: {
+  estimateTokenCount(content: string): number
+  embedQuery(query: string): Promise<number[]>
+  syncVersionedChunks<TRecord, TPayload>(params: {
     sourceVersionKey: string
     chunks: ParsedDocumentChunk[]
     loadExisting: () => Promise<TRecord[]>
@@ -81,64 +64,144 @@ export class DocumentChunkService {
       tokenEstimate: number
     }) => TPayload
     selectShape: (row: TRecord) => VersionedDocumentChunkRecordShape
-  }): Promise<void> {
-    const existingRows = await params.loadExisting()
-    const existingByChunkKey = new Map(
-      existingRows
-        .filter((row) => params.selectShape(row).sourceVersionKey === params.sourceVersionKey)
-        .map((row) => [params.selectShape(row).chunkKey, row]),
-    )
-    const embeddings = await this.embeddings.embedDocuments(params.chunks.map((chunk) => chunk.content))
-    const seenChunkKeys = new Set<string>()
-    const staleVersionRows = existingRows.filter(
-      (row) => params.selectShape(row).sourceVersionKey !== params.sourceVersionKey,
-    )
-
-    await params.archive(staleVersionRows)
-
-    await Promise.all(
-      params.chunks.map(async (chunk, index) => {
-        const contentHash = this.hashContent(chunk.content)
-        const existingRow = existingByChunkKey.get(chunk.chunkKey)
-        const payload = params.buildPayload({
-          chunk,
-          embedding: embeddings[index] ?? [],
-          contentHash,
-          tokenEstimate: this.estimateTokenCount(chunk.content),
-        })
-
-        seenChunkKeys.add(chunk.chunkKey)
-
-        if (!existingRow) {
-          await params.create(payload)
-          return
-        }
+  }): Effect.Effect<void, DocumentChunkServiceError>
+}
 
-        const current = params.selectShape(existingRow)
-        const hasChanged =
-          current.contentHash !== contentHash ||
-          current.chunkIndex !== chunk.chunkIndex ||
-          (current.sectionPath ?? null) !== (chunk.sectionPath ?? null) ||
-          (current.pageStart ?? null) !== (chunk.pageStart ?? null) ||
-          (current.pageEnd ?? null) !== (chunk.pageEnd ?? null)
+class DocumentChunkServiceError extends Schema.TaggedErrorClass<DocumentChunkServiceError>()(
+  'DocumentChunkServiceError',
+  { message: Schema.String, cause: Schema.Defect },
+) {}
 
-        if (!hasChanged) {
-          return
-        }
+const effectTryDocumentChunkPromise = makeEffectTryPromiseWithMessage(
+  (message, cause) => new DocumentChunkServiceError({ message, cause }),
+)
 
-        await params.update(existingRow, payload)
-      }),
-    )
+function tryDocumentChunkPromise<A>(
+  message: string,
+  evaluate: () => PromiseLike<A> | Effect.Effect<A, unknown>,
+): Effect.Effect<A, DocumentChunkServiceError> {
+  return effectTryDocumentChunkPromise(evaluate, message)
+}
 
-    const removedCurrentVersionRows = existingRows.filter((row) => {
-      const current = params.selectShape(row)
-      return current.sourceVersionKey === params.sourceVersionKey && !seenChunkKeys.has(current.chunkKey)
-    })
+export function makeDocumentChunkService(embeddings: DocumentChunkEmbeddings): DocumentChunkService {
+  return {
+    buildChunks(params) {
+      if (
+        params.source === 'indexedOutcome' ||
+        params.source === 'websiteIntelligence' ||
+        params.renderMode === 'markdown'
+      ) {
+        return chunkMarkdownDocument({ text: params.text, baseSectionPath: params.sectionPath })
+      }
+
+      if (params.renderMode === 'pdf' && params.pages && params.pages.length > 0) {
+        return chunkPagedDocument({ pages: params.pages })
+      }
+
+      return chunkPlainTextDocument({ text: params.text, sectionPath: params.sectionPath })
+    },
+
+    hashContent(content) {
+      return sha256Hex(content)
+    },
+
+    estimateTokenCount(content) {
+      return estimateDocumentChunkTokenCount(content)
+    },
+
+    embedQuery(query) {
+      return embeddings.embedQuery(query)
+    },
+
+    syncVersionedChunks(params) {
+      return Effect.gen(function* () {
+        const [existingRows, embeddedChunks] = yield* Effect.all([
+          tryDocumentChunkPromise('Failed to load existing document chunks.', () => params.loadExisting()),
+          tryDocumentChunkPromise('Failed to embed document chunks.', () =>
+            embeddings.embedDocuments(params.chunks.map((chunk) => chunk.content)),
+          ),
+        ])
+
+        const existingByChunkKey = new Map(
+          existingRows
+            .filter((row) => params.selectShape(row).sourceVersionKey === params.sourceVersionKey)
+            .map((row) => [params.selectShape(row).chunkKey, row]),
+        )
+        const seenChunkKeys = new Set<string>()
+        const staleVersionRows = existingRows.filter(
+          (row) => params.selectShape(row).sourceVersionKey !== params.sourceVersionKey,
+        )
+
+        yield* tryDocumentChunkPromise('Failed to archive stale document chunks.', () =>
+          params.archive(staleVersionRows),
+        )
+
+        yield* Effect.forEach(
+          params.chunks,
+          (chunk, index) =>
+            Effect.gen(function* () {
+              const contentHash = sha256Hex(chunk.content)
+              const existingRow = existingByChunkKey.get(chunk.chunkKey)
+              const payload = params.buildPayload({
+                chunk,
+                embedding: embeddedChunks[index] ?? [],
+                contentHash,
+                tokenEstimate: estimateDocumentChunkTokenCount(chunk.content),
+              })
+
+              seenChunkKeys.add(chunk.chunkKey)
+
+              if (!existingRow) {
+                yield* tryDocumentChunkPromise(`Failed to create document chunk ${chunk.chunkKey}.`, () =>
+                  params.create(payload),
+                )
+                return
+              }
+
+              const current = params.selectShape(existingRow)
+              const hasChanged =
+                current.contentHash !== contentHash ||
+                current.chunkIndex !== chunk.chunkIndex ||
+                (current.sectionPath ?? null) !== (chunk.sectionPath ?? null) ||
+                (current.pageStart ?? null) !== (chunk.pageStart ?? null) ||
+                (current.pageEnd ?? null) !== (chunk.pageEnd ?? null)
+
+              if (!hasChanged) {
+                return
+              }
+
+              yield* tryDocumentChunkPromise(`Failed to update document chunk ${chunk.chunkKey}.`, () =>
+                params.update(existingRow, payload),
+              )
+            }),
+          { concurrency: 'unbounded', discard: true },
+        )
+
+        const removedCurrentVersionRows = existingRows.filter((row) => {
+          const current = params.selectShape(row)
+          return current.sourceVersionKey === params.sourceVersionKey && !seenChunkKeys.has(current.chunkKey)
+        })
 
-    await params.archive(removedCurrentVersionRows)
+        yield* tryDocumentChunkPromise('Failed to archive removed current-version chunks.', () =>
+          params.archive(removedCurrentVersionRows),
+        )
+      })
+    },
   }
 }
 
-export const documentChunkService = new DocumentChunkService()
+export class DocumentChunkServiceTag extends Context.Service<DocumentChunkServiceTag, DocumentChunkService>()(
+  '@lota-sdk/core/DocumentChunkService',
+) {}
+
+export const DocumentChunkServiceLive = Layer.effect(
+  DocumentChunkServiceTag,
+  Effect.gen(function* () {
+    const runtimeConfig = yield* RuntimeConfigServiceTag
+    return makeDocumentChunkService(
+      createDocumentChunkEmbeddings(runtimeConfig.aiGateway.embeddingModel, runtimeConfig.aiGateway.openRouterApiKey),
+    )
+  }),
+)
 
 export type { ParsedDocumentChunk }

package/src/services/execution-plan/execution-plan-approval.ts

@@ -0,0 +1,26 @@
+import type { ChatMessage } from '@lota-sdk/shared'
+
+import { readApprovalContinuationResponse } from '../../runtime/approval-continuation'
+import type { HumanNodeResponsePayload } from '../plan/plan-executor-helpers'
+
+export function buildApprovalResponseFromMessages(
+  messages: ChatMessage[],
+): { approvalId: string; response: HumanNodeResponsePayload } | null {
+  for (const message of [...messages].reverse()) {
+    if (message.role !== 'assistant') continue
+    const approvalResponse = readApprovalContinuationResponse(message)
+    if (!approvalResponse) continue
+
+    const response: HumanNodeResponsePayload = {
+      approved: approvalResponse.approved,
+      requiredEdits: [...approvalResponse.requiredEdits],
+    }
+    if (approvalResponse.comments) {
+      response.comments = approvalResponse.comments
+    }
+
+    return { approvalId: approvalResponse.approvalId, response }
+  }
+
+  return null
+}

package/src/services/execution-plan/execution-plan-context.ts

@@ -0,0 +1,29 @@
+import type { RecordIdInput } from '../../db/record-id'
+import { recordIdToString } from '../../db/record-id'
+import { TABLES } from '../../db/tables'
+
+export function aggregateBlockingIssues(issues: Array<{ code: string; message: string }>): string {
+  return issues.map((issue) => `${issue.code}: ${issue.message}`).join(' | ')
+}
+
+export function hasCrossThreadSourceContext(
+  sourceThreadId: RecordIdInput | undefined,
+  threadId: RecordIdInput,
+): boolean {
+  if (!sourceThreadId) {
+    return false
+  }
+
+  return recordIdToString(sourceThreadId, TABLES.THREAD) !== recordIdToString(threadId, TABLES.THREAD)
+}
+
+export function isPlanVisibleInThreadContext(
+  threadId: RecordIdInput,
+  params: { threadId: RecordIdInput; sourceThreadId?: RecordIdInput },
+): boolean {
+  const currentThreadId = recordIdToString(threadId, TABLES.THREAD)
+  return (
+    currentThreadId === recordIdToString(params.threadId, TABLES.THREAD) ||
+    (params.sourceThreadId !== undefined && currentThreadId === recordIdToString(params.sourceThreadId, TABLES.THREAD))
+  )
+}