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

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/dist/terminal-ws.js

@@ -298,13 +298,15 @@ function parseBrowserInput(data, isBinary) {
     throw new Error("Unknown or invalid terminal control frame");
 }
 async function applyBrowserInput(terminal, input) {
-    if (input.type === "input") {
-        // Defense in depth: tmux -r also blocks writes, but bytes never reach it.
-        if (terminal.role === "owner")
-            await terminal.write(input.data);
+    // Defense in depth: tmux -r also blocks writes, but neither keystrokes nor
+    // resize/SIGWINCH may reach a read-only Session. Resizing changes live TUI
+    // layout and is therefore a mutation, not a harmless viewer preference.
+    if (terminal.role !== "owner")
         return;
-    }
-    await terminal.resize(input.cols, input.rows);
+    if (input.type === "input")
+        await terminal.write(input.data);
+    else
+        await terminal.resize(input.cols, input.rows);
 }
 async function sendBinary(ws, data) {
     if (ws.readyState !== WebSocket.OPEN)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/server",
-  "version": "0.1.11-beta.2",
+  "version": "0.1.11-beta.21",
   "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/core": "0.1.11-beta.21",
+    "@rynx-ai/plugin-sdk": "0.1.11-beta.21",
+    "@rynx-ai/protocol": "0.1.11-beta.21",
+    "@rynx-ai/remote-runtime-e2ee": "0.1.11-beta.21",
+    "@rynx-ai/runtime": "0.1.11-beta.21"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1",
-    "@rynx-ai/control-web": "0.1.11-beta.2"
+    "@rynx-ai/control-web": "0.1.11-beta.21"
   },
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.json && mkdir -p dist/control-web && cp -R ../control-web/dist/. dist/control-web/",