@exaudeus/workrail 1.4.0 → 1.5.1

package/dist/v2/durable-core/constants.d.ts

@@ -5,6 +5,8 @@ export declare const MAX_DECISION_TRACE_ENTRIES = 25;
 export declare const MAX_DECISION_TRACE_ENTRY_SUMMARY_BYTES = 512;
 export declare const MAX_DECISION_TRACE_TOTAL_BYTES = 8192;
 export declare const MAX_OUTPUT_NOTES_MARKDOWN_BYTES = 4096;
+export declare const MAX_VALIDATION_ISSUE_ITEM_BYTES = 512;
+export declare const MAX_VALIDATION_SUGGESTION_ITEM_BYTES = 1024;
 export declare const MAX_VALIDATION_ISSUES_BYTES = 4096;
 export declare const MAX_VALIDATION_SUGGESTIONS_BYTES = 4096;
 export declare const MAX_CONTEXT_BYTES: number;
@@ -16,3 +18,61 @@ export declare const TRUNCATION_MARKER = "\n\n[TRUNCATED]";
 export declare const RECOVERY_BUDGET_BYTES = 12288;
 export declare const SHA256_DIGEST_PATTERN: RegExp;
 export declare const DELIMITER_SAFE_ID_PATTERN: RegExp;
+export declare const EVENT_KIND: {
+    readonly SESSION_CREATED: "session_created";
+    readonly OBSERVATION_RECORDED: "observation_recorded";
+    readonly RUN_STARTED: "run_started";
+    readonly NODE_CREATED: "node_created";
+    readonly EDGE_CREATED: "edge_created";
+    readonly ADVANCE_RECORDED: "advance_recorded";
+    readonly VALIDATION_PERFORMED: "validation_performed";
+    readonly NODE_OUTPUT_APPENDED: "node_output_appended";
+    readonly PREFERENCES_CHANGED: "preferences_changed";
+    readonly CAPABILITY_OBSERVED: "capability_observed";
+    readonly GAP_RECORDED: "gap_recorded";
+    readonly CONTEXT_SET: "context_set";
+    readonly DIVERGENCE_RECORDED: "divergence_recorded";
+    readonly DECISION_TRACE_APPENDED: "decision_trace_appended";
+};
+export type EventKindV1 = typeof EVENT_KIND[keyof typeof EVENT_KIND];
+export declare const OUTPUT_CHANNEL: {
+    readonly RECAP: "recap";
+    readonly ARTIFACT: "artifact";
+};
+export type OutputChannelV1 = typeof OUTPUT_CHANNEL[keyof typeof OUTPUT_CHANNEL];
+export declare const EDGE_KIND: {
+    readonly ACKED_STEP: "acked_step";
+    readonly CHECKPOINT: "checkpoint";
+};
+export type EdgeKindV1 = typeof EDGE_KIND[keyof typeof EDGE_KIND];
+export declare const ENGINE_STATE: {
+    readonly INIT: "init";
+    readonly RUNNING: "running";
+    readonly BLOCKED: "blocked";
+    readonly COMPLETE: "complete";
+};
+export type EngineStateKindV1 = typeof ENGINE_STATE[keyof typeof ENGINE_STATE];
+export declare const ADVANCE_OUTCOME: {
+    readonly ADVANCED: "advanced";
+    readonly BLOCKED: "blocked";
+};
+export declare const EDGE_CAUSE: {
+    readonly INTENTIONAL_FORK: "intentional_fork";
+    readonly NON_TIP_ADVANCE: "non_tip_advance";
+    readonly IDEMPOTENT_REPLAY: "idempotent_replay";
+    readonly CHECKPOINT_CREATED: "checkpoint_created";
+};
+export type EdgeCauseKindV1 = typeof EDGE_CAUSE[keyof typeof EDGE_CAUSE];
+export declare const MANIFEST_KIND: {
+    readonly SEGMENT_CLOSED: "segment_closed";
+    readonly SNAPSHOT_PINNED: "snapshot_pinned";
+};
+export declare const ADVANCE_INTENT: {
+    readonly ACK_PENDING: "ack_pending";
+};
+export declare const AUTONOMY_MODE: {
+    readonly GUIDED: "guided";
+    readonly FULL_AUTO_NEVER_STOP: "full_auto_never_stop";
+    readonly FULL_AUTO_STOP_ON_USER_DEPS: "full_auto_stop_on_user_deps";
+};
+export type AutonomyModeV1 = typeof AUTONOMY_MODE[keyof typeof AUTONOMY_MODE];

package/dist/v2/durable-core/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DELIMITER_SAFE_ID_PATTERN = exports.SHA256_DIGEST_PATTERN = exports.RECOVERY_BUDGET_BYTES = exports.TRUNCATION_MARKER = exports.DEFAULT_RETRY_AFTER_MS = exports.SESSION_LOCK_RETRY_AFTER_MS = exports.MAX_OBSERVATION_SHORT_STRING_LENGTH = exports.MAX_CONTEXT_DEPTH = exports.MAX_CONTEXT_BYTES = exports.MAX_VALIDATION_SUGGESTIONS_BYTES = exports.MAX_VALIDATION_ISSUES_BYTES = exports.MAX_OUTPUT_NOTES_MARKDOWN_BYTES = exports.MAX_DECISION_TRACE_TOTAL_BYTES = exports.MAX_DECISION_TRACE_ENTRY_SUMMARY_BYTES = exports.MAX_DECISION_TRACE_ENTRIES = exports.MAX_BLOCKER_SUGGESTED_FIX_BYTES = exports.MAX_BLOCKER_MESSAGE_BYTES = exports.MAX_BLOCKERS = void 0;
+exports.AUTONOMY_MODE = exports.ADVANCE_INTENT = exports.MANIFEST_KIND = exports.EDGE_CAUSE = exports.ADVANCE_OUTCOME = exports.ENGINE_STATE = exports.EDGE_KIND = exports.OUTPUT_CHANNEL = exports.EVENT_KIND = exports.DELIMITER_SAFE_ID_PATTERN = exports.SHA256_DIGEST_PATTERN = exports.RECOVERY_BUDGET_BYTES = exports.TRUNCATION_MARKER = exports.DEFAULT_RETRY_AFTER_MS = exports.SESSION_LOCK_RETRY_AFTER_MS = exports.MAX_OBSERVATION_SHORT_STRING_LENGTH = exports.MAX_CONTEXT_DEPTH = exports.MAX_CONTEXT_BYTES = exports.MAX_VALIDATION_SUGGESTIONS_BYTES = exports.MAX_VALIDATION_ISSUES_BYTES = exports.MAX_VALIDATION_SUGGESTION_ITEM_BYTES = exports.MAX_VALIDATION_ISSUE_ITEM_BYTES = exports.MAX_OUTPUT_NOTES_MARKDOWN_BYTES = exports.MAX_DECISION_TRACE_TOTAL_BYTES = exports.MAX_DECISION_TRACE_ENTRY_SUMMARY_BYTES = exports.MAX_DECISION_TRACE_ENTRIES = exports.MAX_BLOCKER_SUGGESTED_FIX_BYTES = exports.MAX_BLOCKER_MESSAGE_BYTES = exports.MAX_BLOCKERS = void 0;
 exports.MAX_BLOCKERS = 10;
 exports.MAX_BLOCKER_MESSAGE_BYTES = 512;
 exports.MAX_BLOCKER_SUGGESTED_FIX_BYTES = 1024;
@@ -8,6 +8,8 @@ exports.MAX_DECISION_TRACE_ENTRIES = 25;
 exports.MAX_DECISION_TRACE_ENTRY_SUMMARY_BYTES = 512;
 exports.MAX_DECISION_TRACE_TOTAL_BYTES = 8192;
 exports.MAX_OUTPUT_NOTES_MARKDOWN_BYTES = 4096;
+exports.MAX_VALIDATION_ISSUE_ITEM_BYTES = 512;
+exports.MAX_VALIDATION_SUGGESTION_ITEM_BYTES = 1024;
 exports.MAX_VALIDATION_ISSUES_BYTES = 4096;
 exports.MAX_VALIDATION_SUGGESTIONS_BYTES = 4096;
 exports.MAX_CONTEXT_BYTES = 256 * 1024;
@@ -19,3 +21,55 @@ exports.TRUNCATION_MARKER = '\n\n[TRUNCATED]';
 exports.RECOVERY_BUDGET_BYTES = 12288;
 exports.SHA256_DIGEST_PATTERN = /^sha256:[0-9a-f]{64}$/;
 exports.DELIMITER_SAFE_ID_PATTERN = /^[a-z0-9_-]+$/;
+exports.EVENT_KIND = {
+    SESSION_CREATED: 'session_created',
+    OBSERVATION_RECORDED: 'observation_recorded',
+    RUN_STARTED: 'run_started',
+    NODE_CREATED: 'node_created',
+    EDGE_CREATED: 'edge_created',
+    ADVANCE_RECORDED: 'advance_recorded',
+    VALIDATION_PERFORMED: 'validation_performed',
+    NODE_OUTPUT_APPENDED: 'node_output_appended',
+    PREFERENCES_CHANGED: 'preferences_changed',
+    CAPABILITY_OBSERVED: 'capability_observed',
+    GAP_RECORDED: 'gap_recorded',
+    CONTEXT_SET: 'context_set',
+    DIVERGENCE_RECORDED: 'divergence_recorded',
+    DECISION_TRACE_APPENDED: 'decision_trace_appended',
+};
+exports.OUTPUT_CHANNEL = {
+    RECAP: 'recap',
+    ARTIFACT: 'artifact',
+};
+exports.EDGE_KIND = {
+    ACKED_STEP: 'acked_step',
+    CHECKPOINT: 'checkpoint',
+};
+exports.ENGINE_STATE = {
+    INIT: 'init',
+    RUNNING: 'running',
+    BLOCKED: 'blocked',
+    COMPLETE: 'complete',
+};
+exports.ADVANCE_OUTCOME = {
+    ADVANCED: 'advanced',
+    BLOCKED: 'blocked',
+};
+exports.EDGE_CAUSE = {
+    INTENTIONAL_FORK: 'intentional_fork',
+    NON_TIP_ADVANCE: 'non_tip_advance',
+    IDEMPOTENT_REPLAY: 'idempotent_replay',
+    CHECKPOINT_CREATED: 'checkpoint_created',
+};
+exports.MANIFEST_KIND = {
+    SEGMENT_CLOSED: 'segment_closed',
+    SNAPSHOT_PINNED: 'snapshot_pinned',
+};
+exports.ADVANCE_INTENT = {
+    ACK_PENDING: 'ack_pending',
+};
+exports.AUTONOMY_MODE = {
+    GUIDED: 'guided',
+    FULL_AUTO_NEVER_STOP: 'full_auto_never_stop',
+    FULL_AUTO_STOP_ON_USER_DEPS: 'full_auto_stop_on_user_deps',
+};

package/dist/v2/durable-core/domain/ack-advance-append-plan.d.ts

@@ -2,31 +2,41 @@ import type { DomainEventV1 } from '../schemas/session/index.js';
 import { type OutputToAppend } from './outputs.js';
 import { type Result } from 'neverthrow';
 import type { SnapshotRef, WorkflowHash } from '../ids/index.js';
-type AdvanceOutcomeV1 = Extract<DomainEventV1, {
-    kind: 'advance_recorded';
-}>['data']['outcome'];
 type EventToAppendV1 = Omit<DomainEventV1, 'eventIndex' | 'sessionId'>;
-export declare function buildAckAdvanceAppendPlanV1(args: {
+export type AckAdvanceAppendPlanArgs = {
     readonly sessionId: string;
     readonly runId: string;
     readonly fromNodeId: string;
     readonly workflowHash: WorkflowHash;
     readonly attemptId: string;
     readonly nextEventIndex: number;
-    readonly outcome?: AdvanceOutcomeV1;
     readonly extraEventsToAppend?: readonly EventToAppendV1[];
-    readonly toNodeId?: string;
-    readonly toNodeKind?: 'step' | 'blocked_attempt';
-    readonly snapshotRef?: SnapshotRef;
-    readonly causeKind?: 'intentional_fork' | 'non_tip_advance';
+} & ({
+    readonly outcome: {
+        kind: 'blocked';
+        blockers: import('./reason-model.js').BlockerReportV1;
+    };
+    readonly minted: {
+        readonly advanceRecordedEventId: string;
+    };
+} | {
+    readonly outcome: {
+        kind: 'advanced';
+        toNodeId: string;
+    };
+    readonly toNodeKind: 'step' | 'blocked_attempt';
+    readonly toNodeId: string;
+    readonly snapshotRef: SnapshotRef;
+    readonly causeKind: 'intentional_fork' | 'non_tip_advance';
     readonly minted: {
         readonly advanceRecordedEventId: string;
-        readonly nodeCreatedEventId?: string;
-        readonly edgeCreatedEventId?: string;
-        readonly outputEventIds?: readonly string[];
+        readonly nodeCreatedEventId: string;
+        readonly edgeCreatedEventId: string;
+        readonly outputEventIds: readonly string[];
     };
     readonly outputsToAppend?: readonly OutputToAppend[];
-}): Result<{
+});
+export declare function buildAckAdvanceAppendPlanV1(args: AckAdvanceAppendPlanArgs): Result<{
     readonly events: readonly DomainEventV1[];
     readonly snapshotPins: readonly {
         snapshotRef: SnapshotRef;

package/dist/v2/durable-core/domain/ack-advance-append-plan.js

@@ -3,157 +3,204 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildAckAdvanceAppendPlanV1 = buildAckAdvanceAppendPlanV1;
 const outputs_js_1 = require("./outputs.js");
 const neverthrow_1 = require("neverthrow");
-function buildAckAdvanceAppendPlanV1(args) {
-    const { sessionId, runId, fromNodeId, workflowHash, attemptId, nextEventIndex, minted, outputsToAppend, extraEventsToAppend, } = args;
-    const outcome = args.outcome ??
-        (args.toNodeId
-            ? { kind: 'advanced', toNodeId: args.toNodeId }
-            :
-                (() => {
-                    throw new Error('INVARIANT: buildAckAdvanceAppendPlanV1 requires toNodeId when outcome is omitted');
-                })());
-    const advanceDedupeKey = `advance_recorded:${sessionId}:${fromNodeId}:${attemptId}`;
-    const advanceRecorded = {
+const constants_js_1 = require("../constants.js");
+function buildAdvanceRecordedEvent(args) {
+    const advanceDedupeKey = `advance_recorded:${args.sessionId}:${args.fromNodeId}:${args.attemptId}`;
+    return {
         v: 1,
-        eventId: minted.advanceRecordedEventId,
-        eventIndex: nextEventIndex,
-        sessionId,
-        kind: 'advance_recorded',
+        eventId: args.eventId,
+        eventIndex: args.eventIndex,
+        sessionId: args.sessionId,
+        kind: constants_js_1.EVENT_KIND.ADVANCE_RECORDED,
         dedupeKey: advanceDedupeKey,
-        scope: { runId, nodeId: fromNodeId },
+        scope: { runId: args.runId, nodeId: args.fromNodeId },
+        data: {
+            attemptId: args.attemptId,
+            intent: constants_js_1.ADVANCE_INTENT.ACK_PENDING,
+            outcome: args.outcome,
+        },
+    };
+}
+function buildNodeCreatedEvent(args) {
+    return {
+        v: 1,
+        eventId: args.eventId,
+        eventIndex: args.eventIndex,
+        sessionId: args.sessionId,
+        kind: constants_js_1.EVENT_KIND.NODE_CREATED,
+        dedupeKey: `node_created:${args.sessionId}:${args.runId}:${args.toNodeId}`,
+        scope: { runId: args.runId, nodeId: args.toNodeId },
+        data: {
+            nodeKind: args.toNodeKind,
+            parentNodeId: args.fromNodeId,
+            workflowHash: args.workflowHash,
+            snapshotRef: args.snapshotRef,
+        },
+    };
+}
+function buildEdgeCreatedEvent(args) {
+    return {
+        v: 1,
+        eventId: args.eventId,
+        eventIndex: args.eventIndex,
+        sessionId: args.sessionId,
+        kind: constants_js_1.EVENT_KIND.EDGE_CREATED,
+        dedupeKey: `edge_created:${args.sessionId}:${args.runId}:${args.fromNodeId}->${args.toNodeId}:acked_step`,
+        scope: { runId: args.runId },
         data: {
-            attemptId,
-            intent: 'ack_pending',
-            outcome,
+            edgeKind: constants_js_1.EDGE_KIND.ACKED_STEP,
+            fromNodeId: args.fromNodeId,
+            toNodeId: args.toNodeId,
+            cause: { kind: args.causeKind, eventId: args.causeEventId },
         },
     };
+}
+function buildOutputEvents(args) {
+    const normalizedOutputs = (0, outputs_js_1.normalizeOutputsForAppend)(args.outputs);
+    if (args.outputEventIds.length !== normalizedOutputs.length) {
+        return (0, neverthrow_1.err)({
+            code: 'INVARIANT_VIOLATION',
+            message: 'outputEventIds length mismatch (caller must supply exactly one eventId per output event)',
+        });
+    }
+    const outputEvents = normalizedOutputs.map((o, idx) => {
+        const base = {
+            v: 1,
+            eventId: args.outputEventIds[idx],
+            eventIndex: args.startEventIndex + idx,
+            sessionId: args.sessionId,
+            kind: constants_js_1.EVENT_KIND.NODE_OUTPUT_APPENDED,
+            dedupeKey: `node_output_appended:${args.sessionId}:${o.outputId}`,
+            scope: { runId: args.runId, nodeId: args.fromNodeId },
+            data: {
+                outputId: o.outputId,
+                outputChannel: o.outputChannel,
+                payload: o.payload,
+            },
+        };
+        return o.supersedesOutputId
+            ? {
+                ...base,
+                data: { ...base.data, supersedesOutputId: o.supersedesOutputId },
+            }
+            : base;
+    });
+    return (0, neverthrow_1.ok)(outputEvents);
+}
+function processExtraEvents(extraEventsToAppend, sessionId, startEventIndex) {
     const extra = [];
     if (extraEventsToAppend && extraEventsToAppend.length > 0) {
         for (let i = 0; i < extraEventsToAppend.length; i++) {
             const raw = extraEventsToAppend[i];
             if ('eventIndex' in raw) {
-                return (0, neverthrow_1.err)({ code: 'INVARIANT_VIOLATION', message: 'extraEventsToAppend must not include eventIndex (assigned by append plan builder)' });
+                return (0, neverthrow_1.err)({
+                    code: 'INVARIANT_VIOLATION',
+                    message: 'extraEventsToAppend must not include eventIndex (assigned by append plan builder)'
+                });
             }
             if ('sessionId' in raw) {
-                return (0, neverthrow_1.err)({ code: 'INVARIANT_VIOLATION', message: 'extraEventsToAppend must not include sessionId (assigned by append plan builder)' });
+                return (0, neverthrow_1.err)({
+                    code: 'INVARIANT_VIOLATION',
+                    message: 'extraEventsToAppend must not include sessionId (assigned by append plan builder)'
+                });
             }
             extra.push({
                 ...extraEventsToAppend[i],
                 sessionId,
-                eventIndex: nextEventIndex + 1 + i,
+                eventIndex: startEventIndex + i,
             });
         }
     }
+    return (0, neverthrow_1.ok)(extra);
+}
+function buildAckAdvanceAppendPlanV1(args) {
+    const { sessionId, runId, fromNodeId, workflowHash, attemptId, nextEventIndex, minted, extraEventsToAppend, outcome, } = args;
+    const advanceRecorded = buildAdvanceRecordedEvent({
+        sessionId,
+        runId,
+        fromNodeId,
+        attemptId,
+        eventIndex: nextEventIndex,
+        eventId: minted.advanceRecordedEventId,
+        outcome,
+    });
+    const extraResult = processExtraEvents(extraEventsToAppend, sessionId, nextEventIndex + 1);
+    if (extraResult.isErr()) {
+        return (0, neverthrow_1.err)(extraResult.error);
+    }
+    const extra = extraResult.value;
     const nextIndexAfterExtra = nextEventIndex + 1 + extra.length;
     if (outcome.kind === 'blocked') {
-        if (typeof console !== 'undefined' && console.warn) {
-            console.warn('[DEPRECATED] Creating advance_recorded with blocked outcome. ' +
-                'Use blocked_attempt nodes instead (see ADR 008). ' +
-                'This path will be removed in 2 releases. ' +
-                'Set USE_BLOCKED_NODES=true to use the new model.');
-        }
-        if (outputsToAppend && outputsToAppend.length > 0) {
-            return (0, neverthrow_1.err)({
-                code: 'INVARIANT_VIOLATION',
-                message: 'blocked outcome cannot include outputsToAppend (no node advancement occurs)',
-            });
-        }
         return (0, neverthrow_1.ok)({
             events: [advanceRecorded, ...extra],
             snapshotPins: [],
         });
     }
-    if (!args.toNodeId || !args.snapshotRef || !args.causeKind) {
-        return (0, neverthrow_1.err)({
-            code: 'INVARIANT_VIOLATION',
-            message: 'advanced outcome requires toNodeId + snapshotRef + causeKind',
-        });
+    if (outcome.kind !== 'advanced') {
+        const _exhaustive = outcome;
+        return (0, neverthrow_1.err)({ code: 'INVARIANT_VIOLATION', message: `Unknown outcome kind` });
     }
-    if (!minted.nodeCreatedEventId || !minted.edgeCreatedEventId || !minted.outputEventIds) {
-        return (0, neverthrow_1.err)({
-            code: 'INVARIANT_VIOLATION',
-            message: 'advanced outcome requires minted.nodeCreatedEventId + minted.edgeCreatedEventId + minted.outputEventIds',
-        });
+    if (!('toNodeId' in args) || !('snapshotRef' in args) || !('causeKind' in args) || !('toNodeKind' in args) || !('minted' in args) || !('nodeCreatedEventId' in args.minted)) {
+        return (0, neverthrow_1.err)({ code: 'INVARIANT_VIOLATION', message: 'Advanced outcome requires toNodeId, snapshotRef, causeKind, toNodeKind, and minted event IDs' });
     }
-    const toNodeId = args.toNodeId;
-    const snapshotRef = args.snapshotRef;
-    const causeKind = args.causeKind;
-    const toNodeKind = args.toNodeKind ?? 'step';
-    const nodeCreatedEventIndex = nextIndexAfterExtra;
-    const edgeCreatedEventIndex = nextIndexAfterExtra + 1;
+    const advancedArgs = args;
+    const toNodeId = advancedArgs.toNodeId;
+    const snapshotRef = advancedArgs.snapshotRef;
+    const causeKind = advancedArgs.causeKind;
+    const toNodeKind = advancedArgs.toNodeKind;
+    const outputsToAppend = advancedArgs.outputsToAppend;
+    const advancedMinted = advancedArgs.minted;
     if (toNodeKind !== 'step' && toNodeKind !== 'blocked_attempt') {
         return (0, neverthrow_1.err)({ code: 'INVARIANT_VIOLATION', message: 'toNodeKind must be step|blocked_attempt' });
     }
-    const advancedEvents = [
-        {
-            v: 1,
-            eventId: minted.nodeCreatedEventId,
-            eventIndex: nodeCreatedEventIndex,
-            sessionId,
-            kind: 'node_created',
-            dedupeKey: `node_created:${sessionId}:${runId}:${toNodeId}`,
-            scope: { runId, nodeId: toNodeId },
-            data: {
-                nodeKind: toNodeKind,
-                parentNodeId: fromNodeId,
-                workflowHash,
-                snapshotRef,
-            },
-        },
-        {
-            v: 1,
-            eventId: minted.edgeCreatedEventId,
-            eventIndex: edgeCreatedEventIndex,
-            sessionId,
-            kind: 'edge_created',
-            dedupeKey: `edge_created:${sessionId}:${runId}:${fromNodeId}->${toNodeId}:acked_step`,
-            scope: { runId },
-            data: {
-                edgeKind: 'acked_step',
-                fromNodeId,
-                toNodeId,
-                cause: { kind: causeKind, eventId: minted.advanceRecordedEventId },
-            },
-        },
-    ];
-    const normalizedOutputs = (0, outputs_js_1.normalizeOutputsForAppend)(outputsToAppend ?? []);
-    const outputEventIds = minted.outputEventIds ?? [];
-    if (outputEventIds.length !== normalizedOutputs.length) {
-        return (0, neverthrow_1.err)({
-            code: 'INVARIANT_VIOLATION',
-            message: 'outputEventIds length mismatch (caller must supply exactly one eventId per output event)',
-        });
-    }
-    const outputEvents = normalizedOutputs.map((o, idx) => {
-        const base = {
-            v: 1,
-            eventId: outputEventIds[idx],
-            eventIndex: nextIndexAfterExtra + 2 + idx,
-            sessionId,
-            kind: 'node_output_appended',
-            dedupeKey: `node_output_appended:${sessionId}:${o.outputId}`,
-            scope: { runId, nodeId: fromNodeId },
-            data: {
-                outputId: o.outputId,
-                outputChannel: o.outputChannel,
-                payload: o.payload,
-            },
-        };
-        return o.supersedesOutputId
-            ? {
-                ...base,
-                data: { ...base.data, supersedesOutputId: o.supersedesOutputId },
-            }
-            : base;
+    const nodeCreatedEventIndex = nextIndexAfterExtra;
+    const edgeCreatedEventIndex = nextIndexAfterExtra + 1;
+    const nodeCreated = buildNodeCreatedEvent({
+        sessionId,
+        runId,
+        toNodeId,
+        fromNodeId,
+        toNodeKind,
+        workflowHash,
+        snapshotRef,
+        eventId: advancedMinted.nodeCreatedEventId,
+        eventIndex: nodeCreatedEventIndex,
     });
-    const events = [advanceRecorded, ...extra, ...advancedEvents, ...outputEvents];
+    const edgeCreated = buildEdgeCreatedEvent({
+        sessionId,
+        runId,
+        fromNodeId,
+        toNodeId,
+        causeKind,
+        causeEventId: minted.advanceRecordedEventId,
+        eventId: advancedMinted.edgeCreatedEventId,
+        eventIndex: edgeCreatedEventIndex,
+    });
+    const outputEventsResult = buildOutputEvents({
+        outputs: outputsToAppend ?? [],
+        outputEventIds: advancedMinted.outputEventIds,
+        sessionId,
+        runId,
+        fromNodeId,
+        startEventIndex: nextIndexAfterExtra + 2,
+    });
+    if (outputEventsResult.isErr()) {
+        return (0, neverthrow_1.err)(outputEventsResult.error);
+    }
+    const events = [
+        advanceRecorded,
+        ...extra,
+        nodeCreated,
+        edgeCreated,
+        ...outputEventsResult.value,
+    ];
     return (0, neverthrow_1.ok)({
         events,
         snapshotPins: [
             {
                 snapshotRef,
                 eventIndex: nodeCreatedEventIndex,
-                createdByEventId: minted.nodeCreatedEventId,
+                createdByEventId: advancedMinted.nodeCreatedEventId,
             },
         ],
     });

package/dist/v2/durable-core/domain/blocked-node-builder.js

@@ -38,11 +38,17 @@ function toTerminalReason(reason) {
 function buildBlockedPayload(args) {
     const retryable = toContractViolationReason(args.primaryReason);
     if (retryable) {
-        const retryAttemptId = (0, attempt_id_derivation_js_1.deriveChildAttemptId)(args.attemptId, args.sha256);
+        const retryAttemptIdRes = (0, attempt_id_derivation_js_1.deriveChildAttemptId)(args.attemptId, args.sha256);
+        if (retryAttemptIdRes.isErr()) {
+            return (0, neverthrow_1.err)({
+                code: 'BLOCKED_NODE_INVARIANT_VIOLATION',
+                message: `Failed to derive retry attemptId: ${retryAttemptIdRes.error.message}`,
+            });
+        }
         return (0, neverthrow_1.ok)({
             kind: 'retryable_block',
             reason: retryable,
-            retryAttemptId: String(retryAttemptId),
+            retryAttemptId: String(retryAttemptIdRes.value),
             validationRef: args.validationRef,
             blockers: args.blockers,
         });

package/dist/v2/durable-core/domain/blocking-decision.d.ts

@@ -7,6 +7,8 @@ export type BlockingDecisionError = {
 };
 export type OutputRequirementStatus = {
     readonly kind: 'not_required';
+} | {
+    readonly kind: 'satisfied';
 } | {
     readonly kind: 'missing';
     readonly contractRef: string;

package/dist/v2/durable-core/domain/blocking-decision.js

@@ -20,21 +20,38 @@ function detectBlockingReasonsV1(args) {
         }
     }
     const outReq = args.outputRequirement;
-    if (outReq && outReq.kind !== 'not_required') {
-        if (outReq.kind === 'missing') {
-            reasons.push({ kind: 'missing_required_output', contractRef: outReq.contractRef });
-        }
-        if (outReq.kind === 'invalid') {
-            reasons.push({ kind: 'invalid_required_output', contractRef: outReq.contractRef });
+    if (outReq) {
+        switch (outReq.kind) {
+            case 'not_required':
+            case 'satisfied':
+                break;
+            case 'missing':
+                reasons.push({ kind: 'missing_required_output', contractRef: outReq.contractRef });
+                break;
+            case 'invalid':
+                reasons.push({ kind: 'invalid_required_output', contractRef: outReq.contractRef });
+                break;
+            default: {
+                const _exhaustive = outReq;
+                return _exhaustive;
+            }
         }
     }
     const capReq = args.capabilityRequirement;
-    if (capReq && capReq.kind !== 'not_required') {
-        if (capReq.kind === 'unknown') {
-            reasons.push({ kind: 'required_capability_unknown', capability: capReq.capability });
-        }
-        if (capReq.kind === 'unavailable') {
-            reasons.push({ kind: 'required_capability_unavailable', capability: capReq.capability });
+    if (capReq) {
+        switch (capReq.kind) {
+            case 'not_required':
+                break;
+            case 'unknown':
+                reasons.push({ kind: 'required_capability_unknown', capability: capReq.capability });
+                break;
+            case 'unavailable':
+                reasons.push({ kind: 'required_capability_unavailable', capability: capReq.capability });
+                break;
+            default: {
+                const _exhaustive = capReq;
+                return _exhaustive;
+            }
         }
     }
     return (0, neverthrow_1.ok)(reasons);

package/dist/v2/durable-core/domain/bundle-builder.d.ts

@@ -16,6 +16,7 @@ export interface BuildExportBundleArgs {
         readonly appliedConfigHash?: string;
     };
     readonly sha256: (bytes: Uint8Array) => Sha256Digest;
+    readonly exportedAt: string;
 }
 export type BundleBuilderError = {
     readonly code: 'BUNDLE_BUILD_EMPTY_EVENTS';

package/dist/v2/durable-core/domain/bundle-builder.js

@@ -30,7 +30,7 @@ function buildExportBundle(args) {
     const bundle = {
         bundleSchemaVersion: 1,
         bundleId: args.bundleId,
-        exportedAt: new Date().toISOString(),
+        exportedAt: args.exportedAt,
         producer: {
             appVersion: args.producer.appVersion,
             ...(args.producer.appliedConfigHash != null

package/dist/v2/durable-core/domain/bundle-validator.js

@@ -4,6 +4,7 @@ exports.validateBundle = validateBundle;
 const neverthrow_1 = require("neverthrow");
 const index_js_1 = require("../schemas/export-bundle/index.js");
 const jcs_js_1 = require("../canonical/jcs.js");
+const constants_js_1 = require("../constants.js");
 function validateBundle(raw, sha256) {
     const schemaResult = validateSchema(raw);
     if (schemaResult.isErr())
@@ -95,7 +96,7 @@ function validateReferences(bundle) {
     const referencedWorkflows = new Set();
     for (const event of bundle.session.events) {
         const evt = event;
-        if (evt.kind === 'node_created') {
+        if (evt.kind === constants_js_1.EVENT_KIND.NODE_CREATED) {
             if (typeof evt.data.snapshotRef === 'string') {
                 referencedSnapshots.add(evt.data.snapshotRef);
             }
@@ -103,7 +104,7 @@ function validateReferences(bundle) {
                 referencedWorkflows.add(evt.data.workflowHash);
             }
         }
-        if (evt.kind === 'run_started' && typeof evt.data.workflowHash === 'string') {
+        if (evt.kind === constants_js_1.EVENT_KIND.RUN_STARTED && typeof evt.data.workflowHash === 'string') {
             referencedWorkflows.add(evt.data.workflowHash);
         }
     }