@rynx-ai/server 0.1.11-beta.23 → 0.1.11-beta.25

package/dist/control-web/index.html

@@ -7,8 +7,8 @@
     <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
     <link rel="icon" type="image/png" href="/favicon.png" />
     <title>rynx · control</title>
-    <script type="module" crossorigin src="/assets/index-D-5t2eCT.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-0noHpRXD.css">
+    <script type="module" crossorigin src="/assets/index-C1ODT189.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-DOUyXr2J.css">
   </head>
   <body>
     <div id="root"></div>

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

@@ -1,4 +1,4 @@
-import { type AdmissionReservation, type AgentRuntimeId, type ConversationRuntime, type ResolvedExecutionSnapshot, type SessionWorkspaceSnapshot, type SessionProviderId, type MachineSessionRecord, type LiveSessionFailure, 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 LiveSessionFailure, type ReasoningEffort, type RuntimeUserInput, type SessionCollaborationMode, 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 { ControlAgentModelOption, ControlAgentSummary, ControlSessionInteractionResolveDisposition, ControlSessionRuntimeSnapshot, SessionPermissionPreset } from "@rynx-ai/protocol/control";
@@ -69,6 +69,7 @@ export interface MachineSessionRunnerPort {
     lastLiveSessionError?(sessionId: string): string | undefined;
     lastLiveSessionFailure?(sessionId: string): LiveSessionFailure | undefined;
     injectMessage(sessionId: string, input: RuntimeUserInput | string): Promise<InjectResult>;
+    updateCollaborationMode?(sessionId: string, mode: SessionCollaborationMode): Promise<void>;
     stopRunner(sessionId: string): void;
     resolveInteraction(sessionId: string, interactionId: string, resolution: SessionInteractionResolution): Promise<{
         disposition: ControlSessionInteractionResolveDisposition;
@@ -312,11 +313,15 @@ export declare class MachineSessionService {
     launchOptions(): Promise<RemoteRuntimeSessionLaunchOptionsListResult>;
     /** Read the effective model defaults used for the next turn. */
     executionSettings(sessionIdInput: string): Promise<RemoteRuntimeSessionExecutionGetResult>;
-    /** Replace the Turn defaults of an idle Session. Execution settings are
-     * passed through to the Provider CLI, which owns availability validation.
-     * The runner is closed so every Provider resumes its native context with
-     * the new settings on the next turn. */
+    /** Replace the defaults for the next new Turn. Codex-lineage Providers keep
+     * their live runner: the host applies changed native thread settings under
+     * its injection lock immediately before the next `turn/start`. Claude still
+     * needs an idle cold resume because its live CLI has no confirmed settings
+     * update boundary. Provider CLIs own model availability validation. */
     updateExecutionSettings(input: RemoteRuntimeSessionExecutionUpdateParams): Promise<RemoteRuntimeSessionExecutionUpdateResult>;
+    /** Persist a mode changed from the native TUI before its reflected event is
+     * fanned out to Web clients. Unknown/deleted and Claude Sessions are ignored. */
+    recordNativeCollaborationMode(sessionIdInput: string, mode: SessionCollaborationMode): void;
     /** Create target-owned Session identity from one Agent preset or direct Provider. */
     create(input: MachineSessionCreateInput): Promise<MachineSessionCreateResult>;
     private createAdmitted;

package/dist/machine-session-service.js

@@ -210,10 +210,11 @@ export class MachineSessionService {
         }
         return executionSettingsResult(meta.execution);
     }
-    /** Replace the Turn defaults of an idle Session. Execution settings are
-     * passed through to the Provider CLI, which owns availability validation.
-     * The runner is closed so every Provider resumes its native context with
-     * the new settings on the next turn. */
+    /** Replace the defaults for the next new Turn. Codex-lineage Providers keep
+     * their live runner: the host applies changed native thread settings under
+     * its injection lock immediately before the next `turn/start`. Claude still
+     * needs an idle cold resume because its live CLI has no confirmed settings
+     * update boundary. Provider CLIs own model availability validation. */
     async updateExecutionSettings(input) {
         const sessionId = validOpaqueToken(input.sessionId, "sessionId", MAX_SESSION_ID_CHARS);
         const modelId = input.model === null ? null : validRequiredText(input.model, "model");
@@ -222,13 +223,15 @@ export class MachineSessionService {
             throw new MachineSessionServiceFailure("not_found", "session not found");
         }
         await this.assertNotForkReserved(sessionId);
-        const runtime = this.ports.runtimeState.snapshot(sessionId);
-        const pendingMessage = await this.ports.pendingMessages?.get(sessionId);
-        if (runtime.status !== "idle" ||
-            runtime.activeResponseIds.length > 0 ||
-            runtime.pendingInteractions.length > 0 ||
-            pendingMessage) {
-            throw new MachineSessionServiceFailure("failed_precondition", "Session must be idle before changing model settings");
+        if (meta.execution.provider === "claude") {
+            const runtime = this.ports.runtimeState.snapshot(sessionId);
+            const pendingMessage = await this.ports.pendingMessages?.get(sessionId);
+            if (runtime.status !== "idle" ||
+                runtime.activeResponseIds.length > 0 ||
+                runtime.pendingInteractions.length > 0 ||
+                pendingMessage) {
+                throw new MachineSessionServiceFailure("failed_precondition", "Claude Session must be idle before changing model settings");
+            }
         }
         const executionPort = this.requireExecution();
         const reasoningEffort = input.reasoningEffort === null
@@ -238,11 +241,51 @@ export class MachineSessionService {
             ...structuredClone(meta.execution),
             model: modelId,
             reasoningEffort,
+            ...(meta.execution.provider !== "claude" && input.collaborationMode !== undefined
+                ? { collaborationMode: input.collaborationMode }
+                : {}),
         };
+        if (meta.execution.provider !== "claude" && input.collaborationMode !== undefined) {
+            const updateMode = executionPort.runner.updateCollaborationMode;
+            if (!updateMode) {
+                const message = "This Runtime does not support live collaboration-mode updates";
+                throw new MachineSessionServiceFailure("failed_precondition", message, message, {
+                    message,
+                    code: "collaboration_mode_unavailable",
+                    statusCode: 409,
+                });
+            }
+            // Omnigent parity: native state is authoritative. Do not make a failed
+            // toggle survive reload when the loaded thread rejected it.
+            try {
+                await updateMode.call(executionPort.runner, sessionId, input.collaborationMode);
+            }
+            catch (error) {
+                const failure = liveSessionFailureFrom(error);
+                const message = collaborationModeFailureMessage(meta.execution.provider, failure, error instanceof Error ? error.message : "Native collaboration mode update failed");
+                throw new MachineSessionServiceFailure("failed_precondition", message, message, failure ? { ...failure, message } : undefined);
+            }
+        }
         this.ports.registry.setExecution(sessionId, nextExecution);
-        executionPort.runner.stopRunner(sessionId);
+        if (nextExecution.provider === "claude") {
+            executionPort.runner.stopRunner(sessionId);
+        }
         return executionSettingsResult(nextExecution);
     }
+    /** Persist a mode changed from the native TUI before its reflected event is
+     * fanned out to Web clients. Unknown/deleted and Claude Sessions are ignored. */
+    recordNativeCollaborationMode(sessionIdInput, mode) {
+        const sessionId = validOpaqueToken(sessionIdInput, "sessionId", MAX_SESSION_ID_CHARS);
+        const meta = this.ports.registry.get(sessionId);
+        if (!meta || meta.execution.provider === "claude")
+            return;
+        if (meta.execution.collaborationMode === mode)
+            return;
+        this.ports.registry.setExecution(sessionId, {
+            ...structuredClone(meta.execution),
+            collaborationMode: mode,
+        });
+    }
     /** Create target-owned Session identity from one Agent preset or direct Provider. */
     async create(input) {
         return this.withAdmission(() => this.createAdmitted(input));
@@ -1016,6 +1059,7 @@ function executionSettingsResult(execution) {
         provider: execution.provider,
         model: execution.model,
         reasoningEffort: execution.reasoningEffort,
+        collaborationMode: execution.collaborationMode ?? null,
     };
 }
 function compareMetaRecency(left, right) {
@@ -1108,6 +1152,20 @@ function liveSessionFailureFrom(error) {
         statusCode: candidate.statusCode,
     };
 }
+/** Turn structured native mode failures into actionable, Provider-specific
+ * messages before the Direct Runtime adapter crosses the process boundary.
+ * Unstructured failures keep their original text and remain subject to the
+ * adapter's normal redaction policy. */
+function collaborationModeFailureMessage(provider, failure, fallback) {
+    const providerLabel = provider === "traex" ? "TraeX" : "Codex";
+    if (failure?.code === "native_session_not_live") {
+        return `No live ${providerLabel} runner is available. Reconnect this Session and try again.`;
+    }
+    if (failure?.code === "native_thread_not_ready") {
+        return `${providerLabel} is still loading its native thread. Reconnect this Session and try again.`;
+    }
+    return failure?.message ?? fallback;
+}
 function requestLimit(value, fallback, maximum, field) {
     return value === undefined ? Math.min(fallback, maximum) : boundedInteger(value, 1, maximum, field);
 }

package/dist/remote-runtime-session-projection.js

@@ -530,6 +530,7 @@ function assertEventScope(event, expectedSessionId) {
     let actual;
     switch (event.type) {
         case "session.status":
+        case "session.collaboration_mode":
         case "response.created":
         case "session.interaction.requested":
         case "session.interaction.resolved":

package/dist/server.js

@@ -257,6 +257,11 @@ export async function startServer({ config = loadConfig(), control, sessionLog,
             kind: r.kind,
         });
     });
+    if (localMachineSessions) {
+        runnerManager.onCollaborationMode((sessionId, mode) => {
+            localMachineSessions.recordNativeCollaborationMode(sessionId, mode);
+        });
+    }
     const app = createApp({
         config,
         control: controlSurface,

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

@@ -21,4 +21,6 @@ export declare class SessionRuntimeIndex {
     private state;
     private removeResponseInteractions;
     private hasRunningTurn;
+    private statusAfterResponseTerminal;
+    private retireStatusResponses;
 }

package/dist/session-runtime-index.js

@@ -17,29 +17,51 @@ export class SessionRuntimeIndex {
             case "response.completed":
                 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.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.interrupted":
                 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 "session.status":
-                state.status =
-                    state.pendingInteractions.size > 0 || this.hasRunningTurn(state)
-                        ? "running"
-                        : event.status;
-                state.statusKind = event.statusKind;
+            case "session.status": {
+                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.pendingInteractions.set(event.interaction.interactionId, {
                     responseId: event.responseId,
@@ -52,7 +74,8 @@ 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.activeResponseIds.clear();
@@ -69,9 +92,7 @@ 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 }),
             activeResponseIds: [...state.activeResponseIds],
             pendingInteractions: [...state.pendingInteractions.values()],
@@ -82,7 +103,9 @@ export class SessionRuntimeIndex {
         let runningTurns = 0;
         let pendingInteractions = 0;
         for (const state of this.sessions.values()) {
-            runningTurns += 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 };
@@ -111,4 +134,18 @@ export class SessionRuntimeIndex {
     hasRunningTurn(state) {
         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/package.json

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