@code-yeongyu/senpi 2026.11.2-3 → 2026.11.3-2

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

@@ -923,6 +923,10 @@ export declare const SESSION_RECORD_SCHEMAS: {
     } & {
         readonly width: Type.TInteger;
         readonly capabilities: Type.TOptional<Type.TArray<Type.TString>>;
+        readonly remoteOrigin: Type.TOptional<Type.TObject<{
+            deviceId: Type.TString;
+            deviceName: Type.TOptional<Type.TString>;
+        }>>;
     }>;
 };
 //# sourceMappingURL=method-classes-schema-session.d.ts.map

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

@@ -198,6 +198,7 @@ const SURFACE_AND_ACCOUNT_SCHEMAS = {
     set_client_info: session("set_client_info", {
         width: Type.Integer({ minimum: 1, maximum: 100_000 }),
         capabilities: Opt(Strings),
+        remoteOrigin: Opt(Type.Object({ deviceId: Id, deviceName: OptId }, { additionalProperties: false })),
     }),
 };
 export const SESSION_RECORD_SCHEMAS = {

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

@@ -1268,6 +1268,10 @@ export declare const RPC_INBOUND_SCHEMAS: {
     } & {
         readonly width: import("typebox").TInteger;
         readonly capabilities: import("typebox").TOptional<import("typebox").TArray<import("typebox").TString>>;
+        readonly remoteOrigin: import("typebox").TOptional<import("typebox").TObject<{
+            deviceId: import("typebox").TString;
+            deviceName: import("typebox").TOptional<import("typebox").TString>;
+        }>>;
     }>;
 };
 export type RpcInboundValidation = {

package/dist/modes/rpc/protocol-identity.js

@@ -19,6 +19,7 @@ import { parseArgs, resolveSessionRuntime } from "../../cli/args.js";
 import { getAgentDir } from "../../config.js";
 import { engineBuildIdentity } from "../../core/engine-build-identity.js";
 import { HOST_GENERATION_ENV, HOST_INSTANCE_ID_ENV } from "./host-identity-env.js";
+import { RPC_METHOD_CLASSES_DIGEST, RPC_METHOD_CLASSES_VERSION } from "./method-classes.js";
 export { HOST_GENERATION_ENV, HOST_INSTANCE_ID_ENV };
 /** Identity of THIS host process, fixed for its lifetime. */
 const INSTANCE_ID = resolveInstanceId(process.env[HOST_INSTANCE_ID_ENV]);
@@ -69,6 +70,7 @@ export function protocolIdentity(agentDir = resolve(getAgentDir())) {
         engineOrdinal: build.ordinal,
         launch_profile: cachedProfile,
         agentDir,
+        method_classes: { version: RPC_METHOD_CLASSES_VERSION, digest: RPC_METHOD_CLASSES_DIGEST },
     };
 }
 //# sourceMappingURL=protocol-identity.js.map

package/dist/modes/rpc/remote-origin.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The remote device a connection speaks for (senpi#5475, omo-relay-daemon#184 P5).
+ *
+ * A relay forwarder opens one engine connection per remote sender and declares, through its own
+ * `set_client_info`, which device that connection speaks for. Every dialog a command of that connection raises
+ * then carries the value as `remoteOrigin`, so the host's desktop and TUI can label it "Requested from <device>".
+ * A connection that never declared one is local, and its dialogs carry no `remoteOrigin`. The engine copies only
+ * this declared value, never a free-form client name. `set_client_info` is `connection_local` in the method-class
+ * table, so a forwarded record can never set or change it.
+ */
+export interface RpcRemoteOrigin {
+    readonly deviceId: string;
+    readonly deviceName?: string;
+}
+/**
+ * Validates a `set_client_info.remoteOrigin` against what the connection already declared, before anything of the
+ * declaration is committed: the origin to record (none when the field is absent), or the refusal to answer.
+ */
+export declare function remoteOriginDeclaration(value: unknown, accepts: (origin: RpcRemoteOrigin) => boolean): {
+    readonly origin: RpcRemoteOrigin | undefined;
+} | {
+    readonly refusal: string;
+};
+export declare function sameRemoteOrigin(a: RpcRemoteOrigin, b: RpcRemoteOrigin): boolean;
+export declare function remoteOriginField(origin: RpcRemoteOrigin | undefined): {
+    remoteOrigin?: RpcRemoteOrigin;
+};
+export declare function originField(origin: RpcRemoteOrigin | undefined): {
+    origin?: RpcRemoteOrigin;
+};
+//# sourceMappingURL=remote-origin.d.ts.map

package/dist/modes/rpc/remote-origin.js

@@ -0,0 +1,58 @@
+/**
+ * The remote device a connection speaks for (senpi#5475, omo-relay-daemon#184 P5).
+ *
+ * A relay forwarder opens one engine connection per remote sender and declares, through its own
+ * `set_client_info`, which device that connection speaks for. Every dialog a command of that connection raises
+ * then carries the value as `remoteOrigin`, so the host's desktop and TUI can label it "Requested from <device>".
+ * A connection that never declared one is local, and its dialogs carry no `remoteOrigin`. The engine copies only
+ * this declared value, never a free-form client name. `set_client_info` is `connection_local` in the method-class
+ * table, so a forwarded record can never set or change it.
+ */
+const MAX_DEVICE_ID_CHARACTERS = 256;
+const MAX_DEVICE_NAME_CHARACTERS = 256;
+const REMOTE_ORIGIN_INVALID = "remote_origin_invalid: remoteOrigin must be { deviceId: non-empty string, deviceName?: non-empty string }";
+const REMOTE_ORIGIN_FIXED = "remote_origin_fixed: a connection's remoteOrigin cannot change after it is declared";
+function boundedText(value, max) {
+    return typeof value === "string" && value.length > 0 && value.length <= max;
+}
+/** The declared origin, `undefined` when the field is absent, or `"invalid"` for any other shape. */
+function parseRemoteOrigin(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return "invalid";
+    const deviceId = Reflect.get(value, "deviceId");
+    const deviceName = Reflect.get(value, "deviceName");
+    const keys = Object.keys(value);
+    if (keys.some((key) => key !== "deviceId" && key !== "deviceName"))
+        return "invalid";
+    if (!boundedText(deviceId, MAX_DEVICE_ID_CHARACTERS))
+        return "invalid";
+    if (deviceName === undefined)
+        return { deviceId };
+    if (!boundedText(deviceName, MAX_DEVICE_NAME_CHARACTERS))
+        return "invalid";
+    return { deviceId, deviceName };
+}
+/**
+ * Validates a `set_client_info.remoteOrigin` against what the connection already declared, before anything of the
+ * declaration is committed: the origin to record (none when the field is absent), or the refusal to answer.
+ */
+export function remoteOriginDeclaration(value, accepts) {
+    const origin = parseRemoteOrigin(value);
+    if (origin === "invalid")
+        return { refusal: REMOTE_ORIGIN_INVALID };
+    if (origin !== undefined && !accepts(origin))
+        return { refusal: REMOTE_ORIGIN_FIXED };
+    return { origin };
+}
+export function sameRemoteOrigin(a, b) {
+    return a.deviceId === b.deviceId && a.deviceName === b.deviceName;
+}
+export function remoteOriginField(origin) {
+    return origin === undefined ? {} : { remoteOrigin: origin };
+}
+export function originField(origin) {
+    return origin === undefined ? {} : { origin };
+}
+//# sourceMappingURL=remote-origin.js.map

package/dist/modes/rpc/rpc-protocol-info-types.d.ts

@@ -33,6 +33,14 @@ export interface RpcProtocolIdentity {
     readonly launch_profile: RpcLaunchProfile;
     /** Absolute agent directory this host reads and writes; a handoff from another agent dir is refused. */
     readonly agentDir: string;
+    /**
+     * The inbound method-class table this engine runs (`method-classes.ts`): a remote forwarder classifies with its
+     * own copy only while that copy's digest equals `digest`.
+     */
+    readonly method_classes: {
+        readonly version: number;
+        readonly digest: string;
+    };
 }
 export interface RpcProtocolInfo extends RpcProtocolIdentity {
     /** Present only on a public POSIX endpoint's answer to a challenge (wire contract v1.1). */

package/dist/modes/rpc/rpc-question-types.d.ts

@@ -1,3 +1,4 @@
+import type { RpcRemoteOrigin } from "./remote-origin.ts";
 /** One question in an RPC `question` UI request. Matches canonical QuestionRequest.questions. */
 export type RpcQuestionSpec = {
     id: string;
@@ -25,6 +26,8 @@ export type RpcQuestionUiRequest = {
     questions: RpcQuestionSpec[];
     /** The connection whose command raised the question, or `"agent"` when no connection's command was dispatching. */
     raisedBy?: string;
+    /** The remote device the raising connection speaks for (senpi#5475); absent for a local connection. */
+    remoteOrigin?: RpcRemoteOrigin;
     timeout: number;
     askedAtMs: number;
     deadlineAtMs: number;
@@ -35,6 +38,7 @@ export type RpcExtensionUIRequest = {
     type: "extension_ui_request";
     id: string;
     method: "select";
+    remoteOrigin?: RpcRemoteOrigin;
     /** Permanent MCP env grant; only a grant_select presentation may answer. */
     grantSelect?: boolean;
     title: string;
@@ -50,10 +54,12 @@ export type RpcExtensionUIRequest = {
     title: string;
     message: string;
     timeout?: number;
+    remoteOrigin?: RpcRemoteOrigin;
 } | {
     type: "extension_ui_request";
     id: string;
     method: "input";
+    remoteOrigin?: RpcRemoteOrigin;
     secret?: boolean;
     deadlineAtMs?: number;
     title: string;
@@ -67,6 +73,7 @@ export type RpcExtensionUIRequest = {
     method: "editor";
     title: string;
     prefill?: string;
+    remoteOrigin?: RpcRemoteOrigin;
 } | {
     type: "extension_ui_request";
     id: string;

package/dist/modes/rpc/rpc-question-types.js

@@ -1,5 +1,2 @@
-// ============================================================================
-// Extension UI Events (stdout)
-// ============================================================================
 export {};
 //# sourceMappingURL=rpc-question-types.js.map

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

@@ -11,7 +11,7 @@ import type { ThinkingLevelSource } from "../../core/session-thinking-memory.ts"
 import type { EffectStatus } from "./effect-record.ts";
 import type { RpcSlashCommand } from "./rpc-command-surface.ts";
 import type { RpcEvalCell, RpcEvalCellSnapshot } from "./rpc-result-types.ts";
-import type { RpcAuthProvider, RpcLoadedExtension, RpcLoadedMcpServer, RpcProviderAccount, RpcSessionState } from "./rpc-session-state-types.ts";
+import type { RpcAuthProvider, RpcAuthStoreError, RpcLoadedExtension, RpcLoadedMcpServer, RpcProviderAccount, RpcSessionState } from "./rpc-session-state-types.ts";
 import type { RpcSnapshot } from "./snapshot-types.ts";
 export type RpcReadResponse = {
     id?: string;
@@ -215,6 +215,7 @@ export type RpcReadResponse = {
     success: true;
     data: {
         providers: RpcAuthProvider[];
+        storeError?: RpcAuthStoreError;
     };
 } | {
     id?: string;

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

@@ -6,6 +6,7 @@ import type { ClientMessageIdentity } from "../../core/client-message-identity.t
 import type { SessionEntry } from "../../core/session-manager.ts";
 import type { ToolBarrierSpec } from "../../core/tool-barrier.ts";
 import type { RpcRecoveryCommand } from "./rpc-recovery-command-types.ts";
+import type { RpcRemoteOrigin } from "./remote-origin.ts";
 import type { RpcSessionModelEntry } from "./rpc-session-state-types.ts";
 export type RpcSessionCommand = {
     id?: string;
@@ -521,6 +522,8 @@ export type RpcSessionCommand = {
     type: "set_client_info";
     width: number;
     capabilities?: string[];
+    /** Declared by a relay forwarder for the remote device this connection speaks for (senpi#5475). */
+    remoteOrigin?: RpcRemoteOrigin;
 };
 /** What `steer`/`follow_up` do on an idle session: queue (default) or start a turn. */
 export type RpcWhenIdle = "queue" | "start";

package/dist/modes/rpc/rpc-session-state-types.d.ts

@@ -27,6 +27,16 @@ export interface RpcAuthProvider {
     /** Where the provider is defined, so a client can name the file or extension to edit (senpi#4328). */
     origin?: ProviderOrigin;
 }
+/**
+ * `get_auth_providers` `storeError`: auth.json exists but could not be loaded, so stored sign-ins read
+ * as unconfigured and every write is refused until it is repaired. `write_back_failed` is the exception:
+ * the file was read, so its sign-ins stay configured and writes are not refused (senpi#4413).
+ * Never a path or contents.
+ */
+export interface RpcAuthStoreError {
+    kind: "malformed_json" | "invalid_format" | "unreadable" | "write_back_failed";
+    reason: string;
+}
 /** Auth status mirror (no credential values), from getProviderAuthStatus. */
 export interface RpcAuthStatus {
     configured: boolean;

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

@@ -16,7 +16,7 @@ export type { EditAssistantMessageResult, EditUserMessageResult, NavigateTreeRes
 export type { RpcWhenIdle } from "./rpc-session-command-types.ts";
 export { STEER_WHEN_IDLE_CAPABILITY, USER_ACTIVITY_CAPABILITY } from "./rpc-session-command-types.ts";
 export type { RpcAccountFailoverEvent, RpcAuthAccountsChangedEvent, RpcExtensionEvent, RpcHighReasoningWarningEvent, RpcLoadedSurfacesChangedEvent, RpcModelChangedEvent, RpcOpenQueuedEvent, RpcPendingInputUpdateEvent, RpcServiceTierChangedEvent, RpcSessionClosedEvent, RpcSessionClosedReason, RpcSessionOpenedEvent, RpcSessionParkedEvent, RpcSessionReplacedEvent, RpcSettingsSourceSelectedEvent, RpcSkillInvocationEvent, RpcThinkingLevelChangedEvent, } from "./rpc-session-event-types.ts";
-export type { RpcAuthProvider, RpcAuthStatus, RpcLoadedExtension, RpcLoadedMcpServer, RpcMcpServerStatus, RpcProviderAccount, RpcSessionModelEntry, RpcSessionState, } from "./rpc-session-state-types.ts";
+export type { RpcAuthProvider, RpcAuthStatus, RpcAuthStoreError, RpcLoadedExtension, RpcLoadedMcpServer, RpcMcpServerStatus, RpcProviderAccount, RpcSessionModelEntry, RpcSessionState, } from "./rpc-session-state-types.ts";
 export type { SessionEffectStatusRecord as RpcEffectStatusEvent } from "./session-effect-status.ts";
 export type { SessionStatusRecord as RpcSessionStatusEvent } from "./session-status.ts";
 //# sourceMappingURL=rpc-types.d.ts.map

package/dist/modes/rpc/runtime-factory-loopless.d.ts

@@ -0,0 +1,57 @@
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import type { AgentSessionLaunchProfile } from "../../core/agent-session-runtime.ts";
+import { type AgentSessionRuntimeDiagnostic } from "../../core/agent-session-services.ts";
+import type { InlineExtension } from "../../core/extensions/types.ts";
+import { type ToolDefinitionEntry } from "../../core/runtime/bootstrap.ts";
+import { SettingsManager } from "../../core/settings-manager.ts";
+import type { CliRuntimeConfiguration } from "../../main.ts";
+import { type LooplessExecuteGrant } from "./loopless-execute-grant.ts";
+/**
+ * A session worker's runtime with the agent loop removed (brain/hand split, senpi#5413): the same
+ * built-in and extension tools a full session serves, executed one call at a time, with no agent loop,
+ * no model binding and no transcript. Its extension runtime is never bound to a loop, so an extension
+ * that tries to drive one (`pi.sendUserMessage`, `pi.setModel`, ...) is refused.
+ */
+export interface LooplessRuntime {
+    readonly cwd: string;
+    /** Every tool this runtime serves: built-ins first, then extension tools, a later name replacing an earlier one. */
+    readonly definitions: ReadonlyMap<string, ToolDefinitionEntry>;
+    /** What building the runtime reported: settings, extension load and `project_trust` handler diagnostics. */
+    readonly diagnostics: readonly AgentSessionRuntimeDiagnostic[];
+    /**
+     * Runs one tool call: argument preparation and schema validation as the loop does, then the tool. An unknown
+     * name is refused before anything runs; invalid arguments and a failing tool come back as an `isError` result.
+     *
+     * It does NOT run the extensions' `tool_call`/`tool_result` handlers (permission checks among them): where those
+     * run for a call that reaches a tool-execution-only process is decided by the remote tool executor that calls
+     * this runtime, including forwarding a two-sided extension's handlers to the process that owns the session.
+     * Until that executor exists, a runtime refuses every call unless it was built with a grant from the closed
+     * allowlist in `loopless-execute-grant.ts` (the in-process test harness only).
+     */
+    execute(name: string, toolCallId: string, params: unknown, signal?: AbortSignal): Promise<AgentToolResult<unknown>>;
+    /** Marks its extension contexts stale, then closes the tool work and the tool child it still runs. */
+    dispose(): Promise<void>;
+}
+export interface LooplessRuntimeProfile {
+    cwd: string;
+    launchProfile?: Readonly<AgentSessionLaunchProfile>;
+}
+export type LooplessRuntimeFactory = (profile: LooplessRuntimeProfile) => Promise<LooplessRuntime>;
+export declare class LooplessToolNotFoundError extends Error {
+    readonly toolName: string;
+    constructor(toolName: string);
+}
+/**
+ * Builds loopless runtimes from the same launch configuration as `createCliRuntimeFactory`: the same
+ * cwd-bound services (settings, project trust, model registry, extensions and their flags), then the tool
+ * registry through `bootstrapRuntime()` / `buildToolRegistry()` (senpi#5222) on a runner without a session
+ * (senpi#5223), so nothing is ever written to a session file. Tools are placed by the same tool-child runtime
+ * a session builds (senpi#5227), so `--tool-runtime child` runs child-placed work on this runtime's own child.
+ */
+export declare function createLooplessRuntimeFactory(configuration: CliRuntimeConfiguration, local?: {
+    extensionFactories?: InlineExtension[];
+    startupSettingsManager?: SettingsManager;
+    /** Required for `execute`; see `loopless-execute-grant.ts`. */
+    executeGrant?: LooplessExecuteGrant;
+}): LooplessRuntimeFactory;
+//# sourceMappingURL=runtime-factory-loopless.d.ts.map

package/dist/modes/rpc/runtime-factory-loopless.js

@@ -0,0 +1,131 @@
+import { randomUUID } from "node:crypto";
+import { createAgentSessionServices } from "../../core/agent-session-services.js";
+import { bootstrapRuntime, buildToolRegistry } from "../../core/runtime/bootstrap.js";
+import { SettingsManager } from "../../core/settings-manager.js";
+import { childModuleRoots } from "../../core/tool-dispatch/offload.js";
+import { createToolChildRuntime } from "../../core/tool-dispatch/tool-child-runtime.js";
+import { builtInExtensions } from "../../extensions/index.js";
+import { looplessToolFilters, resolveCliPaths, resolveLooplessSettings } from "./loopless-runtime-settings.js";
+import { isLooplessExecuteGranted, LooplessExecuteRefusedError, } from "./loopless-execute-grant.js";
+import { runLooplessToolCall } from "./loopless-tool-call.js";
+import { toolChildModuleRoots } from "./tool-child/session-child.js";
+export class LooplessToolNotFoundError extends Error {
+    constructor(toolName) {
+        super(`loopless_tool_not_found: ${toolName}`);
+        this.toolName = toolName;
+    }
+}
+/**
+ * Builds loopless runtimes from the same launch configuration as `createCliRuntimeFactory`: the same
+ * cwd-bound services (settings, project trust, model registry, extensions and their flags), then the tool
+ * registry through `bootstrapRuntime()` / `buildToolRegistry()` (senpi#5222) on a runner without a session
+ * (senpi#5223), so nothing is ever written to a session file. Tools are placed by the same tool-child runtime
+ * a session builds (senpi#5227), so `--tool-runtime child` runs child-placed work on this runtime's own child.
+ */
+export function createLooplessRuntimeFactory(configuration, local = {}) {
+    const { parsed, agentDir, toolRuntime } = configuration;
+    const extensionFactories = local.extensionFactories ?? builtInExtensions;
+    const startupSettingsManager = local.startupSettingsManager ?? SettingsManager.create(configuration.cwd, configuration.agentDir);
+    return async (profile) => {
+        const { cwd } = profile;
+        const diagnostics = [];
+        const { settingsManager, flagValues, reloadOptions } = await resolveLooplessSettings(configuration, startupSettingsManager, profile, diagnostics);
+        const services = await createAgentSessionServices({
+            cwd,
+            agentDir,
+            settingsManager,
+            modelRuntimeSignal: AbortSignal.timeout(15_000),
+            extensionFlagValues: flagValues,
+            ...(reloadOptions ? { resourceLoaderReloadOptions: reloadOptions } : {}),
+            resourceLoaderOptions: {
+                sessionKind: profile.launchProfile?.sessionKind,
+                sessionContext: profile.launchProfile?.sessionContext,
+                additionalExtensionPaths: resolveCliPaths(cwd, parsed.extensions),
+                additionalSkillPaths: resolveCliPaths(cwd, parsed.skills),
+                additionalPromptTemplatePaths: resolveCliPaths(cwd, parsed.promptTemplates),
+                additionalThemePaths: resolveCliPaths(cwd, parsed.themes),
+                noExtensions: parsed.noExtensions,
+                noSkills: parsed.noSkills,
+                noPromptTemplates: parsed.noPromptTemplates,
+                noThemes: parsed.noThemes,
+                noContextFiles: parsed.noContextFiles,
+                extensionFactories,
+            },
+        });
+        const extensionsResult = services.resourceLoader.getExtensions();
+        diagnostics.push(...services.diagnostics, ...extensionsResult.errors.map(({ path, error }) => ({
+            type: "warning",
+            message: `Failed to load extension "${path}": ${error}`,
+        })), ...(extensionsResult.warnings ?? []).map(({ path, warning }) => ({
+            type: "warning",
+            message: `Extension package "${path}": ${warning}`,
+        })));
+        let execute = () => Promise.reject(new Error("Loopless runtime is not ready"));
+        let toolNames = () => [];
+        const toolChildRuntime = createToolChildRuntime({
+            toolRuntime: toolRuntime ?? "in-process",
+            agentDir,
+            scopeId: `loopless-${randomUUID()}`,
+            cwd: services.cwd,
+            moduleRoots: () => [
+                ...toolChildModuleRoots(runtime.extensionRunner.getAllRegisteredTools()),
+                ...childModuleRoots(runtime.extensionRunner.getAllChildModules()),
+            ],
+            hostCallDeps: {
+                cwd: services.cwd,
+                executeNested: async (_parentToolCallId, name, args, signal) => {
+                    const toolCall = { type: "toolCall", id: `nested-${randomUUID()}`, name, arguments: {} };
+                    const result = await execute(name, toolCall.id, args, signal);
+                    return { toolCall, result, isError: result.isError === true };
+                },
+                callableToolNames: () => toolNames(),
+                target: () => undefined,
+                filesystemPolicy: () => runtime.filesystemPolicy,
+            },
+            onRecord: () => { },
+        });
+        const { dispatcher, toolChild } = toolChildRuntime;
+        const runtime = bootstrapRuntime({
+            cwd: services.cwd,
+            settingsManager: services.settingsManager,
+            extensionsResult,
+            modelRegistry: services.modelRegistry,
+            toolDispatcher: dispatcher,
+        });
+        const registry = buildToolRegistry({
+            baseToolDefinitions: runtime.baseToolDefinitions,
+            runner: runtime.extensionRunner,
+            dispatcher,
+            ...looplessToolFilters(parsed, services.settingsManager),
+        });
+        toolNames = () => [...registry.toolRegistry.keys()];
+        execute = (name, toolCallId, params, signal) => {
+            if (!isLooplessExecuteGranted(local.executeGrant))
+                return Promise.reject(new LooplessExecuteRefusedError("no executor runs the tool_call/tool_result handlers for this runtime yet"));
+            const tool = registry.toolRegistry.get(name);
+            if (tool === undefined)
+                return Promise.reject(new LooplessToolNotFoundError(name));
+            return runLooplessToolCall(tool, {
+                toolCallId,
+                params,
+                ...(signal ? { signal } : {}),
+            });
+        };
+        return {
+            cwd: services.cwd,
+            definitions: registry.definitions,
+            diagnostics,
+            execute: (name, toolCallId, params, signal) => execute(name, toolCallId, params, signal),
+            dispose: async () => {
+                // Stale first, as a session disposes: a close that fails must not leave the contexts usable.
+                runtime.extensionRunner.invalidate("This loopless runtime was disposed.");
+                // Both closes run to the end; the first failure is then reported to the caller.
+                const closed = await Promise.allSettled([dispatcher.dispose(), toolChild?.close()]);
+                const failure = closed.find((outcome) => outcome.status === "rejected");
+                if (failure !== undefined)
+                    throw failure.reason;
+            },
+        };
+    };
+}
+//# sourceMappingURL=runtime-factory-loopless.js.map

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

@@ -4,7 +4,7 @@ import { createRegistryWarm } from "./host-warm.js";
 import { refreshesSessionActivity } from "./session-command-activity.js";
 import { publishedSessionContext } from "./session-context-patch.js";
 import { attachLiveSession, markPathAttached } from "./session-live-attachment.js";
-import { syncRuntimeMetadata } from "./session-registry-claims.js";
+import { beginPendingClaim, syncRuntimeMetadata } from "./session-registry-claims.js";
 import { openRegistrySession } from "./session-registry-open.js";
 import { RpcSessionRegistryError, } from "./session-registry-types.js";
 import { beginSessionClose, closeMarkedSession, closeSession } from "./session-teardown.js";
@@ -44,8 +44,17 @@ export class RpcSessionRegistry {
                 return deleted;
             },
             releaseReservation: async (key) => {
-                await this.options.pathReservations?.release(key);
-                this.reservations.delete(key);
+                // Close may finish at its grace deadline before removal settles. Keep
+                // that work visible to reopen even after the closing entry is gone. A failed removal
+                // still gives the path back: no entry is left to ever release it later.
+                const settle = beginPendingClaim(this.pendingClaims, key);
+                try {
+                    await this.options.pathReservations?.release(key);
+                }
+                finally {
+                    this.reservations.delete(key);
+                    settle();
+                }
             },
             markDetached: (key) => this.options.pathReservations?.setAttached(key, false),
             now: () => this.now(),

package/dist/modes/rpc/session-worker-client.js

@@ -5,6 +5,7 @@ import { createWebViewBroker } from "../../core/webview/webview-broker.js";
 import { workerCapabilities } from "./worker-client-capabilities.js";
 import { captureAdmissionReply, withAdmissionReply } from "./compact-admission-reply.js";
 import { roleConnection } from "./connection-roles.js";
+import { originField } from "./remote-origin.js";
 import { answeredUiRequestId, isGrantSelectRequest, refusedExtensionUiResponse } from "./extension-ui-response.js";
 import { enqueueLegacyRecord } from "./legacy-record-depth.js";
 import { SessionAcceptanceLane } from "./session-acceptance-lane.js";
@@ -199,6 +200,7 @@ export class SessionWorkerClient {
                     command,
                     connection,
                     roles: options.connectionRoles?.rolesOf(roleConnection(connection)),
+                    ...originField(options.connectionRoles?.originOf(connection)),
                     ...(owner === undefined ? {} : { owner }),
                 });
             },

package/dist/modes/rpc/session-worker-protocol.d.ts

@@ -1,3 +1,4 @@
+import type { RpcRemoteOrigin } from "./remote-origin.ts";
 import type { BrowserEngine } from "../../core/browser-engine.ts";
 import type { McpFormInput, McpFormOutcome } from "../../core/mcp-form-types.ts";
 import type { RecoveryCarrier } from "../../core/session-recovery-identity.ts";
@@ -96,6 +97,8 @@ export type HostToSessionWorker = {
     command: object;
     connection?: string;
     roles?: readonly string[];
+    /** The remote device the connection declared on the host (senpi#5475); the isolate adopts it. */
+    origin?: RpcRemoteOrigin;
     /** The gate the host captured at ingress, before its first await (#4728). */
     owner?: ExtensionOwnerWire;
 }

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

@@ -338,6 +338,8 @@ async function handle(message) {
                 throw new Error("session_closing");
             if (message.roles !== undefined)
                 connectionRoles.adopt(roleConnection(message.connection), message.roles);
+            if (message.origin !== undefined)
+                connectionRoles.declareOrigin(roleConnection(message.connection), message.origin);
             const activeBinding = binding;
             const run = () => activeBinding.handle(message.command);
             await workerAdmissionCommand(message, writer, issuedOwners, run);

package/docs/development.md

@@ -70,7 +70,7 @@ Never use `__dirname` directly for package assets.
 ```bash
 bun run test            # Vitest across workspaces (skips live-API; default test runner)
 ./pi-test.sh        # Launch the CLI from source via tsx for manual testing (--no-env unsets API keys)
-bun run check       # oxlint + oxfmt + lint ratchet + tsc + browser-smoke check (pre-commit equivalent)
+bun run check       # oxlint + bun fmt + lint ratchet + tsc + browser-smoke check (pre-commit equivalent)
 ```
 
 Live-API tests are env-gated vitest tests. Set `PI_ENABLE_LIVE_API_TESTS=1` (or a per-provider flag from `packages/ai/test/live-api-gates.ts`) plus the provider API keys, then run `bun run test`.

package/docs/engine-socket/fixtures/admission-routes/c-baseline.json

@@ -43,9 +43,9 @@
 				"hint": "restart_from_catalog",
 				"retryAfterMs": 0
 			},
-			"length": 1000,
-			"digest": "131dc6a4a4e49873ce5d5d0330f81816be72c8a12c25dec7d14d4fe2c9cc32e4",
-			"bytes": "ewAiAGYAbwByAG0AYQB0ACIAOgAiAHMAZQBuAHAAaQAtAHIAZQBjAG8AdgBlAHIAeQAtAG0AYQBuAGkAZgBlAHMAdAAiACwAIgB2AGUAcgBzAGkAbwBuACIAOgAxACwAIgBzAG8AYwBrAGUAdABFAHAAbwBjAGgAIgA6AHsAIgBpAGQAIgA6ACIAcwBvAGMAawBlAHQALQAxACIAfQAsACIAYQBkAG0AaQBzAHMAaQBvAG4ASQBkACIAOgB7ACIAaQBkACIAOgAiAGcAbwBsAGQAZQBuAC0AYQAiAH0ALAAiAHIAbwB1AHQAZQBLAGkAbgBkACIAOgAiAG8AcgBkAGkAbgBhAHIAeQAiACwAIgBzAGUAcwBzAGkAbwBuACIAOgB7ACIAaQBkACIAOgAiAHIAcABjAC0AMQAiAH0ALAAiAHMAZQBzAHMAaQBvAG4ARQBwAG8AYwBoACIAOgB7ACIAaQBkACIAOgAiADAAMAAwADAAMAAwADAAMAAtADAAMAAwADAALQA0ADAAMAAwAC0AOAAwADAAMAAtADAAMAAwADAAMAAwADAAMAAwADAAMAAxACIAfQAsACIAZwBlAG4AZQByAGEAdABpAG8AbgAiADoAMQAsACIAcwBlAHEAdQBlAG4AYwBlACIAOgAwACwAIgBoAGkAcwB0AG8AcgB5AFYAZQByAHMAaQBvAG4AIgA6ADUALAAiAHQAbwBrAGUAbgAiADoAewAiAGkAZAAiADoAIgBzAG8AYwBrAGUAdAAtADEAOgAxACIAfQAsACIAbABlAGEAZgAiADoAewAiAGkAZAAiADoAIgAwADAAMAAwADAAMAAwADEAIgB9ACwAIgBhAGMAdABpAHYAZQBNAGUAcwBzAGEAZwBlACIAOgBuAHUAbABsACwAIgB0AHUAcgBuACIAOgBuAHUAbABsACwAIgBjAGgAZQBjAGsAcABvAGkAbgB0AEQAaQBnAGUAcwB0ACIAOgAiADEAYgBiAGMAYQBkADIAOQAzADIAMABmADIAMAA4ADQANwBhADUAMQA1AGMAYwA4ADUANAAwADYAMwBjAGQAYQAwAGQAZABhAGUAYQAyADAAYwBkAGMAZgBmADQANQBlAGIANgBiADUAZQAwAGUAOQBlAGUAMQA1AGYAYgBkADQAIgAsACIAYwBhAHQAYQBsAG8AZwBSAG8AbwB0ACIAOgAiAGMALQAwADAAMAAwADAAMAAwADAAMAAwADAAMAAwADAAMAAxACIALAAiAGMAYQB0AGEAbABvAGcAUgBvAG8AdABMAGUAbgBnAHQAaAAiADoAMwA5ADQANgB9AA=="
+			"length": 1230,
+			"digest": "afc0506ef0b5e09ae70818c0b435b2fa633d3536d44f6e357950aad78d0102f9",
+			"bytes": "ewAiAGYAbwByAG0AYQB0ACIAOgAiAHMAZQBuAHAAaQAtAHIAZQBjAG8AdgBlAHIAeQAtAG0AYQBuAGkAZgBlAHMAdAAiACwAIgB2AGUAcgBzAGkAbwBuACIAOgAxACwAIgBzAG8AYwBrAGUAdABFAHAAbwBjAGgAIgA6AHsAIgBpAGQAIgA6ACIAcwBvAGMAawBlAHQALQAxACIAfQAsACIAYQBkAG0AaQBzAHMAaQBvAG4ASQBkACIAOgB7ACIAaQBkACIAOgAiAGcAbwBsAGQAZQBuAC0AYQAiAH0ALAAiAHIAbwB1AHQAZQBLAGkAbgBkACIAOgAiAG8AcgBkAGkAbgBhAHIAeQAiACwAIgBzAGUAcwBzAGkAbwBuACIAOgB7ACIAaQBkACIAOgAiAHIAcABjAC0AMQAiAH0ALAAiAHMAZQBzAHMAaQBvAG4ARQBwAG8AYwBoACIAOgB7ACIAaQBkACIAOgAiADAAMAAwADAAMAAwADAAMAAtADAAMAAwADAALQA0ADAAMAAwAC0AOAAwADAAMAAtADAAMAAwADAAMAAwADAAMAAwADAAMAAxACIAfQAsACIAZwBlAG4AZQByAGEAdABpAG8AbgAiADoAMQAsACIAcwBlAHEAdQBlAG4AYwBlACIAOgAwACwAIgBoAGkAcwB0AG8AcgB5AFYAZQByAHMAaQBvAG4AIgA6ADUALAAiAHQAbwBrAGUAbgAiADoAewAiAGkAZAAiADoAIgBzAG8AYwBrAGUAdAAtADEAOgAxACIAfQAsACIAbABlAGEAZgAiADoAewAiAGkAZAAiADoAIgAwADAAMAAwADAAMAAwADEAIgB9ACwAIgBhAGMAdABpAHYAZQBNAGUAcwBzAGEAZwBlACIAOgBuAHUAbABsACwAIgB0AHUAcgBuACIAOgBuAHUAbABsACwAIgBjAGgAZQBjAGsAcABvAGkAbgB0AEQAaQBnAGUAcwB0ACIAOgAiADEAYgBiAGMAYQBkADIAOQAzADIAMABmADIAMAA4ADQANwBhADUAMQA1AGMAYwA4ADUANAAwADYAMwBjAGQAYQAwAGQAZABhAGUAYQAyADAAYwBkAGMAZgBmADQANQBlAGIANgBiADUAZQAwAGUAOQBlAGUAMQA1AGYAYgBkADQAIgAsACIAYwBhAHQAYQBsAG8AZwBSAG8AbwB0ACIAOgAiAGMALQAwADAAMAAwADAAMAAwADAAMAAwADAAMAAwADAAMAAxACIALAAiAGMAYQB0AGEAbABvAGcAUgBvAG8AdABMAGUAbgBnAHQAaAAiADoAMwA5ADQANgAsACIAcgBlAHEAdQBpAHIAZQBkAEsAaQBuAGQAcwAiADoAWwAiAGEAYwB0AGkAdgBlACIALAAiAGMAYQBsAGwAcwAiACwAIgBkAGkAYQBsAG8AZwBzACIALAAiAGkAZABlAG4AdABpAHQAeQAiACwAIgBsAGkAZgBlAGMAeQBjAGwAZQAiACwAIgBvAHAAYQBxAHUAZQAiACwAIgByAHUAbgAiACwAIgBzAGUAdAB0AGwAZQBkACIALAAiAHMAbwB1AHIAYwBlACIALAAiAHQAcgBhAG4AcwBjAHIAaQBwAHQAIgBdAH0A"
 		}
 	}
 }