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

package/dist/modes/rpc/host-park-ledger.d.ts

@@ -0,0 +1,19 @@
+import type { OpenRpcSession } from "./session-registry.ts";
+/** Owns both in-flight builds and ready parks, including the races with claim, expiry and shutdown. */
+export declare class HostParkLedger {
+    private readonly parks;
+    private readonly replacements;
+    private stopped;
+    private readonly close;
+    constructor(close: (opened: OpenRpcSession) => Promise<void>);
+    get size(): number;
+    park(key: string, build: () => Promise<OpenRpcSession>): Promise<"parked" | "already_parked" | "full">;
+    /** A claim never waits for a build, and consumes the ready park synchronously. */
+    take(key: string): OpenRpcSession | undefined;
+    finish(key: string): void;
+    replace(key: string, build: () => Promise<OpenRpcSession>): void;
+    /** Fences new builds synchronously; every build already accepted is closed when it finishes. */
+    stop(): Promise<void>;
+    private retire;
+}
+//# sourceMappingURL=host-park-ledger.d.ts.map

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/loopless-tool-handlers.d.ts

@@ -25,6 +25,12 @@ export type LooplessLoopHooks = (event: string, payload: JsonValue) => Promise<J
  * (`errors`).
  */
 export declare function extensionLoopHooks(runner: ExtensionRunner, twoSidedHome: TwoSidedHome, cwd: string, call: LoopHookCall): LooplessLoopHooks;
+/**
+ * The user's loop hooks, which a hand runs for a hosted loop: its non-builtin extensions (C7(c), K5) and the hooks
+ * builtin, which runs the user's shell hooks (C8). Every other builtin is the loop's own machinery (model, compaction,
+ * todo, search): each side loads its own builtins, so those run where the loop runs, as S29 never forwards builtins.
+ */
+export declare const isUserLoopHook: (extensionPath: string) => boolean;
 /** A message a loop hook sent during its call, for the loop to send with the same options. */
 export interface SentLoopMessage {
     readonly message: Parameters<LoopHookCallFacts["sendMessage"]>[0];

package/dist/modes/rpc/loopless-tool-handlers.js

@@ -1,5 +1,6 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { forwardToolEvents } from "../../core/extensions/two-sided-forwarding.js";
+import { hookModelOf, hookRequestOutputOf, parseHookRequestInput } from "../../core/hand/hook-contract.js";
 /**
  * A loopless runtime's own extensions' `tool_call`/`tool_result` handlers, emitted as a session emits them. On a hand
  * (a call that carries its nested requests), a two-sided extension's handlers are forwarded to the loop that owns the
@@ -78,6 +79,18 @@ export function extensionLoopHooks(runner, twoSidedHome, cwd, call) {
                 ...(preview === undefined ? {} : { preview }),
             })));
         }
+        if (event === "before_provider_request") {
+            // The hosted loop's request hooks (CK21): the user's hooks get the projected input (payload and effective model,
+            // no headers), and the reply's `output` carries the payload they produced.
+            const input = parseHookRequestInput(payload.input);
+            const model = hookModelOf(input);
+            return call.run(sessionId, cwd, idle, (effects) => dispatchLoopHook(runner, call, effects, async () => ({
+                output: hookRequestOutputOf(input, await runner.emitBeforeProviderRequest(structuredClone(input.payload), undefined, undefined, {
+                    only: isUserLoopHook,
+                    ...(model === undefined ? {} : { model }),
+                })),
+            })));
+        }
         throw new Error(`no loop hooks run on a hand for ${event}`);
     };
 }
@@ -86,7 +99,7 @@ export function extensionLoopHooks(runner, twoSidedHome, cwd, call) {
  * builtin, which runs the user's shell hooks (C8). Every other builtin is the loop's own machinery (model, compaction,
  * todo, search): each side loads its own builtins, so those run where the loop runs, as S29 never forwards builtins.
  */
-const isUserLoopHook = (extensionPath) => !extensionPath.startsWith("<builtin:") || extensionPath === "<builtin:hooks>";
+export const isUserLoopHook = (extensionPath) => !extensionPath.startsWith("<builtin:") || extensionPath === "<builtin:hooks>";
 const INPUT_SOURCES = ["interactive", "rpc", "extension"];
 const INPUT_ATTRIBUTIONS = ["user", "agent"];
 const STREAMING_BEHAVIORS = ["steer", "followUp"];

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;