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

package/dist/core/ultrafast-lanes.js

@@ -1,3 +1,4 @@
+import { ULTRAFAST_DOCUMENTED_MODEL_IDS } from "@earendil-works/pi-ai";
 /**
  * Providers that receive `service_tier: "ultrafast"`: OpenAI's own API and the ChatGPT
  * subscription backend. Gateways and other providers serving an OpenAI model on the Responses
@@ -5,7 +6,6 @@
  * sends Ultrafast only to first-party OpenAI and Codex models).
  */
 const ULTRAFAST_PROVIDERS = new Set(["openai", "chatgpt-subscription"]);
-const ULTRAFAST_DOCUMENTED_MODEL_IDS = new Set(["gpt-6-astra", "gpt-6.1-sol"]);
 export function serviceTierForProvider(provider, serviceTier) {
     if (serviceTier !== "ultrafast")
         return serviceTier;
@@ -18,7 +18,9 @@ export function ultrafastSelectionWarning(model, serviceTier) {
     if (!ULTRAFAST_PROVIDERS.has(model.provider)) {
         return `Ultrafast is only sent to OpenAI and ChatGPT Subscription; ${model.provider}/${model.id} runs at its default tier`;
     }
-    if (ULTRAFAST_DOCUMENTED_MODEL_IDS.has(model.id))
+    // A tier-pinned row (for example `gpt-6.1-sol-ultrafast`) is documented by its upstream model,
+    // as the pricing code already checks (senpi#2978).
+    if (ULTRAFAST_DOCUMENTED_MODEL_IDS.has(model.upstreamModelId ?? model.id))
         return undefined;
     return `Ultrafast is documented for GPT-6 Astra and GPT-6.1 Sol; ${model.provider}/${model.id} may reject or ignore it`;
 }

package/dist/modes/interactive/components/footer.d.ts

@@ -10,11 +10,26 @@ export declare function formatTokens(count: number): string;
 /**
  * Mirrors the provider-shown-only-when->1 rule for accounts: the active account
  * name appears only when the provider actually pools more than one slot. The
- * pick shown is the pin when present, else the first account of the user order
- * (senpi#3591), else the session's HRW winner - the same ranking the rotation
- * engine uses, so the footer names the slot that will serve.
+ * pick shown is the effective pin (CLI > settings > stored, senpi#5983) when
+ * present, else the first account of the user order (senpi#3591), else the
+ * session's HRW winner - the same ranking the rotation engine uses, so the
+ * footer names the slot that will serve. The effective pin only reaches the
+ * footer for the Anthropic subscription provider (senpi#6222 review); other
+ * pooled providers keep their stored pin even when a slot shares the pin's
+ * name. A blocked pin (blockedUntil in the
+ * future) is skipped for the first usable slot in that ranking, and the
+ * suffix marks the blocked pin (`@B (A blocked until 14:00)`); when every
+ * slot is blocked it names the top-ranked slot and marks it blocked instead
+ * of silently naming a slot that cannot serve. Block state rides on the
+ * stored slots (SlotBlockState); slots without it are treated as usable.
  */
-export declare function accountFooterSuffix(credential: Credential | undefined, sessionId: string): string;
+export type AccountFooterOptions = {
+    /** Effective pin from CLI/settings, outranking the stored pin (senpi#5983). */
+    pinnedAccount?: string;
+    /** Override for "now" (tests); defaults to `Date.now()`. */
+    now?: number;
+};
+export declare function accountFooterSuffix(credential: Credential | undefined, sessionId: string, options?: AccountFooterOptions): string;
 export declare function formatCwdForFooter(cwd: string, home: string | undefined): string;
 /**
  * Footer component that shows pwd, token stats, and context usage.
@@ -25,7 +40,10 @@ export declare class FooterComponent implements Component {
     private footerData;
     private autoCompactEnabled;
     private compactionDelegated;
-    constructor(session: AgentSession, footerData: ReadonlyFooterDataProvider);
+    private resolveAccountPin;
+    constructor(session: AgentSession, footerData: ReadonlyFooterDataProvider, options?: {
+        resolveAccountPin?: (sessionId: string) => string | undefined;
+    });
     setSession(session: AgentSession): void;
     setAutoCompactEnabled(enabled: boolean): void;
     /**

package/dist/modes/interactive/components/footer.js

@@ -4,6 +4,7 @@ import { slotsOfOwnKind } from "@earendil-works/pi-ai/auth/pool/kinds";
 import { applyAccountOrder, rendezvousOrder } from "@earendil-works/pi-ai/auth/pool/select";
 import { accountLabel } from "@earendil-works/pi-ai/auth/pool/slots";
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { ANTHROPIC_SUBSCRIPTION_PROVIDER_ID } from "../../../core/extensions/builtin/anthropic-subscription/provider-id.js";
 import { theme } from "../theme/theme.js";
 import { planFooterLayout } from "./footer-layout.js";
 import { buildRightLabel, colorRightSide } from "./footer-right-label.js";
@@ -39,25 +40,43 @@ export function formatTokens(count) {
         return `${trim1(n / 1_000_000_000)}B`;
     return `${Math.round(n / 1_000_000_000)}B`;
 }
-/**
- * Mirrors the provider-shown-only-when->1 rule for accounts: the active account
- * name appears only when the provider actually pools more than one slot. The
- * pick shown is the pin when present, else the first account of the user order
- * (senpi#3591), else the session's HRW winner - the same ranking the rotation
- * engine uses, so the footer names the slot that will serve.
- */
-export function accountFooterSuffix(credential, sessionId) {
+function formatBlockedUntil(until) {
+    const date = new Date(until);
+    return `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`;
+}
+export function accountFooterSuffix(credential, sessionId, options = {}) {
     const pooled = credential;
     // Only slots the credential can serve with; a mixed pool's other-kind slot never does (senpi#3486).
     const slots = credential ? slotsOfOwnKind(credential) : [];
     if (slots.length < 2)
         return "";
-    const pinned = Object.entries(credential ?? {}).find(([key]) => key === "pinned")?.[1];
-    const pinnedSlot = slots.find((slot) => slot.name === pinned);
-    if (pinnedSlot)
-        return `@${footerAccountLabel(pinnedSlot)}`;
-    const winner = applyAccountOrder(pooled?.order, rendezvousOrder(sessionId, slots, (input) => createHash("sha256").update(input).digest().readBigUInt64BE(0)))[0];
-    return winner === undefined ? "" : `@${footerAccountLabel(winner)}`;
+    const now = options.now ?? Date.now();
+    // Block state rides on the stored slots at runtime (SlotBlockState) but
+    // is not part of the CredentialSlot type, so read it through unknown.
+    const blockedUntilOf = (slot) => slot.blockedUntil;
+    const isBlocked = (slot) => {
+        const until = blockedUntilOf(slot);
+        return until !== undefined && until > now;
+    };
+    const ranked = applyAccountOrder(pooled?.order, rendezvousOrder(sessionId, slots, (input) => createHash("sha256").update(input).digest().readBigUInt64BE(0)));
+    const storedPinned = Object.entries(credential ?? {}).find(([key]) => key === "pinned")?.[1];
+    const pinnedName = options.pinnedAccount ?? storedPinned;
+    const pinnedSlot = pinnedName === undefined ? undefined : slots.find((slot) => slot.name === pinnedName);
+    if (pinnedSlot) {
+        if (!isBlocked(pinnedSlot))
+            return `@${footerAccountLabel(pinnedSlot)}`;
+        const until = blockedUntilOf(pinnedSlot);
+        const serving = ranked.find((slot) => slot !== pinnedSlot && !isBlocked(slot));
+        if (serving)
+            return `@${footerAccountLabel(serving)} (${footerAccountLabel(pinnedSlot)} blocked until ${formatBlockedUntil(until)})`;
+        return `@${footerAccountLabel(pinnedSlot)} (blocked until ${formatBlockedUntil(until)})`;
+    }
+    const winner = ranked.find((slot) => !isBlocked(slot)) ?? ranked[0];
+    if (winner === undefined)
+        return "";
+    if (isBlocked(winner))
+        return `@${footerAccountLabel(winner)} (blocked until ${formatBlockedUntil(blockedUntilOf(winner))})`;
+    return `@${footerAccountLabel(winner)}`;
 }
 /**
  * Widest account label the provider segment carries. A label wider than this
@@ -90,11 +109,12 @@ export function formatCwdForFooter(cwd, home) {
  * Computes token/context stats from session, gets git branch and extension statuses from provider.
  */
 export class FooterComponent {
-    constructor(session, footerData) {
+    constructor(session, footerData, options = {}) {
         this.autoCompactEnabled = true;
         this.compactionDelegated = false;
         this.session = session;
         this.footerData = footerData;
+        this.resolveAccountPin = options.resolveAccountPin;
     }
     setSession(session) {
         this.session = session;
@@ -201,7 +221,16 @@ export class FooterComponent {
         let accountSuffix = "";
         if (state.model) {
             try {
-                accountSuffix = accountFooterSuffix(this.session.modelRegistry.authStorage.get(state.model.provider), this.session.sessionManager.getSessionId());
+                const sessionId = this.session.sessionManager.getSessionId();
+                // The resolver carries the Anthropic CLI/settings pin; resolve
+                // it only when the current model uses the Anthropic
+                // subscription provider. A same-named slot of another pooled
+                // provider (e.g. openai-codex "default") keeps its own stored
+                // pin instead (senpi#6222 review).
+                const pinnedAccount = state.model.provider === ANTHROPIC_SUBSCRIPTION_PROVIDER_ID
+                    ? this.resolveAccountPin?.(sessionId)
+                    : undefined;
+                accountSuffix = accountFooterSuffix(this.session.modelRegistry.authStorage.get(state.model.provider), sessionId, pinnedAccount === undefined ? undefined : { pinnedAccount });
             }
             catch {
                 // The footer must render even when credential storage is unreadable.

package/dist/modes/interactive/interactive-mode.js

@@ -25,6 +25,8 @@ import { collectEntriesForBranchSummary } from "../../core/compaction/branch-sum
 import { findExtensionStackMatches } from "../../core/crash-log.js";
 import { AssistantEditError, assistantTextEquals } from "../../core/edited-assistant-message.js";
 import { subscribeProviderAccountEvents } from "../../core/extensions/builtin/anthropic-subscription/account-events.js";
+import { getSessionClaudeAccountPin, resolveClaudeAccountPin, } from "../../core/extensions/builtin/anthropic-subscription/account-command.js";
+import { loadAnthropicSubscriptionProviderSettingsFromDisk } from "../../core/extensions/builtin/anthropic-subscription/settings.js";
 import { formatAccountFailoverNotice } from "./account-failover-notice.js";
 import { askUserAnswerDisplayText, formatUserMessage, showsPartialAnswers, } from "../../core/extensions/builtin/ask-user/format.js";
 import { askUserRenderers } from "../../core/extensions/builtin/ask-user/render.js";
@@ -817,7 +819,13 @@ export class InteractiveMode {
         this.footerDataProvider = new FooterDataProvider(this.sessionManager.getCwd());
         this.footer = this.chrome
             ? this.chrome.createFooter(this.session, this.footerDataProvider)
-            : new FooterComponent(this.session, this.footerDataProvider);
+            : new FooterComponent(this.session, this.footerDataProvider, {
+                // CLI > settings > stored pin, resolved per render so a
+                // mid-session /claude-account pin or settings change is
+                // picked up (senpi#5983); the stored pin stays the
+                // fallback inside accountFooterSuffix.
+                resolveAccountPin: (sessionId) => resolveClaudeAccountPin(getSessionClaudeAccountPin(sessionId), loadAnthropicSubscriptionProviderSettingsFromDisk(this.sessionManager.getCwd()).pinnedAccount, undefined),
+            });
         this.footer.setAutoCompactEnabled(this.session.autoCompactionEnabled);
         this.footerContainer = new Container();
         this.footerContainer.addChild(this.footer);

package/dist/modes/interactive/session-control-rpc-commands.d.ts

@@ -1,7 +1,7 @@
 import type { AgentSession } from "../../core/agent-session.ts";
 import { type ControlAttachments } from "./session-control-attach.ts";
 import { type ControlCommand, type ControlConnection } from "./session-control-server.ts";
-export declare const TUI_RPC_COMMANDS: readonly ["open_session", "get_snapshot", "subscribe_sessions", "unsubscribe_sessions", "steer", "follow_up", "prompt", "admit_external_message", "get_effect_status", "set_client_info", "attach_session", "release_attachment", "abort", "mcp_presenter_context", "mcp_form_presented", "mcp_form_response", "mcp_form_sync", "mcp_presenter_secret_answer"];
+export declare const TUI_RPC_COMMANDS: readonly ["open_session", "park_session", "claim_session", "get_snapshot", "subscribe_sessions", "unsubscribe_sessions", "steer", "follow_up", "prompt", "admit_external_message", "get_effect_status", "set_client_info", "attach_session", "release_attachment", "abort", "mcp_presenter_context", "mcp_form_presented", "mcp_form_response", "mcp_form_sync", "mcp_presenter_secret_answer"];
 export interface RpcCommandContext {
     /** This endpoint's instance id: the `expectedHostInstance` an `attach_session` may name. */
     readonly instanceId: string;

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,8 +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 forwarder granted this connection `peer_agent` in its host-mode delegation (senpi#6305). */
-    readonly peerAgent?: boolean;
+    /** 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,17 +9,9 @@ function ledgerId(deliveryId, origin) {
         ? `rpc:local/${deliveryId}`
         : `device:${encodeURIComponent(origin.deviceId)}/${deliveryId}`;
 }
-/**
- * The turn a delivery opens: a steer joins the running turn; an agent's delivery on a delegated connection the
- * forwarder granted `peer_agent` is a peer turn (senpi#6305), the record's sender kind being only a consistency check;
- * anything else keeps the connection's origin.
- */
+/** The turn a delivery opens: a steer joins the running turn; anything else counts as the connection's turn origin. */
 function deliveryTurnMark(command, peer) {
-    if (command.deliverAs === "steer")
-        return "join";
-    if (peer.connectionOrigin === "delegated" && peer.peerAgent === true && command.sender?.kind === "agent")
-        return "peer";
-    return peer.connectionOrigin;
+    return command.deliverAs === "steer" ? "join" : (peer.turnOrigin ?? peer.connectionOrigin);
 }
 export function admitExternalMessage(session, command, peer) {
     const chain = admitInputChain(command.chainCount, session.settingsManager);

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-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";
@@ -209,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.
@@ -1009,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 {
@@ -1047,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",
@@ -1055,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
             // =================================================================
@@ -1066,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;
@@ -1136,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":
@@ -1238,7 +1245,7 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                 const peer = {
                     origin: connectionRoles.originOf(currentConnectionId()),
                     connectionOrigin: connectionOrigin(),
-                    peerAgent: connectionRoles.grantedByForwarder(currentConnectionId(), "peer_agent"),
+                    turnOrigin: turnOrigin(),
                 };
                 const answer = admitExternalMessage(session, command, peer);
                 if (!answer.ok) {
@@ -1991,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();
@@ -2052,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,6 +59,8 @@ 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. */

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);

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

@@ -65,6 +65,8 @@ export declare const DELEGATED_CONNECTION_CAPABILITY = "delegated_connection_v1"
 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.
@@ -117,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

@@ -65,6 +65,8 @@ export const DELEGATED_CONNECTION_CAPABILITY = "delegated_connection_v1";
 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.
@@ -117,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

@@ -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,12 +43,13 @@ 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)

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";

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, PEER_AGENT_ROLE_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";
@@ -72,6 +72,8 @@ export function multiSessionHostCapabilities(options) {
             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.
@@ -103,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-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.
  *

package/dist/modes/rpc/host-observe-request.js

@@ -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.
  *
@@ -59,7 +61,10 @@ export function isObservingRequest(line) {
     if (typeof request !== "object" || request === null || Array.isArray(request))
         return false;
     const record = request;
-    if (record.type === "warm" || record.type === "authenticate" || record.type === RPC_LAUNCH_PROOF_RECORD)
+    if (record.type === "warm" ||
+        record.type === "park_session" ||
+        record.type === "authenticate" ||
+        record.type === RPC_LAUNCH_PROOF_RECORD)
         return true;
     return record[OBSERVE_REQUEST_FIELD] === true && OBSERVING_COMMANDS.has(record.type);
 }