@lota-sdk/core 0.1.14 → 0.1.16

package/src/services/agent-executor.service.ts

@@ -0,0 +1,293 @@
+import type {
+  ExecutionMode,
+  OwnershipDispatchContext,
+  PlanArtifactSubmission,
+  PlanNodeResult,
+  PlanNodeSpec,
+  PlanSchemaRegistry,
+  WriteIntent,
+} from '@lota-sdk/shared'
+import { PlanNodeResultSubmissionSchema, WriteIntentSchema } from '@lota-sdk/shared'
+import { stepCountIs, tool } from 'ai'
+import type { ToolLoopAgent, ToolSet } from 'ai'
+
+import { agentRoster, buildAgentTools, createAgent, getAgentRuntimeConfig } from '../config/agent-defaults'
+import { ensureRecordId } from '../db/record-id'
+import { databaseService } from '../db/service'
+import { TABLES } from '../db/tables'
+import {
+  OWNERSHIP_DISPATCH_BLOCKED_TOOL_NAMES,
+  buildOwnershipDispatchContextSection,
+  buildOwnershipDispatchResponseGuard,
+} from '../runtime/agent-runtime-policy'
+import { buildIndexedRepositoriesContext, getPluginService } from '../runtime/plugin-resolution'
+import { nodeWorkspaceService } from './node-workspace.service'
+import type { PlanValidationIssueInput } from './plan-validator.service'
+import { WorkstreamSchema } from './workstream.types'
+import { writeIntentValidatorService } from './write-intent-validator.service'
+
+function applyToolPolicy(tools: ToolSet, nodeSpec: PlanNodeSpec): ToolSet {
+  const blockedToolNames = new Set([...OWNERSHIP_DISPATCH_BLOCKED_TOOL_NAMES, ...nodeSpec.toolPolicy.deny])
+  const allowList = nodeSpec.toolPolicy.allow.length > 0 ? new Set(nodeSpec.toolPolicy.allow) : null
+
+  return Object.fromEntries(
+    Object.entries(tools).filter(
+      ([toolName]) => !blockedToolNames.has(toolName) && (allowList === null || allowList.has(toolName)),
+    ),
+  )
+}
+
+function buildDispatchPrompt(nodeSpec: PlanNodeSpec): string {
+  return [
+    `Execute the execution-plan node "${nodeSpec.label}".`,
+    `Objective: ${nodeSpec.objective}`,
+    `Instructions: ${nodeSpec.instructions}`,
+    'Return the final node result JSON only.',
+  ].join('\n\n')
+}
+
+export function buildWriteIntentDispatchPrompt(nodeSpec: PlanNodeSpec): string {
+  const deliverables = nodeSpec.deliverables
+    .map((d) => `- ${d.name} (${d.kind}${d.required ? ', required' : ''})`)
+    .join('\n')
+  return [
+    `Execute the execution-plan node "${nodeSpec.label}".`,
+    `Objective: ${nodeSpec.objective}`,
+    `Instructions: ${nodeSpec.instructions}`,
+    '',
+    'Produce each deliverable by calling the writeIntent tool:',
+    deliverables,
+    '',
+    'For each, call writeIntent with targetPath matching the deliverable name.',
+    'If writeIntent returns validation_failed, correct the payload and try again.',
+    'When all deliverables are written, end with a brief completion summary.',
+  ].join('\n')
+}
+
+const MAX_SELF_CORRECTION_RETRIES = 3
+
+class AgentExecutorService {
+  validateOwner(agentId: string, nodeId: string): PlanValidationIssueInput[] {
+    if (!agentRoster.includes(agentId)) {
+      return [
+        {
+          severity: 'blocking',
+          code: 'agent_executor_missing',
+          message: `Node "${nodeId}" references unknown agent executor "${agentId}".`,
+          nodeId,
+          detail: { agentId },
+        },
+      ]
+    }
+
+    return []
+  }
+
+  async executeNode(params: {
+    nodeSpec: PlanNodeSpec
+    resolvedInput: Record<string, unknown>
+    inputArtifacts: PlanArtifactSubmission[]
+    context: OwnershipDispatchContext
+    executionMode?: ExecutionMode
+    schemaRegistry?: PlanSchemaRegistry
+  }): Promise<PlanNodeResult> {
+    if (params.nodeSpec.owner.executorType !== 'agent') {
+      throw new Error(`AgentExecutor cannot execute owner type "${params.nodeSpec.owner.executorType}".`)
+    }
+
+    const agentId = params.nodeSpec.owner.ref
+    if (!agentRoster.includes(agentId)) {
+      throw new Error(`Agent executor "${agentId}" is not registered.`)
+    }
+
+    const workstream = await databaseService.findOne(
+      TABLES.WORKSTREAM,
+      { id: ensureRecordId(params.context.workstreamId, TABLES.WORKSTREAM) },
+      WorkstreamSchema,
+    )
+    if (!workstream) {
+      throw new Error(`Workstream ${params.context.workstreamId} not found for dispatched execution.`)
+    }
+
+    const organizationRef = ensureRecordId(params.context.organizationId, TABLES.ORGANIZATION)
+    const workstreamRef = ensureRecordId(params.context.workstreamId, TABLES.WORKSTREAM)
+    const userRefSource = params.context.userId ?? workstream.userId
+    if (!userRefSource) {
+      throw new Error(`Workstream ${params.context.workstreamId} is missing a user context for dispatched execution.`)
+    }
+    const userRef = ensureRecordId(userRefSource, TABLES.USER)
+    const userName = params.context.userName ?? 'User'
+    const getLinearInstallationByOrgId = getPluginService([
+      'linear',
+      'services',
+      'linearService',
+      'getInstallationByOrgId',
+    ])
+    const getGithubInstallationForOrganization = getPluginService([
+      'github',
+      'services',
+      'githubService',
+      'getInstallationForOrganization',
+    ])
+    const [linearInstallation, githubInstallation, indexedRepoContext] = await Promise.all([
+      getLinearInstallationByOrgId ? getLinearInstallationByOrgId(organizationRef) : Promise.resolve(null),
+      getGithubInstallationForOrganization
+        ? getGithubInstallationForOrganization(params.context.organizationId)
+        : Promise.resolve(null),
+      buildIndexedRepositoriesContext(params.context.organizationId),
+    ])
+
+    const mode = params.executionMode ?? 'linear'
+
+    const dispatchMode = workstream.mode === 'group' ? 'fixedWorkstreamMode' : 'direct'
+    const runtimeConfig = getAgentRuntimeConfig({
+      agentId,
+      workstreamMode: workstream.mode,
+      mode: dispatchMode,
+      onboardingActive: false,
+      linearInstalled: Boolean(linearInstallation),
+      reasoningProfile: 'standard',
+      additionalInstructionSections: [
+        buildOwnershipDispatchContextSection({
+          node: params.nodeSpec,
+          resolvedInput: params.resolvedInput,
+          inputArtifacts: params.inputArtifacts,
+        }),
+      ],
+      responseGuardSection: buildOwnershipDispatchResponseGuard({ node: params.nodeSpec, executionMode: mode }),
+    }) as Record<string, unknown>
+
+    const rawTools = (await buildAgentTools({
+      agentId,
+      orgId: organizationRef,
+      userId: userRef,
+      userName,
+      workstreamId: workstreamRef,
+      orgIdString: params.context.organizationId,
+      workstreamMode: workstream.mode,
+      mode: dispatchMode,
+      linearInstalled: Boolean(linearInstallation),
+      onboardingActive: false,
+      githubInstalled: Boolean(githubInstallation),
+      provideRepoTool: indexedRepoContext.provideRepoTool,
+      defaultRepoSections: indexedRepoContext.defaultSectionsByAgent[agentId],
+      memoryBlock: '',
+      onAppendMemoryBlock: () => undefined,
+      availableUploads: [],
+      includeExecutionPlanTools: false,
+    })) as ToolSet
+    const tools = applyToolPolicy(rawTools, params.nodeSpec)
+
+    const agentFactory = createAgent[agentId] as ((...args: unknown[]) => unknown) | undefined
+    if (!agentFactory) {
+      throw new Error(`Agent factory "${agentId}" is not registered.`)
+    }
+
+    const maxSteps = typeof runtimeConfig.maxSteps === 'number' ? runtimeConfig.maxSteps : 8
+
+    if (mode === 'linear') {
+      const agent = agentFactory({
+        mode: dispatchMode,
+        tools,
+        extraInstructions:
+          typeof runtimeConfig.extraInstructions === 'string' ? runtimeConfig.extraInstructions : undefined,
+        maxRetries: 1,
+        stopWhen: [stepCountIs(maxSteps)],
+      }) as ToolLoopAgent<never, ToolSet>
+
+      const result = await agent.generate({ prompt: buildDispatchPrompt(params.nodeSpec) })
+      const outputCandidate = PlanNodeResultSubmissionSchema.safeParse(result.output)
+      if (outputCandidate.success) {
+        return outputCandidate.data
+      }
+
+      throw new Error(`Agent executor "${agentId}" returned an invalid node result.`)
+    }
+
+    // --- Graph-lite / Graph-full path ---
+
+    const workspace = nodeWorkspaceService.initialize({
+      nodeSpec: params.nodeSpec,
+      resolvedInput: params.resolvedInput,
+      inputArtifacts: params.inputArtifacts,
+      schemaRegistry: params.schemaRegistry ?? {},
+    })
+
+    const writeIntentTool = tool({
+      description:
+        'Write a validated artifact or structured output field. Call this for each deliverable. If validation fails, correct your payload and try again.',
+      inputSchema: WriteIntentSchema,
+      execute: async (intent: WriteIntent) => {
+        const correctionCount = workspace.sys.correctionCounts.get(intent.targetPath) ?? 0
+
+        const validation = writeIntentValidatorService.validate({
+          intent,
+          nodeSpec: params.nodeSpec,
+          schemaRegistry: workspace.ctx.schemaRegistry,
+          existingDeliverables: workspace.deliverables,
+        })
+
+        if (validation.issues.length > 0) {
+          if (correctionCount >= MAX_SELF_CORRECTION_RETRIES) {
+            throw new Error(
+              `Write validation failed for "${intent.targetPath}" after ${MAX_SELF_CORRECTION_RETRIES} retries: ${validation.issues.map((i) => i.message).join(', ')}`,
+            )
+          }
+          workspace.sys.correctionCounts.set(intent.targetPath, correctionCount + 1)
+          workspace.sys.writeLog.push({
+            targetPath: intent.targetPath,
+            action: intent.action,
+            timestamp: new Date(),
+            result: 'rejected',
+          })
+          return {
+            status: 'validation_failed',
+            error: { targetPath: intent.targetPath, action: intent.action, issues: validation.issues },
+            hint: `Correct and re-emit. Attempt ${correctionCount + 1}/${MAX_SELF_CORRECTION_RETRIES}.`,
+          }
+        }
+
+        nodeWorkspaceService.stageWrite(workspace, intent, 'validated')
+        return { status: 'accepted', message: `Write to "${intent.targetPath}" validated and staged.` }
+      },
+    })
+
+    const graphTools = { ...tools, writeIntent: writeIntentTool }
+
+    const agent = agentFactory({
+      mode: dispatchMode,
+      tools: graphTools,
+      extraInstructions:
+        typeof runtimeConfig.extraInstructions === 'string' ? runtimeConfig.extraInstructions : undefined,
+      maxRetries: 1,
+      stopWhen: [stepCountIs(maxSteps)],
+    }) as ToolLoopAgent<never, ToolSet>
+
+    await agent.generate({ prompt: buildWriteIntentDispatchPrompt(params.nodeSpec) })
+
+    const finalResult = nodeWorkspaceService.finalize(workspace)
+
+    if (!finalResult.isComplete) {
+      const result: PlanNodeResult = {
+        structuredOutput: finalResult.structuredOutput,
+        artifacts: finalResult.artifacts,
+        notes: 'Execution incomplete: missing required deliverables or validation failures.',
+        quality: 'partial',
+      }
+      nodeWorkspaceService.cleanup(workspace)
+      return result
+    }
+
+    const result: PlanNodeResult = {
+      structuredOutput: finalResult.structuredOutput,
+      artifacts: finalResult.artifacts,
+      notes: finalResult.notes,
+      quality: finalResult.quality,
+    }
+
+    nodeWorkspaceService.cleanup(workspace)
+    return result
+  }
+}
+
+export const agentExecutorService = new AgentExecutorService()

package/src/services/artifact-provenance.service.ts

@@ -0,0 +1,172 @@
+import type { ImpactAnalysis, PlanNodeRunRecord, ProvenanceChain, ProvenanceNode } from '@lota-sdk/shared'
+
+import { recordIdToString } from '../db/record-id'
+
+class ArtifactProvenanceService {
+  /**
+   * Backward: trace which upstream nodes/artifacts produced the inputs for this artifact's node.
+   * From nodeId, follow edges upstream. At each upstream node, collect its artifacts.
+   * Continue until maxDepth or no more upstreams.
+   */
+  async traceBackward(params: { runId: string; nodeId: string; maxDepth?: number }): Promise<ProvenanceChain> {
+    const { planRunService } = await import('./plan-run.service')
+
+    const run = await planRunService.getRunById(params.runId)
+    const spec = await planRunService.getPlanSpecById(run.planSpecId)
+    const nodeSpecs = await planRunService.listNodeSpecs(spec.id)
+    const artifacts = await planRunService.listArtifacts(run.id)
+
+    const nodeSpecsByNodeId = new Map(nodeSpecs.map((n) => [n.nodeId, n]))
+    const artifactsByNodeId = new Map<string, typeof artifacts>()
+    for (const artifact of artifacts) {
+      const list = artifactsByNodeId.get(artifact.nodeId) ?? []
+      list.push(artifact)
+      artifactsByNodeId.set(artifact.nodeId, list)
+    }
+
+    const maxDepth = params.maxDepth ?? 10
+    const chain: ProvenanceNode[] = []
+    const visited = new Set<string>()
+    const queue: Array<{ nodeId: string; depth: number }> = [{ nodeId: params.nodeId, depth: 0 }]
+
+    while (queue.length > 0) {
+      const entry = queue.shift()
+      if (!entry || visited.has(entry.nodeId) || entry.depth > maxDepth) continue
+      visited.add(entry.nodeId)
+
+      const nodeSpec = nodeSpecsByNodeId.get(entry.nodeId)
+      if (!nodeSpec) continue
+
+      const nodeArtifacts = (artifactsByNodeId.get(entry.nodeId) ?? []).map((a) => ({
+        name: a.name,
+        kind: a.kind,
+        id: recordIdToString(a.id),
+      }))
+
+      chain.push({ nodeId: entry.nodeId, label: nodeSpec.label, artifacts: nodeArtifacts })
+
+      // Walk upstream
+      for (const upstreamId of nodeSpec.upstreamNodeIds) {
+        if (!visited.has(upstreamId)) {
+          queue.push({ nodeId: upstreamId, depth: entry.depth + 1 })
+        }
+      }
+    }
+
+    return { root: { nodeId: params.nodeId }, chain, depth: Math.max(0, chain.length - 1) }
+  }
+
+  /**
+   * Forward: trace which downstream nodes consume this artifact's node output.
+   * Same as backward but follow edges downstream.
+   */
+  async traceForward(params: { runId: string; nodeId: string; maxDepth?: number }): Promise<ProvenanceChain> {
+    const { planRunService } = await import('./plan-run.service')
+
+    const run = await planRunService.getRunById(params.runId)
+    const spec = await planRunService.getPlanSpecById(run.planSpecId)
+    const nodeSpecs = await planRunService.listNodeSpecs(spec.id)
+    const artifacts = await planRunService.listArtifacts(run.id)
+
+    const nodeSpecsByNodeId = new Map(nodeSpecs.map((n) => [n.nodeId, n]))
+    const artifactsByNodeId = new Map<string, typeof artifacts>()
+    for (const artifact of artifacts) {
+      const list = artifactsByNodeId.get(artifact.nodeId) ?? []
+      list.push(artifact)
+      artifactsByNodeId.set(artifact.nodeId, list)
+    }
+
+    const maxDepth = params.maxDepth ?? 10
+    const chain: ProvenanceNode[] = []
+    const visited = new Set<string>()
+    const queue: Array<{ nodeId: string; depth: number }> = [{ nodeId: params.nodeId, depth: 0 }]
+
+    while (queue.length > 0) {
+      const entry = queue.shift()
+      if (!entry || visited.has(entry.nodeId) || entry.depth > maxDepth) continue
+      visited.add(entry.nodeId)
+
+      const nodeSpec = nodeSpecsByNodeId.get(entry.nodeId)
+      if (!nodeSpec) continue
+
+      const nodeArtifacts = (artifactsByNodeId.get(entry.nodeId) ?? []).map((a) => ({
+        name: a.name,
+        kind: a.kind,
+        id: recordIdToString(a.id),
+      }))
+
+      chain.push({ nodeId: entry.nodeId, label: nodeSpec.label, artifacts: nodeArtifacts })
+
+      // Walk downstream
+      for (const downstreamId of nodeSpec.downstreamNodeIds) {
+        if (!visited.has(downstreamId)) {
+          queue.push({ nodeId: downstreamId, depth: entry.depth + 1 })
+        }
+      }
+    }
+
+    return { root: { nodeId: params.nodeId }, chain, depth: Math.max(0, chain.length - 1) }
+  }
+
+  /**
+   * Impact: which downstream nodes/artifacts would be affected.
+   * Forward traversal collecting all affected nodes and their artifacts.
+   * Includes non-completed nodes.
+   */
+  async analyzeImpact(params: { runId: string; nodeId: string }): Promise<ImpactAnalysis> {
+    const { planRunService } = await import('./plan-run.service')
+
+    const run = await planRunService.getRunById(params.runId)
+    const spec = await planRunService.getPlanSpecById(run.planSpecId)
+    const nodeSpecs = await planRunService.listNodeSpecs(spec.id)
+    const nodeRuns = await planRunService.listNodeRuns(run.id)
+    const artifacts = await planRunService.listArtifacts(run.id)
+
+    const nodeSpecsByNodeId = new Map(nodeSpecs.map((n) => [n.nodeId, n]))
+    const nodeRunsByNodeId = new Map(nodeRuns.map((n: PlanNodeRunRecord) => [n.nodeId, n]))
+
+    const affectedNodes: Array<{ nodeId: string; label: string; status: PlanNodeRunRecord['status'] }> = []
+    const affectedArtifacts: Array<{ name: string; nodeId: string }> = []
+
+    const visited = new Set<string>()
+    const queue: string[] = []
+
+    // Seed: downstream neighbors of the source node
+    const sourceSpec = nodeSpecsByNodeId.get(params.nodeId)
+    if (sourceSpec) {
+      for (const downstreamId of sourceSpec.downstreamNodeIds) {
+        queue.push(downstreamId)
+      }
+    }
+
+    while (queue.length > 0) {
+      const nodeId = queue.shift()
+      if (!nodeId || visited.has(nodeId)) continue
+      visited.add(nodeId)
+
+      const nodeSpec = nodeSpecsByNodeId.get(nodeId)
+      if (!nodeSpec) continue
+
+      const nodeRun = nodeRunsByNodeId.get(nodeId)
+      affectedNodes.push({ nodeId, label: nodeSpec.label, status: nodeRun?.status ?? 'pending' })
+
+      // Collect artifacts for this node
+      for (const artifact of artifacts.filter((a) => a.nodeId === nodeId)) {
+        affectedArtifacts.push({ name: artifact.name, nodeId })
+      }
+
+      // Continue downstream
+      for (const downstreamId of nodeSpec.downstreamNodeIds) {
+        if (!visited.has(downstreamId)) queue.push(downstreamId)
+      }
+    }
+
+    return {
+      sourceNodeId: params.nodeId,
+      affectedNodes: affectedNodes as ImpactAnalysis['affectedNodes'],
+      affectedArtifacts,
+    }
+  }
+}
+
+export const artifactProvenanceService = new ArtifactProvenanceService()

package/src/services/attachment.service.ts

@@ -3,7 +3,7 @@ import { recordIdToString } from '../db/record-id'
 import { TABLES } from '../db/tables'
 import { attachmentStorageService } from '../storage/attachment-storage.service'
 import type { UploadedWorkstreamAttachment as SdkUploadedWorkstreamAttachment } from '../storage/attachment-storage.service'
-import type { MessagePartLike, ReadableUploadMetadata as SdkReadableUploadMetadata } from '../storage/attachments.types'
+import type { MessagePartLike, ReadableUploadMetadata as SdkReadableUploadMetadata } from '../storage/attachment-types'
 
 export type ReadableUploadMetadata = SdkReadableUploadMetadata
 
@@ -57,7 +57,7 @@ class AttachmentService {
     name: string
     contentType: string
   }): Promise<string> {
-    return await attachmentStorageService.extractStoredAttachmentText({ storageKey, name, contentType })
+    return attachmentStorageService.extractStoredAttachmentText({ storageKey, name, contentType })
   }
 
   async extractStoredAttachmentPages({
@@ -69,7 +69,7 @@ class AttachmentService {
     name: string
     contentType: string
   }): Promise<{ pageMode: 'logical' | 'pdf'; pages: string[] }> {
-    return await attachmentStorageService.extractStoredAttachmentPages({ storageKey, name, contentType })
+    return attachmentStorageService.extractStoredAttachmentPages({ storageKey, name, contentType })
   }
 
   async readFilePartsFromUpload({
@@ -85,7 +85,7 @@ class AttachmentService {
     part?: number
     pagesPerPart?: number
   }) {
-    return await attachmentStorageService.readFilePartsFromUpload({
+    return attachmentStorageService.readFilePartsFromUpload({
       upload,
       orgId: toOrgId(orgId),
       userId: toUserId(userId),
@@ -111,7 +111,7 @@ class AttachmentService {
     content: string
     contentType: string
   }): Promise<{ storageKey: string; sizeBytes: number }> {
-    return await attachmentStorageService.writeOrganizationDocument({
+    return attachmentStorageService.writeOrganizationDocument({
       orgId: toOrgId(orgId),
       namespace,
       relativePath,
@@ -131,12 +131,7 @@ class AttachmentService {
     namespace: string
     relativePath: string
   }) {
-    return await attachmentStorageService.uploadOrganizationDocument({
-      file,
-      orgId: toOrgId(orgId),
-      namespace,
-      relativePath,
-    })
+    return attachmentStorageService.uploadOrganizationDocument({ file, orgId: toOrgId(orgId), namespace, relativePath })
   }
 
   async uploadWorkstreamAttachment({
@@ -148,7 +143,7 @@ class AttachmentService {
     orgId: RecordIdRef
     userId: RecordIdRef
   }): Promise<SdkUploadedWorkstreamAttachment> {
-    return await attachmentStorageService.uploadWorkstreamAttachment({
+    return attachmentStorageService.uploadWorkstreamAttachment({
       file,
       orgId: toOrgId(orgId),
       userId: toUserId(userId),

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

@@ -5,10 +5,12 @@ import type { RecordIdRef } from '../db/record-id'
 import { recordIdToString } from '../db/record-id'
 import { databaseService } from '../db/service'
 import { TABLES } from '../db/tables'
+import { getRedisConnection } from '../redis/connection-accessor'
+import { withRedisLeaseLock } from '../redis/redis-lease-lock'
 import { parseWorkstreamState, toStateFieldsUpdated } from '../runtime/context-compaction'
-import { CONTEXT_SIZE, WORKSTREAM_RAW_TAIL_MESSAGES } from '../runtime/context-compaction-constants'
+import { CONTEXT_WINDOW_TOKENS, WORKSTREAM_RAW_TAIL_MESSAGES } from '../runtime/context-compaction-constants'
 import type { WorkstreamState } from '../runtime/workstream-state'
-import { compactMemoryBlockSummary, contextCompactionRuntime } from './context-compaction-runtime'
+import { compactMemoryBlockSummary, contextCompactionRuntime } from './context-compaction-runtime.singleton'
 import { workstreamMessageService } from './workstream-message.service'
 import { WorkstreamSchema } from './workstream.types'
 
@@ -35,7 +37,7 @@ class ContextCompactionService {
     return contextCompactionRuntime.formatWorkstreamStateForPrompt(state)
   }
 
-  estimateThreshold(contextSize = CONTEXT_SIZE): number {
+  estimateThreshold(contextSize = CONTEXT_WINDOW_TOKENS): number {
     return contextCompactionRuntime.estimateThreshold(contextSize)
   }
 
@@ -47,68 +49,83 @@ class ContextCompactionService {
     workstreamId: RecordIdRef
     contextSize?: number
   }): Promise<{ compacted: boolean; state: WorkstreamState | null }> {
-    const workstream = await databaseService.findOne(TABLES.WORKSTREAM, { id: params.workstreamId }, WorkstreamSchema)
-    if (!workstream) {
-      throw new Error(
-        `Workstream not found for compaction: ${recordIdToString(params.workstreamId, TABLES.WORKSTREAM)}`,
-      )
-    }
-
-    const currentState = parseWorkstreamState(workstream.state)
-    const liveMessages = await workstreamMessageService.listMessagesAfterCursor(
-      params.workstreamId,
-      typeof workstream.lastCompactedMessageId === 'string' ? workstream.lastCompactedMessageId : undefined,
-    )
+    const entityId = recordIdToString(params.workstreamId, TABLES.WORKSTREAM)
 
-    const result = await contextCompactionRuntime.compactHistory({
-      summaryText: typeof workstream.compactionSummary === 'string' ? workstream.compactionSummary : '',
-      liveMessages,
-      tailMessageCount: WORKSTREAM_RAW_TAIL_MESSAGES,
-      contextSize: params.contextSize,
-      existingState: currentState,
-    })
-
-    if (!result.compacted || !result.lastCompactedMessageId) {
-      return { compacted: false, state: currentState }
-    }
-
-    if (result.compactedMessages.length > 0) {
-      await workstreamMessageService.upsertMessages({
-        workstreamId: params.workstreamId,
-        messages: result.compactedMessages,
-      })
-    }
-
-    await databaseService.update(
-      TABLES.WORKSTREAM,
-      params.workstreamId,
+    return withRedisLeaseLock(
       {
-        compactionSummary: result.summaryText,
-        lastCompactedMessageId: result.lastCompactedMessageId,
-        state: result.state,
+        redis: getRedisConnection(),
+        lockKey: `compaction:lock:${entityId}`,
+        lockTtlMs: 120_000,
+        maxWaitMs: 30_000,
+        label: 'context-compaction',
+      },
+      async () => {
+        const workstream = await databaseService.findOne(
+          TABLES.WORKSTREAM,
+          { id: params.workstreamId },
+          WorkstreamSchema,
+        )
+        if (!workstream) {
+          throw new Error(`Workstream not found for compaction: ${entityId}`)
+        }
+
+        const currentState = parseWorkstreamState(workstream.state)
+        const liveMessages = await workstreamMessageService.listMessagesAfterCursor(
+          params.workstreamId,
+          typeof workstream.lastCompactedMessageId === 'string' ? workstream.lastCompactedMessageId : undefined,
+        )
+
+        const result = await contextCompactionRuntime.compactHistory({
+          summaryText: typeof workstream.compactionSummary === 'string' ? workstream.compactionSummary : '',
+          liveMessages,
+          tailMessageCount: WORKSTREAM_RAW_TAIL_MESSAGES,
+          contextSize: params.contextSize,
+          existingState: currentState,
+        })
+
+        if (!result.compacted || !result.lastCompactedMessageId) {
+          return { compacted: false, state: currentState }
+        }
+
+        if (result.compactedMessages.length > 0) {
+          await workstreamMessageService.upsertMessages({
+            workstreamId: params.workstreamId,
+            messages: result.compactedMessages,
+          })
+        }
+
+        await databaseService.update(
+          TABLES.WORKSTREAM,
+          params.workstreamId,
+          {
+            compactionSummary: result.summaryText,
+            lastCompactedMessageId: result.lastCompactedMessageId,
+            state: result.state,
+          },
+          WorkstreamSchema,
+        )
+
+        this.logCompactionMetrics({
+          domain: 'workstream',
+          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,
+          stateFieldsUpdated: toStateFieldsUpdated(result.stateDelta),
+          conflictsDetected: result.stateDelta.conflicts?.length ?? 0,
+        })
+
+        return { compacted: true, state: result.state }
       },
-      WorkstreamSchema,
     )
-
-    this.logCompactionMetrics({
-      domain: 'workstream',
-      entityId: recordIdToString(params.workstreamId, TABLES.WORKSTREAM),
-      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,
-      stateFieldsUpdated: toStateFieldsUpdated(result.stateDelta),
-      conflictsDetected: result.stateDelta.conflicts?.length ?? 0,
-    })
-
-    return { compacted: true, state: result.state }
   }
 
   async compactMemoryBlock(params: { previousSummary: string; newEntriesText: string }): Promise<string> {
-    return await compactMemoryBlockSummary(params)
+    return compactMemoryBlockSummary(params)
   }
 
   private logCompactionMetrics(metrics: PersistedCompactionMetrics): void {