@code-yeongyu/senpi 2026.10.24-2 → 2026.10.24-3

package/dist/modes/rpc/host-lifecycle-proxy.js

@@ -3,17 +3,20 @@
  * adoption of the public name, and the readiness probes of the private hop. Split out of
  * `host-lifecycle.ts`, which keeps the supervisor's orchestration (senpi#2566).
  */
-import { chmod, mkdir, rename, stat, unlink } from "node:fs/promises";
+import { chmod, mkdir, stat, unlink } from "node:fs/promises";
 import { createConnection, createServer } from "node:net";
 import { dirname } from "node:path";
 import { proxyWithAdmission } from "./host-admission-proxy.js";
 import { connectInternalConnection } from "./internal-channel.js";
 import { attachJsonlLineReader, MAX_RPC_LINE_CHARACTERS } from "./jsonl.js";
-import { MAX_SOCKET_PATH_BYTES, socketEntryListenerState, statSocketIdentity, } from "./socket-ownership.js";
+import { PublicRpcConnection } from "./rpc-public-auth.js";
+import { MAX_SOCKET_PATH_BYTES, socketEntryListenerState } from "./socket-ownership.js";
+export { adoptPublicSocket } from "./socket-ownership.js";
 import { authenticateSocket, ensureSocketSecret, resolveSocketTransportAddress, sendSocketHandshake, socketSecretPath, } from "./socket-transport.js";
 export function createPublicProxy(options) {
     const { internalSocket, internalSecret, publicSecret, clients } = options;
     return createServer((client) => {
+        const auth = options.publicEndpoint ? new PublicRpcConnection(client, options.publicEndpoint) : undefined;
         const accept = async () => {
             // Teardown is terminal even for an accept that raced socket shielding/server.close.
             if (!clients.admit(client))
@@ -47,8 +50,10 @@ export function createPublicProxy(options) {
                     hop?.destroy();
                     return;
                 }
-                proxyWithAdmission(client, hop, options.admission);
-                client.resume();
+                proxyWithAdmission(client, hop, options.admission, auth);
+                // An authenticated endpoint resumes the client itself once its key record is published.
+                if (!auth)
+                    client.resume();
             }
             catch {
                 detach();
@@ -60,23 +65,6 @@ export function createPublicProxy(options) {
             void accept();
     });
 }
-/**
- * Takes the public name over with a rename, once - and only while - that name still refers to the
- * entry this handoff was decided against. A socket that changed underneath belongs to another
- * process now: replacing it would unlink an endpoint this generation cannot prove it owns, so the
- * successor aborts instead and leaves both the intruder's socket and its own bind entry alone.
- */
-export async function adoptPublicSocket(bindSocket, publicSocket, expected) {
-    if (expected === undefined)
-        throw new Error(`${publicSocket}: a generation launch must name the entry it replaces`);
-    const current = await statSocketIdentity(publicSocket);
-    if (current === undefined || current.dev !== expected.dev || current.ino !== expected.ino) {
-        throw new Error(`${publicSocket}: owned by another socket entry now; refusing to replace it`);
-    }
-    // rename(2) is atomic for readers of the path: every connect either reaches the old entry or
-    // this one, never nothing. The inode this supervisor bound simply answers to a second name.
-    await rename(bindSocket, publicSocket);
-}
 /**
  * Reuses an existing valid secret - including one ensureHost() just wrote - and
  * creates one (with its parent directories, mode 0600) when it is missing or

package/dist/modes/rpc/host-lifecycle-shutdown.d.ts

@@ -10,6 +10,7 @@ import type { HostStopSender } from "./host-crash-record.ts";
 import type { HostDaemonPaths, HostGenerationPaths } from "./host-daemon-paths.ts";
 import type { SupervisorActivity } from "./host-lifecycle-activity.ts";
 import type { SupervisorDrain } from "./host-lifecycle-drain.ts";
+import type { RpcPublicEndpoint } from "./rpc-public-key.ts";
 import { type SocketFileIdentity } from "./socket-ownership.ts";
 export { CHILD_STOP_TIMEOUT_MS } from "./host-stop-intent.ts";
 export interface SupervisorState {
@@ -34,6 +35,7 @@ export interface SupervisorShutdown {
     readonly drain: SupervisorDrain;
     readonly admission: HostAdmission;
     readonly state: SupervisorState;
+    readonly publicEndpoint?: RpcPublicEndpoint;
     /** Stops the idle ticker, the supersession watch and the win32 identity watchdog. */
     readonly stopWatchers: () => void;
 }

package/dist/modes/rpc/host-lifecycle-shutdown.js

@@ -68,6 +68,9 @@ export async function performShutdown(context, reason, exitCode) {
         }
     }
     finally {
+        await context.publicEndpoint?.dispose().catch((cause) => {
+            supervisorLog(`endpoint key cleanup failed: ${errorMessage(cause)}`);
+        });
         if (hardExit)
             clearTimeout(hardExit);
         // Windows named-pipe handles can outlive their JavaScript wrappers, so cleanup failure must

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

@@ -1,12 +1,11 @@
 #!/usr/bin/env node
 import { randomUUID } from "node:crypto";
-import { realpathSync } from "node:fs";
 import { join } from "node:path";
-import { fileURLToPath } from "node:url";
 import { getAgentDir, isBundledNode, VERSION } from "../../config.js";
 import { HostAdmission } from "./host-admission.js";
 import { classifyChildExit, noteChildExit } from "./host-child-exit.js";
 import { hostCrashCleanupPaths } from "./host-cleanup-paths.js";
+import { isCliModuleEntry } from "./host-cli-entry.js";
 import { createHostDaemonPaths, generationPaths } from "./host-daemon-paths.js";
 import { HOST_INSTANCE_ID_ENV } from "./host-identity-env.js";
 import { SupervisorActivity, SupervisorOwner } from "./host-lifecycle-activity.js";
@@ -18,7 +17,8 @@ import { adoptPublicSocket, createPublicProxy, ensurePublicSocketSecret, listen,
 import { readSettingsFile, recordChildPid } from "./host-lifecycle-scratch.js";
 import { performShutdown, registerSupervisorSignals, supervisorSender, } from "./host-lifecycle-shutdown.js";
 import { startSupervisorTicker } from "./host-lifecycle-ticker.js";
-import { errorMessage, writeStderrLine } from "./host-supervisor-log.js";
+import { errorMessage, writeHostReady, writeStderrLine } from "./host-supervisor-log.js";
+import { RpcPublicEndpoint } from "./rpc-public-key.js";
 import { PUBLIC_SOCKET_IDENTITY_FILE, statSocketIdentity, writeSocketIdentityFile } from "./socket-ownership.js";
 // The exit verdict, the launch surface and the cold-start/idle-exit policy live in their own modules
 // (host-child-exit.ts, host-lifecycle-launch.ts, host-lifecycle-policy.ts); they stay exported from
@@ -36,6 +36,7 @@ export async function runHostSupervisor(launch) {
     const generation = generationPaths(paths, instanceId);
     const policy = resolveHostPolicy(await readSettingsFile(paths.settingsFile), process.env);
     const publicSocket = launch.socket;
+    const publicEndpoint = process.platform === "win32" ? undefined : new RpcPublicEndpoint(launch.agentDir ?? getAgentDir(), publicSocket);
     // A successor generation binds its own name and adopts the public one by rename; an ordinary
     // start binds the public name directly. Everything downstream - the child's environment, the
     // ownership token, the teardown - is expressed in terms of the PUBLIC path either way.
@@ -119,6 +120,7 @@ export async function runHostSupervisor(launch) {
         internalSocket,
         ...hop.transport,
         ...(publicSecret ? { publicSecret } : {}),
+        ...(publicEndpoint ? { publicEndpoint } : {}),
         clients: activity.clients,
         admission,
         onDetach: () => activity.refresh(),
@@ -148,6 +150,7 @@ export async function runHostSupervisor(launch) {
         drain,
         admission,
         state,
+        ...(publicEndpoint ? { publicEndpoint } : {}),
         stopWatchers: () => {
             for (const stop of watchers.splice(0))
                 stop();
@@ -174,6 +177,7 @@ export async function runHostSupervisor(launch) {
         await activity.openObserver();
         await prepareSocketPath(bindSocket);
         await listen(server, bindSocket, publicSecret);
+        await publicEndpoint?.publish();
         state.publicSocketOwned = true;
         if (successor)
             await adoptPublicSocket(bindSocket, publicSocket, launch.replaceIdentity);
@@ -195,21 +199,10 @@ export async function runHostSupervisor(launch) {
     if (process.platform === "win32") {
         watchers.push(await watchWin32ChildIdentity(child, () => state.shuttingDown, () => void shutdown("rpc host child exit observed by identity watchdog", 0)));
     }
-    writeStderrLine(`senpi rpc host ready on unix://${publicSocket} (coldStart=${policy.coldStart}, idleExitMs=${policy.coldStart === "persistent" ? "never" : String(policy.idleExitMs)})`);
+    writeHostReady(publicSocket, policy.coldStart, policy.idleExitMs);
     await new Promise(() => { });
 }
-function isEntryScript() {
-    const entry = process.argv[1];
-    if (!entry)
-        return false;
-    try {
-        return fileURLToPath(import.meta.url) === realpathSync(entry);
-    }
-    catch {
-        return false;
-    }
-}
-if (!isBundledNode && isEntryScript()) {
+if (!isBundledNode && isCliModuleEntry(import.meta.url)) {
     const launch = parseSupervisorArgs(process.argv.slice(2));
     if (!launch) {
         writeStderrLine("usage: host-lifecycle.ts --socket <path> [host cli args...]");

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

@@ -45,7 +45,7 @@ export function isObservingRequest(line) {
     if (typeof request !== "object" || request === null || Array.isArray(request))
         return false;
     const record = request;
-    if (record.type === "warm")
+    if (record.type === "warm" || record.type === "authenticate")
         return true;
     return record[OBSERVE_REQUEST_FIELD] === true && OBSERVING_COMMANDS.has(record.type);
 }

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

@@ -1,24 +1,26 @@
 import { type HostAttachHold } from "./host-attach-hold.ts";
 import { type HostProtocolInfo } from "./host-decision.ts";
 import { requestOnSocket } from "./host-socket-request.ts";
+import type { RpcKeyOptions } from "./rpc-auth-client.ts";
 export { requestOnSocket };
 /** Default probe budget: long enough for a host under load, short enough to keep an ensure moving. */
 export declare const DEFAULT_PROBE_TIMEOUT_MS = 10000;
 export interface ProbeHostOptions {
     readonly socket: string;
     readonly timeoutMs?: number;
+    readonly keyRoot?: string;
 }
 /** The running host's identity, or `undefined` when nothing is serving the endpoint. */
 export declare function probeHost(options: ProbeHostOptions): Promise<HostProtocolInfo | undefined>;
-export declare function probeProtocolInfo(socketPath: string, timeoutMs: number): Promise<HostProtocolInfo | undefined>;
+export declare function probeProtocolInfo(socketPath: string, timeoutMs: number, options?: RpcKeyOptions): Promise<HostProtocolInfo | undefined>;
 /** `probeProtocolInfo` for a read that must not count as host activity, such as `host status`. */
-export declare function observeProtocolInfo(socketPath: string, timeoutMs: number): Promise<HostProtocolInfo | undefined>;
+export declare function observeProtocolInfo(socketPath: string, timeoutMs: number, options?: RpcKeyOptions): Promise<HostProtocolInfo | undefined>;
 /**
  * The host's identity together with an attach hold on the connection that answered, or `undefined`
  * when nothing answers. The answer and the claim share one connection, so there is no instant
  * between "the host is ready" and "the host is held" in which an idle window could close.
  */
-export declare function holdProtocolInfo(socketPath: string, timeoutMs: number): Promise<{
+export declare function holdProtocolInfo(socketPath: string, timeoutMs: number, options?: RpcKeyOptions): Promise<{
     readonly info: HostProtocolInfo;
     readonly hold: HostAttachHold;
 } | undefined>;
@@ -28,12 +30,12 @@ export declare function holdProtocolInfo(socketPath: string, timeoutMs: number):
  * difference decides whether an ensure may end it: a silent-but-connectable socket has an owner
  * serving sessions behind it, and killing that owner destroys every one of them.
  */
-export declare function probeSocketReachable(socketPath: string, timeoutMs: number): Promise<boolean>;
+export declare function probeSocketReachable(socketPath: string, timeoutMs: number, options?: RpcKeyOptions): Promise<boolean>;
 /**
  * How many sessions the host holds right now, worker sessions included, or `undefined` when it
  * does not answer. A stop decision needs the number the host reports, not the one a client remembers.
  */
-export declare function probeSessionCount(socketPath: string, timeoutMs: number): Promise<number | undefined>;
+export declare function probeSessionCount(socketPath: string, timeoutMs: number, options?: RpcKeyOptions): Promise<number | undefined>;
 /**
  * The session count together with the connection that answered it, kept open so the SAME host can be
  * asked again after its public path was handed to somebody else: the recount reaches the process that
@@ -45,5 +47,5 @@ export interface HeldSessionCount {
     recount(timeoutMs: number): Promise<number | undefined>;
     close(): void;
 }
-export declare function holdSessionCount(socketPath: string, timeoutMs: number): Promise<HeldSessionCount | undefined>;
+export declare function holdSessionCount(socketPath: string, timeoutMs: number, options?: RpcKeyOptions): Promise<HeldSessionCount | undefined>;
 //# sourceMappingURL=host-probe.d.ts.map

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

@@ -7,15 +7,15 @@ export { requestOnSocket };
 export const DEFAULT_PROBE_TIMEOUT_MS = 10_000;
 /** The running host's identity, or `undefined` when nothing is serving the endpoint. */
 export function probeHost(options) {
-    return probeProtocolInfo(options.socket, options.timeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS);
+    return probeProtocolInfo(options.socket, options.timeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS, options);
 }
-export async function probeProtocolInfo(socketPath, timeoutMs) {
-    const reply = await requestOnSocket(socketPath, { type: "get_protocol_info" }, timeoutMs);
+export async function probeProtocolInfo(socketPath, timeoutMs, options = {}) {
+    const reply = await requestOnSocket(socketPath, { type: "get_protocol_info" }, timeoutMs, options);
     return reply === undefined ? undefined : parseHostProtocolInfo(reply);
 }
 /** `probeProtocolInfo` for a read that must not count as host activity, such as `host status`. */
-export async function observeProtocolInfo(socketPath, timeoutMs) {
-    const reply = await requestOnSocket(socketPath, { type: "get_protocol_info", [OBSERVE_REQUEST_FIELD]: true }, timeoutMs);
+export async function observeProtocolInfo(socketPath, timeoutMs, options = {}) {
+    const reply = await requestOnSocket(socketPath, { type: "get_protocol_info", [OBSERVE_REQUEST_FIELD]: true }, timeoutMs, options);
     return reply === undefined ? undefined : parseHostProtocolInfo(reply);
 }
 /**
@@ -23,8 +23,8 @@ export async function observeProtocolInfo(socketPath, timeoutMs) {
  * when nothing answers. The answer and the claim share one connection, so there is no instant
  * between "the host is ready" and "the host is held" in which an idle window could close.
  */
-export async function holdProtocolInfo(socketPath, timeoutMs) {
-    const outcome = await connectAndAsk(socketPath, { id: PROBE_REQUEST_ID, type: "get_protocol_info" }, timeoutMs, true);
+export async function holdProtocolInfo(socketPath, timeoutMs, options = {}) {
+    const outcome = await connectAndAsk(socketPath, { id: PROBE_REQUEST_ID, type: "get_protocol_info" }, timeoutMs, true, options);
     const info = outcome.answer === undefined ? undefined : parseHostProtocolInfo(outcome.answer);
     if (outcome.kept === undefined)
         return undefined;
@@ -40,18 +40,18 @@ export async function holdProtocolInfo(socketPath, timeoutMs) {
  * difference decides whether an ensure may end it: a silent-but-connectable socket has an owner
  * serving sessions behind it, and killing that owner destroys every one of them.
  */
-export async function probeSocketReachable(socketPath, timeoutMs) {
-    return (await connectAndAsk(socketPath, { id: PROBE_REQUEST_ID, type: "get_protocol_info" }, timeoutMs)).connected;
+export async function probeSocketReachable(socketPath, timeoutMs, options = {}) {
+    return (await connectAndAsk(socketPath, { id: PROBE_REQUEST_ID, type: "get_protocol_info" }, timeoutMs, false, options)).connected;
 }
 /**
  * How many sessions the host holds right now, worker sessions included, or `undefined` when it
  * does not answer. A stop decision needs the number the host reports, not the one a client remembers.
  */
-export async function probeSessionCount(socketPath, timeoutMs) {
-    return sessionCountOf(await requestOnSocket(socketPath, { type: "list_sessions", include_workers: true }, timeoutMs));
+export async function probeSessionCount(socketPath, timeoutMs, options = {}) {
+    return sessionCountOf(await requestOnSocket(socketPath, { type: "list_sessions", include_workers: true }, timeoutMs, options));
 }
-export async function holdSessionCount(socketPath, timeoutMs) {
-    const outcome = await connectAndAsk(socketPath, { id: PROBE_REQUEST_ID, type: "list_sessions", include_workers: true }, timeoutMs, true);
+export async function holdSessionCount(socketPath, timeoutMs, options = {}) {
+    const outcome = await connectAndAsk(socketPath, { id: PROBE_REQUEST_ID, type: "list_sessions", include_workers: true }, timeoutMs, true, options);
     const kept = outcome.kept;
     if (kept === undefined)
         return undefined;

package/dist/modes/rpc/host-request-key-root.d.ts

@@ -0,0 +1,8 @@
+import type { HostRequest } from "./host-runner.ts";
+/**
+ * Where a host request proves endpoint keys from (senpi#3815): the caller's explicit `--rpc-key-root`, then a gc's
+ * explicit target directory (it dials that directory's endpoints, whose hosts published their records there), then
+ * an enclosing key root, `SENPI_RPC_KEY_ROOT`, and finally the target's agent dir.
+ */
+export declare function hostRequestKeyRoot(request: HostRequest, explicit?: string): string;
+//# sourceMappingURL=host-request-key-root.d.ts.map

package/dist/modes/rpc/host-request-key-root.js

@@ -0,0 +1,14 @@
+import { rpcKeyRoot } from "./rpc-auth-client.js";
+/**
+ * Where a host request proves endpoint keys from (senpi#3815): the caller's explicit `--rpc-key-root`, then a gc's
+ * explicit target directory (it dials that directory's endpoints, whose hosts published their records there), then
+ * an enclosing key root, `SENPI_RPC_KEY_ROOT`, and finally the target's agent dir.
+ */
+export function hostRequestKeyRoot(request, explicit) {
+    if (explicit !== undefined)
+        return explicit;
+    if (request.action === "gc")
+        return request.agentDir;
+    return rpcKeyRoot({}, request.action === "shard_path" ? undefined : request.target.agentDir);
+}
+//# sourceMappingURL=host-request-key-root.js.map

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

@@ -48,5 +48,7 @@ export type HostRequest = {
     readonly owner: string;
     readonly root: string;
 };
-export declare function runHostRequest(request: HostRequest): Promise<HostOutcome>;
+export declare function runHostRequest(request: HostRequest, options?: {
+    readonly keyRoot?: string;
+}): Promise<HostOutcome>;
 //# sourceMappingURL=host-runner.d.ts.map

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

@@ -33,8 +33,13 @@ import { readHostStatus, readSessionCounts } from "./host-status.js";
 import { readAllHostStatus } from "./host-status-all.js";
 import { staleStopGeneration, stopHost } from "./host-stop.js";
 export { HOST_EXIT_ERROR, HOST_EXIT_FALLBACK, HOST_EXIT_OK, HOST_EXIT_REFUSED, HOST_EXIT_USAGE, } from "./host-outcome.js";
+import { hostRequestKeyRoot } from "./host-request-key-root.js";
+import { withRpcKeyRoot } from "./rpc-auth-client.js";
 const PROBE_TIMEOUT_MS = 10_000;
-export async function runHostRequest(request) {
+export async function runHostRequest(request, options = {}) {
+    return withRpcKeyRoot(hostRequestKeyRoot(request, options.keyRoot), () => runHostRequestInKeyRoot(request));
+}
+async function runHostRequestInKeyRoot(request) {
     if (request.action === "ensure" || request.action === "handoff" || request.action === "stop") {
         const { socket, agentDir } = request.target;
         if ((await endpointKindOfSocket(socket, agentDir)) === "tui") {

package/dist/modes/rpc/host-socket-bind.d.ts

@@ -0,0 +1,6 @@
+import type { Server } from "node:net";
+import { type SocketFileIdentity } from "./socket-ownership.ts";
+export declare function resolveSocketPath(value: string, agentDir: string): string;
+export declare function formatSocketAddress(socketPath: string): string;
+export declare function listen(server: Server, socketPath: string, secret?: Uint8Array): Promise<SocketFileIdentity | undefined>;
+//# sourceMappingURL=host-socket-bind.d.ts.map

package/dist/modes/rpc/host-socket-bind.js

@@ -0,0 +1,42 @@
+/** Where a socket host listens and how it binds: the `--listen` address forms and the owned bind (moved out of multi-session-host.ts). */
+import { chmod } from "node:fs/promises";
+import { join } from "node:path";
+import { statSocketIdentity } from "./socket-ownership.js";
+import { resolveSocketTransportAddress } from "./socket-transport.js";
+export function resolveSocketPath(value, agentDir) {
+    if (value === "unix://")
+        return join(agentDir, "rpc", "rpc.sock");
+    if (value.startsWith("unix://")) {
+        const path = value.slice("unix://".length);
+        if (path.length === 0)
+            return join(agentDir, "rpc", "rpc.sock");
+        if (path.startsWith("@") && process.platform === "linux")
+            return `\0${path.slice(1)}`;
+        return path;
+    }
+    return value;
+}
+export function formatSocketAddress(socketPath) {
+    return socketPath.startsWith("\0") ? `unix://@${socketPath.slice(1)}` : `unix://${socketPath}`;
+}
+export function listen(server, socketPath, secret) {
+    return new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(resolveSocketTransportAddress(socketPath, process.platform, secret), async () => {
+            server.off("error", reject);
+            try {
+                if (process.platform !== "win32" && !socketPath.startsWith("\0")) {
+                    await chmod(socketPath, 0o600);
+                    // Record which filesystem entry THIS listener created; shutdown
+                    // removes the path only while this identity still matches.
+                    return resolve(await statSocketIdentity(socketPath));
+                }
+                resolve(undefined);
+            }
+            catch (cause) {
+                reject(cause);
+            }
+        });
+    });
+}
+//# sourceMappingURL=host-socket-bind.js.map

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

@@ -5,6 +5,7 @@
  * behind it. `host-probe` builds the typed questions on top of it.
  */
 import { type Socket } from "node:net";
+import { type RpcKeyOptions } from "./rpc-auth-client.ts";
 export declare const PROBE_REQUEST_ID = "ensure-host-probe";
 /** One probe's outcome: whether the socket accepted a connection, and the answer if one arrived. */
 export interface ProbeOutcome {
@@ -14,8 +15,8 @@ export interface ProbeOutcome {
     readonly kept?: Socket;
 }
 /** Sends one command and returns its `data`, or `undefined` for any failure to get a usable answer. */
-export declare function requestOnSocket(socketPath: string, command: Readonly<Record<string, unknown>>, timeoutMs: number): Promise<unknown>;
-export declare function connectAndAsk(socketPath: string, request: Readonly<Record<string, unknown>>, timeoutMs: number, keep?: boolean): Promise<ProbeOutcome>;
+export declare function requestOnSocket(socketPath: string, command: Readonly<Record<string, unknown>>, timeoutMs: number, options?: RpcKeyOptions): Promise<unknown>;
+export declare function connectAndAsk(socketPath: string, request: Readonly<Record<string, unknown>>, timeoutMs: number, keep?: boolean, options?: RpcKeyOptions): Promise<ProbeOutcome>;
 export declare function readAnswer(text: string, id?: string): unknown;
 export declare function isRecord(value: unknown): value is Readonly<Record<string, unknown>>;
 //# sourceMappingURL=host-socket-request.d.ts.map

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

@@ -5,14 +5,16 @@
  * behind it. `host-probe` builds the typed questions on top of it.
  */
 import { createConnection } from "node:net";
+import { connectAuthenticatedRpcSocket } from "./rpc-auth-client.js";
+import { RpcEndpointAuthError } from "./rpc-auth-proof.js";
 import { readSocketSecret, resolveSocketTransportAddress, sendSocketHandshake, socketSecretPath, } from "./socket-transport.js";
 import { socketNeedsHandshake } from "./tui-socket.js";
 export const PROBE_REQUEST_ID = "ensure-host-probe";
 /** Sends one command and returns its `data`, or `undefined` for any failure to get a usable answer. */
-export async function requestOnSocket(socketPath, command, timeoutMs) {
-    return (await connectAndAsk(socketPath, { id: PROBE_REQUEST_ID, ...command }, timeoutMs)).answer;
+export async function requestOnSocket(socketPath, command, timeoutMs, options = {}) {
+    return (await connectAndAsk(socketPath, { id: PROBE_REQUEST_ID, ...command }, timeoutMs, false, options)).answer;
 }
-export async function connectAndAsk(socketPath, request, timeoutMs, keep = false) {
+export async function connectAndAsk(socketPath, request, timeoutMs, keep = false, options = {}) {
     let secret;
     if (socketNeedsHandshake(socketPath)) {
         try {
@@ -22,16 +24,39 @@ export async function connectAndAsk(socketPath, request, timeoutMs, keep = false
             return { connected: false, answer: undefined };
         }
     }
-    return new Promise((resolveProbe) => {
-        const socket = createConnection(resolveSocketTransportAddress(socketPath, process.platform, secret));
+    let authenticated;
+    const deadline = Date.now() + timeoutMs;
+    if (!socketNeedsHandshake(socketPath)) {
+        try {
+            authenticated = await connectAuthenticatedRpcSocket(socketPath, request.type === "get_protocol_info" ? request : undefined, options, timeoutMs);
+        }
+        catch (cause) {
+            if (cause instanceof RpcEndpointAuthError)
+                throw cause;
+            return {
+                connected: cause instanceof Error && "rpcSocketConnected" in cause && cause.rpcSocketConnected === true,
+                answer: undefined,
+            };
+        }
+        if (request.type === "get_protocol_info") {
+            const answer = authenticated.protocol.data ?? {};
+            if (keep)
+                return { connected: true, answer, kept: authenticated.socket };
+            authenticated.socket.destroy();
+            return { connected: true, answer };
+        }
+    }
+    return new Promise((resolveProbe, rejectProbe) => {
+        const socket = authenticated?.socket ?? createConnection(resolveSocketTransportAddress(socketPath, process.platform, secret));
         let buffer = "";
         let settled = false;
-        let connected = false;
+        let connected = authenticated !== undefined;
         const finish = (value) => {
             if (settled)
                 return;
             settled = true;
             clearTimeout(timeout);
+            socket.removeAllListeners("data");
             if (keep && value !== undefined && !socket.destroyed) {
                 resolveProbe({ connected, answer: value, kept: socket });
                 return;
@@ -39,11 +64,11 @@ export async function connectAndAsk(socketPath, request, timeoutMs, keep = false
             socket.destroy();
             resolveProbe({ connected, answer: value });
         };
-        const timeout = setTimeout(() => finish(), timeoutMs);
-        socket.once("connect", () => {
+        const timeout = setTimeout(() => finish(), Math.max(0, deadline - Date.now()));
+        const send = () => {
             connected = true;
             socket.write(`${JSON.stringify(request)}\n`);
-        });
+        };
         socket.on("data", (chunk) => {
             buffer += chunk.toString("utf8");
             for (;;) {
@@ -52,9 +77,25 @@ export async function connectAndAsk(socketPath, request, timeoutMs, keep = false
                     return;
                 const line = buffer.slice(0, newline);
                 buffer = buffer.slice(newline + 1);
+                let value;
+                try {
+                    value = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (isRecord(value) &&
+                    value.id === request.id &&
+                    (value.errorCode === "auth_required" || value.errorCode === "auth_failed")) {
+                    clearTimeout(timeout);
+                    settled = true;
+                    socket.destroy();
+                    rejectProbe(new RpcEndpointAuthError(value.errorCode, `${socketPath}; set SENPI_RPC_KEY_ROOT to the host's agent dir`));
+                    return;
+                }
                 // A host broadcasts lifecycle records to every connection, so the reply to THIS
                 // request is the line carrying its id - not simply the first line that arrives.
-                const answer = readAnswer(line);
+                const answer = readAnswer(line, typeof request.id === "string" ? request.id : PROBE_REQUEST_ID);
                 if (answer !== undefined)
                     return finish(answer);
             }
@@ -67,6 +108,10 @@ export async function connectAndAsk(socketPath, request, timeoutMs, keep = false
         // of becoming the expected "no existing host" result for the next ensure.
         if (secret)
             sendSocketHandshake(socket, secret);
+        if (authenticated)
+            send();
+        else
+            socket.once("connect", send);
     });
 }
 export function readAnswer(text, id = PROBE_REQUEST_ID) {

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

@@ -92,11 +92,12 @@ export declare function readHostStatus(options: HostStatusOptions, read?: HostSt
  * falls back to the RECORDED generation, so only this says whether the socket named an instance - and
  * `listing` is every row `list_sessions` returned, whether or not the report publishes them.
  */
-export declare function probeHostStatus(options: HostStatusOptions, read?: HostStatusReadOptions): Promise<{
+export declare function probeHostStatus(options: HostStatusOptions, read?: HostStatusReadOptions): Promise<HostStatusProbe>;
+interface HostStatusProbe {
     readonly report: HostStatusReport;
     readonly answered: HostProtocolInfo | undefined;
     readonly listing: readonly HostSessionRow[];
-}>;
+}
 /**
  * The occupancy a stop decision is made on. A host that does not answer holds nothing a client can
  * see, and an empty count is what lets a stop proceed against a socket nobody serves.

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

@@ -20,6 +20,7 @@ import { electPointer } from "./host-pointer-election.js";
 import { observeProtocolInfo, requestOnSocket } from "./host-probe.js";
 import { readHostProcessMetrics } from "./host-process-metrics.js";
 import { parseSessionRows, readClaimRows } from "./host-status-rows.js";
+import { rpcKeyRoot, withRpcKeyRoot } from "./rpc-auth-client.js";
 const STATUS_PROBE_TIMEOUT_MS = 10_000;
 export async function readHostStatus(options, read = {}) {
     return (await probeHostStatus(options, read)).report;
@@ -31,6 +32,10 @@ export async function readHostStatus(options, read = {}) {
  * `listing` is every row `list_sessions` returned, whether or not the report publishes them.
  */
 export async function probeHostStatus(options, read = {}) {
+    // The host's key record lives under its own agent dir; a looker that names it proves the key from there.
+    return withRpcKeyRoot(rpcKeyRoot({}, options.agentDir), () => probeHostStatusInKeyRoot(options, read));
+}
+async function probeHostStatusInKeyRoot(options, read) {
     const paths = createHostDaemonPaths({
         socket: options.socket,
         ...(options.agentDir ? { agentDir: options.agentDir } : {}),

package/dist/modes/rpc/host-supervisor-log.d.ts

@@ -4,6 +4,7 @@
  */
 export declare function writeStderrLine(text: string): void;
 export declare function supervisorLog(message: string): void;
+export declare function writeHostReady(socket: string, coldStart: string, idleExitMs: number): void;
 export declare function logUnknownHostIdentity(record: "legacy_host.pid" | "host.pid" | "session-path-claim", pid: number): void;
 export declare function errorMessage(cause: unknown): string;
 //# sourceMappingURL=host-supervisor-log.d.ts.map

package/dist/modes/rpc/host-supervisor-log.js

@@ -14,6 +14,9 @@ export function writeStderrLine(text) {
 export function supervisorLog(message) {
     writeStderrLine(`senpi rpc host supervisor: ${message}`);
 }
+export function writeHostReady(socket, coldStart, idleExitMs) {
+    writeStderrLine(`senpi rpc host ready on unix://${socket} (coldStart=${coldStart}, idleExitMs=${coldStart === "persistent" ? "never" : String(idleExitMs)})`);
+}
 // Identity refusal loops share one process-local diagnostic budget, not a persisted latch.
 const loggedUnknownIdentities = new Set();
 export function logUnknownHostIdentity(record, pid) {

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

@@ -41,7 +41,14 @@ export interface HostWatchdogConfig {
  */
 export declare function readHostWatchdogConfig(env?: Readonly<Record<string, string | undefined>>): HostWatchdogConfig | undefined;
 /** Same configuration, resolved through the brand-aware env prefixes. */
-export declare function readHostWatchdogConfigFromBrandEnv(): HostWatchdogConfig | undefined;
+export declare function readHostWatchdogConfigFromBrandEnv(env?: NodeJS.ProcessEnv): HostWatchdogConfig | undefined;
+/**
+ * Reads the supervisor binding once and removes it from `env` (senpi#3815 review L4), so no tool, shell or nested host
+ * this host starts inherits a binding to a supervisor that is not its own. The generation identity (instance id,
+ * daemon dir) stays: sessions use it to name the host they run in.
+ */
+export declare function consumeHostWatchdogEnv(env?: NodeJS.ProcessEnv): HostWatchdogConfig | undefined;
+export declare function scrubHostWatchdogEnv(env?: NodeJS.ProcessEnv): void;
 /**
  * Arms the configured watchdog. `onSupervisorGone` receives the reason and is
  * expected to perform the host's normal clean shutdown; the scratch directory