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

package/dist/core/turn-deadline.d.ts

@@ -0,0 +1,92 @@
+export declare const TURN_DEADLINE_ENTRY_TYPE = "deadline-stop";
+export interface TurnDeadlineSettings {
+    readonly inactivityMs: number;
+    readonly maxRuntimeMs: number;
+}
+/** Milliseconds the abort is given to terminalize before the lease forces settlement. */
+export declare const TURN_DEADLINE_GRACE_MS = 10000;
+export declare const DEFAULT_TURN_INACTIVITY_MS = 3600000;
+export declare const MIN_TURN_INACTIVITY_MS = 60000;
+export declare const DEFAULT_TURN_MAX_RUNTIME_MS = 21600000;
+export type TurnDeadlineKind = "inactivity" | "max_runtime";
+export interface TurnDeadline {
+    readonly kind: TurnDeadlineKind;
+    readonly limitMs: number;
+    readonly elapsedMs: number;
+}
+/**
+ * The recorded form of a deadline stop, durable on the session branch so a config reload
+ * or session reopen keeps suppressing goal continuations until admitted user input.
+ */
+export interface DeadlineStopData {
+    readonly kind: TurnDeadlineKind;
+    readonly limitMs: number;
+    readonly elapsedMs: number;
+    readonly at: number;
+}
+interface DeadlineStopEntry {
+    readonly type: string;
+    readonly customType?: string;
+    readonly data?: unknown;
+    readonly message?: {
+        readonly role?: string;
+    };
+}
+/**
+ * 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 declare function deadlineStopPendingSinceLastTurn(entries: readonly DeadlineStopEntry[]): DeadlineStopData | undefined;
+export declare function resolveTurnDeadlineSettings(configured: {
+    readonly turn_inactivity_ms?: unknown;
+    readonly turn_max_runtime_ms?: unknown;
+}): TurnDeadlineSettings;
+/**
+ * The narrow AgentSession surface the tracker needs, declared here so the tracker lives
+ * with the rest of the deadline contract instead of inside agent-session.ts.
+ */
+export type TurnDeadlineWarning = "turn_deadline_record_failed" | "turn_deadline_abort_failed" | "turn_deadline_unsettled" | "turn_deadline_failed";
+export interface DeadlineSessionOwner {
+    _recordDeadlineStop(deadline: TurnDeadline): void;
+    /** End the turn through the normal system abort (tools see the abort signal); resolves once the session is idle. */
+    abortTurnForDeadline(): Promise<void>;
+    /** True while a provider retry is in flight; the engine is actively recovering the turn. */
+    readonly isRetryInFlight: boolean;
+    readonly isIdle: boolean;
+    /** A deadline stop that could not complete (the entry write failed, or the turn outlived the grace). */
+    _warnDeadline(event: TurnDeadlineWarning, detail: string): void;
+}
+/**
+ * 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 declare class AgentDeadlineTracker {
+    private inactivityTimer;
+    private maxRuntimeTimer;
+    private deadlineValue;
+    private startedAtMs;
+    private readonly session;
+    private readonly settings;
+    private readonly now;
+    get current(): TurnDeadline | undefined;
+    constructor(session: DeadlineSessionOwner, settings: () => TurnDeadlineSettings, now?: () => number);
+    arm(): void;
+    renew(): void;
+    disarm(): void;
+    /**
+     * 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(): void;
+    private clearTimers;
+    private fire;
+    private expire;
+}
+export declare function buildDeadlineStopNotice(deadline: TurnDeadline): string;
+export {};
+//# sourceMappingURL=turn-deadline.d.ts.map

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/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

@@ -21,7 +21,7 @@ export declare function isEffectBegin(value: EffectBegin | RpcResponse): value i
 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

@@ -74,7 +74,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 +93,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/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

@@ -2410,7 +2410,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

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. |
@@ -545,6 +545,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-3",
 	"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-3",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.16-3",
+		"@earendil-works/pi-tui": "npm:@code-yeongyu/senpi-tui@2026.10.16-3",
 		"@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-3",
+		"@earendil-works/pi-pty": "npm:@code-yeongyu/senpi-pty@2026.10.16-3",
 		"@modelcontextprotocol/sdk": "1.32.1",
 		"@mozilla/readability": "0.6.0",
 		"linkedom": "0.18.13",