@lota-sdk/core 0.1.9 → 0.1.12

package/src/services/index.ts

@@ -0,0 +1,14 @@
+export * from './attachment.service'
+export * from './document-chunk.service'
+export * from './execution-plan.service'
+export * from './memory.service'
+export * from './organization-member.service'
+export * from './organization.service'
+export * from './plan-run.service'
+export * from './recent-activity-title.service'
+export * from './recent-activity.service'
+export * from './user.service'
+export * from './workstream-message.service'
+export * from './workstream-title.service'
+export * from './workstream-turn'
+export * from './workstream.service'

package/src/services/learned-skill.service.ts

@@ -1,19 +1,28 @@
-import { recordIdStringSchema } from '@lota-sdk/shared/schemas/common'
+import { recordIdStringSchema } from '@lota-sdk/shared'
 import { BoundQuery } from 'surrealdb'
 import { z } from 'zod'
 
 import { renderLearnedSkillInstructions } from '../ai/definitions'
+import { lotaDebugLogger } from '../config/debug-logger'
 import { serverLogger } from '../config/logger'
 import { ensureRecordId } from '../db/record-id'
 import { databaseService } from '../db/service'
 import { TABLES } from '../db/tables'
-import { createDefaultEmbeddings } from '../embeddings/provider'
+import { getDefaultEmbeddings } from '../embeddings/provider'
+import { getRedisConnection } from '../redis'
 
-const embeddings = createDefaultEmbeddings()
+const embeddings = getDefaultEmbeddings()
 
 const PROMOTION_MIN_USES = 5
 const PROMOTION_MIN_SUCCESS_RATE = 0.6
 
+const SKILL_EXISTS_TTL_SECONDS = 120
+const SKILL_EXISTS_KEY_PREFIX = 'skill-exists'
+
+function skillExistsKey(orgId: string, agentId: string): string {
+  return `${SKILL_EXISTS_KEY_PREFIX}:${orgId}:${agentId}`
+}
+
 const LearnedSkillRowSchema = z.object({
   id: recordIdStringSchema,
   name: z.string(),
@@ -51,7 +60,7 @@ const SearchResultRowSchema = z.object({
 
 type SearchResultRow = z.infer<typeof SearchResultRowSchema>
 
-export interface CreateLearnedSkillInput {
+interface CreateLearnedSkillInput {
   name: string
   description: string
   instructions: string
@@ -66,7 +75,7 @@ export interface CreateLearnedSkillInput {
   hash: string
 }
 
-export interface UpdateLearnedSkillInput {
+interface UpdateLearnedSkillInput {
   name?: string
   description?: string
   instructions?: string
@@ -80,7 +89,7 @@ export interface UpdateLearnedSkillInput {
   supersedes?: string
 }
 
-export interface RetrieveForTurnParams {
+interface RetrieveForTurnParams {
   orgId: string
   agentId: string
   query: string
@@ -107,7 +116,9 @@ class LearnedSkillService {
       hash: input.hash,
     }
 
-    return databaseService.create(TABLES.LEARNED_SKILL, data, LearnedSkillRowSchema)
+    const result = await databaseService.create(TABLES.LEARNED_SKILL, data, LearnedSkillRowSchema)
+    await this.invalidateSkillExistsCache(input.organizationId, input.agentId)
+    return result
   }
 
   async update(skillId: string, input: UpdateLearnedSkillInput): Promise<LearnedSkillRow> {
@@ -133,12 +144,16 @@ class LearnedSkillService {
 
   async archive(skillId: string): Promise<void> {
     const ref = ensureRecordId(skillId, TABLES.LEARNED_SKILL)
+    const skill = await this.getById(skillId)
     await databaseService.update(
       TABLES.LEARNED_SKILL,
       ref,
       { status: 'archived', archivedAt: new Date().toISOString(), updatedAt: new Date().toISOString() },
       LearnedSkillRowSchema,
     )
+    if (skill) {
+      await this.invalidateSkillExistsCache(String(skill.organizationId), skill.agentId ?? null)
+    }
   }
 
   async getById(skillId: string): Promise<LearnedSkillRow | null> {
@@ -149,27 +164,60 @@ class LearnedSkillService {
     )
   }
 
+  private async hasSkillsForAgent(orgId: string, agentId: string): Promise<boolean> {
+    const redis = getRedisConnection()
+    const key = skillExistsKey(orgId, agentId)
+
+    const cached = await redis.get(key)
+    if (cached !== null) return cached === '1'
+
+    const orgRef = ensureRecordId(orgId, TABLES.ORGANIZATION)
+    const rows = await databaseService.query<{ id: unknown }>(
+      new BoundQuery(
+        `SELECT id FROM ${TABLES.LEARNED_SKILL}
+         WHERE organizationId = $orgRef
+           AND status IN ['learned', 'verified', 'promoted']
+           AND archivedAt IS NONE
+           AND (agentId IS NONE OR agentId = $agentId)
+         LIMIT 1`,
+        { orgRef, agentId },
+      ),
+    )
+
+    const exists = rows.length > 0
+    await redis.set(key, exists ? '1' : '0', 'EX', SKILL_EXISTS_TTL_SECONDS)
+    return exists
+  }
+
+  private async invalidateSkillExistsCache(orgId: string, agentId: string | null): Promise<void> {
+    const redis = getRedisConnection()
+    const pattern = `${SKILL_EXISTS_KEY_PREFIX}:${orgId}:*`
+    const keys = await redis.keys(pattern)
+    if (keys.length > 0) {
+      await redis.del(...keys)
+    }
+    // Also set the specific key if we know a skill was just created
+    if (agentId) {
+      await redis.set(skillExistsKey(orgId, agentId), '1', 'EX', SKILL_EXISTS_TTL_SECONDS)
+    }
+  }
+
   async searchForTurn(params: RetrieveForTurnParams): Promise<SearchResultRow[]> {
-    const orgRef = ensureRecordId(params.orgId, TABLES.ORGANIZATION)
+    const timer = lotaDebugLogger.timer('learned-skills')
+
+    const hasSkills = await this.hasSkillsForAgent(params.orgId, params.agentId)
+    if (!hasSkills) {
+      lotaDebugLogger.step('learned-skills: skipped — no skills for org+agent')
+      return []
+    }
+    timer.step('has-skills-check')
+
     const queryEmbedding = await embeddings.embedQuery(params.query)
+    timer.step('embed-query')
     if (queryEmbedding.length === 0) return []
 
-    const candidateLimit = params.limit * 4
+    const orgRef = ensureRecordId(params.orgId, TABLES.ORGANIZATION)
     const sql = `
-      LET $candidateRows = (
-        SELECT
-          id,
-          vector::distance::knn() AS distance
-        FROM ${TABLES.LEARNED_SKILL}
-        WHERE organizationId = $organizationId
-          AND status IN ['learned', 'verified', 'promoted']
-          AND archivedAt IS NONE
-          AND confidence >= $minConfidence
-          AND (agentId IS NONE OR agentId = $agentId)
-          AND embedding <|${candidateLimit}|> $embedding
-        ORDER BY distance ASC
-      );
-
       SELECT
         type::string(id) AS id,
         name,
@@ -178,9 +226,13 @@ class LearnedSkillService {
         confidence,
         vector::similarity::cosine(embedding, $embedding) AS similarity
       FROM ${TABLES.LEARNED_SKILL}
-      WHERE id IN $candidateRows.id
+      WHERE organizationId = $organizationId
+        AND status IN ['learned', 'verified', 'promoted']
+        AND archivedAt IS NONE
+        AND confidence >= $minConfidence
+        AND (agentId IS NONE OR agentId = $agentId)
+        AND embedding <|${params.limit}|> $embedding
       ORDER BY similarity DESC
-      LIMIT $limit
     `
 
     const rows = await databaseService.query<unknown>(
@@ -189,9 +241,9 @@ class LearnedSkillService {
         embedding: queryEmbedding,
         agentId: params.agentId,
         minConfidence: params.minConfidence,
-        limit: params.limit,
       }),
     )
+    timer.step('knn-query')
 
     return rows.map((row) => SearchResultRowSchema.parse(row)).filter((row) => row.similarity >= 0.3)
   }
@@ -253,24 +305,15 @@ class LearnedSkillService {
     if (descEmbedding.length === 0) return null
 
     const sql = `
-      LET $candidateRows = (
-        SELECT
-          id,
-          vector::distance::knn() AS distance
-        FROM ${TABLES.LEARNED_SKILL}
-        WHERE organizationId = $organizationId
-          AND status IN ['learned', 'verified', 'promoted']
-          AND archivedAt IS NONE
-          AND embedding <|3|> $embedding
-        ORDER BY distance ASC
-      );
-
       SELECT *,
         type::string(id) AS id,
         type::string(organizationId) AS organizationId,
         vector::similarity::cosine(embedding, $embedding) AS similarity
       FROM ${TABLES.LEARNED_SKILL}
-      WHERE id IN $candidateRows.id
+      WHERE organizationId = $organizationId
+        AND status IN ['learned', 'verified', 'promoted']
+        AND archivedAt IS NONE
+        AND embedding <|3|> $embedding
       ORDER BY similarity DESC
       LIMIT 1
     `

package/src/services/memory.service.ts

@@ -1,7 +1,6 @@
 import { z } from 'zod'
 
 import { agentRoster } from '../config/agent-defaults'
-import { env } from '../config/env-shapes'
 import { aiLogger } from '../config/logger'
 import { Memory } from '../db/memory'
 import { isUniqueIndexConflict } from '../db/memory-store.helpers'
@@ -24,6 +23,7 @@ import {
   executeScopedRetrieval,
   scopedRetrievalToMap,
 } from '../runtime/retrieval-adapters'
+import { getRuntimeConfig } from '../runtime/runtime-config'
 import { createMemoryRerankerAgent, memoryRerankerPrompt } from '../system-agents/memory-reranker.agent'
 import { createOrgMemoryAgent, orgMemoryPrompt } from '../system-agents/memory.agent'
 import { assessMemoryImportance, clampMemoryImportance } from './memory-assessment.service'
@@ -304,7 +304,7 @@ class MemoryService {
     scopeId: string
     memoryType: MemoryType
   }): Promise<string> {
-    const limit = env.MEMORY_SEARCH_K
+    const limit = getRuntimeConfig().memory.searchK
     const candidateLimit = getCandidateLimit(limit)
 
     const candidates = await memory.searchCandidates(query, { scopeId, limit: candidateLimit, memoryType })
@@ -362,7 +362,8 @@ class MemoryService {
     aiLogger.info`[MEMORY_DEBUG] searchOrganizationMemoriesRaw - orgId: "${orgId}", scopeId: "${orgScopeId}"`
     const memory = this.getOrgMemory(orgId)
     const fastMode = options?.fastMode ?? true
-    const limit = options?.limit ?? (fastMode ? Math.min(env.MEMORY_SEARCH_K, 4) : env.MEMORY_SEARCH_K)
+    const searchK = getRuntimeConfig().memory.searchK
+    const limit = options?.limit ?? (fastMode ? Math.min(searchK, 4) : searchK)
 
     try {
       const candidates = await memory.searchCandidates(query, {
@@ -489,7 +490,7 @@ class MemoryService {
     fastMode?: boolean
     allowMultiScopeRerank?: boolean
   }): Promise<string> {
-    const limit = Math.min(env.MEMORY_SEARCH_K, MAX_MEMORY_RESULTS_PER_SCOPE)
+    const limit = Math.min(getRuntimeConfig().memory.searchK, MAX_MEMORY_RESULTS_PER_SCOPE)
     const candidateLimit = fastMode ? limit : getCandidateLimit(limit)
     const orgScopeId = scopeId(ORG_SCOPE_PREFIX, orgId)
     const orgMemory = this.getOrgMemory(orgId)

package/src/services/mutating-approval.service.ts

@@ -6,7 +6,7 @@ import { workstreamMessageService } from './workstream-message.service'
 
 const APPROVAL_VERIFICATION_MESSAGE_WINDOW = 20
 
-export type VerifyMutatingApproval = (params: {
+type VerifyMutatingApproval = (params: {
   workstreamId: string
   approvalReason: string
   approvalToken: string

package/src/services/organization-member.service.ts

@@ -1,4 +1,4 @@
-import { recordIdStringSchema } from '@lota-sdk/shared/schemas/common'
+import { recordIdStringSchema } from '@lota-sdk/shared'
 import { z } from 'zod'
 
 import { BaseService } from '../db/base.service'

package/src/services/organization.service.ts

@@ -1,4 +1,4 @@
-import { recordIdStringSchema } from '@lota-sdk/shared/schemas/common'
+import { recordIdStringSchema } from '@lota-sdk/shared'
 import { z } from 'zod'
 
 import { BaseService } from '../db/base.service'

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

@@ -0,0 +1,83 @@
+import { PlanApprovalSchema } from '@lota-sdk/shared'
+import type { PlanApprovalRecord, PlanApprovalStatus } from '@lota-sdk/shared'
+import { RecordId } from 'surrealdb'
+
+import type { RecordIdInput } from '../db/record-id'
+import { ensureRecordId } from '../db/record-id'
+import { databaseService } from '../db/service'
+import type { DatabaseTransaction } from '../db/service'
+import { TABLES } from '../db/tables'
+
+class PlanApprovalService {
+  async createPendingApproval(params: {
+    tx: DatabaseTransaction
+    runId: RecordIdInput
+    nodeRunId: RecordIdInput
+    nodeId: string
+    requestedBy: string
+    presented: Record<string, unknown>
+  }): Promise<PlanApprovalRecord> {
+    const approvalId = new RecordId(TABLES.PLAN_APPROVAL, Bun.randomUUIDv7())
+    const created = await params.tx
+      .create(approvalId)
+      .content({
+        runId: ensureRecordId(params.runId, TABLES.PLAN_RUN),
+        nodeRunId: ensureRecordId(params.nodeRunId, TABLES.PLAN_NODE_RUN),
+        nodeId: params.nodeId,
+        status: 'pending',
+        requestedBy: params.requestedBy,
+        presented: params.presented,
+        requiredEdits: [],
+      })
+      .output('after')
+
+    return PlanApprovalSchema.parse(created)
+  }
+
+  async getApprovalById(approvalId: RecordIdInput): Promise<PlanApprovalRecord | null> {
+    return await databaseService.findOne(
+      TABLES.PLAN_APPROVAL,
+      { id: ensureRecordId(approvalId, TABLES.PLAN_APPROVAL) },
+      PlanApprovalSchema,
+    )
+  }
+
+  async getPendingApprovalForNodeRun(nodeRunId: RecordIdInput): Promise<PlanApprovalRecord | null> {
+    const approvals = await databaseService.findMany(
+      TABLES.PLAN_APPROVAL,
+      { nodeRunId: ensureRecordId(nodeRunId, TABLES.PLAN_NODE_RUN), status: 'pending' },
+      PlanApprovalSchema,
+      { orderBy: 'createdAt', orderDir: 'DESC', limit: 1 },
+    )
+
+    return approvals.at(0) ?? null
+  }
+
+  async updateApprovalResponse(params: {
+    tx: DatabaseTransaction
+    approval: PlanApprovalRecord
+    status: PlanApprovalStatus
+    response: Record<string, unknown>
+    respondedBy: string
+    approvalMessageId?: string
+    comments?: string
+    requiredEdits?: string[]
+  }): Promise<PlanApprovalRecord> {
+    const updated = await params.tx
+      .update(ensureRecordId(params.approval.id, TABLES.PLAN_APPROVAL))
+      .merge({
+        status: params.status,
+        response: params.response,
+        respondedBy: params.respondedBy,
+        ...(params.approvalMessageId ? { approvalMessageId: params.approvalMessageId } : {}),
+        ...(params.comments ? { comments: params.comments } : {}),
+        ...(params.requiredEdits ? { requiredEdits: params.requiredEdits } : {}),
+        respondedAt: new Date(),
+      })
+      .output('after')
+
+    return PlanApprovalSchema.parse(updated)
+  }
+}
+
+export const planApprovalService = new PlanApprovalService()

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

@@ -0,0 +1,44 @@
+import { PlanArtifactSchema } from '@lota-sdk/shared'
+import type { PlanArtifactRecord, PlanArtifactSubmission } from '@lota-sdk/shared'
+import { RecordId } from 'surrealdb'
+
+import type { RecordIdInput } from '../db/record-id'
+import { ensureRecordId } from '../db/record-id'
+import type { DatabaseTransaction } from '../db/service'
+import { TABLES } from '../db/tables'
+
+class PlanArtifactService {
+  async persistArtifacts(params: {
+    tx: DatabaseTransaction
+    runId: RecordIdInput
+    attemptId: RecordIdInput
+    nodeId: string
+    artifacts: PlanArtifactSubmission[]
+  }): Promise<PlanArtifactRecord[]> {
+    const records: PlanArtifactRecord[] = []
+
+    for (const artifact of params.artifacts) {
+      const artifactId = new RecordId(TABLES.PLAN_ARTIFACT, Bun.randomUUIDv7())
+      const created = await params.tx
+        .create(artifactId)
+        .content({
+          runId: ensureRecordId(params.runId, TABLES.PLAN_RUN),
+          attemptId: ensureRecordId(params.attemptId, TABLES.PLAN_NODE_ATTEMPT),
+          nodeId: params.nodeId,
+          name: artifact.name,
+          kind: artifact.kind,
+          pointer: artifact.pointer,
+          ...(artifact.schemaRef ? { schemaRef: artifact.schemaRef } : {}),
+          ...(artifact.description ? { description: artifact.description } : {}),
+          ...(artifact.payload ? { payload: artifact.payload } : {}),
+        })
+        .output('after')
+
+      records.push(PlanArtifactSchema.parse(created))
+    }
+
+    return records
+  }
+}
+
+export const planArtifactService = new PlanArtifactService()

package/src/services/plan-builder.service.ts

@@ -0,0 +1,61 @@
+import type { PlanDraft } from '@lota-sdk/shared'
+
+function buildImplicitLinearEdges(draft: PlanDraft) {
+  if (draft.edges.length > 0 || draft.nodes.length <= 1) {
+    return draft.edges
+  }
+
+  return draft.nodes
+    .slice(0, -1)
+    .map((node, index) => ({
+      id: `edge_${node.id}_to_${draft.nodes[index + 1]?.id ?? index + 1}`,
+      source: node.id,
+      target: draft.nodes[index + 1].id,
+      map: {},
+    }))
+}
+
+class PlanBuilderService {
+  roleAssignment(draft: PlanDraft): PlanDraft {
+    return draft
+  }
+
+  structureDesign(draft: PlanDraft): PlanDraft {
+    return {
+      ...draft,
+      edges: buildImplicitLinearEdges(draft),
+      entryNodeIds: draft.entryNodeIds && draft.entryNodeIds.length > 0 ? draft.entryNodeIds : [draft.nodes[0].id],
+    }
+  }
+
+  semanticCompletion(draft: PlanDraft): PlanDraft {
+    return {
+      ...draft,
+      nodes: draft.nodes.map((node) => ({
+        ...node,
+        deliverables: [...node.deliverables],
+        successCriteria: [...node.successCriteria],
+        completionChecks: [...node.completionChecks],
+        failurePolicy: [...node.failurePolicy],
+        retryPolicy: { ...node.retryPolicy, retryOn: [...node.retryPolicy.retryOn] },
+        toolPolicy: { allow: [...node.toolPolicy.allow], deny: [...node.toolPolicy.deny] },
+        contextPolicy: {
+          retrievalScopes: [...node.contextPolicy.retrievalScopes],
+          attachmentPolicy: node.contextPolicy.attachmentPolicy,
+          webPolicy: node.contextPolicy.webPolicy,
+        },
+      })),
+      edges: draft.edges.map((edge) => ({ ...edge, map: { ...edge.map } })),
+      schemas: structuredClone(draft.schemas),
+      entryNodeIds: [...(draft.entryNodeIds ?? [])],
+    }
+  }
+
+  prepareDraft(draft: PlanDraft): PlanDraft {
+    const withRoles = this.roleAssignment(draft)
+    const withStructure = this.structureDesign(withRoles)
+    return this.semanticCompletion(withStructure)
+  }
+}
+
+export const planBuilderService = new PlanBuilderService()

package/src/services/plan-checkpoint.service.ts

@@ -0,0 +1,53 @@
+import { PlanCheckpointSchema } from '@lota-sdk/shared'
+import type { PlanCheckpointRecord, PlanRunStatus } from '@lota-sdk/shared'
+import { RecordId } from 'surrealdb'
+
+import type { RecordIdInput } from '../db/record-id'
+import { ensureRecordId } from '../db/record-id'
+import { databaseService } from '../db/service'
+import type { DatabaseTransaction } from '../db/service'
+import { TABLES } from '../db/tables'
+
+class PlanCheckpointService {
+  async createCheckpoint(params: {
+    tx: DatabaseTransaction
+    runId: RecordIdInput
+    sequence: number
+    runStatus: PlanRunStatus
+    readyNodeIds: string[]
+    activeNodeIds: string[]
+    artifactIds: RecordIdInput[]
+    lastCompletedNodeIds: string[]
+    snapshot: Record<string, unknown>
+  }): Promise<PlanCheckpointRecord> {
+    const checkpointId = new RecordId(TABLES.PLAN_CHECKPOINT, Bun.randomUUIDv7())
+    const created = await params.tx
+      .create(checkpointId)
+      .content({
+        runId: ensureRecordId(params.runId, TABLES.PLAN_RUN),
+        sequence: params.sequence,
+        runStatus: params.runStatus,
+        readyNodeIds: [...params.readyNodeIds],
+        activeNodeIds: [...params.activeNodeIds],
+        artifactIds: params.artifactIds.map((artifactId) => ensureRecordId(artifactId, TABLES.PLAN_ARTIFACT)),
+        lastCompletedNodeIds: [...params.lastCompletedNodeIds],
+        snapshot: params.snapshot,
+      })
+      .output('after')
+
+    return PlanCheckpointSchema.parse(created)
+  }
+
+  async loadLatestForRun(runId: RecordIdInput): Promise<PlanCheckpointRecord | null> {
+    const checkpoints = await databaseService.findMany(
+      TABLES.PLAN_CHECKPOINT,
+      { runId: ensureRecordId(runId, TABLES.PLAN_RUN) },
+      PlanCheckpointSchema,
+      { orderBy: 'sequence', orderDir: 'DESC', limit: 1 },
+    )
+
+    return checkpoints.at(0) ?? null
+  }
+}
+
+export const planCheckpointService = new PlanCheckpointService()

package/src/services/plan-compiler.service.ts

@@ -0,0 +1,81 @@
+import type { PlanDraft, PlanNodeSpec, PlanNodeSpecRecord } from '@lota-sdk/shared'
+
+import { planValidatorService } from './plan-validator.service'
+
+export interface CompiledPlanNode {
+  node: PlanNodeSpec
+  position: number
+  upstreamNodeIds: string[]
+  downstreamNodeIds: string[]
+}
+
+interface CompiledPlanDraft {
+  draft: PlanDraft
+  nodes: CompiledPlanNode[]
+}
+
+class PlanCompilerService {
+  compile(draft: PlanDraft): CompiledPlanDraft {
+    const validation = planValidatorService.validateDraft(draft)
+    if (validation.blocking.length > 0) {
+      throw new Error(
+        `Plan draft failed validation: ${validation.blocking.map((issue) => `${issue.code}: ${issue.message}`).join(' | ')}`,
+      )
+    }
+
+    const upstreamByNodeId = new Map<string, string[]>()
+    const downstreamByNodeId = new Map<string, string[]>()
+
+    for (const node of draft.nodes) {
+      upstreamByNodeId.set(node.id, [])
+      downstreamByNodeId.set(node.id, [])
+    }
+
+    for (const edge of draft.edges) {
+      upstreamByNodeId.get(edge.target)?.push(edge.source)
+      downstreamByNodeId.get(edge.source)?.push(edge.target)
+    }
+
+    return {
+      draft,
+      nodes: draft.nodes.map((node, index) => ({
+        node,
+        position: index,
+        upstreamNodeIds: [...(upstreamByNodeId.get(node.id) ?? [])],
+        downstreamNodeIds: [...(downstreamByNodeId.get(node.id) ?? [])],
+      })),
+    }
+  }
+
+  toNodeSpecRecords(
+    compiled: CompiledPlanDraft,
+  ): Array<Omit<PlanNodeSpecRecord, 'id' | 'planSpecId' | 'createdAt' | 'updatedAt'>> {
+    return compiled.nodes.map(({ node, position, upstreamNodeIds, downstreamNodeIds }) => ({
+      nodeId: node.id,
+      position,
+      type: node.type,
+      label: node.label,
+      owner: node.owner,
+      objective: node.objective,
+      instructions: node.instructions,
+      ...(node.inputSchemaRef ? { inputSchemaRef: node.inputSchemaRef } : {}),
+      ...(node.outputSchemaRef ? { outputSchemaRef: node.outputSchemaRef } : {}),
+      deliverables: [...node.deliverables],
+      successCriteria: [...node.successCriteria],
+      completionChecks: [...node.completionChecks],
+      retryPolicy: { ...node.retryPolicy, retryOn: [...node.retryPolicy.retryOn] },
+      failurePolicy: [...node.failurePolicy],
+      ...(node.timeoutMs ? { timeoutMs: node.timeoutMs } : {}),
+      toolPolicy: { allow: [...node.toolPolicy.allow], deny: [...node.toolPolicy.deny] },
+      contextPolicy: {
+        retrievalScopes: [...node.contextPolicy.retrievalScopes],
+        attachmentPolicy: node.contextPolicy.attachmentPolicy,
+        webPolicy: node.contextPolicy.webPolicy,
+      },
+      upstreamNodeIds,
+      downstreamNodeIds,
+    }))
+  }
+}
+
+export const planCompilerService = new PlanCompilerService()