@sixb/core 0.1.18 → 0.1.19

package/src/testing/action-run-storage-contract.ts

@@ -0,0 +1,335 @@
+import { describe, expect, test } from "bun:test"
+import type {
+  ActionRunFailure,
+  ActionRunPhase,
+  ActionRunRecord,
+  RecordActionRunInput,
+  Storage,
+} from "../storage"
+import { ActionRunError } from "../storage"
+import {
+  createTestActionExecution,
+  createTestActionRunRecord,
+  recordTestActionRun,
+  type TestActionRunInput,
+} from "./action-execution"
+
+export type ActionRunStorageContractStorage = Storage & {
+  readonly actionRuns: NonNullable<Storage["actionRuns"]>
+}
+
+export interface ActionRunStorageContractSuiteOptions<
+  TStorage extends ActionRunStorageContractStorage = ActionRunStorageContractStorage,
+> {
+  readonly createStorage: () => TStorage | Promise<TStorage>
+  readonly cleanup?: (storage: TStorage) => void | Promise<void>
+}
+
+const projectId = "action-run-contract"
+const startedAt = new Date("2026-04-29T10:00:00.000Z")
+const finishedAt = new Date("2026-04-29T10:00:03.842Z")
+
+function failure<TPhase extends ActionRunPhase>(
+  runId: string,
+  phase: TPhase,
+  message: string
+): ActionRunFailure<TPhase> {
+  return {
+    code: "action.phase_failed",
+    message,
+    retryable: false,
+    at: finishedAt.toISOString(),
+    details: { actionId: "createInvoice", runId, phase },
+  }
+}
+
+type RunOverrides = Partial<
+  Pick<
+    TestActionRunInput,
+    "actionId" | "subject" | "phase" | "startedAt" | "finishedAt" | "writeback"
+  >
+> &
+  (
+    | { readonly status?: "succeeded"; readonly error?: never }
+    | { readonly status: "failed"; readonly error: ActionRunFailure }
+  )
+
+function run(id: string, overrides: RunOverrides = {}): TestActionRunInput {
+  return {
+    id,
+    projectId,
+    actionId: "createInvoice",
+    subject: { kind: "none" },
+    params: { amount: 42 },
+    idempotencyKey: `action:${projectId}:${id}`,
+    startedAt,
+    finishedAt,
+    ...overrides,
+  }
+}
+
+/** Runs the record-once Action run contract against one complete storage provider. */
+export function runActionRunStorageContractSuite<TStorage extends ActionRunStorageContractStorage>(
+  label: string,
+  options: ActionRunStorageContractSuiteOptions<TStorage>
+): void {
+  const withStorage = async (body: (storage: TStorage) => Promise<void>): Promise<void> => {
+    const storage = await options.createStorage()
+    try {
+      await body(storage)
+    } finally {
+      await options.cleanup?.(storage)
+    }
+  }
+
+  describe(label, () => {
+    test("records a terminal run once, and reads it back detached", async () => {
+      await withStorage(async (storage) => {
+        const input = await createTestActionRunRecord(
+          storage.executions,
+          run("act_1", {
+            subject: { kind: "object", objectTypeId: "Opportunity", primaryId: "opp-1" },
+            writeback: {
+              status: "succeeded",
+              completedAt: new Date("2026-04-29T10:00:01.000Z"),
+              result: { externalInvoiceId: "ext_1" },
+            },
+          })
+        )
+
+        const recorded = await storage.actionRuns.record(input)
+        const expected: ActionRunRecord = {
+          id: "act_1",
+          projectId,
+          executionId: "test_action_execution:act_1",
+          actionId: "createInvoice",
+          subject: { kind: "object", objectTypeId: "Opportunity", primaryId: "opp-1" },
+          status: "succeeded",
+          phase: "commit",
+          startedAt,
+          finishedAt,
+          params: { amount: 42 },
+          idempotencyKey: `action:${projectId}:act_1`,
+          writeback: {
+            status: "succeeded",
+            completedAt: new Date("2026-04-29T10:00:01.000Z"),
+            result: { externalInvoiceId: "ext_1" },
+          },
+        }
+        expect(recorded).toEqual(expected)
+        ;(recorded.params as { amount: number }).amount = 1
+        await expect(storage.actionRuns.getById({ projectId, id: "act_1" })).resolves.toEqual(
+          expected
+        )
+
+        await expect(storage.actionRuns.record(input)).rejects.toBeInstanceOf(ActionRunError)
+        await expect(
+          storage.actionRuns.record({ ...input, id: "act_2", idempotencyKey: "act_2" })
+        ).rejects.toBeInstanceOf(ActionRunError)
+        await expect(storage.actionRuns.getById({ projectId, id: "act_2" })).resolves.toBeNull()
+      })
+    })
+
+    test("requires the trusted execution created for the run", async () => {
+      await withStorage(async (storage) => {
+        const input = await createTestActionRunRecord(storage.executions, run("act_owned"))
+        await expect(
+          storage.actionRuns.record({ ...input, executionId: "missing" })
+        ).rejects.toThrow("does not authorize Action run")
+
+        const otherAction = await createTestActionExecution(storage.executions, {
+          projectId,
+          actionId: "otherAction",
+          runId: "act_other",
+        })
+        await expect(
+          storage.actionRuns.record({ ...input, executionId: otherAction })
+        ).rejects.toThrow("does not authorize Action run")
+        await expect(storage.actionRuns.getById({ projectId, id: "act_owned" })).resolves.toBeNull()
+      })
+    })
+
+    test("refuses a record a run cannot end with", async () => {
+      await withStorage(async (storage) => {
+        const succeeded = await createTestActionRunRecord(storage.executions, run("act_invalid"))
+        const writebackFailure = failure("act_invalid", "writeback", "Upstream rejected it")
+        const invalid: readonly RecordActionRunInput[] = [
+          { ...succeeded, phase: "effects" },
+          { ...succeeded, status: "failed", phase: "commit", error: writebackFailure },
+          {
+            ...succeeded,
+            status: "failed",
+            phase: "writeback",
+            error: failure("another-run", "writeback", "Upstream rejected it"),
+          },
+          { ...succeeded, finishedAt: new Date(startedAt.getTime() - 1) },
+        ]
+        for (const input of invalid) {
+          await expect(storage.actionRuns.record(input)).rejects.toThrow()
+        }
+        await expect(
+          storage.actionRuns.getById({ projectId, id: "act_invalid" })
+        ).resolves.toBeNull()
+      })
+    })
+
+    test("records a failure with the phase it ended in", async () => {
+      await withStorage(async (storage) => {
+        const error = failure("act_failed", "writeback", "TeamLeader API returned 503")
+        const recorded = await recordTestActionRun(
+          storage,
+          run("act_failed", {
+            status: "failed",
+            error,
+            writeback: { status: "failed", completedAt: finishedAt, error },
+          })
+        )
+
+        expect(recorded).toMatchObject({ status: "failed", phase: "writeback", error })
+        await expect(
+          storage.actionRuns.getById({ projectId, id: "act_failed" })
+        ).resolves.toMatchObject({
+          status: "failed",
+          phase: "writeback",
+          error,
+          writeback: { status: "failed", error },
+        })
+      })
+    })
+
+    test("records the effects of a run that committed, once", async () => {
+      await withStorage(async (storage) => {
+        await recordTestActionRun(storage, run("act_effects"))
+        const error = failure("act_effects", "effects", "Slack timed out")
+        const completedAt = new Date("2026-04-29T10:00:05.000Z")
+
+        const recorded = await storage.actionRuns.recordEffects({
+          id: "act_effects",
+          projectId,
+          status: "failed",
+          completedAt,
+          error,
+        })
+        expect(recorded).toMatchObject({
+          status: "succeeded",
+          phase: "effects",
+          effects: { status: "failed", completedAt, error },
+        })
+        expect(recorded.error).toBeUndefined()
+
+        // The same outcome again changes nothing, its completion time included.
+        await expect(
+          storage.actionRuns.recordEffects({
+            id: "act_effects",
+            projectId,
+            status: "failed",
+            completedAt: new Date("2026-04-29T10:00:06.000Z"),
+            error,
+          })
+        ).resolves.toEqual(recorded)
+        await expect(
+          storage.actionRuns.recordEffects({ id: "act_effects", projectId, status: "succeeded" })
+        ).rejects.toBeInstanceOf(ActionRunError)
+        await expect(storage.actionRuns.getById({ projectId, id: "act_effects" })).resolves.toEqual(
+          recorded
+        )
+      })
+    })
+
+    test("records effects only on a succeeded run in its commit phase", async () => {
+      await withStorage(async (storage) => {
+        await recordTestActionRun(storage, run("act_no_edits", { phase: "writeback" }))
+        await recordTestActionRun(
+          storage,
+          run("act_rejected", {
+            status: "failed",
+            error: failure("act_rejected", "commit", "Commit failed"),
+          })
+        )
+
+        for (const id of ["act_no_edits", "act_rejected", "act_missing"]) {
+          await expect(
+            storage.actionRuns.recordEffects({ id, projectId, status: "succeeded" })
+          ).rejects.toBeInstanceOf(ActionRunError)
+        }
+        await expect(
+          storage.actionRuns.getById({ projectId, id: "act_no_edits" })
+        ).resolves.toMatchObject({ phase: "writeback" })
+      })
+    })
+
+    test("lists runs with filters, in start order, by page", async () => {
+      await withStorage(async (storage) => {
+        const at = (minute: number) => new Date(Date.UTC(2026, 3, 29, 10, minute))
+        await recordTestActionRun(
+          storage,
+          run("act_1", {
+            subject: { kind: "object", objectTypeId: "Opportunity", primaryId: "opp-1" },
+            startedAt: at(0),
+            finishedAt: at(1),
+            status: "failed",
+            error: failure("act_1", "validation", "Invalid amount"),
+          })
+        )
+        await recordTestActionRun(
+          storage,
+          run("act_2", {
+            subject: { kind: "object", objectTypeId: "Opportunity", primaryId: "opp-2" },
+            startedAt: at(10),
+            finishedAt: at(11),
+          })
+        )
+        await recordTestActionRun(
+          storage,
+          run("act_3", { actionId: "closeOpportunity", startedAt: at(20), finishedAt: at(21) })
+        )
+
+        const succeeded = await storage.actionRuns.list({
+          projectId,
+          actionId: "createInvoice",
+          statuses: ["succeeded"],
+          startedAfter: at(5),
+          limit: 1,
+        })
+        expect(succeeded).toMatchObject({ total: 1, hasMore: false })
+        expect(succeeded.runs.map((recorded) => recorded.id)).toEqual(["act_2"])
+
+        const all = await storage.actionRuns.list({ projectId, order: "asc", limit: 2 })
+        expect(all).toMatchObject({ total: 3, hasMore: true })
+        expect(all.runs.map((recorded) => recorded.id)).toEqual(["act_1", "act_2"])
+
+        const latest = await storage.actionRuns.list({ projectId, startedBefore: at(15) })
+        expect(latest.runs.map((recorded) => recorded.id)).toEqual(["act_2", "act_1"])
+
+        const forObject = await storage.actionRuns.list({
+          projectId,
+          objectTypeId: "Opportunity",
+          primaryId: "opp-1",
+        })
+        expect(forObject.runs.map((recorded) => recorded.id)).toEqual(["act_1"])
+      })
+    })
+
+    test("drops a record written in a transaction that rolls back", async () => {
+      await withStorage(async (storage) => {
+        const input = await createTestActionRunRecord(storage.executions, run("act_rolled_back"))
+        await expect(
+          storage.transaction(async (tx) => {
+            await tx.actionRuns?.record(input)
+            throw new Error("rollback")
+          })
+        ).rejects.toThrow("rollback")
+        await expect(
+          storage.actionRuns.getById({ projectId, id: "act_rolled_back" })
+        ).resolves.toBeNull()
+
+        await storage.transaction(async (tx) => {
+          await tx.actionRuns?.record(input)
+        })
+        await expect(
+          storage.actionRuns.getById({ projectId, id: "act_rolled_back" })
+        ).resolves.toMatchObject({ status: "succeeded" })
+      })
+    })
+  })
+}

package/src/testing/index.ts

@@ -1,7 +1,14 @@
 export {
   createTestActionExecution,
-  queueTestActionRun,
+  createTestActionRunRecord,
+  recordTestActionRun,
+  type TestActionRunInput,
 } from "./action-execution"
+export {
+  type ActionRunStorageContractStorage,
+  type ActionRunStorageContractSuiteOptions,
+  runActionRunStorageContractSuite,
+} from "./action-run-storage-contract"
 export { createTestAgentExecution } from "./agent-execution"
 export {
   type AgentStorageContractSuiteOptions,

package/src/testing/materializer-storage-contract.ts

@@ -13,6 +13,7 @@ import {
 import type { TrustedPrimitiveRef } from "../execution"
 import { restoreTrustedPrimitiveExecutionScope } from "../execution/durable"
 import { createTestingScope } from "../execution/scopes"
+import { MaterializationConflictError } from "../materialization/errors"
 import type {
   ExpectedLinkRevision,
   ExpectedObjectRevision,
@@ -35,8 +36,13 @@ import type {
   PlannedReplacementIdentity,
   ProjectionExecution,
   ProjectionRunStorage,
+  RecordActionRunInput,
 } from "../storage"
-import { createTestActionExecution, queueTestActionRun } from "./action-execution"
+import {
+  createTestActionExecution,
+  createTestActionRunRecord,
+  recordTestActionRun,
+} from "./action-execution"
 import { createTestProjectionExecution, startTestProjectionRun } from "./projection-execution"
 
 export interface MaterializerStorageContractProvider<TStorage extends Storage> {
@@ -406,23 +412,29 @@ export function runMaterializerStorageContractSuite<TStorage extends Storage>(
         })
       ).toBeNull()
 
-      await createTestActionExecution(storage.executions, {
+      // A run id is recorded once, so a commit for a run that is already recorded commits nothing.
+      const recordedRun = {
+        id: "recorded-action-run",
         projectId: "materializer-storage-contract",
         actionId: "renameDevice",
-        runId: "missing-action-run",
-      })
-      const missingActionMaterializer = await primitiveMaterializer(materializer, storage, {
+        subject: { kind: "object", objectTypeId: Device.id, primaryId: "one" },
+        params: {},
+        idempotencyKey: "recorded-action-run",
+      } as const
+      await recordTestActionRun(storage, { ...recordedRun, phase: "validation" })
+      const recordedActionMaterializer = await primitiveMaterializer(materializer, storage, {
         kind: "action",
         id: "renameDevice",
-        runId: "missing-action-run",
+        runId: recordedRun.id,
       })
       await expect(
-        missingActionMaterializer.edits.commit({
+        recordedActionMaterializer.edits.commit({
           mode: "atomic",
-          source: { kind: "action", actionId: "renameDevice", runId: "missing-action-run" },
+          source: { kind: "action", actionId: "renameDevice", runId: recordedRun.id },
+          run: await createTestActionRunRecord(storage.executions, recordedRun),
           operations: [
             {
-              id: "missing-run-rename",
+              id: "recorded-run-rename",
               kind: "object.patch",
               ref: { objectTypeId: Device.id, primaryId: "one" },
               set: { name: "Must not persist" },
@@ -434,9 +446,15 @@ export function runMaterializerStorageContractSuite<TStorage extends Storage>(
           expectedLinks: [],
           expectedLinkScopes: [],
         })
-      ).rejects.toThrow("missing-action-run")
+      ).rejects.toThrow("recorded-action-run")
+      expect(
+        await storage.actionRuns.getById({
+          projectId: "materializer-storage-contract",
+          id: recordedRun.id,
+        })
+      ).toMatchObject({ phase: "validation" })
 
-      await queueTestActionRun(storage, {
+      const actionRun = await createTestActionRunRecord(storage.executions, {
         id: "action-run",
         projectId: "materializer-storage-contract",
         actionId: "renameDevice",
@@ -444,10 +462,6 @@ export function runMaterializerStorageContractSuite<TStorage extends Storage>(
         params: {},
         idempotencyKey: "action-run",
       })
-      await storage.actionRuns.start({
-        id: "action-run",
-        projectId: "materializer-storage-contract",
-      })
       const actionMaterializer = await primitiveMaterializer(materializer, storage, {
         kind: "action",
         id: "renameDevice",
@@ -456,6 +470,7 @@ export function runMaterializerStorageContractSuite<TStorage extends Storage>(
       const actionCommit = await actionMaterializer.edits.commit({
         mode: "atomic",
         source: { kind: "action", actionId: "renameDevice", runId: "action-run" },
+        run: actionRun,
         operations: [
           {
             id: "rename",
@@ -470,6 +485,13 @@ export function runMaterializerStorageContractSuite<TStorage extends Storage>(
         expectedLinks: [],
         expectedLinkScopes: [],
       })
+      // The commit recorded the run it carried, with its edits.
+      expect(
+        await storage.actionRuns.getById({
+          projectId: "materializer-storage-contract",
+          id: "action-run",
+        })
+      ).toMatchObject({ status: "succeeded", phase: "commit", executionId: actionRun.executionId })
       expect(
         await storage.ontology.commits.getByOrigin({
           projectId: "materializer-storage-contract",
@@ -941,7 +963,7 @@ export function runMaterializerStorageContractSuite<TStorage extends Storage>(
         })
       )
       const commitObservation = async (runId: string, name: string) => {
-        await queueTestActionRun(storage, {
+        const run = await createTestActionRunRecord(storage.executions, {
           id: runId,
           projectId: "materializer-storage-contract",
           actionId: "observePeers",
@@ -949,7 +971,6 @@ export function runMaterializerStorageContractSuite<TStorage extends Storage>(
           params: {},
           idempotencyKey: runId,
         })
-        await storage.actionRuns.start({ id: runId, projectId: "materializer-storage-contract" })
         const actionMaterializer = await primitiveMaterializer(materializer, storage, {
           kind: "action",
           id: "observePeers",
@@ -958,6 +979,7 @@ export function runMaterializerStorageContractSuite<TStorage extends Storage>(
         return actionMaterializer.edits.commit({
           mode: "atomic",
           source: { kind: "action", actionId: "observePeers", runId },
+          run,
           operations: [
             {
               id: `record-${runId}`,
@@ -1000,6 +1022,13 @@ export function runMaterializerStorageContractSuite<TStorage extends Storage>(
           primaryId: source.primaryId,
         })
       ).toMatchObject({ properties: { name: "observed peers" } })
+      // The conflict fails the commit after it inserted the run's record, which rolls back with it.
+      expect(
+        await storage.actionRuns.getById({
+          projectId: "materializer-storage-contract",
+          id: "stale-many-scope-action",
+        })
+      ).toBeNull()
     } finally {
       await provider.cleanup?.(createdStorage)
     }
@@ -1354,6 +1383,97 @@ export function runMaterializerStorageContractSuite<TStorage extends Storage>(
     }
   })
 
+  // Two processes can execute one run id, each under an execution of its own, and commit its edits
+  // at the same time: the second commit waits for the first, then replays it and is refused.
+  // Removal proof: drop `recordActionRun` from `executeEditTransaction`
+  // (`materializer/edits/commit.ts`), and no record holds the run that committed.
+  if (provider.concurrentTransactions) {
+    test(`${name} commits a run id once when two of its executions commit together`, async () => {
+      const createdStorage = await provider.createStorage()
+      const storage = requireContractStorage(createdStorage)
+      const primitive = { kind: "action", id: "createDevice", runId: "shared-run" } as const
+      const scopeOf = async (executionId: string) => {
+        const execution = await storage.executions.getById({
+          projectId: CONTRACT_PROJECT,
+          id: executionId,
+        })
+        if (!execution) throw new Error(`Test execution '${executionId}' is missing.`)
+        return restoreTrustedPrimitiveExecutionScope({ execution, primitive })
+      }
+      const commitOf = (run: RecordActionRunInput, primaryId: string) => ({
+        mode: "atomic" as const,
+        source: { kind: "action" as const, actionId: "createDevice", runId: "shared-run" },
+        run,
+        operations: [
+          {
+            id: "create",
+            kind: "object.create" as const,
+            ref: deviceRef(primaryId),
+            properties: { id: primaryId, name: primaryId },
+          },
+        ],
+        expectedObjects: [],
+        expectedLinks: [],
+        expectedLinkScopes: [],
+      })
+      try {
+        const firstRun = await createTestActionRunRecord(storage.executions, {
+          id: "shared-run",
+          projectId: CONTRACT_PROJECT,
+          actionId: "createDevice",
+          subject: { kind: "none" },
+          params: {},
+          idempotencyKey: "shared-run",
+        })
+        const secondRun = {
+          ...firstRun,
+          executionId: await createTestActionExecution(storage.executions, {
+            projectId: CONTRACT_PROJECT,
+            actionId: "createDevice",
+            runId: "shared-run",
+            executionId: "shared-run-second",
+          }),
+        }
+        const paused = pauseBeforeFinalize(storage)
+        const first = contractMaterializer(paused.storage)
+          .withScope(await scopeOf(firstRun.executionId))
+          .edits.commit(commitOf(firstRun, "first"))
+        // It has recorded the run and holds its transaction open.
+        await paused.reached
+
+        let retries = 0
+        const recording = observeActionRunRecords(storage)
+        const second = contractMaterializer(recording.storage, {}, () => {
+          retries += 1
+        })
+          .withScope(await scopeOf(secondRun.executionId))
+          .edits.commit(commitOf(secondRun, "second"))
+          .then(
+            () => null,
+            (error: unknown) => error
+          )
+        // Its transaction reads before the first one commits, and then records the run too.
+        await recording.reached
+        paused.release()
+
+        await expect(first).resolves.toMatchObject({ created: true })
+        const refused = await second
+        expect(refused).toBeInstanceOf(MaterializationConflictError)
+        expect(refused instanceof MaterializationConflictError ? refused.kind : refused).toBe(
+          "idempotency"
+        )
+        expect(retries).toBeGreaterThan(0)
+        expect(
+          await storage.actionRuns.getById({ projectId: CONTRACT_PROJECT, id: "shared-run" })
+        ).toMatchObject({ executionId: firstRun.executionId })
+        expect(await device(storage, "first")).not.toBeNull()
+        expect(await device(storage, "second")).toBeNull()
+      } finally {
+        await provider.cleanup?.(createdStorage)
+      }
+    })
+  }
+
   // Removal proof: in PostgreSQL's `committedSince`, count only commits at or past the
   // watermark's xmax; the edit, in flight when the plan opened, is then taken as seen.
   if (provider.concurrentTransactions) {
@@ -1907,7 +2027,8 @@ const CONTRACT_PROJECT = "materializer-storage-contract"
 
 function contractMaterializer(
   storage: Storage,
-  batching: { readonly transactionReplanRows?: number } = {}
+  batching: { readonly transactionReplanRows?: number } = {},
+  onSerializationRetry?: () => void
 ): OntologyMaterializer {
   return createOntologyMaterializer({
     projectId: CONTRACT_PROJECT,
@@ -1916,6 +2037,7 @@ function contractMaterializer(
     storage,
     dependencies: {
       batching: { sourceStageRows: 1, statePageRows: 1, planChunkRows: 1, ...batching },
+      ...(onSerializationRetry === undefined ? {} : { onSerializationRetry }),
     },
   })
 }
@@ -1986,6 +2108,40 @@ function observePlanning(
 }
 
 /** The same storage, whose transactions wait before they finalize until `release` is called. */
+/** Resolves `reached` when a transaction of `storage` first records an Action run. */
+function observeActionRunRecords(storage: ContractStorage) {
+  const reached = Promise.withResolvers<void>()
+  const observed = new Proxy(storage, {
+    get(target, property) {
+      if (property !== "transaction") {
+        const value = Reflect.get(target, property, target)
+        return typeof value === "function" ? value.bind(target) : value
+      }
+      return (run: (tx: Storage) => unknown, options?: Parameters<Storage["transaction"]>[1]) =>
+        target.transaction((tx) => {
+          const actionRuns = tx.actionRuns
+          if (!actionRuns) return run(tx)
+          const recording: ActionRunStorage = {
+            record: (input) => {
+              reached.resolve()
+              return actionRuns.record(input)
+            },
+            recordEffects: (input) => actionRuns.recordEffects(input),
+            getById: (input) => actionRuns.getById(input),
+            list: (input) => actionRuns.list(input),
+          }
+          return run(
+            new Proxy(tx, {
+              get: (store, key) =>
+                key === "actionRuns" ? recording : Reflect.get(store, key, store),
+            })
+          )
+        }, options)
+    },
+  })
+  return { storage: observed, reached: reached.promise }
+}
+
 function pauseBeforeFinalize(storage: ContractStorage) {
   let reach!: () => void
   const reached = new Promise<void>((resolve) => {

package/src/testing/queues-contract.ts

@@ -388,17 +388,6 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
               },
             ],
           })
-          await queues.actions.enqueue({
-            projectId: "project-a",
-            jobs: [
-              {
-                type: "action.run.requested",
-                payload: {
-                  runId: "act_1",
-                },
-              },
-            ],
-          })
           await queues.agents.enqueue({
             projectId: "project-a",
             jobs: [
@@ -433,11 +422,6 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
             workerId: "workflow-worker-1",
             limit: 10,
           })
-          const actionLane = await queues.actions.claim({
-            projectId: "project-a",
-            workerId: "action-worker-1",
-            limit: 10,
-          })
           const agentLane = await queues.agents.claim({
             projectId: "project-a",
             workerId: "agent-worker-1",
@@ -460,8 +444,6 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
           expect(projectionLane[0]?.job.payload.runId).toBe("projection-run-1")
           expect(workflowLane).toHaveLength(1)
           expect(workflowLane[0]?.job.payload.runId).toBe("workflow-run-1")
-          expect(actionLane).toHaveLength(1)
-          expect(actionLane[0]?.job.payload.runId).toBe("act_1")
           expect(agentLane).toHaveLength(1)
           expect(agentLane[0]?.job).toMatchObject({
             type: "agent.run.requested",