@loomwork/wire-abi 0.0.0-stage → 0.1.1

package/src/foldVectors.ts

@@ -0,0 +1,944 @@
+import type { EventEnvelope } from "@loomwork/core";
+import { foldEvents } from "@loomwork/replay-vm";
+
+// ── T2.3 — language-agnostic fold conformance vectors ─────────────────────────
+//
+// The event log is the kernel's on-disk ABI (K5): state = fold(events). These
+// vectors are the EXECUTABLE, language-agnostic conformance suite the amendment
+// requires — event-log fixtures in, expected folds out. Any client
+// implementation (in any language) can load `FOLD_VECTORS` as plain JSON, run
+// its own fold, and assert equality; the TS reference below is one such runner.
+// This extends the K1/K5 pins from "the fold understands these types" to "the
+// fold produces exactly this state for this log".
+
+export interface FoldVector {
+  name: string;
+  events: EventEnvelope[];
+  /** The expected `fold(events)` — compared field-by-field (JSON-equal). */
+  expected: {
+    status: string;
+    sequence: number;
+    variables: Record<string, unknown>;
+    frames: Record<string, { status: string; attempts: number }>;
+    /**
+     * Optional (ADR 0113, additive): each frame's first-start sequence and kernel-recorded scope
+     * path. Present only on the vectors that pin them, so the vectors that predate them are
+     * unchanged.
+     */
+    frameMeta?: Record<string, { firstSeq?: number; scope?: string }>;
+  };
+}
+
+function ev(
+  executionId: string,
+  sequence: number,
+  eventType: string,
+  payload: unknown,
+  metadata?: Record<string, unknown>
+): EventEnvelope {
+  return {
+    id: `${executionId}-${sequence}`,
+    workflowId: "wf",
+    executionId,
+    eventType,
+    sequence,
+    timestamp: 1000 + sequence,
+    payload,
+    ...(metadata !== undefined && { metadata }),
+  };
+}
+
+/**
+ * The canonical vectors. Deliberately covers the core lifecycle plus a
+ * representative kernel-ring fact, so a foreign fold that mishandles any of them
+ * fails loudly. Extend (never repurpose) alongside the K5 schema.
+ */
+export const FOLD_VECTORS: FoldVector[] = [
+  {
+    name: "start → step → complete",
+    events: [
+      ev("v1", 0, "EXECUTION_STARTED", { input: { n: 1 } }),
+      ev("v1", 1, "STEP_STARTED", { stepId: "a", input: { n: 1 } }),
+      ev("v1", 2, "STEP_COMPLETED", { stepId: "a", output: { n: 2 } }),
+      ev("v1", 3, "EXECUTION_COMPLETED", { output: { n: 2 } }),
+    ],
+    expected: {
+      status: "completed",
+      sequence: 3,
+      variables: { _input: { n: 1 }, _output: { n: 2 } },
+      frames: { a: { status: "completed", attempts: 1 } },
+    },
+  },
+  {
+    name: "suspend leaves a running frame + suspended status",
+    events: [
+      ev("v2", 0, "EXECUTION_STARTED", { input: {} }),
+      ev("v2", 1, "STEP_STARTED", { stepId: "gate", input: {} }),
+      ev("v2", 2, "EXECUTION_SUSPENDED", { condition: { on: "Approval" } }),
+    ],
+    expected: {
+      status: "suspended",
+      sequence: 2,
+      variables: { _input: {} },
+      frames: { gate: { status: "running", attempts: 1 } },
+    },
+  },
+  {
+    name: "a metered + denied ring log folds its audit facts",
+    events: [
+      ev("v3", 0, "EXECUTION_STARTED", { input: {} }),
+      ev("v3", 1, "RESOURCE_METERED", { tokens: 100, costUsd: 0.5, ms: 10 }),
+      ev("v3", 2, "EFFECT_DENIED", { toolId: "delete-prod", reason: "not granted" }),
+    ],
+    expected: {
+      status: "running",
+      sequence: 2,
+      variables: {
+        _input: {},
+        _resources: { tokens: 100, costUsd: 0.5, ms: 10, count: 1 },
+        _denials: [{ toolId: "delete-prod", reason: "not granted" }],
+      },
+      frames: {},
+    },
+  },
+  {
+    // 1.19.0 (ADR 0102) — the one fold step keyed on an envelope stamp, not a type:
+    // `metadata.flowEmit` (a 16-hex content digest) on ANY event type — here a domain
+    // event and SURFACE_PATCH, neither of which has a handler — is counted per digest in
+    // a 16-way trie of 16-slot arrays over the digest's last three hex digits. An unstamped event (a legacy log's emit, or one
+    // appended while an effect was in flight) counts nothing.
+    name: "stamped flow-level emits are counted per content digest; unstamped ones are not",
+    events: [
+      ev("v4", 0, "EXECUTION_STARTED", { input: {} }),
+      ev("v4", 1, "response.committed", { msg: "m1" }, { flowEmit: "0123456789abcdef" }),
+      ev("v4", 2, "SURFACE_PATCH", { patches: [] }, { flowEmit: "ffffffffffffffef", fence: 2 }),
+      ev("v4", 3, "response.committed", { msg: "m1" }, { flowEmit: "0123456789abcdef" }),
+      ev("v4", 4, "legacy.domain", {}),
+    ],
+    expected: {
+      status: "running",
+      sequence: 4,
+      variables: {
+        _input: {},
+        // 16-slot arrays indexed by the digest's last three hex digits (f, e, then d / f).
+        _flowEmits: [
+          null,
+          null,
+          null,
+          null,
+          null,
+          null,
+          null,
+          null,
+          null,
+          null,
+          null,
+          null,
+          null,
+          null,
+          null,
+          [
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            [
+              null,
+              null,
+              null,
+              null,
+              null,
+              null,
+              null,
+              null,
+              null,
+              null,
+              null,
+              null,
+              null,
+              { "0123456789abcdef": 2 },
+              null,
+              { ffffffffffffffef: 1 },
+            ],
+            null,
+          ],
+        ],
+      },
+      frames: {},
+    },
+  },
+  {
+    // 1.21.0 (ADR 0105) — STEP_FAILED folds the step's frame only. A flow that catches the
+    // failure keeps running; only EXECUTION_FAILED fails the execution. A foreign fold that
+    // still moves the execution status on a step failure reports a live execution terminal.
+    name: "a caught step failure fails the frame, not the execution",
+    events: [
+      ev("v5", 0, "EXECUTION_STARTED", { input: {} }),
+      ev("v5", 1, "STEP_STARTED", { stepId: "a", input: {} }),
+      ev("v5", 2, "STEP_FAILED", { stepId: "a", error: "Error: 503" }),
+      ev("v5", 3, "STEP_STARTED", { stepId: "fallback", input: {} }),
+    ],
+    expected: {
+      status: "running",
+      sequence: 3,
+      variables: { _input: {} },
+      frames: {
+        a: { status: "failed", attempts: 1 },
+        fallback: { status: "running", attempts: 1 },
+      },
+    },
+  },
+  {
+    // 1.21.0 (ADR 0105) — a STEP_FAILED that lands while the execution is PARKED (a parallel
+    // sibling) leaves it suspended and sets `_failedWhileParked`; a following `null` resume is
+    // status-only (no gate passthrough) and clears it. A foreign fold that serves that null to
+    // the gate lets it pass with no approval.
+    name: "a null resume after a sibling failed while parked answers no gate",
+    events: [
+      ev("v6", 0, "EXECUTION_STARTED", { input: {} }),
+      ev("v6", 1, "STEP_STARTED", { stepId: "slow", input: {} }),
+      ev("v6", 2, "EXECUTION_SUSPENDED", { condition: { on: "Approval" } }),
+      ev("v6", 3, "STEP_FAILED", { stepId: "slow", error: "Error: late" }),
+      ev("v6", 4, "EXECUTION_RESUMED", null),
+    ],
+    expected: {
+      status: "running",
+      sequence: 4,
+      variables: { _input: {} },
+      frames: { slow: { status: "failed", attempts: 1 } },
+    },
+  },
+  // ── 1.23.0 (Wave 2, W2-0) — the reserved shapes. No kernel writer exists yet; these pin what
+  // a foreign fold must do with them, and (the last two) what it must NOT do without the stamp.
+  {
+    // ADR 0109: a continuation. The predecessor ends `continued` (NOT completed, no `_output`)
+    // naming its successor; the stamp `metadata.kernel` is what makes the event count.
+    name: "a stamped EXECUTION_CONTINUED ends the execution as `continued`",
+    events: [
+      ev("v7", 0, "EXECUTION_STARTED", {
+        input: { n: 1 },
+        principal: { v: 1 },
+        chainId: "v7",
+        generation: 0,
+      }),
+      ev(
+        "v7",
+        1,
+        "EXECUTION_CONTINUED",
+        { successorId: "v7~1", chainId: "v7", generation: 1 },
+        { kernel: true }
+      ),
+    ],
+    expected: {
+      status: "continued",
+      sequence: 1,
+      variables: {
+        _input: { n: 1 },
+        _principal: { v: 1 },
+        _chain: { chainId: "v7", generation: 0 },
+        _continuedTo: "v7~1",
+      },
+      frames: {},
+    },
+  },
+  {
+    // ADR 0109 D3: the successor's start carries budget and inbox; the fold applies them.
+    name: "a successor start seeds _resources and _inbox from its validated carry",
+    events: [
+      ev("v8", 0, "EXECUTION_STARTED", {
+        input: { turn: 0 },
+        principal: { v: 1, ref: "r" },
+        parent: "p",
+        chainId: "v7",
+        generation: 1,
+        codeHash: "sha256:00",
+        continuedFrom: {
+          executionId: "v7",
+          carried: {
+            resources: { tokens: 10, costUsd: 0, ms: 4, count: 2, custom: { credits: 3 } },
+            inbox: { cursors: { chat: 4 }, dedupe: ["m1"] },
+            chainDeadline: 5000,
+          },
+        },
+      }),
+      ev("v8", 1, "RESOURCE_METERED", { tokens: 5, custom: { credits: 1, gpu_seconds: 2 } }),
+    ],
+    expected: {
+      status: "running",
+      sequence: 1,
+      variables: {
+        _input: { turn: 0 },
+        _principal: { v: 1, ref: "r" },
+        _parent: "p",
+        _chain: {
+          chainId: "v7",
+          generation: 1,
+          continuedFrom: {
+            executionId: "v7",
+            carried: {
+              resources: { tokens: 10, costUsd: 0, ms: 4, count: 2, custom: { credits: 3 } },
+              inbox: { cursors: { chat: 4 }, dedupe: ["m1"] },
+              chainDeadline: 5000,
+            },
+          },
+        },
+        _codeHash: "sha256:00",
+        _resources: {
+          tokens: 15,
+          costUsd: 0,
+          ms: 4,
+          count: 3,
+          custom: { credits: 4, gpu_seconds: 2 },
+        },
+        _inbox: { cursors: { chat: 4 }, dedupe: ["m1"] },
+      },
+      frames: {},
+    },
+  },
+  {
+    // ADR 0110: a two-arm park; the inbox arm is answered by a stamped MESSAGE_CONSUMED, then the
+    // gate arm by a stamped wait-addressed resume (unwrapped into `_waitAnswers`, never into
+    // `_resumePayloads`). The timer arm's `wakeAt` is pinned at its first registration.
+    name: "a multi-wait park answered per wait (MESSAGE_CONSUMED, then a wait-addressed resume)",
+    events: [
+      ev("v9", 0, "EXECUTION_STARTED", { input: {} }),
+      ev(
+        "v9",
+        1,
+        "EXECUTION_SUSPENDED",
+        {
+          condition: {
+            on: "Approval",
+            waits: [
+              { waitId: "#0", kind: "gate", on: "Approval" },
+              { waitId: "#1", kind: "inbox", topic: "chat" },
+              { waitId: "#2", kind: "timer", wakeAt: 7000 },
+            ],
+          },
+        },
+        { kernel: true }
+      ),
+      ev(
+        "v9",
+        2,
+        "MESSAGE_CONSUMED",
+        {
+          waitId: "#1",
+          topic: "chat",
+          messageId: "m1",
+          inboxSeq: 0,
+          sender: { actor: "a" },
+          payload: "hi",
+        },
+        { kernel: true }
+      ),
+      ev(
+        "v9",
+        3,
+        "EXECUTION_RESUMED",
+        { waitId: "#0", payload: { approved: true } },
+        { kernel: true }
+      ),
+    ],
+    expected: {
+      status: "running",
+      sequence: 3,
+      variables: {
+        _input: {},
+        _waits: { "#2": { kind: "timer", wakeAt: 7000 } },
+        _inbox: { cursors: { chat: 0 }, dedupe: ["m1"] },
+        _waitAnswers: {
+          "#1": { kind: "inbox", name: "chat", payload: "hi" },
+          "#0": { kind: "gate", name: "Approval", payload: { approved: true } },
+        },
+      },
+      frames: {},
+    },
+  },
+  {
+    // ADR 0110 amendment (D8): an operator discard is an ordinary stamped MESSAGE_CONSUMED whose
+    // waitId no wait can carry. The cursor advances (monotone), the id joins the dedupe window, and the
+    // fixed waitId records ONE answer (first wins) whose payload is null, however many discards run. No
+    // fold change: an older node folds the same log identically.
+    name: "an operator discard (MESSAGE_CONSUMED under the reserved discard waitId)",
+    events: [
+      ev("v11", 0, "EXECUTION_STARTED", { input: {} }),
+      ev(
+        "v11",
+        1,
+        "MESSAGE_CONSUMED",
+        {
+          waitId: "__loom_discard__",
+          topic: "cold",
+          messageId: "d1",
+          inboxSeq: 4,
+          sender: { actor: "ops" },
+          payload: null,
+          discarded: true,
+          skipped: 2,
+        },
+        { kernel: true }
+      ),
+      ev(
+        "v11",
+        2,
+        "MESSAGE_CONSUMED",
+        {
+          waitId: "__loom_discard__",
+          topic: "cold",
+          messageId: "d2",
+          inboxSeq: 9,
+          sender: { actor: "ops" },
+          payload: null,
+          discarded: true,
+          skipped: 1,
+        },
+        { kernel: true }
+      ),
+      ev(
+        "v11",
+        3,
+        "MESSAGE_CONSUMED",
+        {
+          waitId: "__loom_discard__",
+          topic: "cold",
+          messageId: "d3",
+          inboxSeq: 3,
+          sender: { actor: "ops" },
+          payload: null,
+          discarded: true,
+          skipped: 0,
+        },
+        { kernel: true }
+      ),
+    ],
+    expected: {
+      status: "running",
+      sequence: 3,
+      variables: {
+        _input: {},
+        _inbox: { cursors: { cold: 9 }, dedupe: ["d1", "d2", "d3"] },
+        _waitAnswers: { __loom_discard__: { kind: "inbox", name: "cold", payload: null } },
+      },
+      frames: {},
+    },
+  },
+  {
+    // ADR 0112 D2, ADR 0115 D2, ADR 0116 D1: the scope outcome, an open metering dimension (a bad
+    // key skipped, deterministically) and a late outcome.
+    name: "PARALLEL_COMPLETED, RESOURCE_METERED.custom and a late OUTCOME_RECORDED",
+    events: [
+      ev("v10", 0, "EXECUTION_STARTED", { input: {} }),
+      ev(
+        "v10",
+        1,
+        "PARALLEL_COMPLETED",
+        { scopePath: "/0.1", failedBranch: 1, error: "boom", cancelled: ["b#0"] },
+        { kernel: true }
+      ),
+      ev("v10", 2, "RESOURCE_METERED", { ms: 1, custom: { gpu_seconds: 2, "Bad Key": 9 } }),
+      ev(
+        "v10",
+        3,
+        "OUTCOME_RECORDED",
+        { key: "route", score: 1, decisionId: "d", recordedBy: "ops", late: true },
+        { kernel: true }
+      ),
+    ],
+    expected: {
+      status: "running",
+      sequence: 3,
+      variables: {
+        _input: {},
+        _scopes: { "/0.1": { failedBranch: 1, error: "boom", cancelled: ["b#0"] } },
+        _resources: { tokens: 0, costUsd: 0, ms: 1, count: 1, custom: { gpu_seconds: 2 } },
+        _outcomes: [{ key: "route", score: 1, decisionId: "d", recordedBy: "ops", late: true }],
+      },
+      frames: {},
+    },
+  },
+  {
+    // ADR 0115 D2/D3 — an open dimension's bad keys (a prototype name, a negative, an over-ceiling
+    // value) are skipped and the rest folds; a decision's descriptive `estimatedCost` map keeps
+    // its valid entries only. Neither is ever a replay input.
+    name: "RESOURCE_METERED.custom with prototype-named keys, and DECISION_RECORDED.estimatedCost",
+    events: [
+      ev("v11", 0, "EXECUTION_STARTED", { input: {} }),
+      ev("v11", 1, "RESOURCE_METERED", {
+        ms: 1,
+        custom: JSON.parse('{"credits":3,"constructor":4,"__proto__":5,"neg":-1,"big":1e16}'),
+      }),
+      ev("v11", 2, "DECISION_RECORDED", {
+        decisionId: "route",
+        choice: "a",
+        estimatedCost: { gpu_seconds: 2, "Bad Key": 1, credits: -1 },
+      }),
+    ],
+    expected: {
+      status: "running",
+      sequence: 2,
+      variables: {
+        _input: {},
+        _resources: { tokens: 0, costUsd: 0, ms: 1, count: 1, custom: { credits: 3 } },
+        _decisions: { route: { choice: "a", estimatedCost: { gpu_seconds: 2 }, seq: 2 } },
+      },
+      frames: {},
+    },
+  },
+  {
+    // ADR 0112 D2 — the scope record's ADDITIVE fields (amended 2026-10-06, R6 review): the
+    // launched count, the per-branch gate-answer consumption + cursor, and the failing error's
+    // class (and a typed failure's channel + payload). Malformed entries (a negative or fractional
+    // index, a non-string path) are skipped; a record without them folds as before.
+    name: "PARALLEL_COMPLETED's additive launched / consumed / cursor / error-class fields",
+    events: [
+      ev("v10b", 0, "EXECUTION_STARTED", { input: {} }),
+      ev(
+        "v10b",
+        1,
+        "PARALLEL_COMPLETED",
+        {
+          scopePath: "/0",
+          failedBranch: 0,
+          error: "TypedFailure: outage",
+          errorName: "TypedFailure",
+          errorChannel: "outage",
+          errorPayload: { code: 503 },
+          cancelled: [],
+          launched: 2,
+          consumed: [
+            ["/0.0", 0, 1],
+            ["/0.1", 1.5, 1],
+            ["/0.1", -1, 1],
+            [7, 2, 1],
+            ["/0.1", 2, 0],
+            ["/0.1", 2],
+            ["/0.1", 2, 3],
+          ],
+          cursor: 3,
+        },
+        { kernel: true }
+      ),
+      ev(
+        "v10b",
+        2,
+        "PARALLEL_COMPLETED",
+        { scopePath: "/1", failedBranch: 0, error: "x", cancelled: [], launched: -1, cursor: "z" },
+        { kernel: true }
+      ),
+    ],
+    expected: {
+      status: "running",
+      sequence: 2,
+      variables: {
+        _input: {},
+        _scopes: {
+          "/0": {
+            failedBranch: 0,
+            error: "TypedFailure: outage",
+            errorName: "TypedFailure",
+            errorChannel: "outage",
+            errorPayload: { code: 503 },
+            cancelled: [],
+            launched: 2,
+            consumed: [
+              ["/0.0", 0, 1],
+              ["/0.1", 2, 3],
+            ],
+            cursor: 3,
+          },
+          "/1": { failedBranch: 0, error: "x", cancelled: [] },
+        },
+      },
+      frames: {},
+    },
+  },
+  {
+    // The marker rule: the SAME events without `metadata.kernel` fold as an app event always did
+    // (no handler effect at all), so an existing log that happens to use these names replays
+    // byte-identically. Only PARALLEL_COMPLETED had a (no-op) handler before; it keeps it.
+    name: "the new kinds without the kernel stamp fold as no-ops",
+    events: [
+      ev("v11", 0, "EXECUTION_STARTED", { input: {} }),
+      ev("v11", 1, "EXECUTION_CONTINUED", { successorId: "v11~1", chainId: "v11", generation: 1 }),
+      ev("v11", 2, "MESSAGE_CONSUMED", {
+        waitId: "#0",
+        topic: "t",
+        messageId: "m",
+        inboxSeq: 0,
+        payload: 1,
+      }),
+      ev("v11", 3, "PARALLEL_COMPLETED", {
+        scopePath: "/0.0",
+        failedBranch: 0,
+        error: "e",
+        cancelled: [],
+      }),
+    ],
+    expected: {
+      status: "running",
+      sequence: 3,
+      variables: { _input: {} },
+      frames: {},
+    },
+  },
+  {
+    // ADR 0110 D3/D4: `waits` is honoured only on a kernel-stamped EXECUTION_SUSPENDED. A flow that
+    // forges one (no stamp) pins nothing, records no deadline, and a stamped wait-addressed
+    // resume naming its wait answers nothing; an unstamped OUTCOME_RECORDED claiming
+    // recordedBy/late folds without them.
+    name: "an unstamped park's waits and an unstamped outcome's recordedBy/late are userspace and dropped",
+    events: [
+      ev("v13", 0, "EXECUTION_STARTED", { input: {} }),
+      ev("v13", 1, "EXECUTION_SUSPENDED", {
+        condition: {
+          on: "A",
+          waits: [
+            { waitId: "root#0", kind: "timer", wakeAt: 9e15 },
+            { waitId: "#0", kind: "gate", on: "A" },
+          ],
+        },
+      }),
+      ev("v13", 2, "EXECUTION_RESUMED", { waitId: "#0", payload: "yes" }, { kernel: true }),
+      ev("v13", 3, "OUTCOME_RECORDED", { key: "k", score: 1, recordedBy: "ops", late: true }),
+    ],
+    expected: {
+      status: "running",
+      sequence: 3,
+      variables: { _input: {}, _outcomes: [{ key: "k", score: 1 }] },
+      frames: {},
+    },
+  },
+  {
+    // A fork of a chain member leaves the chain (ADR 0109 D7) and acts as the forker (ADR 0111 D7).
+    name: "forkChain and forkedBy on a copied start replace the copied chain and principal",
+    events: [
+      ev(
+        "v12",
+        0,
+        "EXECUTION_STARTED",
+        {
+          input: {},
+          principal: { v: 1, ref: "owner" },
+          chainId: "v7",
+          generation: 2,
+          continuedFrom: {
+            executionId: "v7~1",
+            carried: { inbox: { cursors: { t: 3 }, dedupe: [] } },
+          },
+        },
+        { forkChain: { chainId: "v12", generation: 0 }, forkedBy: { v: 1, ref: "forker" } }
+      ),
+    ],
+    expected: {
+      status: "running",
+      sequence: 0,
+      variables: {
+        _input: {},
+        _principal: { v: 1, ref: "forker" },
+        _chain: { chainId: "v12", generation: 0 },
+      },
+      frames: {},
+    },
+  },
+  {
+    // ADR 0113 (R7, additive within 1.23.0): the first-start sequence of every frame (kept through
+    // later events and a re-start), the scope path of a STEP_STARTED folded ONLY from a kernel-stamped
+    // envelope, and a decision's innerSteps (kernel-stamped only; an overflow flag, the sequence the
+    // decider began at, and the record's own sequence ride along only when well-formed).
+    name: "R7: frame firstSeq/scope and DECISION_RECORDED innerSteps (kernel-stamped only)",
+    events: [
+      ev("v13", 0, "EXECUTION_STARTED", { input: {}, codeHash: "fp1" }),
+      ev("v13", 1, "STEP_STARTED", { stepId: "a", input: 1, scope: "/0.1" }, { kernel: true }),
+      ev("v13", 2, "STEP_STARTED", { stepId: "b", input: 2, scope: "/0.2" }), // unstamped: scope ignored
+      ev("v13", 3, "STEP_COMPLETED", { stepId: "a", output: 1 }),
+      ev("v13", 4, "STEP_STARTED", { stepId: "a", input: 1, scope: "/9" }, { kernel: true }), // re-start
+      ev(
+        "v13",
+        5,
+        "DECISION_RECORDED",
+        { decisionId: "d", choice: 1, innerSteps: ["a", 7, "b"] },
+        {
+          kernel: true,
+        }
+      ),
+      ev("v13", 6, "DECISION_RECORDED", { decisionId: "e", choice: 2, innerSteps: ["a"] }), // unstamped
+      ev(
+        "v13",
+        7,
+        "DECISION_RECORDED",
+        { decisionId: "f", choice: 3, innerSteps: ["a"], innerStepsOverflow: true, innerFrom: 4 },
+        { kernel: true }
+      ),
+      ev("v13", 8, "EXECUTION_MIGRATED", { toFlowId: "wf", toCodeHash: "fp2" }),
+    ],
+    expected: {
+      status: "running",
+      sequence: 8,
+      variables: {
+        _input: {},
+        _codeHash: "fp2",
+        _decisions: {
+          d: { choice: 1, innerSteps: ["a", "b"], seq: 5 },
+          e: { choice: 2, seq: 6 },
+          f: {
+            choice: 3,
+            innerSteps: ["a"],
+            innerStepsOverflow: true,
+            innerFrom: 4,
+            recordedAtSeq: 7,
+            seq: 7,
+          },
+        },
+        _migratedTo: "wf",
+        _migrations: [{ toFlowId: "wf" }],
+      },
+      frames: { a: { status: "running", attempts: 2 }, b: { status: "running", attempts: 1 } },
+      frameMeta: { a: { firstSeq: 1, scope: "/0.1" }, b: { firstSeq: 2 } },
+    },
+  },
+  {
+    // ADR 0128 (additive, EVENT_SCHEMA 1.24.0): each folded decision carries `seq`, the ENVELOPE
+    // sequence of the FIRST record of that id. A repeated id keeps its first `seq` (and its slot) and
+    // takes the later content; an array-index-like id is stamped like any other, so the order
+    // survives a checkpoint that reorders the map's keys. `seq` is never a replay input.
+    name: "ADR 0128: DECISION_RECORDED stamps seq from the envelope, a repeated id keeps its first",
+    events: [
+      ev("v14", 0, "EXECUTION_STARTED", { input: {} }),
+      ev("v14", 1, "DECISION_RECORDED", { decisionId: "route-b", choice: 1 }),
+      ev("v14", 2, "DECISION_RECORDED", { decisionId: "10", choice: 2, seq: 99 }), // payload seq ignored
+      ev("v14", 3, "DECISION_RECORDED", { decisionId: "route-a", choice: 3 }),
+      ev("v14", 4, "DECISION_RECORDED", { decisionId: "route-b", choice: 4 }), // repeat
+    ],
+    expected: {
+      status: "running",
+      sequence: 4,
+      variables: {
+        _input: {},
+        _decisions: {
+          "route-b": { choice: 4, seq: 1 },
+          "10": { choice: 2, seq: 2 },
+          "route-a": { choice: 3, seq: 3 },
+        },
+      },
+      frames: {},
+    },
+  },
+  {
+    // ADR 0130 residuals D9 (EVENT_SCHEMA 1.25.0, RESERVED): a kernel-stamped INBOX_QUARANTINED holds
+    // the topic's head. The cursor advances (the original entry no longer pins the stream), the entry
+    // joins the topic's queue as `held`, and the dedupe window is NOT touched.
+    name: "ADR 0130: INBOX_QUARANTINED advances the cursor, queues the entry, leaves the dedupe window",
+    events: [
+      ev("v15", 0, "EXECUTION_STARTED", { input: {} }),
+      ev(
+        "v15",
+        1,
+        "INBOX_QUARANTINED",
+        {
+          topic: "chat",
+          inboxSeq: 3,
+          key: "k3",
+          messageId: "m3",
+          heldAt: 0,
+          operator: { actor: "op" },
+        },
+        { kernel: true }
+      ),
+    ],
+    expected: {
+      status: "running",
+      sequence: 1,
+      variables: {
+        _input: {},
+        _inbox: { cursors: { chat: 3 }, dedupe: [] },
+        _quarantined: { chat: [{ key: "k3", inboxSeq: 3, heldAt: 0, state: "held" }] },
+      },
+      frames: {},
+    },
+  },
+  {
+    // …then a manual release marks it `released` (still ahead of everything above the cursor), and the
+    // delivery's MESSAGE_CONSUMED (whose messageId is the dedupe key) drops it WITHOUT moving the cursor.
+    name: "ADR 0130: INBOX_RELEASED deliver, then MESSAGE_CONSUMED of its key, drops the entry",
+    events: [
+      ev("v16", 0, "EXECUTION_STARTED", { input: {} }),
+      ev(
+        "v16",
+        1,
+        "INBOX_QUARANTINED",
+        {
+          topic: "chat",
+          inboxSeq: 3,
+          key: "k3",
+          messageId: "m3",
+          heldAt: 0,
+          operator: { actor: "op" },
+        },
+        { kernel: true }
+      ),
+      ev(
+        "v16",
+        2,
+        "INBOX_RELEASED",
+        { topic: "chat", key: "k3", messageId: "m3", disposition: "deliver", auto: true },
+        { kernel: true }
+      ),
+      ev(
+        "v16",
+        3,
+        "MESSAGE_CONSUMED",
+        { waitId: "#0", topic: "chat", messageId: "k3", inboxSeq: 3, sender: {}, payload: "hello" },
+        { kernel: true }
+      ),
+    ],
+    expected: {
+      status: "running",
+      sequence: 3,
+      variables: {
+        _input: {},
+        _inbox: { cursors: { chat: 3 }, dedupe: ["k3"] },
+        _waitAnswers: { "#0": { kind: "inbox", name: "chat", payload: "hello" } },
+      },
+      frames: {},
+    },
+  },
+  {
+    // A release naming both `operator` and `auto`, or neither, is ignored; so is an unstamped one.
+    name: "ADR 0130: an INBOX_RELEASED with both or neither of operator/auto, or unstamped, is ignored",
+    events: [
+      ev("v17", 0, "EXECUTION_STARTED", { input: {} }),
+      ev(
+        "v17",
+        1,
+        "INBOX_QUARANTINED",
+        {
+          topic: "chat",
+          inboxSeq: 3,
+          key: "k3",
+          messageId: "m3",
+          heldAt: 0,
+          operator: { actor: "op" },
+        },
+        { kernel: true }
+      ),
+      ev(
+        "v17",
+        2,
+        "INBOX_RELEASED",
+        {
+          topic: "chat",
+          key: "k3",
+          messageId: "m3",
+          disposition: "deliver",
+          auto: true,
+          operator: { actor: "op" },
+        },
+        { kernel: true }
+      ),
+      ev(
+        "v17",
+        3,
+        "INBOX_RELEASED",
+        { topic: "chat", key: "k3", messageId: "m3", disposition: "deliver" },
+        { kernel: true }
+      ),
+      ev("v17", 4, "INBOX_RELEASED", {
+        topic: "chat",
+        key: "k3",
+        messageId: "m3",
+        disposition: "deliver",
+        operator: { actor: "op" },
+      }),
+    ],
+    expected: {
+      status: "running",
+      sequence: 4,
+      variables: {
+        _input: {},
+        _inbox: { cursors: { chat: 3 }, dedupe: [] },
+        _quarantined: { chat: [{ key: "k3", inboxSeq: 3, heldAt: 0, state: "held" }] },
+      },
+      frames: {},
+    },
+  },
+  {
+    // D7: the envelope key `metadata.seal` is a marker the FOLD never reads, so the same log with and
+    // without it folds to the same state (this vector is the "with" half of the pair, v1 above is the
+    // "without").
+    name: "ADR 0130: metadata.seal is ignored by the fold (same state as the log without it)",
+    events: [
+      ev(
+        "v18",
+        0,
+        "EXECUTION_STARTED",
+        { input: { n: 1 } },
+        { seal: { v: 1, cipher: "loom/aes-256-gcm", covers: ["STEP_COMPLETED.output"] } }
+      ),
+      ev("v18", 1, "STEP_STARTED", { stepId: "a", input: { n: 1 } }),
+      ev(
+        "v18",
+        2,
+        "STEP_COMPLETED",
+        { stepId: "a", output: { n: 2 } },
+        { seal: { v: 1, cipher: "loom/aes-256-gcm", covers: ["STEP_COMPLETED.output"] } }
+      ),
+      ev("v18", 3, "EXECUTION_COMPLETED", { output: { n: 2 } }),
+    ],
+    expected: {
+      status: "completed",
+      sequence: 3,
+      variables: { _input: { n: 1 }, _output: { n: 2 } },
+      frames: { a: { status: "completed", attempts: 1 } },
+    },
+  },
+];
+
+/** Run the reference fold over every vector; returns per-vector pass/fail + detail. */
+export function runFoldVectors(vectors: readonly FoldVector[] = FOLD_VECTORS): Array<{
+  name: string;
+  passed: boolean;
+  detail?: string;
+}> {
+  return vectors.map((v) => {
+    const state = foldEvents(v.events);
+    const framesView: Record<string, { status: string; attempts: number }> = {};
+    for (const [k, f] of Object.entries(state.frames)) {
+      framesView[k] = { status: f.status, attempts: f.attempts };
+    }
+    const actual: FoldVector["expected"] = {
+      status: state.status,
+      sequence: state.sequence,
+      variables: state.variables,
+      frames: framesView,
+    };
+    if (v.expected.frameMeta !== undefined) {
+      const meta: Record<string, { firstSeq?: number; scope?: string }> = {};
+      for (const [k, f] of Object.entries(state.frames)) {
+        meta[k] = {
+          ...(f.firstSeq !== undefined && { firstSeq: f.firstSeq }),
+          ...(f.scope !== undefined && { scope: f.scope }),
+        };
+      }
+      actual.frameMeta = meta;
+    }
+    const passed = JSON.stringify(actual) === JSON.stringify(v.expected);
+    return passed
+      ? { name: v.name, passed }
+      : {
+          name: v.name,
+          passed,
+          detail: `expected ${JSON.stringify(v.expected)} got ${JSON.stringify(actual)}`,
+        };
+  });
+}