@fabric-harness/sdk 1.14.0 → 2.0.0

package/dist/submission-store-contract.js

@@ -0,0 +1,730 @@
+/**
+ * Shared contract tests for {@link AgentSubmissionStore} implementations.
+ *
+ * Store packages call {@link defineSubmissionStoreContractTests} with a
+ * factory that creates their backend. The tests exercise every method on
+ * `AgentSubmissionStore` with identical behavioral assertions regardless of
+ * the underlying storage engine — no store-specific assumptions.
+ *
+ * @example
+ * ```ts
+ * import { defineSubmissionStoreContractTests } from '@fabric-harness/sdk/testing';
+ *
+ * defineSubmissionStoreContractTests('My backend', async () => ({
+ *   store: await createMyStore(),
+ *   close: async () => myStore.close(),
+ * }));
+ * ```
+ */
+import { afterEach, describe, expect, it } from 'vitest';
+// ─── Fixtures ───────────────────────────────────────────────────────────────
+const SESSION_ID = 'agent:assistant:agent-1:default';
+function dispatchInput(overrides = {}) {
+    return {
+        dispatchId: 'dispatch-1',
+        agent: 'assistant',
+        id: 'agent-1',
+        session: 'default',
+        message: { kind: 'signal', type: 'test.event', body: 'Hello' },
+        input: null,
+        acceptedAt: '2026-06-03T00:00:00.000Z',
+        ...overrides,
+    };
+}
+function directInput(overrides = {}) {
+    return {
+        kind: 'direct',
+        submissionId: 'direct-1',
+        agent: 'assistant',
+        id: 'agent-1',
+        session: 'default',
+        message: { kind: 'user', body: 'Hello' },
+        acceptedAt: Date.parse('2026-06-03T00:00:00.000Z'),
+        ...overrides,
+    };
+}
+function attempt(submissionId, attemptId) {
+    return { submissionId, attemptId };
+}
+function claim(submissionId, attemptId, ownerId = 'test-owner') {
+    return { submissionId, attemptId, ownerId, leaseExpiresAt: Date.now() + 30_000 };
+}
+function settlementRecord(outcome, submissionId = 'direct-1') {
+    return {
+        type: 'submission_settled',
+        submissionId,
+        outcome,
+        ...(outcome === 'completed' ? { resultText: 'All done.' } : { error: 'It broke.' }),
+    };
+}
+async function admitDispatchReady(store, input) {
+    const admission = await store.admitDispatch(input);
+    if (admission.kind !== 'submission')
+        return admission;
+    const submission = await store.markSubmissionCanonicalReady(admission.submission.submissionId);
+    return { kind: 'submission', submission: submission ?? admission.submission };
+}
+async function admitDirectReady(store, input) {
+    const submission = await store.admitDirect(input);
+    return (await store.markSubmissionCanonicalReady(submission.submissionId)) ?? submission;
+}
+/**
+ * Register the standard {@link AgentSubmissionStore} contract tests under the
+ * given describe label. Each test gets a fresh store from `factory()`.
+ */
+export function defineSubmissionStoreContractTests(name, factory) {
+    describe(name, () => {
+        let active;
+        async function create() {
+            active = await factory();
+            return active.store;
+        }
+        afterEach(async () => {
+            await active?.close?.();
+            active = undefined;
+        });
+        // ── Dispatch admission ────────────────────────────────────────────
+        describe('dispatch admission', () => {
+            it('admits one queued dispatch row when the same submission is replayed', async () => {
+                const store = await create();
+                const first = await store.admitDispatch(dispatchInput());
+                const replay = await store.admitDispatch(dispatchInput());
+                expect(replay).toEqual(first);
+                expect(first).toMatchObject({
+                    kind: 'submission',
+                    submission: {
+                        submissionId: 'dispatch-1',
+                        storeSessionId: SESSION_ID,
+                        status: 'queued',
+                    },
+                });
+            });
+            it('treats a replay differing only in acceptedAt as an exact replay (redelivery timestamps are volatile)', async () => {
+                const store = await create();
+                const first = await store.admitDispatch(dispatchInput());
+                const redelivered = await store.admitDispatch(dispatchInput({ acceptedAt: '2026-07-09T12:34:56.000Z' }));
+                expect(redelivered.kind).toBe('submission');
+                if (first.kind === 'submission' && redelivered.kind === 'submission') {
+                    expect(redelivered.submission.submissionId).toBe(first.submission.submissionId);
+                }
+            });
+            it('returns conflict when one dispatch id is reused with another payload', async () => {
+                const store = await create();
+                await store.admitDispatch(dispatchInput());
+                expect(await store.admitDispatch(dispatchInput({ message: { kind: 'signal', type: 'test.event', body: 'Different' } }))).toEqual({ kind: 'conflict' });
+            });
+            it('round-trips the dispatch payload, tenant, and actor verbatim', async () => {
+                const store = await create();
+                const input = dispatchInput({
+                    message: { kind: 'user', body: 'Here is the screenshot.' },
+                    tenantId: 'tenant-1',
+                    actor: { onBehalfOf: 'user-1' },
+                });
+                const admitted = await admitDispatchReady(store, input);
+                expect(admitted).toMatchObject({
+                    kind: 'submission',
+                    submission: {
+                        submissionId: input.dispatchId,
+                        input: { message: input.message, tenantId: 'tenant-1', actor: { onBehalfOf: 'user-1' } },
+                    },
+                });
+                expect((await store.getSubmission(input.dispatchId))?.input).toMatchObject({
+                    message: input.message,
+                });
+            });
+        });
+        // ── Direct admission ───────────────────────────────────────────────
+        describe('direct admission', () => {
+            it('round-trips a direct submission input and replays it idempotently', async () => {
+                const store = await create();
+                const input = directInput();
+                const admitted = await admitDirectReady(store, input);
+                expect(admitted.input).toEqual(input);
+                expect(admitted.storeSessionId).toBe(SESSION_ID);
+                const replay = await store.admitDirect(input);
+                expect(replay.input).toEqual(input);
+                expect(replay.submissionId).toBe(admitted.submissionId);
+                expect((await store.getSubmission(input.submissionId))?.input).toEqual(input);
+            });
+            it('rejects a direct replay with a different payload', async () => {
+                const store = await create();
+                await admitDirectReady(store, directInput());
+                await expect(store.admitDirect(directInput({ message: { kind: 'user', body: 'Different' } }))).rejects.toThrow('unexpected result');
+            });
+        });
+        describe('canonical readiness', () => {
+            it('does not list or claim a queued submission before canonical readiness', async () => {
+                const store = await create();
+                const admission = await store.admitDispatch(dispatchInput());
+                expect(admission).toMatchObject({
+                    kind: 'submission',
+                    submission: { canonicalReadyAt: null },
+                });
+                expect(await store.listRunnableSubmissions()).toEqual([]);
+                expect(await store.claimSubmission(claim('dispatch-1', 'attempt-1'))).toBeNull();
+            });
+            it('lists unready queued submissions in admission order', async () => {
+                const store = await create();
+                const first = await store.admitDispatch(dispatchInput());
+                await admitDispatchReady(store, dispatchInput({ dispatchId: 'dispatch-2' }));
+                const third = await store.admitDirect(directInput({ submissionId: 'direct-2', id: 'agent-2' }));
+                expect(await store.listUnreadySubmissions()).toEqual([
+                    expect.objectContaining({
+                        submissionId: first.kind === 'submission' ? first.submission.submissionId : '',
+                    }),
+                    expect.objectContaining({ submissionId: third.submissionId }),
+                ]);
+            });
+            it('lists and claims a queued submission after canonical readiness', async () => {
+                const store = await create();
+                await store.admitDispatch(dispatchInput());
+                const ready = await store.markSubmissionCanonicalReady('dispatch-1');
+                expect(ready?.canonicalReadyAt).toEqual(expect.any(Number));
+                expect(await store.markSubmissionCanonicalReady('dispatch-1')).toEqual(ready);
+                expect(await store.listRunnableSubmissions()).toEqual([ready]);
+                expect(await store.claimSubmission(claim('dispatch-1', 'attempt-1'))).toMatchObject({
+                    status: 'running',
+                    canonicalReadyAt: ready?.canonicalReadyAt,
+                });
+            });
+        });
+        // ── Submission ordering ───────────────────────────────────────────
+        describe('submission ordering', () => {
+            it('orders direct and dispatched submissions together within one session', async () => {
+                const store = await create();
+                const direct = await admitDirectReady(store, directInput());
+                await admitDispatchReady(store, dispatchInput());
+                const other = await admitDirectReady(store, directInput({ submissionId: 'direct-2', id: 'agent-2' }));
+                expect(await store.listRunnableSubmissions()).toEqual([direct, other]);
+                expect(await store.claimSubmission(claim('dispatch-1', 'attempt-blocked'))).toBeNull();
+            });
+            it('lists queued dispatches in admission order and selects one runnable head per session', async () => {
+                const store = await create();
+                await admitDispatchReady(store, dispatchInput());
+                await admitDispatchReady(store, dispatchInput({ dispatchId: 'dispatch-2' }));
+                await admitDispatchReady(store, dispatchInput({ dispatchId: 'dispatch-3', id: 'agent-2' }));
+                expect(await store.listRunnableSubmissions()).toEqual([
+                    expect.objectContaining({ submissionId: 'dispatch-1' }),
+                    expect.objectContaining({ submissionId: 'dispatch-3' }),
+                ]);
+            });
+            it('exposes the next submission of a session only after the head settles', async () => {
+                const store = await create();
+                await admitDispatchReady(store, dispatchInput());
+                await admitDispatchReady(store, dispatchInput({ dispatchId: 'dispatch-2' }));
+                await store.claimSubmission(claim('dispatch-1', 'attempt-1'));
+                expect(await store.listRunnableSubmissions()).toEqual([]);
+                await store.completeSubmission(attempt('dispatch-1', 'attempt-1'));
+                expect(await store.listRunnableSubmissions()).toEqual([
+                    expect.objectContaining({ submissionId: 'dispatch-2' }),
+                ]);
+                expect(await store.claimSubmission(claim('dispatch-2', 'attempt-2'))).toMatchObject({
+                    submissionId: 'dispatch-2',
+                    status: 'running',
+                });
+            });
+        });
+        // ── Claim semantics ──────────────────────────────────────────────
+        describe('claim semantics', () => {
+            it('claims only runnable session heads while allowing separate sessions to claim independently', async () => {
+                const store = await create();
+                await admitDispatchReady(store, dispatchInput());
+                await admitDispatchReady(store, dispatchInput({ dispatchId: 'dispatch-2' }));
+                await admitDispatchReady(store, dispatchInput({ dispatchId: 'dispatch-3', id: 'agent-2' }));
+                const first = await store.claimSubmission(claim('dispatch-1', 'attempt-1'));
+                const blocked = await store.claimSubmission(claim('dispatch-2', 'attempt-2'));
+                const other = await store.claimSubmission(claim('dispatch-3', 'attempt-3'));
+                expect(first).toMatchObject({
+                    submissionId: 'dispatch-1',
+                    status: 'running',
+                    attemptId: 'attempt-1',
+                    startedAt: expect.any(Number),
+                });
+                expect(blocked).toBeNull();
+                expect(other).toMatchObject({
+                    submissionId: 'dispatch-3',
+                    status: 'running',
+                    attemptId: 'attempt-3',
+                });
+                expect(await store.listRunningSubmissions()).toEqual([first, other]);
+                expect(await store.listRunnableSubmissions()).toEqual([]);
+            });
+            it('never lets two claims for the same submission both succeed', async () => {
+                const store = await create();
+                await admitDispatchReady(store, dispatchInput());
+                const [first, second] = await Promise.all([
+                    store.claimSubmission(claim('dispatch-1', 'attempt-a', 'owner-a')),
+                    store.claimSubmission(claim('dispatch-1', 'attempt-b', 'owner-b')),
+                ]);
+                const successes = [first, second].filter((submission) => submission !== null);
+                expect(successes).toHaveLength(1);
+                const claimed = await store.getSubmission('dispatch-1');
+                expect(claimed?.attemptCount).toBe(1);
+            });
+        });
+        // ── Lifecycle transitions ─────────────────────────────────────────
+        describe('lifecycle transitions', () => {
+            it('records input application and recovery requests only for the owning attempt', async () => {
+                const store = await create();
+                await admitDispatchReady(store, dispatchInput());
+                await store.claimSubmission(claim('dispatch-1', 'attempt-1'));
+                expect(await store.markSubmissionInputApplied(attempt('dispatch-1', 'attempt-1'))).toBe(true);
+                expect(await store.markSubmissionInputApplied(attempt('dispatch-1', 'stale-attempt'))).toBe(false);
+                expect(await store.requestSubmissionRecovery(attempt('dispatch-1', 'attempt-1'))).toBe(true);
+                expect(await store.requestSubmissionRecovery(attempt('dispatch-1', 'stale-attempt'))).toBe(false);
+                expect(await store.getSubmission('dispatch-1')).toMatchObject({
+                    status: 'running',
+                    attemptId: 'attempt-1',
+                    inputAppliedAt: expect.any(Number),
+                    recoveryRequestedAt: expect.any(Number),
+                });
+            });
+            it('requeues interrupted attempts only before canonical input application', async () => {
+                const store = await create();
+                await admitDispatchReady(store, dispatchInput({ dispatchId: 'requeue-safe' }));
+                await admitDispatchReady(store, dispatchInput({ dispatchId: 'requeue-unsafe', id: 'agent-2' }));
+                await store.claimSubmission(claim('requeue-safe', 'attempt-safe'));
+                await store.claimSubmission(claim('requeue-unsafe', 'attempt-unsafe'));
+                await store.markSubmissionInputApplied(attempt('requeue-unsafe', 'attempt-unsafe'));
+                expect(await store.requeueSubmissionBeforeInputApplied(attempt('requeue-safe', 'attempt-safe'))).toBe(true);
+                expect(await store.requeueSubmissionBeforeInputApplied(attempt('requeue-unsafe', 'attempt-unsafe'))).toBe(false);
+                expect(await store.getSubmission('requeue-safe')).toMatchObject({ status: 'queued' });
+                expect(await store.getSubmission('requeue-unsafe')).toMatchObject({ status: 'running' });
+            });
+            it('reports unsettled visibility until a claimed dispatch completes', async () => {
+                const store = await create();
+                await admitDispatchReady(store, dispatchInput());
+                expect(await store.hasUnsettledSubmissions()).toBe(true);
+                await store.claimSubmission(claim('dispatch-1', 'attempt-1'));
+                expect(await store.listRunningSubmissions()).toHaveLength(1);
+                await store.completeSubmission(attempt('dispatch-1', 'attempt-1'));
+                expect(await store.hasUnsettledSubmissions()).toBe(false);
+                expect(await store.getSubmission('dispatch-1')).toMatchObject({ status: 'settled' });
+            });
+            it('ignores stale-attempt settlement and keeps the first owning terminal state', async () => {
+                const store = await create();
+                await admitDispatchReady(store, dispatchInput());
+                await store.claimSubmission(claim('dispatch-1', 'attempt-1'));
+                expect(await store.completeSubmission(attempt('dispatch-1', 'stale-attempt'))).toBe(false);
+                expect(await store.failSubmission(attempt('dispatch-1', 'attempt-1'), new Error('first failure'))).toBe(true);
+                expect(await store.completeSubmission(attempt('dispatch-1', 'attempt-1'))).toBe(false);
+                expect(await store.failSubmission(attempt('dispatch-1', 'attempt-1'), new Error('later failure'))).toBe(false);
+                expect(await store.getSubmission('dispatch-1')).toMatchObject({
+                    status: 'settled',
+                    error: 'first failure',
+                });
+            });
+        });
+        // ── Session abort requests ────────────────────────────────────────
+        describe('session abort requests', () => {
+            it('stamps an abort intent on a queued submission without changing its status', async () => {
+                const store = await create();
+                const admitted = await admitDispatchReady(store, dispatchInput());
+                const storeSessionId = admitted.kind === 'submission' ? admitted.submission.storeSessionId : '';
+                const affected = await store.requestSessionAbort(storeSessionId);
+                expect(affected).toEqual(['dispatch-1']);
+                expect(await store.getSubmission('dispatch-1')).toMatchObject({
+                    status: 'queued',
+                    abortRequestedAt: expect.any(Number),
+                });
+            });
+            it('stamps the running head and every queued submission in the session at once', async () => {
+                const store = await create();
+                // Same instance/session: dispatch-1 runs, the rest queue behind it.
+                const admitted = await admitDispatchReady(store, dispatchInput());
+                await admitDispatchReady(store, dispatchInput({ dispatchId: 'dispatch-2' }));
+                await admitDispatchReady(store, dispatchInput({ dispatchId: 'dispatch-3' }));
+                await store.claimSubmission(claim('dispatch-1', 'attempt-1'));
+                const storeSessionId = admitted.kind === 'submission' ? admitted.submission.storeSessionId : '';
+                const affected = await store.requestSessionAbort(storeSessionId);
+                expect(new Set(affected)).toEqual(new Set(['dispatch-1', 'dispatch-2', 'dispatch-3']));
+                expect(await store.getSubmission('dispatch-1')).toMatchObject({
+                    status: 'running',
+                    attemptId: 'attempt-1',
+                    abortRequestedAt: expect.any(Number),
+                });
+                expect(await store.getSubmission('dispatch-3')).toMatchObject({
+                    status: 'queued',
+                    abortRequestedAt: expect.any(Number),
+                });
+            });
+            it('keeps the first abort timestamp when the request is repeated', async () => {
+                const store = await create();
+                const admitted = await admitDispatchReady(store, dispatchInput());
+                const storeSessionId = admitted.kind === 'submission' ? admitted.submission.storeSessionId : '';
+                await store.requestSessionAbort(storeSessionId);
+                const stampedAt = (await store.getSubmission('dispatch-1'))?.abortRequestedAt;
+                await store.requestSessionAbort(storeSessionId);
+                expect((await store.getSubmission('dispatch-1'))?.abortRequestedAt).toBe(stampedAt);
+            });
+            it('leaves settled submissions untouched and does not resurrect them', async () => {
+                const store = await create();
+                const admitted = await admitDispatchReady(store, dispatchInput());
+                await store.claimSubmission(claim('dispatch-1', 'attempt-1'));
+                await store.completeSubmission(attempt('dispatch-1', 'attempt-1'));
+                const storeSessionId = admitted.kind === 'submission' ? admitted.submission.storeSessionId : '';
+                expect(await store.requestSessionAbort(storeSessionId)).toEqual([]);
+                // A settled submission is an immovable sink: never offered for
+                // re-processing and cannot be re-claimed.
+                expect(await store.listRunnableSubmissions()).toHaveLength(0);
+                expect(await store.listExpiredSubmissions()).toHaveLength(0);
+                expect(await store.claimSubmission(claim('dispatch-1', 'attempt-2'))).toBeNull();
+            });
+            it('returns an empty array for a session with no unsettled submissions', async () => {
+                const store = await create();
+                expect(await store.requestSessionAbort('agent:none:none:none')).toEqual([]);
+            });
+        });
+        // ── Direct settlement obligation ──────────────────────────────────
+        describe('direct settlement obligation', () => {
+            const recordId = 'direct-1:settled';
+            it('reserves a canonical settlement only for the owning direct attempt', async () => {
+                const store = await create();
+                await admitDirectReady(store, directInput());
+                await store.claimSubmission(claim('direct-1', 'attempt-1'));
+                const record = settlementRecord('completed');
+                expect(await store.reserveSubmissionSettlement(attempt('direct-1', 'stale'), { recordId, record })).toBeNull();
+                const reserved = await store.reserveSubmissionSettlement(attempt('direct-1', 'attempt-1'), {
+                    recordId,
+                    record,
+                });
+                expect(reserved).toEqual({
+                    submissionId: 'direct-1',
+                    storeSessionId: SESSION_ID,
+                    attemptId: 'attempt-1',
+                    recordId,
+                    record,
+                });
+                expect(await store.getSubmission('direct-1')).toMatchObject({ status: 'terminalizing' });
+            });
+            it('rejects a settlement record naming a different submission', async () => {
+                const store = await create();
+                await admitDirectReady(store, directInput());
+                await store.claimSubmission(claim('direct-1', 'attempt-1'));
+                expect(await store.reserveSubmissionSettlement(attempt('direct-1', 'attempt-1'), {
+                    recordId,
+                    record: settlementRecord('completed', 'someone-else'),
+                })).toBeNull();
+                expect(await store.getSubmission('direct-1')).toMatchObject({ status: 'running' });
+            });
+            it('replays an exact obligation and rejects a conflicting settlement payload', async () => {
+                const store = await create();
+                await admitDirectReady(store, directInput());
+                await store.claimSubmission(claim('direct-1', 'attempt-1'));
+                const ref = attempt('direct-1', 'attempt-1');
+                const completed = settlementRecord('completed');
+                const first = await store.reserveSubmissionSettlement(ref, { recordId, record: completed });
+                expect(first).not.toBeNull();
+                expect(await store.reserveSubmissionSettlement(ref, { recordId, record: completed })).toEqual(first);
+                expect(await store.reserveSubmissionSettlement(ref, { recordId, record: settlementRecord('failed') })).toBeNull();
+            });
+            it('keeps terminalizing work unsettled and ordered but not runnable or reclaimable', async () => {
+                const store = await create();
+                await admitDirectReady(store, directInput());
+                await admitDirectReady(store, directInput({ submissionId: 'direct-2' }));
+                await store.claimSubmission({ ...claim('direct-1', 'attempt-1'), leaseExpiresAt: 1 });
+                const record = settlementRecord('completed');
+                await store.reserveSubmissionSettlement(attempt('direct-1', 'attempt-1'), { recordId, record });
+                expect(await store.hasUnsettledSubmissions()).toBe(true);
+                expect(await store.listRunnableSubmissions()).toEqual([]);
+                expect(await store.listRunningSubmissions()).toEqual([]);
+                expect(await store.listExpiredSubmissions()).toEqual([]);
+            });
+            it('lists and finalizes a pending settlement obligation', async () => {
+                const store = await create();
+                await admitDirectReady(store, directInput());
+                await store.claimSubmission(claim('direct-1', 'attempt-1'));
+                const ref = attempt('direct-1', 'attempt-1');
+                const record = settlementRecord('completed');
+                await store.reserveSubmissionSettlement(ref, { recordId, record });
+                expect(await store.listPendingSubmissionSettlements()).toEqual([
+                    {
+                        submissionId: 'direct-1',
+                        storeSessionId: SESSION_ID,
+                        attemptId: 'attempt-1',
+                        recordId,
+                        record,
+                    },
+                ]);
+                expect(await store.finalizeSubmissionSettlement(ref, recordId)).toBe(true);
+                expect(await store.listPendingSubmissionSettlements()).toEqual([]);
+                expect(await store.hasUnsettledSubmissions()).toBe(false);
+                expect(await store.getSubmission('direct-1')).toMatchObject({ status: 'settled' });
+            });
+            it('does not finalize for a stale attempt or a different record id', async () => {
+                const store = await create();
+                await admitDirectReady(store, directInput());
+                await store.claimSubmission(claim('direct-1', 'attempt-1'));
+                const ref = attempt('direct-1', 'attempt-1');
+                await store.reserveSubmissionSettlement(ref, { recordId, record: settlementRecord('completed') });
+                expect(await store.finalizeSubmissionSettlement(attempt('direct-1', 'stale'), recordId)).toBe(false);
+                expect(await store.finalizeSubmissionSettlement(ref, 'other-record')).toBe(false);
+                expect(await store.getSubmission('direct-1')).toMatchObject({ status: 'terminalizing' });
+            });
+            it('leaves dispatch settlement behavior unchanged', async () => {
+                const store = await create();
+                await admitDispatchReady(store, dispatchInput());
+                await store.claimSubmission(claim('dispatch-1', 'attempt-1'));
+                expect(await store.reserveSubmissionSettlement(attempt('dispatch-1', 'attempt-1'), {
+                    recordId: 'dispatch-1:settled',
+                    record: settlementRecord('completed', 'dispatch-1'),
+                })).toBeNull();
+                expect(await store.completeSubmission(attempt('dispatch-1', 'attempt-1'))).toBe(true);
+            });
+        });
+        // ── Durability ───────────────────────────────────────────────────
+        describe('durability', () => {
+            it('initializes attemptCount to 0 and timeoutAt to 0 at admission', async () => {
+                const store = await create();
+                await admitDispatchReady(store, dispatchInput());
+                expect(await store.getSubmission('dispatch-1')).toMatchObject({
+                    attemptCount: 0,
+                    maxRetry: 10,
+                    timeoutAt: 0,
+                });
+            });
+            it('sets attemptCount to 1 and applies system defaults at claim time', async () => {
+                const store = await create();
+                await admitDispatchReady(store, dispatchInput());
+                const before = Date.now();
+                await store.claimSubmission(claim('dispatch-1', 'attempt-1'));
+                const claimed = await store.getSubmission('dispatch-1');
+                if (!claimed)
+                    throw new Error('Expected claimed submission to exist.');
+                expect(claimed.attemptCount).toBe(1);
+                expect(claimed.maxRetry).toBe(10);
+                expect(claimed.timeoutAt).toBeGreaterThanOrEqual(before + 60 * 60_000);
+            });
+            it('applies custom durability when input is marked applied', async () => {
+                const store = await create();
+                await admitDispatchReady(store, dispatchInput());
+                const customTimeout = Date.now() + 6 * 60 * 60_000;
+                await store.claimSubmission(claim('dispatch-1', 'attempt-1'));
+                await store.markSubmissionInputApplied(attempt('dispatch-1', 'attempt-1'), {
+                    maxRetry: 5,
+                    timeoutAt: customTimeout,
+                });
+                expect(await store.getSubmission('dispatch-1')).toMatchObject({
+                    attemptCount: 1,
+                    maxRetry: 5,
+                    timeoutAt: customTimeout,
+                });
+            });
+            it('installs durability once — a repeated application keeps the first values', async () => {
+                const store = await create();
+                await admitDispatchReady(store, dispatchInput());
+                const customTimeout = Date.now() + 6 * 60 * 60_000;
+                await store.claimSubmission(claim('dispatch-1', 'attempt-1'));
+                await store.markSubmissionInputApplied(attempt('dispatch-1', 'attempt-1'), {
+                    maxRetry: 5,
+                    timeoutAt: customTimeout,
+                });
+                const first = await store.getSubmission('dispatch-1');
+                // Idempotent-true: the gate still matches, but durability is not rewritten.
+                expect(await store.markSubmissionInputApplied(attempt('dispatch-1', 'attempt-1'), {
+                    maxRetry: 7,
+                    timeoutAt: customTimeout + 60_000,
+                })).toBe(true);
+                expect(await store.getSubmission('dispatch-1')).toMatchObject({
+                    maxRetry: 5,
+                    timeoutAt: customTimeout,
+                    inputAppliedAt: first?.inputAppliedAt,
+                });
+            });
+            it('increments attemptCount on recovery via replaceSubmissionAttempt', async () => {
+                const store = await create();
+                await admitDispatchReady(store, dispatchInput());
+                await store.claimSubmission(claim('dispatch-1', 'attempt-1'));
+                expect(await store.getSubmission('dispatch-1')).toMatchObject({ attemptCount: 1 });
+                const replaced = await store.replaceSubmissionAttempt(attempt('dispatch-1', 'attempt-1'), 'attempt-2');
+                expect(replaced).toMatchObject({ attemptCount: 2, attemptId: 'attempt-2' });
+            });
+            it('increments attemptCount and preserves timeoutAt when reclaiming after requeue', async () => {
+                const store = await create();
+                await admitDispatchReady(store, dispatchInput());
+                await store.claimSubmission(claim('dispatch-1', 'attempt-1'));
+                const first = await store.getSubmission('dispatch-1');
+                if (!first)
+                    throw new Error('Expected claimed submission to exist.');
+                expect(first.attemptCount).toBe(1);
+                await store.requeueSubmissionBeforeInputApplied(attempt('dispatch-1', 'attempt-1'));
+                await store.claimSubmission(claim('dispatch-1', 'attempt-2'));
+                expect(await store.getSubmission('dispatch-1')).toMatchObject({
+                    attemptCount: 2,
+                    timeoutAt: first.timeoutAt,
+                });
+            });
+        });
+        // ── Recovery attempt replacement ──────────────────────────────────
+        describe('replaceSubmissionAttempt()', () => {
+            it('replaces a running attempt and returns the updated submission', async () => {
+                const store = await create();
+                await admitDispatchReady(store, dispatchInput());
+                await store.claimSubmission(claim('dispatch-1', 'attempt-1'));
+                await store.requestSubmissionRecovery(attempt('dispatch-1', 'attempt-1'));
+                const replaced = await store.replaceSubmissionAttempt(attempt('dispatch-1', 'attempt-1'), 'attempt-2');
+                expect(replaced).toMatchObject({
+                    submissionId: 'dispatch-1',
+                    status: 'running',
+                    attemptId: 'attempt-2',
+                });
+                // The pending recovery request is cleared by the handoff.
+                expect((await store.getSubmission('dispatch-1'))?.recoveryRequestedAt).toBeUndefined();
+            });
+            it('returns null without writing when the attempt no longer owns the submission', async () => {
+                const store = await create();
+                await admitDispatchReady(store, dispatchInput());
+                await store.claimSubmission(claim('dispatch-1', 'attempt-1'));
+                expect(await store.replaceSubmissionAttempt(attempt('dispatch-1', 'attempt-stale'), 'attempt-2')).toBeNull();
+                expect(await store.getSubmission('dispatch-1')).toMatchObject({
+                    attemptId: 'attempt-1',
+                    attemptCount: 1,
+                });
+            });
+            it('installs the new lease when one is supplied', async () => {
+                const store = await create();
+                await admitDispatchReady(store, dispatchInput());
+                await store.claimSubmission(claim('dispatch-1', 'attempt-1'));
+                const leaseExpiresAt = Date.now() + 60_000;
+                const replaced = await store.replaceSubmissionAttempt(attempt('dispatch-1', 'attempt-1'), 'attempt-2', { ownerId: 'owner-2', leaseExpiresAt });
+                expect(replaced).toMatchObject({ attemptId: 'attempt-2', ownerId: 'owner-2', leaseExpiresAt });
+            });
+        });
+        // ── Attempt markers ──────────────────────────────────────────────
+        describe('attempt markers', () => {
+            it('lists inserted markers with creation timestamps', async () => {
+                const store = await create();
+                const before = Date.now();
+                await store.insertAttemptMarker(attempt('dispatch-1', 'attempt-1'));
+                const markers = await store.listAttemptMarkers();
+                expect(markers).toEqual([
+                    { submissionId: 'dispatch-1', attemptId: 'attempt-1', createdAt: expect.any(Number) },
+                ]);
+                const [marker] = markers;
+                if (!marker)
+                    throw new Error('Expected an attempt marker.');
+                expect(marker.createdAt).toBeGreaterThanOrEqual(before);
+            });
+            it('keeps one marker with the original timestamp when the same attempt is inserted twice', async () => {
+                const store = await create();
+                await store.insertAttemptMarker(attempt('dispatch-1', 'attempt-1'));
+                const first = await store.listAttemptMarkers();
+                await store.insertAttemptMarker(attempt('dispatch-1', 'attempt-1'));
+                expect(await store.listAttemptMarkers()).toEqual(first);
+            });
+            it('deletes only the marker matching both submission and attempt', async () => {
+                const store = await create();
+                await store.insertAttemptMarker(attempt('dispatch-1', 'attempt-1'));
+                await store.insertAttemptMarker(attempt('dispatch-1', 'attempt-2'));
+                await store.deleteAttemptMarker(attempt('dispatch-1', 'attempt-1'));
+                expect(await store.listAttemptMarkers()).toEqual([
+                    expect.objectContaining({ submissionId: 'dispatch-1', attemptId: 'attempt-2' }),
+                ]);
+            });
+            it('silently handles deleting nonexistent markers', async () => {
+                const store = await create();
+                await expect(store.deleteAttemptMarker(attempt('missing', 'attempt-1'))).resolves.toBeUndefined();
+            });
+        });
+        // ── Lease management ──────────────────────────────────────────────
+        describe('renewLeases()', () => {
+            it('extends lease timestamp for owned running submissions', async () => {
+                const store = await create();
+                await admitDispatchReady(store, dispatchInput());
+                const expiry = Date.now() + 5_000;
+                await store.claimSubmission({
+                    submissionId: 'dispatch-1',
+                    attemptId: 'attempt-1',
+                    ownerId: 'owner-a',
+                    leaseExpiresAt: expiry,
+                });
+                await store.renewLeases('owner-a', ['dispatch-1']);
+                const submission = await store.getSubmission('dispatch-1');
+                if (!submission)
+                    throw new Error('Expected renewed submission to exist.');
+                expect(submission.leaseExpiresAt).toBeGreaterThan(expiry);
+            });
+            it('ignores submissions owned by a different coordinator', async () => {
+                const store = await create();
+                await admitDispatchReady(store, dispatchInput());
+                const expiry = Date.now() + 5_000;
+                await store.claimSubmission({
+                    submissionId: 'dispatch-1',
+                    attemptId: 'attempt-1',
+                    ownerId: 'owner-a',
+                    leaseExpiresAt: expiry,
+                });
+                await store.renewLeases('owner-b', ['dispatch-1']);
+                const submission = await store.getSubmission('dispatch-1');
+                if (!submission)
+                    throw new Error('Expected submission to exist.');
+                expect(submission.leaseExpiresAt).toBe(expiry);
+            });
+            it('ignores settled submissions', async () => {
+                const store = await create();
+                await admitDispatchReady(store, dispatchInput());
+                await store.claimSubmission(claim('dispatch-1', 'attempt-1'));
+                await store.completeSubmission(attempt('dispatch-1', 'attempt-1'));
+                // Should not throw — settled submissions are silently skipped.
+                await store.renewLeases('test-owner', ['dispatch-1']);
+            });
+        });
+        describe('listExpiredSubmissions()', () => {
+            it('returns running submissions with expired leases', async () => {
+                const store = await create();
+                await admitDispatchReady(store, dispatchInput());
+                await store.claimSubmission({
+                    submissionId: 'dispatch-1',
+                    attemptId: 'attempt-1',
+                    ownerId: 'owner-a',
+                    leaseExpiresAt: 1, // expired in the past
+                });
+                const expired = await store.listExpiredSubmissions();
+                expect(expired).toHaveLength(1);
+                const submission = expired[0];
+                if (!submission)
+                    throw new Error('Expected one expired submission.');
+                expect(submission.submissionId).toBe('dispatch-1');
+            });
+            it('excludes submissions with future lease expiry', async () => {
+                const store = await create();
+                await admitDispatchReady(store, dispatchInput());
+                await store.claimSubmission({
+                    submissionId: 'dispatch-1',
+                    attemptId: 'attempt-1',
+                    ownerId: 'owner-a',
+                    leaseExpiresAt: Date.now() + 60_000,
+                });
+                expect(await store.listExpiredSubmissions()).toHaveLength(0);
+            });
+            it('excludes settled submissions', async () => {
+                const store = await create();
+                await admitDispatchReady(store, dispatchInput());
+                await store.claimSubmission({
+                    submissionId: 'dispatch-1',
+                    attemptId: 'attempt-1',
+                    ownerId: 'owner-a',
+                    leaseExpiresAt: 1,
+                });
+                await store.completeSubmission(attempt('dispatch-1', 'attempt-1'));
+                expect(await store.listExpiredSubmissions()).toHaveLength(0);
+            });
+            it('returns empty when no submissions exist', async () => {
+                const store = await create();
+                expect(await store.listExpiredSubmissions()).toHaveLength(0);
+            });
+        });
+        // ── Edge cases ────────────────────────────────────────────────────
+        describe('edge cases', () => {
+            it('reports no unsettled submissions initially', async () => {
+                const store = await create();
+                expect(await store.hasUnsettledSubmissions()).toBe(false);
+            });
+            it('getSubmission returns null for unknown ids', async () => {
+                const store = await create();
+                expect(await store.getSubmission('nonexistent')).toBeNull();
+            });
+        });
+    });
+}
+//# sourceMappingURL=submission-store-contract.js.map