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

package/dist/src/booking-surface/runtime.js

@@ -0,0 +1,351 @@
+import { createHash, randomUUID } from 'node:crypto';
+import './contracts.js';
+import { validateBookingCopilotTurnV1, validateActionReceiptV1, validateBookingReadActionV1, validateBookingSurfaceEventV1 } from './validation.js';
+import { normalizeBookingErrorCode, safeBookingErrorMessage } from './error-codes.js';
+const LEDGER_SCHEMA = 'booking.copilot.ledger.v1';
+const LEDGER_ACTOR = 'system:booking-copilot';
+const TASK_STARTED = 'booking.copilot.task.started';
+const USER_TURN_OBSERVED = 'booking.copilot.user.turn.observed';
+const ACTION_ISSUED = 'booking.copilot.action.issued';
+const RECEIPT_OBSERVED = 'booking.copilot.receipt.observed';
+const EVENT_EMITTED = 'booking.copilot.event.emitted';
+function stableValue(value) {
+    if (Array.isArray(value)) return value.map(stableValue);
+    if (typeof value !== 'object' || value === null) return value;
+    const source = value;
+    const target = {};
+    for (const key of Object.keys(source).sort())target[key] = stableValue(source[key]);
+    return target;
+}
+function digest(value) {
+    return createHash('sha256').update(JSON.stringify(stableValue(value))).digest('hex');
+}
+function checkpointDigest(action) {
+    return digest({
+        actionId: action.actionId,
+        kind: action.kind,
+        contextRef: action.contextRef,
+        expectedRevision: action.expectedRevision,
+        factRefs: action.factRefs,
+        reasonDigest: action.reasonDigest,
+        inputDigest: action.inputDigest,
+        eventId: action.eventId,
+        sequence: action.sequence,
+        emittedAt: action.emittedAt
+    });
+}
+function actionMatchesCheckpoint(action, checkpoint) {
+    return checkpoint.actionDigest === checkpointDigest({
+        actionId: checkpoint.actionId,
+        kind: action.kind,
+        contextRef: action.contextRef,
+        expectedRevision: action.expectedRevision,
+        factRefs: action.factRefs,
+        reasonDigest: digest(action.reason),
+        inputDigest: digest(action.input),
+        eventId: checkpoint.eventId,
+        sequence: checkpoint.sequence,
+        emittedAt: checkpoint.emittedAt
+    });
+}
+function assertSafeFactRefs(action) {
+    const opaque = (ref)=>/^[A-Za-z0-9][A-Za-z0-9:._-]*$/.test(ref) && !/^eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/i.test(ref);
+    if (!opaque(action.actionId)) throw new Error('unsafe_action_id');
+    if (action.factRefs.some((ref)=>!opaque(ref))) throw new Error('unsafe_fact_ref');
+}
+function validationMessage(result) {
+    return result.ok ? '' : result.errors.join('; ');
+}
+function assertTaskId(taskId) {
+    if (!taskId) throw new Error('invalid_task_id');
+}
+function sameActionAllowlist(left, right) {
+    return left.length === right.length && [
+        ...left
+    ].sort().every((kind, index)=>kind === [
+            ...right
+        ].sort()[index]);
+}
+export class BookingCopilotTaskRuntime {
+    ledger;
+    idFactory;
+    now;
+    constructor(ledger, options = {}){
+        this.ledger = ledger;
+        this.idFactory = options.idFactory ?? ((prefix)=>`${prefix}-${randomUUID()}`);
+        this.now = options.now ?? (()=>new Date().toISOString());
+    }
+    startTask(turn) {
+        const validation = validateBookingCopilotTurnV1(turn);
+        if (!validation.ok || turn.kind !== 'user.turn') throw new Error(`invalid_planner_turn:${validationMessage(validation)}`);
+        const taskId = turn.taskId ?? this.idFactory('task');
+        assertTaskId(taskId);
+        const requestDigest = digest(turn.request.text);
+        const apply = this.ledger.db.transaction(()=>{
+            const existing = this.resumeTask(taskId);
+            if (existing) {
+                if (existing.contextRef !== turn.workspace.contextRef) throw new Error('task_conflict:context_mismatch');
+                if (existing.surface !== turn.workspace.surface) throw new Error('task_conflict:surface_mismatch');
+                if (existing.revision !== turn.workspace.revision) throw new Error('task_conflict:revision_mismatch');
+                if (!sameActionAllowlist(existing.allowedActions, turn.workspace.capabilities.allowedActions)) {
+                    throw new Error('task_conflict:capability_mismatch');
+                }
+                if (existing.phase === 'waiting_receipt') throw new Error('receipt_required');
+                this.observeUserTurn(taskId, existing.contextRef, requestDigest, existing.userTurnCount + 1);
+                return this.requireTask(taskId);
+            }
+            const foreign = this.ledger.db.prepare("SELECT 1 AS present FROM events WHERE tenant_id = ? AND run_id = ? AND kind LIKE 'booking.copilot.v2.%' LIMIT 1").get(this.ledger.tenant, taskId);
+            if (foreign) throw new Error('task_conflict:protocol_version');
+            const payload = {
+                schema: LEDGER_SCHEMA,
+                taskId,
+                contextRef: turn.workspace.contextRef,
+                surface: turn.workspace.surface,
+                revision: turn.workspace.revision,
+                allowedActions: [
+                    ...turn.workspace.capabilities.allowedActions
+                ]
+            };
+            this.appendLedgerEvent(TASK_STARTED, taskId, payload, `booking-copilot:task:${taskId}`);
+            this.observeUserTurn(taskId, turn.workspace.contextRef, requestDigest, 1);
+            return this.requireTask(taskId);
+        });
+        return apply.immediate();
+    }
+    resumeTask(taskId) {
+        assertTaskId(taskId);
+        const rows = this.readTaskRows(taskId);
+        if (rows.length === 0) return null;
+        let state = null;
+        for (const row of rows){
+            const payload = JSON.parse(row.payload);
+            if (payload.schema !== LEDGER_SCHEMA || payload.taskId !== taskId) throw new Error(`ledger_corrupt:${taskId}:seq=${row.seq}`);
+            if (row.kind === TASK_STARTED) {
+                const started = payload;
+                if (state) throw new Error(`ledger_corrupt:${taskId}:duplicate_start`);
+                state = {
+                    schemaVersion: 'booking.surface.v1',
+                    taskId,
+                    contextRef: started.contextRef,
+                    surface: started.surface,
+                    revision: started.revision,
+                    allowedActions: [
+                        ...started.allowedActions
+                    ],
+                    userTurnCount: 0,
+                    phase: 'planning',
+                    lastSequence: 0
+                };
+                continue;
+            }
+            if (!state) throw new Error(`ledger_corrupt:${taskId}:event_before_start`);
+            if (payload.contextRef !== state.contextRef) throw new Error(`ledger_corrupt:${taskId}:context_drift`);
+            if (row.kind === USER_TURN_OBSERVED) {
+                const observed = payload;
+                state.userTurnCount += 1;
+                state.lastUserTurnDigest = observed.requestDigest;
+            } else if (row.kind === ACTION_ISSUED) {
+                const issued = payload;
+                if (issued.action.actionDigest !== checkpointDigest(issued.action)) throw new Error(`ledger_corrupt:${taskId}:action`);
+                if (state.pendingAction) throw new Error(`ledger_corrupt:${taskId}:parallel_actions`);
+                state.pendingAction = issued.action;
+                state.phase = 'waiting_receipt';
+                state.lastSequence = Math.max(state.lastSequence, issued.action.sequence);
+            } else if (row.kind === RECEIPT_OBSERVED) {
+                const observed = payload;
+                if (observed.receiptDigest !== digest(observed.receipt) || !validateActionReceiptV1(observed.receipt).ok) {
+                    throw new Error(`ledger_corrupt:${taskId}:receipt`);
+                }
+                if (!state.pendingAction || state.pendingAction.actionId !== observed.receipt.actionId) {
+                    throw new Error(`ledger_corrupt:${taskId}:orphan_receipt`);
+                }
+                state.lastReceipt = observed.receipt;
+                state.revision = observed.receipt.revision;
+                delete state.pendingAction;
+                state.phase = 'planning';
+            } else if (row.kind === EVENT_EMITTED) {
+                const emitted = payload;
+                state.lastSequence = Math.max(state.lastSequence, emitted.sequence);
+            }
+        }
+        return state;
+    }
+    issueOperation(taskId, action) {
+        const validation = validateBookingReadActionV1(action);
+        if (!validation.ok) throw new Error(`invalid_action:${validation.errors.join('; ')}`);
+        assertSafeFactRefs(action);
+        const apply = this.ledger.db.transaction(()=>{
+            const state = this.requireTask(taskId);
+            const reasonDigest = digest(action.reason);
+            const inputDigest = digest(action.input);
+            if (state.pendingAction) {
+                if (state.pendingAction.actionId !== action.actionId) throw new Error('receipt_required');
+                if (!actionMatchesCheckpoint(action, state.pendingAction)) throw new Error('action_conflict');
+                return {
+                    schemaVersion: 'booking.surface.v1',
+                    eventId: state.pendingAction.eventId,
+                    taskId,
+                    contextRef: state.pendingAction.contextRef,
+                    sequence: state.pendingAction.sequence,
+                    emittedAt: state.pendingAction.emittedAt,
+                    kind: 'operation',
+                    action
+                };
+            }
+            const historicalReceipt = this.ledger.db.prepare(`SELECT payload FROM events WHERE tenant_id = ? AND run_id = ? AND kind = ?`).all(this.ledger.tenant, taskId, RECEIPT_OBSERVED);
+            if (historicalReceipt.some((row)=>JSON.parse(row.payload).receipt?.actionId === action.actionId)) throw new Error('action_already_receipted');
+            if (state.lastReceipt?.actionId === action.actionId) throw new Error('action_already_receipted');
+            if (action.contextRef !== state.contextRef) throw new Error('context_mismatch');
+            if (!new Set(state.allowedActions).has(action.kind)) throw new Error('unsupported_action');
+            if (action.expectedRevision !== state.revision) throw new Error('stale_revision');
+            const event = {
+                schemaVersion: 'booking.surface.v1',
+                eventId: this.idFactory('event'),
+                taskId,
+                contextRef: state.contextRef,
+                sequence: state.lastSequence + 1,
+                emittedAt: this.now(),
+                kind: 'operation',
+                action
+            };
+            const eventValidation = validateBookingSurfaceEventV1(event);
+            if (!eventValidation.ok) throw new Error(`invalid_operation_event:${eventValidation.errors.join('; ')}`);
+            const checkpointBase = {
+                actionId: action.actionId,
+                kind: action.kind,
+                contextRef: action.contextRef,
+                expectedRevision: action.expectedRevision,
+                factRefs: [
+                    ...action.factRefs
+                ],
+                reasonDigest,
+                inputDigest,
+                eventId: event.eventId,
+                sequence: event.sequence,
+                emittedAt: event.emittedAt
+            };
+            const checkpoint = {
+                ...checkpointBase,
+                actionDigest: checkpointDigest(checkpointBase)
+            };
+            const payload = {
+                schema: LEDGER_SCHEMA,
+                taskId,
+                contextRef: state.contextRef,
+                action: checkpoint
+            };
+            this.appendActionIssued(taskId, payload, `booking-copilot:action:${taskId.length}:${taskId}:${action.actionId.length}:${action.actionId}`);
+            return event;
+        });
+        return apply.immediate();
+    }
+    continueWithReceipt(turn) {
+        const validation = validateBookingCopilotTurnV1(turn);
+        if (!validation.ok || turn.kind !== 'action.receipt.continuation') {
+            throw new Error(`invalid_receipt_continuation:${validationMessage(validation)}`);
+        }
+        const receiptDigest = digest(turn.receipt);
+        const apply = this.ledger.db.transaction(()=>{
+            const state = this.requireTask(turn.taskId);
+            if (turn.workspace.contextRef !== state.contextRef || turn.receipt.contextRef !== state.contextRef) throw new Error('context_mismatch');
+            const history = this.ledger.db.prepare(`SELECT payload FROM events WHERE tenant_id = ? AND run_id = ? AND kind = ? ORDER BY seq`).all(this.ledger.tenant, turn.taskId, RECEIPT_OBSERVED);
+            for (const row of history){
+                const prior = JSON.parse(row.payload);
+                if (prior.receipt?.actionId !== turn.receipt.actionId) continue;
+                if (prior.schema !== LEDGER_SCHEMA || prior.taskId !== turn.taskId || prior.contextRef !== state.contextRef || prior.receiptDigest !== digest(prior.receipt) || !validateActionReceiptV1(prior.receipt).ok) throw new Error('ledger_corrupt:receipt');
+                if (prior.receiptDigest !== receiptDigest) throw new Error('receipt_conflict');
+                return state;
+            }
+            if (!state.pendingAction) throw new Error('unexpected_receipt');
+            if (state.pendingAction.actionId !== turn.receipt.actionId) throw new Error('receipt_action_mismatch');
+            if (turn.receipt.revision < state.pendingAction.expectedRevision) throw new Error('revision_regression');
+            const payload = {
+                schema: LEDGER_SCHEMA,
+                taskId: turn.taskId,
+                contextRef: state.contextRef,
+                receipt: turn.receipt,
+                receiptDigest
+            };
+            const idemKey = `booking-copilot:receipt:${turn.taskId.length}:${turn.taskId}:${turn.receipt.actionId.length}:${turn.receipt.actionId}`;
+            const info = this.ledger.db.prepare(`INSERT INTO events (tenant_id, ts, actor, kind, subject_id, payload, idem_key, run_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(this.ledger.tenant, this.now(), LEDGER_ACTOR, RECEIPT_OBSERVED, turn.taskId, JSON.stringify(payload), idemKey, turn.taskId);
+            if (info.changes !== 1) throw new Error('ledger_write_failed:receipt');
+            return this.requireTask(turn.taskId);
+        });
+        return apply.immediate();
+    }
+    emitEvent(taskId, draft) {
+        const apply = this.ledger.db.transaction(()=>{
+            const state = this.requireTask(taskId);
+            const safeDraft = draft.kind === 'error' ? {
+                ...draft,
+                error: {
+                    ...draft.error,
+                    code: normalizeBookingErrorCode(draft.error.code),
+                    message: safeBookingErrorMessage(normalizeBookingErrorCode(draft.error.code))
+                }
+            } : draft;
+            const event = {
+                schemaVersion: 'booking.surface.v1',
+                eventId: this.idFactory('event'),
+                taskId,
+                contextRef: state.contextRef,
+                sequence: state.lastSequence + 1,
+                emittedAt: this.now(),
+                ...safeDraft
+            };
+            const validation = validateBookingSurfaceEventV1(event);
+            if (!validation.ok) throw new Error(`invalid_event:${validation.errors.join('; ')}`);
+            const payload = {
+                schema: LEDGER_SCHEMA,
+                taskId,
+                contextRef: state.contextRef,
+                eventId: event.eventId,
+                sequence: event.sequence,
+                emittedAt: event.emittedAt,
+                eventKind: event.kind,
+                contentDigest: digest(safeDraft)
+            };
+            this.appendLedgerEvent(EVENT_EMITTED, taskId, payload, `booking-copilot:event:${taskId}:${event.eventId}`);
+            return event;
+        });
+        return apply.immediate();
+    }
+    requireTask(taskId) {
+        const state = this.resumeTask(taskId);
+        if (!state) throw new Error('task_not_found');
+        return state;
+    }
+    readTaskRows(taskId) {
+        return this.ledger.db.prepare(`SELECT seq, kind, payload FROM events
+       WHERE tenant_id = ? AND run_id = ?
+         AND kind IN (?, ?, ?, ?, ?)
+       ORDER BY seq`).all(this.ledger.tenant, taskId, TASK_STARTED, USER_TURN_OBSERVED, ACTION_ISSUED, RECEIPT_OBSERVED, EVENT_EMITTED);
+    }
+    observeUserTurn(taskId, contextRef, requestDigest, ordinal) {
+        const payload = {
+            schema: LEDGER_SCHEMA,
+            taskId,
+            contextRef,
+            requestDigest
+        };
+        this.appendLedgerEvent(USER_TURN_OBSERVED, taskId, payload, `booking-copilot:user-turn:${taskId}:${ordinal}`);
+    }
+    appendLedgerEvent(kind, taskId, payload, idemKey) {
+        const result = this.ledger.db.prepare(`INSERT OR IGNORE INTO events
+       (tenant_id, ts, actor, kind, subject_id, payload, idem_key, run_id)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(this.ledger.tenant, this.now(), LEDGER_ACTOR, kind, taskId, JSON.stringify(payload), idemKey, taskId);
+        if (result.changes > 0) return Number(result.lastInsertRowid);
+        const existing = this.ledger.db.prepare('SELECT seq FROM events WHERE tenant_id = ? AND idem_key = ?').get(this.ledger.tenant, idemKey);
+        if (!existing) throw new Error(`ledger_write_failed:${kind}`);
+        return existing.seq;
+    }
+    appendActionIssued(taskId, payload, idemKey) {
+        const result = this.ledger.db.prepare(`INSERT INTO events (tenant_id, ts, actor, kind, subject_id, payload, idem_key, run_id)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(this.ledger.tenant, this.now(), LEDGER_ACTOR, ACTION_ISSUED, taskId, JSON.stringify(payload), idemKey, taskId);
+        if (result.changes !== 1) throw new Error('ledger_write_failed:action');
+        return Number(result.lastInsertRowid);
+    }
+}
+
+
+//# sourceURL=ts/src/booking-surface/runtime.ts

package/dist/src/booking-surface/server-v2.js

@@ -0,0 +1,334 @@
+import { BOOKING_SURFACE_SCHEMA_V2_SHA256, BOOKING_SURFACE_SCHEMA_VERSION_V2, BOOKING_COPILOT_V2_ACCEPTED_TURN_KINDS, BOOKING_READ_ACTION_KINDS_V2, BOOKING_SURFACE_ALLOWED_ACTIONS_V2 } from './contracts-v2.js';
+import { BookingCopilotTaskRuntimeV2 } from './runtime-v2.js';
+import { validateBookingSurfaceV2 } from './validation-v2.js';
+import { normalizeBookingErrorCode, safeBookingErrorMessage } from './error-codes.js';
+const sessionsByAdapter = new WeakMap();
+const decisionFlightsByAdapter = new WeakMap();
+function sessionsFor(adapter) {
+    let sessions = sessionsByAdapter.get(adapter);
+    if (!sessions) {
+        sessions = new Map();
+        sessionsByAdapter.set(adapter, sessions);
+    }
+    return sessions;
+}
+function decisionFlightsFor(adapter) {
+    let flights = decisionFlightsByAdapter.get(adapter);
+    if (!flights) {
+        flights = new Map();
+        decisionFlightsByAdapter.set(adapter, flights);
+    }
+    return flights;
+}
+async function runDecisionSingleFlight(adapter, key, work) {
+    const flights = decisionFlightsFor(adapter);
+    const prior = flights.get(key);
+    if (prior) return prior;
+    const current = work();
+    flights.set(key, current);
+    try {
+        return await current;
+    } finally{
+        if (flights.get(key) === current) flights.delete(key);
+    }
+}
+function send(res, status, body) {
+    res.writeHead(status, {
+        'content-type': 'application/json; charset=utf-8'
+    });
+    res.end(JSON.stringify(body));
+}
+function readBody(req, max) {
+    return new Promise((resolve, reject)=>{
+        const chunks = [];
+        let size = 0;
+        let tooLarge = false;
+        req.on('data', (chunk)=>{
+            size += chunk.length;
+            if (size > max) tooLarge = true;
+            else chunks.push(chunk);
+        });
+        req.on('end', ()=>tooLarge ? reject(new Error('payload_too_large')) : resolve(Buffer.concat(chunks).toString('utf8')));
+        req.on('error', reject);
+    });
+}
+function write(res, event) {
+    res.write(`event: ${event.kind}\ndata: ${JSON.stringify(event)}\n\n`);
+}
+export { normalizeBookingErrorCode as bookingPlannerErrorCode, safeBookingErrorMessage as bookingPlannerErrorMessage } from './error-codes.js';
+function sameCapabilities(a, b) {
+    return a.length === b.length && [
+        ...a
+    ].sort().every((kind, index)=>kind === [
+            ...b
+        ].sort()[index]);
+}
+function exactKeys(value, allowed) {
+    return Object.keys(value).length === allowed.length && Object.keys(value).every((key)=>allowed.includes(key));
+}
+const SURFACE_ACTION_MATRIX = BOOKING_SURFACE_ALLOWED_ACTIONS_V2;
+function validSurfaceActions(surface, allowed) {
+    if (typeof surface !== 'string' || !Object.prototype.hasOwnProperty.call(SURFACE_ACTION_MATRIX, surface)) return false;
+    if (!Array.isArray(allowed) || allowed.length < 1 || new Set(allowed).size !== allowed.length) return false;
+    const matrix = SURFACE_ACTION_MATRIX[surface];
+    return allowed.every((action)=>typeof action === 'string' && matrix.includes(action) && BOOKING_READ_ACTION_KINDS_V2.includes(action));
+}
+function validBoundWorkspaceAuthority(workspace) {
+    return workspace.capabilities.surface === workspace.surface && validSurfaceActions(workspace.surface, workspace.capabilities.allowedActions);
+}
+function validIngressBinding(binding, ingress) {
+    if (!binding || typeof binding !== 'object' || Array.isArray(binding)) return false;
+    const candidate = binding;
+    if (!exactKeys(candidate, [
+        'taskId',
+        'turnId',
+        'contextRef',
+        'surface',
+        'allowedActions'
+    ])) return false;
+    if (typeof candidate.taskId !== 'string' || typeof candidate.turnId !== 'string' || typeof candidate.contextRef !== 'string') return false;
+    if (typeof candidate.surface !== 'string' || candidate.surface !== ingress.surfaceHint || !Object.prototype.hasOwnProperty.call(SURFACE_ACTION_MATRIX, candidate.surface)) return false;
+    return validSurfaceActions(candidate.surface, candidate.allowedActions);
+}
+function fallbackErrorEvent(task, code) {
+    return {
+        schemaVersion: BOOKING_SURFACE_SCHEMA_VERSION_V2,
+        eventId: `error-${task.taskId}-${task.lastSequence + 1}`,
+        taskId: task.taskId,
+        contextRef: task.contextRef,
+        sequence: task.lastSequence + 1,
+        emittedAt: new Date().toISOString(),
+        kind: 'error',
+        error: {
+            code: normalizeBookingErrorCode(code),
+            message: safeBookingErrorMessage(normalizeBookingErrorCode(code)),
+            retryable: false
+        }
+    };
+}
+function writeTypedError(res, adapter, task, error, requestKey, includeSubmitted = false) {
+    const code = normalizeBookingErrorCode(error);
+    try {
+        const decision = {
+            kind: 'error',
+            error: {
+                code,
+                message: safeBookingErrorMessage(code),
+                retryable: false
+            }
+        };
+        if (requestKey) {
+            const events = adapter.runtime.applyDecisionBatch(task.taskId, requestKey, [
+                decision
+            ], includeSubmitted);
+            for (const event of events)write(res, event);
+            return;
+        }
+        write(res, adapter.runtime.emitEvent(task.taskId, decision));
+    } catch  {
+        write(res, fallbackErrorEvent(task, code));
+    }
+}
+export async function handleBookingCopilotV2Request(req, res, adapter, maxBodyBytes) {
+    let turn;
+    let browserRequestKey;
+    let requestBinding;
+    try {
+        const parsed = JSON.parse(await readBody(req, maxBodyBytes));
+        const valid = validateBookingSurfaceV2(parsed);
+        if (!valid.ok) {
+            send(res, 400, {
+                error: {
+                    code: 'invalid_booking_surface_turn',
+                    details: valid.errors
+                }
+            });
+            return;
+        }
+        if (parsed.kind === 'user.turn.ingress') {
+            const ingress = parsed;
+            browserRequestKey = ingress.requestKey;
+            if (adapter.ingressMode !== 'bff-ingress-binding' || !adapter.ingressBinding || !adapter.principal) {
+                send(res, 503, {
+                    error: {
+                        code: 'trusted_ingress_binding_required',
+                        mode: adapter.ingressMode ?? 'bff-bound-turn-only',
+                        acceptedTurnKinds: [
+                            ...BOOKING_COPILOT_V2_ACCEPTED_TURN_KINDS
+                        ]
+                    }
+                });
+                return;
+            }
+            const binding = await adapter.ingressBinding.bind(ingress, adapter.principal);
+            if (!validIngressBinding(binding, ingress)) {
+                send(res, 502, {
+                    error: {
+                        code: 'invalid_ingress_binding'
+                    }
+                });
+                return;
+            }
+            const boundWorkspace = {
+                ...ingress.workspace,
+                contextRef: binding.contextRef,
+                surface: binding.surface,
+                capabilities: {
+                    surface: binding.surface,
+                    allowedActions: [
+                        ...binding.allowedActions
+                    ]
+                }
+            };
+            turn = {
+                schemaVersion: 'booking.surface.v2',
+                kind: 'user.turn',
+                taskId: binding.taskId,
+                turnId: binding.turnId,
+                workspace: boundWorkspace,
+                request: ingress.request
+            };
+            requestBinding = {
+                requestKey: ingress.requestKey,
+                principal: adapter.principal,
+                ...ingress.taskHandle ? {
+                    taskHandle: ingress.taskHandle
+                } : {}
+            };
+            const boundValid = validateBookingSurfaceV2(turn);
+            if (!boundValid.ok) {
+                send(res, 502, {
+                    error: {
+                        code: 'invalid_ingress_binding',
+                        details: boundValid.errors
+                    }
+                });
+                return;
+            }
+        } else {
+            turn = parsed;
+            if (!validBoundWorkspaceAuthority(turn.workspace)) {
+                send(res, 403, {
+                    error: {
+                        code: 'invalid_bound_turn_authority'
+                    }
+                });
+                return;
+            }
+        }
+    } catch (error) {
+        const code = normalizeBookingErrorCode(error);
+        send(res, code === 'PAYLOAD_TOO_LARGE' ? 413 : 400, {
+            error: {
+                code
+            }
+        });
+        return;
+    }
+    let task;
+    let fresh = false;
+    let replayKey;
+    let replayEvents = null;
+    let activeDecisionKey;
+    try {
+        fresh = turn.kind === 'action.receipt.continuation' ? false : !turn.taskId || adapter.runtime.resumeTask(turn.taskId) === null;
+        if (turn.kind === 'action.receipt.continuation') {
+            replayKey = `receipt:${turn.receipt.actionId}:${adapter.runtime.receiptDigest(turn.receipt)}`;
+            task = adapter.runtime.continueWithReceipt(turn);
+            if (task.awaitingApproval) {
+                replayKey = adapter.runtime.approvalPresentationRequestKey(turn.taskId);
+            }
+            replayEvents = adapter.runtime.readDecisionBatch(turn.taskId, replayKey);
+            if (!replayEvents && task.phase === 'terminal') replayEvents = adapter.runtime.terminalDecisionBatch(turn.taskId, replayKey);
+        } else {
+            const existing = turn.taskId ? adapter.runtime.resumeTask(turn.taskId) : null;
+            if (requestBinding && turn.kind === 'user.turn') adapter.runtime.assertRequestBinding(browserRequestKey, turn, requestBinding);
+            const requestReplayKey = existing && browserRequestKey ? `ingress:${existing.taskId}:${browserRequestKey}` : undefined;
+            const directReplayKey = existing && turn.kind === 'user.turn' && turn.turnId ? `turn:${existing.taskId}:${turn.turnId}` : undefined;
+            const stableReplayKey = requestReplayKey ?? directReplayKey;
+            const stableReplay = stableReplayKey ? adapter.runtime.readDecisionBatch(existing.taskId, stableReplayKey) : null;
+            if (stableReplay) {
+                if (existing && turn.kind === 'user.turn' && directReplayKey) adapter.runtime.assertTurnBinding(existing.taskId, turn);
+                task = existing;
+                replayKey = stableReplayKey;
+                replayEvents = stableReplay;
+            } else if (existing?.phase === 'terminal' || existing?.phase === 'error') {
+                throw new Error('task_terminal');
+            } else if (existing?.phase === 'waiting_receipt') {
+                const workspace = turn.workspace;
+                if (workspace.contextRef !== existing.contextRef || workspace.surface !== existing.surface || workspace.revision !== existing.revision || workspace.capabilities.surface !== existing.surface || !sameCapabilities(workspace.capabilities.allowedActions, existing.allowedActions)) throw new Error('task_conflict:workspace_mismatch');
+                if (!turn.turnId || existing.lastTurnId !== turn.turnId) throw new Error('receipt_required');
+                replayKey = browserRequestKey ? `ingress:${existing.taskId}:${browserRequestKey}` : `turn:${existing.taskId}:${existing.lastTurnId ?? existing.userTurnCount}`;
+                replayEvents = adapter.runtime.readDecisionBatch(existing.taskId, replayKey);
+                if (!replayEvents) throw new Error('receipt_required');
+                task = existing;
+            } else {
+                task = adapter.runtime.startTask(turn, requestBinding);
+                if (turn.kind === 'user.turn' && turn.taskId) {
+                    replayKey = browserRequestKey ? `ingress:${task.taskId}:${browserRequestKey}` : `turn:${task.taskId}:${turn.turnId ?? task.userTurnCount}`;
+                    replayEvents = adapter.runtime.readDecisionBatch(task.taskId, replayKey);
+                }
+            }
+        }
+    } catch (error) {
+        send(res, 409, {
+            error: {
+                code: normalizeBookingErrorCode(error)
+            }
+        });
+        return;
+    }
+    res.writeHead(200, {
+        'content-type': 'text/event-stream; charset=utf-8',
+        'cache-control': 'no-cache, no-transform',
+        connection: 'keep-alive',
+        'x-content-type-options': 'nosniff',
+        'x-booking-surface-version': BOOKING_SURFACE_SCHEMA_VERSION_V2,
+        'x-booking-surface-schema-sha256': BOOKING_SURFACE_SCHEMA_V2_SHA256
+    });
+    try {
+        if (replayEvents) {
+            for (const event of replayEvents)write(res, event);
+        } else {
+            const requestKey = replayKey ?? `turn:${task.taskId}:${task.userTurnCount}`;
+            activeDecisionKey = requestKey;
+            const flightKey = JSON.stringify([
+                task.taskId,
+                requestKey
+            ]);
+            const decisionEvents = await runDecisionSingleFlight(adapter, flightKey, async ()=>{
+                if (turn.kind === 'action.receipt.continuation' && task.awaitingApproval) {
+                    return adapter.runtime.applyDecisionBatch(task.taskId, requestKey, [
+                        adapter.runtime.approvalQuestion(task.taskId)
+                    ], false);
+                }
+                const sessions = sessionsFor(adapter);
+                const session = sessions.get(task.taskId) ?? adapter.plannerFactory(task);
+                sessions.set(task.taskId, session);
+                const decisions = await session.next({
+                    turn,
+                    task: adapter.runtime.resumeTask(task.taskId) ?? task
+                });
+                const plannerDecisions = decisions.length ? decisions : [
+                    {
+                        kind: 'error',
+                        error: {
+                            code: 'PLANNER_NO_DECISION',
+                            message: 'Planner returned no typed decision.',
+                            retryable: false
+                        }
+                    }
+                ];
+                return adapter.runtime.applyDecisionBatch(task.taskId, requestKey, plannerDecisions, fresh);
+            });
+            for (const event of decisionEvents)write(res, event);
+        }
+    } catch (error) {
+        writeTypedError(res, adapter, task, error, activeDecisionKey, fresh);
+    } finally{
+        res.end();
+    }
+}
+
+
+//# sourceURL=ts/src/booking-surface/server-v2.ts