@osolmaz/pi-workflows 0.1.0 → 0.2.0

package/src/viewer/session-reducer.ts

@@ -0,0 +1,347 @@
+import type { WorkflowSessionEntryRecord, WorkflowSessionEventRecord } from "../workflows/types.js";
+
+export type TemporalContentBlock = {
+  contentIndex: number;
+  kind: "text" | "thinking" | "toolCall";
+  text: string;
+  value?: unknown;
+};
+
+export type TemporalMessage = {
+  messageId: string;
+  role: string;
+  status: "streaming" | "finished" | "error" | "settled" | "unsettled";
+  entryId?: string;
+  blocks: TemporalContentBlock[];
+};
+
+export type TemporalTool = {
+  toolCallId: string;
+  messageId: string;
+  toolName: string;
+  status: "running" | "finished" | "failed";
+  updates: number;
+  args?: unknown;
+  result?: unknown;
+};
+
+export type TemporalSessionState = {
+  throughSeq: number;
+  messages: TemporalMessage[];
+  tools: TemporalTool[];
+  settledEntryIds: string[];
+  diagnostics: string[];
+};
+
+type MutableMessage = Omit<TemporalMessage, "blocks"> & {
+  blocks: Map<number, TemporalContentBlock>;
+};
+
+function payloadString(payload: Record<string, unknown>, key: string): string | undefined {
+  const value = payload[key];
+  return typeof value === "string" ? value : undefined;
+}
+
+function payloadIndex(payload: Record<string, unknown>): number | undefined {
+  const value = payload.contentIndex;
+  return Number.isSafeInteger(value) && (value as number) >= 0 ? (value as number) : undefined;
+}
+
+function ensureBlock(
+  message: MutableMessage,
+  contentIndex: number,
+  kind: TemporalContentBlock["kind"],
+): TemporalContentBlock {
+  const existing = message.blocks.get(contentIndex);
+  if (existing) {
+    return existing;
+  }
+  const block: TemporalContentBlock = { contentIndex, kind, text: "" };
+  message.blocks.set(contentIndex, block);
+  return block;
+}
+
+function entryIds(entries: WorkflowSessionEntryRecord[]): Set<string> {
+  return new Set(
+    entries.flatMap((record) => {
+      const id = record.entry.id;
+      return typeof id === "string" ? [id] : [];
+    }),
+  );
+}
+
+function foldSessionEvents(
+  entries: WorkflowSessionEntryRecord[],
+  events: WorkflowSessionEventRecord[],
+  throughSeq: number,
+  initial?: TemporalSessionState,
+): TemporalSessionState {
+  const messages = new Map<string, MutableMessage>();
+  const messageOrder: string[] = [];
+  for (const message of initial?.messages ?? []) {
+    messages.set(message.messageId, {
+      ...message,
+      blocks: new Map(message.blocks.map((block) => [block.contentIndex, { ...block }] as const)),
+    });
+    messageOrder.push(message.messageId);
+  }
+  const tools = new Map<string, TemporalTool>();
+  const toolOrder: string[] = [];
+  for (const tool of initial?.tools ?? []) {
+    tools.set(tool.toolCallId, { ...tool });
+    toolOrder.push(tool.toolCallId);
+  }
+  const settledEntryIds: string[] = [...(initial?.settledEntryIds ?? [])];
+  const knownEntries = entryIds(entries);
+  const diagnostics: string[] = [...(initial?.diagnostics ?? [])];
+  let expectedSeq = (initial?.throughSeq ?? 0) + 1;
+  let lastSeq = initial?.throughSeq ?? 0;
+
+  for (const event of events) {
+    if (event.seq <= lastSeq) {
+      continue;
+    }
+    if (event.seq > throughSeq) {
+      break;
+    }
+    if (event.seq !== expectedSeq) {
+      diagnostics.push(`session event sequence gap at ${expectedSeq}`);
+      expectedSeq = event.seq;
+    }
+    expectedSeq += 1;
+    lastSeq = event.seq;
+
+    switch (event.type) {
+      case "message_started": {
+        if (!event.messageId) {
+          diagnostics.push(`message_started ${event.seq} has no messageId`);
+          break;
+        }
+        if (!messages.has(event.messageId)) {
+          messages.set(event.messageId, {
+            messageId: event.messageId,
+            role: payloadString(event.payload, "role") ?? "unknown",
+            status: "streaming",
+            blocks: new Map(),
+          });
+          messageOrder.push(event.messageId);
+        }
+        break;
+      }
+      case "assistant_event": {
+        if (!event.messageId) {
+          diagnostics.push(`assistant_event ${event.seq} has no messageId`);
+          break;
+        }
+        const message = messages.get(event.messageId);
+        if (!message) {
+          diagnostics.push(`assistant_event ${event.seq} precedes message_started`);
+          break;
+        }
+        const assistantType = payloadString(event.payload, "type");
+        const contentIndex = payloadIndex(event.payload);
+        if (
+          contentIndex !== undefined &&
+          (assistantType === "text_start" ||
+            assistantType === "thinking_start" ||
+            assistantType === "toolcall_start")
+        ) {
+          ensureBlock(
+            message,
+            contentIndex,
+            assistantType === "text_start"
+              ? "text"
+              : assistantType === "thinking_start"
+                ? "thinking"
+                : "toolCall",
+          );
+        } else if (
+          contentIndex !== undefined &&
+          (assistantType === "text_delta" ||
+            assistantType === "thinking_delta" ||
+            assistantType === "toolcall_delta")
+        ) {
+          const block = ensureBlock(
+            message,
+            contentIndex,
+            assistantType === "text_delta"
+              ? "text"
+              : assistantType === "thinking_delta"
+                ? "thinking"
+                : "toolCall",
+          );
+          block.text += payloadString(event.payload, "delta") ?? "";
+        } else if (
+          contentIndex !== undefined &&
+          (assistantType === "text_end" || assistantType === "thinking_end")
+        ) {
+          const block = ensureBlock(
+            message,
+            contentIndex,
+            assistantType === "text_end" ? "text" : "thinking",
+          );
+          const content = payloadString(event.payload, "content") ?? "";
+          if (block.text !== content) {
+            diagnostics.push(`${assistantType} mismatch for ${event.messageId}:${contentIndex}`);
+            block.text = content;
+          }
+        } else if (contentIndex !== undefined && assistantType === "toolcall_end") {
+          const block = ensureBlock(message, contentIndex, "toolCall");
+          block.value = event.payload.toolCall;
+        } else if (assistantType === "done") {
+          message.status = "finished";
+        } else if (assistantType === "error") {
+          message.status = "error";
+        }
+        break;
+      }
+      case "message_finished": {
+        if (!event.messageId) {
+          diagnostics.push(`message_finished ${event.seq} has no messageId`);
+          break;
+        }
+        const message = messages.get(event.messageId);
+        if (!message) {
+          diagnostics.push(`message_finished ${event.seq} precedes message_started`);
+          break;
+        }
+        const settled = event.payload.settled === true;
+        const entryId = payloadString(event.payload, "entryId");
+        if (settled && entryId) {
+          message.status = "settled";
+          message.entryId = entryId;
+          settledEntryIds.push(entryId);
+          if (!knownEntries.has(entryId)) {
+            diagnostics.push(`settled entry ${entryId} is missing`);
+          }
+        } else {
+          message.status = "unsettled";
+        }
+        break;
+      }
+      case "tool_execution_started": {
+        if (!event.toolCallId || !event.messageId) {
+          diagnostics.push(`tool_execution_started ${event.seq} is uncorrelated`);
+          break;
+        }
+        const tool: TemporalTool = {
+          toolCallId: event.toolCallId,
+          messageId: event.messageId,
+          toolName: payloadString(event.payload, "toolName") ?? "tool",
+          status: "running",
+          updates: 0,
+          ...(event.payload.args === undefined ? {} : { args: event.payload.args }),
+        };
+        tools.set(event.toolCallId, tool);
+        toolOrder.push(event.toolCallId);
+        break;
+      }
+      case "tool_execution_updated": {
+        const tool = event.toolCallId ? tools.get(event.toolCallId) : undefined;
+        if (tool) {
+          tool.updates += 1;
+        } else {
+          diagnostics.push(`tool_execution_updated ${event.seq} precedes start`);
+        }
+        break;
+      }
+      case "tool_execution_finished": {
+        const tool = event.toolCallId ? tools.get(event.toolCallId) : undefined;
+        if (!tool) {
+          diagnostics.push(`tool_execution_finished ${event.seq} precedes start`);
+          break;
+        }
+        tool.status = event.payload.isError === true ? "failed" : "finished";
+        if (event.payload.result !== undefined) {
+          tool.result = event.payload.result;
+        }
+        break;
+      }
+      case "turn_started":
+      case "turn_finished":
+        break;
+      default:
+        break;
+    }
+  }
+
+  return {
+    throughSeq: lastSeq,
+    messages: messageOrder.map((messageId) => {
+      const message = messages.get(messageId)!;
+      return {
+        messageId: message.messageId,
+        role: message.role,
+        status: message.status,
+        ...(message.entryId === undefined ? {} : { entryId: message.entryId }),
+        blocks: [...message.blocks.values()].toSorted(
+          (left, right) => left.contentIndex - right.contentIndex,
+        ),
+      };
+    }),
+    tools: toolOrder.map((toolCallId) => tools.get(toolCallId)!),
+    settledEntryIds,
+    diagnostics,
+  };
+}
+
+/** Fold the durable semantic journal through one sequence position. */
+export function reduceSessionEvents(
+  entries: WorkflowSessionEntryRecord[],
+  events: WorkflowSessionEventRecord[],
+  throughSeq: number = Number.MAX_SAFE_INTEGER,
+): TemporalSessionState {
+  return foldSessionEvents(entries, events, throughSeq);
+}
+
+/**
+ * In-memory seek index. Checkpoints are viewer-only cache state and are never
+ * persisted into a run bundle.
+ */
+export class SessionReplayIndex {
+  private readonly entries: WorkflowSessionEntryRecord[];
+  private readonly events: WorkflowSessionEventRecord[];
+  private readonly checkpoints: Array<{ seq: number; state: TemporalSessionState }> = [];
+  private readonly timestamps: Array<{ at: number; seq: number }>;
+
+  constructor(
+    entries: WorkflowSessionEntryRecord[],
+    events: WorkflowSessionEventRecord[],
+    checkpointInterval = 256,
+  ) {
+    this.entries = entries;
+    this.events = events;
+    let lastTimestamp = Number.NEGATIVE_INFINITY;
+    this.timestamps = events.map((event) => {
+      const parsed = Date.parse(event.at);
+      lastTimestamp = Math.max(lastTimestamp, Number.isFinite(parsed) ? parsed : lastTimestamp);
+      return { at: lastTimestamp, seq: event.seq };
+    });
+    let state = foldSessionEvents(entries, events, 0);
+    this.checkpoints.push({ seq: 0, state });
+    for (let end = checkpointInterval - 1; end < events.length; end += checkpointInterval) {
+      const seq = events[end]?.seq ?? state.throughSeq;
+      state = foldSessionEvents(entries, events, seq, state);
+      this.checkpoints.push({ seq, state });
+    }
+  }
+
+  stateAtSeq(throughSeq: number): TemporalSessionState {
+    const checkpoint = this.checkpoints.findLast(({ seq }) => seq <= throughSeq);
+    return foldSessionEvents(this.entries, this.events, throughSeq, checkpoint?.state);
+  }
+
+  seqAtOrBefore(timestampMs: number): number {
+    let low = 0;
+    let high = this.timestamps.length;
+    while (low < high) {
+      const middle = (low + high) >>> 1;
+      if ((this.timestamps[middle]?.at ?? Number.POSITIVE_INFINITY) <= timestampMs) {
+        low = middle + 1;
+      } else {
+        high = middle;
+      }
+    }
+    return low === 0 ? 0 : (this.timestamps[low - 1]?.seq ?? 0);
+  }
+}

package/src/workflows/artifacts.ts

@@ -0,0 +1,188 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import type { ArtifactRef, ArtifactValue } from "./types.js";
+
+/**
+ * Value externalization for run bundles (see docs/run-bundles.md): string
+ * leaves larger than the threshold are written once, content-addressed, under
+ * `artifacts/` and replaced by `{ "$artifact": ref }`. Because artifacts are
+ * immutable and deduplicated by hash, the same output appearing in `outputs`,
+ * `results`, `steps`, and the trace costs one file plus small references.
+ */
+
+export const ARTIFACT_THRESHOLD_BYTES = 4096;
+export const ARTIFACTS_DIR = "artifacts";
+
+const ARTIFACT_KEY = "$artifact";
+const ESCAPED_KEY = "$escaped";
+
+export function isArtifactValue(value: unknown): value is ArtifactValue {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    !Array.isArray(value) &&
+    Object.keys(value).length === 1 &&
+    ARTIFACT_KEY in value
+  );
+}
+
+function isEscapedValue(value: unknown): value is { $escaped: Record<string, unknown> } {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    !Array.isArray(value) &&
+    Object.keys(value).length === 1 &&
+    ESCAPED_KEY in value
+  );
+}
+
+/** True for a single-key object that would be misread as a sentinel. */
+function needsEscape(value: Record<string, unknown>): boolean {
+  const keys = Object.keys(value);
+  return keys.length === 1 && (keys[0] === ARTIFACT_KEY || keys[0] === ESCAPED_KEY);
+}
+
+/**
+ * Writes externalized string leaves for one run bundle. Instances serialize
+ * their writes and deduplicate by content hash, so encoding the same large
+ * string in several value positions touches the filesystem once.
+ */
+export class ArtifactWriter {
+  private readonly runDir: string;
+  private readonly written = new Set<string>();
+  private chain: Promise<unknown> = Promise.resolve();
+  private dirCreated = false;
+
+  constructor(runDir: string) {
+    this.runDir = runDir;
+  }
+
+  /** True once any artifact exists for this run. */
+  get hasArtifacts(): boolean {
+    return this.written.size > 0;
+  }
+
+  async externalize(text: string): Promise<ArtifactValue> {
+    const bytes = Buffer.from(text, "utf8");
+    const sha256 = createHash("sha256").update(bytes).digest("hex");
+    const relativePath = `${ARTIFACTS_DIR}/sha256-${sha256}.txt`;
+    const task = this.chain.then(async () => {
+      if (this.written.has(sha256)) {
+        return;
+      }
+      if (!this.dirCreated) {
+        await fs.mkdir(path.join(this.runDir, ARTIFACTS_DIR), { recursive: true, mode: 0o700 });
+        this.dirCreated = true;
+      }
+      const filePath = path.join(this.runDir, relativePath);
+      // Content-addressed files are immutable; an existing file is complete
+      // unless a previous crash left a partial write, which the temp-rename
+      // pattern prevents.
+      const tempPath = `${filePath}.${process.pid}.tmp`;
+      await fs.writeFile(tempPath, bytes, { mode: 0o600 });
+      await fs.rename(tempPath, filePath);
+      this.written.add(sha256);
+    });
+    this.chain = task.catch(() => undefined);
+    await task;
+    return {
+      $artifact: {
+        path: relativePath,
+        mediaType: "text/plain",
+        bytes: bytes.byteLength,
+        sha256,
+      },
+    };
+  }
+}
+
+/**
+ * Encode a persisted value: externalize large string leaves and escape
+ * single-key `$artifact`/`$escaped` objects so the sentinel stays
+ * unambiguous. Returns the original value when nothing changed.
+ */
+export async function encodeValue(
+  value: unknown,
+  writer: ArtifactWriter,
+  thresholdBytes: number = ARTIFACT_THRESHOLD_BYTES,
+): Promise<unknown> {
+  if (typeof value === "string") {
+    if (Buffer.byteLength(value, "utf8") <= thresholdBytes) {
+      return value;
+    }
+    return await writer.externalize(value);
+  }
+  if (Array.isArray(value)) {
+    const encoded = await Promise.all(
+      value.map((item) => encodeValue(item, writer, thresholdBytes)),
+    );
+    return encoded.some((item, index) => item !== value[index]) ? encoded : value;
+  }
+  if (typeof value === "object" && value !== null) {
+    const record = value as Record<string, unknown>;
+    const entries = await Promise.all(
+      Object.entries(record).map(
+        async ([key, item]) => [key, await encodeValue(item, writer, thresholdBytes)] as const,
+      ),
+    );
+    const changed = entries.some(([key, item]) => item !== record[key]);
+    const encoded = changed ? Object.fromEntries(entries) : record;
+    return needsEscape(record) ? { [ESCAPED_KEY]: encoded } : encoded;
+  }
+  return value;
+}
+
+/**
+ * Walk a persisted value, replacing every `$artifact` sentinel via `resolve`
+ * and unwrapping `$escaped` objects. `resolve` may return the artifact
+ * contents or a placeholder; it receives the reference untouched.
+ */
+export function decodeValueWith(value: unknown, resolve: (ref: ArtifactRef) => unknown): unknown {
+  if (isArtifactValue(value)) {
+    return resolve(value.$artifact);
+  }
+  if (isEscapedValue(value)) {
+    // The unwrapped object is user data: process its children but do not
+    // re-test the object itself as a sentinel.
+    return decodeChildren(value.$escaped, resolve);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => decodeValueWith(item, resolve));
+  }
+  if (typeof value === "object" && value !== null) {
+    return decodeChildren(value as Record<string, unknown>, resolve);
+  }
+  return value;
+}
+
+function decodeChildren(
+  record: Record<string, unknown>,
+  resolve: (ref: ArtifactRef) => unknown,
+): Record<string, unknown> {
+  return Object.fromEntries(
+    Object.entries(record).map(([key, item]) => [key, decodeValueWith(item, resolve)]),
+  );
+}
+
+/** Resolve every artifact reference in `value` by reading the bundle files. */
+export async function resolveArtifacts(value: unknown, runDir: string): Promise<unknown> {
+  const refs: ArtifactRef[] = [];
+  decodeValueWith(value, (ref) => {
+    refs.push(ref);
+    return null;
+  });
+  const contents = new Map<string, string>();
+  for (const ref of refs) {
+    if (contents.has(ref.path)) {
+      continue;
+    }
+    const resolved = path.resolve(runDir, ref.path);
+    // A reference must never escape the bundle directory.
+    if (!resolved.startsWith(path.resolve(runDir) + path.sep)) {
+      throw new Error(`Artifact path escapes the bundle: ${ref.path}`);
+    }
+    contents.set(ref.path, await fs.readFile(resolved, "utf8"));
+  }
+  return decodeValueWith(value, (ref) => contents.get(ref.path) ?? null);
+}

package/src/workflows/engine.ts

@@ -4,12 +4,13 @@ import { CancelledError, errorMessage, isAbortLikeError, TimeoutError } from "./
 import { resolveNext, resolveNextForOutcome, validateWorkflowDefinition } from "./graph.js";
 import { extractJsonValue } from "./json.js";
 import { runShellAction, shellResultFromError } from "./shell.js";
-import { WorkflowRunStore, createRunId } from "./store.js";
+import { RUN_STATE_SCHEMA, WorkflowRunStore, createRunId } from "./store.js";
 import type {
   AgentNodeDefinition,
   AgentStepExecutor,
   ActionNodeDefinition,
   CheckpointNodeDefinition,
+  ConversationRange,
   ShellActionNodeDefinition,
   ShellActionResult,
   WorkflowActionReceipt,
@@ -35,6 +36,7 @@ type NodeExecution = {
   output: unknown;
   promptText: string | null;
   action?: WorkflowActionReceipt;
+  conversation?: ConversationRange;
 };
 
 /**
@@ -64,6 +66,8 @@ export class WorkflowEngine {
   private readonly defaultNodeTimeoutMs: number;
   private readonly maxSteps: number;
   private readonly onEvent?: WorkflowEngineOptions["onEvent"];
+  private readonly onRunStarted?: WorkflowEngineOptions["onRunStarted"];
+  private readonly onRunFinishing?: WorkflowEngineOptions["onRunFinishing"];
   private activeAbort: AbortController | null = null;
   private cancelled = false;
   private paused = false;
@@ -71,10 +75,12 @@ export class WorkflowEngine {
 
   constructor(options: WorkflowEngineOptions) {
     this.executor = options.executor;
-    this.store = new WorkflowRunStore(options.outputRoot);
+    this.store = options.store ?? new WorkflowRunStore(options.outputRoot);
     this.defaultNodeTimeoutMs = options.defaultNodeTimeoutMs ?? DEFAULT_NODE_TIMEOUT_MS;
     this.maxSteps = options.maxSteps ?? DEFAULT_MAX_STEPS;
     this.onEvent = options.onEvent;
+    this.onRunStarted = options.onRunStarted;
+    this.onRunFinishing = options.onRunFinishing;
   }
 
   get outputRoot(): string {
@@ -130,8 +136,13 @@ export class WorkflowEngine {
       payload: {
         workflowName: workflow.name,
         ...(state.runTitle ? { runTitle: state.runTitle } : {}),
+        input: state.input,
       },
     });
+    // Awaited so anything the hook writes (e.g. a session binding and its
+    // `session_bound` event) lands before node events and can never trail
+    // the terminal event of a fast run.
+    await this.onRunStarted?.(runDir, state);
 
     try {
       await this.executeGraph(workflow, state, runDir);
@@ -178,6 +189,8 @@ export class WorkflowEngine {
   ): Promise<WorkflowRunState> {
     const now = new Date().toISOString();
     return {
+      schema: RUN_STATE_SCHEMA,
+      traceSeq: 0,
       runId: createRunId(workflow.name),
       workflowName: workflow.name,
       ...(await this.resolveTitleBounded(workflow, input)),
@@ -218,6 +231,8 @@ export class WorkflowEngine {
 
       const attempt = await this.executeNode(workflow, state, runDir, currentNodeId, node);
       this.recordAttempt(state, attempt);
+      // The terminal node event carries the output, receipt, and conversation
+      // linkage so the trace alone is sufficient to reconstruct the run.
       await this.persist(runDir, state, {
         scope: "node",
         type: attempt.result.outcome === "ok" ? "node_finished" : "node_failed",
@@ -226,7 +241,12 @@ export class WorkflowEngine {
         payload: {
           outcome: attempt.result.outcome,
           durationMs: attempt.result.durationMs,
+          ...(attempt.result.outcome === "ok" ? { output: attempt.result.output ?? null } : {}),
           ...(attempt.result.error !== undefined ? { error: attempt.result.error } : {}),
+          ...(attempt.execution?.action !== undefined ? { action: attempt.execution.action } : {}),
+          ...(attempt.execution?.conversation !== undefined
+            ? { conversation: attempt.execution.conversation }
+            : {}),
         },
       });
 
@@ -316,16 +336,18 @@ export class WorkflowEngine {
       outcome: attempt.result.outcome,
       startedAt: attempt.result.startedAt,
       finishedAt: attempt.result.finishedAt,
-      promptText: attempt.execution?.promptText ?? null,
+      prompt: attempt.execution?.promptText ?? null,
       // `undefined` would drop the required field during JSON serialization.
       output: attempt.result.output ?? null,
       ...(attempt.result.error !== undefined ? { error: attempt.result.error } : {}),
       ...(attempt.execution?.action !== undefined ? { action: attempt.execution.action } : {}),
+      ...(attempt.execution?.conversation !== undefined
+        ? { conversation: attempt.execution.conversation }
+        : {}),
     };
     state.steps.push(step);
     delete state.currentNode;
     delete state.currentAttemptId;
-    delete state.currentNodeType;
     delete state.currentNodeStartedAt;
     delete state.statusDetail;
   }
@@ -341,7 +363,6 @@ export class WorkflowEngine {
     const startedAt = new Date().toISOString();
     state.currentNode = nodeId;
     state.currentAttemptId = attemptId;
-    state.currentNodeType = node.nodeType;
     state.currentNodeStartedAt = startedAt;
     if (node.statusDetail !== undefined) {
       state.statusDetail = node.statusDetail;
@@ -571,7 +592,11 @@ export class WorkflowEngine {
       },
       signal,
     );
-    return { output: submission.output, promptText: prompt };
+    return {
+      output: submission.output,
+      promptText: prompt,
+      ...(submission.conversation !== undefined ? { conversation: submission.conversation } : {}),
+    };
   }
 
   private async acceptSubmission(
@@ -629,6 +654,13 @@ export class WorkflowEngine {
     if (status === "failed" && state.status === "timed_out") {
       status = "timed_out";
     }
+    // Let observers (e.g. the session recorder) stop and drain before the
+    // terminal event exists, so the bundle is immutable from that point on.
+    try {
+      await this.onRunFinishing?.(runDir, state);
+    } catch {
+      // Finishing the run wins over observer failures.
+    }
     state.status = status;
     state.finishedAt = new Date().toISOString();
     if (fields.error !== undefined) {
@@ -642,7 +674,6 @@ export class WorkflowEngine {
     }
     delete state.currentNode;
     delete state.currentAttemptId;
-    delete state.currentNodeType;
     delete state.currentNodeStartedAt;
     await this.persist(runDir, state, {
       scope: "run",
@@ -651,6 +682,7 @@ export class WorkflowEngine {
         status,
         ...(fields.error !== undefined ? { error: fields.error } : {}),
         ...(fields.waitingOn !== undefined ? { waitingOn: fields.waitingOn } : {}),
+        ...(fields.finalOutput !== undefined ? { finalOutput: fields.finalOutput } : {}),
       },
     });
   }