@sixb/core 0.1.10 → 0.1.12

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

@@ -290,6 +290,252 @@ export function runAgentStorageContractSuite<TStorage extends AgentStorageContra
   }
 
   describe(label, () => {
+    test("replaces lost state only under its current execution fence", async () => {
+      // Regression proof: remove replace's name/owner guards; the stale attempts succeed.
+      await withStorage(async (storage, fixture) => {
+        await storage.threads.create(threadInput({ sandboxParams: {} }))
+        const run = runInput({ execution: execution("first", new Date("2099-01-01")) })
+        await createAndStartRun(storage, fixture, run)
+        const acquire = {
+          projectId,
+          id: "thr_1",
+          action: "acquire" as const,
+          runId: run.id,
+          executionToken: "first",
+          name: "name-1",
+          sourceFingerprint: "a".repeat(64),
+        }
+        await storage.threads.transitionSandbox(acquire)
+        const replace = { ...acquire, action: "replace" as const, nextName: "name-2" }
+        await expectAgentError(storage.threads.transitionSandbox(replace), "invalid_state")
+        await storage.threads.transitionSandbox({
+          ...acquire,
+          action: "settle",
+          status: "ready",
+          initialized: true,
+        })
+        await expectAgentError(storage.threads.transitionSandbox(replace), "invalid_state")
+        await storage.threads.transitionSandbox(acquire)
+        for (const nextName of ["name-1", "../invalid", ""]) {
+          await expectAgentError(
+            storage.threads.transitionSandbox({ ...replace, nextName }),
+            "invalid_state"
+          )
+        }
+        await expectAgentError(
+          storage.threads.transitionSandbox({ ...replace, executionToken: "stale" }),
+          "execution_lost"
+        )
+        const replacement = await storage.threads.transitionSandbox(replace)
+        const resetAt = replacement.resetAt
+        expect(replacement).toMatchObject({
+          name: "name-2",
+          status: "busy",
+          initialized: false,
+          owner: { runId: run.id, executionToken: "first" },
+          sourceFingerprint: acquire.sourceFingerprint,
+          resetAt: expect.any(String),
+        })
+        await expectAgentError(storage.threads.transitionSandbox(replace), "invalid_state")
+        await expectAgentError(
+          storage.threads.transitionSandbox({
+            ...acquire,
+            action: "settle",
+            status: "ready",
+            initialized: true,
+          }),
+          "invalid_state"
+        )
+        await storage.threads.transitionSandbox({
+          ...acquire,
+          name: "name-2",
+          action: "settle",
+          status: "ready",
+          initialized: true,
+        })
+        const resumed = await storage.threads.transitionSandbox({
+          ...acquire,
+          name: "name-2",
+        })
+        expect(resumed.resetAt).toBe(resetAt)
+        expect((await storage.threads.getById({ projectId, id: "thr_1" }))?.sandboxState).toEqual(
+          resumed
+        )
+      })
+    })
+
+    test("fences workspace ownership across reclamation and explicit recreation", async () => {
+      // Regression proof: remove the busy-state or owner-token checks in transitionAgentThreadSandbox.
+      await withStorage(async (storage, fixture) => {
+        await storage.threads.create(threadInput({ sandboxParams: {} }))
+        const input = runInput({ execution: execution("first", new Date("2099-01-01")) })
+        await createTestAgentExecution(fixture, {
+          projectId,
+          runId: input.id,
+          executionId: input.executionId,
+          authority: "inherited",
+        })
+        await storage.runs.create(input)
+        await storage.runs.start(input)
+        const acquire = {
+          projectId,
+          id: "thr_1",
+          action: "acquire" as const,
+          runId: input.id,
+          executionToken: "first",
+          name: "name-1",
+          sourceFingerprint: "a".repeat(64),
+        }
+        const attempts = await Promise.allSettled([
+          storage.threads.transitionSandbox(acquire),
+          storage.threads.transitionSandbox(acquire),
+        ])
+        expect(attempts.filter((attempt) => attempt.status === "fulfilled")).toHaveLength(1)
+        expect(
+          (await storage.threads.getById({ projectId, id: "thr_1" }))?.sandboxState
+        ).toMatchObject({ status: "busy", initialized: false })
+        await expectAgentError(storage.threads.transitionSandbox(acquire), "invalid_state")
+        await storage.runs.reclaim({
+          projectId,
+          id: input.id,
+          execution: execution("second", new Date("2099-01-01")),
+        })
+        await expectAgentError(
+          storage.threads.transitionSandbox({
+            ...acquire,
+            executionToken: "second",
+          }),
+          "invalid_state"
+        )
+        await expectAgentError(
+          storage.threads.transitionSandbox({
+            ...acquire,
+            action: "settle",
+            status: "ready",
+            initialized: true,
+          }),
+          "execution_lost"
+        )
+        const recreate = {
+          projectId,
+          id: "thr_1",
+          action: "recreate" as const,
+          expectedSandboxName: "name-1",
+          name: "name-2",
+        }
+        await expectAgentError(storage.threads.transitionSandbox(recreate), "invalid_state")
+        await storage.runs.finish({
+          projectId,
+          id: input.id,
+          executionToken: "second",
+          status: "failed",
+        })
+        expect(await storage.threads.transitionSandbox(recreate)).toEqual({
+          name: "name-2",
+          status: "new",
+          initialized: false,
+          resetAt: expect.any(String),
+        })
+        await expectAgentError(storage.threads.transitionSandbox(recreate), "invalid_state")
+      })
+    })
+
+    test("resumes only confirmed workspace state with the pinned source", async () => {
+      await withStorage(async (storage, fixture) => {
+        await storage.threads.create(threadInput({ sandboxParams: {} }))
+        const input = runInput({ execution: execution("owner", new Date("2099-01-01")) })
+        await createTestAgentExecution(fixture, {
+          projectId,
+          runId: input.id,
+          executionId: input.executionId,
+          authority: "inherited",
+        })
+        await storage.runs.create(input)
+        await storage.runs.start(input)
+        const acquire = {
+          projectId,
+          id: "thr_1",
+          action: "acquire" as const,
+          runId: input.id,
+          executionToken: "owner",
+          name: "name",
+          sourceFingerprint: "b".repeat(64),
+        }
+        await storage.threads.transitionSandbox(acquire)
+        await storage.threads.transitionSandbox({
+          ...acquire,
+          action: "settle",
+          status: "ready",
+          initialized: true,
+        })
+        await expectAgentError(
+          storage.threads.transitionSandbox({
+            ...acquire,
+            sourceFingerprint: "c".repeat(64),
+          }),
+          "invalid_state"
+        )
+        expect(await storage.threads.transitionSandbox(acquire)).toMatchObject({
+          status: "busy",
+          initialized: true,
+        })
+      })
+    })
+
+    test("snapshots workspace bindings without accepting runtime state or credentials", async () => {
+      // Regression proof: remove snapshotAgentThreadSandboxParams from a provider's thread create.
+      await withStorage(async (storage) => {
+        const sandboxParams = { clientId: "acme", nested: { branch: "main" } }
+        const record = await storage.threads.create(threadInput({ sandboxParams }))
+        sandboxParams.nested.branch = "changed"
+        const read = await storage.threads.getById({ projectId, id: record.id })
+        expect(read?.sandboxParams).toEqual({ clientId: "acme", nested: { branch: "main" } })
+        const mutable = record.sandboxParams?.nested
+        if (mutable && typeof mutable === "object" && !Array.isArray(mutable))
+          mutable.branch = "tampered"
+        expect((await storage.threads.list({ projectId })).threads[0]?.sandboxParams).toEqual(
+          read?.sandboxParams
+        )
+        await expectAgentError(
+          storage.threads.create(
+            threadInput({
+              id: "unsafe",
+              // @ts-expect-error storage requires a JSON object
+              sandboxParams: [],
+            })
+          ),
+          "invalid_input"
+        )
+        await expectAgentError(
+          storage.threads.create(
+            threadInput({
+              id: "non-json",
+              // @ts-expect-error storage accepts normalized JSON, not typed Dates
+              sandboxParams: { at: new Date() },
+            })
+          ),
+          "invalid_input"
+        )
+      })
+    })
+
+    test("keeps delimiter-containing project and sandbox thread ids distinct", async () => {
+      // Regression proof: change the memory store key back to projectId + ":" + id.
+      await withStorage(async (storage) => {
+        await storage.threads.create(
+          threadInput({ projectId: "a:b", id: "c", sandboxParams: { repo: "one" } })
+        )
+        await storage.threads.create(
+          threadInput({ projectId: "a", id: "b:c", sandboxParams: { repo: "two" } })
+        )
+        expect(
+          (await storage.threads.getById({ projectId: "a:b", id: "c" }))?.sandboxParams?.repo
+        ).toBe("one")
+        expect(
+          (await storage.threads.getById({ projectId: "a", id: "b:c" }))?.sandboxParams?.repo
+        ).toBe("two")
+      })
+    })
     // ── threads ───────────────────────────────────────────────────────────────────────────────
 
     test("creates threads, isolates projects, and rejects duplicate ids", async () => {

package/src/testing/ai-cost-storage-contract.ts

@@ -236,8 +236,22 @@ export function runAiCostStorageContractSuite<TStorage extends AiCostStorage>(
             inputTokens: 15,
             outputTokens: 12,
             totalTokens: 27,
+            uncachedInputTokens: 12,
+            cacheReadInputTokens: 0,
             reportingStatus: "complete",
           },
+          usageCoverage: {
+            completeCallCount: 3,
+            fieldCallCounts: {
+              inputTokens: 3,
+              outputTokens: 3,
+              uncachedInputTokens: 1,
+              cacheReadInputTokens: 1,
+              cacheWriteInputTokens: 0,
+              textOutputTokens: 0,
+              reasoningOutputTokens: 0,
+            },
+          },
           costs: {
             amounts: [{ currency: "USD", amountNanos: "95000" }],
             ratedCallCount: 1,
@@ -290,6 +304,85 @@ export function runAiCostStorageContractSuite<TStorage extends AiCostStorage>(
       }
     })
 
+    test("retains known tokens and coverage across incomplete periods", async () => {
+      // Removal proof: require presentCallCount === modelCallCount in finishAggregateUsage.
+      // Both the in-memory and SQL-backed contract runs then lose the Sep 16/18 totals.
+      const storage = await fixture()
+      try {
+        // Currency fragments must merge coverage and usage exactly once per call.
+        for (const [index, currency] of ["USD", "EUR"].entries()) {
+          await storage.recordModelCallCost(
+            ratedCost(`partial_16_${index}`, {
+              components: [],
+              money: { currency, amountNanos: "1" },
+              priceSource: { ...priceSource(`partial_${index}`), sourceId: "provider-reported" },
+            })
+          )
+        }
+        const overview = await storage.queryProjectOverview({
+          projectId,
+          from: new Date("2026-09-16"),
+          to: new Date("2026-09-19"),
+          bucket: "day",
+        })
+        expect(
+          overview.series.map((period) => ({
+            calls: period.modelCallCount,
+            total: period.usage.totalTokens,
+            complete: period.usageCoverage.completeCallCount,
+          }))
+        ).toEqual([
+          { calls: 87, total: 4_013_782, complete: 84 },
+          { calls: 0, total: undefined, complete: 0 },
+          { calls: 29, total: 334_815, complete: 28 },
+        ])
+        for (const aggregate of [overview.totals, ...overview.models, ...overview.workflows]) {
+          expect(aggregate.usage).toEqual({
+            inputTokens: 4_348_597,
+            outputTokens: 0,
+            totalTokens: 4_348_597,
+            reportingStatus: "partial",
+          })
+          expect(aggregate.usageCoverage).toMatchObject({
+            completeCallCount: 112,
+            fieldCallCounts: { inputTokens: 112, outputTokens: 112, cacheReadInputTokens: 0 },
+          })
+        }
+        expect(overview.totals.costs.amounts).toEqual([
+          { currency: "EUR", amountNanos: "1" },
+          { currency: "USD", amountNanos: "1" },
+        ])
+        const edges = await storage.queryProjectOverview({
+          projectId,
+          from: new Date("2026-09-19"),
+          to: new Date("2026-09-22"),
+          bucket: "day",
+          providerId: "gateway",
+          modelId: "partial/model",
+        })
+        expect(edges.series[0]).toMatchObject({
+          usage: { inputTokens: 3, outputTokens: 4, totalTokens: 7, reportingStatus: "partial" },
+          usageCoverage: {
+            completeCallCount: 0,
+            fieldCallCounts: { inputTokens: 1, outputTokens: 1 },
+          },
+        })
+        expect(edges.series[1]).toMatchObject({
+          modelCallCount: 1,
+          usage: { reportingStatus: "unavailable" },
+          usageCoverage: { completeCallCount: 0 },
+        })
+        expect(edges.series[1]?.usage.totalTokens).toBeUndefined()
+        expect(edges.series[2]).toMatchObject({
+          usage: { inputTokens: 0, totalTokens: 0, reportingStatus: "partial" },
+          usageCoverage: { completeCallCount: 0 },
+        })
+        expect(edges.series[2]?.usage.outputTokens).toBeUndefined()
+      } finally {
+        await options.cleanup?.(storage)
+      }
+    })
+
     test("rejects missing usage and mismatched billed quantities", async () => {
       const storage = await fixture()
       try {
@@ -405,4 +498,45 @@ export async function seedAiCostStorageContractUsage(
     occurredAt: new Date("2026-08-03T12:00:00.000Z"),
     recordedAt: new Date("2026-08-03T12:00:00.100Z"),
   })
+
+  for (const [day, calls, complete, tokens] of [
+    [16, 87, 84, 4_013_782],
+    [18, 29, 28, 334_815],
+  ] as const) {
+    for (let index = 0; index < calls; index++) {
+      await usage.recordModelCall({
+        id: `partial_${day}_${index}`,
+        projectId,
+        executionId: otherExecutionId,
+        attempt: 1,
+        callId: `partial_${day}_${index}`,
+        responseId: `response_partial_${day}_${index}`,
+        requesterGroupIds: [],
+        providerId: "gateway",
+        requestedModelId: "partial/model",
+        usage: index < complete ? { inputTokens: index === 0 ? tokens : 0, outputTokens: 0 } : {},
+        occurredAt: new Date(`2026-09-${day}T12:00:00Z`),
+      })
+    }
+  }
+  for (const [index, day, counts] of [
+    [0, 19, { inputTokens: 3 }],
+    [1, 19, { outputTokens: 4 }],
+    [2, 20, {}],
+    [3, 21, { inputTokens: 0 }],
+  ] as const) {
+    await usage.recordModelCall({
+      id: `edge_${index}`,
+      projectId,
+      executionId: otherExecutionId,
+      attempt: 1,
+      callId: `edge_${index}`,
+      responseId: `response_edge_${index}`,
+      requesterGroupIds: [],
+      providerId: "gateway",
+      requestedModelId: "partial/model",
+      usage: counts,
+      occurredAt: new Date(`2026-09-${day}T12:00:00Z`),
+    })
+  }
 }

package/src/testing/connector-connection-storage-contract.ts

@@ -486,25 +486,25 @@ export function runConnectorConnectionStorageContractSuite<
       })
     })
 
-    test("commits expiry cleanup before rejecting account selection", async () => {
+    test("allows account selection after its legacy deadline", async () => {
       await withStorage(async (storage, root) => {
         const authorization = await createAuthorization(storage, "authorization-a", "account-a")
-        await options.advanceTime(root, 60_000)
+        await options.advanceTime(root, 365 * 24 * 60 * 60_000)
 
-        await expect(connect(storage, authorization, "connection-a", "account-a")).rejects.toThrow(
-          "selectable authorization"
-        )
+        await expect(
+          connect(storage, authorization, "connection-a", "account-a")
+        ).resolves.toMatchObject({ connection: { status: "connected" } })
         await expect(
           storage.getAuthorization(authorizationKey(authorization.id))
-        ).resolves.toMatchObject({ status: "revocation_pending" })
+        ).resolves.toMatchObject({ status: "active" })
       })
     })
 
-    test("commits lazy run expiry before rejecting a late selection", async () => {
+    test("keeps account-selection runs selectable after their legacy deadline", async () => {
       await withStorage(async (storage, root) => {
         const authorization = await createAuthorization(storage, "authorization-a", "account-a")
         await createSelectionRun(storage, authorization)
-        await options.advanceTime(root, 60_000)
+        await options.advanceTime(root, 365 * 24 * 60 * 60_000)
 
         await expect(
           storage.putConnectionFromRun({
@@ -515,13 +515,13 @@ export function runConnectorConnectionStorageContractSuite<
             account: { id: "account-a", label: "Account A" },
             replace: false,
           })
-        ).rejects.toThrow("invalid, expired, or already used")
+        ).resolves.toMatchObject({ run: { status: "succeeded" } })
         await expect(
           storage.getConnectionRun({ projectId, connectorId, runId: "run-a" })
-        ).resolves.toMatchObject({ status: "expired" })
+        ).resolves.toMatchObject({ status: "succeeded" })
         await expect(
           storage.getAuthorization(authorizationKey(authorization.id))
-        ).resolves.toMatchObject({ status: "revocation_pending" })
+        ).resolves.toMatchObject({ status: "active" })
       })
     })
 

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

@@ -285,6 +285,35 @@ export function runLakeStorageContractSuite<TStorage extends LakeStorage>(
     })
 
     describe("writes and reads", () => {
+      test("cancels reads before starting and between rows", async () => {
+        // Red check: remove readRows' signal checks in the provider under test.
+        await withStorage(async (storage) => {
+          await storage.createDataset(writeDataset)
+          const write = await storage.beginWrite({ dataset: writeDataset, mode: "snapshot" })
+          await write.writeRows([
+            { orderId: "1", customerName: "first" },
+            { orderId: "2", customerName: "second" },
+          ])
+          await write.commit()
+          const controller = new AbortController()
+          const rows = storage
+            .readRows({ datasetId: writeDataset.id, signal: controller.signal })
+            [Symbol.asyncIterator]()
+          try {
+            expect((await rows.next()).done).toBe(false)
+            controller.abort(new Error("cancel dataset read"))
+            await expect(rows.next()).rejects.toThrow("cancel dataset read")
+            await expect(
+              collectRows(
+                storage.readRows({ datasetId: writeDataset.id, signal: controller.signal })
+              )
+            ).rejects.toThrow("cancel dataset read")
+          } finally {
+            await rows.return?.()
+          }
+        })
+      })
+
       test("keeps immutable-version row order and offsets stable", async () => {
         await withStorage(async (storage) => {
           await storage.createDataset(writeDataset)

package/src/testing/object-query-contract.ts

@@ -10,6 +10,7 @@ import {
   normalizeObjectQuery,
   type ObjectQuery,
   ObjectQueryPlanningError,
+  planObjectQuery,
   validateObjectQuery,
 } from "../objects/query"
 import { defineObjectType, link, OntologyRegistry, prop, stringEnum } from "../ontology"
@@ -85,16 +86,11 @@ const Room = defineObjectType({
       { type: "map", keySchema: "string", valueSchema: "string" },
       { query: { searchable: true, filterable: true } }
     ),
-    prop(
-      "embedding",
-      { type: "array", items: "double" },
-      { query: { searchable: true, vector: true } }
-    ),
+    prop("embedding", { type: "array", items: "double" }, { query: { searchable: true } }),
   ],
   links: [link("hasDevice", Device)],
   search: {
     defaultText: ["name", "description"],
-    vector: { property: "embedding", source: ["name", "description"] },
   },
 })
 
@@ -1174,34 +1170,54 @@ export function runObjectQueryProviderContractSuite<TStorage extends Storage>(
       })
     })
 
-    test("executes or rejects vector search according to provider capabilities", async () => {
-      await withStorage(async ({ objects: storage, fixture }) => {
-        await seedObjectQueryContractData(fixture)
+    test("plans or rejects vector search according to provider capabilities", async () => {
+      await withStorage(async ({ objects: storage }) => {
+        // Keep generic fixture writes usable by providers without vector persistence.
+        const ontology = new OntologyRegistry({
+          sources: [
+            Device,
+            defineObjectType({
+              ...Room,
+              search: {
+                vectors: {
+                  content: {
+                    source: ["name", "description"],
+                    model: {
+                      providerId: "test",
+                      modelId: "embedding",
+                      definition: {
+                        kind: "embedding",
+                        providerId: "test",
+                        modelId: "embedding",
+                        dimensions: 2,
+                      },
+                    },
+                  },
+                },
+              },
+            }),
+          ],
+        })
         const query: ObjectQuery = {
           kind: "vector",
-          propertyId: "embedding",
+          profile: "content",
           vector: [1, 0],
           k: 2,
           input: { kind: "start", objectTypeId: Room.id },
         }
 
+        // Native vector execution is covered by the dedicated vector-search suite.
+        const validated = validateObjectQuery(query, { ontology })
+        const plan = planObjectQuery(validated.query, {
+          capabilities: storage.queryCapabilities(),
+          hasQueryObjects: typeof storage.queryObjects === "function",
+        })
         if (storage.queryCapabilities().nodes?.vector === true) {
-          const result = await executeObjectQuery(
-            { projectId, query },
-            { ontology: objectQueryContractOntology, storage }
-          )
-          expect(result.plan.mode).toBe("pushdown")
-          expect(ids(result)).toEqual(["room-alpha", "room-beta"])
-          return
+          expect(plan.mode).toBe("pushdown")
+        } else {
+          expect(plan.mode).toBe("rejected")
+          expect(plan.issues.map((issue) => issue.code)).toContain("query_node_not_supported")
         }
-
-        await expectPlanningIssue(
-          executeObjectQuery(
-            { projectId, query },
-            { ontology: objectQueryContractOntology, storage }
-          ),
-          "query_node_not_supported"
-        )
       })
     })
 

package/src/testing/object-read-scope-contract.ts

@@ -70,11 +70,7 @@ const Proposal = defineObjectType({
     }),
     prop("rank", "double", { query: { searchable: true, filterable: true, sortable: true } }),
     prop("category", "string", { query: { searchable: true, filterable: true, facet: true } }),
-    prop(
-      "embedding",
-      { type: "array", items: "double" },
-      { query: { searchable: true, vector: true } }
-    ),
+    prop("embedding", { type: "array", items: "double" }, { query: { searchable: true } }),
     prop("secret", "string", { query: { searchable: true, filterable: true, facet: true } }),
   ],
   links: [

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

@@ -677,7 +677,10 @@ export function runOntologyStorageContractSuite<TStorage extends OntologyStorage
       })
     })
 
-    test("keeps batch outbox settlement atomic when callers catch a stale lease", async () => {
+    test.each([
+      "root",
+      "transaction",
+    ] as const)("keeps %s batch outbox settlement atomic when callers catch a stale lease", async (boundary) => {
       await withStorage(async (storage) => {
         await commitExactObject(storage, "lease-atomic-a")
         await commitExactObject(storage, "lease-atomic-b")
@@ -699,7 +702,7 @@ export function runOntologyStorageContractSuite<TStorage extends OntologyStorage
         const untouched = claimed.find((row) => row.envelope.id !== reclaimed!.envelope.id)!
 
         let conflict: unknown
-        await storage.transaction(async (tx) => {
+        const settle = async (tx: OntologyContractStorage) => {
           try {
             await tx.ontology.outbox.markPublished({
               projectId: "contract-project",
@@ -710,7 +713,9 @@ export function runOntologyStorageContractSuite<TStorage extends OntologyStorage
           } catch (error) {
             conflict = error
           }
-        })
+        }
+        if (boundary === "transaction") await storage.transaction(settle)
+        else await settle(storage)
         expect(conflict).toMatchObject({ kind: "outbox-lease" })
 
         await storage.ontology.outbox.markPublished({

package/src/testing/queues-contract.ts

@@ -54,6 +54,37 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
   }
 
   describe(label, () => {
+    test("vector indexing has independent delivery capacity and idempotent generation ids", async () => {
+      await withQueues(async (queues) => {
+        const jobs = [
+          {
+            id: "generation-1",
+            type: "vector.index.requested" as const,
+            payload: { indexingId: "generation-1" },
+          },
+        ]
+        await queues.vectorIndexing.enqueue({ projectId: "project-a", jobs })
+        await queues.vectorIndexing.enqueue({ projectId: "project-a", jobs })
+        expect(
+          await queues.projections.claim({ projectId: "project-a", workerId: "projection" })
+        ).toHaveLength(0)
+        const claimed = await queues.vectorIndexing.claim({
+          projectId: "project-a",
+          workerId: "indexing",
+          limit: 2,
+        })
+        expect(claimed).toHaveLength(1)
+        expect(claimed[0]!.job.payload).toEqual({ indexingId: "generation-1" })
+        await queues.vectorIndexing.complete({
+          projectId: "project-a",
+          jobId: claimed[0]!.job.id,
+          leaseId: claimed[0]!.leaseId,
+        })
+        expect(
+          await queues.vectorIndexing.claim({ projectId: "project-a", workerId: "indexing" })
+        ).toHaveLength(0)
+      })
+    })
     describe("enqueue", () => {
       test("returns envelopes with generated id, createdAt, availableAt, attempt=0", async () => {
         await withQueues(async (queues) => {