@lota-sdk/core 0.4.0 → 0.4.2

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

@@ -29,8 +29,10 @@ import { ensureRecordId, recordIdToString } from '../db/record-id'
 import { databaseService } from '../db/service'
 import type { DatabaseTransaction } from '../db/service'
 import { TABLES } from '../db/tables'
+import { generatedDocumentStorageService } from '../storage/generated-document-storage.service'
 import { toDatabaseDateTime } from '../utils/date-time'
 import { isRecord } from '../utils/string'
+import { artifactService } from './artifact.service'
 import { planApprovalService } from './plan-approval.service'
 import { planArtifactService } from './plan-artifact.service'
 import { planCheckpointService } from './plan-checkpoint.service'
@@ -109,6 +111,22 @@ function buildNodeContext(params: {
   }
 }
 
+function buildPublishedArtifactContent(params: {
+  artifact: PlanNodeResultSubmission['artifacts'][number]
+  notes: string
+}): string {
+  const { artifact, notes } = params
+  if (artifact.content?.trim()) {
+    return artifact.content
+  }
+
+  if (artifact.payload !== undefined) {
+    return `# ${artifact.name}\n\n\`\`\`json\n${JSON.stringify(artifact.payload, null, 2)}\n\`\`\``
+  }
+
+  return `# ${artifact.name}\n\n${notes.trim()}`
+}
+
 function evaluateCondition(expression: string | undefined, context: Record<string, unknown>): boolean {
   if (!expression?.trim()) return true
   const normalized = expression.trim()
@@ -305,257 +323,351 @@ class PlanExecutorService {
       result: params.result,
     })
     const emittedEvents: PlanEventRecord[] = []
+    const publishedArtifactStorageKeys: string[] = []
 
-    await databaseService.withTransaction(async (tx) => {
-      const attempt = await this.createAttempt({
-        tx,
-        run,
-        nodeRun,
-        emittedBy: params.emittedBy,
-        result: params.result,
-        status: validation.blocking.length > 0 ? 'failed' : 'completed',
-        failureClass: validation.failureClass,
-      })
+    try {
+      await databaseService.withTransaction(async (tx) => {
+        const attempt = await this.createAttempt({
+          tx,
+          run,
+          nodeRun,
+          emittedBy: params.emittedBy,
+          result: params.result,
+          status: validation.blocking.length > 0 ? 'failed' : 'completed',
+          failureClass: validation.failureClass,
+        })
 
-      const issues = await this.persistValidationIssues({
-        tx,
-        run,
-        spec,
-        attemptId: attempt.id,
-        nodeId: params.nodeId,
-        issues: [...validation.blocking, ...validation.warnings],
-      })
+        const issues = await this.persistValidationIssues({
+          tx,
+          run,
+          spec,
+          attemptId: attempt.id,
+          nodeId: params.nodeId,
+          issues: [...validation.blocking, ...validation.warnings],
+        })
 
-      const finalizedAttempt = PlanNodeAttemptSchema.parse(
-        await tx
-          .update(ensureRecordId(attempt.id, TABLES.PLAN_NODE_ATTEMPT))
-          .content({
-            runId: ensureRecordId(attempt.runId, TABLES.PLAN_RUN),
-            nodeRunId: ensureRecordId(attempt.nodeRunId, TABLES.PLAN_NODE_RUN),
-            nodeId: attempt.nodeId,
-            emittedBy: attempt.emittedBy,
-            status: attempt.status,
-            ...(attempt.structuredOutput ? { structuredOutput: attempt.structuredOutput } : {}),
-            ...(attempt.notes ? { notes: attempt.notes } : {}),
-            validationIssueIds: issues.map((issue) => ensureRecordId(issue.id, TABLES.PLAN_VALIDATION_ISSUE)),
-            ...(attempt.failureClass ? { failureClass: attempt.failureClass } : {}),
-          })
-          .output('after'),
-      )
+        const finalizedAttempt = PlanNodeAttemptSchema.parse(
+          await tx
+            .update(ensureRecordId(attempt.id, TABLES.PLAN_NODE_ATTEMPT))
+            .content({
+              runId: ensureRecordId(attempt.runId, TABLES.PLAN_RUN),
+              nodeRunId: ensureRecordId(attempt.nodeRunId, TABLES.PLAN_NODE_RUN),
+              nodeId: attempt.nodeId,
+              emittedBy: attempt.emittedBy,
+              status: attempt.status,
+              ...(attempt.structuredOutput ? { structuredOutput: attempt.structuredOutput } : {}),
+              ...(attempt.notes ? { notes: attempt.notes } : {}),
+              validationIssueIds: issues.map((issue) => ensureRecordId(issue.id, TABLES.PLAN_VALIDATION_ISSUE)),
+              ...(attempt.failureClass ? { failureClass: attempt.failureClass } : {}),
+            })
+            .output('after'),
+        )
 
-      const persistedArtifacts = await planArtifactService.persistArtifacts({
-        tx,
-        runId: run.id,
-        attemptId: finalizedAttempt.id,
-        nodeId: params.nodeId,
-        artifacts: params.result.artifacts,
-      })
+        const publishedArtifacts =
+          validation.blocking.length > 0
+            ? params.result.artifacts
+            : await Promise.all(
+                params.result.artifacts.map(async (artifact) => {
+                  const deliverable = nodeSpec.deliverables.find((candidate) => candidate.name === artifact.name)
+                  if (!deliverable?.publishAs) {
+                    return artifact
+                  }
+
+                  const content = buildPublishedArtifactContent({ artifact, notes: params.result.notes })
+                  const published = await artifactService.publishArtifactInTransaction(
+                    {
+                      organizationId: recordIdToString(run.organizationId, TABLES.ORGANIZATION),
+                      authorAgentId: params.emittedBy,
+                      title: artifact.name,
+                      artifactKind: deliverable.publishAs.artifactKind,
+                      templateId: deliverable.publishAs.templateId,
+                      canonicalKey: deliverable.publishAs.canonicalKey,
+                      content,
+                      tags: [],
+                      ...(artifact.description ? { description: artifact.description } : {}),
+                      sourceThreadId: recordIdToString(run.threadId, TABLES.THREAD),
+                      sourcePlanRunId: recordIdToString(run.id, TABLES.PLAN_RUN),
+                      sourcePlanNodeId: params.nodeId,
+                      deliverableName: artifact.name,
+                    },
+                    tx,
+                  )
+                  publishedArtifactStorageKeys.push(published.storageKey)
+
+                  return { ...artifact, content, publishedArtifactId: recordIdToString(published.id, TABLES.ARTIFACT) }
+                }),
+              )
 
-      let nextNodeRun = PlanNodeRunSchema.parse(
-        await tx
-          .update(ensureRecordId(nodeRun.id, TABLES.PLAN_NODE_RUN))
-          .content(
-            toNodeRunData(nodeRun, {
-              attemptCount: nodeRun.attemptCount + 1,
-              latestAttemptId: finalizedAttempt.id,
-              latestStructuredOutput: params.result.structuredOutput ?? null,
-              latestNotes: params.result.notes,
-            }),
-          )
-          .output('after'),
-      )
+        const persistedArtifacts = await planArtifactService.persistArtifacts({
+          tx,
+          runId: run.id,
+          attemptId: finalizedAttempt.id,
+          nodeId: params.nodeId,
+          artifacts: publishedArtifacts,
+        })
 
-      const nodeRuns = await planRunService.listNodeRuns(run.id)
-      const withUpdatedNodeRuns = nodeRuns.map((candidate) =>
-        candidate.nodeId === nextNodeRun.nodeId ? nextNodeRun : candidate,
-      )
-      const nextArtifacts = [...existingArtifacts, ...persistedArtifacts]
+        let nextNodeRun = PlanNodeRunSchema.parse(
+          await tx
+            .update(ensureRecordId(nodeRun.id, TABLES.PLAN_NODE_RUN))
+            .content(
+              toNodeRunData(nodeRun, {
+                attemptCount: nodeRun.attemptCount + 1,
+                latestAttemptId: finalizedAttempt.id,
+                latestStructuredOutput: params.result.structuredOutput ?? null,
+                latestNotes: params.result.notes,
+              }),
+            )
+            .output('after'),
+        )
 
-      if (validation.blocking.length > 0) {
-        const shouldRetry =
-          validation.failureClass &&
-          nodeSpec.retryPolicy.maxAttempts > nextNodeRun.retryCount &&
-          (nodeSpec.retryPolicy.retryOn.length === 0 || nodeSpec.retryPolicy.retryOn.includes(validation.failureClass))
+        const nodeRuns = await planRunService.listNodeRuns(run.id)
+        const withUpdatedNodeRuns = nodeRuns.map((candidate) =>
+          candidate.nodeId === nextNodeRun.nodeId ? nextNodeRun : candidate,
+        )
+        const nextArtifacts = [...existingArtifacts, ...persistedArtifacts]
 
-        if (shouldRetry) {
-          nextNodeRun = PlanNodeRunSchema.parse(
-            await tx
-              .update(ensureRecordId(nextNodeRun.id, TABLES.PLAN_NODE_RUN))
-              .content(
-                toNodeRunData(nextNodeRun, {
-                  status: 'ready',
-                  retryCount: nextNodeRun.retryCount + 1,
-                  failureClass: validation.failureClass,
-                  blockedReason: validation.blocking[0]?.message ?? null,
-                  readyAt: new Date(),
-                  startedAt: null,
-                  completedAt: null,
-                }),
-              )
-              .output('after'),
-          )
+        if (validation.blocking.length > 0) {
+          const shouldRetry =
+            validation.failureClass &&
+            nodeSpec.retryPolicy.maxAttempts > nextNodeRun.retryCount &&
+            (nodeSpec.retryPolicy.retryOn.length === 0 ||
+              nodeSpec.retryPolicy.retryOn.includes(validation.failureClass))
 
-          await this.emitEvent({
-            tx,
-            run,
-            spec,
-            nodeId: nextNodeRun.nodeId,
-            attemptId: finalizedAttempt.id,
-            eventType: 'validation-reported',
-            message: `Validation failed for node "${nodeSpec.label}", scheduling retry.`,
-            detail: { issues: validation.blocking.map((issue) => issue.code) },
-            emittedBy: params.emittedBy,
-            capturedEvents: emittedEvents,
-          })
-          await this.emitEvent({
-            tx,
-            run,
-            spec,
-            nodeId: nextNodeRun.nodeId,
-            attemptId: finalizedAttempt.id,
-            eventType: 'node-unblocked',
-            fromStatus: nodeRun.status,
-            toStatus: nextNodeRun.status,
-            message: `Node "${nodeSpec.label}" is ready for another attempt.`,
-            detail: { retryCount: nextNodeRun.retryCount },
-            emittedBy: params.emittedBy,
-            capturedEvents: emittedEvents,
-          })
+          if (shouldRetry) {
+            nextNodeRun = PlanNodeRunSchema.parse(
+              await tx
+                .update(ensureRecordId(nextNodeRun.id, TABLES.PLAN_NODE_RUN))
+                .content(
+                  toNodeRunData(nextNodeRun, {
+                    status: 'ready',
+                    retryCount: nextNodeRun.retryCount + 1,
+                    failureClass: validation.failureClass,
+                    blockedReason: validation.blocking[0]?.message ?? null,
+                    readyAt: new Date(),
+                    startedAt: null,
+                    completedAt: null,
+                  }),
+                )
+                .output('after'),
+            )
 
-          const synced = await this.syncRunGraph({
-            tx,
-            run,
-            spec,
-            nodeSpecs,
-            nodeRuns: withUpdatedNodeRuns.map((candidate) =>
-              candidate.nodeId === nextNodeRun.nodeId ? nextNodeRun : candidate,
-            ),
-            artifacts: nextArtifacts,
-            emittedBy: params.emittedBy,
-            capturedEvents: emittedEvents,
-          })
+            await this.emitEvent({
+              tx,
+              run,
+              spec,
+              nodeId: nextNodeRun.nodeId,
+              attemptId: finalizedAttempt.id,
+              eventType: 'validation-reported',
+              message: `Validation failed for node "${nodeSpec.label}", scheduling retry.`,
+              detail: { issues: validation.blocking.map((issue) => issue.code) },
+              emittedBy: params.emittedBy,
+              capturedEvents: emittedEvents,
+            })
+            await this.emitEvent({
+              tx,
+              run,
+              spec,
+              nodeId: nextNodeRun.nodeId,
+              attemptId: finalizedAttempt.id,
+              eventType: 'node-unblocked',
+              fromStatus: nodeRun.status,
+              toStatus: nextNodeRun.status,
+              message: `Node "${nodeSpec.label}" is ready for another attempt.`,
+              detail: { retryCount: nextNodeRun.retryCount },
+              emittedBy: params.emittedBy,
+              capturedEvents: emittedEvents,
+            })
 
-          const checkpoint = await this.saveCheckpoint({
-            tx,
-            run: synced.run,
-            spec,
-            nodeRuns: synced.nodeRuns,
-            artifacts: synced.artifacts,
-            sequence: (latestCheckpoint?.sequence ?? 0) + 1,
-            reason: 'node-result-retry',
-            capturedEvents: emittedEvents,
-          })
+            const synced = await this.syncRunGraph({
+              tx,
+              run,
+              spec,
+              nodeSpecs,
+              nodeRuns: withUpdatedNodeRuns.map((candidate) =>
+                candidate.nodeId === nextNodeRun.nodeId ? nextNodeRun : candidate,
+              ),
+              artifacts: nextArtifacts,
+              emittedBy: params.emittedBy,
+              capturedEvents: emittedEvents,
+            })
 
-          await this.attachCheckpoint(tx, synced.run, checkpoint)
-          return
-        }
+            const checkpoint = await this.saveCheckpoint({
+              tx,
+              run: synced.run,
+              spec,
+              nodeRuns: synced.nodeRuns,
+              artifacts: synced.artifacts,
+              sequence: (latestCheckpoint?.sequence ?? 0) + 1,
+              reason: 'node-result-retry',
+              capturedEvents: emittedEvents,
+            })
 
-        const failureAction = this.resolveFailureAction(nodeSpec, validation.failureClass)
-        if (failureAction === 'human-review') {
-          nextNodeRun = PlanNodeRunSchema.parse(
-            await tx
-              .update(ensureRecordId(nextNodeRun.id, TABLES.PLAN_NODE_RUN))
-              .content(
-                toNodeRunData(nextNodeRun, {
-                  status: 'awaiting-human',
-                  retryCount: nextNodeRun.retryCount + 1,
-                  failureClass: validation.failureClass,
-                  blockedReason: validation.blocking[0]?.message ?? null,
-                  startedAt: nextNodeRun.startedAt ?? new Date(),
-                }),
-              )
-              .output('after'),
-          )
+            await this.attachCheckpoint(tx, synced.run, checkpoint)
+            return
+          }
 
-          const approval = await planApprovalService.createPendingApproval({
-            tx,
-            runId: run.id,
-            nodeRunId: nextNodeRun.id,
-            nodeId: nextNodeRun.nodeId,
-            requestedBy: params.emittedBy,
-            presented: {
-              nodeId: nodeSpec.nodeId,
-              label: nodeSpec.label,
-              objective: nodeSpec.objective,
-              instructions: nodeSpec.instructions,
-              validationIssues: validation.blocking,
-            },
-          })
+          const failureAction = this.resolveFailureAction(nodeSpec, validation.failureClass)
+          if (failureAction === 'human-review') {
+            nextNodeRun = PlanNodeRunSchema.parse(
+              await tx
+                .update(ensureRecordId(nextNodeRun.id, TABLES.PLAN_NODE_RUN))
+                .content(
+                  toNodeRunData(nextNodeRun, {
+                    status: 'awaiting-human',
+                    retryCount: nextNodeRun.retryCount + 1,
+                    failureClass: validation.failureClass,
+                    blockedReason: validation.blocking[0]?.message ?? null,
+                    startedAt: nextNodeRun.startedAt ?? new Date(),
+                  }),
+                )
+                .output('after'),
+            )
 
-          const failedRun = await this.replaceRun(tx, run, {
-            status: 'awaiting-human',
-            currentNodeId: nextNodeRun.nodeId,
-            waitingNodeId: nextNodeRun.nodeId,
-            readyNodeIds: [],
-            failureCount: run.failureCount + 1,
-          })
+            const approval = await planApprovalService.createPendingApproval({
+              tx,
+              runId: run.id,
+              nodeRunId: nextNodeRun.id,
+              nodeId: nextNodeRun.nodeId,
+              requestedBy: params.emittedBy,
+              presented: {
+                nodeId: nodeSpec.nodeId,
+                label: nodeSpec.label,
+                objective: nodeSpec.objective,
+                instructions: nodeSpec.instructions,
+                validationIssues: validation.blocking,
+              },
+            })
 
-          await this.emitEvent({
-            tx,
-            run: failedRun,
-            spec,
-            nodeId: nextNodeRun.nodeId,
-            attemptId: finalizedAttempt.id,
-            approvalId: approval.id,
-            eventType: 'approval-requested',
-            fromStatus: run.status,
-            toStatus: failedRun.status,
-            message: `Node "${nodeSpec.label}" requires human review before continuing.`,
-            detail: { issues: validation.blocking.map((issue) => issue.code) },
-            emittedBy: params.emittedBy,
-            capturedEvents: emittedEvents,
-          })
+            const failedRun = await this.replaceRun(tx, run, {
+              status: 'awaiting-human',
+              currentNodeId: nextNodeRun.nodeId,
+              waitingNodeId: nextNodeRun.nodeId,
+              readyNodeIds: [],
+              failureCount: run.failureCount + 1,
+            })
 
-          const checkpoint = await this.saveCheckpoint({
-            tx,
-            run: failedRun,
-            spec,
-            nodeRuns: withUpdatedNodeRuns.map((candidate) =>
-              candidate.nodeId === nextNodeRun.nodeId ? nextNodeRun : candidate,
-            ),
-            artifacts: nextArtifacts,
-            sequence: (latestCheckpoint?.sequence ?? 0) + 1,
-            reason: 'node-result-human-review',
-            capturedEvents: emittedEvents,
-          })
+            await this.emitEvent({
+              tx,
+              run: failedRun,
+              spec,
+              nodeId: nextNodeRun.nodeId,
+              attemptId: finalizedAttempt.id,
+              approvalId: approval.id,
+              eventType: 'approval-requested',
+              fromStatus: run.status,
+              toStatus: failedRun.status,
+              message: `Node "${nodeSpec.label}" requires human review before continuing.`,
+              detail: { issues: validation.blocking.map((issue) => issue.code) },
+              emittedBy: params.emittedBy,
+              capturedEvents: emittedEvents,
+            })
 
-          await this.attachCheckpoint(tx, failedRun, checkpoint)
-          return
-        }
+            const checkpoint = await this.saveCheckpoint({
+              tx,
+              run: failedRun,
+              spec,
+              nodeRuns: withUpdatedNodeRuns.map((candidate) =>
+                candidate.nodeId === nextNodeRun.nodeId ? nextNodeRun : candidate,
+              ),
+              artifacts: nextArtifacts,
+              sequence: (latestCheckpoint?.sequence ?? 0) + 1,
+              reason: 'node-result-human-review',
+              capturedEvents: emittedEvents,
+            })
+
+            await this.attachCheckpoint(tx, failedRun, checkpoint)
+            return
+          }
+
+          if (failureAction === 'replan') {
+            nextNodeRun = PlanNodeRunSchema.parse(
+              await tx
+                .update(ensureRecordId(nextNodeRun.id, TABLES.PLAN_NODE_RUN))
+                .content(
+                  toNodeRunData(nextNodeRun, {
+                    status: 'blocked',
+                    retryCount: nextNodeRun.retryCount + 1,
+                    failureClass: validation.failureClass,
+                    blockedReason: validation.blocking[0]?.message ?? null,
+                  }),
+                )
+                .output('after'),
+            )
+
+            const blockedRun = await this.replaceRun(tx, run, {
+              status: 'blocked',
+              currentNodeId: nextNodeRun.nodeId,
+              waitingNodeId: null,
+              readyNodeIds: [],
+              failureCount: run.failureCount + 1,
+            })
+
+            await this.emitEvent({
+              tx,
+              run: blockedRun,
+              spec,
+              nodeId: nextNodeRun.nodeId,
+              attemptId: finalizedAttempt.id,
+              eventType: 'node-blocked',
+              fromStatus: nodeRun.status,
+              toStatus: nextNodeRun.status,
+              message: `Node "${nodeSpec.label}" failed validation and requires replanning.`,
+              detail: { failureClass: validation.failureClass, issues: validation.blocking.map((issue) => issue.code) },
+              emittedBy: params.emittedBy,
+              capturedEvents: emittedEvents,
+            })
+
+            const checkpoint = await this.saveCheckpoint({
+              tx,
+              run: blockedRun,
+              spec,
+              nodeRuns: withUpdatedNodeRuns.map((candidate) =>
+                candidate.nodeId === nextNodeRun.nodeId ? nextNodeRun : candidate,
+              ),
+              artifacts: nextArtifacts,
+              sequence: (latestCheckpoint?.sequence ?? 0) + 1,
+              reason: 'node-result-replan',
+              capturedEvents: emittedEvents,
+            })
+
+            await this.attachCheckpoint(tx, blockedRun, checkpoint)
+            return
+          }
 
-        if (failureAction === 'replan') {
           nextNodeRun = PlanNodeRunSchema.parse(
             await tx
               .update(ensureRecordId(nextNodeRun.id, TABLES.PLAN_NODE_RUN))
               .content(
                 toNodeRunData(nextNodeRun, {
-                  status: 'blocked',
+                  status: 'failed',
                   retryCount: nextNodeRun.retryCount + 1,
                   failureClass: validation.failureClass,
                   blockedReason: validation.blocking[0]?.message ?? null,
+                  completedAt: new Date(),
                 }),
               )
               .output('after'),
           )
 
-          const blockedRun = await this.replaceRun(tx, run, {
-            status: 'blocked',
-            currentNodeId: nextNodeRun.nodeId,
+          const failedRun = await this.replaceRun(tx, run, {
+            status: 'failed',
+            currentNodeId: null,
             waitingNodeId: null,
             readyNodeIds: [],
             failureCount: run.failureCount + 1,
+            completedAt: new Date(),
           })
 
           await this.emitEvent({
             tx,
-            run: blockedRun,
+            run: failedRun,
             spec,
             nodeId: nextNodeRun.nodeId,
             attemptId: finalizedAttempt.id,
-            eventType: 'node-blocked',
+            eventType: 'node-failed',
             fromStatus: nodeRun.status,
             toStatus: nextNodeRun.status,
-            message: `Node "${nodeSpec.label}" failed validation and requires replanning.`,
+            message: `Node "${nodeSpec.label}" failed validation and the run has been aborted.`,
             detail: { failureClass: validation.failureClass, issues: validation.blocking.map((issue) => issue.code) },
             emittedBy: params.emittedBy,
             capturedEvents: emittedEvents,
@@ -563,18 +675,18 @@ class PlanExecutorService {
 
           const checkpoint = await this.saveCheckpoint({
             tx,
-            run: blockedRun,
+            run: failedRun,
             spec,
             nodeRuns: withUpdatedNodeRuns.map((candidate) =>
               candidate.nodeId === nextNodeRun.nodeId ? nextNodeRun : candidate,
             ),
             artifacts: nextArtifacts,
             sequence: (latestCheckpoint?.sequence ?? 0) + 1,
-            reason: 'node-result-replan',
+            reason: 'node-result-failed',
             capturedEvents: emittedEvents,
           })
 
-          await this.attachCheckpoint(tx, blockedRun, checkpoint)
+          await this.attachCheckpoint(tx, failedRun, checkpoint)
           return
         }
 
@@ -583,118 +695,70 @@ class PlanExecutorService {
             .update(ensureRecordId(nextNodeRun.id, TABLES.PLAN_NODE_RUN))
             .content(
               toNodeRunData(nextNodeRun, {
-                status: 'failed',
-                retryCount: nextNodeRun.retryCount + 1,
-                failureClass: validation.failureClass,
-                blockedReason: validation.blocking[0]?.message ?? null,
+                status: validation.warnings.length > 0 ? 'partial' : 'completed',
+                latestAttemptId: finalizedAttempt.id,
+                latestStructuredOutput: params.result.structuredOutput ?? null,
+                latestNotes: params.result.notes,
+                blockedReason: null,
+                failureClass: null,
                 completedAt: new Date(),
               }),
             )
             .output('after'),
         )
 
-        const failedRun = await this.replaceRun(tx, run, {
-          status: 'failed',
-          currentNodeId: null,
-          waitingNodeId: null,
-          readyNodeIds: [],
-          failureCount: run.failureCount + 1,
-          completedAt: new Date(),
-        })
-
         await this.emitEvent({
           tx,
-          run: failedRun,
+          run,
           spec,
           nodeId: nextNodeRun.nodeId,
           attemptId: finalizedAttempt.id,
-          eventType: 'node-failed',
+          eventType: validation.warnings.length > 0 ? 'node-partial' : 'node-completed',
           fromStatus: nodeRun.status,
           toStatus: nextNodeRun.status,
-          message: `Node "${nodeSpec.label}" failed validation and the run has been aborted.`,
-          detail: { failureClass: validation.failureClass, issues: validation.blocking.map((issue) => issue.code) },
+          message:
+            validation.warnings.length > 0
+              ? `Node "${nodeSpec.label}" completed with warnings.`
+              : `Node "${nodeSpec.label}" completed successfully.`,
+          detail: { warningCount: validation.warnings.length },
           emittedBy: params.emittedBy,
           capturedEvents: emittedEvents,
         })
 
-        const checkpoint = await this.saveCheckpoint({
+        const synced = await this.syncRunGraph({
           tx,
-          run: failedRun,
+          run,
           spec,
+          nodeSpecs,
           nodeRuns: withUpdatedNodeRuns.map((candidate) =>
             candidate.nodeId === nextNodeRun.nodeId ? nextNodeRun : candidate,
           ),
           artifacts: nextArtifacts,
-          sequence: (latestCheckpoint?.sequence ?? 0) + 1,
-          reason: 'node-result-failed',
+          emittedBy: params.emittedBy,
           capturedEvents: emittedEvents,
         })
 
-        await this.attachCheckpoint(tx, failedRun, checkpoint)
-        return
-      }
-
-      nextNodeRun = PlanNodeRunSchema.parse(
-        await tx
-          .update(ensureRecordId(nextNodeRun.id, TABLES.PLAN_NODE_RUN))
-          .content(
-            toNodeRunData(nextNodeRun, {
-              status: validation.warnings.length > 0 ? 'partial' : 'completed',
-              latestAttemptId: finalizedAttempt.id,
-              latestStructuredOutput: params.result.structuredOutput ?? null,
-              latestNotes: params.result.notes,
-              blockedReason: null,
-              failureClass: null,
-              completedAt: new Date(),
-            }),
-          )
-          .output('after'),
-      )
+        const checkpoint = await this.saveCheckpoint({
+          tx,
+          run: synced.run,
+          spec,
+          nodeRuns: synced.nodeRuns,
+          artifacts: synced.artifacts,
+          sequence: (latestCheckpoint?.sequence ?? 0) + 1,
+          reason: 'node-result-complete',
+          capturedEvents: emittedEvents,
+        })
 
-      await this.emitEvent({
-        tx,
-        run,
-        spec,
-        nodeId: nextNodeRun.nodeId,
-        attemptId: finalizedAttempt.id,
-        eventType: validation.warnings.length > 0 ? 'node-partial' : 'node-completed',
-        fromStatus: nodeRun.status,
-        toStatus: nextNodeRun.status,
-        message:
-          validation.warnings.length > 0
-            ? `Node "${nodeSpec.label}" completed with warnings.`
-            : `Node "${nodeSpec.label}" completed successfully.`,
-        detail: { warningCount: validation.warnings.length },
-        emittedBy: params.emittedBy,
-        capturedEvents: emittedEvents,
+        await this.attachCheckpoint(tx, synced.run, checkpoint)
       })
-
-      const synced = await this.syncRunGraph({
-        tx,
-        run,
-        spec,
-        nodeSpecs,
-        nodeRuns: withUpdatedNodeRuns.map((candidate) =>
-          candidate.nodeId === nextNodeRun.nodeId ? nextNodeRun : candidate,
+    } catch (error) {
+      await Promise.allSettled(
+        publishedArtifactStorageKeys.map((storageKey) =>
+          generatedDocumentStorageService.deleteTextArtifact(storageKey),
         ),
-        artifacts: nextArtifacts,
-        emittedBy: params.emittedBy,
-        capturedEvents: emittedEvents,
-      })
-
-      const checkpoint = await this.saveCheckpoint({
-        tx,
-        run: synced.run,
-        spec,
-        nodeRuns: synced.nodeRuns,
-        artifacts: synced.artifacts,
-        sequence: (latestCheckpoint?.sequence ?? 0) + 1,
-        reason: 'node-result-complete',
-        capturedEvents: emittedEvents,
-      })
-
-      await this.attachCheckpoint(tx, synced.run, checkpoint)
-    })
+      )
+      throw error
+    }
 
     const orgId = recordIdToString(run.organizationId, TABLES.ORGANIZATION)
     const runIdStr = recordIdToString(run.id, TABLES.PLAN_RUN)
@@ -1287,7 +1351,9 @@ class PlanExecutorService {
           eventType: 'run-status-changed',
           fromStatus: params.run.status,
           toStatus: currentRun.status,
-          message: `Run blocked: unresolved cross-plan dependencies (${unresolved.map((d) => d.sourcePlanTitle).join(', ')}).`,
+          message: `Run blocked: unresolved cross-plan dependencies (${unresolved
+            .map((d) => d.sourcePlanSpecId)
+            .join(', ')}).`,
           emittedBy: params.emittedBy,
           capturedEvents: params.capturedEvents,
         })