@rynx-ai/server 0.1.10 → 0.1.11-beta.10

package/dist/machine-session-service.js

@@ -7,9 +7,9 @@
  * Direct adapters can therefore expose the same behavior without copying state
  * into a Control Plane database.
  */
-import { SESSION_PROVIDER_IDS, getRuntimeProfile, isSessionProviderId, newSessionId, normalizeSessionTitle, } from "@rynx-ai/core";
+import { createHash, randomUUID } from "node:crypto";
+import { SESSION_PROVIDER_IDS, getRuntimeProfile, isSessionProviderId, newSessionItemId, newSessionId, normalizeSessionTitle, } from "@rynx-ai/core";
 import { REMOTE_RUNTIME_SESSION_DEFAULT_PAGE_SIZE, REMOTE_RUNTIME_SESSION_MAX_CURSOR_CHARS, REMOTE_RUNTIME_SESSION_MAX_ID_CHARS, REMOTE_RUNTIME_SESSION_MAX_PAGE_SIZE, } from "@rynx-ai/protocol/remote-runtime-rpc";
-import { ensureCodexResumeRollout, } from "@rynx-ai/runtime";
 const DEFAULT_LIST_LIMIT = REMOTE_RUNTIME_SESSION_DEFAULT_PAGE_SIZE;
 const MAX_LIST_LIMIT = REMOTE_RUNTIME_SESSION_MAX_PAGE_SIZE;
 const DEFAULT_SNAPSHOT_ITEM_LIMIT = REMOTE_RUNTIME_SESSION_DEFAULT_PAGE_SIZE;
@@ -47,8 +47,11 @@ export class MachineSessionService {
     snapshotPageMaxBytes;
     directoryScanLimit;
     pendingMessageRetryMs;
+    admissionOpen;
+    admissionReserve;
     pendingDeliveries = new Map();
     cancelledPendingDeliveries = new Set();
+    forkTasks = new Map();
     constructor(ports, options = {}) {
         this.ports = ports;
         this.maxListLimit = boundedInteger(options.maxListLimit ?? MAX_LIST_LIMIT, 1, MAX_LIST_LIMIT, "maxListLimit");
@@ -57,7 +60,10 @@ 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();
     }
     async list(input = {}) {
         const limit = requestLimit(input.limit, DEFAULT_LIST_LIMIT, this.maxListLimit, "limit");
@@ -105,14 +111,22 @@ export class MachineSessionService {
         })).slice(0, limit + 1).map((item) => structuredClone(item));
         const runtime = cloneRuntimeSnapshot(this.ports.runtimeState.snapshot(sessionId));
         const empty = snapshotPage(sessionId, [], runtime, false);
-        const items = candidates.slice(0, limit);
-        while (items.length > 0) {
-            const result = snapshotPage(sessionId, items, runtime, candidates.length > items.length);
-            if (items.length === 1 || jsonByteLength(result) <= this.snapshotPageMaxBytes)
-                return result;
-            items.pop();
+        const items = [];
+        let itemsJsonBytes = 0;
+        for (const item of candidates.slice(0, limit)) {
+            const nextItemsJsonBytes = itemsJsonBytes + (items.length > 0 ? 1 : 0) + jsonByteLength(item);
+            const nextCount = items.length + 1;
+            const hasMore = candidates.length > nextCount;
+            if (items.length > 0 &&
+                snapshotPageJsonByteLength(sessionId, nextItemsJsonBytes, item.id, runtime, hasMore) > this.snapshotPageMaxBytes) {
+                break;
+            }
+            items.push(item);
+            itemsJsonBytes = nextItemsJsonBytes;
         }
-        return empty;
+        return items.length > 0
+            ? snapshotPage(sessionId, items, runtime, candidates.length > items.length)
+            : empty;
     }
     /**
      * Install a live subscriber synchronously, before returning control to an
@@ -145,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) {
@@ -178,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) {
@@ -199,21 +265,189 @@ export class MachineSessionService {
             }
             target = { provider: input.provider };
         }
-        const sessionId = newSessionId();
-        this.ports.registry.create({
-            id: sessionId,
-            source: "console",
-            ...target,
-            ...(input.model === undefined ? {} : { model: input.model }),
-            ...(input.reasoningEffort === undefined ? {} : { reasoningEffort: input.reasoningEffort }),
-            ...(input.title === undefined ? {} : { title: input.title }),
-            createdAt: new Date().toISOString(),
+        const workspacePort = this.requireWorkspace();
+        const workspace = await workspacePort.resolve(input.projectId);
+        try {
+            const execution = await this.requireExecution().resolve({
+                ...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();
+            this.ports.registry.create({
+                id: sessionId,
+                source: "console",
+                workspace,
+                execution,
+                ...(input.title === undefined ? {} : { title: input.title }),
+                createdAt: new Date().toISOString(),
+            });
+            return { sessionId };
+        }
+        catch (error) {
+            if (input.projectId === undefined) {
+                await workspacePort.discardUnbound?.(workspace).catch(() => undefined);
+            }
+            throw error;
+        }
+    }
+    /** 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. */
+    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
+            ? undefined
+            : normalizeSessionTitle(input.title.trim());
+        if (input.title !== undefined && !title) {
+            throw new MachineSessionServiceInputError("title must not be empty");
+        }
+        const requestHash = createHash("sha256")
+            .update(JSON.stringify({ sourceSessionId, title: title ?? null }))
+            .digest("hex");
+        const operation = await this.requireForks().claim({
+            operationId,
+            requestHash,
+            sourceSessionId,
+            ...(title ? { title } : {}),
+        });
+        if (operation.state === "target_deleted") {
+            throw new MachineSessionServiceFailure("conflict", "fork target was deleted");
+        }
+        if (operation.state === "completed") {
+            return { sessionId: operation.targetSessionId, disposition: "replayed" };
+        }
+        const inflight = this.forkTasks.get(operationId);
+        if (inflight)
+            return inflight;
+        const task = this.performFork(operation).finally(() => {
+            if (this.forkTasks.get(operationId) === task) {
+                this.forkTasks.delete(operationId);
+            }
+        });
+        this.forkTasks.set(operationId, task);
+        return task;
+    }
+    /** 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. */
+    async recordNativeRotation(input) {
+        const sourceSessionId = validOpaqueToken(input.sourceSessionId, "sourceSessionId", MAX_SESSION_ID_CHARS);
+        const targetSessionId = validOpaqueToken(input.targetSessionId, "targetSessionId", MAX_SESSION_ID_CHARS);
+        if (sourceSessionId === targetSessionId) {
+            throw new MachineSessionServiceInputError("source and target Session must differ");
+        }
+        const source = this.ports.registry.get(sourceSessionId);
+        if (!source) {
+            throw new MachineSessionServiceFailure("not_found", "source Session not found");
+        }
+        const existing = this.ports.registry.get(targetSessionId);
+        if (existing) {
+            if (input.kind === "fork" &&
+                existing.forkedFromSessionId === sourceSessionId)
+                return;
+            throw new MachineSessionServiceFailure("conflict", "target Session already exists");
+        }
+        const workspace = structuredClone(source.workspace);
+        const execution = structuredClone(source.execution);
+        const sourceTitle = source.title;
+        const now = new Date().toISOString();
+        const target = {
+            id: targetSessionId,
+            source: input.kind,
+            workspace,
+            execution,
+            ...(input.kind === "fork" && sourceTitle ? { title: sourceTitle } : {}),
+            ...(input.kind === "fork" ? { forkedFromSessionId: sourceSessionId } : {}),
+            createdAt: now,
+            updatedAt: now,
+        };
+        if (input.kind === "clear") {
+            this.ports.registry.create(target);
+            return;
+        }
+        const items = (await this.ports.log.snapshot(sourceSessionId))
+            .map((item) => structuredClone(item));
+        await this.requireForks().publishNativeFork({
+            sourceSessionId,
+            target,
+            items,
         });
-        return { sessionId };
+    }
+    async performFork(operation) {
+        const source = this.ports.registry.get(operation.sourceSessionId);
+        if (!source) {
+            throw new MachineSessionServiceFailure("not_found", "source Session not found");
+        }
+        const runner = this.requireExecution().runner;
+        if (!runner.forkSession) {
+            throw new MachineSessionServiceFailure("failed_precondition", "Provider does not support Session fork");
+        }
+        const workspace = structuredClone(source.workspace);
+        const execution = structuredClone(source.execution);
+        const sourceTitle = source.title;
+        let items;
+        try {
+            this.assertForkableSource(operation.sourceSessionId);
+            const native = await runner.forkSession(operation.sourceSessionId, operation.targetSessionId, {
+                workspace: structuredClone(workspace),
+                execution: structuredClone(execution),
+                beforeProviderFork: async () => {
+                    this.assertForkableSource(operation.sourceSessionId);
+                    items = (await this.ports.log.snapshot(operation.sourceSessionId))
+                        .map((item) => structuredClone(item));
+                },
+            });
+            if (!native.ok) {
+                throw new MachineSessionServiceFailure("failed_precondition", "Provider could not fork the Session", native.message);
+            }
+            if (!items) {
+                throw new MachineSessionServiceFailure("outcome_unknown", "Provider fork completed without a canonical fork point");
+            }
+            const now = new Date().toISOString();
+            const targetTitle = operation.title ?? sourceTitle;
+            await this.requireForks().commit({
+                operationId: operation.operationId,
+                target: {
+                    id: operation.targetSessionId,
+                    source: "fork",
+                    workspace: structuredClone(workspace),
+                    execution: structuredClone(execution),
+                    ...(targetTitle ? { title: targetTitle } : {}),
+                    forkedFromSessionId: operation.sourceSessionId,
+                    createdAt: now,
+                    updatedAt: now,
+                },
+                items,
+            });
+            return { sessionId: operation.targetSessionId, disposition: "created" };
+        }
+        catch (error) {
+            await Promise.resolve(this.requireForks().markError(operation.operationId, error instanceof Error ? error.message : String(error))).catch(() => undefined);
+            throw error;
+        }
+    }
+    assertForkableSource(sessionId) {
+        const runtime = this.ports.runtimeState.snapshot(sessionId);
+        if (runtime.status !== "idle" ||
+            runtime.activeResponseIds.length > 0 ||
+            runtime.pendingInteractions.length > 0) {
+            throw new MachineSessionServiceFailure("failed_precondition", "source Session must be idle before it can be forked");
+        }
     }
     /** 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"
             ? { message: messageInput }
             : messageInput;
@@ -272,11 +506,54 @@ export class MachineSessionService {
         if (request.clientMessageId) {
             await resources?.markMessageInjecting(sessionId, request.clientMessageId);
         }
+        const responseId = this.ports.publishEvent ? `resp_${randomUUID()}` : undefined;
+        if (responseId) {
+            await this.ports.publishEvent(sessionId, {
+                type: "session.input.consumed",
+                item: {
+                    id: newSessionItemId("message"),
+                    sessionId,
+                    position: 0,
+                    responseId,
+                    status: "completed",
+                    createdAt: Date.now(),
+                    type: "message",
+                    data: {
+                        role: "user",
+                        content: prepared.input.content.map((part) => part.type === "text"
+                            ? { type: "input_text", text: part.text }
+                            : { ...part.resource }),
+                    },
+                },
+            });
+            await this.ports.publishEvent(sessionId, {
+                type: "session.status",
+                sessionId,
+                responseId,
+                status: "running",
+                statusKind: "startup",
+            });
+        }
+        const abandonResponseHandoff = responseId
+            ? this.ports.runtimeState.beginResponseHandoff?.(sessionId, responseId)
+            : undefined;
+        const clearStartup = async (status) => {
+            if (!responseId)
+                return;
+            await this.ports.publishEvent(sessionId, {
+                type: "session.status",
+                sessionId,
+                responseId,
+                status,
+            });
+        };
         let execution;
         try {
             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));
             }
@@ -284,26 +561,36 @@ export class MachineSessionService {
         }
         let outcome;
         try {
-            outcome = await execution.runner.injectMessage(sessionId, hasMessage && !needsPreparedOperation ? request.message : prepared.input);
+            const runtimeInput = responseId
+                ? { ...prepared.input, responseId }
+                : prepared.input;
+            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);
             }
             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") {
+            abandonResponseHandoff?.();
+            await clearStartup("idle");
             if (request.clientMessageId) {
                 await resources?.markMessageFailedNotStarted(sessionId, request.clientMessageId, `live injection ${outcome}`);
             }
             throw new MachineSessionServiceFailure("failed_precondition", `live injection ${outcome}`);
         }
+        await clearStartup("running");
         if (request.clientMessageId) {
             try {
                 await resources?.markMessageInjected(sessionId, request.clientMessageId);
@@ -347,7 +634,11 @@ 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) {
             throw new MachineSessionServiceInputError("message must be a non-empty string");
         }
@@ -377,6 +668,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) ??
@@ -397,40 +691,13 @@ export class MachineSessionService {
     }
     async liveSessionRequest(sessionId, meta = this.ports.registry.get(sessionId)) {
         const execution = this.requireExecution();
-        const consoleMeta = meta?.source === "console" ? meta : undefined;
-        const bound = consoleMeta ? null : ((await execution.sessionStore?.get(sessionId)) ?? null);
-        if (!meta && !bound) {
+        if (!meta) {
             throw new MachineSessionServiceFailure("not_found", "session not found");
         }
-        const liveRuntime = await execution.runtime.resolveRuntime({
-            agentName: consoleMeta?.agent,
-            agentSpec: consoleMeta?.config,
-            provider: meta?.provider ?? bound?.runtime,
-        });
-        if (liveRuntime === "codex" || liveRuntime === "traex") {
-            const codexRecord = await execution.sessionStore?.get(sessionId);
-            if (codexRecord?.codexSessionId) {
-                ensureCodexResumeRollout({
-                    sessionId,
-                    runtime: liveRuntime,
-                    threadId: codexRecord.codexSessionId,
-                    cwd: codexRecord.cwd ?? process.cwd(),
-                    items: await this.ports.log.snapshot(sessionId),
-                });
-            }
-        }
+        const liveRuntime = meta.execution.provider;
         const options = {
-            ...(bound?.cwd
-                ? { cwd: bound.cwd }
-                : consoleMeta?.config?.osEnv?.cwd
-                    ? { cwd: consoleMeta.config.osEnv.cwd }
-                    : {}),
-            runtime: liveRuntime,
-            ...(consoleMeta?.reasoningEffort
-                ? { reasoningEffort: consoleMeta.reasoningEffort }
-                : {}),
-            ...(consoleMeta?.agent ? { agentName: consoleMeta.agent } : {}),
-            ...(consoleMeta?.config ? { agentSpec: consoleMeta.config } : {}),
+            workspace: structuredClone(meta.workspace),
+            execution: structuredClone(meta.execution),
         };
         return { execution, liveRuntime, options };
     }
@@ -441,6 +708,7 @@ export class MachineSessionService {
     }
     async delete(sessionIdInput) {
         const sessionId = validOpaqueToken(sessionIdInput, "sessionId", MAX_SESSION_ID_CHARS);
+        await this.assertNotForkReserved(sessionId);
         try {
             await this.ports.lifecycle?.beforeDelete?.(sessionId);
         }
@@ -455,6 +723,7 @@ export class MachineSessionService {
         this.ports.registry.remove(sessionId);
         await this.ports.log.deleteSession(sessionId);
         this.ports.runtimeState.remove?.(sessionId);
+        await this.ports.forks?.markTargetDeleted(sessionId);
         try {
             await this.ports.lifecycle?.afterDelete?.(sessionId);
         }
@@ -469,6 +738,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");
@@ -520,7 +807,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;
@@ -553,6 +842,9 @@ export class MachineSessionService {
                     return;
                 }
             }
+            finally {
+                admission?.release();
+            }
             await retryDelay(this.pendingMessageRetryMs);
         }
     }
@@ -592,6 +884,44 @@ export class MachineSessionService {
         }
         return this.ports.execution;
     }
+    requireWorkspace() {
+        const workspace = this.ports.workspace;
+        if (!workspace) {
+            throw new MachineSessionServiceFailure("failed_precondition", "Session workspace resolution is unavailable");
+        }
+        return workspace;
+    }
+    requireForks() {
+        if (!this.ports.forks) {
+            throw new MachineSessionServiceFailure("failed_precondition", "Session fork storage is unavailable");
+        }
+        return this.ports.forks;
+    }
+    async assertNotForkReserved(sessionId) {
+        if (await this.ports.forks?.hasReservedSource(sessionId)) {
+            throw new MachineSessionServiceFailure("conflict", "Session fork is in progress");
+        }
+    }
+    async resumeReservedForks() {
+        if (!this.ports.forks)
+            return;
+        try {
+            for (const operation of await this.ports.forks.listReserved()) {
+                if (this.forkTasks.has(operation.operationId))
+                    continue;
+                const task = this.performFork(operation).finally(() => {
+                    if (this.forkTasks.get(operation.operationId) === task) {
+                        this.forkTasks.delete(operation.operationId);
+                    }
+                });
+                this.forkTasks.set(operation.operationId, task);
+                void task.catch(() => undefined);
+            }
+        }
+        catch {
+            // A direct replay or the next daemon restart retries durable operations.
+        }
+    }
 }
 /** One-line title derived from the first user message; no model call. */
 export function synthesizeSessionTitle(message, limit = 60) {
@@ -688,6 +1018,13 @@ function snapshotPage(sessionId, items, runtime, hasMore) {
         ...(hasMore && items.length > 0 ? { nextAfterId: items.at(-1).id } : {}),
     };
 }
+/** Exact UTF-8 size of {@link snapshotPage} without repeatedly serializing the
+ * complete item array while searching for a page boundary. */
+function snapshotPageJsonByteLength(sessionId, itemsJsonBytes, finalItemId, runtime, hasMore) {
+    return Buffer.byteLength(`{"sessionId":${JSON.stringify(sessionId)},"items":[`, "utf8")
+        + itemsJsonBytes
+        + Buffer.byteLength(`],"runtime":${JSON.stringify(runtime)},"hasMore":${hasMore}${hasMore ? `,"nextAfterId":${JSON.stringify(finalItemId)}` : ""}}`, "utf8");
+}
 function sessionSummary(id, meta, log, runtimeState, pendingState) {
     const createdAt = meta?.createdAt ?? timestampFromEpoch(log?.createdAt, "createdAt");
     const updatedAt = log
@@ -695,8 +1032,7 @@ function sessionSummary(id, meta, log, runtimeState, pendingState) {
         : (meta?.updatedAt ?? createdAt);
     return {
         id,
-        ...(meta?.provider === undefined ? {} : { provider: meta.provider }),
-        ...(meta?.agent === undefined ? {} : { agent: meta.agent }),
+        ...(meta?.execution?.provider === undefined ? {} : { provider: meta.execution.provider }),
         ...(meta?.title === undefined ? {} : { title: normalizeSessionTitle(meta.title) }),
         status: runtimeState.snapshot(id).status,
         ...(pendingState === undefined
@@ -711,6 +1047,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");
@@ -805,6 +1148,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`);