@code-yeongyu/senpi 2026.10.5 → 2026.10.7

package/dist/modes/interactive/theme/dark.json

@@ -34,9 +34,9 @@
 		"customMessageBg": "okhsl(295 42% 24%)",
 		"customMessageText": "muted",
 		"customMessageLabel": "violet",
-		"toolPendingBg": "okhsl(229 5% 24%)",
-		"toolSuccessBg": "okhsl(158 46% 25%)",
-		"toolErrorBg": "okhsl(19 54% 25%)",
+		"toolPendingBg": "okhsl(229 5% 13%)",
+		"toolSuccessBg": "okhsl(158 26% 13%)",
+		"toolErrorBg": "okhsl(19 28% 14%)",
 		"toolTitle": "text",
 		"toolOutput": "muted",
 		"mdHeading": "yellow",
@@ -49,8 +49,8 @@
 		"mdQuoteBorder": "muted",
 		"mdHr": "muted",
 		"mdListBullet": "violet",
-		"toolDiffAdded": "green",
-		"toolDiffRemoved": "red",
+		"toolDiffAdded": "okhsl(159 58% 76%)",
+		"toolDiffRemoved": "okhsl(20 70% 77%)",
 		"toolDiffContext": "muted",
 		"syntaxComment": "muted",
 		"syntaxKeyword": "blue",

package/dist/modes/interactive/theme/light.json

@@ -34,9 +34,9 @@
 		"customMessageBg": "okhsl(295 25% 91%)",
 		"customMessageText": "muted",
 		"customMessageLabel": "violet",
-		"toolPendingBg": "okhsl(248 3% 91%)",
-		"toolSuccessBg": "okhsl(156 21% 91%)",
-		"toolErrorBg": "okhsl(24 23% 91%)",
+		"toolPendingBg": "okhsl(248 3% 93%)",
+		"toolSuccessBg": "okhsl(156 25% 91%)",
+		"toolErrorBg": "okhsl(24 28% 91%)",
 		"toolTitle": "text",
 		"toolOutput": "muted",
 		"mdHeading": "yellow",
@@ -49,8 +49,8 @@
 		"mdQuoteBorder": "muted",
 		"mdHr": "muted",
 		"mdListBullet": "violet",
-		"toolDiffAdded": "green",
-		"toolDiffRemoved": "red",
+		"toolDiffAdded": "okhsl(159 85% 28%)",
+		"toolDiffRemoved": "okhsl(20 100% 30%)",
 		"toolDiffContext": "muted",
 		"syntaxComment": "muted",
 		"syntaxKeyword": "blue",

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

@@ -74,6 +74,12 @@ export declare const PROMPT_SURFACE_CAPABILITY = "prompt_surface";
  * value reaches every consumer, so a client may rely on it the moment it sees this name.
  */
 export declare const BROWSER_ENGINE_CAPABILITY = "browser_engine";
+/**
+ * HOST capability: this host honors `open_session.retryFallback` (`{ modelFallback, fallbackChains }`). The
+ * policy is that session's own: it is applied as an in-memory settings override for that session only,
+ * never written to a settings file and never seen by another session on the host.
+ */
+export declare const RETRY_FALLBACK_PROFILE_CAPABILITY = "retry_fallback_profile";
 /**
  * HOST capability: `open_session.promptSurface` also accepts `chat` (a chat bridge: no routing line,
  * no handoff block, no todo cues). A host without it refuses `chat` with `invalid_launch_profile`,

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

@@ -74,6 +74,12 @@ export const PROMPT_SURFACE_CAPABILITY = "prompt_surface";
  * value reaches every consumer, so a client may rely on it the moment it sees this name.
  */
 export const BROWSER_ENGINE_CAPABILITY = "browser_engine";
+/**
+ * HOST capability: this host honors `open_session.retryFallback` (`{ modelFallback, fallbackChains }`). The
+ * policy is that session's own: it is applied as an in-memory settings override for that session only,
+ * never written to a settings file and never seen by another session on the host.
+ */
+export const RETRY_FALLBACK_PROFILE_CAPABILITY = "retry_fallback_profile";
 /**
  * HOST capability: `open_session.promptSurface` also accepts `chat` (a chat bridge: no routing line,
  * no handoff block, no todo cues). A host without it refuses `chat` with `invalid_launch_profile`,

package/dist/modes/rpc/host-daemon-registration.d.ts

@@ -1,3 +1,4 @@
+import type { EngineOrdinal } from "../../core/engine-build-identity.ts";
 import { type DaemonPidFile } from "../app-server/daemon/process.ts";
 import { type HostDaemonPaths, type HostGenerationPaths } from "./host-daemon-paths.ts";
 /** Who wrote a registration: the process identity a later stop must match to be allowed. */
@@ -13,6 +14,14 @@ export interface HostRegistration {
     readonly generation: number;
     /** The profile the spawned host was launched with, for a client comparing two generations. */
     readonly launchProfileId: string;
+    /**
+     * The build of the process this record names. Absent while it is not known yet (a handoff's
+     * successor before it answers): the record then claims no engine version rather than the writer's.
+     */
+    readonly build?: {
+        readonly text: string;
+        readonly ordinal: EngineOrdinal;
+    };
 }
 export interface RegisteredHost {
     readonly record: DaemonPidFile;

package/dist/modes/rpc/host-daemon-registration.js

@@ -23,7 +23,6 @@
  * this module reads and writes through its primitives and never builds a path of its own.
  */
 import { rename, rm } from "node:fs/promises";
-import { engineBuildIdentity } from "../../core/engine-build-identity.js";
 import { parseDaemonPidFile, processMatchesPidFile, readProcessStartTime, } from "../app-server/daemon/process.js";
 import { createGenerationDirectory, generationPaths, HOST_DAEMON_LAYOUT, sameEndpoint, } from "./host-daemon-paths.js";
 import { isRecord, parseJson, readFileOrUndefined, writeStateFile } from "./host-daemon-state.js";
@@ -80,14 +79,13 @@ export async function writeHostRegistration(paths, registration) {
 export async function writeGenerationRecord(paths, registration) {
     const generation = generationPaths(paths, registration.instanceId);
     const writer = { pid: process.pid, startTime: await thisProcessStartTime() };
-    const build = engineBuildIdentity();
+    const { build } = registration;
     await createGenerationDirectory(generation);
     await writeStateFile(generation.pidFile, {
         ...registration.record,
         instance_id: registration.instanceId,
         generation: registration.generation,
-        engineVersion: build.text,
-        engineOrdinal: build.ordinal,
+        ...(build && { engineVersion: build.text, engineOrdinal: build.ordinal }),
         launchProfileId: registration.launchProfileId,
         socket: registration.socket,
         writer,

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

@@ -2,6 +2,7 @@
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { open, readFile } from "node:fs/promises";
+import { engineBuildIdentity } from "../../core/engine-build-identity.js";
 import { readProcessStartTime, waitForStartTime } from "../app-server/daemon/process.js";
 import { clearHostRegistration, writeHostRegistration } from "./host-daemon-registration.js";
 import { writeHostSettings } from "./host-daemon-state.js";
@@ -92,6 +93,7 @@ export async function startHost(paths, socket, options, generation = 0) {
             instanceId,
             generation,
             launchProfileId: hostLaunchProfile(hostChildArgv(options.hostArgs ?? []), process.cwd()).profile_id,
+            build: engineBuildIdentity(),
         });
         child.unref();
     }

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-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-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/dist/modes/rpc/rpc-client.d.ts

@@ -6,6 +6,7 @@
 import type { AgentMessage, ThinkingLevel } from "@earendil-works/pi-agent-core";
 import type { ImageContent } from "@earendil-works/pi-ai";
 import type { PromptDisposition, QueuedInputDisposition, SessionStats } from "../../core/agent-session.ts";
+import type { SessionRetryFallbackProfile } from "../../core/agent-session-runtime.ts";
 import type { BashResult } from "../../core/bash-executor.ts";
 import type { BrowserEngine } from "../../core/browser-engine.ts";
 import { type ClientMessageIdentity } from "../../core/client-message-identity.ts";
@@ -136,6 +137,8 @@ export declare class RpcClient {
         promptSurface?: PromptSurface;
         /** Which browser this session's skills drive; needs the host's `browser_engine`. */
         browserEngine?: BrowserEngine;
+        /** This session's own fallback policy, in memory only; needs the host's `retry_fallback_profile`. */
+        retryFallback?: SessionRetryFallbackProfile;
     }): Promise<{
         sessionId: string;
         state: RpcSessionState;

package/dist/modes/rpc/rpc-input-validation.d.ts

@@ -40,6 +40,13 @@ export declare function sessionPromptSurfaceError(value: unknown): string | unde
  * own browser must not silently run without one.
  */
 export declare function sessionBrowserEngineError(value: unknown): string | undefined;
+/**
+ * Detail for an `open_session.retryFallback` the host refuses, or undefined when it is absent or well
+ * formed: `{ modelFallback: boolean, fallbackChains: Record<string, string[]> }`, at most 32 chains of at
+ * most 32 non-empty selectors. A malformed profile is refused rather than ignored, so a caller that asked
+ * for a chain never runs without one unknowingly.
+ */
+export declare function sessionRetryFallbackError(value: unknown): string | undefined;
 export declare function rpcCommandShapeError(command: unknown): string | undefined;
 export declare function rpcMessageLengthError(command: unknown): string | undefined;
 //# sourceMappingURL=rpc-input-validation.d.ts.map

package/dist/modes/rpc/rpc-input-validation.js

@@ -161,6 +161,43 @@ export function sessionBrowserEngineError(value) {
         return undefined;
     return `browserEngine must be "connected", "builtin" or "none".`;
 }
+const MAX_RETRY_FALLBACK_CHAINS = 32;
+const MAX_RETRY_FALLBACK_ENTRIES = 32;
+const MAX_RETRY_FALLBACK_SELECTOR_LENGTH = 512;
+/**
+ * Detail for an `open_session.retryFallback` the host refuses, or undefined when it is absent or well
+ * formed: `{ modelFallback: boolean, fallbackChains: Record<string, string[]> }`, at most 32 chains of at
+ * most 32 non-empty selectors. A malformed profile is refused rather than ignored, so a caller that asked
+ * for a chain never runs without one unknowingly.
+ */
+export function sessionRetryFallbackError(value) {
+    if (value === undefined)
+        return undefined;
+    const shape = "retryFallback must be { modelFallback: boolean, fallbackChains: Record<string, string[]> }.";
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return shape;
+    const record = value;
+    if (typeof record.modelFallback !== "boolean")
+        return shape;
+    const chains = record.fallbackChains;
+    if (typeof chains !== "object" || chains === null || Array.isArray(chains))
+        return shape;
+    const entries = Object.entries(chains);
+    if (entries.length > MAX_RETRY_FALLBACK_CHAINS)
+        return `retryFallback allows at most ${MAX_RETRY_FALLBACK_CHAINS} chains.`;
+    for (const [key, selectors] of entries) {
+        if (!isSelector(key))
+            return shape;
+        if (!Array.isArray(selectors) || !selectors.every(isSelector))
+            return shape;
+        if (selectors.length > MAX_RETRY_FALLBACK_ENTRIES)
+            return `retryFallback allows at most ${MAX_RETRY_FALLBACK_ENTRIES} entries per chain.`;
+    }
+    return undefined;
+}
+function isSelector(value) {
+    return typeof value === "string" && value.trim().length > 0 && value.length <= MAX_RETRY_FALLBACK_SELECTOR_LENGTH;
+}
 export function rpcCommandShapeError(command) {
     if (typeof command !== "object" || command === null || Array.isArray(command)) {
         return "RPC command must be a JSON object.";

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

@@ -9,6 +9,7 @@ import type { ImageContent, Model, ProviderDiagnostic, ThinkingSelection } from
 import type { SessionRuntimeKind } from "../../cli/args.ts";
 import type { AgentAbortSource } from "../../core/agent-abort-provenance.ts";
 import type { PromptDisposition, QueuedInput, QueuedInputDisposition, SessionStats } from "../../core/agent-session.ts";
+import type { SessionRetryFallbackProfile } from "../../core/agent-session-runtime.ts";
 import type { BashResult } from "../../core/bash-executor.ts";
 import type { BrowserEngine } from "../../core/browser-engine.ts";
 import type { ClientMessageIdentity } from "../../core/client-message-identity.ts";
@@ -504,6 +505,14 @@ export type RpcCommand = (RpcSessionCommand & {
      * Requires the host capability `browser_engine`. Any other value is refused with `invalid_launch_profile`.
      */
     browserEngine?: BrowserEngine;
+    /**
+     * The fallback policy THIS session runs with (e.g. a task child's own chain): applied as an
+     * in-memory override of this session's `retry.modelFallback` / `retry.fallbackChains`, never written
+     * to a settings file and never seen by another session. Requires the host capability
+     * `retry_fallback_profile`; a malformed value is refused with `invalid_launch_profile`. Applied
+     * when the open creates the session; an attach keeps the session's existing policy.
+     */
+    retryFallback?: SessionRetryFallbackProfile;
 } | {
     id?: string;
     type: "close_session";

package/dist/modes/rpc/session-command-activity.d.ts

@@ -0,0 +1,2 @@
+export declare function refreshesSessionActivity(command: string): boolean;
+//# sourceMappingURL=session-command-activity.d.ts.map

package/dist/modes/rpc/session-command-activity.js

@@ -0,0 +1,25 @@
+/** Whether the command itself refreshes activity, apart from attached-client keepalives. */
+const observations = new Set([
+    "get_state",
+    "get_messages",
+    "get_entries",
+    "get_tree",
+    "get_fork_messages",
+    "get_last_assistant_text",
+    "get_session_stats",
+    "get_steering_messages",
+    "get_follow_up_messages",
+    "get_available_models",
+    "get_available_thinking_levels",
+    "get_fast_mode",
+    "get_commands",
+    "get_loaded_surfaces",
+    "get_media",
+    "get_auth_providers",
+    "get_provider_accounts",
+    "memory_report",
+]);
+export function refreshesSessionActivity(command) {
+    return !observations.has(command);
+}
+//# sourceMappingURL=session-command-activity.js.map