@code-yeongyu/senpi 2026.11.10 → 2026.11.11

package/dist/modes/interactive/session-control-rpc-commands.js

@@ -26,6 +26,8 @@ import { failure, success } from "./session-control-server.js";
 import { TERMINAL_PRESENTER_COMMANDS } from "./terminal-presenter-surface.js";
 export const TUI_RPC_COMMANDS = [
     "open_session",
+    "park_session",
+    "claim_session",
     "get_snapshot",
     "subscribe_sessions",
     "unsubscribe_sessions",
@@ -64,6 +66,9 @@ export async function runTuiRpcCommand(context, connection, command) {
         }
         case "open_session":
             return openSession(context, connection, command);
+        case "park_session":
+        case "claim_session":
+            return failure(idOf(command), command.type, "multi_session_disabled");
         case "subscribe_sessions":
             return subscribe(context, connection, frame(command));
         case "unsubscribe_sessions":

package/dist/modes/rpc/admit-external-message-command.d.ts

@@ -20,6 +20,8 @@ export interface DeliveryPeer {
     /** The remote device the connection speaks for (`ConnectionRoles.originOf`); absent on a plain local connection. */
     readonly origin: RpcRemoteOrigin | undefined;
     readonly connectionOrigin: ConnectionOrigin;
+    /** The origin the turn this delivery opens counts as (senpi#6342); the connection's origin when absent. */
+    readonly turnOrigin?: ConnectionOrigin;
 }
 export type AdmitExternalMessageAnswer = {
     readonly ok: true;

package/dist/modes/rpc/admit-external-message-command.js

@@ -9,6 +9,10 @@ function ledgerId(deliveryId, origin) {
         ? `rpc:local/${deliveryId}`
         : `device:${encodeURIComponent(origin.deviceId)}/${deliveryId}`;
 }
+/** The turn a delivery opens: a steer joins the running turn; anything else counts as the connection's turn origin. */
+function deliveryTurnMark(command, peer) {
+    return command.deliverAs === "steer" ? "join" : (peer.turnOrigin ?? peer.connectionOrigin);
+}
 export function admitExternalMessage(session, command, peer) {
     const chain = admitInputChain(command.chainCount, session.settingsManager);
     if (chain.kind === "refused")
@@ -54,7 +58,7 @@ export function admitExternalMessage(session, command, peer) {
     }, {
         ...(origin === undefined ? {} : { remoteOrigin: origin }),
         ...(chain.chainCount === undefined ? {} : { chainCount: chain.chainCount }),
-        turnMark: command.deliverAs === "steer" ? "join" : peer.connectionOrigin,
+        turnMark: deliveryTurnMark(command, peer),
     });
     return answer(result.kind, result.turn_epoch);
 }

package/dist/modes/rpc/compact-admission-validation.js

@@ -22,7 +22,10 @@ export function unknownCompactAdmission(host, command) {
     if (!host.admissions || command.admissionId === undefined)
         return undefined;
     // These commands introduce client IDs; their bounded attempt index owns retry/conflict/retirement.
-    if (command.type === "open_session" || command.type === "attach_session" || command.type === "subscribe_sessions")
+    if (command.type === "open_session" ||
+        command.type === "claim_session" ||
+        command.type === "attach_session" ||
+        command.type === "subscribe_sessions")
         return undefined;
     // RULING-96: recovery IDs select token/lease authority, not the ordinary attempt ledger.
     if (command.type === "get_recovery_page" || command.type === "release_recovery")

package/dist/modes/rpc/connection-authority.d.ts

@@ -2,7 +2,8 @@
  * The authority word of a host-mode delegated connection (omo-relay-daemon#307).
  *
  * One `Int32Array(SharedArrayBuffer(8))` per incarnation of a delegated socket: index 0 packs
- * `epoch << 3 | retired << 2 | mask` (mask bit 0 = interactive_user, bit 1 = task_parent), index 1 is the incarnation,
+ * `epoch << 4 | retired << 3 | mask` (mask bit 0 = interactive_user, bit 1 = task_parent, bit 2 = peer_agent), index 1 is
+ * the incarnation,
  * stamped once before the buffer is shared. The host thread is the only writer, and every write is monotone within a
  * word: mask bits are only cleared, retired is only set, the epoch only grows and changes only on a real transition.
  * Host and worker threads read the same memory with one `Atomics.load` per command, so the load at a command's first

package/dist/modes/rpc/connection-authority.js

@@ -2,7 +2,8 @@
  * The authority word of a host-mode delegated connection (omo-relay-daemon#307).
  *
  * One `Int32Array(SharedArrayBuffer(8))` per incarnation of a delegated socket: index 0 packs
- * `epoch << 3 | retired << 2 | mask` (mask bit 0 = interactive_user, bit 1 = task_parent), index 1 is the incarnation,
+ * `epoch << 4 | retired << 3 | mask` (mask bit 0 = interactive_user, bit 1 = task_parent, bit 2 = peer_agent), index 1 is
+ * the incarnation,
  * stamped once before the buffer is shared. The host thread is the only writer, and every write is monotone within a
  * word: mask bits are only cleared, retired is only set, the epoch only grows and changes only on a real transition.
  * Host and worker threads read the same memory with one `Atomics.load` per command, so the load at a command's first
@@ -10,12 +11,13 @@
  *
  * This module has no package imports on purpose: worker-thread tests load it directly.
  */
-/** The two roles a word can carry, in bit order. */
-const WORD_ROLES = ["interactive_user", "task_parent"];
-const RETIRED_BIT = 4;
-const EPOCH_SHIFT = 3;
-/** The epoch field holds 29 bits; within one incarnation it never passes 4, so this bound is an invariant check. */
-const EPOCH_LIMIT = 2 ** 29;
+/** The roles a word can carry, in bit order. */
+const WORD_ROLES = ["interactive_user", "task_parent", "peer_agent"];
+const MASK_BITS = 7;
+const RETIRED_BIT = 8;
+const EPOCH_SHIFT = 4;
+/** The epoch field holds 28 bits; within one incarnation it never passes 4, so this bound is an invariant check. */
+const EPOCH_LIMIT = 2 ** 28;
 /** The largest incarnation slot [1] holds unchanged. */
 export const INCARNATION_MAX = 0x7fffffff;
 export function maskOfRoles(roles) {
@@ -31,7 +33,7 @@ export function rolesOfMask(mask) {
     return WORD_ROLES.filter((_role, bit) => (mask & (1 << bit)) !== 0);
 }
 export function decodeWord(word) {
-    const mask = word & 3;
+    const mask = word & MASK_BITS;
     return { epoch: word >>> EPOCH_SHIFT, retired: (word & RETIRED_BIT) !== 0, mask, roles: rolesOfMask(mask) };
 }
 function packWord(epoch, retired, mask) {
@@ -45,7 +47,7 @@ export function createAuthority(incarnation, mask) {
         throw new Error("authority_incarnation_invalid");
     const buffer = new SharedArrayBuffer(8);
     const view = new Int32Array(buffer);
-    view[0] = packWord(1, false, mask & 3);
+    view[0] = packWord(1, false, mask & MASK_BITS);
     view[1] = incarnation;
     return buffer;
 }

package/dist/modes/rpc/connection-handler.d.ts

@@ -73,6 +73,8 @@ export interface RpcConnectionHandler {
      * extension UI context is installed (used by tests that drive ctx.ui directly).
      */
     readonly ready: Promise<void>;
+    /** Complete a prebuilt binding with the capabilities its opener supplied. */
+    setClientCapabilities(capabilities: readonly string[]): void;
     /** Feed one inbound JSONL line (command or extension_ui_response). */
     handleInputLine(line: string): Promise<void>;
     /**

package/dist/modes/rpc/connection-handler.js

@@ -52,7 +52,8 @@ import { ConnectionQuestionBridge, degradeQuestion, sessionQuestionBridges } fro
 import { remoteOriginDeclaration, remoteOriginField } from "./remote-origin.js";
 import { advertisedCompactCapabilities, sessionDeclaration } from "./compact-negotiation.js";
 import { commandAuthority } from "./command-authority.js";
-import { noteDelegatedRecord } from "./delegated-drive-origin.js";
+import { runInRecordScope } from "../../core/turn-origin.js";
+import { recordTurnOrigin } from "./delegated-drive-origin.js";
 import { ConnectionRoles, DELEGATION_INCARNATION_STALE, roleConnection } from "./connection-roles.js";
 import { ACCOUNT_RESET_CAPABILITY, AUTH_KEY_VERIFY_CAPABILITY, AUTO_TITLE_SESSIONS_CAPABILITY, buildCustomUnsupportedRequest, CONTINUE_FROM_LEAF_CAPABILITY, DEFAULT_CUSTOM_EXTENSION_LABEL, EVAL_CELLS_CAPABILITY, EXTENSION_EVENTS_CAPABILITY, ENTRIES_TAIL_CAPABILITY, INTERACTIVE_USER_CAPABILITY, MEDIA_PLACEHOLDERS_CAPABILITY, PROVIDER_ACCOUNT_TEST_CAPABILITY, QUESTION_CAPABILITY, QUEUED_MESSAGE_REVISION_CAPABILITY, RESUME_SESSION_CAPABILITY, RETRY_FALLBACK_COMMAND_CAPABILITY, SESSION_HELD_CAPABILITY, TOOL_BARRIER_CAPABILITY, TASK_PARENT_CAPABILITY, } from "./custom-capability.js";
 import { runAbort, runGetEffectStatus, runQueuedInputChange, runSetThinkingLevel, } from "./effect-commands.js";
@@ -72,6 +73,7 @@ import { HostSessionControl } from "./host-session-control.js";
 import { createRpcLoginPromptCallbacks } from "./login-prompts.js";
 import { answerMemoryReport } from "./memory-report-command.js";
 import { readProjectSettings, readProjectTrust, writeProjectSetting, writeProjectTrust, } from "./project-workspace-commands.js";
+import { readProjectFile, writeProjectFile } from "./project-file-commands.js";
 import { protocolIdentity } from "./protocol-identity.js";
 import { buildRpcCommandsForSession, createCommandsChangedEvent, rpcCommandListDigest } from "./rpc-command-surface.js";
 import { rpcCommandPayloadError, rpcCommandShapeError, rpcMessageLengthError, sessionRetryFallbackError, } from "./rpc-input-validation.js";
@@ -208,6 +210,9 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
     const currentConnectionId = () => roleConnection(options.clientInfo?.connectionId());
     const hasRole = (role) => connectionRoles.has(currentConnectionId(), role);
     const connectionOrigin = () => connectionRoles.isDelegated(currentConnectionId()) ? "delegated" : "local";
+    // senpi#6342: a turn follows this machine's own setting; only a device the forwarder did not state is the same account
+    // counts as delegated for the permission rule.
+    const turnOrigin = () => connectionOrigin() === "delegated" && !connectionRoles.sameAccount(currentConnectionId()) ? "delegated" : "local";
     const routingSessionId = options.sessionId;
     // True only while THIS connection's own command drives a replacement; the issuer
     // already learns the new identity from its command response.
@@ -1008,7 +1013,6 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
     // Handle a single command
     const handleCommand = async (command, requestContext) => {
         const id = command.id;
-        noteDelegatedRecord(command, connectionOrigin(), session.sessionManager);
         switch (command.type) {
             case "get_protocol_info":
                 return {
@@ -1046,7 +1050,9 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                                 ...(options.retryFallbackCommand ? [RETRY_FALLBACK_COMMAND_CAPABILITY] : []),
                                 ...(options.toolRuntime ? toolRuntimeCapabilities(options.toolRuntime) : []),
                                 // Client flags cannot advertise a host guard this classic binding does not run, nor a tool runtime.
-                                ...advertisedCompactCapabilities(options.capabilities ?? [], false).filter((capability) => capability !== SESSION_HELD_CAPABILITY && !isHostOwnedToolRuntimeCapability(capability)),
+                                ...advertisedCompactCapabilities(options.capabilities ?? [], false).filter((capability) => capability !== SESSION_HELD_CAPABILITY &&
+                                    capability !== "park_claim" &&
+                                    !isHostOwnedToolRuntimeCapability(capability)),
                             ]),
                         ],
                         mode: "classic",
@@ -1054,7 +1060,9 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                     },
                 };
             case "open_session":
-                return error(id, "open_session", "multi_session_disabled");
+            case "park_session":
+            case "claim_session":
+                return error(id, command.type, "multi_session_disabled");
             // =================================================================
             // Prompting
             // =================================================================
@@ -1065,7 +1073,7 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                 if (holdAutomaticInput(session, command, hasRole(INTERACTIVE_USER_CAPABILITY)))
                     return success(id, "prompt", { disposition: "handled", heldAsNotice: true });
                 turnRequested = true;
-                const admission = handleClientInput(session, command, { output, promptCalls }, { interactiveUser: hasRole(INTERACTIVE_USER_CAPABILITY), connectionOrigin: connectionOrigin() });
+                const admission = handleClientInput(session, command, { output, promptCalls }, { interactiveUser: hasRole(INTERACTIVE_USER_CAPABILITY), connectionOrigin: turnOrigin() });
                 promptCalls.add(admission);
                 void admission.finally(() => promptCalls.delete(admission));
                 return undefined;
@@ -1135,7 +1143,7 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                 if (holdAutomaticInput(session, command, hasRole(INTERACTIVE_USER_CAPABILITY)))
                     return success(id, command.type, { disposition: "handled", heldAsNotice: true });
                 turnRequested = true;
-                await handleClientInput(session, command, { output, promptCalls }, { interactiveUser: hasRole(INTERACTIVE_USER_CAPABILITY), connectionOrigin: connectionOrigin() });
+                await handleClientInput(session, command, { output, promptCalls }, { interactiveUser: hasRole(INTERACTIVE_USER_CAPABILITY), connectionOrigin: turnOrigin() });
                 return undefined;
             }
             case "abort":
@@ -1237,6 +1245,7 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                 const peer = {
                     origin: connectionRoles.originOf(currentConnectionId()),
                     connectionOrigin: connectionOrigin(),
+                    turnOrigin: turnOrigin(),
                 };
                 const answer = admitExternalMessage(session, command, peer);
                 if (!answer.ok) {
@@ -1750,6 +1759,18 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                     ? success(id, "set_project_setting", result.data)
                     : error(id, "set_project_setting", result.message, result.errorCode);
             }
+            case "read_project_file": {
+                const result = await readProjectFile(session, command.path);
+                return result.ok
+                    ? success(id, "read_project_file", result.data)
+                    : error(id, "read_project_file", result.message, result.errorCode, result.errorData);
+            }
+            case "write_project_file": {
+                const result = await writeProjectFile(session, command.path, command.content, command.ifEtag);
+                return result.ok
+                    ? success(id, "write_project_file", result.data)
+                    : error(id, "write_project_file", result.message, result.errorCode, result.errorData);
+            }
             case "extension_request":
             case "eval_cells.list":
             case "eval_cells.peek":
@@ -1977,7 +1998,8 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
             return;
         }
         try {
-            const response = await handleCommand(command, requestContext);
+            // senpi#6342: the record's own handling, and the first run it starts, run under the record's origin.
+            const response = await runInRecordScope(recordTurnOrigin(command, turnOrigin()), () => handleCommand(command, requestContext));
             if (response) {
                 output(response);
                 await waitForRpcBackpressure();
@@ -2038,6 +2060,10 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
         pendingPrompts() {
             return [...promptCalls];
         },
+        setClientCapabilities(capabilities) {
+            replaceClientCapabilities([...capabilities]);
+            refreshGrantPresentation();
+        },
         isShutdownRequested() {
             return shutdownRequested;
         },

package/dist/modes/rpc/connection-roles.d.ts

@@ -59,10 +59,17 @@ export declare class ConnectionRoles {
     acceptsOrigin(connectionId: string, origin: RpcRemoteOrigin): boolean;
     /** Records the remote device a local connection speaks for; a delegated connection's origin is never declared. */
     declareOrigin(connectionId: string, origin: RpcRemoteOrigin): void;
+    /** Whether the forwarder stated this delegated connection's device is the host's own account (senpi#6342). */
+    sameAccount(connectionId: string | undefined): boolean;
     /** The remote device this connection speaks for: a delegated connection's principal, else its declared origin. */
     originOf(connectionId: string | undefined): RpcRemoteOrigin | undefined;
     /** Whether the connection is delegated (a remote device's): on the host, retained by a worker, or carried to one. */
     isDelegated(connectionId: string | undefined): boolean;
+    /**
+     * Whether the forwarder itself granted `role` to this connection (senpi#6305): only a host-mode delegation's live,
+     * unretired authority word counts. No client claim, legacy-mode delegation or local connection can satisfy it.
+     */
+    grantedByForwarder(connectionId: string | undefined, role: string): boolean;
     has(connectionId: string | undefined, role: string): boolean;
     /** A logical detach: drops claims of earlier incarnations of a delegated socket, and everything of a local one. */
     release(connectionId: string): void;

package/dist/modes/rpc/connection-roles.js

@@ -117,6 +117,10 @@ export class ConnectionRoles {
         if (this.acceptsOrigin(connectionId, origin))
             this.origins.set(connectionId, origin);
     }
+    /** Whether the forwarder stated this delegated connection's device is the host's own account (senpi#6342). */
+    sameAccount(connectionId) {
+        return this.viewOf(roleConnection(connectionId))?.descriptor.principal.sameAccount === true;
+    }
     /** The remote device this connection speaks for: a delegated connection's principal, else its declared origin. */
     originOf(connectionId) {
         const key = roleConnection(connectionId);
@@ -132,6 +136,17 @@ export class ConnectionRoles {
         const key = roleConnection(connectionId);
         return this.viewOf(key) !== undefined || this.carried.has(key);
     }
+    /**
+     * Whether the forwarder itself granted `role` to this connection (senpi#6305): only a host-mode delegation's live,
+     * unretired authority word counts. No client claim, legacy-mode delegation or local connection can satisfy it.
+     */
+    grantedByForwarder(connectionId, role) {
+        const descriptor = this.viewOf(roleConnection(connectionId))?.descriptor;
+        if (descriptor?.mode !== "host" || descriptor.authority === undefined)
+            return false;
+        const state = readAuthority(descriptor.authority);
+        return !state.retired && state.roles.includes(role);
+    }
     has(connectionId, role) {
         const key = roleConnection(connectionId);
         const store = commandAuthority.getStore();

package/dist/modes/rpc/custom-capability.d.ts

@@ -63,6 +63,10 @@ export declare const DELEGATED_CONNECTION_CAPABILITY = "delegated_connection_v1"
  * incarnation, `relayExec` and the `authority` receipt.
  */
 export declare const DELEGATION_ROLES_CAPABILITY = "delegation_roles_v1";
+/** A host-mode delegation may carry the forwarder-granted `peer_agent` role (senpi#6305). */
+export declare const PEER_AGENT_ROLE_CAPABILITY = "peer_agent_role_v1";
+/** A delegation may state `principal.sameAccount`, so that device's turns follow this host's own setting (senpi#6342). */
+export declare const SAME_ACCOUNT_DELEGATION_CAPABILITY = "same_account_delegation_v1";
 /**
  * Client opt-in (D11 S3-5): the connection renders the value-free `secret_input_notice` and `grant_select_notice` of a
  * raiser-only dialog another connection presents, and their `*_notice_settled` records. It never answers them.
@@ -115,6 +119,8 @@ export declare const AUTO_TITLE_PER_SESSION_CAPABILITY = "auto_title_per_session
  * cwd, kind and context needs without opening a session. Advertised only by an in-process runtime.
  */
 export declare const WARM_CAPABILITY = "warm";
+/** HOST capability: invisible speculative sessions and single-use claim, in-process registries only. */
+export declare const PARK_CLAIM_CAPABILITY = "park_claim";
 /**
  * HOST capability: this host honors `open_session.durableSessionId`, so a caller that already
  * owns a stable record id for the conversation can CREATE the session under that id and keep

package/dist/modes/rpc/custom-capability.js

@@ -63,6 +63,10 @@ export const DELEGATED_CONNECTION_CAPABILITY = "delegated_connection_v1";
  * incarnation, `relayExec` and the `authority` receipt.
  */
 export const DELEGATION_ROLES_CAPABILITY = "delegation_roles_v1";
+/** A host-mode delegation may carry the forwarder-granted `peer_agent` role (senpi#6305). */
+export const PEER_AGENT_ROLE_CAPABILITY = "peer_agent_role_v1";
+/** A delegation may state `principal.sameAccount`, so that device's turns follow this host's own setting (senpi#6342). */
+export const SAME_ACCOUNT_DELEGATION_CAPABILITY = "same_account_delegation_v1";
 /**
  * Client opt-in (D11 S3-5): the connection renders the value-free `secret_input_notice` and `grant_select_notice` of a
  * raiser-only dialog another connection presents, and their `*_notice_settled` records. It never answers them.
@@ -115,6 +119,8 @@ export const AUTO_TITLE_PER_SESSION_CAPABILITY = "auto_title_per_session";
  * cwd, kind and context needs without opening a session. Advertised only by an in-process runtime.
  */
 export const WARM_CAPABILITY = "warm";
+/** HOST capability: invisible speculative sessions and single-use claim, in-process registries only. */
+export const PARK_CLAIM_CAPABILITY = "park_claim";
 /**
  * HOST capability: this host honors `open_session.durableSessionId`, so a caller that already
  * owns a stable record id for the conversation can CREATE the session under that id and keep

package/dist/modes/rpc/delegated-drive-origin.d.ts

@@ -1,9 +1,9 @@
-import type { SessionManager } from "../../core/session-manager.ts";
-import { type ConnectionOrigin } from "../../core/turn-origin.ts";
+import type { ConnectionOrigin } from "../../core/turn-origin.ts";
 /**
- * Marks a session as remote-driven when a delegated connection sends it any record that can act on its work, decided
- * by the engine's own method-class table (`drive`, and `device_admin`, which grants more), never by a hand-kept list of
- * commands, so a new run starter (`continue_from_leaf`, `wake`, `resume_for_run`, ...) cannot slip past the rule.
+ * The origin a record's own handling runs under (senpi#6342): delegated for a cross-account record that can act on the
+ * session's work, decided by the engine's own method-class table (`drive`, and `device_admin`, which grants more),
+ * never by a hand-kept list of commands, so a new run starter (`continue_from_leaf`, `wake`, `resume_for_run`, ...)
+ * cannot slip past the rule. Any other record runs as local.
  */
-export declare function noteDelegatedRecord(command: object, origin: ConnectionOrigin, sessionManager: Pick<SessionManager, "getEntries" | "appendCustomEntry">): void;
+export declare function recordTurnOrigin(command: object, origin: ConnectionOrigin): ConnectionOrigin;
 //# sourceMappingURL=delegated-drive-origin.d.ts.map

package/dist/modes/rpc/delegated-drive-origin.js

@@ -1,16 +1,15 @@
-import { recordDelegatedOrigin } from "../../core/turn-origin.js";
 import { classifyRpcMethod } from "./method-classes.js";
 const ACTING_CLASSES = new Set(["drive", "device_admin"]);
 /**
- * Marks a session as remote-driven when a delegated connection sends it any record that can act on its work, decided
- * by the engine's own method-class table (`drive`, and `device_admin`, which grants more), never by a hand-kept list of
- * commands, so a new run starter (`continue_from_leaf`, `wake`, `resume_for_run`, ...) cannot slip past the rule.
+ * The origin a record's own handling runs under (senpi#6342): delegated for a cross-account record that can act on the
+ * session's work, decided by the engine's own method-class table (`drive`, and `device_admin`, which grants more),
+ * never by a hand-kept list of commands, so a new run starter (`continue_from_leaf`, `wake`, `resume_for_run`, ...)
+ * cannot slip past the rule. Any other record runs as local.
  */
-export function noteDelegatedRecord(command, origin, sessionManager) {
+export function recordTurnOrigin(command, origin) {
     if (origin !== "delegated")
-        return;
+        return "local";
     const methodClass = classifyRpcMethod(command);
-    if (methodClass !== undefined && ACTING_CLASSES.has(methodClass))
-        recordDelegatedOrigin(sessionManager);
+    return methodClass !== undefined && ACTING_CLASSES.has(methodClass) ? "delegated" : "local";
 }
 //# sourceMappingURL=delegated-drive-origin.js.map

package/dist/modes/rpc/delegation-declaration.d.ts

@@ -4,6 +4,8 @@ export interface Principal {
     readonly deviceId: string;
     readonly deviceName?: string;
     readonly conn?: string;
+    /** The forwarder states this device is the host's own account (senpi#6342); fixed for the record's life. */
+    readonly sameAccount?: true;
 }
 export interface Declaration {
     readonly principal: Principal;

package/dist/modes/rpc/delegation-declaration.js

@@ -8,7 +8,7 @@ const FORWARDABLE_CLASSES = new Set([
 const MAX_PRINCIPAL_FIELD = 256;
 const MAX_CONN_FIELD = 64;
 /** The connection roles a host-mode declaration may carry (omo-relay-daemon#307). */
-const DECLARABLE_ROLES = new Set(["interactive_user", "task_parent"]);
+const DECLARABLE_ROLES = new Set(["interactive_user", "task_parent", "peer_agent"]);
 export function parseDeclaration(record) {
     const principal = Reflect.get(record, "principal");
     if (typeof principal !== "object" || principal === null || Array.isArray(principal))
@@ -22,6 +22,9 @@ export function parseDeclaration(record) {
         return "principal.deviceName must be 1-256 characters";
     if (conn !== undefined && !boundedString(conn, MAX_CONN_FIELD))
         return "principal.conn must be 1-64 characters";
+    const sameAccount = Reflect.get(principal, "sameAccount");
+    if (sameAccount !== undefined && sameAccount !== true)
+        return "principal.sameAccount must be true when present";
     const granted = Reflect.get(record, "granted");
     if (!Array.isArray(granted))
         return "granted must be an array of method classes";
@@ -40,17 +43,18 @@ export function parseDeclaration(record) {
             deviceId: deviceId,
             ...(deviceName === undefined ? {} : { deviceName: deviceName }),
             ...(conn === undefined ? {} : { conn: conn }),
+            ...(sameAccount === true ? { sameAccount: true } : {}),
         },
         granted: classes,
     };
 }
 export function samePrincipal(a, b) {
-    return a.deviceId === b.deviceId && a.deviceName === b.deviceName && a.conn === b.conn;
+    return (a.deviceId === b.deviceId && a.deviceName === b.deviceName && a.conn === b.conn && a.sameAccount === b.sameAccount);
 }
 function parseRoles(value) {
     if (value === undefined)
         return undefined;
-    const invalid = "roles holds each of interactive_user, task_parent at most once";
+    const invalid = "roles holds each of interactive_user, task_parent, peer_agent at most once";
     if (!Array.isArray(value))
         return invalid;
     const roles = new Set();

package/dist/modes/rpc/effect-commands.d.ts

@@ -66,6 +66,27 @@ export declare function runSetThinkingLevel(ctx: EffectCommandContext, command:
         readonly reclaimed: true;
         readonly sessionId: string;
     };
+} | {
+    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: import("./rpc-session-state-types.ts").RpcSessionState;
+        attached?: boolean;
+        presence?: import("./rpc-host-response-types.ts").RpcSessionPresence;
+    };
 } | {
     id?: string;
     type: "response";
@@ -414,6 +435,12 @@ export declare function runSetThinkingLevel(ctx: EffectCommandContext, command:
     command: "set_project_setting";
     success: true;
     data: import("./project-workspace-commands.ts").RpcProjectSettings;
+} | {
+    id?: string;
+    type: "response";
+    command: "write_project_file";
+    success: true;
+    data: import("./project-file-commands.ts").RpcProjectFile;
 } | {
     id?: string;
     type: "response";
@@ -871,6 +898,12 @@ export declare function runSetThinkingLevel(ctx: EffectCommandContext, command:
     command: "get_project_settings";
     success: true;
     data: import("./project-workspace-commands.ts").RpcProjectSettings;
+} | {
+    id?: string;
+    type: "response";
+    command: "read_project_file";
+    success: true;
+    data: import("./project-file-commands.ts").RpcProjectFile;
 } | {
     id?: string;
     type: "response";

package/dist/modes/rpc/host-capabilities.d.ts

@@ -14,6 +14,7 @@ export declare const SET_PERMISSION_PRESET_CAPABILITY = "set_permission_preset_v
  */
 export declare function multiSessionHostCapabilities(options: {
     readonly warm: boolean;
+    readonly parkClaim?: boolean;
     readonly toolRuntime: ToolRuntimeKind;
     readonly negotiated: readonly string[];
     readonly mcpPresenters?: boolean;

package/dist/modes/rpc/host-capabilities.js

@@ -2,7 +2,7 @@ import { compactUpdatesEnabled } from "../../core/engine-socket-flag.js";
 import { isHostOwnedToolRuntimeCapability, toolRuntimeCapabilities, } from "../../cli/tool-runtime.js";
 import { ACCEPT_EDITS_PERMISSION_PRESET_CAPABILITY, AUTO_PERMISSION_PRESET_CAPABILITY, } from "../../core/extensions/builtin/permission-system/config.js";
 import { DURABLE_CLIENT_MESSAGE_ID_CAPABILITY } from "./client-admission-record.js";
-import { ACCOUNT_RESET_CAPABILITY, ATTENDED_CAPABILITY, AUTH_KEY_VERIFY_CAPABILITY, AUTO_TITLE_PER_SESSION_CAPABILITY, AUTO_TITLE_SESSIONS_CAPABILITY, BROWSER_ENGINE_CAPABILITY, CONTINUE_FROM_LEAF_CAPABILITY, DELEGATED_CONNECTION_CAPABILITY, DELEGATION_ROLES_CAPABILITY, DETACH_CONNECTION_CAPABILITY, DURABLE_SESSION_ID_CAPABILITY, ENTRIES_TAIL_CAPABILITY, EVAL_CELLS_CAPABILITY, MEDIA_PLACEHOLDERS_CAPABILITY, MOVED_PATH_GUARD_CAPABILITY, OBSERVE_READS_CAPABILITY, PROMPT_SURFACE_CAPABILITY, PROMPT_SURFACE_CHAT_CAPABILITY, PROVIDER_ACCOUNT_TEST_CAPABILITY, QUEUED_MESSAGE_REVISION_CAPABILITY, RESUME_SESSION_CAPABILITY, RETAIN_ON_DISCONNECT_CAPABILITY, RETRY_FALLBACK_PROFILE_CAPABILITY, SESSION_CONTEXT_CAPABILITY, SESSION_ENV_CAPABILITY, SESSION_HELD_CAPABILITY, SESSION_KIND_CAPABILITY, SESSION_RELOCATION_CAPABILITY, SESSION_STATUS_CAPABILITY, TOOL_BARRIER_CAPABILITY, WARM_CAPABILITY, } from "./custom-capability.js";
+import { ACCOUNT_RESET_CAPABILITY, ATTENDED_CAPABILITY, AUTH_KEY_VERIFY_CAPABILITY, AUTO_TITLE_PER_SESSION_CAPABILITY, AUTO_TITLE_SESSIONS_CAPABILITY, BROWSER_ENGINE_CAPABILITY, CONTINUE_FROM_LEAF_CAPABILITY, DELEGATED_CONNECTION_CAPABILITY, DELEGATION_ROLES_CAPABILITY, DETACH_CONNECTION_CAPABILITY, DURABLE_SESSION_ID_CAPABILITY, PEER_AGENT_ROLE_CAPABILITY, SAME_ACCOUNT_DELEGATION_CAPABILITY, ENTRIES_TAIL_CAPABILITY, EVAL_CELLS_CAPABILITY, MEDIA_PLACEHOLDERS_CAPABILITY, MOVED_PATH_GUARD_CAPABILITY, OBSERVE_READS_CAPABILITY, PROMPT_SURFACE_CAPABILITY, PROMPT_SURFACE_CHAT_CAPABILITY, PROVIDER_ACCOUNT_TEST_CAPABILITY, QUEUED_MESSAGE_REVISION_CAPABILITY, RESUME_SESSION_CAPABILITY, RETAIN_ON_DISCONNECT_CAPABILITY, RETRY_FALLBACK_PROFILE_CAPABILITY, SESSION_CONTEXT_CAPABILITY, SESSION_ENV_CAPABILITY, SESSION_HELD_CAPABILITY, SESSION_KIND_CAPABILITY, SESSION_RELOCATION_CAPABILITY, SESSION_STATUS_CAPABILITY, TOOL_BARRIER_CAPABILITY, WARM_CAPABILITY, PARK_CLAIM_CAPABILITY, } from "./custom-capability.js";
 import { EFFECT_LEDGER_CAPABILITY } from "./effect-record.js";
 import { SESSION_MODEL_SCOPE_CAPABILITY } from "./rpc-session-command-types.js";
 import { STEER_WHEN_IDLE_CAPABILITY, USER_ACTIVITY_CAPABILITY } from "./rpc-types.js";
@@ -70,6 +70,10 @@ export function multiSessionHostCapabilities(options) {
             DELEGATED_CONNECTION_CAPABILITY,
             // ...and decides a host-mode connection's roles per incarnation, with receipts (omo-relay-daemon#307).
             DELEGATION_ROLES_CAPABILITY,
+            // ...and may carry the forwarder-granted `peer_agent` role on such a connection (senpi#6305).
+            PEER_AGENT_ROLE_CAPABILITY,
+            // ...and lets the forwarder state a device is the host's own account, whose turns then ask nothing extra.
+            SAME_ACCOUNT_DELEGATION_CAPABILITY,
             // Only a multi-session host keeps sessions loaded that a client can ask it to free.
             UNLOAD_SESSION_CAPABILITY,
             // Only a multi-session host owns a move ledger and the hosted-session list export checks against.
@@ -101,9 +105,11 @@ export function multiSessionHostCapabilities(options) {
             AUTO_PERMISSION_PRESET_CAPABILITY,
             // Only an in-process runtime shares the loop a warm loads into (senpi#2314).
             ...(options.warm ? [WARM_CAPABILITY] : []),
+            ...(options.parkClaim ? [PARK_CLAIM_CAPABILITY] : []),
             ...toolRuntimeCapabilities(options.toolRuntime),
             // The host alone says where tool work runs; a negotiated copy would make two answers.
             ...options.negotiated.filter((capability) => capability !== "mcp_form_presenter_v1" &&
+                capability !== PARK_CLAIM_CAPABILITY &&
                 // RULING-111 (LEAK-E): only the compact negotiation owns these names; flag off echoes them as main does.
                 (!compactUpdatesEnabled() ||
                     (capability !== "compact_message_updates_v1" && capability !== "compact_events")) &&

package/dist/modes/rpc/host-gc-evidence.d.ts

@@ -1,5 +1,5 @@
 import { type HostDaemonDirectory } from "./host-daemon-paths.ts";
-export type EndpointInUse = "live_generation" | "live_claim" | "reachable";
+export type EndpointInUse = "live_generation" | "live_claim" | "reachable" | "credential_unavailable";
 export type SocketSilence = "socket_refused" | "socket_absent";
 /**
  * The three-part test, in the order its answers are reported: (a) no generation pidfile names a live

package/dist/modes/rpc/host-gc-evidence.js

@@ -33,12 +33,17 @@ export async function endpointInUse(paths, socket) {
             return { inUse: "live_claim" };
     }
     const silence = await socketSilence(socket);
+    if (silence === "credential_unavailable")
+        return { inUse: silence };
     if (silence === undefined)
         return { inUse: "reachable" };
     // A successor mid-handoff listens on `<socket>.next-<gen>` before it registers anywhere.
     const successors = (await socketSiblings(socket)).filter((name) => name.startsWith(`${basename(socket)}.next-`) && !isBindScratchName(name));
     for (const successor of successors) {
-        if ((await socketSilence(join(dirname(socket), successor))) === undefined)
+        const successorSilence = await socketSilence(join(dirname(socket), successor));
+        if (successorSilence === "credential_unavailable")
+            return { inUse: successorSilence };
+        if (successorSilence === undefined)
             return { inUse: "reachable" };
     }
     return { inUse: undefined, silence };
@@ -101,10 +106,11 @@ async function recordIsLive(record) {
 async function socketSilence(socket) {
     let secret;
     if (process.platform === "win32") {
-        // The pipe name includes the secret; without one no client can reach the pipe either.
+        // The pipe name includes the secret, so without a readable one nothing proves the pipe silent: a
+        // live host may still serve it under the key whose file was lost (sisyphuslabs/omo-desktop-app#4199).
         secret = await readSocketSecret(socketSecretPath(socket)).catch(() => undefined);
         if (secret === undefined)
-            return "socket_absent";
+            return "credential_unavailable";
     }
     return new Promise((resolveProbe) => {
         const connection = createConnection(resolveSocketTransportAddress(socket, process.platform, secret));

package/dist/modes/rpc/host-gc.js

@@ -14,6 +14,7 @@
  *     live_generation   a generation pidfile (any, the pointer's included) names a live process
  *     live_claim        a session-path claim in `reservations/` has a live owner
  *     reachable         the socket (or a `.next-*` successor bind) did not refuse the connection
+ *     credential_unavailable  win32: the socket secret cannot be read, so its pipe cannot be proven silent
  *     locked            the ensure lock was not free within 2 s
  *     legacy_layout     the agent dir predates layout 2; its flat files belong to a legacy host
  *     unknown_identity  nothing in the directory names its socket, so its lock cannot be taken
@@ -94,7 +95,9 @@ export async function gcEndpoint(socket, dir, options) {
     try {
         await options._test?.afterLockAcquired?.(socket);
         const evidence = await endpointInUse(hostDaemonDirectoryPaths(dir), socket);
-        if (evidence.inUse === "live_claim" || (evidence.inUse !== undefined && options.staleEngine === undefined)) {
+        if (evidence.inUse === "live_claim" ||
+            evidence.inUse === "credential_unavailable" ||
+            (evidence.inUse !== undefined && options.staleEngine === undefined)) {
             return { removed: false, reason: evidence.inUse };
         }
         if (evidence.inUse !== undefined)

package/dist/modes/rpc/host-observe-request.d.ts

@@ -12,6 +12,8 @@
  * and the connection attaches, so a client cannot hold a session while its host idles out under it.
  * `warm` never attaches, marked or not: it opens nothing, so a host that only received it idles out
  * on its normal deadline (senpi#2314).
+ * `park_session` likewise holds no client attachment: its speculative runtime is discarded at host exit.
+ * `claim_session` takes an ordinary opener attachment and is never observing.
  * Hosts that predate the field ignore it (commands are parsed by `type`), so a marked read works
  * against every generation.
  *