@rynx-ai/server 0.1.11-beta.3 → 0.1.11-beta.31

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

@@ -13,12 +13,6 @@ 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. */
@@ -27,4 +21,6 @@ export declare class SessionRuntimeIndex {
     private state;
     private removeResponseInteractions;
     private hasRunningTurn;
+    private statusAfterResponseTerminal;
+    private retireStatusResponses;
 }

package/dist/session-runtime-index.js

@@ -6,57 +6,72 @@
  */
 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;
+                state.backgroundTaskCount = undefined;
                 return;
             case "response.completed":
-                state.pendingResponseIds.delete(event.responseId);
                 state.activeResponseIds.delete(event.responseId);
                 this.removeResponseInteractions(state, event.responseId);
-                state.status = this.hasRunningTurn(state) ? "running" : "idle";
+                state.status = this.statusAfterResponseTerminal(state);
                 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 = this.hasRunningTurn(state) ? "running" : "idle";
+                state.status = this.statusAfterResponseTerminal(state);
                 state.statusKind = undefined;
                 return;
-            case "session.status":
-                state.status =
-                    state.pendingInteractions.size > 0 || this.hasRunningTurn(state)
-                        ? "running"
-                        : event.status;
-                state.statusKind = event.statusKind;
+            case "session.interrupted":
+                state.activeResponseIds.delete(event.responseId);
+                this.removeResponseInteractions(state, event.responseId);
+                state.status = this.statusAfterResponseTerminal(state);
+                state.statusKind = undefined;
+                return;
+            case "session.status": {
+                if (event.backgroundTaskCount !== undefined) {
+                    state.backgroundTaskCount = event.backgroundTaskCount > 0
+                        ? event.backgroundTaskCount
+                        : undefined;
+                }
+                else if (event.status === "running" || event.status === "failed") {
+                    state.backgroundTaskCount = undefined;
+                }
+                if (event.status === "running") {
+                    if (event.responseId)
+                        state.activeResponseIds.add(event.responseId);
+                    state.status = "running";
+                    state.statusKind = event.statusKind;
+                    return;
+                }
+                // A provider interaction is a stronger in-flight fact than a quiet-pane
+                // idle observation. Claude's status-file path reports waiting as running;
+                // this guard preserves the same truth on its legacy PTY fallback.
+                if (event.status === "idle" && state.pendingInteractions.size > 0) {
+                    state.status = "running";
+                    state.statusKind = undefined;
+                    return;
+                }
+                this.retireStatusResponses(state);
+                if (event.status === "failed") {
+                    state.status = "failed";
+                }
+                else if (state.status !== "failed") {
+                    // Provider idle is authoritative even when final transcript records
+                    // arrive later. Response identity remains on those events themselves;
+                    // it must not keep Session activity/loading alive.
+                    state.status = this.hasRunningTurn(state) ? "running" : "idle";
+                }
+                state.statusKind = undefined;
                 return;
+            }
             case "session.interaction.requested":
-                state.pendingResponseIds.delete(event.responseId);
                 state.pendingInteractions.set(event.interaction.interactionId, {
                     responseId: event.responseId,
                     interaction: event.interaction,
@@ -68,14 +83,15 @@ export class SessionRuntimeIndex {
             case "session.interaction.resolved":
             case "session.interaction.cancelled":
                 state.pendingInteractions.delete(event.interactionId);
-                state.status = this.hasRunningTurn(state) ? "running" : state.status;
+                if (this.hasRunningTurn(state))
+                    state.status = "running";
                 return;
             case "session.rotated":
-                state.pendingResponseIds.clear();
                 state.activeResponseIds.clear();
                 state.pendingInteractions.clear();
                 state.status = "idle";
                 state.statusKind = undefined;
+                state.backgroundTaskCount = undefined;
                 return;
             default:
                 return;
@@ -86,10 +102,11 @@ export class SessionRuntimeIndex {
         if (!state)
             return { status: "idle", activeResponseIds: [], pendingInteractions: [] };
         return {
-            status: state.pendingInteractions.size > 0 || this.hasRunningTurn(state)
-                ? "running"
-                : state.status,
+            status: state.pendingInteractions.size > 0 ? "running" : state.status,
             ...(state.statusKind === undefined ? {} : { statusKind: state.statusKind }),
+            ...(state.backgroundTaskCount === undefined
+                ? {}
+                : { backgroundTaskCount: state.backgroundTaskCount }),
             activeResponseIds: [...state.activeResponseIds],
             pendingInteractions: [...state.pendingInteractions.values()],
         };
@@ -99,7 +116,9 @@ export class SessionRuntimeIndex {
         let runningTurns = 0;
         let pendingInteractions = 0;
         for (const state of this.sessions.values()) {
-            runningTurns += state.pendingResponseIds.size + state.activeResponseIds.size;
+            if (state.status === "running" || state.pendingInteractions.size > 0) {
+                runningTurns += Math.max(1, state.activeResponseIds.size);
+            }
             pendingInteractions += state.pendingInteractions.size;
         }
         return { runningTurns, pendingInteractions };
@@ -112,7 +131,6 @@ export class SessionRuntimeIndex {
         if (!state) {
             state = {
                 status: "idle",
-                pendingResponseIds: new Set(),
                 activeResponseIds: new Set(),
                 pendingInteractions: new Map(),
             };
@@ -127,6 +145,20 @@ export class SessionRuntimeIndex {
         }
     }
     hasRunningTurn(state) {
-        return state.pendingResponseIds.size > 0 || state.activeResponseIds.size > 0;
+        return state.activeResponseIds.size > 0;
+    }
+    statusAfterResponseTerminal(state) {
+        if (state.pendingInteractions.size > 0 || this.hasRunningTurn(state))
+            return "running";
+        return state.status === "failed" ? "failed" : "idle";
+    }
+    retireStatusResponses(state) {
+        // session.status is Session-wide. Match reference implementation's
+        // _session_active_response_cache: every idle/failed edge closes the one
+        // in-flight native response projection, even when the edge happens to be
+        // stamped with that response id. A late transcript event may still carry
+        // the old id for grouping, but it cannot keep activity alive.
+        state.activeResponseIds.clear();
+        state.pendingInteractions.clear();
     }
 }

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