@code-yeongyu/senpi 2026.10.16-2 → 2026.10.16-4

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

@@ -20,7 +20,7 @@ export class RpcCommandError extends Error {
     }
 }
 import { attachJsonlLineReader, serializeJsonLine } from "./jsonl.js";
-import { armRequestDeadline, OPEN_AFTER_QUEUED_DEADLINE_MS, openStalledMessage, PROMPT_ACK_MAX_WAIT_MS, PROMPT_AFTER_QUEUED_DEADLINE_MS, PROMPT_COMPACTION_DEADLINE_MS, promptStalledMessage, REQUEST_DEADLINE_MS, RpcRequestTimeoutError, } from "./rpc-request-deadline.js";
+import { armRequestDeadline, OPEN_AFTER_QUEUED_DEADLINE_MS, openStalledMessage, PROMPT_ACK_MAX_WAIT_MS, PROMPT_AFTER_QUEUED_DEADLINE_MS, PROMPT_COMPACTION_DEADLINE_MS, promptStalledMessage, REQUEST_DEADLINE_MS, RpcRequestTimeoutError, requestDeadlineMs, } from "./rpc-request-deadline.js";
 import { RPC_ERROR_UNKNOWN_COMMAND } from "./rpc-types.js";
 import { readSocketSecret, resolveSocketTransportAddress, sendSocketHandshake, socketSecretPath, } from "./socket-transport.js";
 import { socketNeedsHandshake } from "./tui-socket.js";
@@ -455,17 +455,30 @@ export class RpcClient {
         // Older hosts omit the disposition; degrade like prompt() so clients render only canonical events.
         return this.getData(response)?.disposition ?? "handled";
     }
+    async abort(options) {
+        if (options === undefined) {
+            try {
+                await this.send({ type: "abort" });
+            }
+            catch (error) {
+                if (!isTransportGoneError(error))
+                    throw error;
+            }
+            return;
+        }
+        return this.getData(await this.send({ ...options, type: "abort" }));
+    }
     /**
-     * Abort current operation.
+     * The newest receipt of one effect (`get_effect_status`, capability `effect_ledger`). With `sessionPath`
+     * the host reads that transcript from disk, so a session no host holds is answered without loading it.
      */
-    async abort() {
-        try {
-            await this.send({ type: "abort" });
-        }
-        catch (error) {
-            if (!isTransportGoneError(error))
-                throw error;
-        }
+    async getEffectStatus(effectId, options = {}) {
+        const command = {
+            type: "get_effect_status",
+            effectId,
+            ...(options.sessionPath === undefined ? {} : { sessionPath: options.sessionPath }),
+        };
+        return this.getData(await this.send(command, options.sessionPath === undefined));
     }
     /** Abort with host refusals and transport loss surfaced to machine callers. */
     async abortStrict() {
@@ -1018,7 +1031,7 @@ export class RpcClient {
             };
             const deadline = armRequestDeadline(command.type === "prompt" && sessionId === this.sessionId && this.isCompacting()
                 ? PROMPT_COMPACTION_DEADLINE_MS
-                : REQUEST_DEADLINE_MS, timeoutMessage, expire);
+                : requestDeadlineMs(command), timeoutMessage, expire);
             // Compaction events extend a prompt's wait, but never past this cap from when it was sent.
             if (command.type === "prompt") {
                 promptCap = setTimeout(() => {

package/dist/modes/rpc/rpc-request-deadline.d.ts

@@ -1,5 +1,17 @@
 /** How long any request waits for the host's answer - for an open, for its `queued` acknowledgement. */
 export declare const REQUEST_DEADLINE_MS = 30000;
+/**
+ * How long one request may wait for its answer before the client gives up. An awaited abort answers only
+ * after the turn stopped or its `graceMs` ran out (up to 60 s), so its wait is that grace plus the
+ * ordinary allowance; every other command keeps the plain request deadline. A `graceMs` the host would
+ * refuse (out of range, fractional, NaN, Infinity) gets the plain deadline too: the host answers it at once
+ * with `invalid_argument`, and the client must still be listening for that refusal.
+ */
+export declare function requestDeadlineMs(command: {
+    readonly type: string;
+    readonly awaitIdle?: unknown;
+    readonly graceMs?: unknown;
+}): number;
 /** Remote compaction may exhaust its budget before a local summary uses its maximum override. */
 export declare const PROMPT_COMPACTION_DEADLINE_MS: number;
 /**

package/dist/modes/rpc/rpc-request-deadline.js

@@ -1,6 +1,21 @@
 import { SUMMARIZATION_MAX_DURATION_CAP_MS, SUMMARIZATION_TOTAL_BUDGET_MS, } from "../../core/compaction/stream-watchdog.js";
+import { ABORT_DEFAULT_GRACE_MS, isAbortGraceInRange } from "./abort-grace.js";
 /** How long any request waits for the host's answer - for an open, for its `queued` acknowledgement. */
 export const REQUEST_DEADLINE_MS = 30_000;
+/**
+ * How long one request may wait for its answer before the client gives up. An awaited abort answers only
+ * after the turn stopped or its `graceMs` ran out (up to 60 s), so its wait is that grace plus the
+ * ordinary allowance; every other command keeps the plain request deadline. A `graceMs` the host would
+ * refuse (out of range, fractional, NaN, Infinity) gets the plain deadline too: the host answers it at once
+ * with `invalid_argument`, and the client must still be listening for that refusal.
+ */
+export function requestDeadlineMs(command) {
+    if (command.type !== "abort" || command.awaitIdle !== true)
+        return REQUEST_DEADLINE_MS;
+    if (command.graceMs === undefined)
+        return ABORT_DEFAULT_GRACE_MS + REQUEST_DEADLINE_MS;
+    return isAbortGraceInRange(command.graceMs) ? command.graceMs + REQUEST_DEADLINE_MS : REQUEST_DEADLINE_MS;
+}
 /** Remote compaction may exhaust its budget before a local summary uses its maximum override. */
 export const PROMPT_COMPACTION_DEADLINE_MS = SUMMARIZATION_TOTAL_BUDGET_MS + SUMMARIZATION_MAX_DURATION_CAP_MS + REQUEST_DEADLINE_MS;
 /**

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

@@ -476,10 +476,13 @@ export class SessionCommandRouter {
             parkedPath !== undefined &&
             retained?.retainOnDisconnect === true &&
             retained.sessionPath !== undefined) {
-            await recordHandoverParkedSession(this.handoverParkedDir, parkedEntryFromProfile({
-                sessionPath: retained.sessionPath,
-                ...(retained.durableSessionId !== undefined ? { durableSessionId: retained.durableSessionId } : {}),
-            }, retained.profile, Object.keys(this.defaults.hostContext ?? {}))).catch((cause) => {
+            await recordHandoverParkedSession(this.handoverParkedDir, {
+                ...parkedEntryFromProfile({
+                    sessionPath: retained.sessionPath,
+                    ...(retained.durableSessionId !== undefined ? { durableSessionId: retained.durableSessionId } : {}),
+                }, retained.profile, Object.keys(this.defaults.hostContext ?? {})),
+                parkedBy: this.defaults.hostContext?.host_instance ?? hostInstanceId(),
+            }).catch((cause) => {
                 process.stderr.write(`senpi rpc handover park record ${sessionId} failed: ${String(cause)}\n`);
             });
         }

package/dist/modes/rpc/session-registry-attach.js

@@ -72,7 +72,12 @@ export async function attachToOpenSession(entries, sessionPath, profile, options
             }
             return attachToOpenSession(entries, sessionPath, profile, options, pathReservations, now);
         }
-        throw new RpcSessionRegistryError("session_path_in_use");
+        // The path is still reserved by a session that is not serving (a teardown past its grace
+        // window): never a bare refusal, so the caller knows to retry (senpi#3485).
+        throw new RpcSessionRegistryError("session_path_in_use", "the session is still being released", {
+            reason: "path_still_held",
+            retry_after_ms: OPEN_IN_PROGRESS_WAIT_RETRY_MS,
+        });
     }
     const [handle, entry] = existing;
     const wasParked = entry.retainOnDisconnect === true && entry.attachments === 0;

package/dist/modes/rpc/session-registry-claims.d.ts

@@ -2,8 +2,28 @@
  * The registry's path claims: the in-process reservation set and the cross-generation claim
  * (`host-reservations.ts`) follow whatever file each entry's runtime is actually writing.
  */
-import type { SessionPathReservations } from "./host-reservations.ts";
-import type { RpcSessionEntry } from "./session-registry-types.ts";
+import { type SessionPathReservations } from "./host-reservations.ts";
+import { type RpcSessionEntry } from "./session-registry-types.ts";
+/** Opens between their in-process reservation and their entry, by path: their cross-generation claim is in flight. */
+export type PendingClaims = Map<string, Promise<void>>;
+/**
+ * Marks `sessionPath` as mid-claim. The returned settle is called once the open has either recorded
+ * its entry or given the reservation back, so a waiter that wakes always finds one or the other.
+ */
+export declare function beginPendingClaim(pending: PendingClaims, sessionPath: string): () => void;
+/**
+ * Takes the cross-generation claim for an open that already holds the in-process reservation, and
+ * returns the settle `beginPendingClaim` handed out: the caller settles it once its entry is recorded.
+ * A live claim another generation holds gives the reservation back and refuses with the owner.
+ */
+export declare function takeCrossGenerationClaim(reservations: Set<string>, pending: PendingClaims, pathReservations: SessionPathReservations, sessionPath: string): Promise<() => void>;
+/**
+ * Waits out another open of this path that is still taking its claim (senpi#3485). Without the wait
+ * the path looked reserved by no session at all and a reopen was refused for a session about to be
+ * served. Bounded by the close grace window: a claim that never settles (a wedged daemon directory)
+ * ends this open with a retryable `session_path_in_use { reason: "claim_in_progress" }`.
+ */
+export declare function settlePendingClaim(pending: ReadonlyMap<string, Promise<void>>, sessionPath: string, graceMs: number): Promise<void>;
 /** Reconcile path and durable identity after runtime replacement. */
 export declare function syncRuntimeMetadata(entries: Iterable<RpcSessionEntry>, reservations: Set<string>, pathReservations: SessionPathReservations | undefined): void;
 /**

package/dist/modes/rpc/session-registry-claims.js

@@ -1,4 +1,72 @@
+/**
+ * The registry's path claims: the in-process reservation set and the cross-generation claim
+ * (`host-reservations.ts`) follow whatever file each entry's runtime is actually writing.
+ */
+import { SESSION_PATH_RETRY_AFTER_MS } from "./host-reservations.js";
 import { canonicalSessionPath } from "./session-path-key.js";
+import { RpcSessionRegistryError } from "./session-registry-types.js";
+/**
+ * Marks `sessionPath` as mid-claim. The returned settle is called once the open has either recorded
+ * its entry or given the reservation back, so a waiter that wakes always finds one or the other.
+ */
+export function beginPendingClaim(pending, sessionPath) {
+    const settled = Promise.withResolvers();
+    pending.set(sessionPath, settled.promise);
+    return () => {
+        if (pending.get(sessionPath) === settled.promise)
+            pending.delete(sessionPath);
+        settled.resolve();
+    };
+}
+/**
+ * Takes the cross-generation claim for an open that already holds the in-process reservation, and
+ * returns the settle `beginPendingClaim` handed out: the caller settles it once its entry is recorded.
+ * A live claim another generation holds gives the reservation back and refuses with the owner.
+ */
+export async function takeCrossGenerationClaim(reservations, pending, pathReservations, sessionPath) {
+    const settle = beginPendingClaim(pending, sessionPath);
+    let holder;
+    try {
+        holder = await pathReservations.claim(sessionPath);
+    }
+    catch (cause) {
+        reservations.delete(sessionPath);
+        settle();
+        throw cause;
+    }
+    if (holder === undefined)
+        return settle;
+    reservations.delete(sessionPath);
+    settle();
+    throw new RpcSessionRegistryError("session_path_in_use", undefined, {
+        owner: holder,
+        retry_after_ms: SESSION_PATH_RETRY_AFTER_MS,
+    });
+}
+/**
+ * Waits out another open of this path that is still taking its claim (senpi#3485). Without the wait
+ * the path looked reserved by no session at all and a reopen was refused for a session about to be
+ * served. Bounded by the close grace window: a claim that never settles (a wedged daemon directory)
+ * ends this open with a retryable `session_path_in_use { reason: "claim_in_progress" }`.
+ */
+export async function settlePendingClaim(pending, sessionPath, graceMs) {
+    let timer;
+    const late = new Promise((resolve) => {
+        timer = setTimeout(() => resolve("late"), graceMs);
+    });
+    try {
+        for (let claim = pending.get(sessionPath); claim !== undefined; claim = pending.get(sessionPath)) {
+            if ((await Promise.race([claim.then(() => "settled"), late])) === "late")
+                throw new RpcSessionRegistryError("session_path_in_use", "another open of this path is still taking its claim", {
+                    reason: "claim_in_progress",
+                    retry_after_ms: SESSION_PATH_RETRY_AFTER_MS,
+                });
+        }
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
 /** Reconcile path and durable identity after runtime replacement. */
 export function syncRuntimeMetadata(entries, reservations, pathReservations) {
     for (const entry of entries) {

package/dist/modes/rpc/session-registry-opening.d.ts

@@ -0,0 +1,23 @@
+import type { SessionStartEvent } from "../../core/extensions/types.ts";
+import type { PreparableRuntimeFactory } from "./host-warm.ts";
+import { type RpcSessionEntry, type RpcSessionLaunchProfile, type RpcSessionOpenOptions } from "./session-registry-types.ts";
+export interface OpeningEntry {
+    readonly entry: RpcSessionEntry;
+    readonly storedProfile: RpcSessionLaunchProfile;
+    readonly runtimeProfile: RpcSessionLaunchProfile;
+    readonly sessionStartEvent: SessionStartEvent | undefined;
+    readonly settleOpen: {
+        readonly resolve: () => void;
+        readonly reject: (cause: unknown) => void;
+    };
+}
+export declare function buildOpeningEntry(input: {
+    readonly profile: RpcSessionLaunchProfile;
+    readonly sessionPath: string | undefined;
+    readonly requestedDurableId: string | undefined;
+    readonly options: RpcSessionOpenOptions | undefined;
+    readonly now: number;
+    readonly createRuntime: PreparableRuntimeFactory;
+    readonly sync: () => void;
+}): OpeningEntry;
+//# sourceMappingURL=session-registry-opening.d.ts.map

package/dist/modes/rpc/session-registry-opening.js

@@ -0,0 +1,57 @@
+/**
+ * The "opening" entry an `openSession` records once its path is reserved and claimed. Built in one
+ * synchronous step so the registry can give the reservation back if building it throws, instead of
+ * leaving a reserved path no entry backs (senpi#3485).
+ */
+import { existsSync } from "node:fs";
+import { ProviderScope } from "@earendil-works/pi-ai/node/provider-scope";
+import { createEntrySwitchSession } from "./session-registry-switch.js";
+import { frozenProfile, sessionIdentity, } from "./session-registry-types.js";
+export function buildOpeningEntry(input) {
+    const { profile, sessionPath, requestedDurableId, options } = input;
+    // Resume vs create parity (D1 + omo SenpiSessionRuntime.ts:198-200):
+    // Create-only launch semantics mirror classic startup flags. A resumed
+    // session restores its persisted model and thinking level instead of being
+    // overridden by the new open_session request.
+    const isResume = sessionPath !== undefined && existsSync(sessionPath);
+    // Re-opening an existing session file is a resume, exactly like interactive
+    // /resume (AgentSessionRuntime.switchSession). Without the event the session
+    // starts with reason "startup" and every extension that only rebuilds state
+    // on a resume - the ask-user dangling-question hook - stays unreachable from
+    // the RPC restart path. A session created by this open stays "startup".
+    const sessionStartEvent = isResume
+        ? { type: "session_start", reason: "resume" }
+        : undefined;
+    const storedProfile = frozenProfile({ ...profile, ...(sessionPath ? { sessionPath } : {}) });
+    const runtimeProfile = isResume
+        ? frozenProfile({ ...storedProfile, creationModel: undefined, initialThinkingLevel: undefined })
+        : storedProfile;
+    let settleOpen;
+    const openCompletion = new Promise((resolve, reject) => {
+        settleOpen = { resolve, reject };
+    });
+    // A concurrent explicit open for the same path waits on this to attach, never to time it out.
+    openCompletion.catch(() => { });
+    const entry = {
+        state: "opening",
+        scope: new ProviderScope(),
+        profile: storedProfile,
+        ...sessionIdentity(storedProfile),
+        sessionPath,
+        reservationKey: sessionPath,
+        cwd: storedProfile.cwd,
+        attachments: 1,
+        retainOnDisconnect: options?.retainOnDisconnect === true,
+        lastCommandAt: input.now,
+        lifecycleMutex: Promise.resolve(),
+        openCompletion,
+    };
+    entry.switchSession = createEntrySwitchSession(entry, input.createRuntime, input.sync);
+    // Recorded before the first await so the synchronous collision guard sees an open that is still
+    // being built. `manager.getSessionId()` overwrites it later with the authoritative value, which on
+    // a resume is the header's id, not the requested one.
+    if (requestedDurableId !== undefined)
+        entry.durableSessionId = requestedDurableId;
+    return { entry, storedProfile, runtimeProfile, sessionStartEvent, settleOpen };
+}
+//# sourceMappingURL=session-registry-opening.js.map

package/dist/modes/rpc/session-registry.d.ts

@@ -5,6 +5,7 @@ export { frozenProfile, type OpenRpcSession, type RpcSessionEntry, type RpcSessi
 export declare class RpcSessionRegistry {
     private readonly entries;
     private readonly reservations;
+    private readonly pendingClaims;
     private readonly teardownHost;
     private nextHandle;
     private readonly options;

package/dist/modes/rpc/session-registry.js

@@ -1,21 +1,19 @@
-import { existsSync } from "node:fs";
 import { isAbsolute } from "node:path";
-import { ProviderScope, runWithProviderScope } from "@earendil-works/pi-ai/node/provider-scope";
+import { runWithProviderScope } from "@earendil-works/pi-ai/node/provider-scope";
 import { createAgentSessionRuntime } from "../../core/agent-session-runtime.js";
 import { assertValidSessionId, SessionManager } from "../../core/session-manager.js";
 import { ClientAdmissions } from "./client-admissions.js";
 import { EffectLedger } from "./effect-ledger.js";
-import { SESSION_PATH_RETRY_AFTER_MS } from "./host-reservations.js";
 import { createRegistryWarm } from "./host-warm.js";
 import { assertRequestedModelResolved } from "./open-session-model.js";
 import { refreshesSessionActivity } from "./session-command-activity.js";
 import { publishedSessionContext } from "./session-context-patch.js";
 import { canonicalSessionPath } from "./session-path-key.js";
 import { attachToOpenSession } from "./session-registry-attach.js";
-import { settleClosingReservation, syncRuntimeMetadata } from "./session-registry-claims.js";
+import { settleClosingReservation, settlePendingClaim, syncRuntimeMetadata, takeCrossGenerationClaim, } from "./session-registry-claims.js";
 import { resolveMovedProfile } from "./session-registry-moved-path.js";
-import { createEntrySwitchSession } from "./session-registry-switch.js";
-import { frozenProfile, RpcSessionRegistryError, sessionIdentity, } from "./session-registry-types.js";
+import { buildOpeningEntry } from "./session-registry-opening.js";
+import { RpcSessionRegistryError, } from "./session-registry-types.js";
 import { beginSessionClose, closeMarkedSession, closeSession, releaseWithinGrace, } from "./session-teardown.js";
 export { frozenProfile, RpcSessionRegistryError, sessionIdentity, } from "./session-registry-types.js";
 /** Process-local lifecycle owner for multi-session RPC runtimes. */
@@ -23,6 +21,7 @@ export class RpcSessionRegistry {
     constructor(options) {
         this.entries = new Map();
         this.reservations = new Set();
+        this.pendingClaims = new Map();
         this.nextHandle = 0;
         if (options.createRuntime.prepare)
             this.warm = createRegistryWarm(options.createRuntime.prepare, {
@@ -85,8 +84,14 @@ export class RpcSessionRegistry {
                 throw new RpcSessionRegistryError("session_id_in_use");
             }
         }
-        if (sessionPath)
+        if (sessionPath) {
             await settleClosingReservation(this.entries.values(), sessionPath, this.closeGraceMs);
+            // Re-checked right before the reservation decision, with no await in between: a waiter woken
+            // by a FAILED claim must see the next open's claim, not a bare reservation (senpi#3485 review).
+            const deadline = Date.now() + this.closeGraceMs;
+            while (this.pendingClaims.has(sessionPath))
+                await settlePendingClaim(this.pendingClaims, sessionPath, Math.max(0, deadline - Date.now()));
+        }
         if (sessionPath && this.reservations.has(sessionPath)) {
             return attachToOpenSession(this.entries, sessionPath, profile, options, this.options.pathReservations, this.now());
         }
@@ -95,6 +100,7 @@ export class RpcSessionRegistry {
                 reason: "session_not_held",
                 action: "rediscover_holder",
             });
+        let claimSettled;
         if (sessionPath) {
             // Taken SYNCHRONOUSLY, before any await: a concurrent open for the same path must find the
             // reservation already held, not a window between the decision and the record of it.
@@ -104,62 +110,44 @@ export class RpcSessionRegistry {
             // Only AWAIT when there is a cross-generation claim to take: `await undefined` still costs a
             // microtask, and an embedded registry (no second generation) must reach the "opening" entry
             // in the same tick a caller that raced it would look, exactly as it did before generations.
-            const holder = this.options.pathReservations
-                ? await this.options.pathReservations.claim(sessionPath)
-                : undefined;
-            if (holder) {
-                this.reservations.delete(sessionPath);
-                throw new RpcSessionRegistryError("session_path_in_use", undefined, {
-                    owner: holder,
-                    retry_after_ms: SESSION_PATH_RETRY_AFTER_MS,
-                });
-            }
+            // A concurrent open of this path waits on `claimSettled` instead of finding a reservation no
+            // entry backs (senpi#3485); it is settled once the entry is recorded or the reservation is back.
+            if (this.options.pathReservations)
+                claimSettled = await takeCrossGenerationClaim(this.reservations, this.pendingClaims, this.options.pathReservations, sessionPath);
         }
-        // Resume vs create parity (D1 + omo SenpiSessionRuntime.ts:198-200):
-        // Create-only launch semantics mirror classic startup flags. A resumed
-        // session restores its persisted model and thinking level instead of being
-        // overridden by the new open_session request.
-        const isResume = sessionPath !== undefined && existsSync(sessionPath);
-        // Re-opening an existing session file is a resume, exactly like interactive
-        // /resume (AgentSessionRuntime.switchSession). Without the event the session
-        // starts with reason "startup" and every extension that only rebuilds state
-        // on a resume - the ask-user dangling-question hook - stays unreachable from
-        // the RPC restart path. A session created by this open stays "startup".
-        const sessionStartEvent = isResume
-            ? { type: "session_start", reason: "resume" }
-            : undefined;
-        const storedProfile = frozenProfile({ ...profile, ...(sessionPath ? { sessionPath } : {}) });
-        const runtimeProfile = isResume
-            ? frozenProfile({ ...storedProfile, creationModel: undefined, initialThinkingLevel: undefined })
-            : storedProfile;
         const handle = `rpc-${++this.nextHandle}`;
-        let settleOpen;
-        const openCompletion = new Promise((resolve, reject) => {
-            settleOpen = { resolve, reject };
-        });
-        // A concurrent explicit open for the same path waits on this to attach, never to time it out.
-        openCompletion.catch(() => { });
-        const entry = {
-            state: "opening",
-            scope: new ProviderScope(),
-            profile: storedProfile,
-            ...sessionIdentity(storedProfile),
-            sessionPath,
-            reservationKey: sessionPath,
-            cwd: storedProfile.cwd,
-            attachments: 1,
-            retainOnDisconnect: options?.retainOnDisconnect === true,
-            lastCommandAt: this.now(),
-            lifecycleMutex: Promise.resolve(),
-            openCompletion,
-        };
-        entry.switchSession = createEntrySwitchSession(entry, this.options.createRuntime, () => this.syncRuntimeMetadata());
-        // Recorded before the first await so the synchronous collision guard above sees an open
-        // that is still being built. `manager.getSessionId()` overwrites it below with the
-        // authoritative value, which on a resume is the header's id, not the requested one.
-        if (requestedDurableId !== undefined)
-            entry.durableSessionId = requestedDurableId;
+        let opening;
+        try {
+            opening = buildOpeningEntry({
+                profile,
+                sessionPath,
+                requestedDurableId,
+                options,
+                now: this.now(),
+                createRuntime: this.options.createRuntime,
+                sync: () => this.syncRuntimeMetadata(),
+            });
+        }
+        catch (cause) {
+            // Give the path back before waking waiters, or they find a reservation no entry backs. A failed
+            // claim release is reported, never allowed to strand the waiters or replace the build error.
+            try {
+                if (sessionPath) {
+                    this.reservations.delete(sessionPath);
+                    await this.options.pathReservations?.release(sessionPath);
+                }
+            }
+            catch (releaseCause) {
+                process.stderr.write(`senpi rpc open of ${sessionPath} could not release its claim: ${String(releaseCause)}\n`);
+            }
+            finally {
+                claimSettled?.();
+            }
+            throw cause;
+        }
+        const { entry, storedProfile, runtimeProfile, sessionStartEvent, settleOpen } = opening;
         this.entries.set(handle, entry);
+        claimSettled?.();
         this.options.onSizeChange?.(this.entries.size);
         try {
             const newSessionOptions = requestedDurableId !== undefined ? { id: requestedDurableId } : undefined;

package/dist/modes/rpc/session-unload.js

@@ -1,3 +1,4 @@
+import { ClientAdmissions } from "./client-admissions.js";
 import { beginEffect, effectAnswer, isEffectBegin } from "./effect-commands.js";
 import { EffectLedger } from "./effect-ledger.js";
 import { abortAndSettle } from "./session-release-interrupt.js";
@@ -49,8 +50,10 @@ async function claimAndUnload(port, command) {
     const stillBlocked = blockers(port, command, ready.session, ready.durableSessionId);
     if (stillBlocked.length > 0)
         return fail(command, ready.session, stillBlocked[0]);
-    if (command.clearQueue === true)
+    if (command.clearQueue === true) {
+        ClientAdmissions.clearQueuedFor(ready.session);
         ready.session.clearQueue();
+    }
     const effect = command.effectId === undefined
         ? undefined
         : EffectLedger.forSession(ready.session).transition(command.effectId, "done", { disposition: "unloaded" });

package/docs/rpc.md

@@ -1585,7 +1585,9 @@ What the host does enforce are lifecycle windows, and they only ever return memo
   reaches zero attachments and closes the session, host shutdown closes it, and the idle-eviction window above still
   parks it (or the completed-detached-worker rule above parks it sooner) — announced as
   `session_parked { sessionId, sessionPath }`, after which the file reopens by path like any
-  evicted session, and the parked session counts as gone for the empty-host exit below. It is also bounded by the empty-host exit
+  evicted session, and the parked session counts as gone for the empty-host exit below. The park is also recorded
+  for the NEXT generation, which reopens it on startup; the host that parked it never reopens it on its own, so a
+  client reopening the session right after `session_parked` is the only open of that path (senpi#3485). It is also bounded by the empty-host exit
   and the supervisor's idle-exit window below: retention survives a client, not the host. Any attach may turn retention
   on for a live session; no attach turns it off for clients that already rely on it. Omitting the flag is byte-identical
   to the previous behavior — the session is closed with its last connection. Probe `retain_on_disconnect` in
@@ -2066,7 +2068,7 @@ codes or code prefixes in `error`:
   - **Mid-turn policy:** a turn admitted before the foreign holder appeared finishes and persists its results; subsequent writing RPCs are refused. Read/control requests, including abort, queue clearing, `extension_ui_response` and `extension_ui_progress`, remain available.
   - **Conservative admission:** `new_session`, `fork`, `clone`, and settings or account commands carrying this session's routing handle are also refused while its current file is held. Close the handle and open another session to leave a held file.
   - Holder records are admission evidence, not an exclusive filesystem lock. SessionManager's append API is synchronous and fresh process-identity checks are asynchronous; changing append to asynchronous admission would change the SDK contract and could discard results of already-executed tools.
-- `session_path_in_use` (path held by an opening or quarantined owner; a fully-open current owner is attached instead, an owner whose teardown is already in flight is waited out on the in-process runtime, and a path a live owner has superseded is released rather than held). A path held by ANOTHER GENERATION of the daemon carries `errorData { owner: { instanceId, pid, processStartTime, sessionPath, current }, retry_after_ms: 2000 }`: that generation is still writing the file and is parking it, so the open is a retry, not a failure. Only a claim whose owner serves the socket (`current: true`) or still has a client attached refuses an open at all - a superseded, attachment-less claim is reclaimed instead
+- `session_path_in_use` (path held by an opening or quarantined owner; a fully-open current owner is attached instead, an owner whose teardown is already in flight is waited out on the in-process runtime, and a path a live owner has superseded is released rather than held). A path held by ANOTHER GENERATION of the daemon carries `errorData { owner: { instanceId, pid, processStartTime, sessionPath, current }, retry_after_ms: 2000 }`: that generation is still writing the file and is parking it, so the open is a retry, not a failure. An open that arrives while ANOTHER open of the same path is still taking that cross-generation claim waits for it - bounded by the close grace window - and then attaches to the session that open is building; a claim that does not settle in that window answers `errorData { reason: "claim_in_progress", retry_after_ms: 2000 }`. When the claim it waited on is refused, the next waiting open takes the claim itself and later ones wait on that, so no racing open answers a bare refusal; a path still reserved by a session past its teardown grace answers `errorData { reason: "path_still_held", retry_after_ms: 2000 }` (senpi#3485). Only a claim whose owner serves the socket (`current: true`) or still has a client attached refuses an open at all - a superseded, attachment-less claim is reclaimed instead
 - `session_reservation_limit` (this worker already holds 64 live session paths; the open or session replacement was refused without disturbing the existing session)
 - `missing_session_id` (session-scoped command without `sessionId` in multi mode)
 - `multi_session_disabled` (`open_session` in classic mode)
@@ -2410,7 +2412,10 @@ Quiesce and queue options (both optional, combinable with `effectId`):
   `{ reason: "invalid_grace_ms", action }`.
 - `clearQueue: true` drains the steering and follow-up queues atomically before the abort, emits
   `queue_update`, and gives each drained input with a `clientMessageId` a `failed` receipt with outcome
-  `cleared_by_abort` (with `reason`, `detail` and `action`). The answer's `cleared` counts the drained inputs.
+  `cleared` (with `reason`, `detail` and `action`). 2026.10.16-2 wrote this outcome as `cleared_by_abort`;
+  receipts stored under that name are still read and reported unchanged, so accept both. The answer's `cleared` counts the drained inputs.
+  `clear_queue` and `unload_session { clearQueue: true }` close drained input with the same `cleared` outcome; a
+  session release does not (its queued deliveries stay unwritten so the sender redelivers them).
   It also empties the queue of an idle session.
 
 ```json
@@ -2418,6 +2423,8 @@ Quiesce and queue options (both optional, combinable with `effectId`):
 {"type": "response", "command": "abort", "success": true, "data": {"effectId": "stop-2", "state": "done", "effect": {"effectId": "stop-2", "kind": "abort", "state": "done", "durableSessionId": "session-id"}, "stopped": true, "idle": true, "cleared": 1}}
 ```
 
+The typed `RpcClient` sends these with `abort({ effectId, awaitIdle, clearQueue, graceMs })` and returns the answer; `abort()` with no options keeps the old fire-and-forget contract. `getEffectStatus(effectId, { sessionPath? })` reads a receipt.
+
 An aborted turn's `agent_end` carries `aborted: true`, `abortSource` and, when an RPC client aborted it,
 `abortedBy: { connectionId, effectId? }`; a `session_abort` caused by a client carries the same `abortedBy`. `interrupt` records its caller the same way. An abort that reached no turn is forgotten once it settles, and a new turn starts with none, so a later system or extension abort never inherits an old client's `abortedBy`.
 Every attached client sees it. `abortSource` is `user` for a client or user abort, `provider` when the

package/docs/settings.md

@@ -103,7 +103,7 @@ Permission rules are a confirmation policy, not a sandbox. Senpi, extensions, pa
 | `defaultModel` | string | - | Startup model ID (saved with Ctrl+S in `/model`, or edited manually) |
 | `recommendedModels` | string[] | `kimi-k3`, `gpt-6-astra`, `gpt-5.6-sol`, `claude-fable-5-1`, `claude-opus-5-5`, `glm-5.2` | Preferred default model ids in priority order. Built-in thinking levels are kimi-k3/`max`, GPT-6 Astra/`high`, GPT-5.6 Sol/`medium`, claude-fable-5-1/`high`, claude-opus-5-5/`max`, glm-5.2/`max`. Override the list or disable auto-switch with `--no-recommended-models` / `warnings.offRecommendedModel`. |
 | `defaultThinkingLevel` | string | - | Startup thinking level (saved with Ctrl+S in `/thinking`, or edited manually): `"off"`, `"minimal"`, `"low"`, `"medium"`, `"high"`, `"xhigh"`, `"max"` |
-| `promptPreset` | string | `"auto"` | Force a system prompt preset: `"auto"`, `"kimi-k2-6"`, `"kimi-k2-7"`, `"kimi-k2-8"`, `"kimi-k3"`, `"glm-5.2"`, `"glm-5.3"`, `"grok-4.5"`, `"grok-4.6"`, `"grok-4.7"`, `"claude-fable-5"`, `"claude-fable-5-1"`, `"claude-opus-5-5"`, `"claude-opus-5"`, `"claude-sonnet-5-5"`, `"claude-haiku-5-5"`, `"claude-opus-4-5"`, `"claude-opus-4-6"`, `"claude-opus-4-7"`, `"claude-opus-4-8"`, `"deepseek-v4-flash"`, `"deepseek-v4-flash-0731"`, `"deepseek-v4-1-flash"`, `"deepseek-v4-pro"`, `"gpt-5"`, `"gpt-5.2"`, `"gpt-5.3-codex"`, `"gpt-5.4"`, `"gpt-5.5"`, `"gpt-5.6"`, or `"gpt-6-astra"` |
+| `promptPreset` | string | `"auto"` | Force a system prompt preset: `"auto"`, `"kimi-k2-6"`, `"kimi-k2-7"`, `"kimi-k2-8"`, `"kimi-k3"`, `"glm-5.2"`, `"glm-5.3"`, `"grok-4.5"`, `"grok-4.6"`, `"grok-4.7"`, `"claude-fable-5"`, `"claude-fable-5-1"`, `"claude-opus-5-5"`, `"claude-opus-5"`, `"claude-sonnet-5-5"`, `"claude-haiku-5-5"`, `"claude-opus-4-5"`, `"claude-opus-4-6"`, `"claude-opus-4-7"`, `"claude-opus-4-8"`, `"deepseek-v4-flash"`, `"deepseek-v4-flash-0731"`, `"deepseek-v4-1-flash"`, `"deepseek-v4-pro"`, `"gemini-4-argon"`, `"gpt-5"`, `"gpt-5.2"`, `"gpt-5.3-codex"`, `"gpt-5.4"`, `"gpt-5.5"`, `"gpt-5.6"`, or `"gpt-6-astra"` |
 | `hideThinkingBlock` | boolean | `false` | Hide thinking blocks in output |
 | `showCacheMissNotices` | boolean | `false` | Show transcript notices for significant prompt-cache misses, compaction or branch-summary usage, and provider recovery diagnostics such as dropped Anthropic thinking blocks |
 | `thinkingBudgets` | object | - | Custom token budgets per thinking level. Anthropic, Google, and Bedrock use these natively. OpenAI-compatible models use them when `compat.thinkingTokenBudgetField` (or `supportsThinkingTokenBudget`) is set. |
@@ -199,6 +199,19 @@ Set `PI_SKIP_VERSION_CHECK=1` to disable the senpi version update check. Use `--
 }
 ```
 
+### Context Files and Skills
+
+| Setting | Type | Default | Description |
+|---------|------|---------|-------------|
+| `contextFiles.maxBytesPerFile` | number | `65536` | Maximum UTF-8 bytes loaded from each AGENTS.md / CLAUDE.md, including the truncation note and any closing code fence |
+| `contextFiles.maxTotalBytes` | number | `131072` | Maximum combined UTF-8 bytes of loaded context files, including truncation notes and closing code fences |
+
+Files receive budget nearest-first: the current directory, its ancestors, then the global file. A cut prefers a newline in the last quarter of the available content budget; otherwise it uses a UTF-8 character boundary. An open backtick or tilde fence is closed with the same marker before the truncation note; the closing marker's bytes count against the budget. Files with less than 1024 bytes of budget left are skipped when they would need truncation, with a warning distinguishing an undersized per-file limit from budget used by nearer files. Both limits accept positive numbers (rounded down); invalid values use the defaults.
+
+The skills section has a fixed 48 KiB rendered UTF-8 byte cap, including its roots table and markup. Above 100 visible skills or 64 KiB of descriptions, descriptions become one line of at most 160 characters. If needed to meet the section cap, smaller catalogs also use compact descriptions, then all descriptions are dropped. If names and locations still exceed the cap, only the first skills that fit are listed, with the omitted count inside the section. Skills remain available for explicit invocation.
+
+Context cuts, skipped files, and compacted or omitted skills share the "Context size limits" resource notice in interactive mode and appear once on stderr at startup in print, JSON, and RPC modes, with the affected path when present. Ordinary skill validation warnings keep their existing diagnostic behavior and are not printed to stderr by this size check.
+
 ### Compaction
 
 | Setting | Type | Default | Description |
@@ -545,6 +558,8 @@ This is the default and has no setting. Tools may declare `exposure: "eval"` to
 |---------|------|---------|-------------|
 | `engineTurns.maxPerUserInput` | number | `150` | Turns the agent may start on its own (stream-rule nudges, goal continuations, other extension follow-ups) after one user message before it pauses; `0` turns the limit off |
 | `engineTurns.maxToolFreePerMinute` | number | `12` | Turns started on its own within 60 s that called no tool before it pauses; `0` turns the limit off |
+| `turn_inactivity_ms` | number | `3600000` | Milliseconds a turn may run with no tool progress before it is stopped as a deadline; renewed only by tool execution events and admitted user input, never by streamed text. Minimum `60000`; `0` disables |
+| `turn_max_runtime_ms` | number | `21600000` | Hard cap on one turn's runtime from prompt accept; `0` disables |
 
 When a limit is reached the session pauses with a notice instead of starting another turn; any message you send continues it, because only turns since your last message count.
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi",
-	"version": "2026.10.16-2",
+	"version": "2026.10.16-4",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"piConfig": {
@@ -60,9 +60,9 @@
 	},
 	"dependencies": {
 		"@earendil-works/chord": "0.99.1",
-		"@earendil-works/pi-agent-core": "npm:@code-yeongyu/senpi-agent-core@2026.10.16-2",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.16-2",
-		"@earendil-works/pi-tui": "npm:@code-yeongyu/senpi-tui@2026.10.16-2",
+		"@earendil-works/pi-agent-core": "npm:@code-yeongyu/senpi-agent-core@2026.10.16-4",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.16-4",
+		"@earendil-works/pi-tui": "npm:@code-yeongyu/senpi-tui@2026.10.16-4",
 		"@silvia-odwyer/photon-node": "0.3.4",
 		"chalk": "6.0.0",
 		"cross-spawn": "7.0.6",
@@ -81,8 +81,8 @@
 		"yaml": "2.9.1",
 		"@anthropic-ai/claude-agent-sdk": "0.3.296",
 		"@anthropic-ai/sdk": "0.127.0",
-		"@code-yeongyu/senpi-codemode": "2026.10.16-2",
-		"@earendil-works/pi-pty": "npm:@code-yeongyu/senpi-pty@2026.10.16-2",
+		"@code-yeongyu/senpi-codemode": "2026.10.16-4",
+		"@earendil-works/pi-pty": "npm:@code-yeongyu/senpi-pty@2026.10.16-4",
 		"@modelcontextprotocol/sdk": "1.32.1",
 		"@mozilla/readability": "0.6.0",
 		"linkedom": "0.18.13",