npm - @rynx-ai/server - Versions diffs - 0.1.11-beta.2 → 0.1.11-beta.21 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (27) hide show

package/dist/control-api.d.ts +10 -3
package/dist/control-api.js +168 -7
package/dist/control-web/assets/{highlighted-body-OFNGDK62-DWWsUtHF.js → highlighted-body-OFNGDK62-Ctle6Bpj.js} +1 -1
package/dist/control-web/assets/index-0noHpRXD.css +32 -0
package/dist/control-web/assets/index-dOafa0IY.js +709 -0
package/dist/control-web/assets/{mermaid-GHXKKRXX-C1fxAgiw.js → mermaid-GHXKKRXX-DvISAPzD.js} +3 -3
package/dist/control-web/index.html +2 -2
package/dist/control-web-dist.d.ts +1 -1
package/dist/control-web-dist.js +4 -2
package/dist/machine-session-service.d.ts +31 -6
package/dist/machine-session-service.js +124 -7
package/dist/remote-runtime-dispatcher.d.ts +1 -1
package/dist/remote-runtime-dispatcher.js +4 -0
package/dist/server.d.ts +25 -3
package/dist/server.js +117 -43
package/dist/session-browser-service.d.ts +8 -0
package/dist/session-browser-service.js +37 -20
package/dist/session-portal.d.ts +42 -0
package/dist/session-portal.js +746 -0
package/dist/session-runtime-index.d.ts +7 -0
package/dist/session-runtime-index.js +35 -6
package/dist/session-terminal-host.d.ts +6 -0
package/dist/session-terminal-host.js +56 -41
package/dist/terminal-ws.js +8 -6
package/package.json +7 -7
package/dist/control-web/assets/index-BnX7NWJX.js +0 -689
package/dist/control-web/assets/index-CUoWRX2i.css +0 -32

package/dist/control-web/index.html CHANGED Viewed

@@ -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-BnX7NWJX.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-CUoWRX2i.css">
+    <script type="module" crossorigin src="/assets/index-dOafa0IY.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-0noHpRXD.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/control-web-dist.d.ts CHANGED Viewed

@@ -3,4 +3,4 @@ import type { Context } from "koa";
 export declare function resolveControlWebDist(): string | null;
 /** Serve a static file from the SPA dir; missing non-asset paths fall back to
  *  index.html (client-side routing), missing assets return 404. */
-export declare function sendSpaFile(ctx: Context, distDir: string, basePath?: string): Promise<void>;
+export declare function sendSpaFile(ctx: Context, distDir: string, basePath?: string, transformIndex?: (html: string) => string): Promise<void>;

package/dist/control-web-dist.js CHANGED Viewed

@@ -37,7 +37,7 @@ export function resolveControlWebDist() {
 }
 /** Serve a static file from the SPA dir; missing non-asset paths fall back to
  *  index.html (client-side routing), missing assets return 404. */
-export async function sendSpaFile(ctx, distDir, basePath = "/") {
+export async function sendSpaFile(ctx, distDir, basePath = "/", transformIndex) {
     const path = basePath !== "/" && ctx.path.startsWith(basePath)
         ? ctx.path.slice(basePath.length) || "/"
         : ctx.path;
@@ -64,5 +64,7 @@ export async function sendSpaFile(ctx, distDir, basePath = "/") {
         }
     }
     ctx.type = CONTENT_TYPES[ext] ?? "application/octet-stream";
-    ctx.body = data;
+    ctx.body = ext === ".html" && transformIndex
+        ? transformIndex(data.toString("utf8"))
+        : data;
 }

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

@@ -1,11 +1,12 @@
-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";
-import { type RemoteRuntimeSessionInterruptResult, type RemoteRuntimeSessionLaunchOptionsListResult, type RemoteRuntimeSessionListParams, type RemoteRuntimeSessionListResult, type RemoteRuntimeSessionSnapshotParams } from "@rynx-ai/protocol/remote-runtime-rpc";
+import type { ControlAgentModelOption, ControlAgentSummary, ControlSessionInteractionResolveDisposition, ControlSessionRuntimeSnapshot, SessionPermissionPreset } from "@rynx-ai/protocol/control";
+import { type RemoteRuntimeSessionInterruptResult, type RemoteRuntimeSessionExecutionGetResult, type RemoteRuntimeSessionExecutionUpdateParams, type RemoteRuntimeSessionExecutionUpdateResult, type RemoteRuntimeSessionLaunchOptionsListResult, type RemoteRuntimeSessionListParams, type RemoteRuntimeSessionListResult, type RemoteRuntimeSessionSnapshotParams } from "@rynx-ai/protocol/remote-runtime-rpc";
 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 {
@@ -129,7 +130,7 @@ export interface MachineSessionForkStorePort {
     markTargetDeleted(sessionId: string): void | Promise<void>;
 }
 export interface MachineSessionServicePorts {
-    registry: Pick<SessionRegistry, "create" | "get" | "list" | "setTitle" | "remove">;
+    registry: Pick<SessionRegistry, "create" | "get" | "list" | "setTitle" | "setExecution" | "remove">;
     log: Pick<SessionLogStore, "list" | "listSessions" | "snapshot" | "deleteSession">;
     events: Pick<SessionBus, "subscribe"> & Partial<Pick<SessionBus, "close">>;
     /** Canonical persistence + fan-out for user turns accepted before a native
@@ -153,10 +154,12 @@ export interface MachineSessionServicePorts {
         resolve(input: {
             agent?: string;
             provider?: SessionProviderId;
-            model?: string;
+            model?: string | null;
             reasoningEffort?: ReasoningEffort;
+            permissionPreset?: SessionPermissionPreset;
             cwd: string;
         }): Promise<ResolvedExecutionSnapshot>;
+        listModels?(provider: SessionProviderId): Promise<ControlAgentModelOption[]>;
         runner: MachineSessionRunnerPort;
     };
     /** Resolve a temporary Project selection, or create a Session-only fallback directory. */
@@ -181,6 +184,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 {
@@ -198,8 +206,9 @@ export interface MachineSessionSnapshotPage {
 }
 export type MachineSessionInterruptResult = RemoteRuntimeSessionInterruptResult;
 interface MachineSessionCreateOptions {
-    model?: string;
+    model?: string | null;
     reasoningEffort?: ReasoningEffort;
+    permissionPreset?: SessionPermissionPreset;
     title?: string;
     projectId?: string;
 }
@@ -277,6 +286,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;
@@ -298,12 +309,21 @@ export declare class MachineSessionService {
     }>;
     /** Target-owned Provider readiness plus the existing Agent preset catalog. */
     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. */
+    updateExecutionSettings(input: RemoteRuntimeSessionExecutionUpdateParams): Promise<RemoteRuntimeSessionExecutionUpdateResult>;
     /** 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 +332,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 +344,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 CHANGED Viewed

@@ -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();
     }
@@ -155,11 +159,18 @@ export class MachineSessionService {
         const statusCache = new Map();
         const { agents } = await this.agentOptions();
         const [providers, launchAgents] = await Promise.all([
-            Promise.all(SESSION_PROVIDER_IDS.map(async (provider) => ({
-                id: provider,
-                name: getRuntimeProfile(provider).displayName,
-                ...await this.runtimeReadiness(provider, statusCache),
-            }))),
+            Promise.all(SESSION_PROVIDER_IDS.map(async (provider) => {
+                const execution = this.ports.execution;
+                const models = execution?.listModels
+                    ? await execution.listModels(provider).catch(() => [])
+                    : undefined;
+                return {
+                    id: provider,
+                    name: getRuntimeProfile(provider).displayName,
+                    ...await this.runtimeReadiness(provider, statusCache),
+                    ...(models === undefined ? {} : { models }),
+                };
+            })),
             Promise.all(agents.map(async (agent) => {
                 const execution = this.ports.execution;
                 if (!execution) {
@@ -188,8 +199,53 @@ export class MachineSessionService {
         ]);
         return { providers, agents: launchAgents };
     }
+    /** Read the effective model defaults used for the next turn. */
+    async executionSettings(sessionIdInput) {
+        const sessionId = validOpaqueToken(sessionIdInput, "sessionId", MAX_SESSION_ID_CHARS);
+        const meta = this.ports.registry.get(sessionId);
+        if (!meta) {
+            throw new MachineSessionServiceFailure("not_found", "session not found");
+        }
+        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. */
+    async updateExecutionSettings(input) {
+        const sessionId = validOpaqueToken(input.sessionId, "sessionId", MAX_SESSION_ID_CHARS);
+        const modelId = input.model === null ? null : validRequiredText(input.model, "model");
+        const meta = this.ports.registry.get(sessionId);
+        if (!meta) {
+            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");
+        }
+        const executionPort = this.requireExecution();
+        const reasoningEffort = input.reasoningEffort === null
+            ? null
+            : validRequiredText(input.reasoningEffort, "reasoningEffort");
+        const nextExecution = {
+            ...structuredClone(meta.execution),
+            model: modelId,
+            reasoningEffort,
+        };
+        this.ports.registry.setExecution(sessionId, nextExecution);
+        executionPort.runner.stopRunner(sessionId);
+        return executionSettingsResult(nextExecution);
+    }
     /** 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) {
@@ -216,6 +272,7 @@ export class MachineSessionService {
                 ...target,
                 ...(input.model === undefined ? {} : { model: input.model }),
                 ...(input.reasoningEffort === undefined ? {} : { reasoningEffort: input.reasoningEffort }),
+                ...(input.permissionPreset === undefined ? {} : { permissionPreset: input.permissionPreset }),
                 cwd: workspace.cwd,
             });
             const sessionId = newSessionId();
@@ -240,6 +297,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 +443,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 +534,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 +552,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 +567,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,19 +575,23 @@ 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}`);
             }
             throw new MachineSessionServiceFailure("outcome_unknown", `live injection ${outcome}`);
         }
-        if (outcome !== "injected") {
+        if (outcome !== "injected" && outcome !== "steered") {
+            abandonResponseHandoff?.();
             await clearStartup("idle");
             if (request.clientMessageId) {
                 await resources?.markMessageFailedNotStarted(sessionId, request.clientMessageId, `live injection ${outcome}`);
             }
             throw new MachineSessionServiceFailure("failed_precondition", `live injection ${outcome}`);
         }
+        if (outcome === "steered")
+            abandonResponseHandoff?.();
         await clearStartup("running");
         if (request.clientMessageId) {
             try {
@@ -564,6 +636,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 +670,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 +740,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 +809,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;
@@ -725,7 +823,7 @@ export class MachineSessionService {
                     return;
                 injectionAttempted = true;
                 const outcome = await execution.runner.injectMessage(sessionId, pending.message);
-                if (outcome === "injected") {
+                if (outcome === "injected" || outcome === "steered") {
                     await Promise.resolve(pendingStore.delete(sessionId)).catch(async () => {
                         await Promise.resolve(pendingStore.markOutcomeUnknown(sessionId)).catch(() => undefined);
                     });
@@ -746,6 +844,9 @@ export class MachineSessionService {
                     return;
                 }
             }
+            finally {
+                admission?.release();
+            }
             await retryDelay(this.pendingMessageRetryMs);
         }
     }
@@ -948,6 +1049,13 @@ function sessionSummary(id, meta, log, runtimeState, pendingState) {
         updatedAt: validTimestamp(updatedAt, "updatedAt"),
     };
 }
+function executionSettingsResult(execution) {
+    return {
+        provider: execution.provider,
+        model: execution.model,
+        reasoningEffort: execution.reasoningEffort,
+    };
+}
 function compareMetaRecency(left, right) {
     const leftTime = validTimestamp(left.updatedAt ?? left.createdAt, "updatedAt");
     const rightTime = validTimestamp(right.updatedAt ?? right.createdAt, "updatedAt");
@@ -1042,6 +1150,15 @@ function validOpaqueToken(value, field, maximum) {
     }
     return value;
 }
+function validRequiredText(value, field) {
+    if (typeof value !== "string" || value.trim().length === 0 || value.length > 512) {
+        throw new MachineSessionServiceInputError(`${field} must be a non-empty string of at most 512 characters`);
+    }
+    if (/[\u0000-\u001f\u007f]/.test(value)) {
+        throw new MachineSessionServiceInputError(`${field} contains invalid control characters`);
+    }
+    return value.trim();
+}
 function validTimestamp(value, field) {
     if (typeof value !== "string" || !Number.isFinite(Date.parse(value))) {
         throw new MachineSessionServiceInputError(`${field} must be a valid timestamp`);

package/dist/remote-runtime-dispatcher.d.ts CHANGED Viewed

@@ -34,7 +34,7 @@ export interface RemoteRuntimeProjectHost {
     update(projectId: string, input: RemoteRuntimeProjectCreateParams): RemoteRuntimeProject | undefined | Promise<RemoteRuntimeProject | undefined>;
     remove(projectId: string): boolean | Promise<boolean>;
 }
-export type RemoteRuntimeSessionHost = Pick<MachineSessionService, "list" | "snapshot" | "watch" | "interrupt" | "agentOptions" | "launchOptions" | "create" | "fork" | "sendMessage" | "resourcePolicy" | "beginResourceUpload" | "writeResourceUploadChunk" | "commitResourceUpload" | "getResource" | "readResource" | "deleteResource" | "enqueueMessage" | "startTerminal" | "delete" | "resolveInteraction">;
+export type RemoteRuntimeSessionHost = Pick<MachineSessionService, "list" | "snapshot" | "watch" | "interrupt" | "agentOptions" | "launchOptions" | "executionSettings" | "updateExecutionSettings" | "create" | "fork" | "sendMessage" | "resourcePolicy" | "beginResourceUpload" | "writeResourceUploadChunk" | "commitResourceUpload" | "getResource" | "readResource" | "deleteResource" | "enqueueMessage" | "startTerminal" | "delete" | "resolveInteraction">;
 export type RemoteRuntimeBrowserHost = Pick<SessionBrowserService, "getState" | "open" | "close" | "createPage" | "closePage" | "activatePage" | "navigatePage" | "goBack" | "goForward" | "reload">;
 export type RemoteRuntimeSessionEmulatorHost = Pick<SessionEmulatorService, "getState" | "listDevices" | "attach" | "detach" | "tap" | "type" | "button" | "rotate" | "launch" | "gesture" | "releaseDevice" | "stopDevice">;
 export interface OpenRemoteRuntimeSessionEvents {

package/dist/remote-runtime-dispatcher.js CHANGED Viewed

@@ -125,6 +125,10 @@ export class RemoteRuntimeDispatcher {
                     return await this.withSessions(request, (sessions) => sessions.agentOptions());
                 case "session.launchOptions.list":
                     return await this.withSessions(request, (sessions) => sessions.launchOptions());
+                case "session.execution.get":
+                    return await this.withSessions(request, (sessions) => sessions.executionSettings(request.params.sessionId));
+                case "session.execution.update":
+                    return await this.withSessions(request, (sessions) => sessions.updateExecutionSettings(request.params));
                 case "session.create":
                     return await this.withSessions(request, (sessions) => sessions.create(request.params));
                 case "session.fork":

package/dist/server.d.ts CHANGED Viewed

@@ -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";
@@ -18,6 +18,9 @@ import { type ControlPlaneDeps, type LocalSessionResourceHost, type SessionResou
 import type { MachineSessionService } from "./machine-session-service.js";
 import type { DaemonRuntimeHost } from "./remote-runtime.js";
 import { type AttachDesktopBrowserHostServerOptions } from "./desktop-browser-host.js";
+import { type SessionPortalAuthorizationPorts } from "./session-portal.js";
+export { createSessionPortalApp, startSessionPortal } from "./session-portal.js";
+export type { SessionPortalAuthorization, SessionPortalAuthorizationPorts, SessionPortalOptions, SessionPortalServer, } from "./session-portal.js";
 import { SessionRuntimeIndex } from "./session-runtime-index.js";
 import type { SessionEmulatorService } from "./session-emulator-service.js";
 import { type SessionTerminalHost } from "./session-terminal-host.js";
@@ -132,6 +135,9 @@ export interface StartServerOptions {
     providerClis?: ProviderCliManagementHost;
     /** Private resident-app Browser Host socket, authenticated by daemonManagement. */
     desktopBrowserHost?: Omit<AttachDesktopBrowserHostServerOptions, "managementToken">;
+    /** Hashed ticket/grant authority for the native Session Portal. Required
+     * when RYNX_SESSION_PORTAL_PORT enables that listener. */
+    sessionPortalAuthorization?: SessionPortalAuthorizationPorts;
 }
 export interface SessionRuntimeServices {
     sessionStore: CodexSessionStore;
@@ -155,9 +161,19 @@ 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;
+    sessionPortal?: {
+        scheme: "http" | "https";
+        bindHost: string;
+        port: number;
+    };
 }
 export interface PluginRuntimeLifecycle {
     bindHostServices(services: PluginRuntimeHostServices): void;
@@ -236,7 +252,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 +435,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
@@ -423,4 +445,4 @@ export declare function createSessionRuntimeServices(input: {
  * no agent request / response / SSE endpoints are exposed here.
  */
 export declare function createApp({ config, control }?: CreateAppOptions): Koa<Koa.DefaultState, Koa.DefaultContext>;
-export declare function startServer({ config, control, sessionLog, sessionRegistry, pluginRuntime, daemonManagement, remoteRuntime, remoteRuntimeAdmin, runtimeTargetControl, runtimeConnectionResolver, localSessionResources, localMachineSessions, sessionEmulators, sessionRuntimeServices, sessionLifecycle, sessionTerminals, runtimeLocalBrowser, providerClis, desktopBrowserHost, }?: StartServerOptions): Promise<RynxServer>;
+export declare function startServer({ config, control, sessionLog, sessionRegistry, pluginRuntime, daemonManagement, remoteRuntime, remoteRuntimeAdmin, runtimeTargetControl, runtimeConnectionResolver, localSessionResources, localMachineSessions, sessionEmulators, sessionRuntimeServices, sessionLifecycle, sessionTerminals, runtimeLocalBrowser, providerClis, desktopBrowserHost, sessionPortalAuthorization, }?: StartServerOptions): Promise<RynxServer>;