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

package/dist/scripts/booking-copilot-crossrepo-fixture-server.js

@@ -0,0 +1,144 @@
+/**
+ * Deterministic, model-free GoTry server for the Hotel-BE/Hotel-FE proof.
+ *
+ * The proof starts this process as a real GoTry HTTP/SSE server.  The planner
+ * is intentionally in-process and typed: it selects a hotel on the payment
+ * link surface, starts a search on every other accepted surface, and only
+ * emits a terminal event after the corresponding receipt continuation.
+ */
+import { mkdtempSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { ensureLedger } from '../src/state-ledger.js';
+import { BOOKING_SURFACE_ALLOWED_ACTIONS, BOOKING_SURFACE_SCHEMA_SHA256, BOOKING_SURFACE_SCHEMA_VERSION, } from '../src/booking-surface/contracts.js';
+import { BookingCopilotTaskRuntime } from '../src/booking-surface/runtime.js';
+import { startBookingCopilotServer } from '../src/booking-surface/server.js';
+const API_KEY = 'test-only-cross-repo-key';
+const stateRoot = mkdtempSync(join(tmpdir(), 'gotry-booking-copilot-crossrepo-'));
+const ledger = ensureLedger(stateRoot);
+let sequence = 0;
+const principal = { subject: 'fixture-crossrepo-bff', scope: 'booking:read' };
+const ingressMode = 'bff-ingress-binding';
+const ingressBinding = {
+    bind(input) {
+        const surface = input.surfaceHint;
+        return {
+            taskId: `fixture-task-${input.requestKey}`,
+            turnId: `fixture-turn-${input.requestKey}`,
+            contextRef: `ctx-fixture-${input.requestKey}`,
+            surface,
+            allowedActions: [...BOOKING_SURFACE_ALLOWED_ACTIONS[surface]],
+        };
+    },
+};
+const plannerFactory = (initialTask) => {
+    let receiptObserved = initialTask.lastReceipt !== undefined;
+    return {
+        async next({ turn, task }) {
+            if (turn.kind === 'action.receipt.continuation') {
+                receiptObserved = true;
+                return [{
+                        kind: 'terminal',
+                        terminal: {
+                            status: 'completed',
+                            summary: 'Fixture receipt observed.',
+                            factRefs: [],
+                        },
+                    }];
+            }
+            // After the receipt-driven approval question, the next browser ingress
+            // carries the exact selected option. Let the planner issue the same
+            // typed read operation; the runtime owns the approval ref injection.
+            if (turn.kind === 'user.turn' && turn.request.approval) {
+                return [{ kind: 'operation', action: {
+                            schemaVersion: BOOKING_SURFACE_SCHEMA_VERSION,
+                            kind: 'search.run',
+                            actionId: 'cross-repo-action-2',
+                            contextRef: task.contextRef,
+                            expectedRevision: task.revision,
+                            reason: 'Run the approved relaxed search.',
+                            factRefs: [],
+                            input: {},
+                        }, intent: { schemaVersion: 'booking.intent.v1', target: 'search.results' } }];
+            }
+            if (receiptObserved) {
+                return [{
+                        kind: 'terminal',
+                        terminal: {
+                            status: 'completed',
+                            summary: 'Fixture task already has a receipt.',
+                            factRefs: [],
+                        },
+                    }];
+            }
+            const action = task.surface === 'payment_link'
+                ? {
+                    schemaVersion: BOOKING_SURFACE_SCHEMA_VERSION,
+                    kind: 'hotel.select',
+                    actionId: 'cross-repo-action-1',
+                    contextRef: task.contextRef,
+                    expectedRevision: task.revision,
+                    reason: 'Select the requested hotel.',
+                    factRefs: [],
+                    input: { hotelRef: 'hotel-proof-1' },
+                }
+                : {
+                    schemaVersion: BOOKING_SURFACE_SCHEMA_VERSION,
+                    kind: 'search.run',
+                    actionId: 'cross-repo-action-1',
+                    contextRef: task.contextRef,
+                    expectedRevision: task.revision,
+                    reason: 'Run the requested search.',
+                    factRefs: [],
+                    input: {},
+                };
+            const intent = action.kind === 'hotel.select'
+                ? { schemaVersion: 'booking.intent.v1', target: 'hotel.selected' }
+                : { schemaVersion: 'booking.intent.v1', target: 'search.results' };
+            return [{ kind: 'operation', action, intent }];
+        },
+    };
+};
+async function main() {
+    const runtime = new BookingCopilotTaskRuntime(ledger, {
+        idFactory: (prefix) => `${prefix}-cross-repo-${++sequence}`,
+        now: () => '2026-08-31T00:00:00.000Z',
+    });
+    const handle = await startBookingCopilotServer({
+        apiKey: API_KEY,
+        runtime,
+        plannerFactory,
+        ingressBinding,
+        principal,
+        ingressMode,
+        host: '127.0.0.1',
+        port: 0,
+    });
+    process.stdout.write(`BOOKING_COPILOT_FIXTURE_STARTUP=${JSON.stringify({
+        url: `http://127.0.0.1:${handle.port}`,
+        version: BOOKING_SURFACE_SCHEMA_VERSION,
+        sha256: BOOKING_SURFACE_SCHEMA_SHA256,
+    })}\n`);
+    await new Promise((resolve) => {
+        const stop = () => resolve();
+        process.once('SIGTERM', stop);
+        process.once('SIGINT', stop);
+    });
+    await handle.close();
+}
+try {
+    await main();
+}
+catch (error) {
+    process.stderr.write(`booking-copilot-crossrepo-fixture failed: ${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+}
+finally {
+    try {
+        ledger.close();
+    }
+    catch (error) {
+        process.stderr.write(`booking-copilot-crossrepo-fixture ledger close failed: ${error instanceof Error ? error.message : String(error)}\n`);
+    }
+    rmSync(stateRoot, { recursive: true, force: true });
+}

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

@@ -0,0 +1,424 @@
+/**
+ * Real DeepSeek Harness subprocess proof for the embedded booking planner.
+ *
+ * A local OpenAI-compatible SSE fixture is the model transport; everything
+ * between it and BookingPlannerDecision is the published dsh core, its SDK
+ * stdio server, the GoTry plugin, tool execution, session events and adapter.
+ */
+import assert from 'node:assert/strict';
+import { execFileSync, spawnSync } from 'node:child_process';
+import { createServer } from 'node:http';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createDshEmbeddedBookingPlanner, createRealRunPort, resolveRealRunPortConfig, DSH_EMBEDDED_BOOKING_TOOL_NAMES, } from '../src/booking-surface/dsh-planner.js';
+import { bookingDigest } from '../src/booking-surface/runtime.js';
+import { throwWithCleanupFailures } from './booking-copilot-cleanup-proof-helper.js';
+const action = {
+    schemaVersion: 'booking.surface',
+    kind: 'search.run',
+    actionId: 'action-real-dsh-1',
+    contextRef: 'ctx-real-dsh-1',
+    expectedRevision: 0,
+    reason: 'Run the authoritative workspace search.',
+    factRefs: [],
+    input: {},
+};
+function completedCheckpoint(completed, sourceTurnId) {
+    const base = {
+        actionId: completed.actionId,
+        kind: completed.kind,
+        contextRef: completed.contextRef,
+        expectedRevision: completed.expectedRevision,
+        factRefs: [...completed.factRefs],
+        input: structuredClone(completed.input),
+        reasonDigest: bookingDigest(completed.reason),
+        inputDigest: bookingDigest(completed.input),
+        eventId: `operation-${completed.actionId}`,
+        sequence: 1,
+        emittedAt: '2026-08-30T12:00:00.000Z',
+        sourceTurnId,
+    };
+    return { ...base, actionDigest: bookingDigest(base) };
+}
+function sse(res, chunks) {
+    res.writeHead(200, {
+        'content-type': 'text/event-stream; charset=utf-8',
+        'cache-control': 'no-cache',
+    });
+    for (const chunk of chunks)
+        res.write(`data: ${JSON.stringify(chunk)}\n\n`);
+    res.end('data: [DONE]\n\n');
+}
+/** 0.2.0-rc.2 起 provider 线型是 Messages 流(message_start、content_block 前缀事件、
+ * message_stop),不再是 OpenAI chat.completion.chunk;合成响应按新线型发。 */
+function messagesToolCallEvents(id, name, input) {
+    return [
+        { type: 'message_start', message: { usage: { input_tokens: 10 } } },
+        { type: 'content_block_start', index: 0, content_block: { type: 'tool_use', id, name, input: {} } },
+        { type: 'content_block_delta', index: 0, delta: { type: 'input_json_delta', partial_json: JSON.stringify(input) } },
+        { type: 'content_block_stop', index: 0 },
+        { type: 'message_delta', delta: { stop_reason: 'tool_use' }, usage: { output_tokens: 5 } },
+        { type: 'message_stop' },
+    ];
+}
+function messagesTextEvents(text) {
+    return [
+        { type: 'message_start', message: { usage: { input_tokens: 20 } } },
+        { type: 'content_block_start', index: 0, content_block: { type: 'text', text } },
+        { type: 'content_block_stop', index: 0 },
+        { type: 'message_delta', delta: { stop_reason: 'end_turn' }, usage: { output_tokens: 4 } },
+        { type: 'message_stop' },
+    ];
+}
+function objectKeys(value) {
+    if (Array.isArray(value))
+        return value.flatMap(objectKeys);
+    if (typeof value !== 'object' || value === null)
+        return [];
+    return Object.entries(value).flatMap(([key, child]) => [key, ...objectKeys(child)]);
+}
+const requests = [];
+let modelCall = 0;
+let continuationServed = false;
+let observeStalledRequest;
+const stalledRequestObserved = new Promise((resolve) => { observeStalledRequest = resolve; });
+const modelServer = createServer((req, res) => {
+    const parts = [];
+    req.on('data', (part) => parts.push(part));
+    req.on('end', () => {
+        const body = JSON.parse(Buffer.concat(parts).toString('utf8'));
+        requests.push({ headers: req.headers, body });
+        modelCall += 1;
+        if (JSON.stringify(body).includes('STALL_PROVIDER_PROOF')) {
+            res.writeHead(200, { 'content-type': 'text/event-stream; charset=utf-8', 'cache-control': 'no-cache' });
+            observeStalledRequest();
+            return;
+        }
+        // Script by request content, not call order: the prose-only retry budget
+        // issues additional runs whose scripted response must stay prose, not the
+        // continuation terminal.
+        if (!continuationServed && JSON.stringify(body).includes('action.receipt.continuation')) {
+            continuationServed = true;
+            sse(res, messagesToolCallEvents('call-booking-continuation', 'booking_search_hotels', { kind: 'terminal' }));
+            return;
+        }
+        if (modelCall === 1) {
+            // The first probabilistic miss omits the mandatory semantic goal. The
+            // model-facing schema must reject this before the parent process ever
+            // sees a superficially valid action.
+            sse(res, messagesToolCallEvents('call-booking-1', 'booking_search_hotels', { kind: 'search.patch', input: { patch: { destination: { query: 'Dubai' } } } }));
+            return;
+        }
+        if (modelCall === 2) {
+            // This repairs the required intent but still violates the full canonical
+            // SearchCriteriaPatch.minProperties rule that the provider-compatible
+            // advertised dialect cannot express.
+            sse(res, messagesToolCallEvents('call-booking-repair', 'booking_search_hotels', { kind: 'search.patch', input: { patch: {} }, intent: { target: 'search.results' } }));
+            return;
+        }
+        if (modelCall === 3) {
+            sse(res, messagesToolCallEvents('call-booking-repair-canonical', 'booking_run_search', { kind: 'search.run', input: {}, intent: { target: 'search.results' } }));
+            return;
+        }
+        sse(res, messagesTextEvents('Typed decision emitted.'));
+    });
+});
+await new Promise((resolve, reject) => {
+    modelServer.once('error', reject);
+    modelServer.listen(0, '127.0.0.1', () => resolve());
+});
+const address = modelServer.address();
+assert.ok(typeof address === 'object' && address);
+const stateRoot = mkdtempSync(join(tmpdir(), 'gotry-booking-dsh-core-'));
+const workspace = {
+    schemaVersion: 'booking.surface',
+    contextRef: action.contextRef,
+    surface: 'tenant',
+    revision: 0,
+    locale: 'zh-CN',
+    currency: 'AED',
+    searchDraft: {},
+    results: { status: 'idle' },
+    visibleHotels: [],
+    loadedOffers: [],
+    shortlistedOfferRefs: [],
+    capabilities: { surface: 'tenant', allowedActions: ['search.patch', 'search.run'] },
+};
+const turn = {
+    schemaVersion: 'booking.surface',
+    kind: 'user.turn',
+    taskId: 'task-real-dsh-1',
+    turnId: 'real-dsh-turn-1',
+    workspace,
+    request: { text: '执行当前酒店搜索' },
+};
+const availability = { initialized: true, recoveryStarted: false, availabilityPhase: 'need_offers', activeHotelOrdinal: 0, hotelRefs: [], hotels: {}, attempts: [], queryReservations: [] };
+const task = {
+    schemaVersion: 'booking.surface',
+    taskId: 'task-real-dsh-1',
+    contextRef: action.contextRef,
+    surface: 'tenant',
+    revision: 0,
+    allowedActions: ['search.patch', 'search.run'],
+    userTurnCount: 1,
+    lastTurnId: 'real-dsh-turn-1',
+    operationCount: 0,
+    phase: 'planning',
+    lastSequence: 0,
+    availability,
+    workspaceSnapshot: workspace,
+};
+/**
+ * Returns the direct dsh child pids, or null when the host forbids process
+ * enumeration (for example hardened sandbox policies that block `ps`).
+ * The liveness assertions degrade to a logged skip instead of failing the
+ * whole proof on a machine that cannot run `ps`.
+ */
+function directDshChildPids() {
+    try {
+        const rows = execFileSync('ps', ['-axo', 'pid=,ppid=,command='], { encoding: 'utf8' });
+        return new Set(rows.split('\n').flatMap((line) => {
+            const match = /^\s*(\d+)\s+(\d+)\s+(.+)$/.exec(line);
+            if (!match || Number(match[2]) !== process.pid || /\bps\s+-axo\b/.test(match[3]))
+                return [];
+            return [Number(match[1])];
+        }));
+    }
+    catch (error) {
+        if (error.code === 'EPERM') {
+            console.log('[core-proof] host forbids `ps`; skipping child-pid liveness assertions (teardown budget still enforced)');
+            return null;
+        }
+        throw error;
+    }
+}
+function processExists(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function runCleanupNegativeControl() {
+    const nodeBinary = process.execPath;
+    const tsxCli = fileURLToPath(new URL('../node_modules/tsx/dist/cli.mjs', import.meta.url));
+    const helper = fileURLToPath(new URL('./booking-copilot-cleanup-proof-helper.js', import.meta.url));
+    const child = spawnSync(nodeBinary, [tsxCli, helper, '--negative-control'], { encoding: 'utf8', timeout: 5_000 });
+    assert.equal(child.error, undefined, `cleanup negative control spawned with ${nodeBinary}`);
+    assert.equal(child.signal, null, 'cleanup negative control exits before its bound');
+    assert.equal(child.status, 0, `cleanup negative control passed: ${child.stderr}`);
+    assert.deepEqual(JSON.parse(child.stdout), {
+        legacy: { caught: 'proof planner cleanup failure', cleanupOrder: ['legacy-planner'] },
+        repaired: {
+            body: 'proof body failure',
+            cleanup: ['proof planner cleanup failure', 'proof port cleanup failure'],
+            cleanupOrder: ['planner', 'port', 'server', 'state-retained'],
+        },
+    }, 'bounded child proof contrasts legacy masking with retained body and cleanup errors while running every cleanup');
+}
+let planner;
+let stalledPlanner;
+let stalledPort;
+let bodyFailed = false;
+let bodyError;
+const plannerMetrics = [];
+// Planner route resolution: a deployment that forgot DEEPSEEK_MODEL must not
+// look like one that set it. The known default route is explicit and reported
+// as `default`, an operator-selected model is reported as `env`/`option`, and a
+// non-default provider has to name its model instead of inheriting a vendor one.
+{
+    const baseEnv = { PATH: process.env.PATH, DEEPSEEK_API_KEY: 'fixture-model-key' };
+    const defaultRoute = resolveRealRunPortConfig({ env: baseEnv });
+    assert.equal(defaultRoute.model, 'deepseek-v4-flash', 'missing DEEPSEEK_MODEL resolves to the known default route');
+    assert.equal(defaultRoute.modelSource, 'default', 'the known default route reports modelSource=default');
+    assert.equal(defaultRoute.reasoningEffort, 'off', 'the known default route disables long reasoning');
+    assert.equal(defaultRoute.maxTokens, 4_096, 'the known default route keeps the 4k budget');
+    const envRoute = resolveRealRunPortConfig({ env: { ...baseEnv, DEEPSEEK_MODEL: 'gateway-selected-model', DEEPSEEK_MAX_TOKENS: '16384' } });
+    assert.equal(envRoute.model, 'gateway-selected-model', 'DEEPSEEK_MODEL selects the route');
+    assert.equal(envRoute.modelSource, 'env', 'an operator-selected model reports modelSource=env');
+    assert.equal(envRoute.reasoningEffort, undefined, 'a custom route keeps its provider reasoning default');
+    assert.equal(envRoute.maxTokens, 16_384, 'DEEPSEEK_MAX_TOKENS is honored');
+    const optionRoute = resolveRealRunPortConfig({ env: baseEnv, model: 'option-model' });
+    assert.equal(optionRoute.model, 'option-model', 'an explicit option selects the route');
+    assert.equal(optionRoute.modelSource, 'option', 'an explicit option reports modelSource=option');
+    assert.throws(() => resolveRealRunPortConfig({ env: baseEnv, provider: 'other-provider' }), /booking_planner_model_required_for_nondefault_provider/, 'a non-default provider must name its model instead of inheriting one');
+    assert.throws(() => resolveRealRunPortConfig({ env: { PATH: process.env.PATH } }), /booking_planner_model_key_required/, 'a missing planner key still fails closed');
+}
+try {
+    runCleanupNegativeControl();
+    planner = await createDshEmbeddedBookingPlanner({
+        stateRoot,
+        env: {
+            PATH: process.env.PATH,
+            DEEPSEEK_API_KEY: 'fixture-model-key',
+            DEEPSEEK_BASE_URL: `http://127.0.0.1:${address.port}/v1`,
+            GOTRY_BOOKING_COPILOT_API_KEY: 'must-not-enter-dsh',
+            HOTELBYTE_TOKEN: 'must-not-enter-dsh',
+        },
+        maxTokens: 512,
+        onMetric: (metric) => plannerMetrics.push(metric),
+    });
+    const session = planner.plannerFactory(task);
+    const decisions = await session.next({ turn, task });
+    assert.equal(decisions.length, 1);
+    assert.equal(decisions[0]?.kind, 'operation');
+    if (decisions[0]?.kind !== 'operation')
+        throw new Error('real dsh did not materialize a booking operation');
+    assert.equal(decisions[0].action.kind, 'search.run');
+    assert.deepEqual(decisions[0].action.input, {});
+    assert.match(decisions[0].action.actionId, /^planner-[a-f0-9]{24}$/);
+    assert.notEqual(decisions[0].action.actionId, action.actionId);
+    assert.equal(requests.length, 3, 'two in-run schema repairs conclude without a redundant post-tool model request');
+    assert.deepEqual(plannerMetrics[0], {
+        outcome: 'operation',
+        decisionSource: 'model',
+        elapsedMs: plannerMetrics[0]?.elapsedMs,
+        harnessRunCount: 1,
+        modelStepCount: 3,
+        schemaRejectedCallCount: 2,
+        firstPassValid: false,
+        schemaRepairedValid: true,
+        proseNudgeRecovered: false,
+        repairedValid: true,
+        bootMs: plannerMetrics[0]?.bootMs,
+        bootMode: plannerMetrics[0]?.bootMode,
+        actionKind: 'search.run',
+    }, 'safe planner metric distinguishes same-turn repair from first-pass validity');
+    assert.ok(Number.isSafeInteger(plannerMetrics[0]?.elapsedMs) && plannerMetrics[0].elapsedMs >= 0);
+    // This planner creates its own runtime, so the turn pays the handshake: the
+    // measurement must attribute that cost to the turn instead of hiding it in
+    // the provider window it shares.
+    assert.equal(plannerMetrics[0]?.bootMode, 'started', 'a turn that owns a fresh runtime reports its own boot');
+    assert.ok(Number.isSafeInteger(plannerMetrics[0]?.bootMs) && plannerMetrics[0].bootMs > 0, 'the turn records the measured initialize cost');
+    // 0.2.0-rc.2 Messages 线型:system 不在 messages 里,是请求体顶层 system 字段。
+    const firstSystem = requests[0].body.system;
+    assert.ok(typeof firstSystem === 'string' && firstSystem.length > 0, 'first model request carries a system message produced by dsh system-prompt');
+    const firstSystemContent = firstSystem;
+    assert.ok(firstSystemContent.includes("You are GoTry's embedded booking planner"), 'first SYSTEM message carries the GoTry personaPrefix (not the generic-default fallback)');
+    assert.ok(firstSystemContent.includes('Shape-only example'), 'first SYSTEM message marks the envelope example as shape-only');
+    assert.ok(firstSystemContent.includes('{"kind":"search.patch","input":{"patch":'), 'first SYSTEM message carries the shallow semantic proposal example');
+    assert.ok(firstSystemContent.includes('"intent":{"target":"search.results"}'), 'first SYSTEM message demonstrates the mandatory semantic goal');
+    for (const runtimeField of ['actionId', 'contextRef', 'expectedRevision', 'sourceFactRef', 'factRefs']) {
+        assert.ok(!JSON.stringify(requests[0].body.tools).includes(`"${runtimeField}"`), `model-facing tools omit runtime-owned ${runtimeField}`);
+    }
+    assert.equal(requests[0].body.model, requests[1].body.model, 'required-intent repair stays in one model session');
+    assert.equal(requests[1].body.model, requests[2].body.model, 'canonical semantic repair stays in the same model session');
+    const requiredIntentRepairMessages = JSON.stringify(requests[1].body.messages);
+    assert.match(requiredIntentRepairMessages, /required property 'intent'|must have required property.*intent/, 'first repair identifies the missing semantic intent');
+    assert.ok(requiredIntentRepairMessages.includes('call-booking-1'), 'first repair references the rejected call id');
+    const canonicalRepairMessages = JSON.stringify(requests[2].body.messages);
+    assert.match(canonicalRepairMessages, /invalid arguments: decision_schema_violation/, 'second repair contains the execute-time canonical ToolArgsError');
+    assert.match(canonicalRepairMessages, /fewer than 1 properties/, 'second repair carries the precise canonical constraint that failed');
+    assert.ok(canonicalRepairMessages.includes('call-booking-repair'), 'second repair references the canonical-schema rejected call id');
+    const toolNames = requests[0].body.tools.map((tool) => tool.function?.name ?? tool.name).sort();
+    assert.deepEqual(toolNames, [...DSH_EMBEDDED_BOOKING_TOOL_NAMES].sort(), 'real model request exposes exactly the embedded tool set');
+    assert.ok(!toolNames.some((name) => /gotry_book|payment|holder|guest/i.test(name)), 'real model request exposes no booking write or PII tool');
+    assert.equal(requests[0].body.model, 'deepseek-v4-flash', 'the default planner model matches the sdk-minimal catalog');
+    assert.deepEqual(requests[0].body.thinking, { type: 'disabled' }, 'known default route disables long reasoning for constrained criteria extraction');
+    const executableKeys = requests[0].body.tools.flatMap((tool) => objectKeys(tool.function?.parameters ?? tool.input_schema));
+    assert.ok(!executableKeys.some((key) => /^(book|payment|holder|guest|portalToken|supplierCost)$/i.test(key)), 'tool inputs expose no write or PII field');
+    // 0.2.0-rc.2 认证头随线型变化(authorization Bearer 或 x-api-key);断言凭据到达,不锁单一头部。
+    assert.ok(requests[0].headers.authorization === 'Bearer fixture-model-key' || requests[0].headers['x-api-key'] === 'fixture-model-key', 'provider credential reaches the provider via the standard auth header');
+    assert.ok(!JSON.stringify(requests).includes('must-not-enter-dsh'), 'BFF and portal credentials never enter the dsh model transport');
+    const proseDecisions = await session.next({ turn, task });
+    assert.equal(proseDecisions[0]?.kind, 'error', 'assistant prose without a tool call never becomes a decision');
+    const continuation = {
+        schemaVersion: 'booking.surface', kind: 'action.receipt.continuation', taskId: task.taskId, workspace,
+        receipt: { schemaVersion: 'booking.surface', kind: 'action.receipt', actionId: decisions[0].action.actionId, contextRef: workspace.contextRef, status: 'applied', revision: 1,
+            observation: { kind: 'search.state', resultCount: 1 }, resultContract: { outcome: 'complete', hardCriteriaMet: true, factRefs: [], gapCodes: [], blockers: [], relaxationsApplied: [] } },
+    };
+    const continuationWorkspace = { ...workspace, revision: 1, results: { status: 'ready', resultCount: 1 } };
+    const boundContinuation = { ...continuation, workspace: continuationWorkspace };
+    const continuationDecisions = await session.next({ turn: boundContinuation, task: { ...task, revision: 1, workspaceSnapshot: continuationWorkspace, lastCompletedAction: completedCheckpoint(decisions[0].action, task.lastTurnId), lastReceipt: continuation.kind === 'action.receipt.continuation' ? continuation.receipt : undefined } });
+    assert.deepEqual(continuationDecisions, [{ kind: 'terminal', terminal: { status: 'completed', summary: 'search_results_ready', factRefs: [] } }], 'real dsh materializes terminal status and summary from the authoritative receipt');
+    // Real SDK/subprocess timeout proof: the user-visible decision deadline is
+    // independent from child teardown, and handle shutdown reaps the actual dsh
+    // process instead of merely incrementing a fake close counter.
+    const childrenBefore = directDshChildPids();
+    const stalledTask = {
+        ...task,
+        taskId: 'task-real-dsh-stalled',
+        contextRef: 'ctx-real-dsh-stalled',
+        lastTurnId: 'real-dsh-stalled-turn',
+        workspaceSnapshot: { ...workspace, contextRef: 'ctx-real-dsh-stalled' },
+    };
+    const stalledTurn = {
+        schemaVersion: 'booking.surface',
+        kind: 'user.turn',
+        taskId: stalledTask.taskId,
+        turnId: stalledTask.lastTurnId,
+        workspace: stalledTask.workspaceSnapshot,
+        request: { text: 'STALL_PROVIDER_PROOF' },
+    };
+    // This case measures a provider stall, after the SAME task-owned port has
+    // completed real SDK initialize. Cold-start timeout is covered separately
+    // by booking-copilot-dsh-readiness-proof.ts without relaxing this deadline.
+    const priorWarmup = process.env.GOTRY_BOOKING_COPILOT_WARMUP;
+    process.env.GOTRY_BOOKING_COPILOT_WARMUP = '0';
+    try {
+        stalledPort = await createRealRunPort({
+            stateRoot,
+            env: {
+                PATH: process.env.PATH,
+                DEEPSEEK_API_KEY: 'fixture-model-key',
+                DEEPSEEK_BASE_URL: `http://127.0.0.1:${address.port}/v1`,
+            },
+            maxTokens: 512,
+        });
+    }
+    finally {
+        if (priorWarmup === undefined)
+            delete process.env.GOTRY_BOOKING_COPILOT_WARMUP;
+        else
+            process.env.GOTRY_BOOKING_COPILOT_WARMUP = priorWarmup;
+    }
+    await stalledPort.warmup();
+    const readyStalledPort = stalledPort;
+    stalledPlanner = await createDshEmbeddedBookingPlanner({
+        runPortFactory: () => readyStalledPort,
+        turnTimeoutMs: 1_500,
+    });
+    const stalledStartedAt = Date.now();
+    const stalledDecisionPromise = stalledPlanner.plannerFactory(stalledTask).next({ turn: stalledTurn, task: stalledTask });
+    await Promise.race([
+        stalledRequestObserved,
+        new Promise((_, reject) => setTimeout(() => reject(new Error('real stalled provider was not reached')), 5_000)),
+    ]);
+    const stalledChildren = childrenBefore === null ? [] : [...directDshChildPids()].filter((pid) => !childrenBefore.has(pid));
+    if (childrenBefore !== null) {
+        assert.ok(stalledChildren.length >= 1, 'real timeout proof observes the task-owned dsh child before the deadline');
+    }
+    const stalledDecisions = await stalledDecisionPromise;
+    const stalledResponseMs = Date.now() - stalledStartedAt;
+    assert.equal(stalledDecisions[0]?.kind, 'error');
+    assert.equal(stalledDecisions[0]?.kind === 'error' ? stalledDecisions[0].error.code : '', 'PLANNER_PROVIDER_TIMEOUT');
+    assert.ok(stalledResponseMs < 3_000, `real stalled provider returns the typed deadline without awaiting teardown (${stalledResponseMs}ms)`);
+    const cleanupStartedAt = Date.now();
+    await stalledPlanner.close();
+    stalledPlanner = undefined;
+    assert.ok(Date.now() - cleanupStartedAt < 3_000, 'real stalled dsh cleanup stays inside the per-turn teardown budget');
+    if (childrenBefore !== null) {
+        assert.ok(stalledChildren.every((pid) => !processExists(pid)), 'real stalled dsh child is reaped after planner shutdown');
+    }
+}
+catch (error) {
+    bodyFailed = true;
+    bodyError = error;
+}
+await throwWithCleanupFailures(bodyFailed, bodyError, [
+    async () => { await stalledPlanner?.close(); },
+    async () => { await stalledPort?.close(); },
+    async () => { await planner?.close(); },
+    async () => {
+        modelServer.closeAllConnections();
+        await new Promise((resolve, reject) => modelServer.close((error) => error ? reject(error) : resolve()));
+    },
+], {
+    onSuccess: () => { rmSync(stateRoot, { recursive: true, force: true }); },
+    onFailure: () => { console.error(`BOOKING COPILOT CLEANUP: retained isolated state at ${stateRoot}`); },
+});
+console.log('BOOKING COPILOT DSH CORE PROOF: real subprocess/sdk/plugin/tool-call/concluded-turn/session event/idle OK');