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

package/dist/scripts/booking-copilot-dsh-plugin-proof-tests.js

@@ -0,0 +1,309 @@
+/** Closed dsh capability-tool registration proof (no dsh runtime required). */
+import assert from 'node:assert/strict';
+import { Ajv2020 } from 'ajv/dist/2020.js';
+import { ToolArgsError } from '@deepseek-ai/dsh-tools';
+// @ts-expect-error Runtime dsh plugins are JavaScript modules registered by path.
+import { apply, embeddedBookingToolDefinitions } from '../src/booking-surface/dsh-plugin.js';
+const registered = [];
+apply({
+    tools: {
+        register(tool) { registered.push(tool); },
+    },
+});
+assert.equal(registered.length, 13);
+assert.deepEqual(registered.map((tool) => tool.name), [
+    'booking_search_hotels',
+    'booking_run_search',
+    'booking_refine_results',
+    'booking_focus_hotel',
+    'booking_select_hotel',
+    'booking_find_room_offers',
+    'booking_view_offers',
+    'booking_compare_offers',
+    'booking_select_offer',
+    'booking_prepare_booking',
+    'booking_prepare_checkout',
+    'booking_observe_booking',
+    'booking_finish_turn',
+]);
+assert.deepEqual(registered, embeddedBookingToolDefinitions);
+assert.ok(!registered.some((tool) => /gotry_book|trade|payment/i.test(String(tool.name))));
+// One concrete closed schema per tool: no top-level anyOf union, no decision
+// envelope, and the tool name alone selects the action kind. Weaker providers
+// cannot be trusted to pick a union branch, so every action tool advertises
+// const kind + that kind's input + mandatory intent.
+const finishTool = registered.find((tool) => tool.name === 'booking_finish_turn');
+const finishParameters = finishTool.parameters;
+assert.equal(finishParameters.type, 'object');
+assert.ok(!Object.prototype.hasOwnProperty.call(finishParameters, 'anyOf'));
+assert.equal(finishParameters.properties.kind.const, 'terminal');
+assert.deepEqual(finishParameters.required, ['kind']);
+assert.ok(!Object.prototype.hasOwnProperty.call(finishParameters.properties, 'decision'));
+const actionTools = registered.filter((tool) => tool.name !== 'booking_finish_turn');
+const TOOL_KIND = {
+    booking_search_hotels: 'search.patch',
+    booking_run_search: 'search.run',
+    booking_refine_results: 'results.view.patch',
+    booking_focus_hotel: 'hotel.focus',
+    booking_select_hotel: 'hotel.select',
+    booking_find_room_offers: 'offers.query',
+    booking_view_offers: 'offers.view.patch',
+    booking_compare_offers: 'offers.compare',
+    booking_select_offer: 'offer.select',
+    booking_prepare_booking: 'offer.check',
+    booking_prepare_checkout: 'checkout.prepare',
+    booking_observe_booking: 'order.observe',
+};
+for (const tool of actionTools) {
+    const parameters = tool.parameters;
+    assert.equal(parameters.type, 'object');
+    assert.ok(!Object.prototype.hasOwnProperty.call(parameters, 'anyOf'), `${tool.name} must not advertise a union`);
+    assert.ok(!Object.prototype.hasOwnProperty.call(parameters.properties ?? {}, 'decision'), `${tool.name} must not advertise a decision envelope`);
+    assert.deepEqual(parameters.required, ['kind', 'input', 'intent']);
+    assert.equal(parameters.additionalProperties, false);
+    assert.equal(parameters.properties.kind.const, TOOL_KIND[String(tool.name)], `${tool.name} advertises exactly its own action kind`);
+}
+const prepare = registered.find((tool) => tool.name === 'booking_prepare_booking');
+assert.equal(prepare.parameters.properties.kind.const, 'offer.check', 'prepare-booking advertises offer.check only');
+assert.ok(!JSON.stringify(prepare.parameters).includes('book"'), 'schema has no Book discriminator');
+const search = registered.find((tool) => tool.name === 'booking_search_hotels');
+const rawExecuteSearch = search.execute;
+let concludedTurns = 0;
+const executeSearch = (args) => rawExecuteSearch(args, {
+    concludeTurn() { concludedTurns += 1; },
+});
+await assert.rejects(executeSearch({ decision: { kind: 'operation' } }), (error) => error instanceof ToolArgsError
+    && error.name === 'ToolArgsError'
+    && error.code === 'INVALID_ARGS'
+    && /decision_schema_violation/.test(error.message), 'schema violations must surface as dsh ToolArgsError with stable INVALID_ARGS code');
+await assert.rejects(executeSearch({ kind: 'search.patch', input: { patch: { destination: { query: 'Dubai' } } } }), (error) => error instanceof ToolArgsError && error.code === 'INVALID_ARGS', 'every fresh operation requires a semantic intent before the tool can conclude the turn');
+assert.equal(concludedTurns, 0, 'an invalid tool call stays in the same turn for local schema repair');
+const validateSearchTool = new Ajv2020({ allErrors: true, strict: true }).compile(search.parameters);
+// The advertised dialect is single-kind now: a terminal proposal is accepted by
+// the execute compat seam but is no longer part of this tool's advertised schema.
+assert.equal(validateSearchTool({ kind: 'terminal' }), false, 'the terminal kind moved to the dedicated finish tool');
+for (const invalidProposal of [
+    { kind: 'search.patch', input: { patch: {} }, intent: { target: 'search.results' } },
+    { kind: 'search.patch', input: { patch: { stay: { checkIn: 'tomorrow' } } }, intent: { target: 'search.results' } },
+    { kind: 'search.patch', input: { patch: { starRating: { strength: 'must', value: { min: 9 } } } }, intent: { target: 'search.results' } },
+    { kind: 'search.patch', input: { patch: { facilities: { strength: 'must', value: { allOf: [] } } } }, intent: { target: 'search.results' } },
+    { kind: 'search.patch', input: { patch: { facilities: { strength: 'must', value: { allOf: ['breakfast', 'breakfast'] } } } }, intent: { target: 'search.results' } },
+]) {
+    // dsh's advertised dialect cannot express every canonical constraint. The
+    // execute seam must still reject it before concludeTurn so the model gets
+    // an INVALID_ARGS repair opportunity in the same bounded run.
+    assert.equal(validateSearchTool(invalidProposal), true, 'the intentionally reduced advertised dialect exposes this regression case');
+    await assert.rejects(executeSearch(invalidProposal), (error) => error instanceof ToolArgsError && error.code === 'INVALID_ARGS', 'full canonical semantic constraints are enforced before concludeTurn');
+}
+assert.equal(concludedTurns, 0, 'canonical semantic failures never conclude the dsh turn');
+const compare = registered.find((tool) => tool.name === 'booking_compare_offers');
+const rawExecuteCompare = compare.execute;
+let compareConcludedTurns = 0;
+const executeCompare = (args) => rawExecuteCompare(args, {
+    concludeTurn() { compareConcludedTurns += 1; },
+});
+const validateCompareTool = new Ajv2020({ allErrors: true, strict: true }).compile(compare.parameters);
+const compositeCompareProposal = {
+    kind: 'offers.compare',
+    input: { offerRefs: ['offer-a', 'offer-b', 'offer-c'], requestedCount: 3 },
+    intent: {
+        target: 'offers.compared',
+        offerCriteria: {
+            meals: { strength: 'must', value: ['breakfast'] },
+            freeCancellation: { strength: 'must', value: true },
+            targetCount: 3,
+        },
+    },
+};
+assert.equal(validateCompareTool(compositeCompareProposal), true, JSON.stringify(validateCompareTool.errors));
+assert.deepEqual(await executeCompare(compositeCompareProposal), { accepted: true, decisionKind: 'operation', actionKind: 'offers.compare' }, 'a shallow action may carry a typed multi-step goal without runtime-owned metadata');
+assert.equal(compareConcludedTurns, 1);
+const reducedIntentCounterexample = {
+    ...compositeCompareProposal,
+    intent: { target: 'offers.compared', offerCriteria: { targetCount: 0 } },
+};
+assert.equal(validateCompareTool(reducedIntentCounterexample), true, 'the reduced model dialect cannot express targetCount minimum');
+await assert.rejects(executeCompare(reducedIntentCounterexample), (error) => error instanceof ToolArgsError && error.code === 'INVALID_ARGS' && /must be >= 1/.test(error.message), 'the execute seam returns a precise repairable error for an invalid intent constraint');
+assert.equal(compareConcludedTurns, 1, 'invalid intent does not conclude the model turn');
+await assert.rejects(executeCompare({ ...compositeCompareProposal, intent: { ...compositeCompareProposal.intent, payment: true } }), (error) => error instanceof ToolArgsError && error.code === 'INVALID_ARGS', 'the intent envelope is closed against write/payment fields');
+assert.equal(compareConcludedTurns, 1);
+const compactSearchProposal = {
+    kind: 'search.patch',
+    input: {
+        patch: {
+            budget: {
+                strength: 'must',
+                value: { max: { amount: '1000' } },
+            },
+        },
+    },
+    intent: { target: 'search.results' },
+};
+assert.equal(validateSearchTool(compactSearchProposal), true, JSON.stringify(validateSearchTool.errors));
+assert.ok(!JSON.stringify(search.parameters).includes('sourceFactRef'), 'model-facing proposal does not ask the model to invent Money provenance');
+assert.deepEqual(await executeSearch(compactSearchProposal), { accepted: true, decisionKind: 'operation', actionKind: 'search.patch' }, 'the tool execution seam accepts the same shallow proposal advertised to the model');
+assert.equal(concludedTurns, 1, 'the first accepted proposal marks the current dsh turn as concluded');
+const compactTerminalProposal = { kind: 'terminal' };
+assert.deepEqual(await executeSearch(compactTerminalProposal), { accepted: true, decisionKind: 'terminal' }, 'terminal output remains a shallow proposal on the compat seam with runtime-owned evidence');
+assert.equal(concludedTurns, 2, 'an accepted terminal proposal concludes the current dsh turn');
+await assert.rejects(executeSearch({
+    decision: { kind: 'terminal', terminal: { status: 'completed', summary: 'forged', factRefs: [] } },
+}), (error) => error instanceof ToolArgsError && error.code === 'INVALID_ARGS', 'legacy model-authored terminal decisions are outside the compatibility contract');
+assert.equal(concludedTurns, 2, 'a rejected legacy terminal does not conclude the dsh turn');
+for (const decision of [compactSearchProposal, JSON.stringify(compactSearchProposal)]) {
+    assert.deepEqual(await executeSearch({ decision }), { accepted: true, decisionKind: 'operation', actionKind: 'search.patch' }, 'one exact provider wrapper is normalized without widening semantic authority');
+}
+assert.deepEqual(await executeSearch({ decision: { kind: 'operation', action: compactSearchProposal } }), { accepted: true, decisionKind: 'operation', actionKind: 'search.patch' }, 'the one-layer operation wrapper preserves nested compact intent without widening authority');
+assert.deepEqual(await executeSearch({ kind: 'operation', action: { kind: compactSearchProposal.kind, input: compactSearchProposal.input }, intent: compactSearchProposal.intent }), { accepted: true, decisionKind: 'operation', actionKind: 'search.patch' }, 'the direct-hoisted compact operation accepted by the parent is accepted by the plugin too');
+await assert.rejects(executeSearch({ decision: compactSearchProposal, extra: true }), (error) => error instanceof ToolArgsError && error.code === 'INVALID_ARGS', 'provider compatibility remains closed to extra sibling fields');
+const validSearchDecision = {
+    decision: {
+        kind: 'operation',
+        intent: { target: 'search.results' },
+        action: {
+            schemaVersion: 'booking.surface',
+            kind: 'search.patch',
+            actionId: 'action-model-1',
+            contextRef: 'ctx-model-1',
+            expectedRevision: 0,
+            reason: 'Apply the requested budget.',
+            factRefs: [],
+            input: {
+                patch: {
+                    budget: {
+                        strength: 'must',
+                        value: { max: { amount: '1000', currency: 'AED', sourceFactRef: 'fact-budget-1' } },
+                    },
+                },
+            },
+        },
+    },
+};
+assert.equal(validateSearchTool(validSearchDecision), false, 'runtime-owned action metadata is absent from the advertised model schema');
+assert.equal(validateSearchTool({ decision: JSON.stringify(validSearchDecision.decision) }), false, 'the advertised model-facing schema remains canonical and object-only');
+assert.deepEqual(await executeSearch({ decision: JSON.stringify(validSearchDecision.decision) }), { accepted: true, decisionKind: 'operation', actionKind: 'search.patch', actionId: 'action-model-1' }, 'the execution seam normalizes one provider-stringified action plus mandatory intent before applying the canonical schema');
+await assert.rejects(executeSearch({ decision: JSON.stringify({ kind: 'operation', action: validSearchDecision.decision.action }) }), (error) => error instanceof ToolArgsError && error.code === 'INVALID_ARGS', 'a fresh legacy full action cannot silently degrade a multi-step request by omitting intent');
+await assert.rejects(executeSearch(Object.create({ decision: JSON.stringify(validSearchDecision.decision), injected: 'prototype-value' })), (error) => error instanceof ToolArgsError && error.code === 'INVALID_ARGS', 'an inherited stringified decision cannot be materialized into an executable own property');
+await assert.rejects(executeSearch(Object.create({ decision: validSearchDecision.decision })), (error) => error instanceof ToolArgsError && error.code === 'INVALID_ARGS', 'an inherited canonical decision cannot satisfy the model-facing schema');
+for (const decision of [
+    'not JSON',
+    `${JSON.stringify(validSearchDecision.decision)} trailing text`,
+    JSON.stringify(null),
+    JSON.stringify([]),
+    JSON.stringify(1),
+    JSON.stringify(JSON.stringify(validSearchDecision.decision)),
+]) {
+    await assert.rejects(executeSearch({ decision }), (error) => error instanceof ToolArgsError && error.code === 'INVALID_ARGS', 'non-canonical decision strings remain rejected at the tool execution seam');
+}
+await assert.rejects(executeSearch({
+    decision: JSON.stringify({
+        ...validSearchDecision.decision,
+        action: JSON.stringify(validSearchDecision.decision.action),
+    }),
+}), (error) => error instanceof ToolArgsError && error.code === 'INVALID_ARGS', 'the compatibility seam does not normalize a stringified action');
+assert.equal(validateSearchTool({ decision: { kind: 'operation', action: {
+            schemaVersion: 'booking.surface', kind: 'search.run', actionId: 'action-model-v2', contextRef: 'ctx-model-1', expectedRevision: 0,
+            reason: 'Run the authoritative workspace search.', factRefs: [], input: {},
+        } } }), false, 'legacy full actions are compatibility input only and stay out of the advertised schema');
+const unsafeFactRefSearchDecision = {
+    decision: {
+        kind: 'operation',
+        action: {
+            schemaVersion: 'booking.surface', kind: 'search.run', actionId: 'action-model-v3', contextRef: 'ctx-model-1', expectedRevision: 1,
+            reason: 'Run the authoritative workspace search after applying the destination.', factRefs: ['draft:destination=Dubai'], input: {},
+        },
+    },
+};
+assert.equal(validateSearchTool(unsafeFactRefSearchDecision), false, 'model-facing tool schema rejects non-canonical factRefs before the planner authority boundary');
+await assert.rejects(executeSearch(unsafeFactRefSearchDecision), (error) => error instanceof ToolArgsError
+    && error.name === 'ToolArgsError'
+    && error.code === 'INVALID_ARGS'
+    && /decision_schema_violation/.test(error.message), 'unsafe factRefs must surface as a repairable dsh INVALID_ARGS result');
+const reservedFactRefSearchDecision = {
+    ...unsafeFactRefSearchDecision,
+    decision: {
+        ...unsafeFactRefSearchDecision.decision,
+        action: {
+            ...unsafeFactRefSearchDecision.decision.action,
+            factRefs: ['modelref:reserved-by-runtime'],
+        },
+    },
+};
+assert.equal(validateSearchTool(reservedFactRefSearchDecision), false, 'model-facing tool schema excludes the runtime-owned modelref namespace');
+await assert.rejects(executeSearch(reservedFactRefSearchDecision), (error) => error instanceof ToolArgsError
+    && error.name === 'ToolArgsError'
+    && error.code === 'INVALID_ARGS'
+    && /decision_schema_violation/.test(error.message), 'reserved modelref factRefs must surface as dsh INVALID_ARGS before the planner authority boundary');
+assert.equal(validateSearchTool({
+    ...unsafeFactRefSearchDecision,
+    decision: {
+        ...unsafeFactRefSearchDecision.decision,
+        action: { ...unsafeFactRefSearchDecision.decision.action, factRefs: ['f'.repeat(513)] },
+    },
+}), false, 'model-facing tool schema enforces the runtime factRef length boundary');
+const unsafeActionIdSearchDecision = {
+    ...unsafeFactRefSearchDecision,
+    decision: {
+        ...unsafeFactRefSearchDecision.decision,
+        action: {
+            ...unsafeFactRefSearchDecision.decision.action,
+            actionId: 'action/model-v3',
+            factRefs: [],
+        },
+    },
+};
+assert.equal(validateSearchTool(unsafeActionIdSearchDecision), false, 'model-facing tool schema rejects non-canonical actionIds before the planner authority boundary');
+await assert.rejects(executeSearch(unsafeActionIdSearchDecision), (error) => error instanceof ToolArgsError
+    && error.name === 'ToolArgsError'
+    && error.code === 'INVALID_ARGS'
+    && /decision_schema_violation/.test(error.message), 'unsafe actionIds must surface as a repairable dsh INVALID_ARGS result');
+assert.equal(validateSearchTool({
+    ...validSearchDecision,
+    decision: {
+        ...validSearchDecision.decision,
+        action: {
+            ...validSearchDecision.decision.action,
+            input: { patch: { unknownCriterion: { strength: 'must', value: true } } },
+        },
+    },
+}), false, 'model-facing tool schema closes nested search criteria');
+assert.equal(validateSearchTool({
+    ...validSearchDecision,
+    decision: {
+        ...validSearchDecision.decision,
+        action: {
+            ...validSearchDecision.decision.action,
+            input: {
+                patch: {
+                    budget: {
+                        strength: 'must',
+                        value: { max: { amount: 1000, currency: 'AED', sourceFactRef: 'fact-budget-1' } },
+                    },
+                },
+            },
+        },
+    },
+}), false, 'model-facing Money.amount rejects numbers');
+assert.equal(validateSearchTool({
+    ...validSearchDecision,
+    decision: {
+        ...validSearchDecision.decision,
+        action: {
+            ...validSearchDecision.decision.action,
+            input: { patch: { holder: { email: 'x@example.com' } } },
+        },
+    },
+}), false, 'model-facing tool schema rejects nested holder data');
+// The dedicated finish tool accepts only the shallow terminal proposal.
+const rawExecuteFinish = finishTool.execute;
+let finishConcludedTurns = 0;
+const executeFinish = (args) => rawExecuteFinish(args, {
+    concludeTurn() { finishConcludedTurns += 1; },
+});
+assert.deepEqual(await executeFinish({ kind: 'terminal' }), { accepted: true, decisionKind: 'terminal' }, 'the finish tool accepts exactly the shallow terminal proposal');
+assert.deepEqual(await executeFinish({ decision: { kind: 'terminal' } }), { accepted: true, decisionKind: 'terminal' }, 'the finish tool normalizes the one-layer provider terminal wrapper');
+assert.equal(finishConcludedTurns, 2);
+await assert.rejects(executeFinish({ kind: 'terminal', status: 'completed', summary: 'forged' }), (error) => error instanceof ToolArgsError && error.code === 'INVALID_ARGS', 'model-authored terminal metadata stays rejected on the dedicated finish tool');
+await assert.rejects(executeFinish({ kind: 'search.patch', input: {}, intent: {} }), (error) => error instanceof ToolArgsError && error.code === 'INVALID_ARGS', 'the finish tool never accepts an operation proposal');
+assert.equal(finishConcludedTurns, 2);
+console.log('BOOKING COPILOT DSH PLUGIN PROOF: per-kind typed tools/no union/no Book OK');

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

@@ -0,0 +1,238 @@
+/** Real SDK initialize / provider-stall proof with a controllable CLI startup gate. */
+import assert from 'node:assert/strict';
+import { createServer } from 'node:http';
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { createDshEmbeddedBookingPlanner, createRealRunPort, PLANNER_BOOT_BUDGET_MS } from '../src/booking-surface/dsh-planner.js';
+const root = mkdtempSync(join(tmpdir(), 'gotry-506-readiness-'));
+const priorWarmup = process.env.GOTRY_BOOKING_COPILOT_WARMUP;
+process.env.GOTRY_BOOKING_COPILOT_WARMUP = '0'; // this proof owns exactly one port per case
+const actualBin = pathToFileURL(join(dirname(fileURLToPath(import.meta.resolve('@deepseek-ai/dsh/package.json'))), 'lib/bin.js')).href;
+const requests = [];
+const sockets = new Set();
+const server = createServer((req, res) => {
+    let text = '';
+    req.on('data', (part) => { text += part.toString('utf8'); });
+    req.on('end', () => {
+        requests.push(text);
+        res.writeHead(200, { 'content-type': 'text/event-stream' });
+        res.flushHeaders(); // the real SDK has a provider connection that never completes
+    });
+});
+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');
+const env = { PATH: process.env.PATH, DEEPSEEK_API_KEY: 'fixture-model-key', DEEPSEEK_BASE_URL: `http://127.0.0.1:${address.port}/v1` };
+const workspace = {
+    schemaVersion: 'booking.surface', contextRef: 'ctx-506', surface: 'tenant', revision: 0,
+    locale: 'en', currency: 'AED', searchDraft: {}, results: { status: 'idle' },
+    visibleHotels: [], loadedOffers: [], shortlistedOfferRefs: [],
+    capabilities: { surface: 'tenant', allowedActions: ['search.run'] },
+};
+const task = {
+    schemaVersion: 'booking.surface', taskId: 'task-506', contextRef: workspace.contextRef,
+    surface: 'tenant', revision: 0, allowedActions: ['search.run'], userTurnCount: 1,
+    lastTurnId: 'turn-506', operationCount: 0, phase: 'planning', lastSequence: 0,
+    availability: { initialized: true, recoveryStarted: false, availabilityPhase: 'need_offers', activeHotelOrdinal: 0, hotelRefs: [], hotels: {}, attempts: [], queryReservations: [] },
+    workspaceSnapshot: workspace,
+};
+const turn = { schemaVersion: 'booking.surface', kind: 'user.turn', taskId: task.taskId, turnId: task.lastTurnId, workspace, request: { text: 'STALL_PROVIDER_PROOF_506' } };
+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 limit = Date.now() + ms;
+    while (!check()) {
+        if (Date.now() >= limit)
+            throw new Error(label);
+        await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+}
+function alive(pid) { try {
+    process.kill(pid, 0);
+    return true;
+}
+catch {
+    return false;
+} }
+function gate(name) {
+    const marker = join(root, `${name}-started.json`);
+    const release = join(root, `${name}-release`);
+    const dshBin = join(root, `${name}-dsh.mjs`);
+    writeFileSync(dshBin, `import { existsSync, writeFileSync } from 'node:fs'\nwriteFileSync(${JSON.stringify(marker)}, JSON.stringify({pid:process.pid,workerPid:process.ppid,startupPhase:'before_initialize'}))\nconst deadline=Date.now()+15000\nwhile(!existsSync(${JSON.stringify(release)})){if(Date.now()>deadline)process.exit(73);await new Promise(r=>setTimeout(r,10))}\nconst {runCli}=await import(${JSON.stringify(actualBin)});await runCli()\n`);
+    return { marker, release, dshBin, pids: () => JSON.parse(readFileSync(marker, 'utf8')) };
+}
+let port;
+let planner;
+let phase = 'initial';
+let evidence = {};
+try {
+    const ready = gate('ready');
+    port = await createRealRunPort({ stateRoot: root, env, dshBin: ready.dshBin, maxTokens: 512 });
+    phase = 'awaiting_real_initialize';
+    let warmupSettled = false;
+    const warming = port.warmup().then(() => { warmupSettled = true; });
+    void warming.catch(() => undefined); // the bounded await below owns setup failure reporting
+    await until(() => existsSync(ready.marker) || warmupSettled, 5_000, 'real dsh never entered startup gate');
+    assert.equal(warmupSettled, false, 'warmup must not report ready before the real runtime starts and initializes');
+    const readyPids = ready.pids();
+    evidence = { ...readyPids, providerRequests: requests.length };
+    assert.equal(requests.length, 0, 'initialize never consumes a provider call');
+    // A known cold-start delay is outside the provider-stall measurement.
+    await new Promise((resolve) => setTimeout(resolve, 1_800));
+    assert.equal(warmupSettled, false, 'startup gate still prevents false readiness after 1800ms');
+    writeFileSync(ready.release, 'release');
+    await bounded(warming, 10_000, 'runtime initialize did not complete');
+    assert.equal(requests.length, 0, 'completed warmup still makes zero model calls');
+    assert.ok(alive(readyPids.pid) && alive(readyPids.workerPid), 'both owned processes are alive after initialize');
+    // Our own boot bill must stay readable next to the provider budget it shares
+    // a wire window with, so the port reports what the handshake actually cost.
+    const readyBoot = port.bootObservation?.();
+    assert.ok(readyBoot, 'the real port must observe its own initialize handshake');
+    const bootMsAtFirstTurn = readyBoot.initializeMs;
+    assert.equal(readyBoot.mode, 'started', 'the first request in a fresh worker performs the handshake');
+    assert.ok(bootMsAtFirstTurn > 0, `real initialize cost must be measured: ${JSON.stringify(readyBoot)}`);
+    evidence = { ...readyPids, providerRequests: requests.length, boot: readyBoot };
+    const readyPort = port;
+    const readyMetrics = [];
+    planner = await createDshEmbeddedBookingPlanner({
+        runPortFactory: () => readyPort,
+        turnTimeoutMs: 1_500,
+        onMetric: (metric) => readyMetrics.push(metric),
+    });
+    phase = 'provider_stall';
+    const started = Date.now();
+    const resultPromise = planner.plannerFactory(task).next({ turn, task });
+    await until(() => requests.length === 1, 3_000, 'initialized real provider was not reached');
+    const providerObservedMs = Date.now() - started;
+    const modelRequest = JSON.parse(requests[0]);
+    // 0.2.0-rc.2 起工具条目是平铺 {name}(旧形态是 {function:{name}} 包裹);
+    // 断言的是 booking 插件在场,两种线型都接受。
+    assert.ok(modelRequest.tools.some((tool) => tool.function?.name === 'booking_run_search' || tool.name === 'booking_run_search'), 'real initialized runtime includes the GoTry booking plugin');
+    const result = await bounded(resultPromise, 3_000, 'planner did not return a bounded timeout');
+    const elapsedMs = Date.now() - started;
+    assert.equal(result[0]?.kind === 'error' && result[0].error.code, 'PLANNER_PROVIDER_TIMEOUT');
+    assert.ok(elapsedMs < 3_000, `provider deadline remains bounded: ${elapsedMs}ms`);
+    const stalledTurnMetric = readyMetrics[0];
+    assert.ok(stalledTurnMetric, 'the provider-stall turn must report its own metric');
+    assert.equal(stalledTurnMetric.bootMode, 'reused', 'a turn on an initialized port reuses the runtime instead of starting one');
+    assert.equal(stalledTurnMetric.bootMs, 0, 'a reused runtime contributes no boot time to the turn');
+    phase = 'ready_cleanup';
+    const cleanupAt = Date.now();
+    await bounded(planner.close(), 3_000, 'ready tree cleanup exceeded budget');
+    planner = undefined;
+    port = undefined;
+    assert.ok(!alive(readyPids.pid) && !alive(readyPids.workerPid), 'ready runtime and worker both reaped');
+    console.log('DSH READINESS READY:', JSON.stringify({ startupDelayMs: 1800, warmupProviderCalls: 0, providerRequests: requests.length, firstTurnBootMs: bootMsAtFirstTurn, reusedTurnBootMs: stalledTurnMetric.bootMs, providerObservedMs, elapsedMs, cleanupMs: Date.now() - cleanupAt, treeReaped: true }));
+    const cold = gate('cold');
+    phase = 'cold_start_timeout';
+    const coldPort = await createRealRunPort({ stateRoot: root, env, dshBin: cold.dshBin, maxTokens: 512 });
+    port = coldPort;
+    planner = await createDshEmbeddedBookingPlanner({ runPortFactory: () => coldPort, turnTimeoutMs: 1_500 });
+    const coldAt = Date.now();
+    const coldResultPromise = planner.plannerFactory(task).next({ turn, task });
+    await until(() => existsSync(cold.marker), 3_000, 'cold real runtime never entered startup gate');
+    const coldPids = cold.pids();
+    evidence = { ...coldPids, providerRequests: requests.length };
+    const coldResult = await bounded(coldResultPromise, 3_000, 'cold-start timeout did not settle');
+    const coldElapsedMs = Date.now() - coldAt;
+    // The handshake never completed, so no provider call happened: the failure is
+    // ours to own and is typed as a local boot timeout, not a provider stall.
+    assert.equal(coldResult[0]?.kind === 'error' && coldResult[0].error.code, 'PLANNER_BOOT_TIMEOUT');
+    assert.equal(requests.length, 1, 'cold blocked startup reaches no provider');
+    await bounded(planner.close(), 3_000, 'cold tree cleanup exceeded budget');
+    planner = undefined;
+    port = undefined;
+    assert.ok(!alive(coldPids.pid) && !alive(coldPids.workerPid), 'cold runtime and worker both reaped');
+    console.log('DSH READINESS COLD:', JSON.stringify({ providerRequests: 0, elapsedMs: coldElapsedMs, code: 'PLANNER_BOOT_TIMEOUT', treeReaped: true }));
+    // The local boot budget must govern its own phase. With a model-stall budget
+    // wider than the boot budget, only the explicit initialize deadline can
+    // settle this turn inside the asserted window; the SDK's 10s fallback or the
+    // 13.3s stall budget would both land later and fail the bound below.
+    phase = 'boot_budget_bound';
+    const budgetGate = gate('boot-budget');
+    port = await createRealRunPort({ stateRoot: root, env, dshBin: budgetGate.dshBin, maxTokens: 512 });
+    planner = await createDshEmbeddedBookingPlanner({ runPortFactory: () => port, turnTimeoutMs: 20_000 });
+    const budgetAt = Date.now();
+    const budgetResultPromise = planner.plannerFactory(task).next({ turn, task });
+    await until(() => existsSync(budgetGate.marker), 3_000, 'boot-budget runtime never entered startup gate');
+    const budgetPids = budgetGate.pids();
+    const budgetResult = await bounded(budgetResultPromise, 15_000, 'boot budget did not settle the turn');
+    const budgetElapsedMs = Date.now() - budgetAt;
+    assert.equal(budgetResult[0]?.kind === 'error' && budgetResult[0].error.code, 'PLANNER_BOOT_TIMEOUT');
+    assert.ok(budgetElapsedMs >= PLANNER_BOOT_BUDGET_MS, `the boot budget must be consumed before it fires (${budgetElapsedMs}ms)`);
+    assert.ok(budgetElapsedMs < PLANNER_BOOT_BUDGET_MS + 6_000, `the local boot budget, not the 13.3s stall budget, must settle this turn (${budgetElapsedMs}ms)`);
+    assert.equal(requests.length, 1, 'a blocked handshake makes no provider request');
+    await bounded(planner.close(), 3_000, 'boot-budget tree cleanup exceeded budget');
+    planner = undefined;
+    port = undefined;
+    assert.ok(!alive(budgetPids.pid) && !alive(budgetPids.workerPid), 'boot-budget runtime and worker both reaped');
+    console.log('DSH READINESS BOOT BUDGET:', JSON.stringify({ budgetMs: PLANNER_BOOT_BUDGET_MS, elapsedMs: budgetElapsedMs, code: 'PLANNER_BOOT_TIMEOUT', providerRequests: 0, treeReaped: true }));
+    phase = 'initialize_failure';
+    const failedMarker = join(root, 'failed-start.json');
+    const failedBin = join(root, 'failed-dsh.mjs');
+    writeFileSync(failedBin, `import { writeFileSync } from 'node:fs'\nwriteFileSync(${JSON.stringify(failedMarker)}, JSON.stringify({pid:process.pid,workerPid:process.ppid,exitCode:23,signal:null}))\nprocess.stderr.write('PRIVATE_FIXTURE_DIAGNOSTIC');process.exit(23)\n`);
+    port = await createRealRunPort({ stateRoot: root, env, dshBin: failedBin, maxTokens: 512 });
+    await assert.rejects(bounded(port.warmup(), 5_000, 'failed initialize did not settle'), { message: 'HARNESS_START_FAILED' });
+    const failed = JSON.parse(readFileSync(failedMarker, 'utf8'));
+    assert.equal(failed.exitCode, 23);
+    assert.equal(failed.signal, null);
+    assert.equal(requests.length, 1, 'failed initialize makes no provider calls');
+    await bounded(port.close(), 3_000, 'failed-start cleanup exceeded budget');
+    port = undefined;
+    assert.ok(!alive(failed.pid) && !alive(failed.workerPid), 'failed runtime and worker both reaped');
+    console.log('DSH READINESS FAILURE CLASSIFICATION:', JSON.stringify({ exitCode: failed.exitCode, signal: failed.signal, error: 'HARNESS_START_FAILED', rawStderrExposed: false, providerRequests: 0, treeReaped: true }));
+    // Opt-in distribution run: boot fresh runtimes back to back so the local
+    // initialize budget can be set from measured percentiles instead of a guess.
+    // Each sample is a new worker plus a new dsh home, so the page cache is the
+    // only warm input; the numbers are observations, not a service guarantee.
+    const bootSampleCount = Number(process.env.GOTRY_BOOT_SAMPLES ?? 0);
+    if (Number.isSafeInteger(bootSampleCount) && bootSampleCount > 0) {
+        phase = 'boot_sampling';
+        const samples = [];
+        for (let index = 1; index <= bootSampleCount; index += 1) {
+            const samplePort = await createRealRunPort({ stateRoot: root, env, maxTokens: 512 });
+            try {
+                await bounded(samplePort.warmup(), 30_000, `boot sample ${index} initialize did not complete`);
+                const observation = samplePort.bootObservation?.();
+                assert.ok(observation, `boot sample ${index} must observe its initialize handshake`);
+                assert.equal(observation.mode, 'started', `boot sample ${index} boots a fresh worker`);
+                samples.push(observation.initializeMs);
+            }
+            finally {
+                await bounded(samplePort.close(), 10_000, `boot sample ${index} cleanup exceeded budget`);
+            }
+        }
+        const sorted = [...samples].sort((left, right) => left - right);
+        const percentile = (fraction) => sorted[Math.min(sorted.length - 1, Math.floor(fraction * sorted.length))];
+        console.log('DSH BOOT SAMPLES:', JSON.stringify({ count: sorted.length, minMs: sorted[0], p50Ms: percentile(0.5), p95Ms: percentile(0.95), maxMs: sorted.at(-1) }));
+    }
+}
+catch (error) {
+    console.error('DSH READINESS FAILURE:', JSON.stringify({ phase, ...evidence, providerRequests: requests.length, error: error instanceof Error ? error.message : 'unknown' }));
+    throw error;
+}
+finally {
+    const cleanup = await Promise.allSettled([planner?.close(), port?.close()]);
+    for (const socket of sockets)
+        socket.destroy();
+    await new Promise((resolve) => server.close(() => resolve()));
+    rmSync(root, { recursive: true, force: true });
+    if (priorWarmup === undefined)
+        delete process.env.GOTRY_BOOKING_COPILOT_WARMUP;
+    else
+        process.env.GOTRY_BOOKING_COPILOT_WARMUP = priorWarmup;
+    const failedCleanup = cleanup.find((result) => result.status === 'rejected');
+    if (failedCleanup?.status === 'rejected')
+        throw failedCleanup.reason;
+}
+console.log('BOOKING COPILOT DSH READINESS PROOF: real initialize, provider stall, cold timeout and process cleanup OK');