@rynx-ai/runtime 0.1.10 → 0.1.11-beta.2

package/dist/runner/manager.js

@@ -160,6 +160,21 @@ export class RunnerManager {
     liveSessionKeys = new Set();
     /** Last live-start error per local session, surfaced by the control API. */
     liveErrors = new Map();
+    /** Last immutable launch snapshots seen for a Session. Used only to restore a
+     * target request that crossed a fork reservation boundary. */
+    liveOptions = new Map();
+    /** A fork reserves its target before the first asynchronous store read. This
+     * prevents another entry point from starting the target against an
+     * uncommitted Provider binding. */
+    forkReservations = new Map();
+    /** A native fork temporarily makes the source read-only so its canonical
+     * snapshot and Provider context are captured at the same boundary. */
+    sourceForkReservations = new Map();
+    /** Manager-wide fork de-duplication. LocalAgentHost only sees one source
+     * runner, so the fence must live here to cover concurrent source runners. */
+    forkOperations = new Map();
+    forkBufferedMessages = new Map();
+    forkBufferedTerminalInputs = new Map();
     constructor(opts) {
         this.config = opts.config;
         this.sessionStore = opts.sessionStore;
@@ -201,6 +216,9 @@ export class RunnerManager {
      * and attach.
      */
     openLiveTerminal(localThreadId, opts) {
+        if (this.forkReservations.has(localThreadId)) {
+            throw new TerminalOpenError("Session fork is still being committed", "terminal_not_live");
+        }
         const handle = this.handles.get(localThreadId);
         if (!handle || handle.dead || !this.liveSessionKeys.has(localThreadId)) {
             throw new TerminalOpenError("terminal not live", "terminal_not_live");
@@ -210,7 +228,26 @@ export class RunnerManager {
     openTerminalOnHandle(handle, localThreadId, opts) {
         handle.lastUsedAt = this.now();
         const attachId = randomUUID();
-        const terminal = new ManagedTerminal(attachId, (msg) => handle.transport.send(msg), () => handle.terminals.delete(attachId));
+        const terminal = new ManagedTerminal(attachId, (msg) => {
+            const sourceReservation = this.sourceForkReservations.get(localThreadId);
+            if (msg.t === "term.input" && sourceReservation) {
+                void sourceReservation.then(() => {
+                    if (!handle.dead)
+                        handle.transport.send(msg);
+                });
+                return;
+            }
+            // A terminal request may race a fork reservation. Never let later
+            // keystrokes reach an unpublished Provider target.
+            if (msg.t === "term.input") {
+                const target = this.reservedForkTarget(handle, localThreadId);
+                if (target) {
+                    this.forkBufferedTerminalInputs.get(target)?.push({ handle, message: msg });
+                    return;
+                }
+            }
+            handle.transport.send(msg);
+        }, () => handle.terminals.delete(attachId));
         handle.terminals.set(attachId, terminal);
         handle.transport.send({
             t: "term.open",
@@ -229,6 +266,8 @@ export class RunnerManager {
     }
     /** Whether this process already owns a live runner for the Session. Read-only; never spawns. */
     hasLiveSession(localThreadId) {
+        if (this.forkReservations.has(localThreadId))
+            return false;
         const handle = this.handles.get(localThreadId);
         return Boolean(handle && !handle.dead && this.liveSessionKeys.has(localThreadId));
     }
@@ -260,8 +299,26 @@ export class RunnerManager {
     startLiveSession(localThreadId, opts) {
         return this.requestLiveSession(localThreadId, opts, false);
     }
-    requestLiveSession(localThreadId, opts, waitForReady) {
-        const handle = this.getOrSpawn(localThreadId);
+    requestLiveSession(localThreadId, opts, waitForReady, allowReservedForkTarget = false) {
+        const sourceReservation = allowReservedForkTarget
+            ? undefined
+            : this.sourceForkReservations.get(localThreadId);
+        if (sourceReservation) {
+            return sourceReservation.then(() => this.requestLiveSession(localThreadId, opts, waitForReady));
+        }
+        this.liveOptions.set(localThreadId, {
+            workspace: structuredClone(opts.workspace),
+            execution: structuredClone(opts.execution),
+            ...(opts.cols ? { cols: opts.cols } : {}),
+            ...(opts.rows ? { rows: opts.rows } : {}),
+        });
+        const reservation = allowReservedForkTarget
+            ? undefined
+            : this.forkReservations.get(localThreadId);
+        if (reservation) {
+            return reservation.then(() => this.requestLiveSession(localThreadId, opts, waitForReady));
+        }
+        const handle = this.getOrSpawn(localThreadId, allowReservedForkTarget);
         handle.lastUsedAt = this.now();
         this.liveSessionKeys.add(localThreadId);
         const reqId = randomUUID();
@@ -270,39 +327,60 @@ export class RunnerManager {
             const timeout = setTimeout(() => {
                 if (!handle.live.delete(reqId))
                     return;
-                const reason = `runner did not acknowledge ${waitForReady ? "live readiness" : "terminal start"} within ${timeoutMs}ms`;
-                this.liveErrors.set(localThreadId, reason);
-                this.liveSessionKeys.delete(localThreadId);
-                resolve(false);
-                // A child that cannot answer a bounded control round-trip is unsafe to
-                // reuse. Reap it so the next click gets a fresh runner.
-                void this.terminateHandle(handle, reason).catch((error) => {
-                    logTerminationFailure(handle, error);
-                });
+                const finishTimeout = () => {
+                    const reason = `runner did not acknowledge ${waitForReady ? "live readiness" : "terminal start"} within ${timeoutMs}ms`;
+                    this.liveErrors.set(localThreadId, reason);
+                    this.liveSessionKeys.delete(localThreadId);
+                    // A child that cannot answer a bounded control round-trip is unsafe
+                    // to reuse. Reap it so the next click gets a fresh runner.
+                    void this.terminateHandle(handle, reason).catch((error) => {
+                        logTerminationFailure(handle, error);
+                    });
+                    return false;
+                };
+                const reservation = allowReservedForkTarget
+                    ? undefined
+                    : this.forkReservations.get(localThreadId);
+                if (reservation) {
+                    void reservation
+                        .then(() => finishTimeout())
+                        .then(resolve, () => resolve(false));
+                    return;
+                }
+                resolve(finishTimeout());
             }, timeoutMs);
             timeout.unref?.();
             handle.live.set(reqId, (res) => {
                 clearTimeout(timeout);
                 const ok = res.ok ?? false;
-                if (ok) {
-                    this.liveErrors.delete(localThreadId);
-                }
-                else {
-                    this.liveErrors.set(localThreadId, res.error ?? "live session did not become ready");
+                const finish = () => {
+                    if (ok) {
+                        this.liveErrors.delete(localThreadId);
+                    }
+                    else {
+                        this.liveErrors.set(localThreadId, res.error ?? "live session did not become ready");
+                    }
+                    return ok;
+                };
+                const reservation = allowReservedForkTarget
+                    ? undefined
+                    : this.forkReservations.get(localThreadId);
+                if (reservation) {
+                    void reservation
+                        .then(() => finish())
+                        .then(resolve, () => resolve(false));
+                    return;
                 }
-                resolve(ok);
+                resolve(finish());
             });
             handle.transport.send({
                 t: "live.ensure",
                 reqId,
                 localThreadId,
-                ...(opts?.cwd ? { cwd: opts.cwd } : {}),
-                ...(opts?.cols ? { cols: opts.cols } : {}),
-                ...(opts?.rows ? { rows: opts.rows } : {}),
-                ...(opts?.runtime ? { runtime: opts.runtime } : {}),
-                ...(opts?.reasoningEffort ? { reasoningEffort: opts.reasoningEffort } : {}),
-                ...(opts?.agentName ? { agentName: opts.agentName } : {}),
-                ...(opts?.agentSpec ? { agentSpec: opts.agentSpec } : {}),
+                workspace: opts.workspace,
+                execution: opts.execution,
+                ...(opts.cols ? { cols: opts.cols } : {}),
+                ...(opts.rows ? { rows: opts.rows } : {}),
                 waitForReady,
             });
         });
@@ -317,11 +395,38 @@ export class RunnerManager {
      * the session has no live forwarder (caller falls back to the run path).
      */
     injectMessage(localThreadId, input) {
+        const sourceReservation = this.sourceForkReservations.get(localThreadId);
+        if (sourceReservation) {
+            return sourceReservation.then(() => this.injectMessage(localThreadId, input));
+        }
+        const reservation = this.forkReservations.get(localThreadId);
+        if (reservation) {
+            return reservation.then(() => this.injectMessage(localThreadId, input));
+        }
         const handle = this.getOrSpawn(localThreadId);
         handle.lastUsedAt = this.now();
         const reqId = randomUUID();
         return new Promise((resolve) => {
-            handle.live.set(reqId, (res) => resolve(res.outcome ?? "failed"));
+            handle.live.set(reqId, (res) => {
+                const outcome = res.outcome ?? "failed";
+                const finish = () => {
+                    if (outcome === "injected") {
+                        this.liveErrors.delete(localThreadId);
+                    }
+                    else {
+                        this.liveErrors.set(localThreadId, res.error ?? `live injection ${outcome}`);
+                    }
+                    return outcome;
+                };
+                const reservation = this.forkReservations.get(localThreadId);
+                if (reservation) {
+                    void reservation
+                        .then(() => finish())
+                        .then(resolve, () => resolve("failed"));
+                    return;
+                }
+                resolve(finish());
+            });
             handle.transport.send(typeof input === "string"
                 ? { t: "inject", reqId, localThreadId, text: input }
                 : { t: "inject", reqId, localThreadId, input });
@@ -382,9 +487,82 @@ export class RunnerManager {
     clearGoal(localThreadId) {
         return this.forwardCap("clearGoal", [localThreadId], localThreadId);
     }
-    forkSession(currentLocalThreadId, newLocalThreadId) {
-        // Runs on the SOURCE session's child (its home has the source rollout to fork).
-        return this.forwardCap("forkSession", [currentLocalThreadId, newLocalThreadId], currentLocalThreadId);
+    forkSession(currentLocalThreadId, newLocalThreadId, options) {
+        if (currentLocalThreadId === newLocalThreadId) {
+            return Promise.resolve({
+                ok: false,
+                message: "source and target Session must differ",
+            });
+        }
+        const inflight = this.forkOperations.get(newLocalThreadId);
+        if (inflight) {
+            if (inflight.sourceSessionId === currentLocalThreadId) {
+                return inflight.operation.then(capabilityForkResult);
+            }
+            return Promise.resolve({
+                ok: false,
+                message: "target Session already has a fork in progress",
+            });
+        }
+        if (this.sourceForkReservations.has(currentLocalThreadId)) {
+            return Promise.resolve({
+                ok: false,
+                message: "source Session already has a fork in progress",
+            });
+        }
+        let releaseReservation;
+        const reservation = new Promise((resolve) => {
+            releaseReservation = resolve;
+        });
+        let releaseSource;
+        const sourceReservation = new Promise((resolve) => {
+            releaseSource = resolve;
+        });
+        this.forkReservations.set(newLocalThreadId, reservation);
+        this.sourceForkReservations.set(currentLocalThreadId, sourceReservation);
+        this.forkBufferedMessages.set(newLocalThreadId, []);
+        this.forkBufferedTerminalInputs.set(newLocalThreadId, []);
+        const retainedLiveOptions = this.liveOptions.get(newLocalThreadId);
+        const operation = (async () => {
+            await options.beforeProviderFork();
+            return this.performManagedFork(currentLocalThreadId, newLocalThreadId, options);
+        })()
+            .finally(() => {
+            const current = this.forkOperations.get(newLocalThreadId);
+            if (current?.operation === operation) {
+                this.forkOperations.delete(newLocalThreadId);
+            }
+            if (this.forkReservations.get(newLocalThreadId) === reservation) {
+                this.forkReservations.delete(newLocalThreadId);
+            }
+            if (this.sourceForkReservations.get(currentLocalThreadId) === sourceReservation) {
+                this.sourceForkReservations.delete(currentLocalThreadId);
+            }
+            const buffered = this.forkBufferedMessages.get(newLocalThreadId) ?? [];
+            this.forkBufferedMessages.delete(newLocalThreadId);
+            const bufferedTerminalInputs = this.forkBufferedTerminalInputs.get(newLocalThreadId) ?? [];
+            this.forkBufferedTerminalInputs.delete(newLocalThreadId);
+            for (const entry of buffered) {
+                this.deliverForkBufferedMessage(entry.handle, entry.message);
+            }
+            for (const entry of bufferedTerminalInputs) {
+                if (!entry.handle.dead)
+                    entry.handle.transport.send(entry.message);
+            }
+            releaseReservation();
+            releaseSource();
+            queueMicrotask(() => {
+                if (this.liveOptions.get(newLocalThreadId) === retainedLiveOptions
+                    && !this.handles.has(newLocalThreadId)) {
+                    this.liveOptions.delete(newLocalThreadId);
+                }
+            });
+        });
+        this.forkOperations.set(newLocalThreadId, {
+            sourceSessionId: currentLocalThreadId,
+            operation,
+        });
+        return operation.then(capabilityForkResult);
     }
     /**
      * Backend-free runtime readiness (not part of `AgentCapabilities`; surfaced for
@@ -417,6 +595,7 @@ export class RunnerManager {
             this.handles.clear();
             this.liveSessionKeys.clear();
             this.liveErrors.clear();
+            this.liveOptions.clear();
             this.mirrorListener = null;
             this.rotateListener = null;
             const errors = results
@@ -442,10 +621,15 @@ export class RunnerManager {
             handle.transport.send({ t: "cap", capId, name, args });
         });
     }
-    getOrSpawn(key) {
+    getOrSpawn(key, allowReservedForkTarget = false) {
         if (this.stopping) {
             throw new AgentRuntimeError("runner manager is stopped", 503, "runner_stopped");
         }
+        if (key !== CAP_KEY &&
+            this.forkReservations.has(key) &&
+            !allowReservedForkTarget) {
+            throw new AgentRuntimeError("Session fork is still being committed", 409, "session_fork_pending");
+        }
         this.reapIdle();
         const existing = this.handles.get(key);
         if (existing && !existing.dead) {
@@ -456,6 +640,204 @@ export class RunnerManager {
         this.handles.set(key, handle);
         return handle;
     }
+    async performManagedFork(currentLocalThreadId, newLocalThreadId, options) {
+        const existingTarget = await this.sessionStore.get(newLocalThreadId);
+        if (existingTarget?.parentSessionId === currentLocalThreadId) {
+            return { ok: true, data: undefined };
+        }
+        if (existingTarget?.parentSessionId) {
+            return {
+                ok: false,
+                reason: "error",
+                message: "target Session already belongs to a different fork",
+            };
+        }
+        const targetHandle = this.handles.get(newLocalThreadId);
+        if (existingTarget) {
+            return {
+                ok: false,
+                reason: "error",
+                message: "target Session already has a Provider binding",
+            };
+        }
+        if (targetHandle && !targetHandle.dead) {
+            return {
+                ok: false,
+                reason: "error",
+                message: "target Session already has a runner",
+            };
+        }
+        if (options.execution.provider === "claude") {
+            return this.performClaudeManagedFork(currentLocalThreadId, newLocalThreadId, options);
+        }
+        // Runs on the SOURCE session's child (its home has the source rollout to
+        // fork). The Provider persists the native fork and target binding before
+        // returning. Only then is the target reservation released.
+        return this.forwardCap("forkSession", [
+            currentLocalThreadId,
+            newLocalThreadId,
+            {
+                workspace: structuredClone(options.workspace),
+                execution: structuredClone(options.execution),
+            },
+        ], currentLocalThreadId);
+    }
+    async performClaudeManagedFork(currentLocalThreadId, newLocalThreadId, options) {
+        const source = await this.sessionStore.get(currentLocalThreadId);
+        const setIntent = this.sessionStore.setClaudeForkIntent?.bind(this.sessionStore);
+        const deleteIntent = this.sessionStore.deleteClaudeForkIntent?.bind(this.sessionStore);
+        if (!source?.codexSessionId || !setIntent || !deleteIntent) {
+            return {
+                ok: false,
+                reason: "unsupported",
+                message: "Claude fork persistence is unavailable",
+            };
+        }
+        const targetClaudeSessionId = randomUUID();
+        try {
+            await setIntent({
+                targetSessionId: newLocalThreadId,
+                sourceSessionId: currentLocalThreadId,
+                sourceClaudeSessionId: source.codexSessionId,
+                targetClaudeSessionId,
+                updatedAt: new Date().toISOString(),
+            });
+            const ready = await this.requestLiveSession(newLocalThreadId, {
+                workspace: structuredClone(options.workspace),
+                execution: structuredClone(options.execution),
+            }, true, true);
+            const target = ready ? await this.sessionStore.get(newLocalThreadId) : null;
+            if (!target ||
+                target.parentSessionId !== currentLocalThreadId ||
+                target.codexSessionId !== targetClaudeSessionId) {
+                throw new Error(this.lastLiveSessionError(newLocalThreadId) ??
+                    "Claude did not materialize the requested fork");
+            }
+            return { ok: true, data: undefined };
+        }
+        catch (error) {
+            await deleteIntent(newLocalThreadId).catch(() => undefined);
+            const target = await this.sessionStore.get(newLocalThreadId).catch(() => null);
+            if (target?.parentSessionId === currentLocalThreadId) {
+                await this.sessionStore.delete(newLocalThreadId).catch(() => undefined);
+            }
+            const handle = this.handles.get(newLocalThreadId);
+            if (handle && !handle.dead) {
+                await this.terminateHandle(handle, "Claude fork materialization failed").catch(() => undefined);
+            }
+            return {
+                ok: false,
+                reason: "error",
+                message: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    bufferForkTargetMessage(handle, message) {
+        const directTarget = message.t === "mirror" ? message.sessionId : message.from;
+        const target = this.reservedForkTarget(handle, directTarget);
+        if (!target)
+            return false;
+        this.forkBufferedMessages.get(target)?.push({ handle, message });
+        return true;
+    }
+    reservedForkTarget(handle, directTarget) {
+        return this.forkReservations.has(directTarget)
+            ? directTarget
+            : [...this.forkReservations.keys()].find((candidate) => this.handles.get(candidate) === handle);
+    }
+    deliverForkBufferedMessage(handle, message) {
+        if (handle.dead)
+            return;
+        if (message.t === "mirror") {
+            this.mirrorListener?.(message.sessionId, message.event);
+            return;
+        }
+        this.deliverRotateMessage(handle, message);
+    }
+    deliverRotateMessage(handle, message) {
+        if (this.forkReservations.has(message.to) ||
+            this.sourceForkReservations.has(message.from)) {
+            void this.terminateHandle(handle, "conflicting Session rotation").catch((error) => logTerminationFailure(handle, error));
+            return;
+        }
+        try {
+            // Rotate the runtime-local context before publishing the new Session
+            // alias to routing or observers. This prevents the new identity from
+            // briefly inheriting stale context after `/clear` or `/fork`.
+            handle.sessionContext?.rotate(message.to);
+        }
+        catch (error) {
+            const reason = `runner Session context rotation failed: ${errorMessage(error)}`;
+            void this.terminateHandle(handle, reason).catch((terminationError) => {
+                logTerminationFailure(handle, terminationError);
+            });
+            return;
+        }
+        let releaseTarget;
+        const targetReservation = new Promise((resolve) => {
+            releaseTarget = resolve;
+        });
+        let releaseSource;
+        const sourceReservation = new Promise((resolve) => {
+            releaseSource = resolve;
+        });
+        this.forkReservations.set(message.to, targetReservation);
+        this.sourceForkReservations.set(message.from, sourceReservation);
+        this.forkBufferedMessages.set(message.to, []);
+        this.forkBufferedTerminalInputs.set(message.to, []);
+        // The physical pane has already rotated. Remove every old routing alias now:
+        // a later request for the source must spawn a fresh runner that resumes the
+        // source Provider binding, while existing terminal attachments continue to
+        // follow the transferred pane.
+        for (const [key, candidate] of this.handles) {
+            if (candidate !== handle)
+                continue;
+            this.handles.delete(key);
+            this.liveSessionKeys.delete(key);
+            this.liveOptions.delete(key);
+        }
+        const rotation = {
+            from: message.from,
+            to: message.to,
+            kind: message.kind,
+            workspace: message.workspace,
+            execution: message.execution,
+            ...(message.parentSessionId ? { parentSessionId: message.parentSessionId } : {}),
+        };
+        void Promise.resolve(this.rotateListener?.(rotation))
+            .then(() => {
+            if (handle.dead)
+                return;
+            this.handles.set(message.to, handle);
+            this.liveSessionKeys.add(message.to);
+            this.liveOptions.set(message.to, {
+                workspace: structuredClone(message.workspace),
+                execution: structuredClone(message.execution),
+            });
+            for (const entry of this.forkBufferedMessages.get(message.to) ?? []) {
+                this.deliverForkBufferedMessage(entry.handle, entry.message);
+            }
+            for (const entry of this.forkBufferedTerminalInputs.get(message.to) ?? []) {
+                if (!entry.handle.dead)
+                    entry.handle.transport.send(entry.message);
+            }
+        })
+            .catch((error) => {
+            void this.terminateHandle(handle, `Session rotation publication failed: ${errorMessage(error)}`).catch((terminationError) => logTerminationFailure(handle, terminationError));
+        })
+            .finally(() => {
+            if (this.forkReservations.get(message.to) === targetReservation) {
+                this.forkReservations.delete(message.to);
+            }
+            if (this.sourceForkReservations.get(message.from) === sourceReservation) {
+                this.sourceForkReservations.delete(message.from);
+            }
+            this.forkBufferedMessages.delete(message.to);
+            this.forkBufferedTerminalInputs.delete(message.to);
+            releaseTarget();
+            releaseSource();
+        });
+    }
     spawnHandle(key) {
         const args = this.runnerEntry.endsWith(".ts")
             ? ["--import", "tsx", this.runnerEntry]
@@ -550,37 +932,18 @@ export class RunnerManager {
                 return;
             }
             case "mirror":
+                if (handle.dead)
+                    return;
+                if (this.bufferForkTargetMessage(handle, msg))
+                    return;
                 this.mirrorListener?.(msg.sessionId, msg.event);
                 return;
             case "rotate": {
                 if (handle.dead)
                     return;
-                try {
-                    // Rotate the runtime-local context before publishing the new Session
-                    // alias to routing or observers. This prevents the new identity from
-                    // briefly inheriting stale context after `/clear` or `/fork`.
-                    handle.sessionContext?.rotate(msg.to);
-                }
-                catch (error) {
-                    const reason = `runner Session context rotation failed: ${errorMessage(error)}`;
-                    void this.terminateHandle(handle, reason).catch((terminationError) => {
-                        logTerminationFailure(handle, terminationError);
-                    });
+                if (this.bufferForkTargetMessage(handle, msg))
                     return;
-                }
-                // Terminal transfer: alias the new session to THIS runner so its injection
-                // (and live/approval) route to the same child that still owns the pane.
-                this.handles.set(msg.to, handle);
-                this.liveSessionKeys.add(msg.to);
-                this.rotateListener?.({
-                    from: msg.from,
-                    to: msg.to,
-                    kind: msg.kind,
-                    ...(msg.agent ? { agent: msg.agent } : {}),
-                    ...(msg.model ? { model: msg.model } : {}),
-                    ...(msg.cwd ? { cwd: msg.cwd } : {}),
-                    ...(msg.parentSessionId ? { parentSessionId: msg.parentSessionId } : {}),
-                });
+                this.deliverRotateMessage(handle, msg);
                 return;
             }
             case "live.ready":
@@ -614,6 +977,9 @@ export class RunnerManager {
             if (h === handle) {
                 this.handles.delete(key);
                 this.liveSessionKeys.delete(key);
+                if (!this.forkReservations.has(key)) {
+                    this.liveOptions.delete(key);
+                }
             }
         }
         const tail = handle.stderr.join("\n");
@@ -836,3 +1202,14 @@ function logTerminationFailure(handle, error) {
         error: error instanceof Error ? error.message : String(error),
     }));
 }
+function capabilityForkResult(result) {
+    return result.ok
+        ? { ok: true }
+        : {
+            ok: false,
+            message: result.message ??
+                (result.reason === "unsupported"
+                    ? "Provider does not support Session fork"
+                    : "Provider Session is unavailable"),
+        };
+}

package/dist/runner/protocol.d.ts

@@ -6,7 +6,7 @@
  * (`live.ensure` / `inject` / `live.interrupt`) plus per-thread capabilities and
  * terminal attachment; the reply channels mirror each request's `reqId`.
  */
-import { AgentRuntimeError, type AgentRuntimeId, type AgentSpec, type ReasoningEffort, type RuntimeUserInput, type SessionInteractionResolution, type SessionEvent } from "@rynx-ai/core";
+import { AgentRuntimeError, type ResolvedExecutionSnapshot, type RuntimeUserInput, type SessionInteractionResolution, type SessionEvent, type SessionWorkspaceSnapshot } from "@rynx-ai/core";
 import type { ResolveInteractionResult } from "../interactions.js";
 /** A runtime error flattened for the wire; rebuilt parent-side as `AgentRuntimeError`. */
 export interface WireError {
@@ -76,22 +76,12 @@ export type ToChild = {
     t: "live.ensure";
     reqId: string;
     localThreadId: string;
-    cwd?: string;
+    /** The two immutable Session snapshots. Provider launch/resume only
+     * projects these values and never resolves a Project or Agent. */
+    workspace: SessionWorkspaceSnapshot;
+    execution: ResolvedExecutionSnapshot;
     cols?: number;
     rows?: number;
-    /** Runtime this session co-drives (resolved from the agent spec by the
-     *  control plane), so live picks the right backend per agent — not the
-     *  global default. Absent ⇒ host falls back to the store record / default. */
-    runtime?: AgentRuntimeId;
-    /** Model-advertised reasoning effort for the live TUI and turn/start. */
-    reasoningEffort?: ReasoningEffort;
-    /** The session's preset agent id, so the host can load its spec and apply
-     *  the agent's model / skills / instructions to the live launch (not just
-     *  the runtime). Absent for inline-config or agent-less sessions. */
-    agentName?: string;
-    /** An inline agent spec (console session created from an inline config
-     *  rather than a preset id) — same purpose as `agentName`. */
-    agentSpec?: AgentSpec;
     /** Setup terminals only need the Provider pane to exist. Message delivery
      *  keeps the default and waits until the native thread is actually bound. */
     waitForReady?: boolean;
@@ -166,9 +156,8 @@ export type FromChild = {
     from: string;
     to: string;
     kind: "clear" | "fork";
-    agent?: string;
-    model?: string;
-    cwd?: string;
+    workspace: SessionWorkspaceSnapshot;
+    execution: ResolvedExecutionSnapshot;
     parentSessionId?: string;
 }
 /** Result of a `live.ensure`: `ok` once the requested gate is reached (pane