@lota-sdk/core 0.1.23 → 0.1.25

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

@@ -13,10 +13,12 @@ import type {
   SerializableExecutionPlan,
 } from '@lota-sdk/shared'
 import {
+  HUMAN_NODE_TYPES as HUMAN_NODE_TYPE_VALUES,
   PlanEventSchema,
   PlanNodeAttemptSchema,
   PlanNodeRunSchema,
   PlanRunSchema,
+  STRUCTURAL_NODE_TYPES as STRUCTURAL_NODE_TYPE_VALUES,
   PlanValidationIssueSchema,
 } from '@lota-sdk/shared'
 import { RecordId } from 'surrealdb'
@@ -29,23 +31,24 @@ import type { DatabaseTransaction } from '../db/service'
 import { TABLES } from '../db/tables'
 import { toDatabaseDateTime } from '../utils/date-time'
 import { isRecord } from '../utils/string'
-import { feedbackLoopService } from './feedback-loop.service'
-import { institutionalMemoryService } from './institutional-memory.service'
 import { planApprovalService } from './plan-approval.service'
 import { planArtifactService } from './plan-artifact.service'
 import { planCheckpointService } from './plan-checkpoint.service'
+import { runPlanCompletionSideEffectsSafely, runPlanNodeCompletionSideEffects } from './plan-completion-side-effects'
 import { planCoordinationService } from './plan-coordination.service'
 import { planEventDeliveryService } from './plan-event-delivery.service'
 import { isExecutableConditionExpression, readPathValue } from './plan-helpers'
+import { toPlanNodeValidationSpec } from './plan-node-spec'
+import { buildExecutionPlanToolResult, toRunData } from './plan-run-data'
+import type { PlanRunUpdate } from './plan-run-data'
 import { planRunService } from './plan-run.service'
 import { planSchedulerService } from './plan-scheduler.service'
 import type { PlanValidationIssueInput } from './plan-validator.service'
 import { planValidatorService } from './plan-validator.service'
-import { qualityMetricsService } from './quality-metrics.service'
 
 const SUCCESSFUL_TERMINAL_NODE_STATUSES = new Set(['completed', 'partial', 'skipped', 'scheduled', 'monitoring'])
-const HUMAN_NODE_TYPES = new Set(['human-input', 'human-approval', 'human-review-edit', 'human-decision'])
-const STRUCTURAL_NODE_TYPES = new Set(['switch', 'join', 'deliberation-fork'])
+const HUMAN_NODE_TYPE_SET = new Set<string>(HUMAN_NODE_TYPE_VALUES)
+const STRUCTURAL_NODE_TYPE_SET = new Set<string>(STRUCTURAL_NODE_TYPE_VALUES)
 
 function setPathValue(target: Record<string, unknown>, path: string, value: unknown) {
   const segments = path
@@ -142,23 +145,11 @@ function isSuccessfulTerminalStatus(status: string): boolean {
 }
 
 function isHumanNodeType(type: string): boolean {
-  return HUMAN_NODE_TYPES.has(type)
+  return HUMAN_NODE_TYPE_SET.has(type)
 }
 
 function isStructuralNodeType(type: string): boolean {
-  return STRUCTURAL_NODE_TYPES.has(type)
-}
-
-type PlanRunUpdate = Omit<
-  Partial<PlanRunRecord>,
-  'currentNodeId' | 'waitingNodeId' | 'replacedRunId' | 'lastCheckpointId' | 'startedAt' | 'completedAt'
-> & {
-  currentNodeId?: string | null
-  waitingNodeId?: string | null
-  replacedRunId?: RecordIdInput | null
-  lastCheckpointId?: RecordIdInput | null
-  startedAt?: string | Date | null
-  completedAt?: string | Date | null
+  return STRUCTURAL_NODE_TYPE_SET.has(type)
 }
 
 type PlanNodeRunUpdate = Omit<
@@ -188,60 +179,6 @@ type PlanNodeRunUpdate = Omit<
   completedAt?: string | Date | null
 }
 
-function toRunData(run: PlanRunRecord, patch: PlanRunUpdate) {
-  return {
-    planSpecId: ensureRecordId(run.planSpecId, TABLES.PLAN_SPEC),
-    organizationId: ensureRecordId(run.organizationId, TABLES.ORGANIZATION),
-    workstreamId: ensureRecordId(run.workstreamId, TABLES.WORKSTREAM),
-    leadAgentId: patch.leadAgentId ?? run.leadAgentId,
-    status: patch.status ?? run.status,
-    ...(patch.currentNodeId === null
-      ? {}
-      : patch.currentNodeId !== undefined
-        ? { currentNodeId: patch.currentNodeId }
-        : run.currentNodeId
-          ? { currentNodeId: run.currentNodeId }
-          : {}),
-    ...(patch.waitingNodeId === null
-      ? {}
-      : patch.waitingNodeId !== undefined
-        ? { waitingNodeId: patch.waitingNodeId }
-        : run.waitingNodeId
-          ? { waitingNodeId: run.waitingNodeId }
-          : {}),
-    readyNodeIds: patch.readyNodeIds ? [...patch.readyNodeIds] : [...run.readyNodeIds],
-    failureCount: patch.failureCount ?? run.failureCount,
-    ...(patch.replacedRunId === null
-      ? {}
-      : patch.replacedRunId
-        ? { replacedRunId: ensureRecordId(patch.replacedRunId, TABLES.PLAN_RUN) }
-        : run.replacedRunId
-          ? { replacedRunId: ensureRecordId(run.replacedRunId, TABLES.PLAN_RUN) }
-          : {}),
-    ...(patch.lastCheckpointId === null
-      ? {}
-      : patch.lastCheckpointId
-        ? { lastCheckpointId: ensureRecordId(patch.lastCheckpointId, TABLES.PLAN_CHECKPOINT) }
-        : run.lastCheckpointId
-          ? { lastCheckpointId: ensureRecordId(run.lastCheckpointId, TABLES.PLAN_CHECKPOINT) }
-          : {}),
-    ...(patch.startedAt === null
-      ? {}
-      : patch.startedAt !== undefined
-        ? { startedAt: toDatabaseDateTime(patch.startedAt) }
-        : run.startedAt
-          ? { startedAt: toDatabaseDateTime(run.startedAt) }
-          : {}),
-    ...(patch.completedAt === null
-      ? {}
-      : patch.completedAt !== undefined
-        ? { completedAt: toDatabaseDateTime(patch.completedAt) }
-        : run.completedAt
-          ? { completedAt: toDatabaseDateTime(run.completedAt) }
-          : {}),
-  }
-}
-
 function toNodeRunData(nodeRun: PlanNodeRunRecord, patch: PlanNodeRunUpdate) {
   return {
     runId: ensureRecordId(nodeRun.runId, TABLES.PLAN_RUN),
@@ -330,22 +267,6 @@ function toNodeRunData(nodeRun: PlanNodeRunRecord, patch: PlanNodeRunUpdate) {
   }
 }
 
-function buildToolResult(params: {
-  action: ExecutionPlanToolResultData['action']
-  plan: SerializableExecutionPlan | null
-  message: string
-  changedNodeId?: string
-}): ExecutionPlanToolResultData {
-  return {
-    action: params.action,
-    message: params.message,
-    ...(params.changedNodeId ? { changedNodeId: params.changedNodeId } : {}),
-    ...(params.plan ? { plan: params.plan } : {}),
-    hasPlan: params.plan !== null,
-    status: params.plan?.status,
-  }
-}
-
 function deriveApprovalStatus(response: Record<string, unknown>): 'approved' | 'rejected' | 'changes-requested' {
   const approved = response.approved === true
   const requiredEdits = Array.isArray(response.requiredEdits)
@@ -396,30 +317,7 @@ class PlanExecutorService {
     const latestCheckpoint = await planRunService.getLatestCheckpoint(run.id)
     const validation = planValidatorService.validateNodeResult({
       draft: { schemas: spec.schemaRegistry },
-      node: {
-        id: nodeSpec.nodeId,
-        type: nodeSpec.type,
-        label: nodeSpec.label,
-        owner: nodeSpec.owner,
-        objective: nodeSpec.objective,
-        instructions: nodeSpec.instructions,
-        inputSchemaRef: nodeSpec.inputSchemaRef,
-        outputSchemaRef: nodeSpec.outputSchemaRef,
-        deliverables: [...nodeSpec.deliverables],
-        successCriteria: [...nodeSpec.successCriteria],
-        completionChecks: [...nodeSpec.completionChecks],
-        retryPolicy: { ...nodeSpec.retryPolicy, retryOn: [...nodeSpec.retryPolicy.retryOn] },
-        failurePolicy: [...nodeSpec.failurePolicy],
-        timeoutMs: nodeSpec.timeoutMs,
-        toolPolicy: { allow: [...nodeSpec.toolPolicy.allow], deny: [...nodeSpec.toolPolicy.deny] },
-        contextPolicy: {
-          retrievalScopes: [...nodeSpec.contextPolicy.retrievalScopes],
-          attachmentPolicy: nodeSpec.contextPolicy.attachmentPolicy,
-          webPolicy: nodeSpec.contextPolicy.webPolicy,
-        },
-        executionVisibility: nodeSpec.executionVisibility,
-        ...(nodeSpec.escalation ? { escalation: nodeSpec.escalation } : {}),
-      },
+      node: toPlanNodeValidationSpec(nodeSpec),
       result: params.result,
     })
     const emittedEvents: PlanEventRecord[] = []
@@ -557,6 +455,7 @@ class PlanExecutorService {
           const checkpoint = await this.saveCheckpoint({
             tx,
             run: synced.run,
+            spec,
             nodeRuns: synced.nodeRuns,
             artifacts: synced.artifacts,
             sequence: (latestCheckpoint?.sequence ?? 0) + 1,
@@ -627,6 +526,7 @@ class PlanExecutorService {
           const checkpoint = await this.saveCheckpoint({
             tx,
             run: failedRun,
+            spec,
             nodeRuns: withUpdatedNodeRuns.map((candidate) =>
               candidate.nodeId === nextNodeRun.nodeId ? nextNodeRun : candidate,
             ),
@@ -681,6 +581,7 @@ class PlanExecutorService {
           const checkpoint = await this.saveCheckpoint({
             tx,
             run: blockedRun,
+            spec,
             nodeRuns: withUpdatedNodeRuns.map((candidate) =>
               candidate.nodeId === nextNodeRun.nodeId ? nextNodeRun : candidate,
             ),
@@ -736,6 +637,7 @@ class PlanExecutorService {
         const checkpoint = await this.saveCheckpoint({
           tx,
           run: failedRun,
+          spec,
           nodeRuns: withUpdatedNodeRuns.map((candidate) =>
             candidate.nodeId === nextNodeRun.nodeId ? nextNodeRun : candidate,
           ),
@@ -801,6 +703,7 @@ class PlanExecutorService {
       const checkpoint = await this.saveCheckpoint({
         tx,
         run: synced.run,
+        spec,
         nodeRuns: synced.nodeRuns,
         artifacts: synced.artifacts,
         sequence: (latestCheckpoint?.sequence ?? 0) + 1,
@@ -811,61 +714,27 @@ class PlanExecutorService {
       await this.attachCheckpoint(tx, synced.run, checkpoint)
     })
 
-    // Record node-level quality metrics (fire-and-forget)
     const orgId = recordIdToString(run.organizationId, TABLES.ORGANIZATION)
     const runIdStr = recordIdToString(run.id, TABLES.PLAN_RUN)
-    const nodeStartedAt = nodeRun.startedAt
-    const executionTimeMs = nodeStartedAt ? Date.now() - new Date(nodeStartedAt).getTime() : 0
-    qualityMetricsService
-      .recordNodeMetrics({
-        organizationId: orgId,
-        runId: runIdStr,
-        nodeId: params.nodeId,
-        metrics: {
-          executionTimeMs: Math.max(0, executionTimeMs),
-          attemptCount: nodeRun.attemptCount + 1,
-          artifactCount: params.result.artifacts.length,
-          validationIssueCount: validation.blocking.length + validation.warnings.length,
-          ownerRef: nodeSpec.owner.ref,
-          ownerType: nodeSpec.owner.executorType,
-          nodeType: nodeSpec.type,
-        },
-      })
-      .catch((error) => {
-        aiLogger.warn`Failed to record node quality metrics for run ${runIdStr} node ${params.nodeId}: ${error instanceof Error ? error.message : String(error)}`
-      })
+    void runPlanNodeCompletionSideEffects({
+      runId: runIdStr,
+      organizationId: orgId,
+      nodeId: params.nodeId,
+      nodeLabel: nodeSpec.label,
+      nodeOwnerRef: nodeSpec.owner.ref,
+      nodeOwnerType: nodeSpec.owner.executorType,
+      nodeType: nodeSpec.type,
+      nodeStartedAt: nodeRun.startedAt,
+      nodeAttemptCount: nodeRun.attemptCount + 1,
+      artifactCount: params.result.artifacts.length,
+      validationIssues: [...validation.blocking, ...validation.warnings],
+    }).catch((error) => {
+      aiLogger.warn`Failed to record node completion metrics for run ${runIdStr} node ${params.nodeId}: ${error instanceof Error ? error.message : String(error)}`
+    })
 
-    // If the run just completed, record cycle metrics, persist feedback recommendations, and extract patterns
     const updatedRun = await planRunService.getRunById(run.id)
     if (updatedRun.status === 'completed') {
-      qualityMetricsService.recordCycleMetrics({ organizationId: orgId, runId: runIdStr }).catch((error) => {
-        aiLogger.warn`Failed to record cycle quality metrics for run ${runIdStr}: ${error instanceof Error ? error.message : String(error)}`
-      })
-      feedbackLoopService
-        .analyzeOutcomes({ runId: runIdStr, organizationId: orgId })
-        .then(async (recommendations) => {
-          if (recommendations.length === 0) return
-          const specRecord = await planRunService.getPlanSpecById(updatedRun.planSpecId)
-          const event = await databaseService.create(
-            TABLES.PLAN_EVENT,
-            {
-              planSpecId: ensureRecordId(specRecord.id, TABLES.PLAN_SPEC),
-              runId: ensureRecordId(updatedRun.id, TABLES.PLAN_RUN),
-              eventType: 'feedback-analyzed',
-              message: `Feedback analysis produced ${recommendations.length} recommendation(s).`,
-              detail: { recommendations },
-              emittedBy: 'system',
-            },
-            PlanEventSchema,
-          )
-          await planEventDeliveryService.dispatchEvent(event)
-        })
-        .catch((error) => {
-          aiLogger.warn`Failed to analyze feedback outcomes for run ${runIdStr}: ${error instanceof Error ? error.message : String(error)}`
-        })
-      institutionalMemoryService.extractPatterns({ organizationId: orgId, runId: runIdStr }).catch((error) => {
-        aiLogger.warn`Failed to extract institutional memory patterns for run ${runIdStr}: ${error instanceof Error ? error.message : String(error)}`
-      })
+      void runPlanCompletionSideEffectsSafely({ runId: runIdStr, organizationId: orgId })
     }
 
     await planEventDeliveryService.dispatchEvents(emittedEvents)
@@ -878,7 +747,7 @@ class PlanExecutorService {
       includeValidationIssues: true,
     })
 
-    return buildToolResult({
+    return buildExecutionPlanToolResult({
       action: 'node-result-submitted',
       plan: snapshot,
       message: `Submitted result for node "${nodeSpec.label}".`,
@@ -917,30 +786,7 @@ class PlanExecutorService {
     const latestCheckpoint = await planRunService.getLatestCheckpoint(run.id)
     const validation = planValidatorService.validateNodeResult({
       draft: { schemas: spec.schemaRegistry },
-      node: {
-        id: nodeSpec.nodeId,
-        type: nodeSpec.type,
-        label: nodeSpec.label,
-        owner: nodeSpec.owner,
-        objective: nodeSpec.objective,
-        instructions: nodeSpec.instructions,
-        inputSchemaRef: nodeSpec.inputSchemaRef,
-        outputSchemaRef: nodeSpec.outputSchemaRef,
-        deliverables: [...nodeSpec.deliverables],
-        successCriteria: [...nodeSpec.successCriteria],
-        completionChecks: [...nodeSpec.completionChecks],
-        retryPolicy: { ...nodeSpec.retryPolicy, retryOn: [...nodeSpec.retryPolicy.retryOn] },
-        failurePolicy: [...nodeSpec.failurePolicy],
-        timeoutMs: nodeSpec.timeoutMs,
-        toolPolicy: { allow: [...nodeSpec.toolPolicy.allow], deny: [...nodeSpec.toolPolicy.deny] },
-        contextPolicy: {
-          retrievalScopes: [...nodeSpec.contextPolicy.retrievalScopes],
-          attachmentPolicy: nodeSpec.contextPolicy.attachmentPolicy,
-          webPolicy: nodeSpec.contextPolicy.webPolicy,
-        },
-        executionVisibility: nodeSpec.executionVisibility,
-        ...(nodeSpec.escalation ? { escalation: nodeSpec.escalation } : {}),
-      },
+      node: toPlanNodeValidationSpec(nodeSpec),
       result: {
         structuredOutput: params.response,
         artifacts: [],
@@ -1072,6 +918,7 @@ class PlanExecutorService {
         const checkpoint = await this.saveCheckpoint({
           tx,
           run: blockedRun,
+          spec,
           nodeRuns,
           artifacts: existingArtifacts,
           sequence: (latestCheckpoint?.sequence ?? 0) + 1,
@@ -1112,6 +959,7 @@ class PlanExecutorService {
       const checkpoint = await this.saveCheckpoint({
         tx,
         run: synced.run,
+        spec,
         nodeRuns: synced.nodeRuns,
         artifacts: synced.artifacts,
         sequence: (latestCheckpoint?.sequence ?? 0) + 1,
@@ -1210,6 +1058,7 @@ class PlanExecutorService {
       const checkpoint = await this.saveCheckpoint({
         tx,
         run: synced.run,
+        spec,
         nodeRuns: synced.nodeRuns,
         artifacts: synced.artifacts,
         sequence: (latestCheckpoint?.sequence ?? 0) + 1,
@@ -1229,7 +1078,7 @@ class PlanExecutorService {
       includeValidationIssues: true,
     })
 
-    return buildToolResult({
+    return buildExecutionPlanToolResult({
       action: 'run-resumed',
       plan: snapshot,
       message: `Resumed execution run "${snapshot.title}".`,
@@ -1325,6 +1174,7 @@ class PlanExecutorService {
       const checkpoint = await this.saveCheckpoint({
         tx,
         run: blockedRun,
+        spec,
         nodeRuns: (await planRunService.listNodeRuns(run.id)).map((candidate) =>
           candidate.nodeId === blockedNodeRun.nodeId ? blockedNodeRun : candidate,
         ),
@@ -1405,6 +1255,7 @@ class PlanExecutorService {
       const checkpoint = await this.saveCheckpoint({
         tx,
         run: synced.run,
+        spec,
         nodeRuns: synced.nodeRuns,
         artifacts: synced.artifacts,
         sequence: (latestCheckpoint?.sequence ?? 0) + 1,
@@ -1996,6 +1847,7 @@ class PlanExecutorService {
   private async saveCheckpoint(params: {
     tx: DatabaseTransaction
     run: PlanRunRecord
+    spec: PlanSpecRecord
     nodeRuns: PlanNodeRunRecord[]
     artifacts: Array<{ id: RecordIdInput; nodeId: string }>
     sequence: number
@@ -2028,7 +1880,7 @@ class PlanExecutorService {
     await this.emitEvent({
       tx: params.tx,
       run: params.run,
-      spec: await planRunService.getPlanSpecById(params.run.planSpecId),
+      spec: params.spec,
       eventType: 'checkpoint-saved',
       message: `Saved checkpoint ${checkpoint.sequence}.`,
       detail: { checkpointId: recordIdToString(checkpoint.id, TABLES.PLAN_CHECKPOINT), reason: params.reason },

package/src/services/plan-node-spec.ts

@@ -0,0 +1,60 @@
+import type { PlanNodeSpec, PlanNodeSpecRecord } from '@lota-sdk/shared'
+
+export type PlanNodeValidationSpec = Pick<
+  PlanNodeSpec,
+  | 'id'
+  | 'type'
+  | 'label'
+  | 'owner'
+  | 'objective'
+  | 'instructions'
+  | 'inputSchemaRef'
+  | 'outputSchemaRef'
+  | 'deliverables'
+  | 'successCriteria'
+  | 'completionChecks'
+  | 'retryPolicy'
+  | 'failurePolicy'
+  | 'timeoutMs'
+  | 'toolPolicy'
+  | 'contextPolicy'
+  | 'executionVisibility'
+  | 'schedule'
+  | 'deadline'
+  | 'escalation'
+  | 'monitoringConfig'
+  | 'delayAfterPredecessorMs'
+  | 'deliberationConfig'
+>
+
+export function toPlanNodeValidationSpec(nodeSpec: PlanNodeSpecRecord): PlanNodeValidationSpec {
+  return {
+    id: nodeSpec.nodeId,
+    type: nodeSpec.type,
+    label: nodeSpec.label,
+    owner: nodeSpec.owner,
+    objective: nodeSpec.objective,
+    instructions: nodeSpec.instructions,
+    inputSchemaRef: nodeSpec.inputSchemaRef,
+    outputSchemaRef: nodeSpec.outputSchemaRef,
+    deliverables: [...nodeSpec.deliverables],
+    successCriteria: [...nodeSpec.successCriteria],
+    completionChecks: [...nodeSpec.completionChecks],
+    retryPolicy: { ...nodeSpec.retryPolicy, retryOn: [...nodeSpec.retryPolicy.retryOn] },
+    failurePolicy: [...nodeSpec.failurePolicy],
+    timeoutMs: nodeSpec.timeoutMs,
+    toolPolicy: { allow: [...nodeSpec.toolPolicy.allow], deny: [...nodeSpec.toolPolicy.deny] },
+    contextPolicy: {
+      retrievalScopes: [...nodeSpec.contextPolicy.retrievalScopes],
+      attachmentPolicy: nodeSpec.contextPolicy.attachmentPolicy,
+      webPolicy: nodeSpec.contextPolicy.webPolicy,
+    },
+    executionVisibility: nodeSpec.executionVisibility,
+    ...(nodeSpec.schedule ? { schedule: nodeSpec.schedule } : {}),
+    ...(nodeSpec.deadline ? { deadline: nodeSpec.deadline } : {}),
+    ...(nodeSpec.escalation ? { escalation: nodeSpec.escalation } : {}),
+    ...(nodeSpec.monitoringConfig ? { monitoringConfig: nodeSpec.monitoringConfig } : {}),
+    ...(nodeSpec.delayAfterPredecessorMs ? { delayAfterPredecessorMs: nodeSpec.delayAfterPredecessorMs } : {}),
+    ...(nodeSpec.deliberationConfig ? { deliberationConfig: nodeSpec.deliberationConfig } : {}),
+  }
+}

package/src/services/plan-run-data.ts

@@ -0,0 +1,88 @@
+import type { ExecutionPlanToolResultData, PlanRunRecord } from '@lota-sdk/shared'
+
+import type { RecordIdInput } from '../db/record-id'
+import { ensureRecordId } from '../db/record-id'
+import { TABLES } from '../db/tables'
+import { toDatabaseDateTime } from '../utils/date-time'
+
+export type PlanRunUpdate = Omit<
+  Partial<PlanRunRecord>,
+  'currentNodeId' | 'waitingNodeId' | 'replacedRunId' | 'lastCheckpointId' | 'startedAt' | 'completedAt'
+> & {
+  currentNodeId?: string | null
+  waitingNodeId?: string | null
+  replacedRunId?: RecordIdInput | null
+  lastCheckpointId?: RecordIdInput | null
+  startedAt?: string | Date | null
+  completedAt?: string | Date | null
+}
+
+export function toRunData(run: PlanRunRecord, patch: PlanRunUpdate) {
+  return {
+    planSpecId: ensureRecordId(run.planSpecId, TABLES.PLAN_SPEC),
+    organizationId: ensureRecordId(run.organizationId, TABLES.ORGANIZATION),
+    workstreamId: ensureRecordId(run.workstreamId, TABLES.WORKSTREAM),
+    leadAgentId: patch.leadAgentId ?? run.leadAgentId,
+    status: patch.status ?? run.status,
+    ...(patch.currentNodeId === null
+      ? {}
+      : patch.currentNodeId !== undefined
+        ? { currentNodeId: patch.currentNodeId }
+        : run.currentNodeId
+          ? { currentNodeId: run.currentNodeId }
+          : {}),
+    ...(patch.waitingNodeId === null
+      ? {}
+      : patch.waitingNodeId !== undefined
+        ? { waitingNodeId: patch.waitingNodeId }
+        : run.waitingNodeId
+          ? { waitingNodeId: run.waitingNodeId }
+          : {}),
+    readyNodeIds: patch.readyNodeIds ? [...patch.readyNodeIds] : [...run.readyNodeIds],
+    failureCount: patch.failureCount ?? run.failureCount,
+    ...(patch.replacedRunId === null
+      ? {}
+      : patch.replacedRunId
+        ? { replacedRunId: ensureRecordId(patch.replacedRunId, TABLES.PLAN_RUN) }
+        : run.replacedRunId
+          ? { replacedRunId: ensureRecordId(run.replacedRunId, TABLES.PLAN_RUN) }
+          : {}),
+    ...(patch.lastCheckpointId === null
+      ? {}
+      : patch.lastCheckpointId
+        ? { lastCheckpointId: ensureRecordId(patch.lastCheckpointId, TABLES.PLAN_CHECKPOINT) }
+        : run.lastCheckpointId
+          ? { lastCheckpointId: ensureRecordId(run.lastCheckpointId, TABLES.PLAN_CHECKPOINT) }
+          : {}),
+    ...(patch.startedAt === null
+      ? {}
+      : patch.startedAt !== undefined
+        ? { startedAt: toDatabaseDateTime(patch.startedAt) }
+        : run.startedAt
+          ? { startedAt: toDatabaseDateTime(run.startedAt) }
+          : {}),
+    ...(patch.completedAt === null
+      ? {}
+      : patch.completedAt !== undefined
+        ? { completedAt: toDatabaseDateTime(patch.completedAt) }
+        : run.completedAt
+          ? { completedAt: toDatabaseDateTime(run.completedAt) }
+          : {}),
+  }
+}
+
+export function buildExecutionPlanToolResult(params: {
+  action: ExecutionPlanToolResultData['action']
+  plan: ExecutionPlanToolResultData['plan'] | null
+  message: string
+  changedNodeId?: string
+}): ExecutionPlanToolResultData {
+  return {
+    action: params.action,
+    message: params.message,
+    ...(params.changedNodeId ? { changedNodeId: params.changedNodeId } : {}),
+    ...(params.plan ? { plan: params.plan } : {}),
+    hasPlan: params.plan !== null,
+    status: params.plan?.status,
+  }
+}

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

@@ -3,17 +3,19 @@ import type {
   PlanDataSchema,
   PlanDraft,
   PlanFailureClass,
+  PlanNodeType,
   PlanNodeResultSubmission,
-  PlanNodeSpec,
   PlanValidationIssueSeverity,
 } from '@lota-sdk/shared'
+import { HUMAN_NODE_TYPES, STRUCTURAL_NODE_TYPES } from '@lota-sdk/shared'
 
 import { isRecord } from '../utils/string'
 import { planCoordinationService } from './plan-coordination.service'
 import { readPathValue } from './plan-helpers'
+import type { PlanNodeValidationSpec } from './plan-node-spec'
 
-const STRUCTURAL_NODE_TYPES = new Set(['switch', 'join', 'deliberation-fork'])
-const HUMAN_NODE_TYPES = new Set(['human-input', 'human-approval', 'human-review-edit', 'human-decision'])
+const STRUCTURAL_NODE_TYPE_SET = new Set<PlanNodeType>(STRUCTURAL_NODE_TYPES)
+const HUMAN_NODE_TYPE_SET = new Set<PlanNodeType>(HUMAN_NODE_TYPES)
 
 export interface PlanValidationIssueInput {
   severity: PlanValidationIssueSeverity
@@ -186,7 +188,7 @@ class PlanValidatorService {
       }
       nodeIds.add(node.id)
 
-      const isStructuralNode = STRUCTURAL_NODE_TYPES.has(node.type)
+      const isStructuralNode = STRUCTURAL_NODE_TYPE_SET.has(node.type)
       if (!isStructuralNode && node.deliverables.length === 0) {
         blocking.push(
           createIssue({
@@ -214,7 +216,7 @@ class PlanValidatorService {
           }),
         )
       }
-      if (HUMAN_NODE_TYPES.has(node.type) && node.owner.executorType !== 'user') {
+      if (HUMAN_NODE_TYPE_SET.has(node.type) && node.owner.executorType !== 'user') {
         blocking.push(
           createIssue({
             code: 'human_node_owner_mismatch',
@@ -224,7 +226,7 @@ class PlanValidatorService {
         )
       }
       if (
-        !HUMAN_NODE_TYPES.has(node.type) &&
+        !HUMAN_NODE_TYPE_SET.has(node.type) &&
         node.type !== 'join' &&
         node.type !== 'switch' &&
         node.owner.ref.trim().length === 0
@@ -518,7 +520,7 @@ class PlanValidatorService {
 
   validateNodeResult(params: {
     draft: Pick<PlanDraft, 'schemas'>
-    node: PlanNodeSpec
+    node: PlanNodeValidationSpec
     result: PlanNodeResultSubmission
   }): NodeResultValidationResult {
     const blocking: PlanValidationIssueInput[] = []
@@ -639,7 +641,7 @@ class PlanValidatorService {
 
   private evaluateCompletionCheck(params: {
     draft: Pick<PlanDraft, 'schemas'>
-    node: PlanNodeSpec
+    node: PlanNodeValidationSpec
     result: PlanNodeResultSubmission
     check: PlanCompletionCheck
   }): PlanValidationIssueInput | null {

package/src/services/workstream-constants.ts

@@ -0,0 +1,2 @@
+export const MEMORY_BLOCK_COMPACTION_TRIGGER_ENTRIES = 15
+export const MEMORY_BLOCK_COMPACTION_CHUNK_ENTRIES = 10

package/src/services/workstream-title.service.ts

@@ -35,7 +35,7 @@ class WorkstreamTitleService {
       title = limitTitleWords(deriveTitle(sourceText || WORKSTREAM.DEFAULT_TITLE))
     }
 
-    await workstreamService.persistGeneratedTitle(workstreamId, title)
+    await workstreamService.update(workstreamId, { title, nameGenerated: true })
   }
 }