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

package/dist/scripts/booking-copilot-dsh-warmer-proof.js

@@ -0,0 +1,123 @@
+/** Real default-warmer lifecycle proof: close owns both blocked SDK trees. */
+import assert from 'node:assert/strict';
+import { createServer } from 'node:http';
+import { mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { createRealRunPort } from '../src/booking-surface/dsh-planner.js';
+const root = mkdtempSync(join(tmpdir(), 'gotry-warmer-proof-'));
+const priorTmpdir = process.env.TMPDIR;
+process.env.TMPDIR = root;
+const markerDir = join(root, 'markers');
+const releaseFile = join(root, 'release');
+mkdirSync(markerDir, { recursive: true });
+const actualBin = pathToFileURL(join(dirname(fileURLToPath(import.meta.resolve('@deepseek-ai/dsh/package.json'))), 'lib/bin.js')).href;
+const gateBin = join(root, 'blocked-dsh.mjs');
+writeFileSync(gateBin, `
+import { existsSync, writeFileSync } from 'node:fs'
+const marker = ${JSON.stringify(markerDir)} + '/gate-' + process.pid + '.json'
+writeFileSync(marker, JSON.stringify({ pid: process.pid, workerPid: process.ppid }))
+while (!existsSync(${JSON.stringify(releaseFile)})) await new Promise((resolve) => setTimeout(resolve, 10))
+const { runCli } = await import(${JSON.stringify(actualBin)})
+await runCli()
+`);
+const requests = [];
+const sockets = new Set();
+const server = createServer((req, res) => {
+    let body = '';
+    req.on('data', (part) => { body += part.toString('utf8'); });
+    req.on('end', () => {
+        requests.push(body);
+        res.writeHead(200, { 'content-type': 'text/event-stream' });
+        res.flushHeaders();
+    });
+});
+server.on('connection', (socket) => { sockets.add(socket); socket.on('close', () => sockets.delete(socket)); });
+await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+const address = server.address();
+assert.ok(address && typeof address !== 'string');
+async function bounded(promise, ms, label) {
+    let timer;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_, reject) => { timer = setTimeout(() => reject(new Error(label)), ms); }),
+        ]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function until(check, ms, label) {
+    const deadline = Date.now() + ms;
+    while (!check()) {
+        if (Date.now() >= deadline)
+            throw new Error(label);
+        await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+}
+function alive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const scratchBefore = new Set(readdirSync(root).filter((name) => name.startsWith('gotry-booking-dsh-')));
+let port;
+let warmup;
+let gatePids = [];
+try {
+    assert.notEqual(process.env.GOTRY_BOOKING_COPILOT_WARMUP, '0', 'proof must exercise the default warmer');
+    port = await createRealRunPort({
+        stateRoot: root,
+        env: {
+            PATH: process.env.PATH,
+            DEEPSEEK_API_KEY: 'fixture-model-key',
+            DEEPSEEK_BASE_URL: `http://127.0.0.1:${address.port}/v1`,
+        },
+        dshBin: gateBin,
+        maxTokens: 512,
+    });
+    const warmScratch = readdirSync(root).filter((name) => name.startsWith('gotry-booking-dsh-') && !scratchBefore.has(name));
+    assert.equal(warmScratch.length, 1, 'real port owns one scratch directory');
+    // The default warmer is already running; start the returned port too so the
+    // close proof observes both independent worker/runtime trees.
+    warmup = port.warmup();
+    void warmup.catch(() => undefined);
+    await until(() => readdirSync(markerDir).length >= 2, 5_000, 'both real dsh startup gates did not start');
+    gatePids = readdirSync(markerDir).map((name) => JSON.parse(readFileSync(join(markerDir, name), 'utf8')));
+    assert.equal(gatePids.length, 2, 'default warmer and actual port each started one runtime');
+    assert.equal(requests.length, 0, 'blocked initialize made no provider requests');
+    const closeStarted = Date.now();
+    const closePromise = port.close();
+    assert.strictEqual(port.close(), closePromise, 'repeated close returns the same cleanup promise');
+    await bounded(closePromise, 5_000, 'port close did not settle within its cleanup bound');
+    assert.ok(Date.now() - closeStarted < 5_000, 'port close remains bounded');
+    assert.ok(gatePids.every(({ pid, workerPid }) => !alive(pid) && !alive(workerPid)), 'close reaps both blocked runtime trees before returning');
+    await assert.rejects(bounded(warmup, 1_000, 'actual port warmup did not settle after close'), /managed DSH run port closed/, 'close rejects the in-flight actual-port warmup');
+    const scratchAfter = readdirSync(root).filter((name) => name.startsWith('gotry-booking-dsh-') && !scratchBefore.has(name));
+    assert.equal(scratchAfter.length, 0, 'close removes scratch only after both trees stop');
+    assert.equal(requests.length, 0, 'close proof made zero provider requests');
+    console.log('DSH WARMER LIFECYCLE PROOF: default warmer and actual port both close, reap, and clean scratch');
+}
+finally {
+    // Release any old-code detached warmer so a red run does not leave a gate
+    // alive after the assertion has captured the lifecycle regression.
+    writeFileSync(releaseFile, 'release');
+    await Promise.allSettled([port?.close(), warmup]);
+    if (gatePids.length) {
+        await until(() => gatePids.every(({ pid, workerPid }) => !alive(pid) && !alive(workerPid)), 5_000, 'observed gate trees did not exit during proof cleanup');
+    }
+    for (const socket of sockets)
+        socket.destroy();
+    await new Promise((resolve) => server.close(() => resolve()));
+    if (priorTmpdir === undefined)
+        delete process.env.TMPDIR;
+    else
+        process.env.TMPDIR = priorTmpdir;
+    rmSync(root, { recursive: true, force: true });
+}

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

@@ -0,0 +1,156 @@
+/**
+ * Real multi-process proof for task-scoped Booking Copilot event sequencing.
+ *
+ * Run from the repository root with Node 24:
+ *   npx tsx ts/scripts/booking-copilot-event-sequence-concurrency-proof-tests.ts
+ */
+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', 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', kind: 'user.turn', taskId,
+    turnId: 'seq-anchor-turn',
+    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')));
+    // The old implementation read the task outside its write transaction. This
+    // barrier makes both workers hold the same stale fold before either append;
+    // an immediate transaction permits only one worker to reach this point.
+    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, turnId: `seq-${variant}-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');
+}

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

@@ -0,0 +1,70 @@
+/**
+ * Cross-repository proof for the Portal sequential HotelRates gap contract.
+ *
+ * The Portal keeps the hotel identity in opaque factRefs while emitting only
+ * fixed safe identifiers in resultContract.gapCodes. This proof calls the
+ * actual GoTry receipt validator so a dynamic legacy code cannot cross the
+ * contract boundary.
+ *
+ * Run from the repository root with Node 24:
+ *   npx tsx ts/scripts/booking-copilot-gap-code-contract-proof-tests.ts
+ */
+import assert from 'node:assert/strict';
+import { validateBookingSurface } from '../src/booking-surface/validation.js';
+const receiptBase = {
+    schemaVersion: 'booking.surface',
+    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'], blockers: [], relaxationsApplied: [] },
+};
+const newRatesFailedReceipt = {
+    ...oldRatesFailedReceipt,
+    resultContract: { ...ratesFailedResult, gapCodes: ['hotel_rates_failed'], blockers: [], relaxationsApplied: [] },
+};
+assert.equal(validateBookingSurface(oldRatesFailedReceipt).ok, false, 'legacy dynamic supplier gap code must fail validation');
+assert.deepEqual(validateBookingSurface(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'],
+        blockers: [],
+        relaxationsApplied: [],
+    },
+};
+const newNotVisibleReceipt = {
+    ...oldNotVisibleReceipt,
+    resultContract: { ...oldNotVisibleReceipt.resultContract, gapCodes: ['hotel_not_visible'] },
+};
+assert.equal(validateBookingSurface(oldNotVisibleReceipt).ok, false, 'legacy dynamic visibility gap code must fail validation');
+assert.deepEqual(validateBookingSurface(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');