@rynx-ai/server 0.1.11-beta.2 → 0.1.11-beta.4

package/dist/control-api.js

@@ -9,7 +9,7 @@
 import { timingSafeEqual } from "node:crypto";
 import Router from "@koa/router";
 import { skillInstallRecipeSchema, } from "@rynx-ai/core";
-import { DAEMON_BROWSER_ARTIFACT_CLEAN_PATH, DAEMON_BROWSER_ARTIFACT_INSTALL_PATH, DAEMON_BROWSER_ARTIFACT_UPDATE_PATH, DAEMON_BROWSER_ARTIFACT_VERSION_PATH, DAEMON_CHROME_INSPECTION_PATH, DAEMON_CLEANUP_SESSIONS_PATH, DAEMON_SHUTDOWN_IF_IDLE_PATH, parseDaemonBrowserArtifactInstallInput, parseDaemonBrowserArtifactUpdateInput, parseDaemonChromeInspectionConfigureInput, parseDaemonCleanupSessionsInput, } from "@rynx-ai/protocol/control";
+import { DAEMON_BROWSER_ARTIFACT_CLEAN_PATH, DAEMON_BROWSER_ARTIFACT_INSTALL_PATH, DAEMON_BROWSER_ARTIFACT_UPDATE_PATH, DAEMON_BROWSER_ARTIFACT_VERSION_PATH, DAEMON_CHROME_INSPECTION_PATH, DAEMON_CLEANUP_SESSIONS_PATH, DAEMON_MAINTENANCE_LEASE_HEADER, DAEMON_MAINTENANCE_LEASE_RELEASE_PATH, DAEMON_SHUTDOWN_IF_IDLE_PATH, parseDaemonBrowserArtifactInstallInput, parseDaemonBrowserArtifactUpdateInput, parseDaemonChromeInspectionConfigureInput, parseDaemonCleanupSessionsInput, } from "@rynx-ai/protocol/control";
 import { DIRECT_RUNTIME_CONTROL_PATH, encodePairingCode, } from "@rynx-ai/protocol/direct-runtime";
 import { PLUGIN_CONSOLE_INSTALL_PREPARATIONS_PATH, PLUGIN_CONSOLE_MARKETPLACES_PATH, PLUGIN_INSTALL_PREPARATIONS_PATH, PLUGIN_MARKETPLACES_PATH, parsePluginInstallCommitInput, parsePluginInstallPrepareInput, parsePluginMarketplaceAddInput, } from "@rynx-ai/protocol/plugin-management";
 import { parseDaemonStatus } from "@rynx-ai/protocol/remote-runtime";
@@ -1918,18 +1918,42 @@ export function createControlRouter(opts) {
             return;
         ctx.body = encodeDaemonStatus(remoteRuntime.status());
     });
-    router.post(DAEMON_SHUTDOWN_IF_IDLE_PATH, (ctx) => {
+    router.post(DAEMON_SHUTDOWN_IF_IDLE_PATH, async (ctx) => {
         if (!isConfiguredDaemonManagement(daemonManagement) ||
             !daemonManagement.shutdownIfIdle) {
             return notFound(ctx, "daemon shutdown management is not configured");
         }
         if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
             return;
-        const result = daemonManagement.shutdownIfIdle();
+        const maintenanceLeaseToken = ctx.get(DAEMON_MAINTENANCE_LEASE_HEADER).trim() || undefined;
+        let result;
+        try {
+            result = await daemonManagement.shutdownIfIdle(maintenanceLeaseToken);
+        }
+        catch (error) {
+            ctx.set("Cache-Control", "no-store");
+            ctx.status = 409;
+            ctx.body = {
+                error: error instanceof Error ? error.message : String(error),
+            };
+            return;
+        }
         ctx.set("Cache-Control", "no-store");
         ctx.status = result.outcome === "accepted" ? 202 : 409;
         ctx.body = result;
     });
+    router.post(DAEMON_MAINTENANCE_LEASE_RELEASE_PATH, (ctx) => {
+        if (!isConfiguredDaemonManagement(daemonManagement)
+            || !daemonManagement.releaseMaintenanceLease) {
+            return notFound(ctx, "daemon maintenance lease management is not configured");
+        }
+        if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
+            return;
+        const result = daemonManagement.releaseMaintenanceLease(ctx.get(DAEMON_MAINTENANCE_LEASE_HEADER).trim());
+        ctx.set("Cache-Control", "no-store");
+        ctx.status = result.outcome === "denied" ? 403 : 200;
+        ctx.body = result;
+    });
     router.post(DAEMON_BROWSER_ARTIFACT_INSTALL_PATH, async (ctx) => {
         await mutateBrowserArtifact(ctx, "install");
     });

package/dist/machine-session-service.d.ts

@@ -1,4 +1,4 @@
-import { type AgentRuntimeId, type ConversationRuntime, type ResolvedExecutionSnapshot, type SessionWorkspaceSnapshot, type SessionProviderId, type MachineSessionRecord, type ReasoningEffort, type RuntimeUserInput, type SessionBus, type SessionLogStore, type SessionRegistry } from "@rynx-ai/core";
+import { type AdmissionReservation, type AgentRuntimeId, type ConversationRuntime, type ResolvedExecutionSnapshot, type SessionWorkspaceSnapshot, type SessionProviderId, type MachineSessionRecord, type ReasoningEffort, type RuntimeUserInput, type SessionBus, type SessionLogStore, type SessionRegistry } from "@rynx-ai/core";
 import type { SequencedSessionEvent, SessionEvent, SessionInteractionResolution, SessionItem, UserContentPart } from "@rynx-ai/protocol";
 import type { RemoteRuntimeSessionResourceDeleteParams, RemoteRuntimeSessionResourceDeleteResult, RemoteRuntimeSessionResourceGetParams, RemoteRuntimeSessionResourceGetResult, RemoteRuntimeSessionResourcePolicyResult, RemoteRuntimeSessionResourceReadParams, RemoteRuntimeSessionResourceReadResult, RemoteRuntimeSessionResourceUploadBeginParams, RemoteRuntimeSessionResourceUploadBeginResult, RemoteRuntimeSessionResourceUploadChunkParams, RemoteRuntimeSessionResourceUploadChunkResult, RemoteRuntimeSessionResourceUploadCommitParams, RemoteRuntimeSessionResourceUploadCommitResult } from "@rynx-ai/protocol/remote-runtime-rpc";
 import type { ControlAgentSummary, ControlSessionInteractionResolveDisposition, ControlSessionRuntimeSnapshot } from "@rynx-ai/protocol/control";
@@ -6,6 +6,7 @@ import { type RemoteRuntimeSessionInterruptResult, type RemoteRuntimeSessionLaun
 import type { CodexRuntimeStatus, InjectOutcome } from "@rynx-ai/runtime";
 export interface MachineSessionRuntimeStatePort {
     snapshot(sessionId: string): ControlSessionRuntimeSnapshot;
+    beginResponseHandoff?(sessionId: string, responseId: string): () => void;
     remove?(sessionId: string): void;
 }
 export interface MachineSessionInterruptPort {
@@ -181,6 +182,11 @@ export interface MachineSessionServiceOptions {
     directoryScanLimit?: number;
     /** Delay between setup-readiness retries for durable pending messages. */
     pendingMessageRetryMs?: number;
+    /** Dynamic daemon-wide admission fence used during process replacement. */
+    admissionOpen?: () => boolean;
+    /** Atomically reserves one work-producing admission until it is rejected or
+     * has become visible in the daemon activity projection. */
+    admissionReserve?: () => AdmissionReservation | undefined;
 }
 export type MachineSessionListInput = RemoteRuntimeSessionListParams;
 export interface MachineSessionListPage extends RemoteRuntimeSessionListResult {
@@ -277,6 +283,8 @@ export declare class MachineSessionService {
     private readonly snapshotPageMaxBytes;
     private readonly directoryScanLimit;
     private readonly pendingMessageRetryMs;
+    private readonly admissionOpen;
+    private readonly admissionReserve;
     private readonly pendingDeliveries;
     private readonly cancelledPendingDeliveries;
     private readonly forkTasks;
@@ -300,10 +308,12 @@ export declare class MachineSessionService {
     launchOptions(): Promise<RemoteRuntimeSessionLaunchOptionsListResult>;
     /** Create target-owned Session identity from one Agent preset or direct Provider. */
     create(input: MachineSessionCreateInput): Promise<MachineSessionCreateResult>;
+    private createAdmitted;
     /** Create one independent Session at the source's stable Provider/canonical
      * boundary. Project and Agent selectors are intentionally absent: the target
      * receives exact copies of the source's already-frozen snapshots. */
     fork(input: MachineSessionForkInput): Promise<MachineSessionForkResult>;
+    private forkAdmitted;
     /** Publish a Provider TUI `/clear` or `/fork` after its native binding has
      * already been persisted. The source snapshots remain the only workspace and
      * execution authority; Provider events cannot alter them during rotation. */
@@ -312,6 +322,7 @@ export declare class MachineSessionService {
     private assertForkableSource;
     /** Inject one turn through the target daemon's native single-writer runner. */
     sendMessage(sessionIdInput: string, messageInput: string | MachineSessionMessageInput): Promise<MachineSessionMessageResult>;
+    private sendMessageAdmitted;
     resourcePolicy(sessionIdInput: string): RemoteRuntimeSessionResourcePolicyResult;
     beginResourceUpload(input: RemoteRuntimeSessionResourceUploadBeginParams): Promise<RemoteRuntimeSessionResourceUploadBeginResult>;
     writeResourceUploadChunk(input: RemoteRuntimeSessionResourceUploadChunkParams): Promise<RemoteRuntimeSessionResourceUploadChunkResult>;
@@ -323,13 +334,17 @@ export declare class MachineSessionService {
      * delivery worker starts the pane now, waits for a real native thread, then
      * injects exactly once. `failed` is fenced as outcome_unknown and never retried. */
     enqueueMessage(sessionIdInput: string, messageInput: string): Promise<MachineSessionMessageEnqueueResult>;
+    private enqueueMessageAdmitted;
     /** Explicitly restore the target daemon's live runner without starting a turn. */
     startTerminal(sessionIdInput: string): Promise<MachineSessionTerminalStartResult>;
+    private startTerminalAdmitted;
     private ensureLiveSession;
     private liveSessionRequest;
     resolveInteraction(sessionIdInput: string, interactionIdInput: string, resolution: SessionInteractionResolution): Promise<MachineSessionInteractionResult>;
     delete(sessionIdInput: string): Promise<MachineSessionDeleteResult>;
     private requireAgents;
+    private reserveAdmission;
+    private withAdmission;
     private requireResources;
     private requireResourceSession;
     private resumePendingDeliveries;

package/dist/machine-session-service.js

@@ -47,6 +47,8 @@ export class MachineSessionService {
     snapshotPageMaxBytes;
     directoryScanLimit;
     pendingMessageRetryMs;
+    admissionOpen;
+    admissionReserve;
     pendingDeliveries = new Map();
     cancelledPendingDeliveries = new Set();
     forkTasks = new Map();
@@ -58,6 +60,8 @@ export class MachineSessionService {
         this.snapshotPageMaxBytes = boundedInteger(options.snapshotPageMaxBytes ?? DEFAULT_SNAPSHOT_PAGE_MAX_BYTES, MIN_PAGE_MAX_BYTES, MAX_PAGE_MAX_BYTES, "snapshotPageMaxBytes");
         this.directoryScanLimit = boundedInteger(options.directoryScanLimit ?? DEFAULT_DIRECTORY_SCAN_LIMIT, 1, MAX_DIRECTORY_SCAN_LIMIT, "directoryScanLimit");
         this.pendingMessageRetryMs = boundedInteger(options.pendingMessageRetryMs ?? 1_000, 10, 60_000, "pendingMessageRetryMs");
+        this.admissionOpen = options.admissionOpen ?? (() => true);
+        this.admissionReserve = options.admissionReserve;
         void this.resumePendingDeliveries();
         void this.resumeReservedForks();
     }
@@ -190,6 +194,9 @@ export class MachineSessionService {
     }
     /** Create target-owned Session identity from one Agent preset or direct Provider. */
     async create(input) {
+        return this.withAdmission(() => this.createAdmitted(input));
+    }
+    async createAdmitted(input) {
         const hasAgent = input.agent !== undefined;
         const hasProvider = input.provider !== undefined;
         if (hasAgent === hasProvider) {
@@ -240,6 +247,9 @@ export class MachineSessionService {
      * boundary. Project and Agent selectors are intentionally absent: the target
      * receives exact copies of the source's already-frozen snapshots. */
     async fork(input) {
+        return this.withAdmission(() => this.forkAdmitted(input));
+    }
+    async forkAdmitted(input) {
         const sourceSessionId = validOpaqueToken(input.sourceSessionId, "sourceSessionId", MAX_SESSION_ID_CHARS);
         const operationId = validOpaqueToken(input.operationId, "operationId", MAX_SESSION_ID_CHARS);
         const title = input.title === undefined
@@ -383,6 +393,9 @@ export class MachineSessionService {
     }
     /** Inject one turn through the target daemon's native single-writer runner. */
     async sendMessage(sessionIdInput, messageInput) {
+        return this.withAdmission(() => this.sendMessageAdmitted(sessionIdInput, messageInput));
+    }
+    async sendMessageAdmitted(sessionIdInput, messageInput) {
         const sessionId = validOpaqueToken(sessionIdInput, "sessionId", MAX_SESSION_ID_CHARS);
         await this.assertNotForkReserved(sessionId);
         const request = typeof messageInput === "string"
@@ -471,6 +484,9 @@ export class MachineSessionService {
                 statusKind: "startup",
             });
         }
+        const abandonResponseHandoff = responseId
+            ? this.ports.runtimeState.beginResponseHandoff?.(sessionId, responseId)
+            : undefined;
         const clearStartup = async (status) => {
             if (!responseId)
                 return;
@@ -486,6 +502,7 @@ export class MachineSessionService {
             execution = await this.ensureLiveSession(sessionId, meta);
         }
         catch (error) {
+            abandonResponseHandoff?.();
             await clearStartup("idle");
             if (request.clientMessageId) {
                 await resources?.markMessageFailedNotStarted(sessionId, request.clientMessageId, error instanceof Error ? error.message : String(error));
@@ -500,6 +517,7 @@ export class MachineSessionService {
             outcome = await execution.runner.injectMessage(sessionId, responseId || needsPreparedOperation ? runtimeInput : request.message);
         }
         catch (error) {
+            abandonResponseHandoff?.();
             await clearStartup("idle");
             if (request.clientMessageId) {
                 await Promise.resolve(resources?.markMessageOutcomeUnknown(sessionId, request.clientMessageId, error instanceof Error ? error.message : String(error))).catch(() => undefined);
@@ -507,6 +525,7 @@ export class MachineSessionService {
             throw new MachineSessionServiceFailure("outcome_unknown", "live injection outcome is unknown");
         }
         if (outcome === "failed") {
+            abandonResponseHandoff?.();
             await clearStartup("idle");
             if (request.clientMessageId) {
                 await resources?.markMessageOutcomeUnknown(sessionId, request.clientMessageId, `live injection ${outcome}`);
@@ -514,6 +533,7 @@ export class MachineSessionService {
             throw new MachineSessionServiceFailure("outcome_unknown", `live injection ${outcome}`);
         }
         if (outcome !== "injected") {
+            abandonResponseHandoff?.();
             await clearStartup("idle");
             if (request.clientMessageId) {
                 await resources?.markMessageFailedNotStarted(sessionId, request.clientMessageId, `live injection ${outcome}`);
@@ -564,6 +584,9 @@ export class MachineSessionService {
      * delivery worker starts the pane now, waits for a real native thread, then
      * injects exactly once. `failed` is fenced as outcome_unknown and never retried. */
     async enqueueMessage(sessionIdInput, messageInput) {
+        return this.withAdmission(() => this.enqueueMessageAdmitted(sessionIdInput, messageInput));
+    }
+    async enqueueMessageAdmitted(sessionIdInput, messageInput) {
         const sessionId = validOpaqueToken(sessionIdInput, "sessionId", MAX_SESSION_ID_CHARS);
         await this.assertNotForkReserved(sessionId);
         if (typeof messageInput !== "string" || messageInput.length === 0) {
@@ -595,6 +618,9 @@ export class MachineSessionService {
     }
     /** Explicitly restore the target daemon's live runner without starting a turn. */
     async startTerminal(sessionIdInput) {
+        return this.withAdmission(() => this.startTerminalAdmitted(sessionIdInput));
+    }
+    async startTerminalAdmitted(sessionIdInput) {
         const sessionId = validOpaqueToken(sessionIdInput, "sessionId", MAX_SESSION_ID_CHARS);
         const request = await this.liveSessionRequest(sessionId);
         const start = request.execution.runner.startLiveSession?.bind(request.execution.runner) ??
@@ -662,6 +688,24 @@ export class MachineSessionService {
         }
         return this.ports.agents;
     }
+    reserveAdmission() {
+        const reservation = this.admissionReserve?.();
+        if (reservation)
+            return reservation;
+        if (!this.admissionReserve && this.admissionOpen()) {
+            return { release() { } };
+        }
+        throw new MachineSessionServiceFailure("failed_precondition", "daemon maintenance is in progress");
+    }
+    async withAdmission(operation) {
+        const reservation = this.reserveAdmission();
+        try {
+            return await operation();
+        }
+        finally {
+            reservation.release();
+        }
+    }
     requireResources() {
         if (!this.ports.resources) {
             throw new MachineSessionServiceFailure("failed_precondition", "Session resources are unavailable");
@@ -713,7 +757,9 @@ export class MachineSessionService {
             if (!pending || pending.state !== "queued")
                 return;
             let injectionAttempted = false;
+            let admission;
             try {
+                admission = this.reserveAdmission();
                 const execution = await this.ensureLiveSession(sessionId);
                 if (this.cancelledPendingDeliveries.has(sessionId))
                     return;
@@ -746,6 +792,9 @@ export class MachineSessionService {
                     return;
                 }
             }
+            finally {
+                admission?.release();
+            }
             await retryDelay(this.pendingMessageRetryMs);
         }
     }

package/dist/server.d.ts

@@ -1,6 +1,6 @@
 import type { Server as HttpServer } from "node:http";
 import Koa from "koa";
-import { ConversationRuntime, type AgentCapabilities, type AgentSessionStore, type AppConfig, type SessionEvent, type SessionBus, type SessionLogStore, type SessionRegistry } from "@rynx-ai/core";
+import { ConversationRuntime, type AdmissionReservation, type AgentCapabilities, type AgentSessionStore, type AppConfig, type SessionEvent, type SessionBus, type SessionLogStore, type SessionRegistry } from "@rynx-ai/core";
 import type { SessionInteractionResolution } from "@rynx-ai/protocol";
 import type { ControlRuntimeShareAddress, DaemonBrowserArtifactCleanResult, DaemonBrowserArtifactInstallInput, DaemonBrowserArtifactInstallResult, DaemonBrowserArtifactUpdateInput, DaemonBrowserArtifactVersionResult, DaemonCleanupSessionsInput, DaemonCleanupSessionsResult, DaemonChromeInspectionConfigureInput, DaemonChromeInspectionStatus, DaemonShutdownIfIdleResult } from "@rynx-ai/protocol/control";
 import type { PluginInstallCommitInput, PluginInstallCommitResult, PluginInstallPreparation, PluginInstallPrepareInput, PluginManagementItem, PluginMarketplaceAddInput, PluginMarketplaceItem } from "@rynx-ai/protocol/plugin-management";
@@ -155,9 +155,14 @@ export interface PluginRuntimeHostServices {
         }): Promise<PluginResolvedSessionExecution>;
     };
     interruptSession(sessionId: string): Promise<boolean>;
+    terminateSession?(sessionId: string): Promise<boolean>;
     resolveSessionInteraction(sessionId: string, interactionId: string, resolution: SessionInteractionResolution): Promise<{
         disposition: "applied" | "already_resolved" | "not_found" | "invalid";
     }>;
+    /** Dynamic daemon-wide admission state. Plugin runtimes may start while this is
+     * closed, but cannot provision Sessions or begin Turns. */
+    admissionOpen?: () => boolean;
+    admissionReserve?: () => AdmissionReservation | undefined;
 }
 export interface PluginRuntimeLifecycle {
     bindHostServices(services: PluginRuntimeHostServices): void;
@@ -236,7 +241,11 @@ export interface DaemonManagementHost {
         restartRequired: boolean;
     };
     /** Perform one final activity check and schedule shutdown only when idle. */
-    shutdownIfIdle?(): DaemonShutdownIfIdleResult;
+    shutdownIfIdle?(maintenanceLeaseToken?: string): DaemonShutdownIfIdleResult | Promise<DaemonShutdownIfIdleResult>;
+    /** Release a cross-process maintenance fence after a verified cutover. */
+    releaseMaintenanceLease?(maintenanceLeaseToken: string): {
+        outcome: "released" | "not_active" | "denied";
+    };
     /** Stateful plugin registry operations owned by the resident daemon. */
     pluginManagement?: PluginManagementHost;
     /** Registered Git/local plugin catalogs. */
@@ -415,6 +424,8 @@ export declare function createSessionRuntimeServices(input: {
     sessionLog?: SessionLogStore;
     onMirrorError?: (error: unknown, sessionId: string) => void;
     sessionContextProvider?: RunnerSessionContextProvider;
+    admissionOpen?: () => boolean;
+    admissionReserve?: () => AdmissionReservation | undefined;
 }): SessionRuntimeServices;
 /**
  * The HTTP surface is just a liveness probe for container orchestration — all

package/dist/server.js

@@ -59,6 +59,8 @@ export function createSessionRuntimeServices(input) {
         ...(input.sessionContextProvider
             ? { sessionContextProvider: input.sessionContextProvider }
             : {}),
+        ...(input.admissionOpen ? { admissionOpen: input.admissionOpen } : {}),
+        ...(input.admissionReserve ? { admissionReserve: input.admissionReserve } : {}),
     });
     const sessionBus = new InMemorySessionBus();
     const sessionRuntimeIndex = new SessionRuntimeIndex();
@@ -179,6 +181,7 @@ export async function startServer({ config = loadConfig(), control, sessionLog,
                 }),
             },
             interruptSession: (sessionId) => runnerManager.interruptLiveSession(sessionId),
+            terminateSession: (sessionId) => runnerManager.terminateLiveSession(sessionId),
             resolveSessionInteraction: (sessionId, interactionId, resolution) => runnerManager.resolveInteraction(sessionId, interactionId, resolution),
         });
     }
@@ -232,8 +235,8 @@ export async function startServer({ config = loadConfig(), control, sessionLog,
                 msg: "Harness agent server listening",
                 host: config.HOST,
                 port: config.PORT,
-                runtime: config.AGENT_RUNTIME,
-                model: resolveRuntimeModel(config, config.AGENT_RUNTIME),
+                runtime: config.DEFAULT_RUNTIME,
+                model: resolveRuntimeModel(config, config.DEFAULT_RUNTIME),
             }));
             const startup = pluginRuntime?.startPluginRuntimes() ?? Promise.resolve();
             void startup.catch((error) => {

package/dist/session-browser-service.d.ts

@@ -1,3 +1,4 @@
+import type { AdmissionReservation } from "@rynx-ai/core";
 import { type RuntimeBrowserCloseParams, type RuntimeBrowserCloseResult, type RuntimeBrowserExecutionBackend, type RuntimeBrowserOpenParams, type RuntimeBrowserPageCreateParams, type RuntimeBrowserPageMutationParams, type RuntimeBrowserPageNavigateParams, type RuntimeBrowserState, type RuntimeBrowserStateGetParams } from "@rynx-ai/protocol/runtime-browser";
 import type { RuntimeBrowserSurfaceFormat, RuntimeBrowserSurfaceInputEvent } from "@rynx-ai/protocol/runtime-browser-surface";
 import { type RuntimeBrowserEndpointDescriptor } from "@rynx-ai/protocol/runtime-browser-bootstrap";
@@ -155,6 +156,11 @@ export interface SessionBrowserServiceOptions {
     pageIdFactory?: () => string;
     /** Injectable boot nonce; production randomization fences stale pre-restart mutations. */
     bootGenerationSeed?: number;
+    /**
+     * Synchronous daemon admission fence. A successful reservation is held until
+     * Browser open has either failed or registered the physical Host handle.
+     */
+    admissionReserve?: () => AdmissionReservation | undefined;
 }
 export type SessionBrowserHostErrorCode = "unavailable" | "page_not_found" | "capacity" | "outcome_unknown";
 /** Expected failure reported by a Browser Host implementation. */
@@ -181,6 +187,7 @@ export declare class SessionBrowserService {
     private readonly observers;
     private readonly pageIdFactory;
     private readonly bootGenerationSeed;
+    private readonly admissionReserve?;
     private shuttingDown;
     private closeAllPromise?;
     constructor(ports: SessionBrowserServicePorts, options?: SessionBrowserServiceOptions);
@@ -225,6 +232,7 @@ export declare class SessionBrowserService {
     closeAll(): Promise<void>;
     private closeEveryRecord;
     private createBrowser;
+    private reserveOpenAdmission;
     private closeUnavailableForRecreate;
     private pageMutation;
     private pageMutationParsed;

package/dist/session-browser-service.js

@@ -42,12 +42,14 @@ export class SessionBrowserService {
     observers = new Set();
     pageIdFactory;
     bootGenerationSeed;
+    admissionReserve;
     shuttingDown = false;
     closeAllPromise;
     constructor(ports, options = {}) {
         this.ports = ports;
         this.pageIdFactory = options.pageIdFactory ?? (() => `page_${randomUUID()}`);
         this.bootGenerationSeed = options.bootGenerationSeed ?? randomBootGenerationSeed();
+        this.admissionReserve = options.admissionReserve;
         if (!Number.isSafeInteger(this.bootGenerationSeed) ||
             this.bootGenerationSeed < 0 ||
             this.bootGenerationSeed >= Number.MAX_SAFE_INTEGER) {
@@ -224,29 +226,35 @@ export class SessionBrowserService {
         });
     }
     async open(input) {
-        const params = parseInput(() => parseRuntimeBrowserOpenParams(input), "Browser open request is invalid");
-        return this.exclusive(params.sessionId, async () => {
-            this.ensureRunning();
-            await this.ensureSessionExists(params.sessionId);
-            const existing = this.records.get(params.sessionId);
-            if (existing?.status === "opening") {
-                return this.project(existing);
-            }
-            if (existing?.status === "ready") {
-                try {
-                    await this.reconcileForRead(existing);
+        const admission = this.reserveOpenAdmission();
+        try {
+            const params = parseInput(() => parseRuntimeBrowserOpenParams(input), "Browser open request is invalid");
+            return await this.exclusive(params.sessionId, async () => {
+                this.ensureRunning();
+                await this.ensureSessionExists(params.sessionId);
+                const existing = this.records.get(params.sessionId);
+                if (existing?.status === "opening") {
                     return this.project(existing);
                 }
-                catch {
-                    // An App Host may have gone away immediately before this open. The
-                    // failed reconciliation marks the old generation unavailable, so an
-                    // idempotent open can recreate it on the current preferred Host.
+                if (existing?.status === "ready") {
+                    try {
+                        await this.reconcileForRead(existing);
+                        return this.project(existing);
+                    }
+                    catch {
+                        // An App Host may have gone away immediately before this open. The
+                        // failed reconciliation marks the old generation unavailable, so an
+                        // idempotent open can recreate it on the current preferred Host.
+                    }
                 }
-            }
-            if (existing)
-                await this.closeUnavailableForRecreate(existing);
-            return this.createBrowser(params);
-        });
+                if (existing)
+                    await this.closeUnavailableForRecreate(existing);
+                return this.createBrowser(params);
+            });
+        }
+        finally {
+            admission?.release();
+        }
     }
     async close(input) {
         const params = parseInput(() => parseRuntimeBrowserCloseParams(input), "Browser close request is invalid");
@@ -438,6 +446,15 @@ export class SessionBrowserService {
             throw new SessionBrowserServiceError("host_failure", "Browser Host state could not be initialized", { cause: error });
         }
     }
+    reserveOpenAdmission() {
+        if (!this.admissionReserve)
+            return undefined;
+        const admission = this.admissionReserve();
+        if (!admission) {
+            throw new SessionBrowserServiceError("shutting_down", "Browser service is shutting down");
+        }
+        return admission;
+    }
     async closeUnavailableForRecreate(record) {
         record.status = "closing";
         try {

package/dist/session-runtime-index.d.ts

@@ -13,6 +13,12 @@ export interface SessionRuntimeActivitySnapshot {
  */
 export declare class SessionRuntimeIndex {
     private readonly sessions;
+    /**
+     * Make an accepted Turn visible before the request admission reservation is
+     * released. The returned callback only abandons the pre-created handoff; once
+     * response.created arrives, the native response remains authoritative.
+     */
+    beginResponseHandoff(sessionId: string, responseId: string): () => void;
     observe(sessionId: string, event: SessionEvent): void;
     snapshot(sessionId: string): SessionRuntimeSnapshot;
     /** Aggregate only process-live work; durable Session history is not activity. */
@@ -20,4 +26,5 @@ export declare class SessionRuntimeIndex {
     remove(sessionId: string): void;
     private state;
     private removeResponseInteractions;
+    private hasRunningTurn;
 }

package/dist/session-runtime-index.js

@@ -6,35 +6,57 @@
  */
 export class SessionRuntimeIndex {
     sessions = new Map();
+    /**
+     * Make an accepted Turn visible before the request admission reservation is
+     * released. The returned callback only abandons the pre-created handoff; once
+     * response.created arrives, the native response remains authoritative.
+     */
+    beginResponseHandoff(sessionId, responseId) {
+        const state = this.state(sessionId);
+        state.pendingResponseIds.add(responseId);
+        state.status = "running";
+        state.statusKind = "startup";
+        let pending = true;
+        return () => {
+            if (!pending)
+                return;
+            pending = false;
+            state.pendingResponseIds.delete(responseId);
+        };
+    }
     observe(sessionId, event) {
         const state = this.state(sessionId);
         switch (event.type) {
             case "response.created":
+                state.pendingResponseIds.delete(event.responseId);
                 state.activeResponseIds.add(event.responseId);
                 state.status = "running";
                 state.statusKind = undefined;
                 return;
             case "response.completed":
+                state.pendingResponseIds.delete(event.responseId);
                 state.activeResponseIds.delete(event.responseId);
                 this.removeResponseInteractions(state, event.responseId);
-                state.status = state.activeResponseIds.size > 0 ? "running" : "idle";
+                state.status = this.hasRunningTurn(state) ? "running" : "idle";
                 state.statusKind = undefined;
                 return;
             case "response.failed":
+                state.pendingResponseIds.delete(event.responseId);
                 state.activeResponseIds.delete(event.responseId);
                 this.removeResponseInteractions(state, event.responseId);
                 // Response failure is Turn-local. It must not poison a reusable Session.
-                state.status = state.activeResponseIds.size > 0 ? "running" : "idle";
+                state.status = this.hasRunningTurn(state) ? "running" : "idle";
                 state.statusKind = undefined;
                 return;
             case "session.status":
                 state.status =
-                    state.pendingInteractions.size > 0 || state.activeResponseIds.size > 0
+                    state.pendingInteractions.size > 0 || this.hasRunningTurn(state)
                         ? "running"
                         : event.status;
                 state.statusKind = event.statusKind;
                 return;
             case "session.interaction.requested":
+                state.pendingResponseIds.delete(event.responseId);
                 state.pendingInteractions.set(event.interaction.interactionId, {
                     responseId: event.responseId,
                     interaction: event.interaction,
@@ -46,9 +68,10 @@ export class SessionRuntimeIndex {
             case "session.interaction.resolved":
             case "session.interaction.cancelled":
                 state.pendingInteractions.delete(event.interactionId);
-                state.status = state.activeResponseIds.size > 0 ? "running" : state.status;
+                state.status = this.hasRunningTurn(state) ? "running" : state.status;
                 return;
             case "session.rotated":
+                state.pendingResponseIds.clear();
                 state.activeResponseIds.clear();
                 state.pendingInteractions.clear();
                 state.status = "idle";
@@ -63,7 +86,9 @@ export class SessionRuntimeIndex {
         if (!state)
             return { status: "idle", activeResponseIds: [], pendingInteractions: [] };
         return {
-            status: state.pendingInteractions.size > 0 ? "running" : state.status,
+            status: state.pendingInteractions.size > 0 || this.hasRunningTurn(state)
+                ? "running"
+                : state.status,
             ...(state.statusKind === undefined ? {} : { statusKind: state.statusKind }),
             activeResponseIds: [...state.activeResponseIds],
             pendingInteractions: [...state.pendingInteractions.values()],
@@ -74,7 +99,7 @@ export class SessionRuntimeIndex {
         let runningTurns = 0;
         let pendingInteractions = 0;
         for (const state of this.sessions.values()) {
-            runningTurns += state.activeResponseIds.size;
+            runningTurns += state.pendingResponseIds.size + state.activeResponseIds.size;
             pendingInteractions += state.pendingInteractions.size;
         }
         return { runningTurns, pendingInteractions };
@@ -87,6 +112,7 @@ export class SessionRuntimeIndex {
         if (!state) {
             state = {
                 status: "idle",
+                pendingResponseIds: new Set(),
                 activeResponseIds: new Set(),
                 pendingInteractions: new Map(),
             };
@@ -100,4 +126,7 @@ export class SessionRuntimeIndex {
                 state.pendingInteractions.delete(interactionId);
         }
     }
+    hasRunningTurn(state) {
+        return state.pendingResponseIds.size > 0 || state.activeResponseIds.size > 0;
+    }
 }

package/dist/session-terminal-host.d.ts

@@ -1,3 +1,4 @@
+import type { AdmissionReservation } from "@rynx-ai/core";
 import { type RunnerManager } from "@rynx-ai/runtime";
 export type SessionTerminalRole = "owner" | "read-only";
 export interface SessionTerminalOpenOptions {
@@ -46,6 +47,11 @@ export interface RunnerSessionTerminalHostOptions {
     } | undefined | Promise<{
         cwd: string;
     } | undefined>;
+    /**
+     * Synchronous daemon admission fence. A successful reservation is held until
+     * the attachment is registered and the runner confirms that it is ready.
+     */
+    admissionReserve?: () => AdmissionReservation | undefined;
 }
 /** Adapt the runner-child terminal protocol without exposing cwd or commands to clients. */
 export declare function createRunnerSessionTerminalHost(options: RunnerSessionTerminalHostOptions): RunnerSessionTerminalHost;

package/dist/session-terminal-host.js

@@ -24,56 +24,71 @@ export function createRunnerSessionTerminalHost(options) {
     return {
         activeTerminalCount: () => attachmentCounts.size,
         async open(sessionId, openOptions) {
-            validateOpen(sessionId, openOptions);
-            throwIfAborted(openOptions.signal);
-            const session = await options.resolveLiveSession(sessionId);
-            if (!session || typeof session.cwd !== "string" || session.cwd.trim().length === 0) {
-                throw new SessionTerminalOpenError("not_live", "Session terminal is not live");
-            }
-            throwIfAborted(openOptions.signal);
-            let parent;
+            const admission = reserveTerminalAdmission(options.admissionReserve);
             try {
-                parent = options.runnerManager.openLiveTerminal(sessionId, {
-                    role: openOptions.role,
-                    cwd: session.cwd,
-                    cols: openOptions.cols,
-                    rows: openOptions.rows,
-                });
-            }
-            catch (error) {
-                if (error instanceof TerminalOpenError && error.code === "terminal_not_live") {
-                    throw new SessionTerminalOpenError("not_live", "Session terminal is not live", {
-                        cause: error,
+                validateOpen(sessionId, openOptions);
+                throwIfAborted(openOptions.signal);
+                const session = await options.resolveLiveSession(sessionId);
+                if (!session || typeof session.cwd !== "string" || session.cwd.trim().length === 0) {
+                    throw new SessionTerminalOpenError("not_live", "Session terminal is not live");
+                }
+                throwIfAborted(openOptions.signal);
+                let parent;
+                try {
+                    parent = options.runnerManager.openLiveTerminal(sessionId, {
+                        role: openOptions.role,
+                        cwd: session.cwd,
+                        cols: openOptions.cols,
+                        rows: openOptions.rows,
                     });
                 }
-                throw new SessionTerminalOpenError("internal", "Session terminal could not be opened", { cause: error });
-            }
-            const attachment = new RunnerSessionTerminalAttachment(sessionId, parent, openOptions.signal);
-            const releaseActivity = trackTerminalAttachment(attachmentCounts, sessionId);
-            void attachment.closed.then(releaseActivity, releaseActivity);
-            try {
-                const opened = await waitFor(parent.ready, openOptions.signal);
-                attachment.opened(opened.role);
-                attachment.throwIfOpeningFailed();
-                return attachment;
-            }
-            catch (error) {
-                await attachment.close().catch(() => undefined);
-                if (isAbort(error)) {
-                    throw new SessionTerminalOpenError("invalid_request", "Session terminal open was cancelled", { cause: error });
+                catch (error) {
+                    if (error instanceof TerminalOpenError && error.code === "terminal_not_live") {
+                        throw new SessionTerminalOpenError("not_live", "Session terminal is not live", {
+                            cause: error,
+                        });
+                    }
+                    throw new SessionTerminalOpenError("internal", "Session terminal could not be opened", { cause: error });
                 }
-                if (error instanceof TerminalOpenError && error.code === "terminal_not_live") {
-                    throw new SessionTerminalOpenError("not_live", "Session terminal is not live", {
-                        cause: error,
-                    });
+                const attachment = new RunnerSessionTerminalAttachment(sessionId, parent, openOptions.signal);
+                const releaseActivity = trackTerminalAttachment(attachmentCounts, sessionId);
+                void attachment.closed.then(releaseActivity, releaseActivity);
+                try {
+                    const opened = await waitFor(parent.ready, openOptions.signal);
+                    attachment.opened(opened.role);
+                    attachment.throwIfOpeningFailed();
+                    return attachment;
+                }
+                catch (error) {
+                    await attachment.close().catch(() => undefined);
+                    if (isAbort(error)) {
+                        throw new SessionTerminalOpenError("invalid_request", "Session terminal open was cancelled", { cause: error });
+                    }
+                    if (error instanceof TerminalOpenError && error.code === "terminal_not_live") {
+                        throw new SessionTerminalOpenError("not_live", "Session terminal is not live", {
+                            cause: error,
+                        });
+                    }
+                    if (error instanceof SessionTerminalOpenError)
+                        throw error;
+                    throw new SessionTerminalOpenError("internal", "Session terminal could not be opened", { cause: error });
                 }
-                if (error instanceof SessionTerminalOpenError)
-                    throw error;
-                throw new SessionTerminalOpenError("internal", "Session terminal could not be opened", { cause: error });
+            }
+            finally {
+                admission?.release();
             }
         },
     };
 }
+function reserveTerminalAdmission(reserve) {
+    if (!reserve)
+        return undefined;
+    const admission = reserve();
+    if (!admission) {
+        throw new SessionTerminalOpenError("not_live", "Session terminal is unavailable during daemon maintenance");
+    }
+    return admission;
+}
 function trackTerminalAttachment(attachmentCounts, sessionId) {
     attachmentCounts.set(sessionId, (attachmentCounts.get(sessionId) ?? 0) + 1);
     let released = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/server",
-  "version": "0.1.11-beta.2",
+  "version": "0.1.11-beta.4",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rynx-ai/rynx.git",
@@ -27,15 +27,15 @@
     "@koa/router": "^15.4.0",
     "koa": "^3.2.0",
     "ws": "^8.21.0",
-    "@rynx-ai/core": "0.1.11-beta.2",
-    "@rynx-ai/plugin-sdk": "0.1.11-beta.2",
-    "@rynx-ai/protocol": "0.1.11-beta.2",
-    "@rynx-ai/remote-runtime-e2ee": "0.1.11-beta.2",
-    "@rynx-ai/runtime": "0.1.11-beta.2"
+    "@rynx-ai/plugin-sdk": "0.1.11-beta.4",
+    "@rynx-ai/core": "0.1.11-beta.4",
+    "@rynx-ai/protocol": "0.1.11-beta.4",
+    "@rynx-ai/remote-runtime-e2ee": "0.1.11-beta.4",
+    "@rynx-ai/runtime": "0.1.11-beta.4"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1",
-    "@rynx-ai/control-web": "0.1.11-beta.2"
+    "@rynx-ai/control-web": "0.1.11-beta.4"
   },
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.json && mkdir -p dist/control-web && cp -R ../control-web/dist/. dist/control-web/",