@danceiny/gotry 0.0.1-rc.16 → 0.0.1-rc.17

package/dist/scripts/booking-copilot-event-sequence-concurrency-proof-tests.js

@@ -0,0 +1,202 @@
+import assert from 'node:assert/strict';
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ensureLedger } from '../src/state-ledger.js';
+import { BookingCopilotTaskRuntime } from '../src/booking-surface/runtime.js';
+const taskId = 'task-event-sequence-atomicity';
+const workspace = {
+    schemaVersion: 'booking.surface.v1',
+    contextRef: 'ctx-event-sequence-atomicity',
+    surface: 'tenant',
+    revision: 0,
+    locale: 'en-US',
+    currency: 'AED',
+    searchDraft: {},
+    results: {
+        status: 'idle'
+    },
+    visibleHotels: [],
+    loadedOffers: [],
+    shortlistedOfferRefs: [],
+    capabilities: {
+        surface: 'tenant',
+        allowedActions: [
+            'search.run'
+        ]
+    }
+};
+const turn = {
+    schemaVersion: 'booking.surface.v1',
+    kind: 'user.turn',
+    taskId,
+    workspace,
+    request: {
+        text: 'opaque user turn'
+    }
+};
+const childIndex = process.argv.indexOf('--child');
+const child = childIndex >= 0;
+const childRoot = child ? process.argv[childIndex + 1] : undefined;
+const childMode = child ? process.argv[childIndex + 2] : undefined;
+const childVariant = child ? process.argv[childIndex + 3] : undefined;
+function sleepWhile(predicate, timeoutMs = 10_000) {
+    const deadline = Date.now() + timeoutMs;
+    while(!predicate()){
+        if (Date.now() > deadline) throw new Error('proof_barrier_timeout');
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5);
+    }
+}
+function waitForFile(path, timeoutMs = 10_000) {
+    return new Promise((resolve, reject)=>{
+        const deadline = Date.now() + timeoutMs;
+        const poll = ()=>{
+            if (existsSync(path)) return resolve();
+            if (Date.now() > deadline) return reject(new Error(`proof_file_timeout:${path}`));
+            setTimeout(poll, 5);
+        };
+        poll();
+    });
+}
+function runChild(root, mode, variant) {
+    const script = fileURLToPath(import.meta.url);
+    const tsx = fileURLToPath(new URL('../node_modules/tsx/dist/cli.mjs', import.meta.url));
+    const processChild = spawn(process.execPath, [
+        tsx,
+        script,
+        '--child',
+        root,
+        mode,
+        variant
+    ], {
+        cwd: process.cwd(),
+        stdio: [
+            'ignore',
+            'pipe',
+            'pipe'
+        ]
+    });
+    let output = '';
+    processChild.stdout.on('data', (chunk)=>{
+        output += chunk.toString();
+    });
+    processChild.stderr.on('data', (chunk)=>{
+        output += chunk.toString();
+    });
+    return new Promise((resolve, reject)=>{
+        const timer = setTimeout(()=>{
+            processChild.kill('SIGKILL');
+            reject(new Error(`child_timeout:${mode}:${variant}:${output}`));
+        }, 15_000);
+        processChild.on('exit', (code)=>{
+            clearTimeout(timer);
+            if (code !== 0) return reject(new Error(`child_exit_${code}:${mode}:${variant}:${output}`));
+            try {
+                resolve(JSON.parse(output.trim().split('\n').at(-1)));
+            } catch (error) {
+                reject(new Error(`child_output_invalid:${mode}:${variant}:${output}:${error}`));
+            }
+        });
+    });
+}
+if (child) {
+    const root = childRoot;
+    const mode = childMode;
+    const variant = childVariant;
+    const ledger = ensureLedger(root);
+    const runtime = new BookingCopilotTaskRuntime(ledger);
+    writeFileSync(join(root, `started-${mode}-${variant}`), 'started');
+    sleepWhile(()=>existsSync(join(root, 'start')));
+    const originalResume = runtime.resumeTask.bind(runtime);
+    let firstRead = true;
+    runtime.resumeTask = (id)=>{
+        const state = originalResume(id);
+        if (firstRead && state) {
+            firstRead = false;
+            writeFileSync(join(root, `ready-${mode}-${variant}`), 'ready');
+            sleepWhile(()=>existsSync(join(root, 'release')));
+        }
+        return state;
+    };
+    try {
+        if (mode === 'user-turn') runtime.startTask(turn);
+        const event = runtime.emitEvent(taskId, {
+            kind: 'status',
+            status: 'working'
+        });
+        console.log(JSON.stringify({
+            event: {
+                sequence: event.sequence
+            }
+        }));
+    } catch (error) {
+        console.log(JSON.stringify({
+            error: error instanceof Error ? error.message : String(error)
+        }));
+        process.exitCode = 1;
+    } finally{
+        ledger.close();
+    }
+} else {
+    async function run(mode) {
+        const root = mkdtempSync(join(tmpdir(), `gotry-event-sequence-${mode}-`));
+        mkdirSync(root, {
+            recursive: true
+        });
+        const ledger = ensureLedger(root);
+        new BookingCopilotTaskRuntime(ledger).startTask(turn);
+        ledger.close();
+        const children = [
+            runChild(root, mode, 'left'),
+            runChild(root, mode, 'right')
+        ];
+        try {
+            await Promise.all([
+                waitForFile(join(root, `started-${mode}-left`)),
+                waitForFile(join(root, `started-${mode}-right`))
+            ]);
+            writeFileSync(join(root, 'start'), 'start');
+            await Promise.race([
+                waitForFile(join(root, `ready-${mode}-left`)),
+                waitForFile(join(root, `ready-${mode}-right`))
+            ]);
+            await new Promise((resolve)=>setTimeout(resolve, 250));
+            assert.equal(existsSync(join(root, `ready-${mode}-left`)) && existsSync(join(root, `ready-${mode}-right`)), false, `${mode} workers both derived state before the first transaction committed`);
+            writeFileSync(join(root, 'release'), 'release');
+            const results = await Promise.all(children);
+            assert.deepEqual(results.map((result)=>result.error), [
+                undefined,
+                undefined
+            ]);
+            const check = ensureLedger(root);
+            const rows = check.db.prepare("SELECT payload FROM events WHERE tenant_id = ? AND run_id = ? AND kind = 'booking.copilot.event.emitted' ORDER BY seq").all(check.tenant, taskId);
+            const sequences = rows.map((row)=>JSON.parse(row.payload).sequence);
+            assert.deepEqual(sequences, [
+                1,
+                2
+            ], `${mode} durable event sequences must be unique and strictly monotonic`);
+            assert.deepEqual(results.map((result)=>result.event?.sequence).sort((a, b)=>a - b), [
+                1,
+                2
+            ]);
+            if (mode === 'user-turn') {
+                const userTurns = check.db.prepare("SELECT COUNT(*) AS n FROM events WHERE tenant_id = ? AND run_id = ? AND kind = 'booking.copilot.user.turn.observed'").get(check.tenant, taskId);
+                assert.equal(userTurns.n, 3, 'initial plus two concurrent user turns must all be durable');
+            }
+            check.close();
+        } finally{
+            rmSync(root, {
+                recursive: true,
+                force: true
+            });
+        }
+    }
+    await run('emit');
+    await run('user-turn');
+    console.log('BOOKING COPILOT EVENT SEQUENCE CONCURRENCY PROOF: emit/user-turn multi-process sequence unique and strictly monotonic');
+}
+
+
+//# sourceURL=ts/scripts/booking-copilot-event-sequence-concurrency-proof-tests.ts

package/dist/scripts/booking-copilot-gap-code-contract-proof-tests.js

@@ -0,0 +1,102 @@
+import assert from 'node:assert/strict';
+import { validateActionReceiptV1 } from '../src/booking-surface/validation.js';
+const receiptBase = {
+    schemaVersion: 'booking.surface.v1',
+    kind: 'action.receipt',
+    actionId: 'offers-query-gap-contract',
+    contextRef: 'ctx-gap-contract',
+    revision: 1
+};
+const ratesFailedResult = {
+    outcome: 'partial',
+    requestedCount: 1,
+    actualCount: 1,
+    hardCriteriaMet: true,
+    factRefs: [
+        'hotel:hotel-1',
+        'hotel:hotel-2',
+        'offer:breakfast'
+    ]
+};
+const ratesFailedObservation = {
+    kind: 'offers.state',
+    hotelRefs: [
+        'hotel-2'
+    ],
+    offerRefs: [
+        'breakfast'
+    ],
+    loadedHotelCount: 1
+};
+const oldRatesFailedReceipt = {
+    ...receiptBase,
+    status: 'partial',
+    observation: ratesFailedObservation,
+    resultContract: {
+        ...ratesFailedResult,
+        gapCodes: [
+            'hotel_rates_failed:hotel-1'
+        ]
+    }
+};
+const newRatesFailedReceipt = {
+    ...oldRatesFailedReceipt,
+    resultContract: {
+        ...ratesFailedResult,
+        gapCodes: [
+            'hotel_rates_failed'
+        ]
+    }
+};
+assert.equal(validateActionReceiptV1(oldRatesFailedReceipt).ok, false, 'legacy dynamic supplier gap code must fail validation');
+assert.deepEqual(validateActionReceiptV1(newRatesFailedReceipt), {
+    ok: true
+}, 'fixed supplier gap code with hotel fact ref must validate');
+assert.deepEqual(newRatesFailedReceipt.resultContract.factRefs, [
+    'hotel:hotel-1',
+    'hotel:hotel-2',
+    'offer:breakfast'
+]);
+const oldNotVisibleReceipt = {
+    ...receiptBase,
+    actionId: 'offers-query-hidden-hotel-gap-contract',
+    status: 'no_match',
+    observation: {
+        kind: 'offers.state',
+        hotelRefs: [],
+        offerRefs: [],
+        loadedHotelCount: 0
+    },
+    resultContract: {
+        outcome: 'empty',
+        requestedCount: 1,
+        actualCount: 0,
+        hardCriteriaMet: false,
+        factRefs: [
+            'hotel:not-visible'
+        ],
+        gapCodes: [
+            'hotel_not_visible:not-visible'
+        ]
+    }
+};
+const newNotVisibleReceipt = {
+    ...oldNotVisibleReceipt,
+    resultContract: {
+        ...oldNotVisibleReceipt.resultContract,
+        gapCodes: [
+            'hotel_not_visible'
+        ]
+    }
+};
+assert.equal(validateActionReceiptV1(oldNotVisibleReceipt).ok, false, 'legacy dynamic visibility gap code must fail validation');
+assert.deepEqual(validateActionReceiptV1(newNotVisibleReceipt), {
+    ok: true
+}, 'fixed visibility gap code with hotel fact ref must validate');
+assert.deepEqual(newNotVisibleReceipt.resultContract.factRefs, [
+    'hotel:not-visible'
+]);
+console.log('BOOKING COPILOT GAP CODE CONTRACT PROOF: dynamic legacy gap codes fail; fixed codes with hotel factRefs pass');
+
+
+//# sourceURL=ts/scripts/booking-copilot-gap-code-contract-proof-tests.ts

package/dist/scripts/booking-copilot-operation-ledger-concurrency-proof-tests.js

@@ -0,0 +1,374 @@
+import assert from 'node:assert/strict';
+import { existsSync, mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ensureLedger } from '../src/state-ledger.js';
+import { BookingCopilotTaskRuntime } from '../src/booking-surface/runtime.js';
+const taskId = 'task-operation-atomicity';
+const workspace = {
+    schemaVersion: 'booking.surface.v1',
+    contextRef: 'ctx-operation-atomicity',
+    surface: 'tenant',
+    revision: 0,
+    locale: 'en-US',
+    currency: 'AED',
+    searchDraft: {},
+    results: {
+        status: 'idle'
+    },
+    visibleHotels: [],
+    loadedOffers: [],
+    shortlistedOfferRefs: [],
+    capabilities: {
+        surface: 'tenant',
+        allowedActions: [
+            'search.patch',
+            'search.run'
+        ]
+    }
+};
+const base = {
+    schemaVersion: 'booking.surface.v1',
+    kind: 'search.patch',
+    actionId: 'action-operation-atomicity',
+    contextRef: workspace.contextRef,
+    expectedRevision: 0,
+    reason: 'raw-reason-marker@example.invalid Bearer RAW_SECRET',
+    factRefs: [
+        'fact:opaque'
+    ],
+    input: {
+        patch: {
+            destination: {
+                query: 'raw-input-marker@example.invalid'
+            }
+        }
+    }
+};
+const child = process.argv.indexOf('--child') >= 0;
+const replayMode = process.argv.indexOf('--replay') >= 0;
+const root = child ? process.argv[process.argv.indexOf('--child') + 1] : '';
+const variant = child ? process.argv[process.argv.indexOf('--child') + 2] : '';
+if (replayMode) {
+    const replayRoot = process.argv[process.argv.indexOf('--replay') + 1];
+    const replayVariant = process.argv[process.argv.indexOf('--replay') + 2] ?? 'base';
+    const replayLedger = ensureLedger(replayRoot);
+    const replayAction = replayVariant === 'conflict' ? action('conflict') : replayVariant === 'different' ? action('different') : base;
+    try {
+        console.log(JSON.stringify({
+            result: 'success',
+            event: new BookingCopilotTaskRuntime(replayLedger).issueOperation(taskId, replayAction)
+        }));
+    } catch (error) {
+        console.log(JSON.stringify({
+            result: 'error',
+            error: error instanceof Error ? error.message : String(error)
+        }));
+    }
+    replayLedger.close();
+    process.exit(0);
+}
+function waitFile(path, timeout = 30_000) {
+    return new Promise((resolve, reject)=>{
+        const end = Date.now() + timeout;
+        const tick = ()=>existsSync(path) ? resolve() : Date.now() > end ? reject(new Error(`timeout:${path}`)) : setTimeout(tick, 5);
+        tick();
+    });
+}
+function action(which) {
+    return {
+        ...base,
+        kind: which === 'kind' ? 'search.run' : base.kind,
+        reason: which === 'conflict' ? 'different reason' : base.reason,
+        contextRef: which === 'context' ? 'ctx-other' : base.contextRef,
+        expectedRevision: which === 'revision' ? 1 : base.expectedRevision,
+        factRefs: which === 'fact-order' ? [
+            'fact:other',
+            'fact:opaque'
+        ] : base.factRefs,
+        input: which === 'kind' ? {} : which === 'input' ? {
+            patch: {
+                destination: {
+                    query: 'other'
+                }
+            }
+        } : base.input,
+        actionId: which === 'different' ? 'action-different' : base.actionId
+    };
+}
+if (child) {
+    const ledger = ensureLedger(root);
+    const runtime = new BookingCopilotTaskRuntime(ledger);
+    const original = runtime.resumeTask.bind(runtime);
+    let first = true;
+    writeFileSync(join(root, `started-${variant}`), 'started');
+    const gateEnd = Date.now() + 10_000;
+    while(!existsSync(join(root, 'start'))){
+        if (Date.now() > gateEnd) throw new Error('start_gate_timeout');
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5);
+    }
+    if (variant !== 'left') Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 100);
+    runtime.resumeTask = (id)=>{
+        const state = original(id);
+        if (first && !state?.pendingAction) {
+            first = false;
+            writeFileSync(join(root, `ready-${variant}`), 'ready');
+            const end = Date.now() + 10_000;
+            while(!existsSync(join(root, 'release'))){
+                if (Date.now() > end) throw new Error('barrier_timeout');
+                Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5);
+            }
+        }
+        return state;
+    };
+    try {
+        const event = runtime.issueOperation(taskId, action(variant));
+        console.log(JSON.stringify({
+            result: 'success',
+            event
+        }));
+    } catch (error) {
+        console.log(JSON.stringify({
+            result: 'error',
+            error: error instanceof Error ? error.message : String(error)
+        }));
+    }
+    ledger.close();
+    process.exit(0);
+}
+async function pair(root, left, right) {
+    const tsx = fileURLToPath(new URL('../node_modules/tsx/dist/cli.mjs', import.meta.url));
+    const script = fileURLToPath(import.meta.url);
+    const ps = [
+        left,
+        right
+    ].map((v)=>spawn(process.execPath, [
+            tsx,
+            script,
+            '--child',
+            root,
+            v
+        ], {
+            cwd: process.cwd(),
+            stdio: [
+                'ignore',
+                'pipe',
+                'pipe'
+            ]
+        }));
+    const out = ps.map(()=>'');
+    ps.forEach((p, i)=>{
+        p.stdout.on('data', (b)=>{
+            out[i] += b;
+        });
+        p.stderr.on('data', (b)=>{
+            out[i] += b;
+        });
+    });
+    await Promise.all([
+        waitFile(join(root, `started-${left}`)),
+        waitFile(join(root, `started-${right}`))
+    ]);
+    writeFileSync(join(root, 'start'), 'start');
+    try {
+        await Promise.race([
+            waitFile(join(root, `ready-${left}`)),
+            waitFile(join(root, `ready-${right}`))
+        ]);
+    } catch (error) {
+        ps.forEach((p)=>p.kill('SIGKILL'));
+        throw new Error(`workers_did_not_reach_callsite:${out.join('|')}:${error}`);
+    }
+    await new Promise((resolve)=>setTimeout(resolve, 250));
+    assert.equal(existsSync(join(root, `ready-${left}`)) && existsSync(join(root, `ready-${right}`)), false, 'both workers entered transaction before release');
+    writeFileSync(join(root, 'release'), 'release');
+    try {
+        await Promise.all(ps.map((p)=>new Promise((resolve, reject)=>{
+                const timer = setTimeout(()=>reject(new Error('worker_timeout')), 10_000);
+                p.on('exit', (code)=>{
+                    clearTimeout(timer);
+                    code === 0 ? resolve() : reject(new Error(`worker_exit:${code}:${out.join('|')}`));
+                });
+            })));
+    } finally{
+        ps.forEach((p)=>{
+            if (p.exitCode === null) p.kill('SIGKILL');
+        });
+    }
+    return out.map((s)=>JSON.parse(s.trim().split('\n').at(-1)));
+}
+async function run(kind, conflictVariant = 'conflict') {
+    const root = mkdtempSync(join(tmpdir(), `gotry-operation-${kind}-`));
+    mkdirSync(root, {
+        recursive: true
+    });
+    const ledger = ensureLedger(root);
+    const runtime = new BookingCopilotTaskRuntime(ledger);
+    const turn = {
+        schemaVersion: 'booking.surface.v1',
+        kind: 'user.turn',
+        taskId,
+        workspace,
+        request: {
+            text: 'opaque'
+        }
+    };
+    runtime.startTask(turn);
+    const result = await pair(root, kind === 'different' ? 'different' : 'left', kind === 'conflict' ? conflictVariant : 'right');
+    const success = result.filter((r)=>r.result === 'success');
+    assert.equal(success.length, kind === 'same' ? 2 : 1);
+    if (kind === 'conflict') assert.equal(result.filter((r)=>r.error === 'action_conflict').length, 1, JSON.stringify(result));
+    if (kind === 'different') assert.equal(result.filter((r)=>r.error === 'receipt_required').length, 1);
+    if (kind === 'same') assert.deepEqual(success[0].event, success[1].event);
+    assert.equal(ledger.db.prepare("SELECT COUNT(*) AS n FROM events WHERE kind = 'booking.copilot.action.issued'").get().n, 1);
+    const durable = ledger.db.prepare("SELECT payload FROM events WHERE kind = 'booking.copilot.action.issued'").get();
+    assert.ok(!/raw-reason-marker|raw-input-marker|Bearer RAW_SECRET|@example|secret/i.test(durable.payload));
+    if (kind === 'same') {
+        const event = success[0].event;
+        ledger.close();
+        const tsx = fileURLToPath(new URL('../node_modules/tsx/dist/cli.mjs', import.meta.url));
+        async function replayVariant(v) {
+            const replayChild = spawn(process.execPath, [
+                tsx,
+                fileURLToPath(import.meta.url),
+                '--replay',
+                root,
+                v
+            ], {
+                cwd: process.cwd(),
+                stdio: [
+                    'ignore',
+                    'pipe',
+                    'pipe'
+                ]
+            });
+            let replayOutput = '';
+            replayChild.stdout.on('data', (b)=>{
+                replayOutput += b;
+            });
+            replayChild.stderr.on('data', (b)=>{
+                replayOutput += b;
+            });
+            await new Promise((resolve, reject)=>{
+                const timer = setTimeout(()=>{
+                    replayChild.kill('SIGKILL');
+                    reject(new Error('replay_timeout'));
+                }, 10_000);
+                replayChild.on('exit', (code)=>{
+                    clearTimeout(timer);
+                    code === 0 ? resolve() : reject(new Error(`replay_exit:${code}:${replayOutput}`));
+                });
+            });
+            return JSON.parse(replayOutput.trim().split('\n').at(-1));
+        }
+        const replayResult = await replayVariant('base');
+        assert.deepEqual(replayResult.event, event);
+        const conflictResult = await replayVariant('conflict');
+        assert.equal(conflictResult.error, 'action_conflict');
+        const differentResult = await replayVariant('different');
+        assert.equal(differentResult.error, 'receipt_required');
+        const restarted = ensureLedger(root);
+        assert.equal(restarted.db.prepare("SELECT COUNT(*) AS n FROM events WHERE kind = 'booking.copilot.action.issued'").get().n, 1);
+        const replay = replayResult.event;
+        const pending = new BookingCopilotTaskRuntime(restarted).resumeTask(taskId)?.pendingAction;
+        assert.deepEqual(pending && {
+            eventId: pending.eventId,
+            sequence: pending.sequence,
+            emittedAt: pending.emittedAt
+        }, {
+            eventId: replay.eventId,
+            sequence: replay.sequence,
+            emittedAt: replay.emittedAt
+        });
+        restarted.close();
+    } else {
+        ledger.close();
+    }
+    rmSync(root, {
+        recursive: true,
+        force: true
+    });
+}
+if (!child) {
+    for(let round = 0; round < 20; round++){
+        await run('same');
+        await run('conflict', [
+            'conflict',
+            'kind',
+            'context',
+            'revision',
+            'fact-order',
+            'input'
+        ][round % 6]);
+        await run('different');
+    }
+    const unsafeRoot = mkdtempSync(join(tmpdir(), 'gotry-operation-unsafe-'));
+    const unsafeLedger = ensureLedger(unsafeRoot);
+    const unsafeRuntime = new BookingCopilotTaskRuntime(unsafeLedger);
+    unsafeRuntime.startTask({
+        schemaVersion: 'booking.surface.v1',
+        kind: 'user.turn',
+        taskId,
+        workspace,
+        request: {
+            text: 'opaque'
+        }
+    });
+    assert.throws(()=>unsafeRuntime.issueOperation(taskId, {
+            ...base,
+            factRefs: [
+                'attacker@example.invalid'
+            ]
+        }), /unsafe_fact_ref/);
+    assert.throws(()=>unsafeRuntime.issueOperation(taskId, {
+            ...base,
+            actionId: 'attacker@example.invalid'
+        }), /unsafe_action_id/);
+    assert.throws(()=>unsafeRuntime.issueOperation(taskId, {
+            ...base,
+            actionId: 'eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.signature'
+        }), /unsafe_action_id/);
+    assert.equal(unsafeLedger.countEvents(), 2);
+    unsafeLedger.close();
+    rmSync(unsafeRoot, {
+        recursive: true,
+        force: true
+    });
+    for (const field of [
+        'actionId',
+        'factRefs',
+        'expectedRevision'
+    ]){
+        const tamperRoot = mkdtempSync(join(tmpdir(), `gotry-operation-tamper-${field}-`));
+        const tamperLedger = ensureLedger(tamperRoot);
+        const tamperRuntime = new BookingCopilotTaskRuntime(tamperLedger);
+        tamperRuntime.startTask({
+            schemaVersion: 'booking.surface.v1',
+            kind: 'user.turn',
+            taskId,
+            workspace,
+            request: {
+                text: 'opaque'
+            }
+        });
+        tamperRuntime.issueOperation(taskId, base);
+        const row = tamperLedger.db.prepare("SELECT seq, payload FROM events WHERE kind = 'booking.copilot.action.issued'").get();
+        const payload = JSON.parse(row.payload);
+        payload.action[field] = field === 'factRefs' ? [
+            'tampered'
+        ] : field === 'expectedRevision' ? 99 : 'tampered-action';
+        tamperLedger.db.prepare('UPDATE events SET payload = ? WHERE seq = ?').run(JSON.stringify(payload), row.seq);
+        assert.throws(()=>new BookingCopilotTaskRuntime(tamperLedger).resumeTask(taskId), /ledger_corrupt/);
+        tamperLedger.close();
+        rmSync(tamperRoot, {
+            recursive: true,
+            force: true
+        });
+    }
+    console.log('BOOKING COPILOT OPERATION LEDGER CONCURRENCY PROOF: 20 rounds atomic');
+}
+
+
+//# sourceURL=ts/scripts/booking-copilot-operation-ledger-concurrency-proof-tests.ts