@code-yeongyu/senpi 2026.11.10-1 → 2026.11.10-2

package/dist/modes/rpc/host-park-ledger.js

@@ -0,0 +1,110 @@
+/** Speculation is bounded independently of the unlimited in-process session registry. */
+const MAX_PARKS = 4;
+const PARK_TTL_MS = 60_000;
+/** Owns both in-flight builds and ready parks, including the races with claim, expiry and shutdown. */
+export class HostParkLedger {
+    constructor(close) {
+        this.parks = new Map();
+        this.replacements = new Map();
+        this.stopped = false;
+        this.close = close;
+    }
+    get size() {
+        return this.parks.size;
+    }
+    async park(key, build) {
+        const existing = this.parks.get(key);
+        if (existing && !existing.claim && !existing.closing) {
+            await existing.ready;
+            return "already_parked";
+        }
+        // A park being claimed or closed is on its way out; the replacement scheduled after it builds the next.
+        if (existing)
+            return "full";
+        const replacement = this.replacements.get(key);
+        if (replacement !== undefined) {
+            clearTimeout(replacement);
+            this.replacements.delete(key);
+        }
+        if (this.stopped)
+            throw new Error("host_draining");
+        if (this.parks.size + this.replacements.size >= MAX_PARKS)
+            return "full";
+        const ready = Promise.withResolvers();
+        ready.promise.catch(() => { });
+        const park = { ready: ready.promise };
+        // Reserved before build's first await: a second request joins, never starts another runtime.
+        this.parks.set(key, park);
+        try {
+            park.opened = await build();
+            if (!this.stopped) {
+                park.expiry = setTimeout(() => void this.retire(key, park), PARK_TTL_MS);
+                park.expiry.unref?.();
+            }
+            ready.resolve();
+            if (this.stopped)
+                await this.retire(key, park);
+            return "parked";
+        }
+        catch (cause) {
+            this.parks.delete(key);
+            ready.reject(cause);
+            throw cause;
+        }
+    }
+    /** A claim never waits for a build, and consumes the ready park synchronously. */
+    take(key) {
+        const park = this.parks.get(key);
+        if (this.stopped || !park?.opened || park.claim || park.closing)
+            return undefined;
+        clearTimeout(park.expiry);
+        park.claim = Promise.withResolvers();
+        return park.opened;
+    }
+    finish(key) {
+        const park = this.parks.get(key);
+        this.parks.delete(key);
+        park?.claim?.resolve();
+    }
+    replace(key, build) {
+        if (this.stopped || this.replacements.has(key))
+            return;
+        const timer = setTimeout(() => {
+            this.replacements.delete(key);
+            void this.park(key, build).catch((cause) => {
+                process.stderr.write(`senpi rpc replacement park failed: ${String(cause)}\n`);
+            });
+        }, 0);
+        timer.unref?.();
+        this.replacements.set(key, timer);
+    }
+    /** Fences new builds synchronously; every build already accepted is closed when it finishes. */
+    async stop() {
+        this.stopped = true;
+        for (const timer of this.replacements.values())
+            clearTimeout(timer);
+        this.replacements.clear();
+        await Promise.all([...this.parks].map(async ([key, park]) => {
+            await park.ready.catch(() => { });
+            if (park.claim)
+                await park.claim.promise;
+            else
+                await this.retire(key, park);
+        }));
+    }
+    retire(key, park) {
+        clearTimeout(park.expiry);
+        park.closing ??= (async () => {
+            try {
+                if (park.opened)
+                    await this.close(park.opened);
+            }
+            finally {
+                if (this.parks.get(key) === park)
+                    this.parks.delete(key);
+            }
+        })();
+        return park.closing;
+    }
+}
+//# sourceMappingURL=host-park-ledger.js.map

package/dist/modes/rpc/lifecycle-delivery.js

@@ -15,7 +15,10 @@ export function observeLifecycleDelivery(record) {
         return record;
     if (record.command === "get_state")
         return { ...record, data: observeState(data) };
-    if (record.command === "open_session" && "state" in data && typeof data.state === "object" && data.state !== null)
+    if ((record.command === "open_session" || record.command === "claim_session") &&
+        "state" in data &&
+        typeof data.state === "object" &&
+        data.state !== null)
         return { ...record, data: { ...data, state: observeState(data.state) } };
     return record;
 }

package/dist/modes/rpc/media-placeholders.js

@@ -39,6 +39,7 @@ const MEDIA_BEARING_RESPONSE_COMMANDS = new Set([
     "get_tree",
     "get_state",
     "open_session",
+    "claim_session",
 ]);
 /**
  * Decoded byte length of a base64 string, derived from its length alone.

package/dist/modes/rpc/method-classes-schema-host.d.ts

@@ -15,6 +15,38 @@ export declare const HOST_RECORD_SCHEMAS: {
         id: Type.TOptional<Type.TString>;
         admissionId: Type.TOptional<Type.TString>;
         type: Type.TLiteral<"open_session">;
+    } & {
+        retry: Type.TOptional<Type.TLiteral<true>>;
+        attended: Type.TOptional<Type.TLiteral<false>>;
+        spawnedBy: Type.TOptional<Type.TObject<{
+            parentSessionId: Type.TString;
+            rootSessionId: Type.TString;
+            taskId: Type.TString;
+        }>>;
+        expectedHostInstance: Type.TOptional<Type.TString>;
+        sessionPath: Type.TOptional<Type.TString>;
+        cwd: Type.TOptional<Type.TString>;
+        provider: Type.TOptional<Type.TString>;
+        modelId: Type.TOptional<Type.TString>;
+        thinkingLevel: Type.TOptional<Type.TUnion<[Type.TLiteral<string>, ...Type.TLiteral<string>[]]>>;
+        permissionPreset: Type.TOptional<Type.TString>;
+        retain_on_disconnect: Type.TOptional<Type.TBoolean>;
+        kind: Type.TOptional<Type.TUnion<[Type.TLiteral<string>, ...Type.TLiteral<string>[]]>>;
+        context: Type.TOptional<Type.TRecord<"^.*$", Type.TString>>;
+        auto_title: Type.TOptional<Type.TBoolean>;
+        durableSessionId: Type.TOptional<Type.TString>;
+        promptSurface: Type.TOptional<Type.TUnion<[Type.TLiteral<string>, ...Type.TLiteral<string>[]]>>;
+        browserEngine: Type.TOptional<Type.TUnion<[Type.TLiteral<string>, ...Type.TLiteral<string>[]]>>;
+        retryFallback: Type.TOptional<Type.TObject<{
+            modelFallback: Type.TBoolean;
+            fallbackChains: Type.TRecord<"^.*$", Type.TImmutable<Type.TArray<Type.TString>>>;
+        }>>;
+        env: Type.TOptional<Type.TRecord<"^.*$", Type.TString>>;
+    }>;
+    claim_session: Type.TObject<{
+        id: Type.TOptional<Type.TString>;
+        admissionId: Type.TOptional<Type.TString>;
+        type: Type.TLiteral<"claim_session">;
     } & {
         readonly retry: Type.TOptional<Type.TLiteral<true>>;
         readonly attended: Type.TOptional<Type.TLiteral<false>>;
@@ -25,7 +57,6 @@ export declare const HOST_RECORD_SCHEMAS: {
         }>>;
         readonly expectedHostInstance: Type.TOptional<Type.TString>;
         readonly sessionPath: Type.TOptional<Type.TString>;
-        readonly cwd: Type.TOptional<Type.TString>;
         readonly provider: Type.TOptional<Type.TString>;
         readonly modelId: Type.TOptional<Type.TString>;
         readonly thinkingLevel: Type.TOptional<Type.TUnion<[Type.TLiteral<string>, ...Type.TLiteral<string>[]]>>;
@@ -42,6 +73,16 @@ export declare const HOST_RECORD_SCHEMAS: {
             fallbackChains: Type.TRecord<"^.*$", Type.TImmutable<Type.TArray<Type.TString>>>;
         }>>;
         readonly env: Type.TOptional<Type.TRecord<"^.*$", Type.TString>>;
+        readonly cwd: Type.TString;
+    }>;
+    park_session: Type.TObject<{
+        id: Type.TOptional<Type.TString>;
+        admissionId: Type.TOptional<Type.TString>;
+        type: Type.TLiteral<"park_session">;
+    } & {
+        readonly cwd: Type.TString;
+        readonly kind: Type.TOptional<Type.TUnion<[Type.TLiteral<string>, ...Type.TLiteral<string>[]]>>;
+        readonly context: Type.TOptional<Type.TRecord<"^.*$", Type.TString>>;
     }>;
     close_session: Type.TObject<{
         id: Type.TOptional<Type.TString>;

package/dist/modes/rpc/method-classes-schema-host.js

@@ -9,32 +9,35 @@ const uiResponseFrame = {
     uiRequestId: OptId,
     answerId: OptId,
 };
+const openProperties = {
+    retry: Opt(Type.Literal(true)),
+    attended: Opt(Type.Literal(false)),
+    spawnedBy: Opt(Type.Object({ parentSessionId: Id, rootSessionId: Id, taskId: Id })),
+    expectedHostInstance: OptId,
+    sessionPath: OptPath,
+    cwd: OptPath,
+    provider: OptId,
+    modelId: OptId,
+    thinkingLevel: Opt(ThinkingLevel),
+    permissionPreset: OptId,
+    retain_on_disconnect: OptBool,
+    kind: Opt(SessionKind),
+    context: Opt(SessionContext),
+    auto_title: OptBool,
+    durableSessionId: OptId,
+    promptSurface: Opt(literals("terminal", "app", "chat")),
+    browserEngine: Opt(literals("connected", "builtin", "none")),
+    retryFallback: Opt(RetryFallback),
+    env: Opt(SessionEnv),
+};
 export const HOST_RECORD_SCHEMAS = {
     get_protocol_info: command("get_protocol_info", {
         auth: Opt(Type.Object({ client_nonce: Id })),
         observe: OptBool,
     }),
-    open_session: command("open_session", {
-        retry: Opt(Type.Literal(true)),
-        attended: Opt(Type.Literal(false)),
-        spawnedBy: Opt(Type.Object({ parentSessionId: Id, rootSessionId: Id, taskId: Id })),
-        expectedHostInstance: OptId,
-        sessionPath: OptPath,
-        cwd: OptPath,
-        provider: OptId,
-        modelId: OptId,
-        thinkingLevel: Opt(ThinkingLevel),
-        permissionPreset: OptId,
-        retain_on_disconnect: OptBool,
-        kind: Opt(SessionKind),
-        context: Opt(SessionContext),
-        auto_title: OptBool,
-        durableSessionId: OptId,
-        promptSurface: Opt(literals("terminal", "app", "chat")),
-        browserEngine: Opt(literals("connected", "builtin", "none")),
-        retryFallback: Opt(RetryFallback),
-        env: Opt(SessionEnv),
-    }),
+    open_session: command("open_session", openProperties),
+    claim_session: command("claim_session", { ...openProperties, cwd: PathStr }),
+    park_session: command("park_session", { cwd: PathStr, kind: Opt(SessionKind), context: Opt(SessionContext) }),
     close_session: command("close_session", { sessionId: Id }),
     move_session: Type.Union([
         move({ op: Type.Literal("prepare"), moveId: Id }),

package/dist/modes/rpc/method-classes-schema.d.ts

@@ -70,6 +70,38 @@ export declare const RPC_INBOUND_SCHEMAS: {
         id: import("typebox").TOptional<import("typebox").TString>;
         admissionId: import("typebox").TOptional<import("typebox").TString>;
         type: import("typebox").TLiteral<"open_session">;
+    } & {
+        retry: import("typebox").TOptional<import("typebox").TLiteral<true>>;
+        attended: import("typebox").TOptional<import("typebox").TLiteral<false>>;
+        spawnedBy: import("typebox").TOptional<import("typebox").TObject<{
+            parentSessionId: import("typebox").TString;
+            rootSessionId: import("typebox").TString;
+            taskId: import("typebox").TString;
+        }>>;
+        expectedHostInstance: import("typebox").TOptional<import("typebox").TString>;
+        sessionPath: import("typebox").TOptional<import("typebox").TString>;
+        cwd: import("typebox").TOptional<import("typebox").TString>;
+        provider: import("typebox").TOptional<import("typebox").TString>;
+        modelId: import("typebox").TOptional<import("typebox").TString>;
+        thinkingLevel: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TLiteral<string>, ...import("typebox").TLiteral<string>[]]>>;
+        permissionPreset: import("typebox").TOptional<import("typebox").TString>;
+        retain_on_disconnect: import("typebox").TOptional<import("typebox").TBoolean>;
+        kind: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TLiteral<string>, ...import("typebox").TLiteral<string>[]]>>;
+        context: import("typebox").TOptional<import("typebox").TRecord<"^.*$", import("typebox").TString>>;
+        auto_title: import("typebox").TOptional<import("typebox").TBoolean>;
+        durableSessionId: import("typebox").TOptional<import("typebox").TString>;
+        promptSurface: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TLiteral<string>, ...import("typebox").TLiteral<string>[]]>>;
+        browserEngine: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TLiteral<string>, ...import("typebox").TLiteral<string>[]]>>;
+        retryFallback: import("typebox").TOptional<import("typebox").TObject<{
+            modelFallback: import("typebox").TBoolean;
+            fallbackChains: import("typebox").TRecord<"^.*$", import("typebox").TImmutable<import("typebox").TArray<import("typebox").TString>>>;
+        }>>;
+        env: import("typebox").TOptional<import("typebox").TRecord<"^.*$", import("typebox").TString>>;
+    }>;
+    readonly claim_session: import("typebox").TObject<{
+        id: import("typebox").TOptional<import("typebox").TString>;
+        admissionId: import("typebox").TOptional<import("typebox").TString>;
+        type: import("typebox").TLiteral<"claim_session">;
     } & {
         readonly retry: import("typebox").TOptional<import("typebox").TLiteral<true>>;
         readonly attended: import("typebox").TOptional<import("typebox").TLiteral<false>>;
@@ -80,7 +112,6 @@ export declare const RPC_INBOUND_SCHEMAS: {
         }>>;
         readonly expectedHostInstance: import("typebox").TOptional<import("typebox").TString>;
         readonly sessionPath: import("typebox").TOptional<import("typebox").TString>;
-        readonly cwd: import("typebox").TOptional<import("typebox").TString>;
         readonly provider: import("typebox").TOptional<import("typebox").TString>;
         readonly modelId: import("typebox").TOptional<import("typebox").TString>;
         readonly thinkingLevel: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TLiteral<string>, ...import("typebox").TLiteral<string>[]]>>;
@@ -97,6 +128,16 @@ export declare const RPC_INBOUND_SCHEMAS: {
             fallbackChains: import("typebox").TRecord<"^.*$", import("typebox").TImmutable<import("typebox").TArray<import("typebox").TString>>>;
         }>>;
         readonly env: import("typebox").TOptional<import("typebox").TRecord<"^.*$", import("typebox").TString>>;
+        readonly cwd: import("typebox").TString;
+    }>;
+    readonly park_session: import("typebox").TObject<{
+        id: import("typebox").TOptional<import("typebox").TString>;
+        admissionId: import("typebox").TOptional<import("typebox").TString>;
+        type: import("typebox").TLiteral<"park_session">;
+    } & {
+        readonly cwd: import("typebox").TString;
+        readonly kind: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TLiteral<string>, ...import("typebox").TLiteral<string>[]]>>;
+        readonly context: import("typebox").TOptional<import("typebox").TRecord<"^.*$", import("typebox").TString>>;
     }>;
     readonly close_session: import("typebox").TObject<{
         id: import("typebox").TOptional<import("typebox").TString>;

package/dist/modes/rpc/method-classes-schema.js

@@ -37,12 +37,15 @@ function fieldBoundsError(record) {
     const payload = rpcCommandPayloadError(record) ?? rpcMessageLengthError(record);
     if (payload !== undefined)
         return payload;
-    if (record.type === "open_session" || record.type === "warm") {
+    if (record.type === "open_session" ||
+        record.type === "warm" ||
+        record.type === "park_session" ||
+        record.type === "claim_session") {
         const context = sessionContextError(record.context);
         if (context !== undefined)
             return context;
     }
-    if (record.type === "open_session")
+    if (record.type === "open_session" || record.type === "claim_session")
         return sessionRetryFallbackError(record.retryFallback) ?? sessionEnvShapeError(record.env);
     if (record.type === "set_retry_fallback")
         return sessionRetryFallbackError(record.retryFallback);

package/dist/modes/rpc/method-classes.d.ts

@@ -163,6 +163,8 @@ export declare const RPC_METHOD_CLASS: {
         readonly classify: typeof openSessionClass;
         readonly version: 2;
     };
+    readonly claim_session: "device_admin";
+    readonly park_session: "device_admin";
     readonly resume_session: "thread";
     readonly fork: "thread";
     readonly clone: "thread";

package/dist/modes/rpc/method-classes.js

@@ -207,6 +207,9 @@ export const RPC_METHOD_CLASS = {
     // thread by id; device_admin when the record names a host path, a permission preset or a tool environment
     new_session: { classify: newSessionClass, version: 1 },
     open_session: { classify: openSessionClass, version: 2 },
+    // Both commands require a cwd; claim has the same device authority as a cwd-naming open.
+    claim_session: "device_admin",
+    park_session: "device_admin",
     resume_session: "thread",
     fork: "thread",
     clone: "thread",

package/dist/modes/rpc/multi-session-host.js

@@ -177,7 +177,7 @@ export function createHostCore(options, writer, capabilities = parseClientCapabi
             return;
         }
         const command = parsed;
-        const response = await gate.dispatch(command.type === "open_session" &&
+        const response = await gate.dispatch((command.type === "open_session" || command.type === "claim_session") &&
             (delegated
                 ? command.retain_on_disconnect !== true
                 : machineOwned && command.retain_on_disconnect === undefined)

package/dist/modes/rpc/rpc-host-command-types.d.ts

@@ -255,7 +255,20 @@ type RpcCommandBody = RpcAttachmentCommand | (RpcSessionCommand & {
     context?: Record<string, string>;
 };
 /** Compact callers may identify their own admission on any correlated session request. */
-export type RpcCommand = RpcCommandBody & {
+export type RpcCommand = (RpcCommandBody | {
+    id?: string;
+    /** Build one invisible session for later claim; never an attachment. Requires `park_claim`. */
+    type: "park_session";
+    cwd: string;
+    kind?: SessionKind;
+    context?: Record<string, string>;
+} | (Omit<Extract<RpcCommandBody, {
+    type: "open_session";
+}>, "type" | "cwd"> & {
+    /** Consume one ready park. A miss returns `claimed: false` and never builds a session. */
+    type: "claim_session";
+    cwd: string;
+})) & {
     readonly admissionId?: string;
 };
 /** Stdin records: session/host commands plus extension-UI replies and progress, and host-request answers. */

package/dist/modes/rpc/rpc-host-response-types.d.ts

@@ -19,6 +19,27 @@ export interface RpcSessionPresence {
     readonly held: number;
 }
 export type RpcHostCommandResponse = {
+    id?: string;
+    type: "response";
+    command: "park_session";
+    success: true;
+    data: {
+        state: "parked" | "already_parked" | "full";
+    };
+} | {
+    id?: string;
+    type: "response";
+    command: "claim_session";
+    success: true;
+    data: {
+        claimed: false;
+    } | {
+        sessionId: string;
+        state: RpcSessionState;
+        attached?: boolean;
+        presence?: RpcSessionPresence;
+    };
+} | {
     id?: string;
     type: "response";
     command: "list_hands";

package/dist/modes/rpc/session-attachment-gate.js

@@ -8,6 +8,8 @@ export const ATTACH_GATE_EXEMPT = new Set([
     "unsubscribe_sessions",
     "get_subscription_limits",
     "warm",
+    "park_session",
+    "claim_session",
     "detach_connection",
     "open_session",
     "attach_session",

package/dist/modes/rpc/session-binding.d.ts

@@ -4,6 +4,7 @@ import type { RpcSessionEntry } from "./session-registry.ts";
 /** A session-owned adapter around the classic command and extension-UI wiring. */
 export interface RpcSessionBinding {
     handle(command: object): Promise<void>;
+    setClientCapabilities?(capabilities: readonly string[]): void;
     cancelPendingExtensionUiRequests?(): void;
     /** A connection of the shared host left this session (`close_session`, a dropped or detached connection). */
     connectionDetached?(connectionId: string): void;

package/dist/modes/rpc/session-binding.js

@@ -40,6 +40,8 @@ export async function createRpcSessionBinding(sessionId, entry, writer, requestC
         return carrier && record && firstOrdinal !== undefined ? { record, carrier, ordinal, firstOrdinal } : undefined;
     };
     const enqueueRecord = (record) => {
+        if (entry.speculative)
+            return;
         toolSpans.observe(record);
         const canonical = pairing?.take(record);
         const refused = pairing?.refused(record) === true;
@@ -103,6 +105,8 @@ export async function createRpcSessionBinding(sessionId, entry, writer, requestC
             writeInScope(record);
         };
         const writeStructuredInScope = bindToProviderScope((record) => {
+            if (entry.speculative)
+                return;
             writer.structuredLanes.accept(sessionId, record);
             const control = pairing?.structured(record);
             if (control && lane)
@@ -151,7 +155,7 @@ export async function createRpcSessionBinding(sessionId, entry, writer, requestC
                 rpcOwnersByConnection.clear();
             },
             publishLoadedSurfacesChanged: (previous, digest) => {
-                if (entry.scope.state !== "closed")
+                if (!entry.speculative && entry.scope.state !== "closed")
                     writer.publishLoadedSurfacesChanged(sessionId, previous, digest);
             },
             ...options,
@@ -171,6 +175,7 @@ export async function createRpcSessionBinding(sessionId, entry, writer, requestC
     });
     await handler.ready;
     return {
+        setClientCapabilities: (capabilities) => runWithProviderScope(entry.scope, () => handler.setClientCapabilities(capabilities)),
         handle: (command) => {
             if (writer.handleMcpForm(command))
                 return Promise.resolve();

package/dist/modes/rpc/session-connection-context.d.ts

@@ -7,6 +7,8 @@ export declare class SessionConnectionContext {
     private readonly delegationOf;
     constructor(ownerOf: (id: string) => ExtensionTransportOwner | undefined, delegationOf?: (id: string) => DelegationDescriptor | undefined);
     run<T>(id: string, task: () => T): T;
+    /** Host-owned background construction has no requesting transport or inherited delegation. */
+    outside<T>(task: () => T): T;
     /** The delegation the running line captured at its start, or undefined for a connection that never declared. */
     get delegation(): DelegationDescriptor | undefined;
     /**

package/dist/modes/rpc/session-connection-context.js

@@ -10,6 +10,10 @@ export class SessionConnectionContext {
         const delegation = this.delegationOf(id);
         return this.storage.run({ id, owner: this.ownerOf(id), ...(delegation === undefined ? {} : { delegation }) }, task);
     }
+    /** Host-owned background construction has no requesting transport or inherited delegation. */
+    outside(task) {
+        return this.storage.exit(task);
+    }
     /** The delegation the running line captured at its start, or undefined for a connection that never declared. */
     get delegation() {
         return this.storage.getStore()?.delegation;

package/dist/modes/rpc/session-registry-attach.d.ts

@@ -1,4 +1,6 @@
 import type { SessionPathReservations } from "./host-reservations.ts";
 import { type OpenRpcSession, type RpcSessionEntry, type RpcSessionLaunchProfile, type RpcSessionOpenOptions } from "./session-registry-types.ts";
 export declare function attachToOpenSession(entries: ReadonlyMap<string, RpcSessionEntry>, sessionPath: string, profile: RpcSessionLaunchProfile, options: RpcSessionOpenOptions | undefined, pathReservations: SessionPathReservations | undefined, now: number): Promise<OpenRpcSession>;
+/** The live launch choices shared by attach-on-open and claiming an already-built session. */
+export declare function applyAttachedProfile(entry: RpcSessionEntry, profile: RpcSessionLaunchProfile): void;
 //# sourceMappingURL=session-registry-attach.d.ts.map

package/dist/modes/rpc/session-registry-attach.js

@@ -102,6 +102,21 @@ export async function attachToOpenSession(entries, sessionPath, profile, options
         entry.retainOnDisconnect = true;
     if (!entry.durableSessionId)
         throw new RpcSessionRegistryError("session_path_in_use");
+    applyAttachedProfile(entry, profile);
+    entry.lastCommandAt = now;
+    if (wasParked) {
+        entry.lifecycleMutex = entry.lifecycleMutex.then(() => entry.runtime?.emitAttachmentEvent("session_resumed"));
+        await entry.lifecycleMutex;
+    }
+    return {
+        sessionId: handle,
+        durableSessionId: entry.durableSessionId,
+        sessionPath: entry.sessionPath,
+        attached: true,
+    };
+}
+/** The live launch choices shared by attach-on-open and claiming an already-built session. */
+export function applyAttachedProfile(entry, profile) {
     // The surface, browser engine and permission preset follow the client: an attach that names one
     // moves the live session to it; an attach without one keeps what the session has.
     if (profile.promptSurface !== undefined && profile.promptSurface !== entry.profile.promptSurface) {
@@ -121,16 +136,5 @@ export async function attachToOpenSession(entries, sessionPath, profile, options
         entry.profile = frozenProfile(withClientPreset(entry.profile, namedPreset));
         entry.runtime?.setPermissionPreset(namedPreset);
     }
-    entry.lastCommandAt = now;
-    if (wasParked) {
-        entry.lifecycleMutex = entry.lifecycleMutex.then(() => entry.runtime?.emitAttachmentEvent("session_resumed"));
-        await entry.lifecycleMutex;
-    }
-    return {
-        sessionId: handle,
-        durableSessionId: entry.durableSessionId,
-        sessionPath: entry.sessionPath,
-        attached: true,
-    };
 }
 //# sourceMappingURL=session-registry-attach.js.map

package/dist/modes/rpc/session-registry-claims.js

@@ -70,6 +70,8 @@ export async function settlePendingClaim(pending, sessionPath, graceMs) {
 /** Reconcile path and durable identity after runtime replacement. */
 export function syncRuntimeMetadata(entries, reservations, pathReservations) {
     for (const entry of entries) {
+        if (entry.speculative)
+            continue;
         const manager = entry.runtime?.session.sessionManager;
         if (!manager)
             continue;

package/dist/modes/rpc/session-registry-open.js

@@ -28,7 +28,7 @@ export async function openRegistrySession(host, requested, options) {
     const requestedDurableId = profile.durableSessionId;
     if (requestedDurableId !== undefined) {
         for (const entry of host.entries.values()) {
-            if (entry.state === "closed")
+            if (entry.state === "closed" || entry.speculative)
                 continue;
             if (entry.durableSessionId !== requestedDurableId)
                 continue;
@@ -101,7 +101,8 @@ export async function openRegistrySession(host, requested, options) {
     const { entry, storedProfile, runtimeProfile, sessionStartEvent, settleOpen } = opening;
     host.entries.set(handle, entry);
     claimSettled?.();
-    host.options.onSizeChange?.(host.entries.size);
+    if (!entry.speculative)
+        host.options.onSizeChange?.([...host.entries.values()].filter((item) => !item.speculative).length);
     const timer = startOpenTimer(`registry-open:${handle}`);
     try {
         const newSessionOptions = {
@@ -112,7 +113,9 @@ export async function openRegistrySession(host, requested, options) {
             ? host.options.sessionFileLoad === "blocking"
                 ? SessionManager.open(sessionPath, undefined, storedProfile.cwd, newSessionOptions)
                 : await SessionManager.openAsync(sessionPath, undefined, storedProfile.cwd, newSessionOptions, host.options.createSlicer?.())
-            : SessionManager.create(storedProfile.cwd, undefined, newSessionOptions);
+            : options?.speculative
+                ? SessionManager.inMemory(storedProfile.cwd, newSessionOptions)
+                : SessionManager.create(storedProfile.cwd, undefined, newSessionOptions);
         timer.mark("session_manager");
         entry.runtime = await runWithProviderScope(entry.scope, () => createAgentSessionRuntime(host.options.createRuntime, {
             cwd: manager.getCwd(),
@@ -125,19 +128,21 @@ export async function openRegistrySession(host, requested, options) {
         assertRequestedModelResolved(runtimeProfile, entry.runtime.diagnostics);
         ClientAdmissions.sealQueuedOnReplace(entry.runtime);
         EffectLedger.sealOnReplace(entry.runtime);
-        entry.durableSessionId = manager.getSessionId();
+        const durableSessionId = manager.getSessionId();
+        if (!entry.speculative)
+            entry.durableSessionId = durableSessionId;
         entry.sessionPath ??= manager.getSessionFile();
         // The accepted baseline precedes the open, so router admission and its reply come after it (R3.C1.1).
         // Gated like a worker incarnation's lane: with the flag off no session owns one (RULING-112).
         if (host.options.workerIsolate !== true && structuredLaneEnabled()) {
             entry.acceptance = new SessionAcceptanceLane(undefined, undefined, host.options.agentDir);
-            await entry.acceptance.generations.bind(entry.durableSessionId);
+            await entry.acceptance.generations.bind(durableSessionId);
             entry.acceptance.bootstrap({ transcript: manager.beginTranscriptJournal() });
             setSessionRecoveryEpoch(entry.runtime.session, entry.acceptance.recoveryEpoch);
         }
         entry.state = "open";
         settleOpen.resolve();
-        return { sessionId: handle, durableSessionId: entry.durableSessionId, sessionPath: entry.sessionPath };
+        return { sessionId: handle, durableSessionId, sessionPath: entry.sessionPath };
     }
     catch (error) {
         // Runtime construction may have started extensions, watchers, and provider
@@ -156,7 +161,8 @@ export async function openRegistrySession(host, requested, options) {
             }
             finally {
                 host.entries.delete(handle);
-                host.options.onSizeChange?.(host.entries.size);
+                if (!entry.speculative)
+                    host.options.onSizeChange?.([...host.entries.values()].filter((item) => !item.speculative).length);
                 if (sessionPath)
                     await releaseWithinGrace(host.teardownHost, handle, sessionPath);
             }

package/dist/modes/rpc/session-registry-opening.js

@@ -38,13 +38,14 @@ export function buildOpeningEntry(input) {
     openCompletion.catch(() => { });
     const entry = {
         state: "opening",
+        ...(options?.speculative ? { speculative: true } : {}),
         scope: new ProviderScope(),
         profile: storedProfile,
         ...sessionIdentity(storedProfile),
         sessionPath,
         reservationKey: sessionPath,
         cwd: storedProfile.cwd,
-        attachments: 1,
+        attachments: options?.speculative ? 0 : 1,
         retainOnDisconnect: options?.retainOnDisconnect === true,
         lastCommandAt: input.now,
         lifecycleMutex: Promise.resolve(),