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

package/dist/core/turn-deadline.js

@@ -0,0 +1,179 @@
+// The session-level turn deadline contract: how long a turn may run with no tool
+// progress, and the absolute cap on one turn's runtime. One implementation for every
+// surface - TUI, RPC, and host sessions all run through AgentSession.
+export const TURN_DEADLINE_ENTRY_TYPE = "deadline-stop";
+/** Milliseconds the abort is given to terminalize before the lease forces settlement. */
+export const TURN_DEADLINE_GRACE_MS = 10_000;
+export const DEFAULT_TURN_INACTIVITY_MS = 3_600_000;
+export const MIN_TURN_INACTIVITY_MS = 60_000;
+export const DEFAULT_TURN_MAX_RUNTIME_MS = 21_600_000;
+function isDeadlineStopData(data) {
+    if (data === null || typeof data !== "object")
+        return false;
+    const candidate = data;
+    return ((candidate.kind === "inactivity" || candidate.kind === "max_runtime") &&
+        typeof candidate.limitMs === "number" &&
+        typeof candidate.elapsedMs === "number");
+}
+/**
+ * The latest deadline stop on the branch, or undefined when none is pending. A
+ * deadline-stopped session suppresses every automatic continuation until admitted user
+ * input starts a new turn; the entry is read fresh so the hold survives reload and reopen.
+ * Only a user message releases the hold: the aborted assistant message of the stopped
+ * turn is persisted after the stop entry and must not clear it.
+ */
+export function deadlineStopPendingSinceLastTurn(entries) {
+    for (let index = entries.length - 1; index >= 0; index -= 1) {
+        const entry = entries[index];
+        if (entry.type === "message" && entry.message?.role === "user")
+            return undefined;
+        if (entry.type === "custom" && entry.customType === TURN_DEADLINE_ENTRY_TYPE && isDeadlineStopData(entry.data)) {
+            return entry.data;
+        }
+    }
+    return undefined;
+}
+export function resolveTurnDeadlineSettings(configured) {
+    const milliseconds = (value, fallback, minimum) => {
+        if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+            return fallback;
+        if (value === 0)
+            return 0;
+        return Math.max(minimum, Math.floor(value));
+    };
+    return {
+        inactivityMs: milliseconds(configured.turn_inactivity_ms, DEFAULT_TURN_INACTIVITY_MS, MIN_TURN_INACTIVITY_MS),
+        maxRuntimeMs: milliseconds(configured.turn_max_runtime_ms, DEFAULT_TURN_MAX_RUNTIME_MS, 1),
+    };
+}
+/** Resolves true when `work` settles within `ms`, false when the time runs out first. */
+async function within(work, ms) {
+    let timer;
+    const expired = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(false), ms);
+    });
+    try {
+        return await Promise.race([
+            work.then(() => true, () => false),
+            expired,
+        ]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * Owns the inactivity lease and the hard max-runtime cap for one turn. Armed at prompt
+ * accept, renewed only by tool execution progress and admitted user input, never by text
+ * deltas. On expiry it records the durable stop entry and ends the run through the normal
+ * system-abort path. This is the single implementation of senpi#3227 for every surface.
+ */
+export class AgentDeadlineTracker {
+    get current() {
+        return this.deadlineValue;
+    }
+    constructor(session, settings, now = Date.now) {
+        this.startedAtMs = 0;
+        this.session = session;
+        this.settings = settings;
+        this.now = now;
+    }
+    arm() {
+        this.clearTimers();
+        this.deadlineValue = undefined;
+        this.startedAtMs = this.now();
+        const { inactivityMs, maxRuntimeMs } = this.settings();
+        if (inactivityMs > 0)
+            this.inactivityTimer = setTimeout(() => this.fire("inactivity"), inactivityMs);
+        if (maxRuntimeMs > 0)
+            this.maxRuntimeTimer = setTimeout(() => this.fire("max_runtime"), maxRuntimeMs);
+    }
+    renew() {
+        if (this.deadlineValue !== undefined || this.startedAtMs === 0)
+            return;
+        const { inactivityMs } = this.settings();
+        if (inactivityMs <= 0)
+            return;
+        if (this.inactivityTimer !== undefined)
+            clearTimeout(this.inactivityTimer);
+        this.inactivityTimer = setTimeout(() => this.fire("inactivity"), inactivityMs);
+    }
+    disarm() {
+        this.clearTimers();
+        this.startedAtMs = 0;
+    }
+    /**
+     * Admitted user input releases the deadline-stopped hold. Input steered into a live run counts as
+     * activity (the inactivity lease restarts) but never resets the max-runtime clock of that run.
+     */
+    clearHold() {
+        // A stopped run that has not settled keeps its deadline (its agent_end reports it); the next arm resets it.
+        if (this.deadlineValue === undefined) {
+            this.renew();
+            return;
+        }
+        // Once the stopped run has settled, its deadline is history: input clears it.
+        if (this.session.isIdle)
+            this.deadlineValue = undefined;
+    }
+    clearTimers() {
+        if (this.inactivityTimer !== undefined)
+            clearTimeout(this.inactivityTimer);
+        if (this.maxRuntimeTimer !== undefined)
+            clearTimeout(this.maxRuntimeTimer);
+        this.inactivityTimer = undefined;
+        this.maxRuntimeTimer = undefined;
+    }
+    fire(kind) {
+        this.expire(kind).catch((error) => this.session._warnDeadline("turn_deadline_failed", error instanceof Error ? error.message : String(error)));
+    }
+    async expire(kind) {
+        if (this.deadlineValue !== undefined || this.startedAtMs === 0)
+            return;
+        const { inactivityMs, maxRuntimeMs } = this.settings();
+        const limitMs = kind === "inactivity" ? inactivityMs : maxRuntimeMs;
+        if (limitMs <= 0)
+            return;
+        // A provider retry in flight is the engine recovering the turn: it renews the inactivity lease.
+        // The max-runtime cap is absolute and applies through retries.
+        if (kind === "inactivity" && this.session.isRetryInFlight) {
+            this.inactivityTimer = undefined;
+            this.renew();
+            return;
+        }
+        this.clearTimers();
+        const deadline = { kind, limitMs, elapsedMs: this.now() - this.startedAtMs };
+        this.deadlineValue = deadline;
+        try {
+            this.session._recordDeadlineStop(deadline);
+        }
+        catch (error) {
+            // The stop still happens; only its durable hold entry is missing.
+            this.session._warnDeadline("turn_deadline_record_failed", error instanceof Error ? error.message : String(error));
+        }
+        // The abort signal reaches every running tool (the bash tool kills its process tree on it), and the
+        // normal settle path emits agent_idle once the run ends. A turn still running after the grace is held by
+        // something no abort can end (an extension handler that never returns): it is reported, never faked idle.
+        let abortError;
+        const aborting = this.session.abortTurnForDeadline().catch((error) => {
+            abortError = error instanceof Error ? error.message : String(error);
+        });
+        const settled = await within(aborting, TURN_DEADLINE_GRACE_MS);
+        if (abortError !== undefined)
+            this.session._warnDeadline("turn_deadline_abort_failed", abortError);
+        if (settled && abortError === undefined)
+            return;
+        if (!this.session.isIdle)
+            this.session._warnDeadline("turn_deadline_unsettled", `turn still running ${TURN_DEADLINE_GRACE_MS} ms after the ${kind} deadline abort`);
+    }
+}
+export function buildDeadlineStopNotice(deadline) {
+    const limit = deadline.limitMs < 60_000
+        ? `${Math.max(1, Math.round(deadline.limitMs / 1000))} s`
+        : `${Math.round(deadline.limitMs / 60_000)} min`;
+    const reason = deadline.kind === "inactivity"
+        ? `no tool progress for ${limit} (turn_inactivity_ms)`
+        : `turn hit its maximum runtime of ${limit} (turn_max_runtime_ms)`;
+    return `turn stopped: ${reason}. Action: send a message to continue, or raise the limit in settings`;
+}
+//# sourceMappingURL=turn-deadline.js.map

package/dist/main.js

@@ -47,7 +47,7 @@ import { ModelRuntime } from "./core/model-runtime.js";
 import { markMovedSessions, movedHereSessionToContinue, withMovedSessions } from "./core/moved-sessions.js";
 import { restoreStdout, takeOverStdout } from "./core/output-guard.js";
 import { recordProcessLifetime } from "./core/process-crash-record.js";
-import { resolveProjectTrusted } from "./core/project-trust.js";
+import { presetTrustsProject, resolveProjectTrusted } from "./core/project-trust.js";
 import { resolveResumeTarget } from "./core/resume-target.js";
 import { formatMissingSessionCwdPrompt, getMissingSessionCwdIssue, MissingSessionCwdError, } from "./core/session-cwd.js";
 import { sessionExtensionFlagValues } from "./core/session-extension-flags.js";
@@ -677,13 +677,26 @@ export function createCliRuntimeFactory(configuration, local = {}) {
         const projectTrustDiagnostics = [];
         const cachedProjectTrust = projectTrustByCwd.get(cwd);
         const hasTrustRequiringResources = hasTrustRequiringProjectResources(cwd);
-        const shouldResolveProjectTrust = parsed.projectTrustOverride === undefined && cachedProjectTrust === undefined && hasTrustRequiringResources;
+        // A full-access session trusts its project without asking, for that session only: nothing is
+        // cached here or saved to the trust store, and a saved "do not trust" still wins (#2465).
+        const fullAccessTrust = presetTrustsProject(sessionExtensionFlagValues(parsed.unknownFlags, launchProfile).get("permission-preset"), startupSettingsManager.getGlobalSettings().permissionPreset) && trustStore.get(cwd) !== false;
+        const shouldResolveProjectTrust = parsed.projectTrustOverride === undefined &&
+            cachedProjectTrust === undefined &&
+            !fullAccessTrust &&
+            hasTrustRequiringResources;
         const projectTrusted = shouldResolveProjectTrust
             ? false
             : (cachedProjectTrust ??
                 parsed.projectTrustOverride ??
-                (!hasTrustRequiringResources || trustStore.get(cwd) === true));
-        const runtimeSettingsManager = SettingsManager.create(cwd, agentDir, { projectTrusted });
+                (fullAccessTrust || !hasTrustRequiringResources || trustStore.get(cwd) === true));
+        // Trusted only because of Full access (resources need trust and nothing else granted it): leaving
+        // Full access withdraws it (#3420 review T5).
+        const trustFromFullAccess = fullAccessTrust &&
+            hasTrustRequiringResources &&
+            cachedProjectTrust === undefined &&
+            parsed.projectTrustOverride === undefined &&
+            trustStore.get(cwd) !== true;
+        const runtimeSettingsManager = SettingsManager.create(cwd, agentDir, { projectTrusted, trustFromFullAccess });
         // The opener's per-session fallback policy is an in-memory override: never saved, never shared.
         if (launchProfile?.retryFallback)
             applyRetryFallbackProfile(runtimeSettingsManager, launchProfile.retryFallback);
@@ -1194,6 +1207,12 @@ export async function main(args, options) {
         reportDiagnostics([{ type: "warning", message: formatThinkingClampWarning(startupThinkingClamp) }]);
     }
     if (appMode !== "interactive") {
+        reportDiagnostics([...(resourceLoader.getAgentsFiles().diagnostics ?? []), ...resourceLoader.getSkills().diagnostics]
+            .filter((diagnostic) => diagnostic.type === "warning" && diagnostic.category === "size-limit")
+            .map((diagnostic) => ({
+            type: "warning",
+            message: diagnostic.path ? `${diagnostic.path}: ${diagnostic.message}` : diagnostic.message,
+        })));
         reportDiagnostics(collectAuthDiagnostics(services.authStorage, "runtime creation"));
     }
     if (runtime.diagnostics.some((diagnostic) => diagnostic.type === "error")) {

package/dist/modes/interactive/interactive-mode.js

@@ -1952,16 +1952,23 @@ export class InteractiveMode {
             }
         }
         if (showDiagnostics) {
-            const addDiagnosticNotice = (title, diagnostics) => {
+            const addDiagnosticNotice = (title, diagnostics, why = "Conflicting or invalid loaded resources were found.") => {
                 this.loadedResourcesContainer.addChild(buildNoticeBox({
                     title,
                     tone: "warning",
-                    why: "Conflicting or invalid loaded resources were found.",
+                    why,
                     extra: this.formatDiagnostics(diagnostics, sourceInfos),
                 }, { expanded: this.toolOutputExpanded }, theme));
                 this.loadedResourcesContainer.addChild(new Spacer(1));
             };
-            const skillDiagnostics = skillsResult.diagnostics;
+            const contextDiagnostics = [
+                ...(this.session.resourceLoader.getAgentsFiles().diagnostics ?? []),
+                ...skillsResult.diagnostics.filter((diagnostic) => diagnostic.category === "size-limit"),
+            ];
+            if (contextDiagnostics.length > 0) {
+                addDiagnosticNotice("Context size limits", contextDiagnostics, "Context files or skill catalogs were limited to keep requests bounded.");
+            }
+            const skillDiagnostics = skillsResult.diagnostics.filter((diagnostic) => diagnostic.category !== "size-limit");
             if (skillDiagnostics.length > 0) {
                 addDiagnosticNotice("Skill conflicts", skillDiagnostics);
             }

package/dist/modes/rpc/abort-grace.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The `abort { awaitIdle }` grace window, shared by the host that enforces it and the client that sizes its
+ * request deadline from it (docs/rpc.md `abort`). Kept free of host imports so the client can load it.
+ */
+export declare const ABORT_DEFAULT_GRACE_MS = 10000;
+export declare const ABORT_MAX_GRACE_MS = 60000;
+/** A `graceMs` the host accepts: a whole number of milliseconds from 0 to {@link ABORT_MAX_GRACE_MS}. */
+export declare function isAbortGraceInRange(graceMs: unknown): graceMs is number;
+//# sourceMappingURL=abort-grace.d.ts.map

package/dist/modes/rpc/abort-grace.js

@@ -0,0 +1,11 @@
+/**
+ * The `abort { awaitIdle }` grace window, shared by the host that enforces it and the client that sizes its
+ * request deadline from it (docs/rpc.md `abort`). Kept free of host imports so the client can load it.
+ */
+export const ABORT_DEFAULT_GRACE_MS = 10_000;
+export const ABORT_MAX_GRACE_MS = 60_000;
+/** A `graceMs` the host accepts: a whole number of milliseconds from 0 to {@link ABORT_MAX_GRACE_MS}. */
+export function isAbortGraceInRange(graceMs) {
+    return typeof graceMs === "number" && Number.isInteger(graceMs) && graceMs >= 0 && graceMs <= ABORT_MAX_GRACE_MS;
+}
+//# sourceMappingURL=abort-grace.js.map

package/dist/modes/rpc/client-admission-record.d.ts

@@ -69,6 +69,7 @@ export declare const clientAdmissionRecordSchema: z.ZodDiscriminatedUnion<[z.Zod
         kind: z.ZodEnum<{
             aborted: "aborted";
             already_delivered: "already_delivered";
+            cleared: "cleared";
             cleared_by_abort: "cleared_by_abort";
             completed: "completed";
             context_budget: "context_budget";

package/dist/modes/rpc/client-admissions.d.ts

@@ -31,6 +31,8 @@ export declare class ClientAdmissions {
     hasIdentities: boolean;
     readonly ready: Promise<void>;
     private constructor();
+    /** Mark queued input cleared on a session whose ledger exists; never builds one (that would restore queued input). */
+    static clearQueuedFor(session: AgentSession): void;
     /**
      * Whenever `runtime` replaces its session, give the outgoing session's still-queued inputs a
      * `dropped_by_replace` receipt. Only a ledger that already exists is touched: building one now would
@@ -60,10 +62,11 @@ export declare class ClientAdmissions {
      */
     forgetAbort(abort: ClientAbort): void;
     /**
-     * `abort { clearQueue }` is about to drain the queues: give every still-queued input an honest
-     * `cleared_by_abort` receipt first, so the drain's `queue_update` cannot read it as delivered.
+     * The queues are about to be drained (`clear_queue`, `abort` or `unload_session` with `clearQueue`, a session
+     * release is not one: its queued deliveries stay unwritten so the sender redelivers them): give every still-queued input an honest `cleared` receipt first, so the drain's `queue_update` cannot
+     * read it as delivered (senpi#3412).
      */
-    clearQueuedByAbort(): void;
+    clearQueued(): void;
     /**
      * The session is being replaced (`new_session`, `switch_session`, `fork`) and its queue is about to be
      * discarded with it: give every still-queued input an honest terminal receipt in its own transcript, so

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

@@ -84,6 +84,10 @@ export class ClientAdmissions {
         // Publish this ledger in the WeakMap before restoration emits queue events.
         this.ready = Promise.resolve().then(() => this.restore());
     }
+    /** Mark queued input cleared on a session whose ledger exists; never builds one (that would restore queued input). */
+    static clearQueuedFor(session) {
+        sessions.get(session)?.clearQueued();
+    }
     /**
      * Whenever `runtime` replaces its session, give the outgoing session's still-queued inputs a
      * `dropped_by_replace` receipt. Only a ledger that already exists is touched: building one now would
@@ -142,10 +146,11 @@ export class ClientAdmissions {
             this.lastAbort = undefined;
     }
     /**
-     * `abort { clearQueue }` is about to drain the queues: give every still-queued input an honest
-     * `cleared_by_abort` receipt first, so the drain's `queue_update` cannot read it as delivered.
+     * The queues are about to be drained (`clear_queue`, `abort` or `unload_session` with `clearQueue`, a session
+     * release is not one: its queued deliveries stay unwritten so the sender redelivers them): give every still-queued input an honest `cleared` receipt first, so the drain's `queue_update` cannot
+     * read it as delivered (senpi#3412).
      */
-    clearQueuedByAbort() {
+    clearQueued() {
         if (this.durableSessionId !== this.session.sessionManager.getSessionId())
             return;
         for (const record of [...this.records.values()]) {
@@ -155,7 +160,7 @@ export class ClientAdmissions {
                 ...record,
                 state: "completed",
                 prepared: undefined,
-                outcome: EFFECT_OUTCOMES.inputClearedByAbort,
+                outcome: EFFECT_OUTCOMES.inputCleared,
             });
         }
     }

package/dist/modes/rpc/connection-handler.js

@@ -651,10 +651,14 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                     const abortSource = session.currentAbortSource;
                     if (abortSource !== undefined)
                         lastAbortSource = abortSource;
+                    const deadline = session.currentDeadline;
                     const abortedBy = abortSource === undefined ? undefined : ClientAdmissions.forSession(session).abortedBy;
-                    correlatedEvents.accept(abortSource === undefined
-                        ? event
-                        : { ...event, aborted: true, abortSource, ...(abortedBy === undefined ? {} : { abortedBy }) });
+                    correlatedEvents.accept({
+                        ...event,
+                        ...(abortSource === undefined ? {} : { aborted: true, abortSource }),
+                        ...(abortedBy === undefined ? {} : { abortedBy }),
+                        ...(deadline === undefined ? {} : { deadline }),
+                    });
                     return;
                 }
                 if (event.type === "session_abort") {
@@ -866,6 +870,7 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
             case "edit_queued_message":
                 return runQueuedInputChange(effectContext(), command);
             case "clear_queue": {
+                ClientAdmissions.clearQueuedFor(session);
                 const cleared = session.clearQueue({ abortWillFollow: command.abortWillFollow ?? false });
                 return success(id, "clear_queue", {
                     steering: cleared.steering,

package/dist/modes/rpc/effect-commands.d.ts

@@ -18,10 +18,8 @@ export declare function beginEffect(ctx: EffectCommandContext, kind: EffectComma
     readonly effectId: string;
 }): Promise<EffectBegin | RpcResponse>;
 export declare function isEffectBegin(value: EffectBegin | RpcResponse): value is EffectBegin;
-export declare const ABORT_DEFAULT_GRACE_MS = 10000;
-export declare const ABORT_MAX_GRACE_MS = 60000;
 /**
- * `abort`: with `clearQueue` the queued inputs are drained (each gets a `cleared_by_abort` receipt) before
+ * `abort`: with `clearQueue` the queued inputs are drained (each gets a `cleared` receipt) before
  * the abort; with `awaitIdle` the answer waits until the session is idle or `graceMs` passes. Without
  * either, the abort is acknowledged on dispatch exactly as before.
  */

package/dist/modes/rpc/effect-commands.js

@@ -1,5 +1,6 @@
 import { ModelUsabilityBudgetError } from "../../core/extensions/builtin/compaction/model-usability-budget.js";
 import { ModelSwitchAuthError } from "../../core/model-switch-auth-error.js";
+import { ABORT_DEFAULT_GRACE_MS, ABORT_MAX_GRACE_MS, isAbortGraceInRange } from "./abort-grace.js";
 import { ClientAdmissions } from "./client-admissions.js";
 import { EffectLedger } from "./effect-ledger.js";
 import { contextBudgetOutcome, EFFECT_OUTCOMES, modelSwitchErrorOutcome, providerUnavailableOutcome, unknownModelOutcome, unsupportedThinkingLevelOutcome, } from "./effect-outcome-copy.js";
@@ -45,13 +46,11 @@ function isResponse(value) {
 export function isEffectBegin(value) {
     return !isResponse(value);
 }
-export const ABORT_DEFAULT_GRACE_MS = 10_000;
-export const ABORT_MAX_GRACE_MS = 60_000;
 function invalidGrace(command) {
     const { graceMs } = command;
     if (graceMs === undefined)
         return undefined;
-    if (Number.isInteger(graceMs) && graceMs >= 0 && graceMs <= ABORT_MAX_GRACE_MS)
+    if (isAbortGraceInRange(graceMs))
         return undefined;
     const reason = "invalid_grace_ms";
     const action = `send graceMs as a whole number of milliseconds from 0 to ${ABORT_MAX_GRACE_MS}`;
@@ -74,7 +73,7 @@ async function quiesce(session, aborting, graceMs) {
     }
 }
 /**
- * `abort`: with `clearQueue` the queued inputs are drained (each gets a `cleared_by_abort` receipt) before
+ * `abort`: with `clearQueue` the queued inputs are drained (each gets a `cleared` receipt) before
  * the abort; with `awaitIdle` the answer waits until the session is idle or `graceMs` passes. Without
  * either, the abort is acknowledged on dispatch exactly as before.
  */
@@ -93,7 +92,7 @@ export async function runAbort(ctx, command, dispatch) {
     const streaming = ctx.session.isStreaming;
     let cleared = 0;
     if (command.clearQueue === true) {
-        admissions.clearQueuedByAbort();
+        admissions.clearQueued();
         const drained = ctx.session.clearQueue({ abortWillFollow: true });
         cleared = drained.steering.length + drained.followUp.length;
     }

package/dist/modes/rpc/effect-outcome-copy.d.ts

@@ -10,10 +10,10 @@ export declare const EFFECT_OUTCOMES: {
         readonly detail: "the session was reopened while this input's turn was running, so that turn never finished";
         readonly action: "read the transcript for what the turn produced, then send the input again with a new clientMessageId";
     };
-    readonly inputClearedByAbort: {
-        readonly kind: "cleared_by_abort";
-        readonly reason: "cleared_by_abort";
-        readonly detail: "an abort with clearQueue removed this queued input before it was delivered";
+    readonly inputCleared: {
+        readonly kind: "cleared";
+        readonly reason: "cleared";
+        readonly detail: "the queue was cleared (clear_queue, or abort or unload_session with clearQueue) before this queued input was delivered";
         readonly action: "send the input again with a new clientMessageId if it is still needed";
     };
     readonly queuedInputAlreadyDelivered: {

package/dist/modes/rpc/effect-outcome-copy.js

@@ -9,10 +9,10 @@ export const EFFECT_OUTCOMES = {
         detail: "the session was reopened while this input's turn was running, so that turn never finished",
         action: "read the transcript for what the turn produced, then send the input again with a new clientMessageId",
     },
-    inputClearedByAbort: {
-        kind: "cleared_by_abort",
-        reason: "cleared_by_abort",
-        detail: "an abort with clearQueue removed this queued input before it was delivered",
+    inputCleared: {
+        kind: "cleared",
+        reason: "cleared",
+        detail: "the queue was cleared (clear_queue, or abort or unload_session with clearQueue) before this queued input was delivered",
         action: "send the input again with a new clientMessageId if it is still needed",
     },
     queuedInputAlreadyDelivered: {

package/dist/modes/rpc/effect-record.d.ts

@@ -14,6 +14,7 @@ export declare const effectOutcomeSchema: z.ZodObject<{
     kind: z.ZodEnum<{
         aborted: "aborted";
         already_delivered: "already_delivered";
+        cleared: "cleared";
         cleared_by_abort: "cleared_by_abort";
         completed: "completed";
         context_budget: "context_budget";
@@ -60,6 +61,7 @@ export declare const rpcEffectRecordSchema: z.ZodObject<{
         kind: z.ZodEnum<{
             aborted: "aborted";
             already_delivered: "already_delivered";
+            cleared: "cleared";
             cleared_by_abort: "cleared_by_abort";
             completed: "completed";
             context_budget: "context_budget";

package/dist/modes/rpc/effect-record.js

@@ -21,6 +21,8 @@ export const effectOutcomeSchema = z.object({
         "unsupported_thinking_level",
         "superseded",
         "context_budget",
+        "cleared",
+        // 2026.10.16-2 wrote an abort-drained input under this name; it must stay readable.
         "cleared_by_abort",
         "already_delivered",
         "not_found",

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

@@ -10,7 +10,7 @@ export function projectAdmission(record, sessionId) {
         effectId: record.clientMessageId,
         kind: "input",
         // A dropped or cleared input is stored as `completed` so older hosts never restore it; it never ran.
-        state: outcome?.kind === "dropped_by_replace" || outcome?.kind === "cleared_by_abort"
+        state: outcome?.kind === "dropped_by_replace" || outcome?.kind === "cleared" || outcome?.kind === "cleared_by_abort"
             ? "failed"
             : ADMISSION_STATES[record.state],
         disposition: record.disposition,

package/dist/modes/rpc/host-handover-parked.d.ts

@@ -30,6 +30,12 @@ export interface HandoverParkedEntry {
     readonly sessionContext?: SessionContext;
     readonly autoTitle?: boolean;
     readonly retryFallback?: SessionRetryFallbackProfile;
+    /**
+     * The host instance that wrote the park. Its own reopen watch skips it: the park is for the NEXT
+     * generation, and a host reopening what it just idle-parked races the client's reopen (senpi#3485).
+     * Absent on entries an older generation wrote, which every reader treats as a predecessor's park.
+     */
+    readonly parkedBy?: string;
 }
 export declare function recordHandoverParkedSession(daemonDir: string, entry: HandoverParkedEntry): Promise<void>;
 export declare function readHandoverParkedSessions(daemonDir: string): Promise<readonly HandoverParkedEntry[]>;

package/dist/modes/rpc/host-handover-parked.js

@@ -35,6 +35,7 @@ function isEntry(value) {
         typeof record.retainOnDisconnect === "boolean" &&
         (record.durableSessionId === undefined || typeof record.durableSessionId === "string") &&
         (record.cwd === undefined || typeof record.cwd === "string") &&
+        (record.parkedBy === undefined || typeof record.parkedBy === "string") &&
         (record.thinkingLevel === undefined || typeof record.thinkingLevel === "string") &&
         (record.permissionPreset === undefined ||
             (typeof record.permissionPreset === "string" &&

package/dist/modes/rpc/host-handover-reopen.js

@@ -46,12 +46,12 @@ export async function reopenHandoverParkedSessions(open, agentDir, socket, holde
         // it by path with the same durable id.
         if (holder?.shouldReopen !== undefined && !holder.shouldReopen())
             return;
-        const parked = await readHandoverParkedSessions(daemonDir);
+        const parked = await inheritedParks(daemonDir, holder);
         for (const entry of parked) {
             sawAnyPark = true;
             await reopenOne(daemonDir, open, entry, reopenAttempts, heldPolls, holder);
         }
-        const remaining = (await readHandoverParkedSessions(daemonDir)).length;
+        const remaining = (await inheritedParks(daemonDir, holder)).length;
         emptyStreak = remaining === 0 ? emptyStreak + 1 : 0;
         if (sawAnyPark && emptyStreak >= HANDOVER_PARKED_REOPEN_QUIET_STREAK)
             return;
@@ -60,6 +60,15 @@ export async function reopenHandoverParkedSessions(open, agentDir, socket, holde
         await new Promise((resolve) => setTimeout(resolve, HANDOVER_PARKED_REOPEN_POLL_MS));
     }
 }
+/**
+ * The parks a PREVIOUS generation left for this one. A park this host wrote itself (its idle sweep
+ * parks retained sessions into the same record) is for its successor: reopening it here would put a
+ * second open of the path in flight against the client reopening it (senpi#3485).
+ */
+async function inheritedParks(daemonDir, holder) {
+    const parked = await readHandoverParkedSessions(daemonDir);
+    return parked.filter((entry) => entry.parkedBy === undefined || entry.parkedBy !== holder?.hostInstance);
+}
 async function reopenOne(daemonDir, open, entry, attempts, heldPolls, holder) {
     await dropHandoverParkedSessionIfFileGone(daemonDir, entry.sessionPath);
     if (!existsSync(entry.sessionPath)) {

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

@@ -22,7 +22,7 @@ export declare class RpcCommandError extends Error {
 }
 import type { SessionEntry, SessionTreeNode } from "../../core/session-manager.ts";
 import type { JsonAgentSessionEvent } from "../json-event.ts";
-import type { EditAssistantMessageResult, EditUserMessageResult, RpcAccountFailoverEvent, RpcAuthAccountsChangedEvent, RpcCommand, RpcEvalCell, RpcEvalCellSnapshot, RpcExtensionEvent, RpcExtensionUIProgress, RpcExtensionUIRequest, RpcExtensionUIResponse, RpcOpenQueuedEvent, RpcProviderAccount, RpcSessionModelEntry, RpcSessionParkedEvent, RpcSessionReplacedEvent, RpcSessionState, RpcSlashCommand, RpcUnloadAnswer } from "./rpc-types.ts";
+import type { EditAssistantMessageResult, EditUserMessageResult, RpcAccountFailoverEvent, RpcAuthAccountsChangedEvent, RpcCommand, RpcEvalCell, RpcEvalCellSnapshot, RpcExtensionEvent, RpcExtensionUIProgress, RpcExtensionUIRequest, RpcExtensionUIResponse, RpcOpenQueuedEvent, RpcProviderAccount, RpcResponse, RpcSessionModelEntry, RpcSessionParkedEvent, RpcSessionReplacedEvent, RpcSessionState, RpcSlashCommand, RpcUnloadAnswer } from "./rpc-types.ts";
 export interface RpcClientOptions {
     /** Connect to an existing multi-session Unix socket instead of spawning a child. */
     socketPath?: string;
@@ -72,6 +72,20 @@ export declare class RpcTransportGoneError extends Error {
     constructor(message?: string);
 }
 export declare function isTransportGoneError(error: unknown): error is RpcTransportGoneError;
+/** The options of a typed `abort` (see `docs/rpc.md`, `abort`). */
+export type RpcAbortOptions = Omit<Extract<RpcCommand, {
+    type: "abort";
+}>, "type" | "id" | "sessionId">;
+/** The host's answer to a typed `abort`; an older host answers with no data. */
+export type RpcAbortAnswer = Extract<RpcResponse, {
+    command: "abort";
+    success: true;
+}>["data"];
+/** `get_effect_status`: the receipt, or proof the whole transcript holds none. */
+export type RpcEffectStatusAnswer = Extract<RpcResponse, {
+    command: "get_effect_status";
+    success: true;
+}>["data"];
 export declare class RpcClientOpenInFlightError extends Error {
     readonly code: "open_session_in_flight";
     constructor();
@@ -222,9 +236,21 @@ export declare class RpcClient {
         enqueueOrder?: number;
     }): Promise<QueuedInputDisposition>;
     /**
-     * Abort current operation.
+     * Abort current operation. With no options this is the fire-and-forget abort it always was (transport
+     * loss resolves). With options it is the typed abort: `effectId` records a receipt, `awaitIdle` answers
+     * once the turn stopped (or `graceMs` passed), `clearQueue` drains queued input first; the host's
+     * answer (`effectId`, `state`, `effect`, `stopped`, `idle`, `cleared`) is returned.
      */
     abort(): Promise<void>;
+    abort(options: RpcAbortOptions): Promise<RpcAbortAnswer>;
+    abort(options?: RpcAbortOptions): Promise<RpcAbortAnswer | undefined>;
+    /**
+     * 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.
+     */
+    getEffectStatus(effectId: string, options?: {
+        readonly sessionPath?: string;
+    }): Promise<RpcEffectStatusAnswer>;
     /** Abort with host refusals and transport loss surfaced to machine callers. */
     abortStrict(): Promise<void>;
     abortCompaction(): Promise<void>;