@code-yeongyu/senpi 2026.10.6 → 2026.10.8

package/dist/modes/rpc/host-handoff-unregistered.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A handoff away from a host that no layout-2 registration proves (#2701).
+ *
+ * After an upgrade the old host is often still serving the very socket the updated client uses, and the
+ * only evidence of who it is may be a flat pre-layout-2 record - or nothing provable at all. Refusing
+ * such a host with `unknown_owner` left the client unable to replace it until somebody drained it by
+ * hand. An IDLE one is replaced instead; one that holds work never is.
+ *
+ * - The sessions are counted over a connection that stays open, and counted again over that same
+ *   connection once the successor owns the socket: the recount reaches the old process, and a session
+ *   it accepted in between is seen there.
+ * - A flat record that proves the process is the only licence to signal it, and the signal is a DRAIN
+ *   (SIGUSR1), sent only when the recount still finds no session. A drain ends no work either way.
+ * - Without a provable owner nothing is signalled: the old host notices that it lost the public entry
+ *   and drains itself (`host-supersession.ts`). That predecessor is named in one warning line, so an
+ *   old host that outlives the handoff can still be identified.
+ */
+import type { HostDaemonPaths } from "./host-daemon-paths.ts";
+import type { HostProtocolInfo } from "./host-decision.ts";
+import type { HandoffHostOptions, HandoffResult } from "./host-handoff.ts";
+/** One session count; an unregistered host is counted twice (before the swap and over the held connection after). */
+export declare const SESSION_COUNT_TIMEOUT_MS = 10000;
+export declare function handoffUnregisteredHost(options: HandoffHostOptions, paths: HostDaemonPaths, host: HostProtocolInfo): Promise<HandoffResult>;
+//# sourceMappingURL=host-handoff-unregistered.d.ts.map

package/dist/modes/rpc/host-handoff-unregistered.js

@@ -0,0 +1,50 @@
+import { busyLegacyHostDetail, describeSessions, provenLegacyOwner } from "./host-legacy.js";
+import { holdSessionCount } from "./host-probe.js";
+import { startSuccessor } from "./host-successor.js";
+/** One session count; an unregistered host is counted twice (before the swap and over the held connection after). */
+export const SESSION_COUNT_TIMEOUT_MS = 10_000;
+export async function handoffUnregisteredHost(options, paths, host) {
+    const counted = await holdSessionCount(options.socket, SESSION_COUNT_TIMEOUT_MS);
+    try {
+        const legacy = await provenLegacyOwner(paths, options.socket);
+        const sessions = counted?.sessions;
+        if (sessions !== 0) {
+            if (legacy !== undefined) {
+                return {
+                    action: "refuse",
+                    reason: "legacy_host",
+                    upgradeable: true,
+                    detail: busyLegacyHostDetail(legacy.pid, options.socket, sessions),
+                };
+            }
+            return {
+                action: "refuse",
+                reason: "unknown_owner",
+                upgradeable: true,
+                detail: `${options.socket} has no provable owner and holds ${describeSessions(sessions)}; it is never signalled - let that work finish, then retry`,
+            };
+        }
+        const result = await startSuccessor({
+            options,
+            paths,
+            host,
+            owner: legacy,
+            drainGate: async () => (await counted?.recount(SESSION_COUNT_TIMEOUT_MS)) === 0,
+        });
+        if (result.action === "handoff" && legacy === undefined)
+            warnUnsignalledPredecessor(options.socket, host);
+        return result;
+    }
+    finally {
+        counted?.close();
+    }
+}
+/**
+ * The one record of a predecessor nobody could prove, on the caller's stderr: the endpoint's log belongs
+ * to the generations writing it. Its pid is not known: no record proves it, and a Unix socket's peer
+ * credentials are not readable from this runtime.
+ */
+function warnUnsignalledPredecessor(socket, host) {
+    process.stderr.write(`generation handoff: no provable owner for ${socket}; the host it replaced (instance ${host.instanceId ?? "unknown"}, engine ${host.engineVersion ?? "unknown"}) listed 0 sessions and was not signalled; it drains itself on losing the public socket\n`);
+}
+//# sourceMappingURL=host-handoff-unregistered.js.map

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

@@ -1,5 +1,8 @@
 import type { HostLifecyclePolicyInput } from "./host-lifecycle.ts";
-/** The longest a handoff holds the ensure lock: its probe of the running host, then the successor's start. */
+/**
+ * The longest a handoff holds the ensure lock: its probe of the running host, the two session counts
+ * an unregistered host gets (before the swap and the recount after it), then the successor's start.
+ */
 export declare const HANDOFF_LOCK_HOLD_MS: number;
 export interface HandoffHostOptions {
     readonly socket: string;
@@ -43,8 +46,10 @@ export type HandoffRefusal =
  | "handoff_unsupported"
 /** win32: a named pipe can be neither renamed nor drained. */
  | "upgrade_unsupported"
-/** The pidfile cannot prove which process serves this socket, so it may not be signalled. */
+/** No record proves which process serves this socket, and that host holds sessions (or will not say). */
  | "unknown_owner"
+/** A host from before layout 2, proven by its flat record, holds sessions; `detail` says how to retire it. */
+ | "legacy_host"
 /** The public socket stopped being the one this handoff was decided against. */
  | "socket_replaced"
 /** `<public>.next-<gen>` would exceed the platform's socket path limit. */

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

@@ -31,11 +31,15 @@ import { createDaemonDirectories, createHostDaemonPaths } from "./host-daemon-pa
 import { provenOwner, readHostRegistration } from "./host-daemon-registration.js";
 import { GENERATION_HANDOFF_CAPABILITY } from "./host-decision.js";
 import { acquireHostEnsureLock } from "./host-ensure-lock.js";
+import { handoffUnregisteredHost, SESSION_COUNT_TIMEOUT_MS } from "./host-handoff-unregistered.js";
 import { probeProtocolInfo } from "./host-probe.js";
 import { SUCCESSOR_START_BUDGET_MS, startSuccessor } from "./host-successor.js";
 const HANDOFF_PROBE_TIMEOUT_MS = 10_000;
-/** The longest a handoff holds the ensure lock: its probe of the running host, then the successor's start. */
-export const HANDOFF_LOCK_HOLD_MS = HANDOFF_PROBE_TIMEOUT_MS + SUCCESSOR_START_BUDGET_MS;
+/**
+ * The longest a handoff holds the ensure lock: its probe of the running host, the two session counts
+ * an unregistered host gets (before the swap and the recount after it), then the successor's start.
+ */
+export const HANDOFF_LOCK_HOLD_MS = HANDOFF_PROBE_TIMEOUT_MS + 2 * SESSION_COUNT_TIMEOUT_MS + SUCCESSOR_START_BUDGET_MS;
 /**
  * How long a handoff waits for the lock. The longest holder is an ensure that probes the running host
  * and then hands it off itself (its upgrade path); 10 s of headroom for a slow runner.
@@ -74,7 +78,7 @@ export async function handoffHostLocked(options) {
     const registered = await readHostRegistration(paths);
     const owner = await provenOwner(registered, options.socket);
     if (!owner)
-        return { action: "refuse", reason: "unknown_owner", upgradeable: true };
+        return handoffUnregisteredHost(options, paths, host);
     return startSuccessor({ options, paths, host, owner });
 }
 function handoffUnsupported(options) {

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

@@ -15,4 +15,7 @@ export declare function provenLegacyOwner(paths: HostDaemonPaths, socket: string
     pid: number;
     processStartTime: string;
 } | undefined>;
+/** Why a proven legacy host that holds work is left alone, and the command that retires it. */
+export declare function busyLegacyHostDetail(pid: number, socket: string, sessions: number | undefined): string;
+export declare function describeSessions(sessions: number | undefined): string;
 //# sourceMappingURL=host-legacy.d.ts.map

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

@@ -96,11 +96,16 @@ async function judgeLegacyHost(paths, probe, platform = process.platform) {
     const sessions = await probeSessionCount(host.socket, LEGACY_PROBE_TIMEOUT_MS);
     if (sessions === 0)
         return { verdict: "idle", host };
-    const held = sessions === undefined ? "an unknown number of sessions" : `${sessions} open session${sessions === 1 ? "" : "s"}`;
-    return {
-        verdict: "held",
-        detail: `${where} holds ${held}; run \`${APP_NAME} host stop --drain --socket ${host.socket}\` to let it finish that work and exit, then retry`,
-    };
+    return { verdict: "held", detail: busyLegacyHostDetail(pid, host.socket, sessions) };
+}
+/** Why a proven legacy host that holds work is left alone, and the command that retires it. */
+export function busyLegacyHostDetail(pid, socket, sessions) {
+    return `pid ${pid} (${socket}) holds ${describeSessions(sessions)}; run \`${APP_NAME} host stop --drain --socket ${socket}\` to let it finish that work and exit, then retry`;
+}
+export function describeSessions(sessions) {
+    return sessions === undefined
+        ? "an unknown number of sessions"
+        : `${sessions} open session${sessions === 1 ? "" : "s"}`;
 }
 /**
  * SIGUSR1, then wait for the proven process to leave. A host that exits before the signal lands has

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

@@ -63,6 +63,7 @@ import { hostCrashCleanupPaths } from "./host-cleanup-paths.js";
 import { createHostDaemonPaths, generationPaths, HOST_DAEMON_DIR_ENV } from "./host-daemon-paths.js";
 import { releaseGeneration } from "./host-daemon-registration.js";
 import { HOST_INSTANCE_ID_ENV } from "./host-identity-env.js";
+import { SessionRunActivity } from "./host-run-activity.js";
 import { watchForSupersession } from "./host-supersession.js";
 import { HOST_CLEANUP_PATHS_ENV, HOST_PUBLIC_SOCKET_ENV, HOST_SCRATCH_DIR_ENV, HOST_WATCH_FD_ENV, HOST_WATCH_PPID_ENV, } from "./host-watchdog.js";
 import { attachJsonlLineReader, MAX_RPC_LINE_CHARACTERS } from "./jsonl.js";
@@ -319,7 +320,7 @@ export async function runHostSupervisor(launch) {
     const internalSecretPath = internal.secretPath ?? socketSecretPath(internalSocket);
     const internalSecret = process.platform === "win32" ? await createSocketSecret(internalSecretPath) : undefined;
     const clients = new ClientOccupancy(() => decider.update(currentActivity()));
-    const busySessions = new Map();
+    const runs = new SessionRunActivity();
     // Declared before anything that can reach `currentActivity()`. A client accepted during startup
     // asks for the activity snapshot, and a `const` read before its initializer runs is a
     // ReferenceError that fails the connection - which is how a successor's first `open_session`
@@ -461,37 +462,13 @@ export async function runHostSupervisor(launch) {
                 unhealthySince: observerLink.unhealthySince(),
                 now: Date.now(),
                 unknownGraceMs: decider.idleExitMs,
-                observedBusy: countBusySessions(),
+                observedBusy: runs.busySessions,
             }),
         };
     }
-    function countBusySessions() {
-        let busy = 0;
-        for (const count of busySessions.values())
-            if (count > 0)
-                busy++;
-        return busy;
-    }
     function observeHostEvent(line) {
-        let event;
-        try {
-            event = JSON.parse(line);
-        }
-        catch {
-            return;
-        }
-        if (typeof event !== "object" || event === null)
-            return;
-        const { type, sessionId } = event;
-        if (typeof sessionId !== "string")
-            return;
-        if (type === "agent_start")
-            busySessions.set(sessionId, (busySessions.get(sessionId) ?? 0) + 1);
-        else if (type === "agent_settled")
-            busySessions.set(sessionId, Math.max(0, (busySessions.get(sessionId) ?? 1) - 1));
-        else
-            return;
-        decider.update(currentActivity());
+        if (runs.observe(line))
+            decider.update(currentActivity());
     }
     async function shutdown(reason, exitCode) {
         // Single-flight: concurrent triggers (listener error, child exit, signals)

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

@@ -32,6 +32,18 @@ export declare function probeSocketReachable(socketPath: string, timeoutMs: numb
  * 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>;
+/**
+ * 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
+ * was counted, never whoever serves the path by then. `undefined` when the host does not answer.
+ */
+export interface HeldSessionCount {
+    readonly sessions: number;
+    /** Asks the counted host again over the held connection; `undefined` when it no longer answers. */
+    recount(timeoutMs: number): Promise<number | undefined>;
+    close(): void;
+}
+export declare function holdSessionCount(socketPath: string, timeoutMs: number): Promise<HeldSessionCount | undefined>;
 /** 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>;
 //# sourceMappingURL=host-probe.d.ts.map

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

@@ -59,10 +59,58 @@ export async function probeSocketReachable(socketPath, timeoutMs) {
  * does not answer. A stop decision needs the number the host reports, not the one a client remembers.
  */
 export async function probeSessionCount(socketPath, timeoutMs) {
-    const reply = await requestOnSocket(socketPath, { type: "list_sessions", include_workers: true }, timeoutMs);
-    if (!isRecord(reply) || !Array.isArray(reply.sessions))
+    return sessionCountOf(await requestOnSocket(socketPath, { type: "list_sessions", include_workers: true }, timeoutMs));
+}
+export async function holdSessionCount(socketPath, timeoutMs) {
+    const outcome = await connectAndAsk(socketPath, { id: PROBE_REQUEST_ID, type: "list_sessions", include_workers: true }, timeoutMs, true);
+    const kept = outcome.kept;
+    if (kept === undefined)
+        return undefined;
+    const sessions = sessionCountOf(outcome.answer);
+    if (sessions === undefined) {
+        kept.destroy();
         return undefined;
-    return reply.sessions.length;
+    }
+    let asked = 0;
+    return {
+        sessions,
+        recount: (recountTimeoutMs) => askAgain(kept, `${PROBE_REQUEST_ID}-recount-${++asked}`, recountTimeoutMs),
+        close: () => kept.destroy(),
+    };
+}
+function askAgain(socket, id, timeoutMs) {
+    return new Promise((resolveCount) => {
+        let buffer = "";
+        const finish = (count) => {
+            clearTimeout(timeout);
+            socket.off("data", onData);
+            socket.off("close", onClose);
+            resolveCount(count);
+        };
+        const onClose = () => finish(undefined);
+        const onData = (chunk) => {
+            buffer += chunk.toString("utf8");
+            for (let newline = buffer.indexOf("\n"); newline !== -1; newline = buffer.indexOf("\n")) {
+                const answer = readAnswer(buffer.slice(0, newline), id);
+                buffer = buffer.slice(newline + 1);
+                if (answer !== undefined) {
+                    finish(sessionCountOf(answer));
+                    return;
+                }
+            }
+        };
+        const timeout = setTimeout(() => finish(undefined), timeoutMs);
+        if (socket.destroyed) {
+            finish(undefined);
+            return;
+        }
+        socket.on("data", onData);
+        socket.once("close", onClose);
+        socket.write(`${JSON.stringify({ id, type: "list_sessions", include_workers: true })}\n`);
+    });
+}
+function sessionCountOf(reply) {
+    return isRecord(reply) && Array.isArray(reply.sessions) ? reply.sessions.length : undefined;
 }
 /** Sends one command and returns its `data`, or `undefined` for any failure to get a usable answer. */
 export async function requestOnSocket(socketPath, command, timeoutMs) {
@@ -125,7 +173,7 @@ async function connectAndAsk(socketPath, request, timeoutMs, keep = false) {
             sendSocketHandshake(socket, secret);
     });
 }
-function readAnswer(text) {
+function readAnswer(text, id = PROBE_REQUEST_ID) {
     let parsed;
     try {
         parsed = JSON.parse(text);
@@ -133,7 +181,7 @@ function readAnswer(text) {
     catch {
         return undefined;
     }
-    if (!isRecord(parsed) || parsed.id !== PROBE_REQUEST_ID || parsed.success !== true)
+    if (!isRecord(parsed) || parsed.id !== id || parsed.success !== true)
         return undefined;
     return parsed.data ?? {};
 }

package/dist/modes/rpc/host-run-activity.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Which sessions have an agent run in progress, from the host child's events. A run emits
+ * `agent_start` on every loop iteration (a provider retry, a post-compaction continue, a follow-up)
+ * but `agent_settled` once, so this tracks runs, not starts: a repeated start for a running session
+ * changes nothing. A session that closes is dropped even if its settle never arrives (#2713).
+ */
+export declare class SessionRunActivity {
+    #private;
+    /** Applies one host event line; true when it is a run or session event the idle decision must re-read. */
+    observe(line: string): boolean;
+    get busySessions(): number;
+}
+//# sourceMappingURL=host-run-activity.d.ts.map

package/dist/modes/rpc/host-run-activity.js

@@ -0,0 +1,39 @@
+/**
+ * Which sessions have an agent run in progress, from the host child's events. A run emits
+ * `agent_start` on every loop iteration (a provider retry, a post-compaction continue, a follow-up)
+ * but `agent_settled` once, so this tracks runs, not starts: a repeated start for a running session
+ * changes nothing. A session that closes is dropped even if its settle never arrives (#2713).
+ */
+export class SessionRunActivity {
+    #running = new Set();
+    /** Applies one host event line; true when it is a run or session event the idle decision must re-read. */
+    observe(line) {
+        const event = parseHostEvent(line);
+        if (event === undefined)
+            return false;
+        if (event.type === "agent_start")
+            this.#running.add(event.sessionId);
+        else if (event.type === "agent_settled" || event.type === "session_closed")
+            this.#running.delete(event.sessionId);
+        else
+            return false;
+        return true;
+    }
+    get busySessions() {
+        return this.#running.size;
+    }
+}
+function parseHostEvent(line) {
+    let event;
+    try {
+        event = JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof event !== "object" || event === null)
+        return undefined;
+    const { type, sessionId } = event;
+    return typeof sessionId === "string" ? { type, sessionId } : undefined;
+}
+//# sourceMappingURL=host-run-activity.js.map

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

@@ -164,7 +164,7 @@ async function handoffOutcome(target, spec) {
         return refusal("refuse", before, {
             reason: upgradeRefusal(result.reason),
             socket: target.socket,
-            detail: result.reason,
+            detail: result.detail ?? result.reason,
             upgradeable: result.upgradeable,
         });
     }

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

@@ -7,10 +7,11 @@ export declare function startSuccessor(context: {
     options: HandoffHostOptions;
     paths: HostDaemonPaths;
     host: HostProtocolInfo;
+    /** The predecessor's proven identity; `undefined` when nothing proves it, and then it is never signalled. */
     owner: {
-        pid: number;
-        processStartTime: string;
-        instanceId: string;
-    };
+        readonly pid: number;
+    } | undefined;
+    /** Asked once the successor owns the socket: the drain request is sent only when it answers true. */
+    drainGate?: () => Promise<boolean>;
 }): Promise<HandoffResult>;
 //# sourceMappingURL=host-successor.d.ts.map

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

@@ -21,7 +21,7 @@ import { randomUUID } from "node:crypto";
 import { open, rm, writeFile } from "node:fs/promises";
 import { waitForStartTime } from "../app-server/daemon/process.js";
 import { generationPaths, HOST_STATE_FILE_MODE } from "./host-daemon-paths.js";
-import { releaseGeneration, writeGenerationRecord, writeHostRegistration } from "./host-daemon-registration.js";
+import { releaseGeneration, writeGenerationRecord, writeHostRegistration, } from "./host-daemon-registration.js";
 import { readFileOrUndefined, readHostSettings, writeHostSettings } from "./host-daemon-state.js";
 import { defaultHostLaunch, PINNED_HOST_CLIENT_CAPABILITIES } from "./host-launch.js";
 import { DEFAULT_HOST_IDLE_EXIT_MS } from "./host-lifecycle.js";
@@ -37,7 +37,7 @@ const SUCCESSOR_EXIT_WAIT_MS = 5_000;
 /** The longest `startSuccessor` runs: its start-time read, the readiness window, one last probe and a refusal's exit wait. */
 export const SUCCESSOR_START_BUDGET_MS = 10_000 + DEFAULT_HANDOFF_READINESS_MS + 2_000 + SUCCESSOR_EXIT_WAIT_MS;
 export async function startSuccessor(context) {
-    const { options, paths, host, owner } = context;
+    const { options, paths, host, owner, drainGate } = context;
     const generation = (host.generation ?? 0) + 1;
     // The successor's identity, chosen here so its generation directory holds its settings before it
     // boots and the pointer can name it the instant it answers on the public socket.
@@ -119,13 +119,14 @@ export async function startSuccessor(context) {
         // The pointer moves to the successor only now: until the rename landed, the generation the
         // clients reach is still the predecessor, and the pointer has to name whoever owns the socket.
         await options._test?.beforeRegistration?.();
-        await writeHostRegistration(paths, registration);
+        await writeHostRegistration(paths, { ...registration, ...successorBuild(answer) });
         child.unref();
         // The successor owns the socket now: the predecessor may drain. SIGUSR1 is sent only here,
         // to a pid the record proved and a host that advertised it can survive the signal. A
         // predecessor that exited on its own in the meantime is already drained, and the handoff it
         // was being asked to make room for has already happened.
-        signalGeneration(owner.pid, "SIGUSR1");
+        if (owner !== undefined && (drainGate === undefined || (await drainGate())))
+            signalGeneration(owner.pid, "SIGUSR1");
         return {
             action: "handoff",
             pid: child.pid,
@@ -185,6 +186,12 @@ async function exitedWithin(exited, ms) {
         clearTimeout(timer);
     }
 }
+/** The successor's build as the successor itself reported it on the socket; never this process's build. */
+function successorBuild(answer) {
+    if (answer.engineVersion === undefined || answer.engineOrdinal === undefined)
+        return {};
+    return { build: { text: answer.engineVersion, ordinal: answer.engineOrdinal } };
+}
 /**
  * The successor's own answer on the PUBLIC socket is the only proof the rename landed: it
  * reports a different `instanceId` than the generation being replaced. An exit instead means

package/docs/rpc.md

@@ -288,8 +288,9 @@ Two guards decide whether a handoff is attempted at all, and both fail closed:
   handler for it, so a host from before the drain existed is never signalled - `handoffHost` answers
   `{ action: "refuse", reason: "handoff_unsupported" }` and `decideHostAction` reports `upgradeable: false`.
 - The registration must prove which process serves the socket (pid + start time, and the record's `socket`
-  must be this endpoint). An unprovable owner refuses with `unknown_owner` rather than signalling a
-  stranger (I1).
+  must be this endpoint) before that process is signalled. Without such a registration a handoff never
+  signals a stranger (I1): it refuses while that host holds a session, and replaces an idle one without
+  a signal unless a flat pre-layout-2 record proves it (see "Daemon state directory (layout 2)").
 
 On win32 a named pipe can be neither renamed nor drained: `handoffHost` refuses with `upgrade_unsupported`
 and `decideHostAction` never yields `handoff` there. Upgrades apply after `stopHost({ drain: true })` or an
@@ -430,6 +431,13 @@ pid and start time must match the live process, so a recycled pid proves nothing
   its endpoint answers with `generation_handoff` and `list_sessions` (workers included) lists no session.
   Otherwise it refuses `legacy_host`, and the CLI refusal carries `detail`: the pid, its endpoint, how many
   sessions it holds and the `host stop --drain --socket <endpoint>` that retires it.
+- A handoff (`host handoff`, and an ensure's upgrade) on an endpoint no layout-2 record proves counts the
+  running host's sessions over a connection it keeps open. With any session, or no answer, it refuses:
+  `legacy_host` with the same `detail` when a flat record proves the process, `unknown_owner` with the
+  session count otherwise. With none, the successor takes the socket; a proven legacy process is sent the
+  drain only if a recount over that held connection still lists no session, and a host no record proves
+  is never signalled - it drains itself once another generation owns the public entry, and the handoff
+  writes one stderr warning naming the socket, that host's instance and its engine.
 
 `ensureHost` fails with a typed `HostDaemonStateError` naming the directory it could not create or write,
 and starts no host in that case.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi",
-	"version": "2026.10.6",
+	"version": "2026.10.8",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"piConfig": {
@@ -57,9 +57,9 @@
 	},
 	"dependencies": {
 		"@earendil-works/chord": "0.99.1",
-		"@earendil-works/pi-agent-core": "npm:@code-yeongyu/senpi-agent-core@2026.10.6",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.6",
-		"@earendil-works/pi-tui": "npm:@code-yeongyu/senpi-tui@2026.10.6",
+		"@earendil-works/pi-agent-core": "npm:@code-yeongyu/senpi-agent-core@2026.10.8",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.8",
+		"@earendil-works/pi-tui": "npm:@code-yeongyu/senpi-tui@2026.10.8",
 		"@silvia-odwyer/photon-node": "0.3.4",
 		"chalk": "6.0.0",
 		"cross-spawn": "7.0.6",
@@ -76,10 +76,10 @@
 		"typebox": "1.3.34",
 		"undici": "8.10.2",
 		"yaml": "2.9.1",
-		"@anthropic-ai/claude-agent-sdk": "0.3.288",
+		"@anthropic-ai/claude-agent-sdk": "0.3.289",
 		"@anthropic-ai/sdk": "0.127.0",
-		"@code-yeongyu/senpi-codemode": "2026.10.6",
-		"@earendil-works/pi-pty": "npm:@code-yeongyu/senpi-pty@2026.10.6",
+		"@code-yeongyu/senpi-codemode": "2026.10.8",
+		"@earendil-works/pi-pty": "npm:@code-yeongyu/senpi-pty@2026.10.8",
 		"@modelcontextprotocol/sdk": "1.30.0",
 		"@mozilla/readability": "0.6.0",
 		"linkedom": "0.18.13",