@danceiny/gotry 0.0.1-rc.9 → 0.2.0-rc.28

package/dist/scripts/booking-copilot-intent-proof-tests.js

@@ -0,0 +1,422 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { ensureLedger } from '../src/state-ledger.js';
+import { BookingCopilotTaskRuntime, bookingDigest, bookingTurnDigest, } from '../src/booking-surface/runtime.js';
+import { validateBookingIntentProjection } from '../src/booking-surface/validation.js';
+const contextRef = 'ctx-intent-proof';
+const allowedActions = [
+    'search.patch',
+    'search.run',
+    'results.view.patch',
+    'hotel.focus',
+    'hotel.select',
+    'offers.query',
+    'offers.view.patch',
+    'offers.compare',
+    'offer.select',
+    'offer.check',
+    'checkout.prepare',
+    'order.observe',
+];
+function workspace(revision = 0) {
+    return {
+        schemaVersion: 'booking.surface',
+        contextRef,
+        surface: 'tenant',
+        revision,
+        locale: 'zh-CN',
+        currency: 'AED',
+        searchDraft: {},
+        results: { status: 'idle' },
+        visibleHotels: [],
+        loadedOffers: [],
+        shortlistedOfferRefs: [],
+        capabilities: { surface: 'tenant', allowedActions: [...allowedActions] },
+    };
+}
+function turn(taskId, requestText, revision = 0, snapshot = workspace(revision)) {
+    return {
+        schemaVersion: 'booking.surface',
+        kind: 'user.turn',
+        taskId,
+        turnId: `${taskId}-turn-${revision}`,
+        workspace: snapshot,
+        request: { text: requestText },
+    };
+}
+function action(actionId, revision = 0) {
+    return {
+        schemaVersion: 'booking.surface',
+        kind: 'search.run',
+        actionId,
+        contextRef,
+        expectedRevision: revision,
+        reason: 'Run the authoritative workspace search.',
+        factRefs: [],
+        input: {},
+    };
+}
+const compositeIntent = {
+    schemaVersion: 'booking.intent.v1',
+    target: 'offers.compared',
+    offerCriteria: {
+        meals: { strength: 'must', value: ['breakfast'] },
+        freeCancellation: { strength: 'must', value: true },
+        targetCount: 3,
+        sort: 'best_match',
+    },
+};
+assert.equal(validateBookingIntentProjection(compositeIntent).ok, true, 'canonical composite offer intent is valid');
+for (const invalid of [
+    { ...compositeIntent, schemaVersion: 'booking.intent.v2' },
+    { ...compositeIntent, target: 'book.now' },
+    { ...compositeIntent, payment: { card: '4111 1111 1111 1111' } },
+    { ...compositeIntent, offerCriteria: { targetCount: 0 } },
+    { ...compositeIntent, offerCriteria: { meals: { strength: 'must', value: [] } } },
+    { ...compositeIntent, offerCriteria: { meals: { strength: 'must', value: ['breakfast', 'breakfast'] } } },
+    { ...compositeIntent, offerCriteria: { roomType: { strength: 'must', value: ['guest@example.com'] } } },
+    { ...compositeIntent, offerCriteria: { roomType: { strength: 'must', value: ['supplier cost AED 10'] } } },
+    { schemaVersion: 'booking.intent.v1', target: 'search.results', offerCriteria: { targetCount: 2 } },
+    { schemaVersion: 'booking.intent.v1', target: 'results.refined', offerCriteria: { targetCount: 2 } },
+    { schemaVersion: 'booking.intent.v1', target: 'hotel.focused', offerCriteria: { targetCount: 2 } },
+    { schemaVersion: 'booking.intent.v1', target: 'hotel.selected', offerCriteria: { targetCount: 2 } },
+    { schemaVersion: 'booking.intent.v1', target: 'order.observed', offerCriteria: { targetCount: 2 } },
+]) {
+    assert.equal(validateBookingIntentProjection(invalid).ok, false, `invalid intent is rejected: ${JSON.stringify(invalid)}`);
+}
+const root = mkdtempSync(join(tmpdir(), 'gotry-booking-intent-proof-'));
+const taskId = 'task-intent-proof';
+const requestText = '迪拜五星，给我三个含早免费取消的真实报价';
+try {
+    const firstLedger = ensureLedger(root);
+    const firstRuntime = new BookingCopilotTaskRuntime(firstLedger, { contextRefFactory: () => contextRef });
+    const initialTurn = turn(taskId, requestText);
+    firstRuntime.startTask(initialTurn);
+    assert.throws(() => firstRuntime.issueOperation(taskId, action('intent-missing-direct')), /booking_intent_required/, 'the low-level runtime boundary cannot infer a final user waypoint from a shallow action');
+    firstRuntime.applyDecisionBatch(taskId, 'intent-first-operation', [{
+            kind: 'operation',
+            action: action('intent-search-run'),
+            intent: compositeIntent,
+        }]);
+    const pending = firstRuntime.resumeTask(taskId);
+    assert.deepEqual(pending?.activeIntent?.projection, compositeIntent, 'the final user waypoint is bound to the first action');
+    assert.equal(pending?.activeIntent?.sourceTurnId, initialTurn.turnId);
+    assert.equal(pending?.activeIntent?.sourceRequestDigest, bookingTurnDigest(initialTurn));
+    const actionPayloadText = firstLedger.db.prepare("SELECT payload FROM events WHERE run_id = ? AND kind = 'booking.copilot.action.issued'").get(taskId).payload;
+    assert.equal(actionPayloadText.includes(requestText), false, 'the action checkpoint stores no raw user request');
+    firstLedger.close();
+    const receiptWorkspace = {
+        ...workspace(1),
+        results: { status: 'ready', searchSessionRef: 'search-intent-1', resultCount: 1 },
+        visibleHotels: [{ hotelRef: 'hotel-intent-1', name: 'Intent Hotel', factRefs: [] }],
+    };
+    const receipt = {
+        schemaVersion: 'booking.surface',
+        kind: 'action.receipt',
+        actionId: 'intent-search-run',
+        contextRef,
+        status: 'applied',
+        revision: 1,
+        observation: { kind: 'search.state', searchSessionRef: 'search-intent-1', resultCount: 1 },
+        resultContract: {
+            outcome: 'complete',
+            hardCriteriaMet: true,
+            factRefs: [],
+            gapCodes: [],
+            blockers: [],
+            relaxationsApplied: [],
+        },
+    };
+    const secondLedger = ensureLedger(root);
+    const secondRuntime = new BookingCopilotTaskRuntime(secondLedger, { contextRefFactory: () => contextRef });
+    const replayedPending = secondRuntime.resumeTask(taskId);
+    assert.deepEqual(replayedPending?.activeIntent?.projection, compositeIntent, 'process restart replays the exact semantic goal');
+    const afterReceipt = secondRuntime.continueWithReceipt({
+        schemaVersion: 'booking.surface',
+        kind: 'action.receipt.continuation',
+        taskId,
+        workspace: receiptWorkspace,
+        receipt,
+    });
+    assert.deepEqual(afterReceipt.activeIntent?.projection, compositeIntent, 'an intermediate receipt cannot shorten the user goal');
+    assert.equal(afterReceipt.lastCompletedAction?.kind, 'search.run');
+    assert.throws(() => secondRuntime.applyDecisionBatch(taskId, 'intent-missing-operation', [{
+            kind: 'operation',
+            action: {
+                schemaVersion: 'booking.surface',
+                kind: 'offers.query',
+                actionId: 'intent-missing-query',
+                contextRef,
+                expectedRevision: 1,
+                reason: 'Attempt to omit the durable goal.',
+                factRefs: [],
+                input: { hotelRefs: ['hotel-intent-1'], criteria: compositeIntent.offerCriteria },
+            },
+        }]), /invalid_booking_intent/, 'a model-facing operation cannot rely on runtime inference when intent is missing');
+    assert.throws(() => secondRuntime.applyDecisionBatch(taskId, 'intent-weakened-operation', [{
+            kind: 'operation',
+            action: {
+                schemaVersion: 'booking.surface',
+                kind: 'offers.query',
+                actionId: 'intent-weakened-query',
+                contextRef,
+                expectedRevision: 1,
+                reason: 'Attempt to execute weaker criteria than the durable goal.',
+                factRefs: [],
+                input: { hotelRefs: ['hotel-intent-1'], criteria: { targetCount: 1 } },
+            },
+            intent: compositeIntent,
+        }]), /action_intent_mismatch/, 'a later action cannot execute weaker criteria than the durable semantic goal');
+    secondRuntime.applyDecisionBatch(taskId, 'intent-next-operation', [{
+            kind: 'operation',
+            action: {
+                schemaVersion: 'booking.surface',
+                kind: 'offers.query',
+                actionId: 'intent-offers-query',
+                contextRef,
+                expectedRevision: 1,
+                reason: 'Load authoritative offers for the visible candidate.',
+                factRefs: [],
+                input: { hotelRefs: ['hotel-intent-1'], criteria: compositeIntent.offerCriteria },
+            },
+            intent: compositeIntent,
+        }]);
+    assert.deepEqual(secondRuntime.resumeTask(taskId)?.activeIntent?.projection, compositeIntent, 'a later action reuses the durable goal without model prose');
+    assert.throws(() => secondRuntime.applyDecisionBatch(taskId, 'intent-mutated-operation', [{
+            kind: 'operation',
+            action: {
+                schemaVersion: 'booking.surface',
+                kind: 'offers.query',
+                actionId: 'intent-mutated-query',
+                contextRef,
+                expectedRevision: 1,
+                reason: 'Attempt to mutate the goal.',
+                factRefs: [],
+                input: { hotelRefs: ['hotel-intent-1'], criteria: { targetCount: 1 } },
+            },
+            intent: { ...compositeIntent, offerCriteria: { targetCount: 1 } },
+        }]), /receipt_required|intent_mutation_forbidden/, 'the model cannot replace an in-flight semantic goal');
+    secondLedger.close();
+}
+finally {
+    rmSync(root, { recursive: true, force: true });
+}
+function tamperIntent(name, mutate) {
+    const tamperRoot = mkdtempSync(join(tmpdir(), `gotry-booking-intent-${name}-`));
+    const tamperTaskId = `task-intent-${name}`;
+    try {
+        const ledger = ensureLedger(tamperRoot);
+        const runtime = new BookingCopilotTaskRuntime(ledger, { contextRefFactory: () => contextRef });
+        runtime.startTask(turn(tamperTaskId, 'find hotels'));
+        runtime.applyDecisionBatch(tamperTaskId, `${name}-operation`, [{
+                kind: 'operation',
+                action: action(`${name}-action`),
+                intent: compositeIntent,
+            }]);
+        const row = ledger.db.prepare("SELECT seq, payload FROM events WHERE run_id = ? AND kind = 'booking.copilot.action.issued'").get(tamperTaskId);
+        const payload = JSON.parse(row.payload);
+        payload.intent = mutate(payload.intent);
+        ledger.db.prepare('UPDATE events SET payload = ? WHERE seq = ?').run(JSON.stringify(payload), row.seq);
+        assert.throws(() => runtime.resumeTask(tamperTaskId), new RegExp(`ledger_corrupt:${tamperTaskId}:intent`), `${name} intent tampering is fail-closed`);
+        ledger.close();
+    }
+    finally {
+        rmSync(tamperRoot, { recursive: true, force: true });
+    }
+}
+tamperIntent('projection', (checkpoint) => ({
+    ...checkpoint,
+    projection: { ...checkpoint.projection, target: 'search.results' },
+}));
+tamperIntent('digest', (checkpoint) => ({ ...checkpoint, intentDigest: '0'.repeat(64) }));
+tamperIntent('source-turn', (checkpoint) => {
+    const base = { ...checkpoint, sourceTurnId: 'forged-turn' };
+    const { intentDigest: _old, ...digestInput } = base;
+    return { ...base, intentDigest: bookingDigest(digestInput) };
+});
+tamperIntent('source-request', (checkpoint) => {
+    const base = { ...checkpoint, sourceRequestDigest: 'f'.repeat(64) };
+    const { intentDigest: _old, ...digestInput } = base;
+    return { ...base, intentDigest: bookingDigest(digestInput) };
+});
+tamperIntent('task-graft', (checkpoint) => {
+    const base = { ...checkpoint, taskId: 'task-from-another-ledger' };
+    const { intentDigest: _old, ...digestInput } = base;
+    return { ...base, intentDigest: bookingDigest(digestInput) };
+});
+tamperIntent('context-graft', (checkpoint) => {
+    const base = { ...checkpoint, contextRef: 'ctx-from-another-actor' };
+    const { intentDigest: _old, ...digestInput } = base;
+    return { ...base, intentDigest: bookingDigest(digestInput) };
+});
+// Expand compatibility: old ACTION rows without a typed intent remain
+// additive-readable, but their action/receipt tail is safely replanned rather
+// than left pending or allowed to terminalize a task.
+{
+    const legacyRoot = mkdtempSync(join(tmpdir(), 'gotry-booking-intent-legacy-'));
+    const legacyTaskId = 'task-intent-legacy';
+    try {
+        const ledger = ensureLedger(legacyRoot);
+        const runtime = new BookingCopilotTaskRuntime(ledger, { contextRefFactory: () => contextRef });
+        runtime.startTask(turn(legacyTaskId, 'find hotels'));
+        runtime.issueOperation(legacyTaskId, action('legacy-intent-action'), { schemaVersion: 'booking.intent.v1', target: 'search.results' });
+        const receiptWorkspace = {
+            ...workspace(1),
+            results: { status: 'ready', searchSessionRef: 'legacy-search-1', resultCount: 1 },
+        };
+        runtime.continueWithReceipt({
+            schemaVersion: 'booking.surface',
+            kind: 'action.receipt.continuation',
+            taskId: legacyTaskId,
+            workspace: receiptWorkspace,
+            receipt: {
+                schemaVersion: 'booking.surface',
+                kind: 'action.receipt',
+                actionId: 'legacy-intent-action',
+                contextRef,
+                status: 'applied',
+                revision: 1,
+                observation: { kind: 'search.state', searchSessionRef: 'legacy-search-1', resultCount: 1 },
+                resultContract: { outcome: 'complete', hardCriteriaMet: true, factRefs: [], gapCodes: [], blockers: [], relaxationsApplied: [] },
+            },
+        });
+        const row = ledger.db.prepare("SELECT seq, payload FROM events WHERE run_id = ? AND kind = 'booking.copilot.action.issued'").get(legacyTaskId);
+        const payload = JSON.parse(row.payload);
+        delete payload.intent;
+        ledger.db.prepare('UPDATE events SET payload = ? WHERE seq = ?').run(JSON.stringify(payload), row.seq);
+        ledger.close();
+        const replayLedger = ensureLedger(legacyRoot);
+        const replayRuntime = new BookingCopilotTaskRuntime(replayLedger, { contextRefFactory: () => contextRef });
+        const replayed = replayRuntime.resumeTask(legacyTaskId);
+        assert.equal(replayed?.pendingAction, undefined, 'legacy action/receipt replay must not remain pending');
+        assert.equal(replayed?.activeIntent, undefined, 'legacy action replay does not invent a later user goal');
+        assert.equal(replayed?.lastReceipt, undefined, 'legacy receipt replay does not become current evidence');
+        assert.equal(replayed?.replayUpgradeRequired, true, 'legacy action/receipt replay requires a fresh turn anchor');
+        assert.equal(replayed?.phase, 'planning', 'legacy action/receipt replay remains replannable, not terminal');
+        assert.throws(() => replayRuntime.issueOperation(legacyTaskId, action('legacy-missing-intent')), /booking_intent_required/, 'untyped legacy two-argument call still fails closed at runtime');
+        replayLedger.close();
+    }
+    finally {
+        rmSync(legacyRoot, { recursive: true, force: true });
+    }
+}
+// A legal action kind paired with an overshooting intent is rejected at issue
+// time and from a tampered replay row using the same ordinal table.
+{
+    const pathRoot = mkdtempSync(join(tmpdir(), 'gotry-booking-intent-path-'));
+    try {
+        const ledger = ensureLedger(pathRoot);
+        const runtime = new BookingCopilotTaskRuntime(ledger, { contextRefFactory: () => contextRef });
+        const pathTaskId = 'task-intent-path';
+        runtime.startTask(turn(pathTaskId, 'search'));
+        assert.throws(() => runtime.applyDecisionBatch(pathTaskId, 'invalid-search-offer-criteria', [{
+                kind: 'operation', action: action('invalid-search-offer-criteria'),
+                intent: { schemaVersion: 'booking.intent.v1', target: 'search.results', offerCriteria: { targetCount: 2 } },
+            }]), /invalid_booking_intent/, 'same-turn intent schema rejects offer criteria on a search waypoint');
+        assert.throws(() => runtime.applyDecisionBatch(pathTaskId, 'overshoot-at-issue', [{
+                kind: 'operation',
+                action: { ...action('overshoot-check'), kind: 'offer.check', input: { offerRef: 'offer-path', offerVersionRef: 'offer-path:v1' } },
+                intent: { schemaVersion: 'booking.intent.v1', target: 'search.results' },
+            }]), /action_intent_mismatch/, 'a legal action cannot overshoot its durable intent target');
+        runtime.applyDecisionBatch(pathTaskId, 'path-valid-prefix', [{
+                kind: 'operation',
+                action: action('path-search-run'),
+                intent: { schemaVersion: 'booking.intent.v1', target: 'offers.compared', offerCriteria: { targetCount: 3 } },
+            }]);
+        const row = ledger.db.prepare("SELECT seq, payload FROM events WHERE run_id = ? AND kind = 'booking.copilot.action.issued'").get(pathTaskId);
+        const payload = JSON.parse(row.payload);
+        payload.intent = { ...payload.intent, projection: { ...payload.intent.projection, target: 'search.results' } };
+        ledger.db.prepare('UPDATE events SET payload = ? WHERE seq = ?').run(JSON.stringify(payload), row.seq);
+        assert.throws(() => runtime.resumeTask(pathTaskId), new RegExp(`ledger_corrupt:${pathTaskId}:intent`), 'the same target/action path rule is enforced during replay');
+        ledger.close();
+    }
+    finally {
+        rmSync(pathRoot, { recursive: true, force: true });
+    }
+}
+// Existing-order observation is an independent waypoint. Preparing Checkout
+// belongs to the current booking journey; after user authorization/Book a new
+// trusted order context starts observation.
+{
+    const checkoutRoot = mkdtempSync(join(tmpdir(), 'gotry-booking-intent-checkout-'));
+    try {
+        const ledger = ensureLedger(checkoutRoot);
+        const runtime = new BookingCopilotTaskRuntime(ledger, { contextRefFactory: () => contextRef });
+        const checkoutTaskId = 'task-intent-order-observed';
+        runtime.startTask(turn(checkoutTaskId, 'observe an existing order'));
+        assert.throws(() => runtime.applyDecisionBatch(checkoutTaskId, 'order-observed-checkout', [{
+                kind: 'operation',
+                action: {
+                    schemaVersion: 'booking.surface', kind: 'checkout.prepare', actionId: 'order-observed-checkout-action', contextRef,
+                    expectedRevision: 0, reason: 'Prepare checkout before observing order.', factRefs: [],
+                    input: { offerRef: 'offer-order-1', offerVersionRef: 'offer-order-1:v1', verifiedOfferRef: 'verified-order-1' },
+                },
+                intent: { schemaVersion: 'booking.intent.v1', target: 'order.observed' },
+            }]), /action_intent_mismatch/, 'checkout.prepare cannot advance an independent order.observed intent');
+        ledger.close();
+    }
+    finally {
+        rmSync(checkoutRoot, { recursive: true, force: true });
+    }
+}
+// A projection can name only a waypoint supported by the current surface.
+{
+    const narrowRoot = mkdtempSync(join(tmpdir(), 'gotry-booking-intent-narrow-'));
+    try {
+        const ledger = ensureLedger(narrowRoot);
+        const runtime = new BookingCopilotTaskRuntime(ledger, { contextRefFactory: () => contextRef });
+        const narrowWorkspace = {
+            ...workspace(),
+            capabilities: { surface: 'tenant', allowedActions: ['search.run'] },
+        };
+        runtime.startTask(turn('task-intent-narrow', 'find and compare offers', 0, narrowWorkspace));
+        assert.throws(() => runtime.applyDecisionBatch('task-intent-narrow', 'narrow-operation', [{
+                kind: 'operation',
+                action: action('narrow-action'),
+                intent: compositeIntent,
+            }]), /intent_target_unsupported/, 'intent cannot expand the surface capability allowlist');
+        ledger.close();
+    }
+    finally {
+        rmSync(narrowRoot, { recursive: true, force: true });
+    }
+}
+// Count semantics are part of the durable goal, not advisory model prose.
+{
+    const countRoot = mkdtempSync(join(tmpdir(), 'gotry-booking-intent-count-'));
+    try {
+        const ledger = ensureLedger(countRoot);
+        const runtime = new BookingCopilotTaskRuntime(ledger, { contextRefFactory: () => contextRef });
+        const countWorkspace = {
+            ...workspace(),
+            loadedOffers: [{ offerRef: 'offer-count-1', offerVersionRef: 'offer-count-1:v1', hotelRef: 'hotel-count-1', evidenceLevel: 'rate_loaded', factRefs: [] }],
+            capabilities: { surface: 'tenant', allowedActions: ['offers.compare'] },
+        };
+        runtime.startTask(turn('task-intent-count', 'compare three offers', 0, countWorkspace));
+        assert.throws(() => runtime.applyDecisionBatch('task-intent-count', 'count-mismatch-operation', [{
+                kind: 'operation',
+                action: {
+                    schemaVersion: 'booking.surface',
+                    kind: 'offers.compare',
+                    actionId: 'count-mismatch-action',
+                    contextRef,
+                    expectedRevision: 0,
+                    reason: 'Attempt to compare fewer offers than requested.',
+                    factRefs: [],
+                    input: { offerRefs: ['offer-count-1'], requestedCount: 1 },
+                },
+                intent: {
+                    schemaVersion: 'booking.intent.v1',
+                    target: 'offers.compared',
+                    offerCriteria: { targetCount: 3 },
+                },
+            }]), /action_intent_mismatch/, 'requestedCount cannot be weakened below the durable comparison target');
+        ledger.close();
+    }
+    finally {
+        rmSync(countRoot, { recursive: true, force: true });
+    }
+}
+console.log('BOOKING COPILOT INTENT PROOF: canonical validation/persistence/restart/tamper/legacy/capability OK');

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

@@ -0,0 +1,184 @@
+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 as StrictBookingCopilotTaskRuntime } from '../src/booking-surface/runtime.js';
+const taskId = 'task-operation-atomicity';
+const workspace = {
+    schemaVersion: 'booking.surface', 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', kind: 'search.patch', actionId: 'action-operation-atomicity', contextRef: workspace.contextRef, expectedRevision: 0, reason: 'raw-reason-marker', factRefs: ['fact:opaque'], input: { patch: { destination: { query: 'typed-input-marker' } } } };
+const searchResultsIntent = { schemaVersion: 'booking.intent.v1', target: 'search.results' };
+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 StrictBookingCopilotTaskRuntime(replayLedger).issueOperation(taskId, replayAction, searchResultsIntent) }));
+    }
+    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 StrictBookingCopilotTaskRuntime(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), searchResultsIntent);
+        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 StrictBookingCopilotTaskRuntime(ledger);
+    const turn = { schemaVersion: 'booking.surface', kind: 'user.turn', taskId, turnId: 'operation-anchor-turn', 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|@example|secret/i.test(durable.payload), 'action reason prose is never durable');
+    assert.match(durable.payload, /"reasonDigest"/, 'the redacted reason digest is durable');
+    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 StrictBookingCopilotTaskRuntime(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 StrictBookingCopilotTaskRuntime(unsafeLedger);
+    unsafeRuntime.startTask({ schemaVersion: 'booking.surface', kind: 'user.turn', taskId, turnId: 'unsafe-anchor-turn', workspace, request: { text: 'opaque' } });
+    assert.throws(() => unsafeRuntime.issueOperation(taskId, { ...base, reason: 'raw prose marker@example.invalid' }, searchResultsIntent), /invalid_action|unsafe/, 'email prose is rejected before an operation is issued');
+    assert.throws(() => unsafeRuntime.issueOperation(taskId, { ...base, factRefs: ['attacker@example.invalid'] }, searchResultsIntent), /invalid_action|unsafe_fact_ref/);
+    assert.throws(() => unsafeRuntime.issueOperation(taskId, { ...base, actionId: 'attacker@example.invalid' }, searchResultsIntent), /invalid_action|unsafe_action_id/);
+    assert.throws(() => unsafeRuntime.issueOperation(taskId, { ...base, actionId: 'eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.signature' }, searchResultsIntent), /invalid_action|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 StrictBookingCopilotTaskRuntime(tamperLedger);
+        tamperRuntime.startTask({ schemaVersion: 'booking.surface', kind: 'user.turn', taskId, turnId: 'tamper-anchor-turn', workspace, request: { text: 'opaque' } });
+        tamperRuntime.issueOperation(taskId, base, searchResultsIntent);
+        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 StrictBookingCopilotTaskRuntime(tamperLedger).resumeTask(taskId), /ledger_corrupt/);
+        tamperLedger.close();
+        rmSync(tamperRoot, { recursive: true, force: true });
+    }
+    console.log('BOOKING COPILOT OPERATION LEDGER CONCURRENCY PROOF: 20 rounds atomic');
+}