@loucompanion/forge-bridge 0.1.3-dev.fbe15023cdfe → 0.1.4-dev.1ff37038366e

package/dist/bridge/bridge.service.js

@@ -4,25 +4,55 @@ import path from "node:path";
 import { randomUUID } from "node:crypto";
 import os from "node:os";
 import { defaultForgeBridgeConfig } from "../config.js";
-import { supportsDraftImageAttachmentsFor } from "../shared/provider-capabilities.js";
+import { bridgeChatCapabilityFor, supportsDraftImageAttachmentsFor } from "../shared/provider-capabilities.js";
 import { redactText } from "../shared/redaction/redaction.js";
 import { BridgeSessionService } from "../session/session.service.js";
 import { ProcessBackedProviderCliService, RoutingProviderCliService, StreamingProviderProcessRunner, } from "../session/provider-cli/provider-cli.service.js";
+import { codexSandboxModeForPlatform, formatProviderCliCommandForCheckpoint } from "../session/provider-cli/provider-cli.prompts.js";
+import { clip, createProviderOutputState } from "../session/provider-cli/provider-output-state.js";
 import { redactRunnerDispatchEvent, redactRunOnceResultPacket } from "../session/session-redaction.js";
-import { HostRuntimeLeaseManager } from "../runtime/host-runtime-lease.js";
+import { PrePublicationValidator } from "../session/pre-publication-validation.js";
+import { HostRuntimeLeaseManager, } from "../runtime/host-runtime-lease.js";
+import { assertHostDatabaseCapabilityBoundary, establishHostDatabaseCapabilityBoundary, } from "../runtime/host-database-capability-boundary.js";
+import { defaultHostExecutionRoot } from "../runtime/host-execution-root.js";
+import { buildMemoryAdmissionDiagnostics } from "../runtime/memory-capacity.js";
+import { DockerEngineProbe } from "../runtime/docker-engine-probe.js";
+import { createNativeTestClusterDatabaseBroker } from "../runtime/attempt-database-broker.js";
+import { readNativeTestPostgresFallback } from "../runtime/native-test-postgres-fallback.js";
+import { estimateWorkspaceBytesFromRepo } from "../runtime/workspace-resource-estimator.js";
 import { GitWorktreeService } from "../worktree/worktree.service.js";
 import { RepositoryCoordinatorLock } from "../sandbox/repository-lock.js";
 import { AttemptCoordinatedProviderProcessRunner, AttemptProcessSupervisorRegistry, } from "../runtime/attempt-process-supervisor-registry.js";
-import { failureResult, parseRunOnceDispatchPacket } from "../session/session.types.js";
+import { failureFactsForCode, failureFactsFromError, failureResult, parseRunOnceDispatchPacket } from "../session/session.types.js";
 import { forgeBridgeVersion } from "../version.js";
 import { canRunDockerMaintenance, DockerPreflight } from "../sandbox/preflight.js";
 import { validateSandboxContract } from "../sandbox/contract.js";
 import { runSandboxProcess } from "../sandbox/process.js";
 import { DockerSandboxRuntime, selectSandboxConfigRefs } from "../sandbox/runtime.js";
 import { codexSandboxProviderAuthAdapter, sandboxProviderAuthAdapterFor, sandboxProviderAuthUnavailableMessage } from "../sandbox/provider-auth/codex.js";
+import { assertBridgeChatCallbackPayload, bridgeChatMaxProviderThreadIdChars, bridgeChatProtocolVersion, isTerminalChatTurnCallbackKind, parseChatTurnDispatchPacket, } from "./bridge-chat.types.js";
+import { formatBytes } from "../shared/format/format-bytes.js";
+import { emptyRunnerHostCapabilitySnapshot, ProcessRunnerHostCapabilityProbe, } from "./runner-host-capabilities.js";
+import { FileReadinessResultOutbox } from "./readiness-result-outbox.js";
+import { FileDispatchResultOutbox } from "./dispatch-result-outbox.js";
+/**
+ * Protocol-v2 events are acknowledged one at a time before runOnce returns.
+ * Sending the complete transcript again in DispatchResult made long QA and CI
+ * sessions exceed SignalR's receive limit, disconnecting the bridge after the
+ * provider had already completed. The API combines its acknowledged streamed
+ * events with the terminal result, so the callback only needs the outcome and
+ * artifacts. Protocol v1 retains the transcript for legacy servers.
+ */
+export function compactTerminalResult(dispatch, result) {
+    return dispatch.schemaVersion >= 2 && result.events.length > 0
+        ? { ...result, events: [] }
+        : result;
+}
 export class ForgeBridgeService {
     config;
     connections;
+    hostCapabilityProbe;
+    chatProcessRunner;
     connection = null;
     heartbeatTimer = null;
     heartbeatInFlight = false;
@@ -32,18 +62,40 @@ export class ForgeBridgeService {
     sandboxMaintenanceTimer = null;
     sandboxMaintenanceRunning = false;
     closed = null;
+    transportRecovery = null;
+    transportRecoveryGeneration = 0;
     stopped = false;
     activeSessions = new Map();
     reservations = new Map();
     activeReadinessProbes = new Map();
+    readinessResultOutbox;
+    readinessResultFlush = null;
+    dispatchResultOutbox;
+    dispatchResultFlush = null;
+    dispatchResultGeneration = 0;
+    dispatchResultFlushedGeneration = -1;
+    dispatchResultHandoffs = new Map();
     preflight;
+    dockerEngineProbe;
     sandboxRuntime;
     sandboxResourceResolver;
     sessions;
-    constructor(config, sessions = undefined, connections = new SignalRBridgeConnectionFactory(), preflight, sandboxRuntime, sandboxResourceResolver) {
+    enforceHostDatabaseCapabilityBoundary;
+    hostCapabilities = emptyRunnerHostCapabilitySnapshot();
+    // Reaping deletes the stale ledger, so its stopped-process proof is held here
+    // until a Hello carrying it is accepted. A bridge restart forgets it, which
+    // leaves those attempts on Forge's conservative unknown-outcome path.
+    recoveredHostAttempts = new Map();
+    hostCapabilitiesDetected = false;
+    constructor(config, sessions = undefined, connections = new SignalRBridgeConnectionFactory(), preflight, sandboxRuntime, sandboxResourceResolver, dockerEngineProbe, hostCapabilityProbe = new ProcessRunnerHostCapabilityProbe(), readinessResultOutbox, chatProcessRunner = new StreamingProviderProcessRunner(), dispatchResultOutbox) {
         this.config = config;
         this.connections = connections;
-        this.sessions = sessions ?? createDefaultSessionService(config.sandboxStateRoot);
+        this.hostCapabilityProbe = hostCapabilityProbe;
+        this.chatProcessRunner = chatProcessRunner;
+        this.enforceHostDatabaseCapabilityBoundary = sessions === undefined;
+        if (this.enforceHostDatabaseCapabilityBoundary) {
+            establishHostDatabaseCapabilityBoundary();
+        }
         this.preflight = preflight ?? new DockerPreflight({
             dockerExecutable: config.dockerExecutable,
             dockerContext: config.dockerContext,
@@ -59,17 +111,36 @@ export class ForgeBridgeService {
             runtimeOverheadBytes: config.sandboxRuntimeOverheadBytes,
             requireRootless: config.requireRootlessDocker
         });
+        this.dockerEngineProbe = dockerEngineProbe ?? new DockerEngineProbe({
+            dockerExecutable: config.dockerExecutable,
+            dockerContext: config.dockerContext,
+            recovery: {
+                enabled: config.dockerDesktopRecoveryEnabled,
+                failureThreshold: config.dockerRecoveryFailureThreshold,
+                cooldownMs: config.dockerRecoveryCooldownMs,
+                startupTimeoutMs: config.dockerRecoveryStartupTimeoutMs,
+                canRecover: () => this.activeSessions.size === 0 && this.reservations.size === 0,
+            },
+            onStatus: logBridgeStatus,
+        });
+        this.sessions = sessions ?? createDefaultSessionService(config.sandboxStateRoot, config.sandboxExecutionRoot, this.dockerEngineProbe);
         this.sandboxRuntime = sandboxRuntime ?? new DockerSandboxRuntime(config, (request, signal) => this.redeemPublishGrant(request, signal));
         this.sandboxResourceResolver = sandboxResourceResolver
             ?? (dispatch => resolveSandboxResourcesFromRepo(dispatch, this.config.sandboxRuntimeOverheadBytes));
+        this.readinessResultOutbox = readinessResultOutbox ?? new FileReadinessResultOutbox(config.sandboxStateRoot);
+        this.dispatchResultOutbox = dispatchResultOutbox ?? new FileDispatchResultOutbox(config.sandboxStateRoot);
     }
     async connectOnce() {
         await this.stopConnection();
         this.stopped = false;
+        if (this.enforceHostDatabaseCapabilityBoundary) {
+            assertHostDatabaseCapabilityBoundary();
+        }
         const hostReap = await this.sessions.reapHostRuntime?.({
             runnerId: this.config.runnerId,
             runnerInstanceId: this.config.runnerInstanceId,
         });
+        this.rememberRecoveredHostAttempts(hostReap);
         if (hostReap && (hostReap.reaped > 0 || hostReap.degraded > 0)) {
             logBridgeStatus(`Managed-host recovery reaped ${hostReap.reaped} stale attempt(s), protected ${hostReap.reusedPidsProtected} reused PID(s), and left ${hostReap.degraded} degraded attempt(s) for reconciliation.`);
         }
@@ -80,17 +151,54 @@ export class ForgeBridgeService {
                 await this.preflight.refresh();
             }
         }
+        await this.dockerEngineProbe.refresh(true);
+        if (!this.hostCapabilitiesDetected) {
+            this.hostCapabilities = await this.hostCapabilityProbe.detect(this.config);
+            this.hostCapabilitiesDetected = true;
+        }
         const connection = this.connections.create(this.config);
         this.connection = connection;
+        this.transportRecovery = null;
         this.closed = new Promise((resolve) => {
-            connection.onClose(() => {
+            connection.onClose((error) => {
                 this.stopHeartbeat();
+                this.completeTransportRecovery(error ?? new Error("bridge connection closed"));
                 this.abortActiveSessions("bridge connection closed");
                 this.abortActiveReadinessProbes("bridge connection closed");
                 resolve();
             });
         });
+        connection.onReconnecting?.((error) => {
+            if (connection !== this.connection || this.stopped)
+                return;
+            this.stopHeartbeat();
+            this.beginTransportRecovery();
+            logBridgeStatus(`Forge connection interrupted${error ? `: ${errorMessage(error)}` : ""}. Reconnecting in place; active dispatches remain supervised...`);
+        });
+        connection.onReconnected?.(async () => {
+            if (connection !== this.connection || this.stopped)
+                return;
+            try {
+                await this.registerConnection(connection);
+                this.completeTransportRecovery();
+                this.startHeartbeat();
+                await this.flushDispatchResults(true).catch(error => {
+                    logBridgeStatus(`Dispatch result replay deferred after reconnect: ${errorMessage(error)}`);
+                });
+                await this.flushReadinessResults().catch(error => {
+                    logBridgeStatus(`Readiness result replay deferred after reconnect: ${errorMessage(error)}`);
+                });
+                await this.flushCleanupReports().catch(() => undefined);
+                logBridgeStatus("Forge connection restored; active dispatches remain attached to this runner process.");
+            }
+            catch (error) {
+                this.completeTransportRecovery(error);
+                logBridgeStatus(`Forge reconnect registration failed: ${errorMessage(error)}. Closing the connection for a clean retry...`);
+                await connection.stop().catch(() => undefined);
+            }
+        });
         connection.onDispatch((dispatch) => this.handleDispatch(dispatch));
+        connection.onChatTurn?.((dispatch) => this.handleChatTurn(dispatch));
         connection.onOffer?.((dispatch) => this.handleOffer(dispatch));
         connection.onStart?.((dispatch) => this.handleStart(dispatch));
         connection.onLeaseUpdate?.((request) => this.handleLeaseUpdate(request));
@@ -98,18 +206,67 @@ export class ForgeBridgeService {
         connection.onReap?.((request) => this.handleReap(request));
         connection.onReadinessProbe?.((request) => this.handleReadinessProbe(request));
         await connection.start();
-        await this.invokeAck("Hello", {
-            version: this.config.version,
-            protocolVersion: this.config.protocolVersion,
-            minServerVersion: this.config.minServerVersion ?? null,
-            runnerInstanceId: this.config.runnerInstanceId,
-            capabilities: this.capabilities()
+        await this.registerConnection(connection);
+        await this.flushDispatchResults(true).catch(error => {
+            logBridgeStatus(`Dispatch result replay deferred: ${errorMessage(error)}`);
+        });
+        await this.flushReadinessResults().catch(error => {
+            logBridgeStatus(`Readiness result replay deferred: ${errorMessage(error)}`);
         });
         await this.flushCleanupReports();
         this.startHeartbeat();
         this.startLeaseWatchdog();
         this.startSandboxMaintenance();
     }
+    rememberRecoveredHostAttempts(report) {
+        for (const attempt of report?.recoveredAttempts ?? []) {
+            if (this.recoveredHostAttempts.size >= maxRecoveredHostAttempts)
+                break;
+            this.recoveredHostAttempts.set(attempt.dispatchAttemptId, attempt);
+        }
+    }
+    async recoveredHostAttemptsForHello() {
+        if (this.recoveredHostAttempts.size === 0)
+            return [];
+        // A durable terminal result outranks the stopped-process proof: it replays
+        // after Hello and Forge accepts the provider's real outcome instead.
+        const pendingResults = new Set((await this.dispatchResultOutbox.pending())
+            .map(entry => entry.payload.dispatchAttemptId)
+            .filter((id) => typeof id === "string"));
+        return [...this.recoveredHostAttempts.values()]
+            .filter(attempt => !pendingResults.has(attempt.dispatchAttemptId));
+    }
+    async registerConnection(connection) {
+        let storageRecoveryAttempt = 0;
+        while (true) {
+            try {
+                const recoveredHostAttempts = await this.recoveredHostAttemptsForHello();
+                const ack = await connection.invoke("Hello", {
+                    version: this.config.version,
+                    protocolVersion: this.config.protocolVersion,
+                    minServerVersion: this.config.minServerVersion ?? null,
+                    runnerInstanceId: this.config.runnerInstanceId,
+                    capabilities: this.capabilities(),
+                    recoveredHostAttempts,
+                });
+                if (!ack.accepted) {
+                    throw new BridgeCallbackRejectedError(ack.code ?? null, ack.message ?? ack.code ?? "Hello callback was rejected.");
+                }
+                this.recoveredHostAttempts.clear();
+                logBridgeStatus(`Registered runner ${this.config.runnerId}, instance ${this.config.runnerInstanceId}, build ${this.config.version}, protocol ${this.config.protocolVersion}.`);
+                return;
+            }
+            catch (error) {
+                if (!isProviderStorageUnavailable(error) || storageRecoveryAttempt >= this.config.reconnectBackoffMs.length) {
+                    throw error;
+                }
+                const backoff = this.config.reconnectBackoffMs[storageRecoveryAttempt] ?? 5000;
+                storageRecoveryAttempt += 1;
+                logBridgeStatus(`Hello reached Forge while storage was recovering. Retrying registration ${storageRecoveryAttempt} in ${formatDelay(backoff)}...`);
+                await delay(backoff);
+            }
+        }
+    }
     async run(signal) {
         let attempt = 0;
         try {
@@ -151,24 +308,351 @@ export class ForgeBridgeService {
         await this.stopConnection();
         await this.preflight.release();
     }
-    async handleDispatch(rawDispatch) {
-        const dispatch = this.parseDispatchOrReport(rawDispatch);
+    async handleChatTurn(rawDispatch) {
+        const packet = this.parseChatTurnOrReport(rawDispatch);
+        if (!packet) {
+            return;
+        }
+        if (packet.runnerInstanceId !== this.config.runnerInstanceId) {
+            logBridgeStatus(`Rejected Bridge Chat turn ${packet.turnId}: stale runner instance.`);
+            return;
+        }
+        const capabilityFailure = this.requiredChatCapabilityFailure(packet);
+        if (capabilityFailure) {
+            await this.sendStandaloneChatTerminal(packet, "failed", {
+                code: "bridge_chat.runner_unavailable",
+                message: capabilityFailure,
+            }).catch(() => undefined);
+            return;
+        }
+        const existing = this.activeSessions.get(packet.leaseId);
+        if (existing) {
+            if (existing.kind === "chat"
+                && existing.fencingToken === packet.fencingToken
+                && existing.chatRunId === packet.chatRunId
+                && existing.conversationId === packet.conversationId
+                && existing.turnId === packet.turnId) {
+                return;
+            }
+            await this.sendStandaloneChatTerminal(packet, "failed", {
+                code: "bridge_chat.stale_fencing_token",
+                message: "Bridge Chat turn fence conflicts with an active bridge session.",
+            }).catch(() => undefined);
+            return;
+        }
+        const controller = new AbortController();
+        const active = {
+            leaseId: packet.leaseId,
+            kind: "chat",
+            fencingToken: packet.fencingToken,
+            dispatchAttemptId: null,
+            runnerInstanceId: packet.runnerInstanceId,
+            leaseExpiresAt: chatTurnLeaseExpiresAt(packet),
+            sandboxed: false,
+            resources: zeroSandboxResources(),
+            controller,
+            chatRunId: packet.chatRunId,
+            conversationId: packet.conversationId,
+            turnId: packet.turnId,
+            providerThreadId: packet.providerThreadId ?? null,
+            chatSequence: 0,
+            terminalCallbackAttempted: false,
+        };
+        this.activeSessions.set(packet.leaseId, active);
+        let workspacePath = null;
+        let cleanupAttempted = false;
+        let cleanupOutcome = null;
+        let cleanupReported = false;
+        const cleanup = async () => {
+            if (!workspacePath || cleanupAttempted)
+                return null;
+            cleanupAttempted = true;
+            cleanupOutcome = await cleanupChatTurnWorkspace(workspacePath, chatRedactionSecrets(packet));
+            return cleanupOutcome;
+        };
+        const reportCleanup = async (outcome) => {
+            if (!outcome || cleanupReported)
+                return;
+            cleanupReported = true;
+            await this.sendChatCallback(active, "output_delta", outcome).catch(() => undefined);
+        };
+        try {
+            workspacePath = await this.createChatTurnWorkspace(packet);
+            await materializeChatTurnMetadata(packet, workspacePath);
+            const run = await this.runChatProviderProcess(packet, active, workspacePath);
+            cleanupOutcome = await cleanup();
+            await reportCleanup(cleanupOutcome);
+            if (controller.signal.aborted) {
+                await this.sendChatAbortTerminal(packet, active, cleanupOutcome);
+                return;
+            }
+            if (cleanupOutcome?.status === "failed") {
+                throw new Error(`chat_turn_cleanup_failed: ${cleanupOutcome.message}`);
+            }
+            if (run.result.exitCode !== 0) {
+                throw chatProviderExitFailure(run.command, run.result, chatRedactionSecrets(packet));
+            }
+            await this.sendChatCallback(active, "output_completed", {
+                code: "output_completed",
+                text: clip(redactText(run.output.finalMessage ?? "", chatRedactionSecrets(packet)), maxChatTerminalTextChars),
+                provider: packet.providerKind,
+                model: packet.model,
+                cleanup: cleanupOutcome,
+            });
+        }
+        catch (error) {
+            cleanupOutcome = cleanupOutcome ?? await cleanup();
+            if (active.terminalCallbackAttempted) {
+                return;
+            }
+            await reportCleanup(cleanupOutcome);
+            const payload = controller.signal.aborted
+                ? chatAbortPayload(controller.signal.reason, cleanupOutcome, packet)
+                : {
+                    code: "provider_failed",
+                    message: clip(redactText(errorMessage(error), chatRedactionSecrets(packet)), 2000),
+                    cleanup: cleanupOutcome,
+                };
+            const kind = controller.signal.aborted ? chatAbortKind(controller.signal.reason) : "failed";
+            await this.sendChatCallback(active, kind, payload).catch(callbackError => {
+                logBridgeStatus(`Bridge Chat terminal callback for turn ${packet.turnId} was not accepted: ${errorMessage(callbackError)}`);
+            });
+        }
+        finally {
+            await this.releaseActiveSessionAndRefreshCapacity(packet.leaseId);
+        }
+    }
+    async createChatTurnWorkspace(packet) {
+        const root = path.join(this.config.sandboxStateRoot, "chat-turns");
+        await fs.promises.mkdir(root, { recursive: true });
+        return await fs.promises.mkdtemp(path.join(root, `${safePathComponent(packet.turnId)}-`));
+    }
+    async runChatProviderProcess(packet, active, cwd) {
+        const output = createProviderOutputState(packet.providerKind);
+        const plan = buildChatProviderCommand(packet, cwd);
+        const redactionSecrets = chatRedactionSecrets(packet);
+        let started = false;
+        const result = await this.chatProcessRunner.run({
+            command: plan.command.command,
+            args: plan.command.args,
+            cwd,
+            env: {
+                FORGE_BRIDGE_CHAT_RUN_ID: packet.chatRunId,
+                FORGE_BRIDGE_CHAT_TURN_ID: packet.turnId,
+            },
+            stdin: plan.stdin,
+        }, {
+            onStarted: async () => {
+                started = true;
+                await this.sendChatCallback(active, "turn_started", {
+                    status: "running",
+                    provider: packet.providerKind,
+                    model: packet.model,
+                    command: redactText(formatProviderCliCommandForCheckpoint(plan.command), redactionSecrets),
+                });
+            },
+            onStdoutLine: async (line) => {
+                for (const event of output.consume(line)) {
+                    await this.sendChatProviderEvent(packet, active, event, output.providerThreadId);
+                }
+            },
+        }, active.controller.signal);
+        if (started && !active.controller.signal.aborted) {
+            await this.sendChatCallback(active, "output_delta", {
+                eventType: "provider_cli_completed",
+                role: "runner",
+                kind: "checkpoint",
+                content: "Bridge Chat provider process exited.",
+            }).catch(() => undefined);
+        }
+        return { command: plan.command, output, result };
+    }
+    async sendChatProviderEvent(packet, active, event, providerThreadId) {
+        if (providerThreadId) {
+            active.providerThreadId = providerThreadId;
+        }
+        else if (event.eventType === "provider_thread_started") {
+            active.providerThreadId = providerThreadIdFromEvent(event) ?? active.providerThreadId;
+        }
+        if (event.eventType === "provider_tool_heartbeat") {
+            return;
+        }
+        const redactionSecrets = chatRedactionSecrets(packet);
+        const payload = {
+            role: event.role,
+            kind: event.kind,
+            eventType: event.eventType ?? "provider_event",
+            content: clip(redactText(event.content, redactionSecrets), maxChatEventContentChars),
+            data: event.data ? clip(redactText(event.data, redactionSecrets), maxChatEventContentChars) : undefined,
+        };
+        await this.sendChatCallback(active, "output_delta", payload);
+    }
+    async sendChatAbortTerminal(packet, active, cleanupOutcome) {
+        await this.sendChatCallback(active, chatAbortKind(active.controller.signal.reason), chatAbortPayload(active.controller.signal.reason, cleanupOutcome, packet));
+    }
+    async sendStandaloneChatTerminal(packet, kind, payload) {
+        const active = {
+            leaseId: packet.leaseId,
+            kind: "chat",
+            fencingToken: packet.fencingToken,
+            dispatchAttemptId: null,
+            runnerInstanceId: packet.runnerInstanceId,
+            leaseExpiresAt: new Date(Date.now() + defaultChatTurnLeaseMs).toISOString(),
+            sandboxed: false,
+            resources: zeroSandboxResources(),
+            controller: new AbortController(),
+            chatRunId: packet.chatRunId,
+            conversationId: packet.conversationId,
+            turnId: packet.turnId,
+            providerThreadId: packet.providerThreadId ?? null,
+            chatSequence: 0,
+            terminalCallbackAttempted: false,
+        };
+        await this.sendChatCallback(active, kind, payload);
+    }
+    async sendChatCallback(active, kind, payload = null) {
+        if (active.kind !== "chat" || !active.chatRunId || !active.conversationId || !active.turnId) {
+            throw new Error("Bridge Chat callback requires an active chat turn.");
+        }
+        const terminal = isTerminalChatTurnCallbackKind(kind);
+        if (terminal && active.terminalCallbackAttempted) {
+            return;
+        }
+        assertBridgeChatCallbackPayload(payload);
+        const sequence = (active.chatSequence ?? 0) + 1;
+        const envelope = {
+            callbackId: randomUUID(),
+            chatRunId: active.chatRunId,
+            conversationId: active.conversationId,
+            turnId: active.turnId,
+            leaseId: active.leaseId,
+            fencingToken: active.fencingToken,
+            runnerId: this.config.runnerId,
+            runnerInstanceId: active.runnerInstanceId ?? this.config.runnerInstanceId,
+            sequence,
+            eventType: kind,
+            redactionStatus: "redacted",
+            providerThreadId: active.providerThreadId ?? null,
+            payload,
+            occurredAt: new Date().toISOString(),
+            protocolVersion: bridgeChatProtocolVersion,
+        };
+        if (terminal) {
+            active.terminalCallbackAttempted = true;
+        }
+        await this.invokeChatCallbackWithRetry(envelope);
+        active.chatSequence = sequence;
+    }
+    async invokeChatCallbackWithRetry(envelope) {
+        const maxAttempts = 3;
+        for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+            try {
+                await this.invokeAck("ChatTurnCallback", envelope);
+                return;
+            }
+            catch (error) {
+                if (error instanceof BridgeCallbackRejectedError || attempt === maxAttempts - 1) {
+                    throw error;
+                }
+                await delay(200 * (attempt + 1));
+            }
+        }
+    }
+    requiredChatCapabilityFailure(packet) {
+        const capability = this.bridgeChatCapability();
+        if (capability.availability === "unavailable" || !capability.supportsTextStreaming) {
+            return capability.unavailableReason ?? "Bridge Chat text capability is unavailable.";
+        }
+        if (capability.supportedProviders.length > 0
+            && !containsIgnoreCase(capability.supportedProviders, packet.providerKind)) {
+            return `Bridge Chat provider '${packet.providerKind}' is not advertised by this bridge.`;
+        }
+        if (capability.supportedModels.length > 0
+            && !containsIgnoreCase(capability.supportedModels, packet.model)) {
+            return `Bridge Chat model '${packet.model}' is not advertised by this bridge.`;
+        }
+        if (packet.requestedCapabilities.includes("cancel") && !capability.supportsCancel) {
+            return "Bridge Chat cancellation is not advertised by this bridge.";
+        }
+        if (packet.requestedCapabilities.includes("resume") && !capability.supportsResume) {
+            return "Bridge Chat resume is not advertised by this bridge.";
+        }
+        if (packet.requestedCapabilities.includes("thread_continuity")
+            && !capability.supportsProviderThreadContinuity) {
+            return "Bridge Chat provider thread continuity is not advertised by this bridge.";
+        }
+        if (packet.requestedCapabilities.includes("attachment_handoffs") && !capability.supportsAttachments) {
+            return "Bridge Chat attachment handoffs are not advertised by this bridge.";
+        }
+        if (packet.requestedCapabilities.includes("action_broker_grants") && !capability.supportsActionBrokerGrants) {
+            return "Bridge Chat action-broker grants are not advertised by this bridge.";
+        }
+        return null;
+    }
+    bridgeChatCapability() {
+        return bridgeChatCapabilityFor(this.config.cliProviders, this.config.providerStatuses, this.config.bridgeChat);
+    }
+    async handleDispatch(rawDispatch, reservationHandoff) {
+        const dispatch = await this.parseDispatchOrReport(rawDispatch);
         if (!dispatch) {
+            this.releaseReservedDispatchHandoff(reservationHandoff);
+            return;
+        }
+        if (this.enforceHostDatabaseCapabilityBoundary) {
+            try {
+                assertHostDatabaseCapabilityBoundary();
+            }
+            catch (error) {
+                const message = errorMessage(error);
+                await this.sendResult(dispatch, failureResult(message, [{
+                        role: "runner",
+                        kind: "error",
+                        content: message,
+                        eventType: "host_database_capability_forbidden",
+                    }], failureFactsFromError(error, { source: "bridge" }))).catch(() => undefined);
+                this.releaseReservedDispatchHandoff(reservationHandoff);
+                return;
+            }
+        }
+        let capabilityFailure;
+        try {
+            capabilityFailure = await this.requiredCapabilityFailure(dispatch);
+        }
+        catch (error) {
+            this.releaseReservedDispatchHandoff(reservationHandoff);
+            throw error;
+        }
+        if (capabilityFailure) {
+            await this.sendResult(dispatch, failureResult(capabilityFailure, [{
+                    role: "runner",
+                    kind: "error",
+                    content: capabilityFailure,
+                    eventType: "docker_engine_unavailable",
+                }], failureFactsForCode("docker_engine_unavailable"))).catch(() => undefined);
+            this.releaseReservedDispatchHandoff(reservationHandoff);
             return;
         }
         const leaseId = dispatch.lease.id;
         const fencingToken = dispatch.lease.fencingToken;
         const redactionSecrets = exactSecrets(dispatch, this.config);
+        if (reservationHandoff && !this.reservedDispatchHandoffIsCurrent(reservationHandoff, dispatch)) {
+            await this.sendResult(dispatch, failureResult("Start rejected because its reservation is missing or stale.", [], failureFactsForCode("bridge.reservation_stale"))).catch(() => undefined);
+            return;
+        }
         const existing = this.activeSessions.get(leaseId);
         if (existing) {
             if (existing.fencingToken === fencingToken) {
+                this.releaseReservedDispatchHandoff(reservationHandoff);
                 return;
             }
-            await this.sendResult(dispatch, failureResult("Dispatch fence conflicts with an active bridge session.")).catch(() => undefined);
+            await this.sendResult(dispatch, failureResult("Dispatch fence conflicts with an active bridge session.", [], failureFactsForCode("bridge.dispatch_fence_conflict"))).catch(() => undefined);
+            this.releaseReservedDispatchHandoff(reservationHandoff);
             return;
         }
-        const controller = new AbortController();
+        const controller = reservationHandoff?.controller ?? new AbortController();
         this.activeSessions.set(leaseId, {
+            leaseId,
+            kind: "dispatch",
             fencingToken,
             dispatchAttemptId: dispatch.sandbox?.dispatchAttemptId ?? null,
             runnerInstanceId: dispatch.sandbox?.runnerInstanceId ?? null,
@@ -179,6 +663,18 @@ export class ForgeBridgeService {
                 : zeroSandboxResources(),
             controller
         });
+        if (reservationHandoff) {
+            // Promotion is synchronous with active-session registration. A qualified
+            // pre-start Cancel therefore sees either the cancellable reservation or
+            // the fully active owner; there is no cancellation-blind handoff gap.
+            this.releaseReservedDispatchHandoff(reservationHandoff);
+        }
+        // Server-requested runtime readiness is background maintenance. A probe may
+        // have passed admission during the narrow handoff between prepared-runtime
+        // verification and the foreground attempt's final admission. Preempt it as
+        // soon as real agent work arrives so the probe cannot consume the memory
+        // headroom that the foreground attempt is waiting to acquire.
+        this.deferActiveReadinessProbes();
         try {
             const normalized = this.normalizeDispatch(dispatch);
             if (normalized.sandbox) {
@@ -205,7 +701,10 @@ export class ForgeBridgeService {
                                 dispatchAttemptId: dispatch.sandbox.dispatchAttemptId,
                                 runnerInstanceId: dispatch.sandbox.runnerInstanceId
                             } : {}),
-                            event: redactRunnerDispatchEvent(event, redactionSecrets)
+                            event: redactRunnerDispatchEvent({ ...event, eventId: event.eventId ?? randomUUID() }, redactionSecrets)
+                        }, {
+                            replayCallbackTimeout: true,
+                            signal: controller.signal,
                         });
                     }
                     catch (error) {
@@ -223,23 +722,86 @@ export class ForgeBridgeService {
             if (normalized.sandbox?.executionMode === "docker") {
                 await this.flushCleanupReports().catch(() => undefined);
             }
-            await this.sendResult(dispatch, redactRunOnceResultPacket(result, redactionSecrets));
+            const redactedResult = redactRunOnceResultPacket(result, redactionSecrets);
+            await this.sendResult(dispatch, compactTerminalResult(dispatch, redactedResult));
         }
         catch (error) {
             const summary = controller.signal.aborted
                 ? `Dispatch cancelled: ${String(controller.signal.reason ?? "cancelled")}`
                 : redactText(error instanceof Error ? error.message : String(error), redactionSecrets);
-            const failureEventType = infrastructureFailureEventType(summary);
+            const failureFacts = failureFactsFromError(error, {
+                cancelled: controller.signal.aborted,
+                source: "bridge",
+            });
+            const failureEventType = failureFacts.category === "unknown" ? null : failureFacts.code;
             const failureEvents = failureEventType ? [{
                     role: "runner",
                     kind: "error",
                     content: summary,
                     eventType: failureEventType,
                 }] : [];
-            await this.sendResult(dispatch, failureResult(summary, failureEvents)).catch(() => undefined);
+            await this.sendResult(dispatch, failureResult(summary, failureEvents, failureFacts)).catch(() => undefined);
         }
         finally {
-            this.activeSessions.delete(leaseId);
+            await this.releaseActiveSessionAndRefreshCapacity(leaseId);
+        }
+    }
+    reservedDispatchHandoffIsCurrent(handoff, dispatch) {
+        const sandbox = dispatch.sandbox;
+        const reservation = handoff.reservation;
+        return sandbox !== null
+            && sandbox !== undefined
+            && sandbox.dispatchAttemptId === handoff.dispatchAttemptId
+            && this.reservations.get(handoff.dispatchAttemptId) === reservation
+            && reservation.startClaim === handoff
+            && !handoff.controller.signal.aborted
+            && reservation.leaseId === dispatch.lease.id
+            && reservation.fencingToken === dispatch.lease.fencingToken
+            && reservation.runnerInstanceId === sandbox.runnerInstanceId
+            && Date.parse(reservation.reservedUntil) > Date.now();
+    }
+    releaseReservedDispatchHandoff(handoff) {
+        if (!handoff
+            || this.reservations.get(handoff.dispatchAttemptId) !== handoff.reservation
+            || handoff.reservation.startClaim !== handoff)
+            return;
+        this.reservations.delete(handoff.dispatchAttemptId);
+    }
+    async releaseActiveSessionAndRefreshCapacity(leaseId, expectedDispatch) {
+        if (expectedDispatch) {
+            const active = this.activeSessions.get(leaseId);
+            // Admission failures may arrive after a newer attempt starts on the same
+            // lease. A terminal callback can release only the dispatch it identifies.
+            if (!active || active.kind !== "dispatch"
+                || active.fencingToken !== expectedDispatch.lease.fencingToken
+                || active.dispatchAttemptId !== (expectedDispatch.sandbox?.dispatchAttemptId ?? null)
+                || active.runnerInstanceId !== (expectedDispatch.sandbox?.runnerInstanceId ?? null))
+                return;
+        }
+        if (!this.activeSessions.delete(leaseId))
+            return;
+        // Publish released host/runtime capacity before the terminal result can
+        // enqueue the next pipeline phase. Otherwise the server may reject that
+        // handoff from the previous periodic heartbeat's active reservation.
+        // Publish the updated reservation counts from cached samples only. Probes
+        // belong to periodic/admission heartbeats and must not outlive this bounded
+        // terminal handoff. Storage recovery must not block durable result delivery.
+        const controller = new AbortController();
+        let timer;
+        try {
+            await Promise.race([
+                this.sendHeartbeatSnapshot(controller.signal).catch(() => undefined),
+                new Promise(resolve => {
+                    timer = setTimeout(() => {
+                        controller.abort("terminal capacity refresh deadline");
+                        resolve();
+                    }, Math.min(5000, positiveFiniteNumber(this.config.callbackAckTimeoutMs ?? 30_000, 30_000)));
+                }),
+            ]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
         }
     }
     async handleOffer(rawDispatch) {
@@ -247,20 +809,19 @@ export class ForgeBridgeService {
         if (!envelope) {
             return;
         }
-        const dispatch = this.parseDispatchOrReport(envelope.dispatch);
+        const dispatch = await this.parseDispatchOrReport(envelope.dispatch);
         if (!dispatch?.sandbox
             || dispatch.sandbox.dispatchAttemptId !== envelope.dispatchAttemptId
             || dispatch.lease.id !== envelope.leaseId
             || dispatch.lease.fencingToken !== envelope.fencingToken)
             return;
         const sandbox = dispatch.sandbox;
-        let existing = this.reservations.get(sandbox.dispatchAttemptId);
-        if (existing && Date.parse(existing.reservedUntil) <= Date.now()) {
-            this.reservations.delete(sandbox.dispatchAttemptId);
-            existing = undefined;
-        }
+        this.expireReservations(Date.now());
+        const existing = this.reservations.get(sandbox.dispatchAttemptId);
         if (existing) {
-            const sameFence = existing.fencingToken === dispatch.lease.fencingToken;
+            const sameFence = existing.leaseId === dispatch.lease.id
+                && existing.fencingToken === dispatch.lease.fencingToken
+                && existing.runnerInstanceId === sandbox.runnerInstanceId;
             await this.sendOfferDecision(dispatch, sameFence, sameFence ? null : "stale_fence", sameFence ? null : "Offer fence conflicts with the existing reservation.", sameFence ? existing.reservedUntil : null, sameFence ? existing.resources : null);
             return;
         }
@@ -287,7 +848,7 @@ export class ForgeBridgeService {
             }
             const providerNetworkFailure = sandboxProviderNetworkFailure(dispatch, this.config);
             if (providerNetworkFailure) {
-                await this.sendOfferDecision(dispatch, false, "provider_network_unavailable", providerNetworkFailure);
+                await this.sendOfferDecision(dispatch, false, "provider_network_policy_denied", providerNetworkFailure);
                 return;
             }
             const authFailure = sandboxAuthFailure(dispatch, this.config);
@@ -296,15 +857,12 @@ export class ForgeBridgeService {
                 return;
             }
         }
-        const runtimeState = this.sandboxRuntime.snapshot();
-        const usedResources = this.usedSandboxResources(runtimeState.degraded);
-        const activeResources = this.activeSandboxResources(runtimeState.degraded);
-        const capacity = this.sandboxResourceCapacity(preflight, activeResources);
         let requestedResources = sandbox.requestedResources;
         let sandboxConfigCommitSha = sandbox.sandboxConfigCommitSha ?? null;
+        const normalizedDispatch = this.normalizeDispatch(dispatch);
         if (sandbox.executionMode === "docker") {
             try {
-                const profile = await this.sandboxResourceResolver(this.normalizeDispatch(dispatch));
+                const profile = await this.sandboxResourceResolver(normalizedDispatch);
                 requestedResources = profile.resources;
                 sandboxConfigCommitSha = profile.sandboxConfigCommitSha;
             }
@@ -313,73 +871,166 @@ export class ForgeBridgeService {
                 return;
             }
         }
-        if (sandbox.executionMode === "docker"
-            && !canReserveSandboxResources(usedResources, requestedResources, capacity)) {
-            await this.sendOfferDecision(dispatch, false, "capacity_unavailable", sandboxCapacityFailureMessage(usedResources, requestedResources, capacity, preflight, this.config));
-            return;
+        else if (normalizedDispatch.repo.serverLocalPath) {
+            // Host execution uses the same project-derived disk reservation as Docker.
+            // The API supplies a placement-time estimate; the runner can safely raise it
+            // from its authoritative checkout before admitting the attempt.
+            const measuredWorkspaceBytes = await estimateWorkspaceBytesFromRepo(normalizedDispatch.repo.serverLocalPath, { role: normalizedDispatch.execution.role }).catch(() => null);
+            if (measuredWorkspaceBytes !== null) {
+                requestedResources = {
+                    ...requestedResources,
+                    workspaceBytes: Math.max(requestedResources.workspaceBytes, measuredWorkspaceBytes),
+                };
+            }
+        }
+        // Resource profiling can await filesystem and Docker work. Admission needs
+        // a dynamic host/daemon sample that began after profiling completed, so an
+        // older in-flight heartbeat inspection cannot supply the commit decision.
+        const admissionPreflight = sandbox.executionMode === "docker"
+            ? await this.preflight.refreshCapacityForAdmission()
+            : preflight;
+        // Resource profiling and preflight may await slow filesystem or Docker I/O.
+        // Re-read every mutable capacity input only after that work, then decide and
+        // commit synchronously. JavaScript cannot interleave another Offer handler
+        // inside this non-async method, so the ledger check and insertion are one
+        // atomic event-loop turn without holding a lock across external I/O.
+        const decision = this.commitOfferReservation(dispatch, requestedResources, admissionPreflight);
+        await this.sendOfferDecision(dispatch, decision.accepted, decision.code, decision.message, decision.reservedUntil, decision.resources, sandboxConfigCommitSha);
+    }
+    commitOfferReservation(dispatch, requestedResources, preparedPreflight) {
+        const sandbox = dispatch.sandbox;
+        const now = Date.now();
+        this.expireReservations(now);
+        const existing = this.reservations.get(sandbox.dispatchAttemptId);
+        if (existing) {
+            const sameFence = existing.leaseId === dispatch.lease.id
+                && existing.fencingToken === dispatch.lease.fencingToken
+                && existing.runnerInstanceId === sandbox.runnerInstanceId;
+            return {
+                accepted: sameFence,
+                code: sameFence ? null : "stale_fence",
+                message: sameFence ? null : "Offer fence conflicts with the existing reservation.",
+                reservedUntil: sameFence ? existing.reservedUntil : null,
+                resources: sameFence ? existing.resources : null,
+            };
+        }
+        if (Date.parse(dispatch.lease.expiresAt) <= now) {
+            return rejectedOfferReservation("lease_expired", "Offer lease is already expired.");
         }
-        const reservedUntil = new Date(Math.min(Date.parse(dispatch.lease.expiresAt), Date.now() + 30_000)).toISOString();
-        this.reservations.set(sandbox.dispatchAttemptId, {
+        if (sandbox.executionMode === "docker") {
+            // A concurrent heartbeat/preflight refresh may have produced a newer
+            // conservative dual-domain sample while this offer was being profiled.
+            const admissionPreflight = this.preflight.current() ?? preparedPreflight;
+            if (!this.config.dockerEnabled || !admissionPreflight?.healthy) {
+                return rejectedOfferReservation(admissionPreflight?.unavailableCode ?? "docker_unavailable", admissionPreflight?.unavailableReason ?? "Docker sandbox preflight is unavailable.");
+            }
+            const runtimeState = this.sandboxRuntime.snapshot();
+            const usedResources = this.usedSandboxResources(runtimeState.degraded);
+            const activeResources = this.activeSandboxResources(runtimeState.degraded);
+            const capacity = this.sandboxResourceCapacity(admissionPreflight, activeResources);
+            if (!canReserveSandboxResources(usedResources, requestedResources, capacity)) {
+                return rejectedOfferReservation("capacity_unavailable", sandboxCapacityFailureMessage(usedResources, requestedResources, capacity, admissionPreflight, this.config));
+            }
+        }
+        const reservedUntil = new Date(Math.min(Date.parse(dispatch.lease.expiresAt), now + 30_000)).toISOString();
+        const reservation = {
             leaseId: dispatch.lease.id,
             fencingToken: dispatch.lease.fencingToken,
             runnerInstanceId: sandbox.runnerInstanceId,
             expiresAt: dispatch.lease.expiresAt,
             reservedUntil,
             sandboxed: sandbox.executionMode === "docker",
-            resources: requestedResources
-        });
-        await this.sendOfferDecision(dispatch, true, null, null, reservedUntil, requestedResources, sandboxConfigCommitSha);
+            resources: requestedResources,
+        };
+        this.reservations.set(sandbox.dispatchAttemptId, reservation);
+        return {
+            accepted: true,
+            code: null,
+            message: null,
+            reservedUntil,
+            resources: requestedResources,
+        };
     }
     async handleStart(rawDispatch) {
         const envelope = parseStartEnvelope(rawDispatch);
         if (!envelope) {
             return;
         }
-        let dispatch = this.parseDispatchOrReport(envelope.dispatch);
+        let dispatch = await this.parseDispatchOrReport(envelope.dispatch);
         if (!dispatch?.sandbox
             || dispatch.sandbox.dispatchAttemptId !== envelope.dispatchAttemptId
             || dispatch.lease.id !== envelope.leaseId
             || dispatch.lease.fencingToken !== envelope.fencingToken)
             return;
+        const active = this.activeSessions.get(dispatch.lease.id);
+        if (active?.kind === "dispatch"
+            && active.fencingToken === dispatch.lease.fencingToken
+            && active.dispatchAttemptId === dispatch.sandbox.dispatchAttemptId
+            && active.runnerInstanceId === dispatch.sandbox.runnerInstanceId) {
+            return;
+        }
         const reservation = this.reservations.get(dispatch.sandbox.dispatchAttemptId);
         if (!reservation
             || reservation.leaseId !== dispatch.lease.id
             || reservation.fencingToken !== dispatch.lease.fencingToken
             || reservation.runnerInstanceId !== dispatch.sandbox.runnerInstanceId
             || Date.parse(reservation.reservedUntil) <= Date.now()) {
-            await this.sendResult(dispatch, failureResult("Start rejected because its reservation is missing or stale.")).catch(() => undefined);
+            await this.sendResult(dispatch, failureResult("Start rejected because its reservation is missing or stale.", [], failureFactsForCode("bridge.reservation_stale"))).catch(() => undefined);
             return;
         }
+        // Claim the exact reservation before redemption or any other post-validation
+        // await. A duplicate Start for the same reservation is an idempotent replay:
+        // it must neither redeem a one-time grant nor disturb the original owner.
+        if (reservation.startClaim)
+            return;
+        const startClaim = {
+            dispatchAttemptId: envelope.dispatchAttemptId,
+            reservation,
+            controller: new AbortController(),
+        };
+        reservation.startClaim = startClaim;
         if (dispatch.apiKeySecretGrant) {
-            this.reservations.delete(dispatch.sandbox.dispatchAttemptId);
-            await this.sendResult(dispatch, failureResult("Start rejected because protocol-v2 packets may not contain a plaintext provider grant.")).catch(() => undefined);
+            this.releaseReservedDispatchHandoff(startClaim);
+            await this.sendResult(dispatch, failureResult("Start rejected because protocol-v2 packets may not contain a plaintext provider grant.", [], failureFactsForCode("contract_plaintext_secret_rejected"))).catch(() => undefined);
             return;
         }
         if (dispatch.apiKeySecretGrantHandle) {
-            const response = await this.redeemSecretGrant(dispatch);
+            let response;
+            try {
+                response = await this.redeemSecretGrant(dispatch);
+            }
+            catch (error) {
+                this.releaseReservedDispatchHandoff(startClaim);
+                throw error;
+            }
+            // Redemption may yield while a qualified Cancel releases this reservation.
+            // Never launch from it or remove a successor reservation after that wait.
+            if (!this.reservedDispatchHandoffIsCurrent(startClaim, dispatch)) {
+                await this.sendResult(dispatch, failureResult("Start rejected because its reservation is missing or stale.", [], failureFactsForCode("bridge.reservation_stale"))).catch(() => undefined);
+                return;
+            }
             const grant = response.grant;
             if (!response.accepted
                 || !grant
                 || grant.grantId !== dispatch.apiKeySecretGrantHandle.grantId
                 || grant.provider !== dispatch.apiKeySecretGrantHandle.provider
                 || Date.parse(grant.expiresAt) <= Date.now()) {
-                this.reservations.delete(dispatch.sandbox.dispatchAttemptId);
-                await this.sendResult(dispatch, failureResult(response.message ?? "Secret grant redemption was rejected.")).catch(() => undefined);
+                this.releaseReservedDispatchHandoff(startClaim);
+                await this.sendResult(dispatch, failureResult(response.message ?? "Secret grant redemption was rejected.", [], failureFactsForCode("bridge.api_key_secret_grant_denied"))).catch(() => undefined);
                 return;
             }
             dispatch = { ...dispatch, apiKeySecretGrant: grant, apiKeySecretGrantHandle: null };
         }
         else if (dispatch.execution.requiresApiKeySecretGrant) {
-            this.reservations.delete(dispatch.sandbox.dispatchAttemptId);
-            await this.sendResult(dispatch, failureResult("Start rejected because the provider secret grant handle is missing.")).catch(() => undefined);
+            this.releaseReservedDispatchHandoff(startClaim);
+            await this.sendResult(dispatch, failureResult("Start rejected because the provider secret grant handle is missing.", [], failureFactsForCode("bridge.api_key_secret_grant_missing"))).catch(() => undefined);
             return;
         }
         dispatch = {
             ...dispatch,
             sandbox: { ...dispatch.sandbox, requestedResources: reservation.resources },
         };
-        this.reservations.delete(envelope.dispatchAttemptId);
-        await this.handleDispatch(dispatch);
+        await this.handleDispatch(dispatch, startClaim);
     }
     async redeemSecretGrant(dispatch) {
         const sandbox = dispatch.sandbox;
@@ -443,7 +1094,7 @@ export class ForgeBridgeService {
         };
         await this.invokeAck("OfferDecision", payload);
     }
-    parseDispatchOrReport(rawDispatch) {
+    async parseDispatchOrReport(rawDispatch) {
         try {
             return parseRunOnceDispatchPacket(rawDispatch);
         }
@@ -453,24 +1104,78 @@ export class ForgeBridgeService {
                 return null;
             }
             const summary = invalidDispatchSummary(error);
-            void this.sendLegacyResult(identifiers.leaseId, identifiers.fencingToken, failureResult(summary, [
+            await this.sendLegacyResult(identifiers.leaseId, identifiers.fencingToken, failureResult(summary, [
                 {
                     role: "runner",
                     kind: "error",
                     content: summary,
                     eventType: "invalid_dispatch"
                 }
-            ])).catch(() => undefined);
+            ], failureFactsForCode("invalid_dispatch"))).catch(() => undefined);
+            return null;
+        }
+    }
+    parseChatTurnOrReport(rawDispatch) {
+        try {
+            return parseChatTurnDispatchPacket(rawDispatch, this.bridgeChatCapability());
+        }
+        catch (error) {
+            logBridgeStatus(invalidChatTurnSummary(error));
             return null;
         }
     }
     async handleCancel(request) {
+        if (request.dispatchAttemptId !== undefined && request.dispatchAttemptId !== null) {
+            // Qualified cancellation is reservation-only. In particular, a delayed
+            // pre-start Cancel must not abort an active session if Start won the race.
+            const reservation = this.reservations.get(request.dispatchAttemptId);
+            if (reservation
+                && request.runnerId === this.config.runnerId
+                && request.runnerInstanceId === this.config.runnerInstanceId
+                && reservation.runnerInstanceId === request.runnerInstanceId
+                && reservation.leaseId === request.leaseId
+                && reservation.fencingToken === request.fencingToken) {
+                reservation.startClaim?.controller.abort(request.reason ?? "cancelled by server");
+                this.reservations.delete(request.dispatchAttemptId);
+            }
+            return;
+        }
         const active = this.activeSessions.get(request.leaseId);
         if (!active || active.fencingToken !== request.fencingToken) {
             return;
         }
+        if (request.runnerId && request.runnerId !== this.config.runnerId) {
+            return;
+        }
+        if (request.runnerInstanceId && request.runnerInstanceId !== (active.runnerInstanceId ?? this.config.runnerInstanceId)) {
+            return;
+        }
+        if (active.kind === "chat" && !this.chatCancelMatchesActiveTurn(active, request)) {
+            return;
+        }
         active.controller.abort(request.reason ?? "cancelled by server");
     }
+    chatCancelMatchesActiveTurn(active, request) {
+        if (request.protocolVersion && request.protocolVersion !== bridgeChatProtocolVersion) {
+            return false;
+        }
+        try {
+            assertBridgeChatCallbackPayload(request.payload, "cancel payload");
+        }
+        catch {
+            return false;
+        }
+        if (request.chatRunId && request.chatRunId !== active.chatRunId)
+            return false;
+        if (request.conversationId && request.conversationId !== active.conversationId)
+            return false;
+        if (request.turnId && request.turnId !== active.turnId)
+            return false;
+        if (request.providerThreadId && active.providerThreadId && request.providerThreadId !== active.providerThreadId) {
+            return false;
+        }
+        return true;
+    }
     async handleReap(request) {
         if (request.runnerId !== this.config.runnerId
             || request.runnerInstanceId !== this.config.runnerInstanceId)
@@ -492,32 +1197,43 @@ export class ForgeBridgeService {
         timer.unref?.();
         let result;
         try {
-            if (!this.sessions.probeHostRuntime) {
-                throw new Error("host_runtime_probe_unavailable: this bridge does not implement runtime readiness probes.");
-            }
-            const probe = await this.sessions.probeHostRuntime({
-                ...request,
-                runnerId: this.config.runnerId,
-                repoRoot: this.config.defaultRepoRoot,
-                cleanupWorktrees: this.config.cleanupWorktrees,
-            }, controller.signal);
-            result = {
+            const accepted = {
                 schemaVersion: 1,
                 requestId: request.requestId,
                 fencingToken: request.fencingToken,
                 runnerInstanceId: this.config.runnerInstanceId,
-                ...probe,
+                acceptedAt: new Date().toISOString(),
             };
+            await this.invokeAck("ReadinessAccepted", accepted);
+            if (this.activeSessions.size > 0) {
+                result = deferredReadinessResult(request, this.config.runnerInstanceId);
+            }
+            else if (!this.sessions.probeHostRuntime) {
+                throw new Error("host_runtime_probe_unavailable: this bridge does not implement runtime readiness probes.");
+            }
+            else {
+                const probe = await this.sessions.probeHostRuntime(this.normalizeReadinessProbe(request), controller.signal);
+                result = readinessDeferralReason(controller.signal)
+                    ? deferredReadinessResult(request, this.config.runnerInstanceId)
+                    : {
+                        schemaVersion: 1,
+                        requestId: request.requestId,
+                        fencingToken: request.fencingToken,
+                        runnerInstanceId: this.config.runnerInstanceId,
+                        ...probe,
+                    };
+            }
         }
         catch (error) {
+            const deferredReason = readinessDeferralReason(controller.signal);
             result = {
                 schemaVersion: 1,
                 requestId: request.requestId,
                 fencingToken: request.fencingToken,
                 runnerInstanceId: this.config.runnerInstanceId,
                 status: "failed",
-                reasonCode: "host_runtime_probe_failed",
-                reasonMessage: errorMessage(error).slice(0, 1000),
+                reasonCode: deferredReason ? "host_runtime_probe_deferred" : "host_runtime_probe_failed",
+                reasonMessage: (deferredReason ?? errorMessage(error)).slice(0, 1000),
                 checkedAt: new Date().toISOString(),
             };
         }
@@ -525,9 +1241,69 @@ export class ForgeBridgeService {
             clearTimeout(timer);
             this.activeReadinessProbes.delete(request.requestId);
         }
-        await this.invokeAck("ReadinessResult", result).catch(() => undefined);
+        try {
+            await this.readinessResultOutbox.persist(result, request.expiresAt);
+        }
+        catch (error) {
+            if (errorMessage(error).includes("runtime_readiness_result_conflict:")) {
+                logBridgeStatus(`Readiness result ${request.requestId} rejected conflicting reuse of a durable request identity.`);
+                await this.sendHeartbeat().catch(() => undefined);
+                return;
+            }
+            logBridgeStatus(`Readiness result ${request.requestId} could not be persisted; attempting direct delivery: ${errorMessage(error)}`);
+            await this.invokeAck("ReadinessResult", result).catch(deliveryError => {
+                logBridgeStatus(`Readiness result ${request.requestId} could not be persisted or delivered: ${errorMessage(deliveryError)}`);
+            });
+            await this.sendHeartbeat().catch(() => undefined);
+            return;
+        }
+        try {
+            await this.flushReadinessResults();
+        }
+        catch (error) {
+            logBridgeStatus(`Readiness result ${request.requestId} remains queued for replay: ${errorMessage(error)}`);
+        }
         await this.sendHeartbeat().catch(() => undefined);
     }
+    deferActiveReadinessProbes() {
+        for (const controller of this.activeReadinessProbes.values()) {
+            if (!controller.signal.aborted) {
+                controller.abort("host_runtime_probe_deferred: foreground agent work took priority over background runtime readiness.");
+            }
+        }
+    }
+    async flushReadinessResults() {
+        if (this.readinessResultFlush)
+            return await this.readinessResultFlush;
+        const flush = this.flushReadinessResultsCore();
+        this.readinessResultFlush = flush;
+        try {
+            await flush;
+        }
+        finally {
+            if (this.readinessResultFlush === flush)
+                this.readinessResultFlush = null;
+        }
+    }
+    async flushReadinessResultsCore() {
+        for (const pending of await this.readinessResultOutbox.pending()) {
+            if (Date.parse(pending.expiresAt) <= Date.now()) {
+                await this.readinessResultOutbox.acknowledge(pending.result.requestId);
+                continue;
+            }
+            try {
+                await this.invokeAck("ReadinessResult", pending.result);
+                await this.readinessResultOutbox.acknowledge(pending.result.requestId);
+            }
+            catch (error) {
+                if (isReadinessNoLongerPending(error)) {
+                    await this.readinessResultOutbox.acknowledge(pending.result.requestId);
+                    continue;
+                }
+                throw error;
+            }
+        }
+    }
     abortActiveSessions(reason) {
         for (const active of this.activeSessions.values()) {
             active.controller.abort(reason);
@@ -539,8 +1315,42 @@ export class ForgeBridgeService {
             controller.abort(reason);
         this.activeReadinessProbes.clear();
     }
+    normalizeReadinessProbe(request) {
+        const mapping = findRepoMapping({
+            id: request.repoId,
+            name: request.repoName,
+            remoteUrl: request.remoteUrl,
+        }, repoMappingsFor(this.config));
+        const configuredPath = mapping?.localPath?.trim();
+        if (!configuredPath) {
+            throw new Error("bridge_repo_mapping_missing: readiness requires a matching local repository mapping.");
+        }
+        // Local configuration, not a path supplied by the server, grants checkout
+        // authority. Equality also excludes a different child/sibling of this repo.
+        const suppliedPath = request.runnerRepoLocalPath.trim();
+        if (!path.isAbsolute(suppliedPath)
+            || (process.platform === "win32" && path.parse(suppliedPath).root.length === 1)) {
+            throw new Error("bridge_repo_mapping_mismatch: readiness requires a fully qualified checkout path.");
+        }
+        const localPath = path.resolve(configuredPath);
+        const requestedPath = path.resolve(suppliedPath);
+        const pathsMatch = process.platform === "win32"
+            ? localPath.toLowerCase() === requestedPath.toLowerCase()
+            : localPath === requestedPath;
+        if (!pathsMatch) {
+            throw new Error("bridge_repo_mapping_mismatch: readiness checkout differs from the locally configured repository.");
+        }
+        return {
+            ...request,
+            runnerId: this.config.runnerId,
+            runnerRepoLocalPath: localPath,
+            cloneOnDemand: false,
+            repoRoot: path.dirname(localPath),
+            cleanupWorktrees: this.config.cleanupWorktrees,
+        };
+    }
     normalizeDispatch(dispatch) {
-        const mapping = findRepoMapping(dispatch, repoMappingsFor(this.config));
+        const mapping = findRepoMapping(dispatch.repo, repoMappingsFor(this.config));
         const localPath = mapping?.localPath?.trim();
         const repoRoot = localPath ? path.dirname(path.resolve(localPath)) : this.config.defaultRepoRoot;
         const qaLaunchTarget = normalizeQaAppLaunchTarget(mapping?.qaAppLaunchTarget) ?? dispatch.qaBrowser?.launchTarget ?? null;
@@ -569,24 +1379,105 @@ export class ForgeBridgeService {
             fencingToken: dispatch.lease.fencingToken,
             dispatchAttemptId: dispatch.sandbox?.dispatchAttemptId ?? null,
             runnerInstanceId: dispatch.sandbox?.runnerInstanceId ?? null,
-            result
+            // Every terminal writer, including early admission failures and exception
+            // paths, crosses the same redaction boundary before outbox persistence.
+            result: redactRunOnceResultPacket(result, exactSecrets(dispatch, this.config))
         };
-        await this.sendResultPayload(payload);
+        await this.sendResultPayload(payload, () => this.releaseActiveSessionAndRefreshCapacity(dispatch.lease.id, dispatch));
     }
     async sendLegacyResult(leaseId, fencingToken, result) {
         await this.sendResultPayload({ leaseId, fencingToken, result });
     }
-    async sendResultPayload(payload) {
+    async sendResultPayload(payload, beforeDelivery) {
+        // Register before persistence: replay can observe a record as soon as the
+        // durable write becomes visible, even before persist() has returned.
+        let releaseHandoff;
+        const priorHandoff = this.dispatchResultHandoffs.get(payload.leaseId);
+        const handoff = new Promise(resolve => { releaseHandoff = resolve; });
+        this.dispatchResultHandoffs.set(payload.leaseId, handoff);
+        let persisted = false;
+        try {
+            try {
+                await this.dispatchResultOutbox.persist(payload);
+                persisted = true;
+                this.dispatchResultGeneration += 1;
+            }
+            catch (error) {
+                logBridgeStatus(`Dispatch result ${payload.leaseId} could not be persisted; attempting direct delivery: ${errorMessage(error)}`);
+            }
+            await priorHandoff;
+            await beforeDelivery?.();
+        }
+        finally {
+            releaseHandoff();
+            if (this.dispatchResultHandoffs.get(payload.leaseId) === handoff)
+                this.dispatchResultHandoffs.delete(payload.leaseId);
+        }
+        if (!persisted) {
+            await this.sendResultPayloadDirect(payload);
+            return;
+        }
+        await this.flushDispatchResults().catch(error => {
+            logBridgeStatus(`Dispatch result ${payload.leaseId} remains queued for replay: ${errorMessage(error)}`);
+        });
+    }
+    async sendResultPayloadDirect(payload) {
         try {
             await this.invokeAck("DispatchResult", payload);
         }
         catch (error) {
-            if (isDispatchNoLongerPending(error)) {
+            if (isDispatchNoLongerPending(error))
                 return;
-            }
             throw error;
         }
     }
+    async flushDispatchResults(force = false) {
+        if (!force && this.dispatchResultGeneration === this.dispatchResultFlushedGeneration)
+            return;
+        if (this.dispatchResultFlush) {
+            await this.dispatchResultFlush;
+            if (!force && this.dispatchResultGeneration === this.dispatchResultFlushedGeneration)
+                return;
+        }
+        const flush = this.flushDispatchResultsCore();
+        this.dispatchResultFlush = flush;
+        try {
+            await flush;
+        }
+        finally {
+            if (this.dispatchResultFlush === flush)
+                this.dispatchResultFlush = null;
+        }
+    }
+    async flushDispatchResultsCore() {
+        const startedGeneration = this.dispatchResultGeneration;
+        while (true) {
+            const records = await this.dispatchResultOutbox.pending();
+            for (const pending of records) {
+                // Periodic heartbeats and reconnect replay share the same release
+                // barrier as the terminal writer. Restart replay has no live handoff.
+                while (this.dispatchResultHandoffs.has(pending.payload.leaseId)) {
+                    await this.dispatchResultHandoffs.get(pending.payload.leaseId);
+                }
+                try {
+                    await this.sendResultPayloadDirect(pending.payload);
+                    await this.dispatchResultOutbox.acknowledge(pending.payload.leaseId);
+                }
+                catch (error) {
+                    if (isDispatchNoLongerPending(error)) {
+                        await this.dispatchResultOutbox.acknowledge(pending.payload.leaseId);
+                        continue;
+                    }
+                    throw error;
+                }
+            }
+            if (records.length < 3)
+                break;
+        }
+        if (this.dispatchResultGeneration === startedGeneration) {
+            this.dispatchResultFlushedGeneration = startedGeneration;
+        }
+    }
     startHeartbeat() {
         this.stopHeartbeat();
         this.consecutiveHeartbeatFailures = 0;
@@ -605,6 +1496,8 @@ export class ForgeBridgeService {
             return;
         this.heartbeatInFlight = true;
         try {
+            await this.flushDispatchResults();
+            await this.flushReadinessResults();
             await this.sendHeartbeat();
             this.consecutiveHeartbeatFailures = 0;
         }
@@ -637,17 +1530,20 @@ export class ForgeBridgeService {
     }
     expireLeases() {
         const now = Date.now();
-        for (const [attemptId, reservation] of this.reservations) {
-            if (Date.parse(reservation.expiresAt) <= now || Date.parse(reservation.reservedUntil) <= now) {
-                this.reservations.delete(attemptId);
-            }
-        }
+        this.expireReservations(now);
         for (const active of this.activeSessions.values()) {
             if (Date.parse(active.leaseExpiresAt) <= now && !active.controller.signal.aborted) {
                 active.controller.abort("dispatch lease expired");
             }
         }
     }
+    expireReservations(now) {
+        for (const [attemptId, reservation] of this.reservations) {
+            if (Date.parse(reservation.expiresAt) <= now || Date.parse(reservation.reservedUntil) <= now) {
+                this.reservations.delete(attemptId);
+            }
+        }
+    }
     stopHeartbeat() {
         if (this.heartbeatTimer) {
             clearInterval(this.heartbeatTimer);
@@ -676,6 +1572,7 @@ export class ForgeBridgeService {
                 runnerId: this.config.runnerId,
                 runnerInstanceId: this.config.runnerInstanceId,
             });
+            this.rememberRecoveredHostAttempts(hostReap);
             if (hostReap && (hostReap.reaped > 0 || hostReap.degraded > 0)) {
                 logBridgeStatus(`Managed-host maintenance reaped ${hostReap.reaped} stale attempt(s) and left ${hostReap.degraded} degraded attempt(s) for reconciliation.`);
             }
@@ -716,22 +1613,50 @@ export class ForgeBridgeService {
         }
     }
     async sendHeartbeat() {
+        // Heartbeats are the recovery path for capacity-blocked work. Refresh the
+        // dynamic sample before advertising it, while reusing the static Docker
+        // capability snapshot established at startup or by an offer.
+        if (this.config.dockerEnabled)
+            await this.preflight.refreshCapacity();
+        // A due probe can start a Docker Desktop recovery that runs for minutes.
+        // Wait only as long as a normal probe takes, then advertise the last
+        // snapshot so the server doesn't mark the runner offline meanwhile.
+        const probeWait = new AbortController();
+        await Promise.race([
+            this.dockerEngineProbe.refresh().catch(() => undefined),
+            delay(positiveFiniteNumber(this.config.heartbeatDockerProbeWaitMs ?? 15_000, 15_000), probeWait.signal),
+        ]);
+        probeWait.abort();
+        await this.sendHeartbeatSnapshot();
+    }
+    async sendHeartbeatSnapshot(signal) {
         await this.invokeAck("Heartbeat", {
             status: "online",
             capabilities: this.capabilities(),
             version: this.config.version,
             protocolVersion: this.config.protocolVersion
-        });
+        }, { signal });
     }
     capabilities() {
         const preflight = this.preflight.current();
+        const dockerEngine = this.dockerEngineProbe.current();
         const runtimeState = this.sandboxRuntime.snapshot();
         const reserved = [...this.reservations.values()].filter(reservation => reservation.sandboxed).length;
         const used = this.usedSandboxResources(runtimeState.degraded);
         const activeResources = this.activeSandboxResources(runtimeState.degraded);
         const capacity = this.sandboxResourceCapacity(preflight, activeResources);
+        const memoryAdmission = preflight ? buildMemoryAdmissionDiagnostics({
+            sampledAt: preflight.sampledAt,
+            totalMemoryBytes: preflight.totalMemoryBytes,
+            rawAvailableMemoryBytes: preflight.rawAvailableMemoryBytes,
+            stabilizedAvailableMemoryBytes: preflight.availableMemoryBytes,
+            controlPlaneMemoryBytes: process.memoryUsage().rss,
+            reserveMemoryBytes: preflight.hostReserveBytes,
+            committedMemoryBytes: used.memoryBytes,
+            pendingCommitmentMemoryBytes: Math.max(0, used.memoryBytes - activeResources.memoryBytes),
+        }) : null;
         return {
-            schemaVersion: 3,
+            schemaVersion: 6,
             activeSessionCount: this.activeSessions.size,
             cliProviders: this.config.cliProviders,
             providerStatuses: this.config.providerStatuses,
@@ -741,6 +1666,19 @@ export class ForgeBridgeService {
             sandboxProfiles: this.config.sandboxProfiles,
             runnerInstanceId: this.config.runnerInstanceId,
             trustDomainId: this.config.trustDomainId,
+            executionFacilities: dockerEngine?.available ? ["docker_engine"] : [],
+            dockerEngine,
+            toolchains: {
+                ...this.hostCapabilities.toolchains,
+                docker: {
+                    available: dockerEngine?.available === true,
+                    executable: this.config.dockerExecutable,
+                    version: dockerEngine?.runtimeVersion ?? null,
+                },
+            },
+            playwrightProjects: this.hostCapabilities.playwrightProjects,
+            browserLaunch: this.hostCapabilities.browserLaunch,
+            providerConnectivity: this.hostCapabilities.providerConnectivity,
             maxConcurrentSandboxes: capacity.sandboxSlots,
             reservedSandboxCount: reserved,
             activeSandboxCount: runtimeState.active,
@@ -752,7 +1690,7 @@ export class ForgeBridgeService {
             allowsOpenPublicSandbox: this.config.allowOpenPublicSandbox,
             sandboxPublicationModes: [this.config.sandboxPublicationMode ?? "shared_filesystem"],
             sandboxAuthModes: sandboxAuthModesFor(this.config),
-            availableMemoryBytes: preflight ? Math.max(0, capacity.memoryBytes - used.memoryBytes) : null,
+            availableMemoryBytes: memoryAdmission?.availableForAdmissionBytes ?? null,
             availableCpuMillis: preflight ? Math.max(0, capacity.cpuMillis - used.cpuMillis) : null,
             availableWorkspaceBytes: preflight ? Math.max(0, capacity.workspaceBytes - used.workspaceBytes) : null,
             diskLow: preflight?.diskLow ?? null,
@@ -766,8 +1704,11 @@ export class ForgeBridgeService {
                 hostReserveBytes: preflight.hostReserveBytes,
                 activeReservationBytes: used.memoryBytes,
                 daemonTotalBytes: preflight.totalMemoryBytes,
-                daemonAvailableBytes: preflight.availableMemoryBytes,
-                availableForAdmissionBytes: Math.max(0, capacity.memoryBytes - used.memoryBytes),
+                daemonAvailableBytes: preflight.rawDaemonAvailableMemoryBytes ?? 0,
+                hostAvailableBytes: preflight.rawHostAvailableMemoryBytes,
+                conservativeAvailableBytes: preflight.rawAvailableMemoryBytes,
+                availableForAdmissionBytes: memoryAdmission.availableForAdmissionBytes,
+                memoryAdmission: memoryAdmission,
             } : null,
             hostRuntime: this.sessions.runtimeCapacity?.() ?? null,
             supportsApiSecretGrant: this.config.supportsApiSecretGrant,
@@ -776,9 +1717,20 @@ export class ForgeBridgeService {
             supportsRunnerAuthoredPhaseArtifacts: this.config.supportsRunnerAuthoredPhaseArtifacts,
             supportsDraftRunOnce: this.config.supportsDraftRunOnce,
             supportsDraftAttachments: this.config.supportsDraftAttachments,
-            supportsDraftImageAttachments: this.config.supportsDraftImageAttachments
+            supportsDraftImageAttachments: this.config.supportsDraftImageAttachments,
+            bridgeChat: bridgeChatCapabilityFor(this.config.cliProviders, this.config.providerStatuses, this.config.bridgeChat)
         };
     }
+    async requiredCapabilityFailure(dispatch) {
+        const requiredCapabilities = dispatch.qaScope?.required_capabilities ?? [];
+        if (!requiredCapabilities.includes("docker_engine"))
+            return null;
+        const executionMode = dispatch.sandbox?.executionMode;
+        if (executionMode === "docker") {
+            return dockerEngineRequirementFailure(requiredCapabilities, executionMode, null);
+        }
+        return dockerEngineRequirementFailure(requiredCapabilities, executionMode, await this.dockerEngineProbe.refresh(true));
+    }
     usedSandboxResources(degradedReservations) {
         const resources = [
             ...[...this.reservations.values()]
@@ -811,9 +1763,7 @@ export class ForgeBridgeService {
             workerMemoryLimitBytes: 0,
             serviceMemoryLimitBytes: 0,
             runtimeOverheadBytes: 0,
-            memoryBytes: Math.max(0, preflight.availableMemoryBytes
-                - (this.config.sandboxHostMemoryReserveBytes ?? 2 * 1024 ** 3)
-                + activeResources.memoryBytes),
+            memoryBytes: sandboxMemoryCommitmentCapacity(preflight, activeResources.memoryBytes),
             workspaceBytes: Math.max(0, preflight.availableWorkspaceBytes
                 - this.config.minimumWorkspaceBytes
                 + activeResources.workspaceBytes),
@@ -821,22 +1771,96 @@ export class ForgeBridgeService {
             buildSlots: this.config.maxConcurrentSandboxBuilds
         };
     }
-    async invokeAck(methodName, payload) {
-        const connection = this.connection;
-        if (!connection) {
-            throw new Error("Bridge is not connected.");
+    async invokeAck(methodName, payload, options = {}) {
+        let storageRecoveryAttempt = 0;
+        let callbackTimeoutAttempt = 0;
+        while (true) {
+            if (options.signal?.aborted) {
+                throw new Error(String(options.signal.reason ?? `${methodName} callback was cancelled.`));
+            }
+            const connection = this.connection;
+            if (!connection) {
+                throw new Error("Bridge is not connected.");
+            }
+            await this.waitForTransportRecovery(connection, this.transportRecovery, options.signal);
+            const recoveryGeneration = this.transportRecoveryGeneration;
+            try {
+                const ack = await waitForCallbackAck(connection.invoke(methodName, payload), methodName, positiveFiniteNumber(this.config.callbackAckTimeoutMs ?? 30_000, 30_000), options.signal);
+                if (!ack.accepted) {
+                    throw new BridgeCallbackRejectedError(ack.code ?? null, ack.message ?? ack.code ?? `${methodName} callback was rejected.`);
+                }
+                return ack;
+            }
+            catch (error) {
+                if (options.signal?.aborted)
+                    throw error;
+                if (connection !== this.connection || this.stopped)
+                    throw error;
+                const recovery = this.transportRecovery;
+                if (recovery && recovery.generation > recoveryGeneration) {
+                    await this.waitForTransportRecovery(connection, recovery, options.signal);
+                    continue;
+                }
+                if (isProviderStorageUnavailable(error)) {
+                    const backoff = this.config.reconnectBackoffMs[Math.min(storageRecoveryAttempt, this.config.reconnectBackoffMs.length - 1)] ?? 5000;
+                    storageRecoveryAttempt += 1;
+                    logBridgeStatus(`${methodName} reached Forge while storage was recovering. Retrying callback ${storageRecoveryAttempt} in ${formatDelay(backoff)}...`);
+                    await delay(backoff, options.signal);
+                    continue;
+                }
+                if (options.replayCallbackTimeout && isBridgeCallbackTimeout(error)) {
+                    const backoff = this.config.reconnectBackoffMs[Math.min(callbackTimeoutAttempt, this.config.reconnectBackoffMs.length - 1)] ?? 5000;
+                    callbackTimeoutAttempt += 1;
+                    logBridgeStatus(`${methodName} acknowledgement timed out. Replaying the idempotent callback ${callbackTimeoutAttempt} in ${formatDelay(backoff)}...`);
+                    await delay(backoff, options.signal);
+                    continue;
+                }
+                throw error;
+            }
         }
-        const ack = await connection.invoke(methodName, payload);
-        if (!ack.accepted) {
-            throw new BridgeCallbackRejectedError(ack.code ?? null, ack.message ?? ack.code ?? `${methodName} callback was rejected.`);
+    }
+    beginTransportRecovery() {
+        if (this.transportRecovery && !this.transportRecovery.completed)
+            return;
+        let resolve = () => undefined;
+        const promise = new Promise((complete) => { resolve = complete; });
+        this.transportRecoveryGeneration += 1;
+        this.transportRecovery = {
+            generation: this.transportRecoveryGeneration,
+            promise,
+            resolve,
+            completed: false,
+            error: null,
+        };
+    }
+    completeTransportRecovery(error = null) {
+        const recovery = this.transportRecovery;
+        if (!recovery || recovery.completed)
+            return;
+        recovery.completed = true;
+        recovery.error = error;
+        recovery.resolve();
+    }
+    async waitForTransportRecovery(connection, recovery, signal) {
+        if (!recovery)
+            return;
+        if (recovery.completed) {
+            if (recovery.error)
+                throw recovery.error;
+            return;
         }
-        return ack;
+        await waitForPromiseOrAbort(recovery.promise, signal);
+        signal?.throwIfAborted();
+        if (connection !== this.connection)
+            throw new Error("Bridge connection changed while recovering.");
+        if (recovery.error)
+            throw recovery.error;
     }
     async waitForClose(signal) {
         if (!this.closed) {
             return;
         }
-        await Promise.race([this.closed, abortPromise(signal)]);
+        await waitForPromiseOrAbort(this.closed, signal);
     }
     async stopConnection() {
         this.stopHeartbeat();
@@ -862,11 +1886,23 @@ function isDispatchNoLongerPending(error) {
     }
     return error instanceof Error && error.message === "Dispatch is no longer pending.";
 }
-function createDefaultSessionService(sandboxStateRoot) {
+function isReadinessNoLongerPending(error) {
+    return error instanceof BridgeCallbackRejectedError
+        && (error.code === "bridge.stale_readiness_probe" || error.code === "bridge.stale_runner_instance");
+}
+function isProviderStorageUnavailable(error) {
+    const message = errorMessage(error).toLowerCase();
+    return message.includes("provider_storage_unavailable")
+        || (message.includes("storage is recovering") && message.includes("503"));
+}
+function isBridgeCallbackTimeout(error) {
+    return errorMessage(error).startsWith("bridge_callback_timeout:");
+}
+function createDefaultSessionService(sandboxStateRoot, sandboxExecutionRoot, dockerEngineProbe) {
     const rawProcessRunner = new StreamingProviderProcessRunner();
     const processSupervisors = new AttemptProcessSupervisorRegistry();
     const coordinatedProcessRunner = new AttemptCoordinatedProviderProcessRunner(processSupervisors, rawProcessRunner);
-    return new BridgeSessionService(new GitWorktreeService(undefined, new RepositoryCoordinatorLock(sandboxStateRoot)), new RoutingProviderCliService(new ProcessBackedProviderCliService(coordinatedProcessRunner)), new HostRuntimeLeaseManager(sandboxStateRoot, undefined, undefined, processSupervisors, rawProcessRunner));
+    return new BridgeSessionService(new GitWorktreeService(undefined, new RepositoryCoordinatorLock(sandboxStateRoot)), new RoutingProviderCliService(new ProcessBackedProviderCliService(coordinatedProcessRunner, undefined, undefined, undefined, new PrePublicationValidator(undefined, dockerEngineProbe, readNativeTestPostgresFallback))), new HostRuntimeLeaseManager(sandboxStateRoot, undefined, undefined, processSupervisors, rawProcessRunner, undefined, undefined, undefined, undefined, undefined, sandboxExecutionRoot, createNativeTestClusterDatabaseBroker(readNativeTestPostgresFallback, sandboxStateRoot)));
 }
 export class SignalRBridgeConnectionFactory {
     create(config) {
@@ -890,10 +1926,11 @@ export class SignalRBridgeConnection {
                 Authorization: `Bearer ${config.deviceToken}`
             }
         })
+            .withAutomaticReconnect([...config.reconnectBackoffMs])
             .configureLogging(LogLevel.Warning)
             .build();
         this.connection.on("Superseded", () => {
-            void this.connection.stop();
+            void this.connection.stop().catch(() => undefined);
         });
     }
     start() {
@@ -905,11 +1942,24 @@ export class SignalRBridgeConnection {
     onClose(handler) {
         this.connection.onclose(handler);
     }
+    onReconnecting(handler) {
+        this.connection.onreconnecting(handler);
+    }
+    onReconnected(handler) {
+        this.connection.onreconnected((connectionId) => {
+            void Promise.resolve(handler(connectionId)).catch(() => undefined);
+        });
+    }
     onDispatch(handler) {
         this.connection.on("Dispatch", (raw) => {
             void handler(raw).catch(() => undefined);
         });
     }
+    onChatTurn(handler) {
+        this.connection.on("ChatTurn", (raw) => {
+            void handler(raw).catch(() => undefined);
+        });
+    }
     onOffer(handler) {
         this.connection.on("Offer", (raw) => {
             void handler(raw).catch(() => undefined);
@@ -947,9 +1997,7 @@ export class SignalRBridgeConnection {
 export function defaultBridgeServiceConfig(overrides = {}) {
     const defaults = defaultForgeBridgeConfig();
     const cliProviders = splitCsv(process.env.FORGE_CLI_PROVIDERS ?? "codex");
-    const sandboxHostMemoryReserveDefault = process.platform === "linux"
-        ? 2 * 1024 ** 3
-        : 1024 ** 3;
+    const configuredSandboxHostMemoryReserveBytes = optionalPositiveFiniteNumber(process.env.FORGE_SANDBOX_HOST_MEMORY_RESERVE_BYTES);
     const sandboxPublicationMode = process.env.FORGE_SANDBOX_PUBLICATION_MODE === "bridge_push" ? "bridge_push" : "shared_filesystem";
     const config = {
         serverUrl: process.env.FORGE_URL ?? "http://localhost:5208",
@@ -964,12 +2012,19 @@ export function defaultBridgeServiceConfig(overrides = {}) {
         sandboxPublicationMode,
         dockerExecutable: process.env.FORGE_DOCKER_EXECUTABLE ?? "docker",
         dockerContext: process.env.FORGE_DOCKER_CONTEXT ?? "",
+        dockerDesktopRecoveryEnabled: process.env.FORGE_DOCKER_DESKTOP_AUTO_RECOVERY === "true",
+        dockerRecoveryFailureThreshold: positiveFiniteNumber(Number(process.env.FORGE_DOCKER_RECOVERY_FAILURE_THRESHOLD ?? 3), 3),
+        dockerRecoveryCooldownMs: positiveFiniteNumber(Number(process.env.FORGE_DOCKER_RECOVERY_COOLDOWN_MS ?? 10 * 60_000), 10 * 60_000),
+        dockerRecoveryStartupTimeoutMs: positiveFiniteNumber(Number(process.env.FORGE_DOCKER_RECOVERY_STARTUP_TIMEOUT_MS ?? 2 * 60_000), 2 * 60_000),
         sandboxStateRoot: process.env.FORGE_SANDBOX_STATE_ROOT ?? path.join(os.homedir(), ".forge", "bridge", "sandboxes"),
+        sandboxExecutionRoot: defaultHostExecutionRoot(),
         requireRootlessDocker: process.env.FORGE_REQUIRE_ROOTLESS_DOCKER === "true" || process.platform === "linux",
         diskHighWatermarkPercent: positiveFiniteNumber(Number(process.env.FORGE_DISK_HIGH_WATERMARK_PERCENT ?? 85), 85),
         diskLowWatermarkPercent: positiveFiniteNumber(Number(process.env.FORGE_DISK_LOW_WATERMARK_PERCENT ?? 75), 75),
         minimumWorkspaceBytes: positiveFiniteNumber(Number(process.env.FORGE_MINIMUM_WORKSPACE_BYTES ?? 10 * 1024 ** 3), 10 * 1024 ** 3),
-        sandboxHostMemoryReserveBytes: positiveFiniteNumber(Number(process.env.FORGE_SANDBOX_HOST_MEMORY_RESERVE_BYTES ?? sandboxHostMemoryReserveDefault), sandboxHostMemoryReserveDefault),
+        // Undefined means preflight derives the bounded reserve from the actual
+        // Docker/host capacity domain after sampling it.
+        sandboxHostMemoryReserveBytes: configuredSandboxHostMemoryReserveBytes,
         defaultSandboxWorkerMemoryLimitBytes: positiveFiniteNumber(Number(process.env.FORGE_SANDBOX_DEFAULT_WORKER_MEMORY_LIMIT_BYTES ?? 2 * 1024 ** 3), 2 * 1024 ** 3),
         defaultSandboxServiceMemoryLimitBytes: nonNegativeFiniteNumber(Number(process.env.FORGE_SANDBOX_DEFAULT_SERVICE_MEMORY_LIMIT_BYTES ?? 0), 0),
         sandboxRuntimeOverheadBytes: Math.max(128 * 1024 ** 2, nonNegativeFiniteNumber(Number(process.env.FORGE_SANDBOX_RUNTIME_OVERHEAD_BYTES ?? 128 * 1024 ** 2), 128 * 1024 ** 2)),
@@ -995,10 +2050,12 @@ export function defaultBridgeServiceConfig(overrides = {}) {
         supportsDraftRunOnce: true,
         supportsDraftAttachments: true,
         supportsDraftImageAttachments: supportsDraftImageAttachmentsFor(cliProviders),
+        bridgeChat: bridgeChatCapabilityFor(cliProviders, providerStatusesFor(cliProviders)),
         version: process.env.FORGE_BRIDGE_VERSION ?? forgeBridgeVersion,
-        protocolVersion: 2,
+        protocolVersion: 4,
         minServerVersion: null,
         heartbeatIntervalMs: positiveFiniteNumber(Number(process.env.FORGE_HEARTBEAT_INTERVAL_MS ?? 30_000), 30_000),
+        callbackAckTimeoutMs: positiveFiniteNumber(Number(process.env.FORGE_CALLBACK_ACK_TIMEOUT_MS ?? 30_000), 30_000),
         reconnectBackoffMs: [1000, 2000, 5000, 10000, 30000],
         ...overrides
     };
@@ -1007,7 +2064,9 @@ export function defaultBridgeServiceConfig(overrides = {}) {
         providerStatuses: overrides.providerStatuses ?? providerStatusesFor(config.cliProviders),
         sandboxProfiles: config.sandboxProfiles ?? defaultSandboxProfiles(config.cliProviders),
         supportsDraftImageAttachments: (overrides.supportsDraftImageAttachments ?? true) && supportsDraftImageAttachmentsFor(config.cliProviders),
-        heartbeatIntervalMs: positiveFiniteNumber(config.heartbeatIntervalMs, 30_000)
+        bridgeChat: overrides.bridgeChat ?? bridgeChatCapabilityFor(config.cliProviders, overrides.providerStatuses ?? providerStatusesFor(config.cliProviders), config.bridgeChat),
+        heartbeatIntervalMs: positiveFiniteNumber(config.heartbeatIntervalMs, 30_000),
+        callbackAckTimeoutMs: positiveFiniteNumber(config.callbackAckTimeoutMs ?? 30_000, 30_000),
     };
 }
 export function resolveBridgeRunnerHubUrl(serverUrl) {
@@ -1022,6 +2081,12 @@ function normalizeServerUrl(serverUrl) {
 function positiveFiniteNumber(value, fallback) {
     return Number.isFinite(value) && value > 0 ? value : fallback;
 }
+function optionalPositiveFiniteNumber(value) {
+    if (value === undefined || value.trim().length === 0)
+        return undefined;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
 function nonNegativeFiniteNumber(value, fallback) {
     return Number.isFinite(value) && value >= 0 ? value : fallback;
 }
@@ -1126,15 +2191,32 @@ function mappingKeys(mapping) {
         mapping.localPath ? `path:${path.resolve(mapping.localPath).toLowerCase()}` : null
     ].filter((key) => Boolean(key));
 }
-function findRepoMapping(dispatch, mappings) {
-    return mappings.find((mapping) => {
-        if (!mapping.localPath?.trim()) {
-            return false;
+function findRepoMapping(repo, mappings) {
+    const usable = mappings.filter(mapping => Boolean(mapping.localPath?.trim()));
+    const selectUnique = (candidates, identity) => {
+        if (candidates.length > 1) {
+            throw new Error(`bridge_repo_mapping_ambiguous: multiple local checkouts match ${identity}.`);
         }
-        return (equalsIgnoreCase(mapping.repoId, dispatch.repo.id) ||
-            equalsIgnoreCase(mapping.name, dispatch.repo.name) ||
-            (!!mapping.remoteUrl?.trim() && equalsIgnoreCase(mapping.remoteUrl, dispatch.repo.remoteUrl)));
-    });
+        return candidates[0];
+    };
+    // Repository identity is authoritative. A same-name mapping for a different
+    // repository must never win merely because it appears first in configuration.
+    const byId = usable.filter(mapping => equalsIgnoreCase(mapping.repoId, repo.id));
+    if (byId.length > 0)
+        return selectUnique(byId, `repo id '${repo.id}'`);
+    const byRemote = repo.remoteUrl?.trim()
+        ? usable.filter(mapping => !mapping.repoId?.trim()
+            && Boolean(mapping.remoteUrl?.trim())
+            && equalsIgnoreCase(mapping.remoteUrl, repo.remoteUrl))
+        : [];
+    if (byRemote.length > 0)
+        return selectUnique(byRemote, `remote '${repo.remoteUrl}'`);
+    const byName = usable.filter(mapping => !mapping.repoId?.trim()
+        && !mapping.remoteUrl?.trim()
+        && equalsIgnoreCase(mapping.name, repo.name));
+    return byName.length > 0
+        ? selectUnique(byName, `repo name '${repo.name}'`)
+        : undefined;
 }
 function normalizeQaAppLaunchTarget(target) {
     if (!target) {
@@ -1183,6 +2265,10 @@ function invalidDispatchSummary(error) {
     const detail = error instanceof Error ? error.message : String(error);
     return `Invalid bridge dispatch packet: ${detail}`;
 }
+function invalidChatTurnSummary(error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return `Invalid Bridge Chat turn packet: ${detail}`;
+}
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -1192,29 +2278,328 @@ function formatDelay(ms) {
     }
     return `${ms}ms`;
 }
+async function waitForCallbackAck(callback, methodName, timeoutMs, signal) {
+    let timeout = null;
+    let rejectAbort = null;
+    const expired = new Promise((_resolve, reject) => {
+        timeout = setTimeout(() => {
+            reject(new Error(`bridge_callback_timeout: ${methodName} callback was not acknowledged within ${formatDelay(timeoutMs)}.`));
+        }, timeoutMs);
+    });
+    const aborted = new Promise((_resolve, reject) => {
+        rejectAbort = reject;
+    });
+    const onAbort = () => rejectAbort?.(new Error(String(signal?.reason ?? `${methodName} callback was cancelled.`)));
+    signal?.addEventListener("abort", onAbort, { once: true });
+    if (signal?.aborted)
+        onAbort();
+    try {
+        return await Promise.race(signal ? [callback, expired, aborted] : [callback, expired]);
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+        signal?.removeEventListener("abort", onAbort);
+    }
+}
 function logBridgeStatus(message) {
     process.stderr.write(`[${new Date().toISOString()}] ${message}\n`);
 }
-function delay(ms, signal) {
+export function delay(ms, signal) {
     if (signal?.aborted) {
         return Promise.resolve();
     }
     return new Promise((resolve) => {
-        const timeout = setTimeout(resolve, ms);
-        signal?.addEventListener("abort", () => {
+        const complete = () => {
             clearTimeout(timeout);
+            signal?.removeEventListener("abort", complete);
             resolve();
-        }, { once: true });
+        };
+        const timeout = setTimeout(complete, ms);
+        signal?.addEventListener("abort", complete, { once: true });
+        if (signal?.aborted)
+            complete();
     });
 }
-function abortPromise(signal) {
+export async function waitForPromiseOrAbort(promise, signal) {
     if (!signal) {
-        return new Promise(() => undefined);
+        await promise;
+        return;
     }
     if (signal.aborted) {
-        return Promise.resolve();
+        return;
+    }
+    let resolveAbort;
+    const abort = new Promise(resolve => { resolveAbort = resolve; });
+    signal.addEventListener("abort", resolveAbort, { once: true });
+    try {
+        await Promise.race([promise, abort]);
+    }
+    finally {
+        signal.removeEventListener("abort", resolveAbort);
+    }
+}
+// Matches the API Hello bound on settled recovered host attempts.
+const maxRecoveredHostAttempts = 128;
+const defaultChatTurnLeaseMs = 60 * 60 * 1000;
+const maxChatEventContentChars = 4000;
+const maxChatTerminalTextChars = 120_000;
+const maxChatExactSecretChars = 8 * 1024;
+const chatTurnMetadataFileName = "forge-chat-metadata.json";
+async function materializeChatTurnMetadata(packet, workspacePath) {
+    if (packet.attachmentHandoffs.length === 0 && packet.actionBrokerGrants.length === 0) {
+        return;
+    }
+    await fs.promises.writeFile(path.join(workspacePath, chatTurnMetadataFileName), `${JSON.stringify({
+        schemaVersion: 1,
+        attachmentHandoffs: packet.attachmentHandoffs.map((handoff) => ({
+            turnId: handoff.turnId,
+            attachmentId: handoff.attachmentId,
+            tempFileToken: handoff.tempFileToken,
+            mimeType: handoff.mimeType,
+            sizeBytes: handoff.sizeBytes,
+            sha256: handoff.sha256,
+            fileNameDisplay: handoff.fileNameDisplay,
+            expiresAt: handoff.expiresAt,
+            status: handoff.status,
+        })),
+        actionBrokerGrants: packet.actionBrokerGrants.map((grant) => ({
+            grantId: grant.grantId,
+            turnId: grant.turnId,
+            leaseId: grant.leaseId,
+            fencingToken: grant.fencingToken,
+            allowedScopes: grant.allowedScopes,
+            expiresAt: grant.expiresAt,
+            redactionStatus: grant.redactionStatus,
+            nonceHeldByBridge: true,
+        })),
+    }, null, 2)}\n`, "utf8");
+}
+function chatTurnLeaseExpiresAt(packet, nowMs = Date.now()) {
+    const defaultExpiresAtMs = nowMs + defaultChatTurnLeaseMs;
+    const metadataExpiresAtMs = [
+        ...packet.attachmentHandoffs.map(handoff => Date.parse(handoff.expiresAt)),
+        ...packet.actionBrokerGrants.map(grant => Date.parse(grant.expiresAt)),
+    ].filter(Number.isFinite);
+    return new Date(Math.min(defaultExpiresAtMs, ...metadataExpiresAtMs)).toISOString();
+}
+async function cleanupChatTurnWorkspace(workspacePath, redactionSecrets) {
+    try {
+        await fs.promises.rm(workspacePath, { recursive: true, force: true, maxRetries: 3 });
+        return {
+            status: "completed",
+            eventType: "chat_turn_cleanup_completed",
+            role: "runner",
+            kind: "checkpoint",
+            content: "Bridge Chat workspace cleanup completed.",
+        };
+    }
+    catch (error) {
+        return {
+            status: "failed",
+            eventType: "chat_turn_cleanup_failed",
+            role: "runner",
+            kind: "error",
+            content: "Bridge Chat workspace cleanup failed.",
+            message: clip(redactText(errorMessage(error), redactionSecrets), 1000),
+        };
+    }
+}
+function buildChatProviderCommand(packet, cwd) {
+    const provider = packet.providerKind.trim().toLowerCase();
+    const model = packet.model.trim();
+    const prompt = buildChatPrompt(packet);
+    const resumeThreadId = packet.providerThreadId?.trim() || null;
+    if (provider === "codex") {
+        const args = ["-s", codexSandboxModeForPlatform(process.platform, "host"), "-a", "never", "exec"];
+        if (resumeThreadId) {
+            args.push("--cd", cwd, "resume");
+        }
+        args.push("--model", model, "--json");
+        if (!resumeThreadId) {
+            args.push("--cd", cwd);
+        }
+        args.push("--skip-git-repo-check");
+        if (resumeThreadId) {
+            args.push(resumeThreadId);
+        }
+        args.push("-");
+        return { command: { command: "codex", args }, stdin: prompt };
+    }
+    if (provider === "cursor") {
+        const args = ["--print", "--output-format", "stream-json", "--model", model, "--workspace", cwd];
+        if (resumeThreadId) {
+            args.push("--resume", resumeThreadId);
+        }
+        args.push("--yolo", "--approve-mcps", "--trust", prompt);
+        return { command: { command: "cursor-agent", args } };
+    }
+    if (provider === "claude") {
+        const args = ["-p", "--output-format", "stream-json", "--verbose", "--model", model, "--permission-mode", "bypassPermissions"];
+        if (resumeThreadId) {
+            args.push("--resume", resumeThreadId);
+        }
+        return { command: { command: "claude", args }, stdin: prompt };
+    }
+    return {
+        command: {
+            command: provider,
+            args: ["--model", model, prompt],
+        },
+    };
+}
+function buildChatPrompt(packet) {
+    const messages = packet.messages
+        .map((message, index) => {
+        const role = message.role.trim() || `message-${index + 1}`;
+        return `[${role}]\n${message.content}`;
+    })
+        .join("\n\n");
+    const contextRefs = packet.contextRefs.length === 0
+        ? ""
+        : `\n\n# Context References\n\n${packet.contextRefs.map((ref, index) => {
+            const title = ref.title?.trim() ? `\nTitle: ${ref.title.trim()}` : "";
+            const summary = ref.summary?.trim() ? `\nSummary: ${ref.summary.trim()}` : "";
+            return `${index + 1}. ${ref.kind}:${ref.refId}${title}${summary}`;
+        }).join("\n\n")}`;
+    const continuation = packet.providerThreadId
+        ? "\n\nContinue the existing provider thread identified by the bridge; do not restart the conversation context."
+        : "";
+    const boundedMetadata = buildChatBoundedMetadataPrompt(packet);
+    return `You are handling a Forge Bridge Chat turn.
+
+Conversation ID: ${packet.conversationId}
+Turn ID: ${packet.turnId}
+Provider: ${packet.providerKind}
+Model: ${packet.model}${continuation}${boundedMetadata}
+
+# Conversation
+
+${messages}${contextRefs}
+`;
+}
+function buildChatBoundedMetadataPrompt(packet) {
+    if (packet.attachmentHandoffs.length === 0 && packet.actionBrokerGrants.length === 0) {
+        return "";
+    }
+    const sections = [
+        `\n\n# Bounded Handoff Metadata\n\nMetadata file: ${chatTurnMetadataFileName}\n\nThe metadata file is turn-scoped and cleaned up by the bridge when the turn ends. It contains opaque handles only; attachment content, raw paths, and grant nonces are not included.`,
+    ];
+    if (packet.attachmentHandoffs.length > 0) {
+        sections.push(`Attachment handoffs:\n${packet.attachmentHandoffs.map((handoff, index) => [
+            `${index + 1}. turnId: ${handoff.turnId}`,
+            `   attachmentId: ${handoff.attachmentId}`,
+            `   tempFileToken: ${handoff.tempFileToken}`,
+            `   mimeType: ${handoff.mimeType}`,
+            `   sizeBytes: ${handoff.sizeBytes}`,
+            `   sha256: ${handoff.sha256}`,
+            `   fileNameDisplay: ${handoff.fileNameDisplay}`,
+            `   expiresAt: ${handoff.expiresAt}`,
+            `   status: ${handoff.status}`,
+        ].join("\n")).join("\n\n")}`);
+    }
+    if (packet.actionBrokerGrants.length > 0) {
+        sections.push(`Action-broker grants:\n${packet.actionBrokerGrants.map((grant, index) => [
+            `${index + 1}. grantId: ${grant.grantId}`,
+            `   turnId: ${grant.turnId}`,
+            `   leaseId: ${grant.leaseId}`,
+            `   fencingToken: ${grant.fencingToken}`,
+            `   allowedScopes: ${grant.allowedScopes.join(", ")}`,
+            `   expiresAt: ${grant.expiresAt}`,
+            `   redactionStatus: ${grant.redactionStatus}`,
+            "   nonce: held by bridge",
+        ].join("\n")).join("\n\n")}`);
+    }
+    return sections.join("\n\n");
+}
+function chatProviderExitFailure(command, result, redactionSecrets) {
+    const commandText = redactText(formatProviderCliCommandForCheckpoint(command), redactionSecrets);
+    const stderr = clip(redactText(result.stderr.trim(), redactionSecrets), 1000);
+    const stdout = clip(redactText(result.stdout.trim(), redactionSecrets), 1000);
+    const diagnostics = [
+        stderr ? `stderr: ${stderr}` : null,
+        stdout ? `stdout: ${stdout}` : null,
+    ].filter(Boolean).join(" ");
+    return new Error(`provider_failed: ${commandText} exited with code ${result.exitCode}.${diagnostics ? ` ${diagnostics}` : ""}`);
+}
+function chatAbortKind(reason) {
+    const message = typeof reason === "string" ? reason.toLowerCase() : "";
+    return message.includes("expired") ? "expired" : "cancelled";
+}
+function chatAbortPayload(reason, cleanupOutcome, packet) {
+    const kind = chatAbortKind(reason);
+    const message = typeof reason === "string" && reason.trim()
+        ? reason.trim()
+        : (kind === "expired" ? "Bridge Chat turn expired." : "Bridge Chat turn cancelled.");
+    return {
+        code: kind === "expired" ? "chat_turn_expired" : "chat_turn_cancelled",
+        message: clip(redactText(message, packet ? chatRedactionSecrets(packet) : []), 1000),
+        cleanup: cleanupOutcome,
+    };
+}
+function providerThreadIdFromEvent(event) {
+    if (!event.data) {
+        return null;
+    }
+    try {
+        const data = JSON.parse(event.data);
+        for (const key of ["threadId", "thread_id", "sessionId", "session_id", "providerThreadId"]) {
+            const value = data[key];
+            if (typeof value === "string") {
+                const clean = value.trim();
+                if (clean.length > 0 && clean.length <= bridgeChatMaxProviderThreadIdChars) {
+                    return clean;
+                }
+            }
+        }
+    }
+    catch {
+        return null;
     }
-    return new Promise((resolve) => signal.addEventListener("abort", () => resolve(), { once: true }));
+    return null;
+}
+function chatRedactionSecrets(packet) {
+    return [
+        packet.chatRunId,
+        packet.conversationId,
+        packet.turnId,
+        packet.leaseId,
+        packet.fencingToken,
+        packet.runnerInstanceId,
+        packet.providerThreadId,
+        ...packet.attachmentHandoffs.flatMap((handoff) => [
+            handoff.attachmentId,
+            handoff.tempFileToken,
+        ]),
+        ...packet.actionBrokerGrants.flatMap((grant) => [
+            grant.grantId,
+            grant.nonce,
+        ]),
+        ...packet.messages.flatMap((message) => boundedChatSecretFragments(message.content)),
+        ...packet.contextRefs.flatMap((ref) => [
+            ...boundedChatSecretFragments(ref.title ?? ""),
+            ...boundedChatSecretFragments(ref.summary ?? ""),
+        ]),
+    ].filter((value) => typeof value === "string" && value.length > 0);
+}
+function boundedChatSecretFragments(value) {
+    const clean = value.trim();
+    if (!clean) {
+        return [];
+    }
+    if (clean.length <= maxChatExactSecretChars) {
+        return [clean];
+    }
+    const half = Math.floor(maxChatExactSecretChars / 2);
+    return [clean.slice(0, half), clean.slice(clean.length - half)];
+}
+function safePathComponent(value) {
+    const clean = value.trim().replace(/[^a-zA-Z0-9_.-]+/gu, "-").replace(/^-+|-+$/gu, "");
+    return clean || "chat-turn";
+}
+function containsIgnoreCase(values, value) {
+    const normalized = value.trim().toLowerCase();
+    return values.some((candidate) => candidate.trim().toLowerCase() === normalized);
 }
 export function canReapManagedSandboxes(preflight) {
     return canRunDockerMaintenance(preflight);
@@ -1234,24 +2619,15 @@ function sandboxNetworkPolicyFailure(dispatch, config) {
     }
     return null;
 }
-function infrastructureFailureEventType(summary) {
-    if (summary.startsWith("worktree_prepare_failed:"))
-        return "worktree_prepare_failed";
-    if (summary.startsWith("provider_start_unavailable:"))
-        return "provider_start_unavailable";
-    if (summary.startsWith("host_port_collision:"))
-        return "host_port_collision";
-    if (summary.startsWith("host_runtime_process_exited:"))
-        return "host_runtime_process_exited";
-    if (summary.startsWith("host_runtime_listener_timeout:"))
-        return "host_runtime_listener_timeout";
-    if (summary.startsWith("host_runtime_http_readiness_timeout:"))
-        return "host_runtime_http_readiness_timeout";
-    if (summary.startsWith("attempt_process_supervisor_start_failed:"))
-        return "attempt_process_supervisor_start_failed";
-    if (summary.startsWith("attempt_process_supervisor_start_timeout:"))
-        return "attempt_process_supervisor_start_timeout";
-    return null;
+export function dockerEngineRequirementFailure(requiredCapabilities, executionMode, capability) {
+    if (!requiredCapabilities.includes("docker_engine"))
+        return null;
+    if (executionMode === "docker") {
+        return "docker_engine_unavailable: docker_engine is not exposed inside Forge agent sandboxes; use a managed host runner with Docker-daemon access.";
+    }
+    return capability?.available
+        ? null
+        : `docker_engine_unavailable: ${capability?.unavailableReason ?? "Docker daemon is unreachable from the bridge process."}`;
 }
 function parseReadinessProbe(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
@@ -1279,6 +2655,24 @@ function parseReadinessProbe(value) {
     }
     return request;
 }
+function deferredReadinessResult(request, runnerInstanceId) {
+    return {
+        schemaVersion: 1,
+        requestId: request.requestId,
+        fencingToken: request.fencingToken,
+        runnerInstanceId,
+        status: "failed",
+        reasonCode: "host_runtime_probe_deferred",
+        reasonMessage: "Foreground agent work is active; Forge deferred background runtime readiness so it cannot consume the agent's host capacity.",
+        checkedAt: new Date().toISOString(),
+    };
+}
+function readinessDeferralReason(signal) {
+    if (!signal.aborted)
+        return null;
+    const reason = errorMessage(signal.reason);
+    return reason.startsWith("host_runtime_probe_deferred:") ? reason : null;
+}
 function sandboxProviderNetworkFailure(dispatch, config) {
     const sandbox = dispatch.sandbox;
     if (!sandbox || sandbox.networkPolicy.mode !== "offline")
@@ -1308,6 +2702,15 @@ function sandboxAuthFailure(dispatch, config) {
     const doctor = adapter.doctor();
     return doctor.available ? null : doctor.message;
 }
+function rejectedOfferReservation(code, message) {
+    return {
+        accepted: false,
+        code,
+        message,
+        reservedUntil: null,
+        resources: null,
+    };
+}
 export function canReserveSandboxResources(used, requested, capacity) {
     return used.sandboxSlots + requested.sandboxSlots <= capacity.sandboxSlots
         && used.cpuMillis + requested.cpuMillis <= capacity.cpuMillis
@@ -1316,6 +2719,14 @@ export function canReserveSandboxResources(used, requested, capacity) {
         && used.pids + requested.pids <= capacity.pids
         && used.buildSlots + requested.buildSlots <= capacity.buildSlots;
 }
+export function sandboxMemoryCommitmentCapacity(preflight, activeMemoryBytes) {
+    const ambientCapacity = preflight.availableMemoryBytes
+        - preflight.hostReserveBytes
+        + activeMemoryBytes;
+    const commitmentCapacity = preflight.totalMemoryBytes
+        - preflight.hostReserveBytes;
+    return Math.max(0, Math.min(ambientCapacity, commitmentCapacity));
+}
 export function sandboxCapacityFailureMessage(used, requested, capacity, preflight, config) {
     const availableSlots = Math.max(0, capacity.sandboxSlots - used.sandboxSlots);
     if (requested.sandboxSlots > availableSlots) {
@@ -1346,14 +2757,6 @@ export function sandboxCapacityFailureMessage(used, requested, capacity, preflig
     const availableBuildSlots = Math.max(0, capacity.buildSlots - used.buildSlots);
     return `Sandbox build capacity is insufficient: requested ${requested.buildSlots}, available ${availableBuildSlots}, ${used.buildSlots} already reserved.`;
 }
-function formatBytes(bytes) {
-    if (!Number.isFinite(bytes) || bytes <= 0)
-        return "0 B";
-    const units = ["B", "KiB", "MiB", "GiB", "TiB"];
-    const power = Math.min(units.length - 1, Math.floor(Math.log(bytes) / Math.log(1024)));
-    const value = bytes / 1024 ** power;
-    return `${value >= 10 || power === 0 ? value.toFixed(0) : value.toFixed(2)} ${units[power]}`;
-}
 function sumSandboxResources(resources) {
     return resources.reduce((total, resource) => ({
         sandboxSlots: total.sandboxSlots + resource.sandboxSlots,
@@ -1425,8 +2828,16 @@ export async function resolveSandboxResourcesFromRepo(dispatch, baseRuntimeOverh
         throw new Error("The approved immutable sandbox contract is unavailable in the mapped repository.");
     }
     const contract = validateSandboxContract(contractResult.stdout);
+    const workspaceBytes = await estimateWorkspaceBytesFromRepo(repoPath, {
+        role: dispatch.execution.role,
+        serviceCount: contract.contract.services.length,
+        browser: contract.contract.browser,
+    });
     return {
-        resources: resolveDynamicSandboxResources(sandbox.requestedResources, contract.contract.services.length, sandbox.networkPolicy.mode, baseRuntimeOverheadBytes),
+        resources: resolveDynamicSandboxResources({
+            ...sandbox.requestedResources,
+            workspaceBytes: Math.max(sandbox.requestedResources.workspaceBytes, workspaceBytes),
+        }, contract.contract.services.length, sandbox.networkPolicy.mode, baseRuntimeOverheadBytes),
         sandboxConfigCommitSha: configCommitSha,
     };
 }