@code-yeongyu/senpi 2026.10.11 → 2026.10.12

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

@@ -0,0 +1,211 @@
+import { StringDecoder } from "node:string_decoder";
+import { hostStoppingResponse } from "./host-admission.js";
+import { MAX_RPC_LINE_CHARACTERS, serializeJsonLine } from "./jsonl.js";
+/**
+ * Requests are size-bounded; each direction awaits downstream socket backpressure.
+ * Opens remain concurrent with control commands. Stop refuses every pending open,
+ * while other commands retain their wire order and child-owned semantics.
+ */
+export function proxyWithAdmission(client, internal, admission) {
+    const pending = [];
+    const refused = new Set();
+    let protocols = 0;
+    let refusals = Promise.resolve();
+    const unsubscribe = admission.onStop(() => {
+        refusals = refusePending();
+        return refusals;
+    });
+    async function refusePending() {
+        const ids = pending.splice(0);
+        for (const id of ids)
+            refused.add(id);
+        try {
+            for (const id of ids)
+                await write(client, serializeJsonLine(hostStoppingResponse(id, "open_session", admission)));
+        }
+        catch {
+            fail();
+        }
+    }
+    client.once("close", () => {
+        unsubscribe();
+        internal?.destroy();
+    });
+    const fail = () => {
+        internal?.destroy();
+        client.destroy();
+    };
+    client.once("error", fail);
+    internal?.once("error", () => {
+        if (!admission.stopping)
+            fail();
+    });
+    void requests().catch(() => {
+        if (!admission.stopping)
+            fail();
+    });
+    if (internal)
+        void responses(internal).catch(() => {
+            if (!admission.stopping)
+                fail();
+        });
+    async function requests() {
+        for await (const line of lines(client, MAX_RPC_LINE_CHARACTERS)) {
+            if (line === undefined) {
+                await write(client, serializeJsonLine({
+                    type: "response",
+                    command: "parse",
+                    success: false,
+                    error: `RPC input line exceeds ${MAX_RPC_LINE_CHARACTERS} characters.`,
+                }));
+                continue;
+            }
+            const request = record(line);
+            if (admission.stopping && request?.type === "get_protocol_info") {
+                await write(client, serializeJsonLine({
+                    id: request.id,
+                    type: "response",
+                    command: request.type,
+                    success: true,
+                    data: admission.protocol(),
+                }));
+            }
+            else if (admission.stopping && (request?.type === "open_session" || !internal)) {
+                await write(client, serializeJsonLine(hostStoppingResponse(request?.id, String(request?.type ?? "parse"), admission)));
+            }
+            else if (internal) {
+                // Record admission before writing: a child response can arrive immediately.
+                if (request?.type === "open_session")
+                    pending.push(request.id);
+                if (request?.type === "get_protocol_info")
+                    protocols++;
+                await write(internal, `${line}\n`);
+            }
+        }
+        internal?.end();
+    }
+    async function responses(source) {
+        // Keep complete records together so local refusals cannot split a streaming delta.
+        // After admission, ordinary traffic stays as raw bytes with one write per chunk.
+        let fragments = [];
+        for await (const chunk of source) {
+            const newline = chunk.lastIndexOf(0x0a);
+            if (newline === -1) {
+                fragments.push(chunk);
+                continue;
+            }
+            const complete = chunk.subarray(0, newline + 1);
+            if (pending.length === 0 && protocols === 0 && refused.size === 0) {
+                // Queue the entire record batch synchronously, without copying split buffers.
+                client.cork();
+                let written;
+                try {
+                    for (const fragment of fragments)
+                        client.write(fragment);
+                    written = write(client, complete);
+                }
+                finally {
+                    client.uncork();
+                }
+                await written;
+            }
+            else {
+                const batch = fragments.length > 0 ? Buffer.concat([...fragments, complete]) : complete;
+                await write(client, filterReplies(batch));
+            }
+            fragments = newline + 1 < chunk.length ? [chunk.subarray(newline + 1)] : [];
+        }
+        if (fragments.length > 0)
+            await write(client, filterReplies(Buffer.concat(fragments)));
+        await refusals;
+        client.end(() => client.destroy());
+    }
+    function filterReplies(batch) {
+        if (pending.length === 0 && protocols === 0 && refused.size === 0)
+            return batch;
+        const output = [];
+        let changed = false;
+        for (let start = 0; start < batch.length;) {
+            const newline = batch.indexOf(0x0a, start);
+            const end = newline === -1 ? batch.length : newline + 1;
+            const line = batch.subarray(start, end);
+            start = end;
+            // Only lifecycle responses need decoding; histories and deltas remain byte slices.
+            const response = line.includes('"open_session"') || line.includes('"get_protocol_info"')
+                ? record(line.toString("utf8"))
+                : undefined;
+            if (response?.type === "response" && response.command === "open_session") {
+                if (refused.has(response.id)) {
+                    changed = true;
+                    continue;
+                }
+                const index = pending.indexOf(response.id);
+                if (index !== -1)
+                    pending.splice(index, 1);
+            }
+            if (response?.type === "response" && response.command === "get_protocol_info") {
+                protocols = Math.max(0, protocols - 1);
+                if (response.success === true) {
+                    if (isRecord(response.data))
+                        admission.observe(response.data);
+                    output.push(Buffer.from(serializeJsonLine({ ...response, data: admission.protocol() })));
+                    changed = true;
+                    continue;
+                }
+            }
+            output.push(line);
+        }
+        return changed ? Buffer.concat(output) : batch;
+    }
+}
+async function write(socket, line) {
+    await new Promise((resolve, reject) => {
+        socket.write(line, (error) => (error ? reject(error) : resolve()));
+    });
+}
+/** Strict LF and incremental UTF-8; an oversized input is discarded through its next LF. */
+async function* lines(socket, limit) {
+    const decoder = new StringDecoder("utf8");
+    let buffer = "";
+    let discarding = false;
+    for await (const chunk of socket) {
+        const text = typeof chunk === "string" ? chunk : decoder.write(chunk);
+        let offset = 0;
+        while (offset < text.length) {
+            const newline = text.indexOf("\n", offset);
+            const end = newline === -1 ? text.length : newline;
+            if (!discarding) {
+                if (buffer.length + end - offset > limit) {
+                    buffer = "";
+                    discarding = true;
+                    yield undefined;
+                }
+                else
+                    buffer += text.slice(offset, end);
+            }
+            if (newline === -1)
+                break;
+            if (!discarding)
+                yield buffer;
+            buffer = "";
+            discarding = false;
+            offset = newline + 1;
+        }
+    }
+    buffer += decoder.end();
+    if (!discarding && buffer.length > 0)
+        yield buffer;
+}
+function record(line) {
+    try {
+        const value = JSON.parse(line);
+        return isRecord(value) ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=host-admission-proxy.js.map

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

@@ -0,0 +1,21 @@
+/**
+ * The public admission authority lives on the supervisor's loop. A ready probe is
+ * informational: every open must still pass this gate, including on held sockets.
+ */
+export declare class HostAdmission {
+    private stopped;
+    private readonly listeners;
+    private replies;
+    private info;
+    constructor(info: Readonly<Record<string, unknown>>);
+    get stopping(): boolean;
+    protocol(): Readonly<Record<string, unknown>>;
+    observe(info: Readonly<Record<string, unknown>>): void;
+    /** Synchronous and monotonic; runs before any child signal or awaited teardown. */
+    stop(): void;
+    /** Flush within the caller's existing five-second cleanup allowance; a stalled reader cannot pin exit. */
+    flush(): Promise<void>;
+    onStop(listener: () => Promise<void>): () => void;
+}
+export declare function hostStoppingResponse(id: unknown, command: string, admission: HostAdmission): object;
+//# sourceMappingURL=host-admission.d.ts.map

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

@@ -0,0 +1,59 @@
+/**
+ * The public admission authority lives on the supervisor's loop. A ready probe is
+ * informational: every open must still pass this gate, including on held sockets.
+ */
+export class HostAdmission {
+    constructor(info) {
+        this.stopped = false;
+        this.listeners = new Set();
+        this.replies = Promise.resolve();
+        this.info = info;
+    }
+    get stopping() {
+        return this.stopped;
+    }
+    protocol() {
+        return { ...this.info, lifecycle: this.stopped ? "stopping" : "ready" };
+    }
+    observe(info) {
+        this.info = info;
+    }
+    /** Synchronous and monotonic; runs before any child signal or awaited teardown. */
+    stop() {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        this.replies = Promise.all([...this.listeners].map((listener) => listener())).then(() => { });
+    }
+    /** Flush within the caller's existing five-second cleanup allowance; a stalled reader cannot pin exit. */
+    async flush() {
+        let timer;
+        try {
+            await Promise.race([
+                this.replies,
+                new Promise((resolve) => {
+                    timer = setTimeout(resolve, 2_000);
+                }),
+            ]);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    onStop(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+}
+export function hostStoppingResponse(id, command, admission) {
+    return {
+        ...(typeof id === "string" ? { id } : {}),
+        type: "response",
+        command,
+        success: false,
+        error: "host_stopping",
+        errorCode: "host_stopping",
+        errorData: { instanceId: admission.protocol().instanceId },
+    };
+}
+//# sourceMappingURL=host-admission.js.map

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

@@ -1,6 +1,6 @@
 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 { AUTO_TITLE_PER_SESSION_CAPABILITY, AUTO_TITLE_SESSIONS_CAPABILITY, BROWSER_ENGINE_CAPABILITY, CONTINUE_FROM_LEAF_CAPABILITY, DURABLE_SESSION_ID_CAPABILITY, MEDIA_PLACEHOLDERS_CAPABILITY, MOVED_PATH_GUARD_CAPABILITY, PROMPT_SURFACE_CAPABILITY, PROMPT_SURFACE_CHAT_CAPABILITY, RETAIN_ON_DISCONNECT_CAPABILITY, RETRY_FALLBACK_PROFILE_CAPABILITY, SESSION_CONTEXT_CAPABILITY, SESSION_HELD_CAPABILITY, SESSION_KIND_CAPABILITY, WARM_CAPABILITY, } from "./custom-capability.js";
+import { AUTO_TITLE_PER_SESSION_CAPABILITY, AUTO_TITLE_SESSIONS_CAPABILITY, BROWSER_ENGINE_CAPABILITY, CONTINUE_FROM_LEAF_CAPABILITY, DURABLE_SESSION_ID_CAPABILITY, EVAL_CELLS_CAPABILITY, MEDIA_PLACEHOLDERS_CAPABILITY, MOVED_PATH_GUARD_CAPABILITY, PROMPT_SURFACE_CAPABILITY, PROMPT_SURFACE_CHAT_CAPABILITY, RETAIN_ON_DISCONNECT_CAPABILITY, RETRY_FALLBACK_PROFILE_CAPABILITY, SESSION_CONTEXT_CAPABILITY, SESSION_HELD_CAPABILITY, SESSION_KIND_CAPABILITY, WARM_CAPABILITY, } from "./custom-capability.js";
 /**
  * The capabilities a multi-session host advertises in `get_protocol_info`, in their wire order. `warm` is added only
  * when the runtime is in-process, and `negotiated` carries the launch capabilities this connection was given.
@@ -13,6 +13,7 @@ export function multiSessionHostCapabilities(options) {
             MEDIA_PLACEHOLDERS_CAPABILITY,
             DURABLE_CLIENT_MESSAGE_ID_CAPABILITY,
             CONTINUE_FROM_LEAF_CAPABILITY,
+            EVAL_CELLS_CAPABILITY,
             // Both shared runtimes dispatch through the active session-writing holder guard.
             SESSION_HELD_CAPABILITY,
             // Host capabilities, not client opt-ins: only a multi-session host owns the

package/dist/modes/rpc/host-client-occupancy.d.ts

@@ -14,10 +14,11 @@ export declare class ClientOccupancy {
     private readonly observers;
     private readonly attached;
     private readonly onAttach;
+    private closed;
     constructor(onAttach: () => void);
     get attachedCount(): number;
     get unclassifiedCount(): number;
-    admit(client: Socket): void;
+    admit(client: Socket): boolean;
     /** Returns whether this peer left without ever proving it was an observing read. */
     release(client: Socket): boolean;
     destroyAll(): void;

package/dist/modes/rpc/host-client-occupancy.js

@@ -6,6 +6,7 @@ export class ClientOccupancy {
         this.clients = new Set();
         this.observers = new Set();
         this.attached = new Set();
+        this.closed = false;
         this.onAttach = onAttach;
     }
     get attachedCount() {
@@ -15,6 +16,10 @@ export class ClientOccupancy {
         return this.clients.size - this.observers.size - this.attached.size;
     }
     admit(client) {
+        if (this.closed) {
+            client.destroy();
+            return false;
+        }
         this.clients.add(client);
         let pending = Buffer.alloc(0);
         const attach = () => {
@@ -39,6 +44,7 @@ export class ClientOccupancy {
                 attach();
         };
         client.on("data", classify);
+        return true;
     }
     /** Returns whether this peer left without ever proving it was an observing read. */
     release(client) {
@@ -49,6 +55,7 @@ export class ClientOccupancy {
         return unclassified;
     }
     destroyAll() {
+        this.closed = true;
         for (const client of this.clients)
             client.destroy();
     }

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

@@ -62,7 +62,7 @@ export type HostDecision = {
     readonly upgradeable: false;
 } | {
     readonly action: "refuse";
-    readonly reason: "protocol" | "capability";
+    readonly reason: "protocol" | "capability" | "host_stopping";
     readonly upgradeable: false;
 } | {
     readonly action: "fallback";
@@ -85,7 +85,7 @@ export type AttachOnlyDecision = Extract<HostDecision, {
     action: "start" | "reuse" | "refuse";
 }>;
 /** Why an ensure refused. The decision's own refusals plus the one only a pidfile can produce. */
-export type HostRefusalReason = "protocol" | "capability" | "foreign_writer" | "legacy_host" | "host_busy" | "host_stalled";
+export type HostRefusalReason = "protocol" | "capability" | "foreign_writer" | "legacy_host" | "host_busy" | "host_stopping" | "host_stalled";
 /**
  * An ensure that found an unusable host and refused to act on it. A refusal is FINAL by design:
  * this process may not signal a host it did not start (I1), and starting a second host on an

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

@@ -63,6 +63,8 @@ function refusalDetail(reason, host) {
             return "a host from before the per-socket daemon directory is still running; it is drained and replaced only while it holds no session, and no second host is started beside it";
         case "host_busy":
             return "its socket accepts connections but did not answer inside the probe budget: a live host under load, which is never ended to make room for a replacement";
+        case "host_stopping":
+            return "this generation is stopping; wait for its exit before launching a successor";
         case "host_stalled":
             return "nothing reaches its socket, but its process is alive and its own loop-lag watchdog measured a recent stall: a stalled host is still serving its sessions, so it is neither stopped nor replaced";
         default:
@@ -73,6 +75,8 @@ export function decideHostAction(client, host, policy) {
     if (host === undefined) {
         return { action: "start", reason: client.startedByUs ? "restart_own_host" : "no_host", upgradeable: false };
     }
+    if (host.lifecycle === "stopping")
+        return { action: "refuse", reason: "host_stopping", upgradeable: false };
     if (host.protocolVersion !== client.protocolVersion) {
         return { action: "refuse", reason: "protocol", upgradeable: false };
     }

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

@@ -22,6 +22,8 @@ export interface EnsureHostOptions {
     readonly env?: Readonly<Record<string, string | null>>;
     /** Whether a newer build may take the socket over from the running host. Defaults to `never`. */
     readonly upgrade?: HostUpgradePolicy;
+    /** Maximum wait for an already-stopping generation; capped by the normal stop budget. */
+    readonly stoppingTimeoutMs?: number;
     readonly _test?: {
         readonly readinessTimeoutMs?: number;
         readonly stopTimeoutMs?: number;

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

@@ -10,7 +10,7 @@ import { ensureClient } from "./host-ensure-client.js";
 import { publicEndpointAccepts, refuseIfStalled } from "./host-ensure-liveness.js";
 import { hostEnsureLockOptions, hostEnsureLockTarget } from "./host-ensure-lock.js";
 import { appendStderr, DEFAULT_READINESS_TIMEOUT_MS, DEFAULT_STOP_TIMEOUT_MS, startHost } from "./host-ensure-start.js";
-import { ensureSender, matchesPidFileOrUnknown, STOP_WAIT_BUDGET_MS, stopManagedHost } from "./host-ensure-stop.js";
+import { delay, ensureSender, matchesPidFileOrUnknown, resolvePidFileOwnership, STOP_WAIT_BUDGET_MS, stopManagedHost, } from "./host-ensure-stop.js";
 import { scheduleOpportunisticHostGc } from "./host-gc-pass.js";
 import { HANDOFF_LOCK_HOLD_MS, handoffHostLocked } from "./host-handoff.js";
 import { reapOrphanedInternalHostDirs } from "./host-internal-dir-reaper.js";
@@ -67,7 +67,7 @@ export async function ensureHost(options) {
     scheduleOpportunisticHostGc({ agentDir: options.agentDir ?? getAgentDir(), exclude: socket });
     return ensured;
 }
-async function ensureHostLocked(paths, socket, options) {
+async function ensureHostLocked(paths, socket, options, stopDeadline = Date.now() + Math.min(options.stoppingTimeoutMs ?? STOP_WAIT_BUDGET_MS, STOP_WAIT_BUDGET_MS)) {
     // Under the lock, so a torn or foreign `endpoint.json` is repaired rather than left unaddressable.
     await ensureEndpointIdentity(paths, socket, { repair: true });
     const testOptions = options._test;
@@ -84,6 +84,23 @@ async function ensureHostLocked(paths, socket, options) {
     // A reusable host is held from the connection that proved it compatible, never re-probed later.
     const held = await holdProtocolInfo(socket, EXISTING_HOST_PROBE_TIMEOUT_MS);
     const protocol = held?.info;
+    if (protocol?.lifecycle === "stopping") {
+        held?.hold.release();
+        // A typed stop is not permission to signal or overwrite a foreign generation.
+        // Wait for BOTH identities to be gone, then re-run discovery under this lock.
+        if (!registeredHere || !registered || registered.instanceId !== protocol.instanceId)
+            throw new HostEnsureRefusedError(socket, "host_stopping", protocol, "no matching registered generation");
+        const generation = generationPaths(paths, registered.instanceId);
+        for (;;) {
+            if ((await resolvePidFileOwnership(registered.record, testOptions?.readProcessStartTime)) === "gone" &&
+                !(await hostChildAlive(generation)))
+                return ensureHostLocked(paths, socket, options, stopDeadline);
+            const remaining = stopDeadline - Date.now();
+            if (remaining <= 0)
+                throw new HostEnsureRefusedError(socket, "host_stopping", protocol, "generation exit exceeded stop budget");
+            await delay(Math.min(50, remaining));
+        }
+    }
     const startedByUs = registeredHere && (await writtenByThisProcess(registered?.writer, testOptions?.readProcessStartTime));
     const attachedPid = registeredHere ? (registered?.record.pid ?? 0) : 0;
     const decision = decide(options, startedByUs, protocol);
@@ -110,7 +127,14 @@ async function ensureHostLocked(paths, socket, options) {
         case "refuse":
             throw new HostEnsureRefusedError(socket, decision.reason, protocol);
         case "handoff":
-            return upgradeGeneration(paths, socket, options, attachedPid);
+            try {
+                return await upgradeGeneration(paths, socket, options, attachedPid);
+            }
+            catch (cause) {
+                if (cause instanceof HostEnsureRefusedError && cause.reason === "host_stopping")
+                    return ensureHostLocked(paths, socket, options, stopDeadline);
+                throw cause;
+            }
         case "start":
             break;
         default:
@@ -198,6 +222,10 @@ async function holdEnsured(socket) {
     const held = await holdProtocolInfo(socket, EXISTING_HOST_PROBE_TIMEOUT_MS);
     if (!held)
         throw new Error(`RPC socket host at ${socket} stopped answering before this ensure could hold it`);
+    if (held.info.lifecycle === "stopping") {
+        held.hold.release();
+        throw new HostEnsureRefusedError(socket, "host_stopping", held.info);
+    }
     return held.hold.release;
 }
 /** Whether a registration is about this endpoint. A record written before the field existed is. */

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

@@ -11,7 +11,8 @@ export declare class SupervisorDrain {
     private graceTimer;
     private readonly child;
     private readonly shuttingDown;
-    constructor(child: ChildProcess, shuttingDown: () => boolean);
+    private readonly beginStopping;
+    constructor(child: ChildProcess, shuttingDown: () => boolean, beginStopping?: () => void);
     get active(): boolean;
     /**
      * Ask the child to announce and park attached sessions as turns/requests settle. The supervisor

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

@@ -3,10 +3,11 @@ import { DEFAULT_HANDOFF_GRACE_MS, HANDOFF_GRACE_MS_ENV, parseIdleExitMs } from
 import { watchForSupersession } from "./host-supersession.js";
 import { errorMessage, supervisorLog } from "./host-supervisor-log.js";
 export class SupervisorDrain {
-    constructor(child, shuttingDown) {
+    constructor(child, shuttingDown, beginStopping = () => { }) {
         this.draining = false;
         this.child = child;
         this.shuttingDown = shuttingDown;
+        this.beginStopping = beginStopping;
     }
     get active() {
         return this.draining;
@@ -20,6 +21,7 @@ export class SupervisorDrain {
         if (this.draining || this.shuttingDown())
             return;
         this.draining = true;
+        this.beginStopping();
         supervisorLog("draining into the next generation");
         const graceMs = parseIdleExitMs(process.env[HANDOFF_GRACE_MS_ENV]) ?? DEFAULT_HANDOFF_GRACE_MS;
         this.graceTimer = setTimeout(() => {

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

@@ -1,4 +1,5 @@
 import { type Server } from "node:net";
+import type { HostAdmission } from "./host-admission.ts";
 import type { ClientOccupancy } from "./host-client-occupancy.ts";
 import { type SocketFileIdentity } from "./socket-ownership.ts";
 export interface PublicProxyOptions {
@@ -6,8 +7,8 @@ export interface PublicProxyOptions {
     readonly internalSecret?: Buffer;
     readonly publicSecret?: Buffer;
     readonly clients: ClientOccupancy;
-    /** True while the supervisor accepts nothing new: shutting down or draining. */
-    readonly refusing: () => boolean;
+    /** Shared authority for stopping, protocol replies and new-session admission. */
+    readonly admission: HostAdmission;
     /** A client went away: occupancy changed. */
     readonly onDetach: () => void;
     /** A dropped unclassified admission breaks quiescence; a proven observing read does not. */

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

@@ -6,46 +6,37 @@
 import { access, chmod, mkdir, rename, unlink } from "node:fs/promises";
 import { createConnection, createServer } from "node:net";
 import { dirname } from "node:path";
+import { proxyWithAdmission } from "./host-admission-proxy.js";
 import { MAX_SOCKET_PATH_BYTES, statSocketIdentity } 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 accept = () => {
-            // A draining supervisor serves what it already proxies and accepts nothing new. After a
-            // handoff the public path resolves to the successor anyway; this covers the connection
-            // that raced the rename, and a drain-stop with no successor at all.
-            if (options.refusing()) {
-                client.destroy();
+            // Teardown is terminal even for an accept that raced socket shielding/server.close.
+            if (!clients.admit(client))
                 return;
-            }
-            const internal = createConnection(resolveSocketTransportAddress(internalSocket, process.platform, internalSecret));
-            if (internalSecret)
+            // Draining peers can still probe and receive typed open refusals, without a child hop.
+            const internal = options.admission.stopping
+                ? undefined
+                : createConnection(resolveSocketTransportAddress(internalSocket, process.platform, internalSecret));
+            if (internal && internalSecret)
                 sendSocketHandshake(internal, internalSecret);
             // A readiness exchange can begin and end between ticks: the client is recorded the
             // moment its first request line arrives, before a later tick can reuse the preceding
             // idle window. An observing read (`status`) is never recorded (host-client-occupancy.ts).
-            clients.admit(client);
             const detach = () => {
                 // Classification resets activity for attachments. Defer the unknown-admission reset
                 // until release so a status read never resets owner grace, even between ticks.
                 if (clients.release(client))
                     options.onAdmit?.();
                 options.onDetach();
-                internal.destroy();
+                internal?.destroy();
                 client.destroy();
             };
-            client.pipe(internal);
-            internal.pipe(client);
+            proxyWithAdmission(client, internal, options.admission);
             client.once("close", detach);
             client.once("error", detach);
-            // Let the final lifecycle records drain through the public socket before closing it.
-            internal.once("end", () => client.end(() => client.destroy()));
-            internal.once("close", () => {
-                if (!internal.readableEnded)
-                    detach();
-            });
-            internal.once("error", detach);
         };
         if (publicSecret)
             authenticateSocket(client, publicSecret, accept);

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

@@ -5,6 +5,7 @@
  */
 import type { ChildProcess } from "node:child_process";
 import type { Server } from "node:net";
+import type { HostAdmission } from "./host-admission.ts";
 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";
@@ -31,6 +32,7 @@ export interface SupervisorShutdown {
     readonly child: ChildProcess;
     readonly activity: SupervisorActivity;
     readonly drain: SupervisorDrain;
+    readonly admission: HostAdmission;
     readonly state: SupervisorState;
     /** Stops the idle ticker, the supersession watch and the win32 identity watchdog. */
     readonly stopWatchers: () => void;

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

@@ -18,17 +18,19 @@ export async function performShutdown(context, reason, exitCode) {
     const { state, child } = context;
     state.shuttingDown = true;
     state.shutdownReason = reason;
+    context.admission.stop();
     let childStopStarted = false;
     let hardExit;
     try {
         context.stopWatchers();
         context.drain.stop();
         writeStderrLine(`senpi rpc host supervisor: ${reason} shutdown`);
-        context.activity.clients.destroyAll();
         // No fallible socket/metadata cleanup may bypass the child's observed exit.
         childStopStarted = true;
         await stopChild(context, reason);
         await state.childExitRecorded;
+        await context.admission.flush();
+        context.activity.clients.destroyAll();
         if (process.platform === "win32")
             hardExit = setTimeout(() => process.exit(exitCode), WINDOWS_SUPERVISOR_SHUTDOWN_HARD_EXIT_MS);
         // libuv unlinks the bound NAME when the listening handle closes - which would delete a newer

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

@@ -0,0 +1,11 @@
+import type { SupervisorActivity, SupervisorOwner } from "./host-lifecycle-activity.ts";
+/** Idle and lifetime-owner checks share one ticker and never overlap owner probes. */
+export declare function startSupervisorTicker(options: {
+    readonly idleExitMs: number;
+    readonly activity: SupervisorActivity;
+    readonly owner: SupervisorOwner;
+    readonly draining: () => boolean;
+    readonly shuttingDown: () => boolean;
+    readonly shutdown: (reason: string, exitCode: number) => Promise<never>;
+}): () => void;
+//# sourceMappingURL=host-lifecycle-ticker.d.ts.map