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

package/dist/src/booking-surface/error-codes.js

@@ -0,0 +1,231 @@
+/** Closed, non-sensitive error vocabulary for planner/runtime boundaries. */
+export const BOOKING_TYPED_ERROR_CODES = [
+    'PAYLOAD_TOO_LARGE',
+    'TASK_NOT_FOUND',
+    'TASK_TERMINAL',
+    'RECEIPT_REQUIRED',
+    'RECEIPT_CONFLICT',
+    'UNSUPPORTED_ACTION',
+    'PLANNER_SURFACE_ACTION_UNSUPPORTED',
+    'PLANNER_NO_DECISION',
+    'PLANNER_TYPED_DECISION_REQUIRED',
+    'PLANNER_PROVIDER_AUTH_FAILED',
+    'PLANNER_PROVIDER_QUOTA_EXHAUSTED',
+    'PLANNER_PROVIDER_RATE_LIMITED',
+    'PLANNER_PROVIDER_UNAVAILABLE',
+    'PLANNER_PROVIDER_REQUEST_REJECTED',
+    'PLANNER_PROVIDER_RESPONSE_INVALID',
+    'PLANNER_PROVIDER_TIMEOUT',
+    'PLANNER_BOOT_TIMEOUT',
+    'PLANNER_CONFIGURATION_INVALID',
+    'PLANNER_FAILED',
+    'INVALID_ACTION',
+    'INVALID_EVENT',
+    'CONTEXT_MISMATCH',
+    'WORKSPACE_MISMATCH',
+    'ACTION_CONFLICT',
+    'STALE_REVISION',
+    'OPERATION_LIMIT_REACHED',
+    'AVAILABILITY_TERMINAL_POLICY_OWNED',
+    'TRUSTED_INGRESS_BINDING_REQUIRED',
+    'INVALID_INGRESS_BINDING',
+    'BOOKING_SURFACE_SCHEMA_MISMATCH',
+    'UNAUTHORIZED',
+    'NOT_FOUND',
+];
+/** Exact, closed reasons safe to expose in dispatch diagnostics. */
+export const BOOKING_DISPATCH_REJECTION_REASONS = [
+    'approval_expired',
+    'approval_mismatch',
+    'approval_not_awaiting',
+    'approval_not_presented',
+    'approval_replayed',
+    'approval_required',
+    'availability_attempt_mismatch',
+    'availability_attempt_unknown',
+    'availability_criteria_changed',
+    'availability_criteria_invalid',
+    'availability_criteria_mismatch',
+    'availability_criteria_required',
+    'availability_duplicate_offer_ref',
+    'availability_duplicate_offer_version_ref',
+    'availability_expected_revision_missing',
+    'availability_generation_mismatch',
+    'availability_hotel_limit_exceeded',
+    'availability_hotel_not_active',
+    'availability_hotel_unknown',
+    'availability_observation_required',
+    'availability_offer_limit_exceeded',
+    'availability_offers_count_mismatch',
+    'availability_offers_hotel_mismatch',
+    'availability_offers_observation_required',
+    'availability_offers_receipt_incoherent',
+    'availability_offers_unreported',
+    'availability_offers_workspace_mismatch',
+    'availability_query_not_reserved',
+    'availability_query_provenance_mismatch',
+    'availability_query_receipt_mismatch',
+    'availability_receipt_digest_mismatch',
+    'availability_receipt_incoherent',
+    'availability_stale_receipt',
+    'availability_terminal',
+    'booking_malformed_workspace',
+    'context_mismatch',
+    'invalid_task_id',
+    'receipt_action_mismatch',
+    'receipt_conflict',
+    'receipt_observation_action_mismatch',
+    'receipt_relaxation_unauthorized',
+    'receipt_required',
+    'receipt_source_action_mismatch',
+    'receipt_source_digest_mismatch',
+    'receipt_target_mismatch',
+    'receipt_verified_offer_expired',
+    'reanchor_turn_required',
+    'request_conflict',
+    'request_key_invalidated',
+    'revision_mismatch',
+    'revision_regression',
+    'task_not_found',
+    'task_terminal',
+    'turn_conflict',
+    'unexpected_receipt',
+    'unsafe_opaque_ref',
+    'workspace_mismatch',
+];
+export const BOOKING_DISPATCH_UNKNOWN_REASON = 'UNCLASSIFIED';
+const DISPATCH_REJECTION_REASON_SET = new Set(BOOKING_DISPATCH_REJECTION_REASONS);
+/** Returns a reason only when the complete boundary error is one known token. */
+export function extractBookingDispatchReason(error) {
+    const message = typeof error === 'string' ? error : error instanceof Error ? error.message : undefined;
+    return message !== undefined && DISPATCH_REJECTION_REASON_SET.has(message)
+        ? message
+        : BOOKING_DISPATCH_UNKNOWN_REASON;
+}
+const ALIASES = {
+    payload_too_large: 'PAYLOAD_TOO_LARGE',
+    task_not_found: 'TASK_NOT_FOUND',
+    task_terminal: 'TASK_TERMINAL',
+    receipt_required: 'RECEIPT_REQUIRED',
+    receipt_conflict: 'RECEIPT_CONFLICT',
+    unsupported_action: 'UNSUPPORTED_ACTION',
+    planner_surface_action_unsupported: 'PLANNER_SURFACE_ACTION_UNSUPPORTED',
+    planner_no_decision: 'PLANNER_NO_DECISION',
+    planner_typed_decision_required: 'PLANNER_TYPED_DECISION_REQUIRED',
+    planner_provider_auth_failed: 'PLANNER_PROVIDER_AUTH_FAILED',
+    planner_provider_quota_exhausted: 'PLANNER_PROVIDER_QUOTA_EXHAUSTED',
+    planner_provider_rate_limited: 'PLANNER_PROVIDER_RATE_LIMITED',
+    planner_provider_unavailable: 'PLANNER_PROVIDER_UNAVAILABLE',
+    planner_provider_request_rejected: 'PLANNER_PROVIDER_REQUEST_REJECTED',
+    planner_provider_response_invalid: 'PLANNER_PROVIDER_RESPONSE_INVALID',
+    planner_provider_timeout: 'PLANNER_PROVIDER_TIMEOUT',
+    planner_boot_timeout: 'PLANNER_BOOT_TIMEOUT',
+    planner_configuration_invalid: 'PLANNER_CONFIGURATION_INVALID',
+    planner_failed: 'PLANNER_FAILED',
+    planner_invalid_tool_arguments: 'PLANNER_PROVIDER_RESPONSE_INVALID',
+    planner_invalid_typed_decision: 'PLANNER_PROVIDER_RESPONSE_INVALID',
+    planner_invalid_action: 'PLANNER_PROVIDER_RESPONSE_INVALID',
+    planner_booking_intent_required: 'PLANNER_PROVIDER_RESPONSE_INVALID',
+    planner_invalid_booking_intent: 'PLANNER_PROVIDER_RESPONSE_INVALID',
+    planner_ambiguous_booking_intent: 'PLANNER_PROVIDER_RESPONSE_INVALID',
+    planner_multiple_typed_decisions: 'PLANNER_PROVIDER_RESPONSE_INVALID',
+    planner_typed_decision_after_candidate: 'PLANNER_PROVIDER_RESPONSE_INVALID',
+    planner_typed_decision_missing: 'PLANNER_PROVIDER_RESPONSE_INVALID',
+    planner_unresolved_tool_call_before_candidate: 'PLANNER_PROVIDER_RESPONSE_INVALID',
+    planner_tool_call_duplicate_call_id: 'PLANNER_PROVIDER_RESPONSE_INVALID',
+    planner_tool_call_missing_call_id: 'PLANNER_PROVIDER_RESPONSE_INVALID',
+    planner_tool_call_rejected: 'PLANNER_PROVIDER_RESPONSE_INVALID',
+    planner_tool_result_malformed: 'PLANNER_PROVIDER_RESPONSE_INVALID',
+    planner_tool_result_out_of_order: 'PLANNER_PROVIDER_RESPONSE_INVALID',
+    planner_tool_result_unmatched: 'PLANNER_PROVIDER_RESPONSE_INVALID',
+    planner_terminal_checkpoint_mismatch: 'PLANNER_PROVIDER_RESPONSE_INVALID',
+    planner_terminal_checkpoint_unavailable: 'PLANNER_PROVIDER_RESPONSE_INVALID',
+    planner_terminal_intent_criteria_unachieved: 'PLANNER_PROVIDER_RESPONSE_INVALID',
+    planner_terminal_intent_target_unachieved: 'PLANNER_PROVIDER_RESPONSE_INVALID',
+    planner_terminal_intent_unjustified: 'PLANNER_PROVIDER_RESPONSE_INVALID',
+    planner_terminal_search_checkpoint_mismatch: 'PLANNER_PROVIDER_RESPONSE_INVALID',
+    planner_terminal_search_patch_not_ready: 'PLANNER_PROVIDER_RESPONSE_INVALID',
+    planner_terminal_search_results_not_ready: 'PLANNER_PROVIDER_RESPONSE_INVALID',
+    planner_terminal_search_workspace_mismatch: 'PLANNER_PROVIDER_RESPONSE_INVALID',
+    planner_forbidden_action: 'UNSUPPORTED_ACTION',
+    planner_forbidden_tool: 'UNSUPPORTED_ACTION',
+    planner_capability_action_mismatch: 'UNSUPPORTED_ACTION',
+    planner_intent_target_unsupported: 'PLANNER_SURFACE_ACTION_UNSUPPORTED',
+    planner_context_mismatch: 'CONTEXT_MISMATCH',
+    planner_revision_mismatch: 'STALE_REVISION',
+    booking_intent_required: 'INVALID_ACTION',
+    invalid_booking_intent: 'INVALID_ACTION',
+    action_intent_mismatch: 'INVALID_ACTION',
+    intent_mutation_forbidden: 'INVALID_ACTION',
+    invalid_action: 'INVALID_ACTION',
+    invalid_event: 'INVALID_EVENT',
+    context_mismatch: 'CONTEXT_MISMATCH',
+    workspace_mismatch: 'WORKSPACE_MISMATCH',
+    action_conflict: 'ACTION_CONFLICT',
+    approval_replayed: 'ACTION_CONFLICT',
+    request_conflict: 'ACTION_CONFLICT',
+    turn_conflict: 'ACTION_CONFLICT',
+    stale_revision: 'STALE_REVISION',
+    operation_limit_reached: 'OPERATION_LIMIT_REACHED',
+    availability_terminal_policy_owned: 'AVAILABILITY_TERMINAL_POLICY_OWNED',
+    trusted_ingress_binding_required: 'TRUSTED_INGRESS_BINDING_REQUIRED',
+    invalid_ingress_binding: 'INVALID_INGRESS_BINDING',
+    booking_surface_schema_mismatch: 'BOOKING_SURFACE_SCHEMA_MISMATCH',
+    unauthorized: 'UNAUTHORIZED',
+    not_found: 'NOT_FOUND',
+};
+const SAFE_MESSAGES = {
+    PAYLOAD_TOO_LARGE: 'Request payload exceeds the configured limit.',
+    TASK_NOT_FOUND: 'The requested task was not found.',
+    TASK_TERMINAL: 'The task is already terminal.',
+    RECEIPT_REQUIRED: 'A matching receipt is required before another action.',
+    RECEIPT_CONFLICT: 'The receipt conflicts with the durable task record.',
+    UNSUPPORTED_ACTION: 'The requested action is outside the trusted action policy.',
+    PLANNER_SURFACE_ACTION_UNSUPPORTED: 'The planner action is outside the trusted surface policy.',
+    PLANNER_NO_DECISION: 'The planner returned no typed decision.',
+    PLANNER_TYPED_DECISION_REQUIRED: 'The planner returned no typed capability decision.',
+    PLANNER_PROVIDER_AUTH_FAILED: 'The planner provider rejected authentication.',
+    PLANNER_PROVIDER_QUOTA_EXHAUSTED: 'The planner provider quota is exhausted.',
+    PLANNER_PROVIDER_RATE_LIMITED: 'The planner provider rate-limited the request.',
+    PLANNER_PROVIDER_UNAVAILABLE: 'The planner provider is temporarily unavailable.',
+    PLANNER_PROVIDER_REQUEST_REJECTED: 'The planner provider rejected the model request.',
+    PLANNER_PROVIDER_RESPONSE_INVALID: 'The planner provider returned an invalid response.',
+    PLANNER_PROVIDER_TIMEOUT: 'The planner did not respond within the booking turn deadline.',
+    PLANNER_BOOT_TIMEOUT: 'The planner runtime did not finish starting within its local boot budget.',
+    PLANNER_CONFIGURATION_INVALID: 'The planner provider configuration is invalid.',
+    PLANNER_FAILED: 'The planner stopped unexpectedly before producing a usable action.',
+    INVALID_ACTION: 'The planner action failed contract validation.',
+    INVALID_EVENT: 'The planner event failed contract validation.',
+    CONTEXT_MISMATCH: 'The request context does not match the trusted task.',
+    WORKSPACE_MISMATCH: 'The request workspace does not match the trusted task.',
+    ACTION_CONFLICT: 'The request conflicts with the durable action checkpoint.',
+    STALE_REVISION: 'The request revision is stale.',
+    OPERATION_LIMIT_REACHED: 'The task operation limit has been reached.',
+    AVAILABILITY_TERMINAL_POLICY_OWNED: 'Availability policy owns the terminal decision.',
+    TRUSTED_INGRESS_BINDING_REQUIRED: 'A trusted ingress binding is required.',
+    INVALID_INGRESS_BINDING: 'The trusted ingress binding is invalid.',
+    BOOKING_SURFACE_SCHEMA_MISMATCH: 'The booking surface schema is not supported.',
+    UNAUTHORIZED: 'The request is not authorized.',
+    NOT_FOUND: 'The requested resource was not found.',
+};
+function rawCode(error) {
+    if (typeof error === 'string')
+        return error.split(':', 1)[0];
+    if (error instanceof Error && error.message)
+        return error.message.split(':', 1)[0];
+    return 'planner_failed';
+}
+export function normalizeBookingErrorCode(error) {
+    const raw = rawCode(error);
+    const normalized = raw.trim().toLowerCase();
+    const aliased = ALIASES[normalized];
+    if (aliased)
+        return aliased;
+    const uppercase = raw.trim().replace(/[^A-Za-z0-9]+/g, '_').toUpperCase();
+    return BOOKING_TYPED_ERROR_CODES.includes(uppercase)
+        ? uppercase
+        : 'PLANNER_FAILED';
+}
+export function safeBookingErrorMessage(code) {
+    return SAFE_MESSAGES[BOOKING_TYPED_ERROR_CODES.includes(code) ? code : 'PLANNER_FAILED'];
+}

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

@@ -0,0 +1,9 @@
+export * from './contracts.js';
+export * from './dsh-planner.js';
+export * from './profile.js';
+export * from './runtime.js';
+export * from './server.js';
+export * from './startup.js';
+export * from './validation.js';
+export * from './availability-policy.js';
+export * from './booking-intent.js';

package/dist/src/booking-surface/managed-dsh-cleanup-diagnostic.js

@@ -0,0 +1,97 @@
+import { execFile } from 'node:child_process';
+/** Diagnostics never include argv, environment, provider output or request data. */
+export class ManagedDshCleanupError extends Error {
+    diagnostic;
+    constructor(message, diagnostic) {
+        // Keep the safe snapshot visible even when nested AggregateError inspection
+        // collapses custom object properties in an uncaught-error log.
+        super(`${message}; diagnostic=${JSON.stringify(diagnostic)}`);
+        this.diagnostic = diagnostic;
+        this.name = 'ManagedDshCleanupError';
+    }
+}
+const MEMBER_LINE = /^(\d+)\s+(\d+)\s+(\d+)\s+([A-Za-z+<NsLlEWXU-]+)\s+(.+?)\s*$/;
+const MAX_MEMBERS = 32;
+/**
+ * Classify one `ps -axo pid=,ppid=,pgid=,stat=,lstart=` table for the owned
+ * group. Pure so proofs can feed crafted tables without signalling anything.
+ */
+export function parseManagedDshGroupSnapshot(stdout, expectedPgid, workerStartedAt = null) {
+    const empty = {
+        status: 'unknown_worker', expectedPgid, members: [], truncated: false, classification: null,
+        liveMemberCount: null, zombieMemberCount: null, workerStartedAt, workerIdentity: null,
+    };
+    if (expectedPgid === null)
+        return { ...empty, status: 'unknown_worker' };
+    const members = [];
+    for (const line of stdout.split('\n')) {
+        const match = line.trim().match(MEMBER_LINE);
+        if (!match || Number(match[3]) !== expectedPgid)
+            continue;
+        members.push({
+            pid: Number(match[1]), ppid: Number(match[2]), pgid: Number(match[3]),
+            state: match[4], startedAt: match[5] ?? null, zombie: match[4].startsWith('Z'),
+        });
+    }
+    const liveMemberCount = members.filter((member) => !member.zombie).length;
+    const zombieMemberCount = members.length - liveMemberCount;
+    const classification = members.length === 0 ? 'empty' : liveMemberCount === 0 ? 'zombie-only' : 'has-live-members';
+    let workerIdentity = 'unknown';
+    if (workerStartedAt !== null) {
+        const workerRow = members.find((member) => member.pid === expectedPgid);
+        workerIdentity = workerRow === undefined
+            ? 'worker-absent'
+            : workerRow.startedAt === workerStartedAt ? 'match' : 'mismatch';
+    }
+    return {
+        status: 'observed', expectedPgid,
+        members: members.slice(0, MAX_MEMBERS), truncated: members.length > MAX_MEMBERS,
+        classification, liveMemberCount, zombieMemberCount,
+        workerStartedAt, workerIdentity,
+    };
+}
+/** Whether the snapshot proves the owned group holds no live member. */
+export function managedDshGroupIsQuiescent(group) {
+    return group.status === 'observed' && (group.classification === 'empty' || group.classification === 'zombie-only');
+}
+/** Read-only one-shot start-time anchor for the live worker (Darwin only). */
+export function readManagedDshWorkerStart(pid) {
+    if (process.platform !== 'darwin')
+        return Promise.resolve(null);
+    return new Promise((resolve) => {
+        execFile('/bin/ps', ['-p', String(pid), '-o', 'lstart='], {
+            encoding: 'utf8', timeout: 250, maxBuffer: 4096,
+            env: { PATH: '/usr/bin:/bin', LC_ALL: 'C' },
+        }, (error, stdout) => resolve(error ? null : stdout.trim() || null));
+    });
+}
+/**
+ * Observe only the detached worker's group, without signalling any process.
+ * Snapshot fields are limited to pid/ppid/pgid/state/start time — never argv,
+ * environment, or request content.
+ */
+export async function snapshotManagedDshGroup(workerPid, workerStartedAt = null) {
+    const empty = {
+        status: 'unknown_worker', expectedPgid: null, members: [], truncated: false, classification: null,
+        liveMemberCount: null, zombieMemberCount: null, workerStartedAt, workerIdentity: null,
+    };
+    if (workerPid === null)
+        return { ...empty, status: 'unknown_worker' };
+    // Only Darwin's installed detached fallback establishes PID == PGID here.
+    // Linux native scopes and Windows Jobs require a provider range identity,
+    // so an unsupported platform claims no expected group at all.
+    if (process.platform !== 'darwin')
+        return { ...empty, status: 'unsupported' };
+    return new Promise((resolve) => {
+        // A separate, bounded failure-only observation; it does not extend the
+        // provider's cleanup deadline or change its success/failure verdict.
+        execFile('/bin/ps', ['-axo', 'pid=,ppid=,pgid=,stat=,lstart='], {
+            encoding: 'utf8', timeout: 250, maxBuffer: 1024 * 1024,
+            env: { PATH: '/usr/bin:/bin', LC_ALL: 'C' },
+        }, (error, stdout) => {
+            if (error)
+                return resolve({ ...empty, expectedPgid: workerPid, status: 'unavailable' });
+            resolve(parseManagedDshGroupSnapshot(stdout, workerPid, workerStartedAt));
+        });
+    });
+}

package/dist/src/booking-surface/managed-dsh-run-port.js

@@ -0,0 +1,244 @@
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { createRequire } from 'node:module';
+import { Context } from '@deepseek-ai/cordis';
+import LocalSubprocessRuntime from '@deepseek-ai/dsh-subprocess-local';
+import { ManagedDshCleanupError, managedDshGroupIsQuiescent, readManagedDshWorkerStart, snapshotManagedDshGroup, } from './managed-dsh-cleanup-diagnostic.js';
+/** The only worker failure classifications allowed to cross the process boundary. */
+const WORKER_FAILURE_CODES = new Set(['HARNESS_BOOT_TIMEOUT', 'HARNESS_START_FAILED', 'HARNESS_RUN_FAILED']);
+const requireFromModule = createRequire(import.meta.url);
+function workerLaunch(path) {
+    // The worker cwd is the isolated booking state root, so a bare `tsx/esm`
+    // loader would resolve from the wrong dependency tree and exit before the
+    // first request. Resolve the loader from this package once and pass its
+    // absolute installed path to Node.
+    return path.endsWith('.ts')
+        ? [process.execPath, '--import', requireFromModule.resolve('tsx/esm'), path]
+        : [process.execPath, path];
+}
+/** Run DeepSeekHarness in a child tree owned by dsh-subprocess-local. */
+export class ManagedDshRunPort {
+    handle;
+    runtime;
+    pending = new Map();
+    sequence = 0;
+    closePromise;
+    terminalError;
+    inputBuffer = '';
+    workerPid = null;
+    workerStartedAt = null;
+    workerOutcome = { state: 'pending' };
+    cleanupRole;
+    graceMs;
+    constructor(options = {}) {
+        const defaultWorker = join(dirname(fileURLToPath(import.meta.url)), 'dsh-worker.js');
+        const workerPath = options.workerPath ?? (existsSync(defaultWorker) ? defaultWorker : defaultWorker.replace(/\.js$/, '.ts'));
+        const { workerPath: _worker, graceMs = 500, cleanupRole, env, groupObserver, bootLog, ...harnessOptions } = options;
+        this.cleanupRole = cleanupRole ?? 'unspecified';
+        this.graceMs = graceMs;
+        this.groupObserver = groupObserver ?? snapshotManagedDshGroup;
+        this.bootLog = bootLog ?? ((line) => { process.stderr.write(`${line}\n`); });
+        this.constructedAtMs = Date.now();
+        this.runtime = new LocalSubprocessRuntime(new Context());
+        this.handle = this.runtime.spawn({
+            argv: workerLaunch(workerPath),
+            cwd: options.cwd ?? process.cwd(),
+            // Provider diagnostics may contain request fragments. Keep a bounded
+            // private tail for ownership without inheriting it into service logs.
+            stdio: { stdin: 'pipe', stdout: 'pipe', stderr: { maxBytes: 64 * 1024 } },
+            graceMs,
+            env,
+        });
+        this.handle.stdout.setEncoding('utf8');
+        this.handle.stdout.on('data', (chunk) => this.consume(chunk));
+        this.handle.done.then((outcome) => {
+            this.workerOutcome = { state: 'exited', exitCode: outcome.exitCode, signal: outcome.signal };
+            this.markTerminal('managed DSH worker exited');
+        }, () => {
+            this.workerOutcome = { state: 'failed' };
+            this.markTerminal('managed DSH worker failed');
+        });
+        // Credentials are already in the managed worker environment. Never copy
+        // them into the JSON-lines protocol or a thrown worker error.
+        this.harnessOptions = harnessOptions;
+        this.cleanupDeadlineMs = Math.max(1_000, graceMs * 4);
+    }
+    harnessOptions;
+    cleanupDeadlineMs;
+    groupObserver;
+    bootLog;
+    constructedAtMs;
+    booted;
+    /**
+     * #511: surface the boot markers in the serving process. The four startup
+     * marker families previously existed only in build-time proof output, so a
+     * recurrence in service runtime left nothing to grep. Payloads are closed
+     * shapes only — role, timings; never prompts, provider fragments, or
+     * credentials.
+     */
+    emitBootLog(line) {
+        try {
+            this.bootLog(line);
+        }
+        catch { /* boot markers must never break the worker protocol */ }
+    }
+    /**
+     * What the most recent worker request paid for the initialize handshake: the
+     * measured wall time when that request started the runtime, and zero when an
+     * earlier request in the same worker already had. Read by the planner to keep
+     * our own boot cost separate from the provider budget it must not consume.
+     */
+    bootObservation() {
+        return this.booted;
+    }
+    consume(chunk) {
+        this.inputBuffer += chunk;
+        for (;;) {
+            const newline = this.inputBuffer.indexOf('\n');
+            if (newline < 0)
+                return;
+            const line = this.inputBuffer.slice(0, newline);
+            this.inputBuffer = this.inputBuffer.slice(newline + 1);
+            try {
+                const message = JSON.parse(line);
+                if (message.lifecycle === 'worker_started') {
+                    if (this.workerPid === null && Number.isSafeInteger(message.workerPid) && message.workerPid > 0 && message.parentPid === process.pid) {
+                        this.workerPid = message.workerPid;
+                        // One bounded read-only start-time anchor, captured while the worker
+                        // is alive, so a later failure snapshot can disprove PID reuse.
+                        void readManagedDshWorkerStart(this.workerPid).then((startedAt) => {
+                            if (this.workerStartedAt === null)
+                                this.workerStartedAt = startedAt;
+                        });
+                    }
+                    continue;
+                }
+                if (message.progress) {
+                    this.pending.get(message.id)?.progress?.();
+                    continue;
+                }
+                // A boot checkpoint carries the initialize handshake the worker already
+                // completed; the terminal reply for the same request still follows, and
+                // a request killed after booting has left this measurement behind.
+                if (message.boot) {
+                    this.booted = message.boot;
+                    // One line per real subprocess boot (#511): only a 'started'
+                    // handshake measured an initialize; 'reused' rode an earlier one.
+                    if (message.boot.mode === 'started') {
+                        this.emitBootLog(`HARNESS_BOOT_STAGE ${JSON.stringify({ role: this.cleanupRole, initializeMs: message.boot.initializeMs, mode: 'started' })}`);
+                    }
+                    if (message.ok === undefined)
+                        continue;
+                }
+                const waiter = this.pending.get(message.id);
+                if (!waiter)
+                    continue;
+                this.pending.delete(message.id);
+                if (message.ok)
+                    waiter.ok(message.result);
+                // Worker stdout is a process boundary: an arbitrary payload must never
+                // become the error the planner classifies on.
+                else if (typeof message.error === 'string' && WORKER_FAILURE_CODES.has(message.error)) {
+                    if (message.error === 'HARNESS_BOOT_TIMEOUT') {
+                        // The worker's own initialize deadline expired before any handshake
+                        // completed; record the closed classification plus what this port
+                        // observable spent on it (closeMs belongs to cleanup diagnostics).
+                        this.emitBootLog(`HARNESS_BOOT_TIMEOUT ${JSON.stringify({
+                            role: this.cleanupRole,
+                            elapsedMs: Date.now() - this.constructedAtMs,
+                            initializeMs: this.booted?.initializeMs ?? null,
+                        })}`);
+                    }
+                    waiter.fail(new Error(message.error));
+                }
+                else
+                    waiter.fail(new Error('HARNESS_RUN_FAILED'));
+            }
+            catch (error) {
+                this.failPending(error instanceof Error ? error : new Error(String(error)));
+            }
+        }
+    }
+    failPending(error) {
+        for (const waiter of this.pending.values())
+            waiter.fail(error);
+        this.pending.clear();
+    }
+    markTerminal(message) {
+        // Retain a safe terminal outcome before rejecting existing waiters: their
+        // continuations may immediately submit another request to this same port.
+        this.terminalError ??= new Error(message);
+        this.failPending(this.terminalError);
+    }
+    run(prompt, options) {
+        if (this.closePromise)
+            return Promise.reject(new Error('managed DSH run port is closed'));
+        if (this.terminalError)
+            return Promise.reject(this.terminalError);
+        const id = ++this.sequence;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { ok: (value) => resolve(value), fail: reject, progress: options.onProgress });
+            this.handle.stdin.write(`${JSON.stringify({ id, prompt, sessionId: options.sessionId, options: this.harnessOptions })}\n`);
+        });
+    }
+    /** Boot the in-worker harness without consuming a provider call. */
+    warmup() {
+        if (this.closePromise)
+            return Promise.reject(new Error('managed DSH run port is closed'));
+        if (this.terminalError)
+            return Promise.reject(this.terminalError);
+        const id = ++this.sequence;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { ok: () => resolve(), fail: reject });
+            this.handle.stdin.write(`${JSON.stringify({ id, warmup: true, options: this.harnessOptions })}\n`);
+        });
+    }
+    close() {
+        if (this.closePromise)
+            return this.closePromise;
+        this.closePromise = (async () => {
+            const started = performance.now();
+            this.failPending(new Error('managed DSH run port closed'));
+            this.handle.terminate();
+            // Observe worker failure even if range observation rejects or times out
+            // first. This derived promise must never become an unhandled rejection.
+            const outcome = this.handle.done.then(() => undefined, () => new Error('managed DSH worker failed'));
+            let rangeEmpty;
+            try {
+                rangeEmpty = await this.handle.waitForExit(AbortSignal.timeout(this.cleanupDeadlineMs));
+            }
+            catch {
+                throw await this.cleanupError('managed DSH process tree observation failed', started);
+            }
+            if (!rangeEmpty) {
+                // On Darwin the installed detached fallback observes the group through
+                // kill(-pgid, 0): a zombie-only group yields EPERM, which the runtime
+                // maps to "alive", and zombies only disappear when their owner reaps
+                // them — no signal can accelerate that. The deadline has not moved;
+                // verify through the safe process table whether a live member actually
+                // remains before converting the observation deadline into a failure.
+                const processGroup = await this.groupObserver(this.workerPid, this.workerStartedAt);
+                if (!managedDshGroupIsQuiescent(processGroup)) {
+                    throw await this.cleanupError('managed DSH process tree cleanup timeout', started, processGroup);
+                }
+            }
+            if (await outcome)
+                throw await this.cleanupError('managed DSH worker failed', started);
+        })();
+        return this.closePromise;
+    }
+    async cleanupError(message, started, processGroup) {
+        const elapsedMs = Math.round(performance.now() - started);
+        const workerOutcome = { ...this.workerOutcome };
+        const group = processGroup ?? await this.groupObserver(this.workerPid, this.workerStartedAt);
+        return new ManagedDshCleanupError(message, {
+            schemaVersion: 'managed-dsh-cleanup.v2', role: this.cleanupRole,
+            workerPid: this.workerPid, elapsedMs, deadlineMs: this.cleanupDeadlineMs,
+            graceMs: this.graceMs, workerOutcome, processGroup: group,
+        });
+    }
+}
+export function createManagedDshRunPort(options) {
+    return new ManagedDshRunPort(options);
+}

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

@@ -0,0 +1,24 @@
+export const EMBEDDED_BOOKING_CAPABILITY_IDS = [
+    'search-hotels',
+    'refine-results',
+    'find-room-offers',
+    'compare-offers',
+    'prepare-booking',
+    'observe-booking',
+];
+/** Closed registry. No booking/payment/write capability exists in this profile. */
+export const embeddedBookingProfile = Object.freeze({
+    id: 'embedded-booking',
+    schemaVersion: 'booking.surface',
+    capabilities: Object.freeze([
+        Object.freeze({ id: 'search-hotels', effect: 'read', actions: Object.freeze(['search.patch', 'search.run']) }),
+        Object.freeze({ id: 'refine-results', effect: 'read', actions: Object.freeze(['results.view.patch', 'hotel.focus', 'hotel.select']) }),
+        Object.freeze({ id: 'find-room-offers', effect: 'read', actions: Object.freeze(['offers.query', 'offers.view.patch']) }),
+        Object.freeze({ id: 'compare-offers', effect: 'read', actions: Object.freeze(['offers.compare', 'offer.select']) }),
+        Object.freeze({ id: 'prepare-booking', effect: 'read', actions: Object.freeze(['offer.check', 'checkout.prepare']) }),
+        Object.freeze({ id: 'observe-booking', effect: 'read', actions: Object.freeze(['order.observe']) }),
+    ]),
+});
+export function actionsForEmbeddedCapability(id) {
+    return embeddedBookingProfile.capabilities.find((capability) => capability.id === id)?.actions ?? [];
+}