@code-yeongyu/senpi 2026.10.18-1 → 2026.10.19

package/dist/core/session-move/move-ledger.js

@@ -0,0 +1,151 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import lockfile from "proper-lockfile";
+import { FILE_STORAGE_LOCK_RETRY_MAX_DELAY_MS, FILE_STORAGE_LOCK_RETRY_MIN_DELAY_MS, isLockError, } from "../lockfile-policy.js";
+import { serializeByKey } from "../session-sidecar-store.js";
+import { parseMoveId } from "./bundle.js";
+export class MoveFencedError extends Error {
+    constructor(moveId, record) {
+        super(`Move ${moveId} can no longer be imported here: it was already answered (${record.state}).`);
+        this.code = "move_fenced";
+        this.name = "MoveFencedError";
+        this.record = record;
+    }
+}
+const LOCK_OPTIONS = { realpath: false, stale: 10_000, update: 2_000, retries: 0 };
+const LOCK_WAIT_MS = 15_000;
+const DECLINE_REASONS = [
+    "no_record",
+    "expired",
+    "cancelled",
+    "chunk_without_ready",
+    "repository",
+];
+const FAIL_REASONS = ["bundle_invalid", "import_failed"];
+function parseRecord(value) {
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    const { state, reason } = value;
+    if (state === "receiving" || state === "accepted")
+        return { state };
+    const decline = DECLINE_REASONS.find((known) => known === reason);
+    if (state === "declined" && decline !== undefined)
+        return { state, reason: decline };
+    const fail = FAIL_REASONS.find((known) => known === reason);
+    if (state === "failed" && fail !== undefined)
+        return { state, reason: fail };
+    return undefined;
+}
+export class MoveLedger {
+    constructor(dir) {
+        this.dir = dir;
+    }
+    /** Starts receiving a move; refused once the move was answered with anything but `receiving`. */
+    beginReceive(moveId) {
+        return this.locked(moveId, () => {
+            const record = this.read(moveId);
+            if (record?.state === "accepted" || record?.state === "receiving")
+                return;
+            if (record !== undefined)
+                throw new MoveFencedError(moveId, record);
+            this.write(moveId, { state: "receiving" });
+        });
+    }
+    /** The signed answer a sender gets; `movedIn` is whether the session file here already records the move. */
+    answerStatus(moveId, here) {
+        return this.locked(moveId, () => {
+            const record = this.read(moveId);
+            if (here.movedIn || record?.state === "accepted")
+                return { state: "accepted" };
+            if (record !== undefined)
+                return record;
+            const declined = { state: "declined", reason: "no_record" };
+            this.write(moveId, declined);
+            return declined;
+        });
+    }
+    /** Cancel, expiry or a refused chunk: only before the bundle was verified and receiving began, never after. */
+    decline(moveId, reason) {
+        return this.settle(moveId, { state: "declined", reason }, ["accepted", "receiving"]);
+    }
+    /** A verified import that could not finish; it may end a receiving move but never an accepted one. */
+    fail(moveId, reason) {
+        return this.settle(moveId, { state: "failed", reason }, ["accepted"]);
+    }
+    /** Runs the import's commit (the atomic rename) under the move's lock, then records it accepted. */
+    commit(moveId, rename) {
+        return this.locked(moveId, async () => {
+            const record = this.read(moveId);
+            if (record !== undefined && record.state !== "receiving" && record.state !== "accepted") {
+                throw new MoveFencedError(moveId, record);
+            }
+            const result = await rename();
+            this.write(moveId, { state: "accepted" });
+            return result;
+        });
+    }
+    settle(moveId, next, keeps) {
+        return this.locked(moveId, () => {
+            const record = this.read(moveId);
+            if (record !== undefined && keeps.includes(record.state))
+                return record;
+            this.write(moveId, next);
+            return next;
+        });
+    }
+    path(moveId) {
+        return join(this.dir, `${parseMoveId(moveId)}.json`);
+    }
+    read(moveId) {
+        let raw;
+        try {
+            raw = readFileSync(this.path(moveId), "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return undefined;
+            throw error;
+        }
+        const record = parseRecord(JSON.parse(raw));
+        if (record === undefined)
+            throw new Error(`Move record ${this.path(moveId)} is not a move record`);
+        return record;
+    }
+    write(moveId, record) {
+        const file = this.path(moveId);
+        const temp = `${file}.${process.pid}.tmp`;
+        writeFileSync(temp, `${JSON.stringify({ ...record, at: new Date().toISOString() })}\n`);
+        renameSync(temp, file);
+    }
+    locked(moveId, fn) {
+        const file = this.path(moveId);
+        return serializeByKey(file, async () => {
+            mkdirSync(this.dir, { recursive: true });
+            const release = await acquire(file);
+            try {
+                return await fn();
+            }
+            finally {
+                await release().catch(() => undefined);
+            }
+        });
+    }
+}
+async function acquire(file) {
+    const startedAt = Date.now();
+    for (let attempt = 0;; attempt += 1) {
+        try {
+            return await lockfile.lock(file, { ...LOCK_OPTIONS, lockfilePath: `${file}.lock` });
+        }
+        catch (error) {
+            if (!isLockError(error))
+                throw error;
+            const waited = Date.now() - startedAt;
+            if (waited >= LOCK_WAIT_MS)
+                throw new Error(`Move record ${file} stayed locked for ${waited}ms`, { cause: error });
+            const delay = Math.min(FILE_STORAGE_LOCK_RETRY_MIN_DELAY_MS * 2 ** attempt, FILE_STORAGE_LOCK_RETRY_MAX_DELAY_MS);
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+    }
+}
+//# sourceMappingURL=move-ledger.js.map

package/dist/core/session-move/ownership.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Who may write a session file when sessions move between devices (sisyphuslabs/omo-desktop-app#3137,
+ * senpi#3630). The file itself records ownership as a sequence of transitions, folded in order:
+ * - writable (no ownership entry yet, a `takeover` release, `session_moved_in`, `session_reclaimed`);
+ * - `moving` after a `move` release: only that move may continue, with `session_moved` (it arrived),
+ *   `session_reclaimed` (it was given back) or `session_moved_in` (an import of that same move);
+ * - `moved` after `session_moved`: nothing may reopen it. A new move id arriving by import replaces the file.
+ * A transition the current state does not allow is refused when written and ignored when read. Entries name the
+ * session they belong to (`session_id`); a copy or branch under a new id ignores the entries it inherited.
+ */
+/** `customType` of the release entry; shared with `release_session` (`modes/rpc/session-release.ts`). */
+export declare const SESSION_RELEASED = "session_released";
+export declare const SESSION_MOVED_IN = "session_moved_in";
+export declare const SESSION_MOVED = "session_moved";
+export declare const SESSION_RECLAIMED = "session_reclaimed";
+export type MoveId = string & {
+    readonly __brand: "MoveId";
+};
+export type RefusedOwnership = {
+    readonly writable: false;
+    readonly state: "moving";
+    readonly moveId: MoveId;
+    readonly target: string;
+} | {
+    readonly writable: false;
+    readonly state: "moved";
+    readonly moveId: MoveId;
+    readonly target: string;
+};
+export type SessionOwnership = {
+    readonly writable: true;
+} | RefusedOwnership;
+export type OwnershipStep = {
+    readonly kind: "none";
+} | {
+    readonly kind: "apply";
+    readonly next: SessionOwnership;
+} | {
+    readonly kind: "refused";
+};
+interface EntryLike {
+    readonly type: string;
+    readonly customType?: string;
+    readonly data?: unknown;
+    readonly id?: unknown;
+}
+export declare function isOwnershipEntryType(customType: string | undefined): boolean;
+/**
+ * The single transition rule. `sessionId` is the id of the session being written; an entry naming another session
+ * (inherited by a copy or branch) is not an ownership step for this one.
+ */
+export declare function ownershipStep(current: SessionOwnership, entry: EntryLike, sessionId: string | undefined): OwnershipStep;
+export declare function headerSessionId(entries: readonly EntryLike[]): string | undefined;
+export declare function sessionOwnership(entries: readonly EntryLike[]): SessionOwnership;
+export declare class SessionMovedAwayError extends Error {
+    readonly code = "session_moved_away";
+    readonly ownership: RefusedOwnership;
+    constructor(sessionFile: string, ownership: RefusedOwnership);
+}
+export {};
+//# sourceMappingURL=ownership.d.ts.map

package/dist/core/session-move/ownership.js

@@ -0,0 +1,89 @@
+/**
+ * Who may write a session file when sessions move between devices (sisyphuslabs/omo-desktop-app#3137,
+ * senpi#3630). The file itself records ownership as a sequence of transitions, folded in order:
+ * - writable (no ownership entry yet, a `takeover` release, `session_moved_in`, `session_reclaimed`);
+ * - `moving` after a `move` release: only that move may continue, with `session_moved` (it arrived),
+ *   `session_reclaimed` (it was given back) or `session_moved_in` (an import of that same move);
+ * - `moved` after `session_moved`: nothing may reopen it. A new move id arriving by import replaces the file.
+ * A transition the current state does not allow is refused when written and ignored when read. Entries name the
+ * session they belong to (`session_id`); a copy or branch under a new id ignores the entries it inherited.
+ */
+/** `customType` of the release entry; shared with `release_session` (`modes/rpc/session-release.ts`). */
+export const SESSION_RELEASED = "session_released";
+export const SESSION_MOVED_IN = "session_moved_in";
+export const SESSION_MOVED = "session_moved";
+export const SESSION_RECLAIMED = "session_reclaimed";
+const WRITABLE = { writable: true };
+const NONE = { kind: "none" };
+const REFUSED = { kind: "refused" };
+const OWNERSHIP_TYPES = new Set([
+    SESSION_RELEASED,
+    SESSION_MOVED_IN,
+    SESSION_MOVED,
+    SESSION_RECLAIMED,
+]);
+export function isOwnershipEntryType(customType) {
+    return customType !== undefined && OWNERSHIP_TYPES.has(customType);
+}
+function field(data, key) {
+    if (typeof data !== "object" || data === null)
+        return undefined;
+    const value = data[key];
+    return typeof value === "string" ? value : undefined;
+}
+function requested(entry) {
+    const moveId = (field(entry.data, "move_id") ?? "");
+    const target = field(entry.data, "target") ?? "";
+    if (entry.customType === SESSION_MOVED)
+        return { writable: false, state: "moved", moveId, target };
+    if (entry.customType === SESSION_RELEASED && field(entry.data, "reason") === "move")
+        return { writable: false, state: "moving", moveId, target };
+    return WRITABLE;
+}
+/**
+ * The single transition rule. `sessionId` is the id of the session being written; an entry naming another session
+ * (inherited by a copy or branch) is not an ownership step for this one.
+ */
+export function ownershipStep(current, entry, sessionId) {
+    if (entry.type !== "custom" || !isOwnershipEntryType(entry.customType))
+        return NONE;
+    const owner = field(entry.data, "session_id");
+    if (owner !== undefined && sessionId !== undefined && owner !== sessionId)
+        return NONE;
+    const next = requested(entry);
+    if (current.writable)
+        return { kind: "apply", next };
+    if (current.state === "moved")
+        return REFUSED;
+    const sameMove = field(entry.data, "move_id") === current.moveId;
+    const continuesMove = entry.customType === SESSION_MOVED ||
+        entry.customType === SESSION_RECLAIMED ||
+        entry.customType === SESSION_MOVED_IN;
+    return sameMove && continuesMove ? { kind: "apply", next } : REFUSED;
+}
+export function headerSessionId(entries) {
+    const header = entries.find((entry) => entry.type === "session");
+    return typeof header?.id === "string" ? header.id : undefined;
+}
+export function sessionOwnership(entries) {
+    const sessionId = headerSessionId(entries);
+    let verdict = WRITABLE;
+    for (const entry of entries) {
+        const step = ownershipStep(verdict, entry, sessionId);
+        if (step.kind === "apply")
+            verdict = step.next;
+    }
+    return verdict;
+}
+export class SessionMovedAwayError extends Error {
+    constructor(sessionFile, ownership) {
+        const where = ownership.target === "" ? "another device" : ownership.target;
+        super(ownership.state === "moving"
+            ? `This session is being moved to ${where}; it is read-only here. Wait for the move to finish, or make a copy to keep working here. (${sessionFile})`
+            : `This session was moved to ${where}; it is read-only here. Open it on ${where}, or make a copy here. (${sessionFile})`);
+        this.code = "session_moved_away";
+        this.name = "SessionMovedAwayError";
+        this.ownership = ownership;
+    }
+}
+//# sourceMappingURL=ownership.js.map

package/dist/core/session-move/requeue.d.ts

@@ -0,0 +1,8 @@
+import type { MoveId } from "./ownership.ts";
+/**
+ * Puts input a move took out of a session back into its pending-input journal, as follow-ups in their original
+ * order. Each gets the id `move:<moveId>:<index>`, so running this twice admits each input once: the second pass is
+ * answered from the journal (`replayed`). The session restores them to its queue when it is next opened.
+ */
+export declare function requeueInput(sessionFile: string, moveId: MoveId, texts: readonly string[]): Promise<void>;
+//# sourceMappingURL=requeue.d.ts.map

package/dist/core/session-move/requeue.js

@@ -0,0 +1,18 @@
+import { SessionPendingInputs } from "../pending-input-session.js";
+import { SessionManager } from "../session-manager.js";
+/**
+ * Puts input a move took out of a session back into its pending-input journal, as follow-ups in their original
+ * order. Each gets the id `move:<moveId>:<index>`, so running this twice admits each input once: the second pass is
+ * answered from the journal (`replayed`). The session restores them to its queue when it is next opened.
+ */
+export async function requeueInput(sessionFile, moveId, texts) {
+    if (texts.length === 0)
+        return;
+    const sessionManager = SessionManager.open(sessionFile);
+    let next = 0;
+    const inputs = new SessionPendingInputs({ sessionManager, nextQueuedId: () => `move-${moveId}-${next++}` });
+    for (const [index, text] of texts.entries()) {
+        await inputs.admit({ clientMessageId: `move:${moveId}:${index}`, text, mode: "followUp" }, () => undefined);
+    }
+}
+//# sourceMappingURL=requeue.js.map

package/dist/core/session-move/write-guard.d.ts

@@ -0,0 +1,22 @@
+interface EntryLike {
+    readonly type: string;
+    readonly customType?: string;
+    readonly data?: unknown;
+    readonly id?: unknown;
+}
+/**
+ * The session-manager write funnel asks this before every persisted write. It folds only the entries appended since
+ * the last call (the funnel appends in place), and starts over when the entry array is replaced by a load or branch.
+ */
+export declare class SessionWriteGuard {
+    private source;
+    private seen;
+    private sessionId;
+    private verdict;
+    assertWritable(entries: readonly EntryLike[], entry: EntryLike, sessionFile: string): void;
+    assertRewritable(entries: readonly EntryLike[], sessionFile: string): void;
+    isWritable(entries: readonly EntryLike[]): boolean;
+    private current;
+}
+export {};
+//# sourceMappingURL=write-guard.d.ts.map

package/dist/core/session-move/write-guard.js

@@ -0,0 +1,44 @@
+import { headerSessionId, ownershipStep, SessionMovedAwayError } from "./ownership.js";
+/**
+ * The session-manager write funnel asks this before every persisted write. It folds only the entries appended since
+ * the last call (the funnel appends in place), and starts over when the entry array is replaced by a load or branch.
+ */
+export class SessionWriteGuard {
+    constructor() {
+        this.seen = 0;
+        this.verdict = { writable: true };
+    }
+    assertWritable(entries, entry, sessionFile) {
+        const ownership = this.current(entries);
+        if (ownership.writable)
+            return;
+        if (ownershipStep(ownership, entry, this.sessionId).kind !== "apply")
+            throw new SessionMovedAwayError(sessionFile, ownership);
+    }
+    assertRewritable(entries, sessionFile) {
+        const ownership = this.current(entries);
+        if (!ownership.writable)
+            throw new SessionMovedAwayError(sessionFile, ownership);
+    }
+    isWritable(entries) {
+        return this.current(entries).writable;
+    }
+    current(entries) {
+        if (entries !== this.source || entries.length < this.seen) {
+            this.source = entries;
+            this.seen = 0;
+            this.sessionId = headerSessionId(entries);
+            this.verdict = { writable: true };
+        }
+        for (; this.seen < entries.length; this.seen += 1) {
+            const entry = entries[this.seen];
+            if (entry === undefined)
+                continue;
+            const step = ownershipStep(this.verdict, entry, this.sessionId);
+            if (step.kind === "apply")
+                this.verdict = step.next;
+        }
+        return this.verdict;
+    }
+}
+//# sourceMappingURL=write-guard.js.map

package/dist/core/settings-manager.d.ts

@@ -21,6 +21,13 @@ export declare const DEFAULT_SESSION_SHUTDOWN_HANDLER_WARN_MS = 2000;
  * hung handler still must not hold quit/reload/new/resume hostage.
  */
 export declare const DEFAULT_SESSION_SHUTDOWN_HANDLER_TIMEOUT_MS = 10000;
+/** Warn threshold for one handler of an agent lifecycle event the session awaits before persisting (senpi#3650). */
+export declare const DEFAULT_EXTENSION_EVENT_HANDLER_WARN_MS = 60000;
+/**
+ * Hard cap for one such handler. Above the 15 min summarization budget a blocking compaction in a `message_end`
+ * handler may legitimately use; past it the host stops waiting so the turn is persisted and queued input delivered.
+ */
+export declare const DEFAULT_EXTENSION_EVENT_HANDLER_TIMEOUT_MS = 1200000;
 export type TuiMode = RendererTuiMode;
 export type FullscreenExitOutput = "transcript" | "resume-hint";
 /**
@@ -133,6 +140,8 @@ export interface Settings {
     websocketConnectTimeoutMs?: number;
     sessionShutdownHandlerWarnMs?: number;
     sessionShutdownHandlerTimeoutMs?: number;
+    extensionEventHandlerWarnMs?: number;
+    extensionEventHandlerTimeoutMs?: number;
     tuiMode?: TuiMode;
     fullscreenExitOutput?: FullscreenExitOutput;
     fullscreenScrollbar?: ScrollViewScrollbar;
@@ -422,6 +431,10 @@ export declare class SettingsManager {
      */
     getSessionShutdownHandlerTimeoutMs(): number;
     setSessionShutdownHandlerTimeoutMs(timeoutMs: number): void;
+    /** How long one agent lifecycle event handler may run before the host reports it as stalled. 0 disables. */
+    getExtensionEventHandlerWarnMs(): number;
+    /** Hard cap on one agent lifecycle event handler; past it the session's event queue moves on. 0 disables. */
+    getExtensionEventHandlerTimeoutMs(): number;
     getProviderRetrySettings(): {
         timeoutMs?: number;
         maxRetries?: number;

package/dist/core/settings-manager.js

@@ -36,6 +36,13 @@ export const DEFAULT_SESSION_SHUTDOWN_HANDLER_WARN_MS = 2_000;
  * hung handler still must not hold quit/reload/new/resume hostage.
  */
 export const DEFAULT_SESSION_SHUTDOWN_HANDLER_TIMEOUT_MS = 10_000;
+/** Warn threshold for one handler of an agent lifecycle event the session awaits before persisting (senpi#3650). */
+export const DEFAULT_EXTENSION_EVENT_HANDLER_WARN_MS = 60_000;
+/**
+ * Hard cap for one such handler. Above the 15 min summarization budget a blocking compaction in a `message_end`
+ * handler may legitimately use; past it the host stops waiting so the turn is persisted and queued input delivered.
+ */
+export const DEFAULT_EXTENSION_EVENT_HANDLER_TIMEOUT_MS = 1_200_000;
 const THINKING_LEVEL_VALUES = new Set([
     "off",
     "minimal",
@@ -1359,6 +1366,16 @@ export class SettingsManager {
         this.markModified("sessionShutdownHandlerTimeoutMs");
         this.save();
     }
+    /** How long one agent lifecycle event handler may run before the host reports it as stalled. 0 disables. */
+    getExtensionEventHandlerWarnMs() {
+        return (parseTimeoutSetting(this.settings.extensionEventHandlerWarnMs, "extensionEventHandlerWarnMs") ??
+            DEFAULT_EXTENSION_EVENT_HANDLER_WARN_MS);
+    }
+    /** Hard cap on one agent lifecycle event handler; past it the session's event queue moves on. 0 disables. */
+    getExtensionEventHandlerTimeoutMs() {
+        return (parseTimeoutSetting(this.settings.extensionEventHandlerTimeoutMs, "extensionEventHandlerTimeoutMs") ??
+            DEFAULT_EXTENSION_EVENT_HANDLER_TIMEOUT_MS);
+    }
     getProviderRetrySettings() {
         return {
             timeoutMs: this.settings.retry?.provider?.timeoutMs,

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

@@ -53,6 +53,8 @@ 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>;
+    /** Stop waiting on extension handlers that still hold the turn; returns how many were released (senpi#3650). */
+    releaseHeldExtensionHandlers(): number;
     /** True while a provider retry is in flight; the engine is actively recovering the turn. */
     readonly isRetryInFlight: boolean;
     readonly isIdle: boolean;

package/dist/core/turn-deadline.js

@@ -153,18 +153,25 @@ export class AgentDeadlineTracker {
         }
         // 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.
+        // something no abort can end, usually an extension handler that never returns: the host stops waiting on
+        // those handlers and gives the settle one more grace. Only a turn still running after that is reported.
         let abortError;
+        const abortStartedAt = this.now();
         const aborting = this.session.abortTurnForDeadline().catch((error) => {
             abortError = error instanceof Error ? error.message : String(error);
         });
-        const settled = await within(aborting, TURN_DEADLINE_GRACE_MS);
+        let settled = await within(aborting, TURN_DEADLINE_GRACE_MS);
+        if (!settled) {
+            // The abort path may already have released the waits (its own grace); either way the release gets a grace.
+            this.session.releaseHeldExtensionHandlers();
+            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`);
+            this.session._warnDeadline("turn_deadline_unsettled", `turn still running ${this.now() - abortStartedAt} ms after the ${kind} deadline abort`);
     }
 }
 export function buildDeadlineStopNotice(deadline) {

package/dist/modes/interactive/components/ask-user-async-widget.d.ts

@@ -25,6 +25,13 @@ export declare function renderQuestionLine(question: Question): string;
 export declare function renderOptionsLine(question: Question, remaining: number): string;
 /** Hint naming every way into the pending question; the shortcut segment follows the effective binding. */
 export declare function renderAnswerHint(): string;
+/**
+ * The modifier that makes a drag select text while the app owns the mouse: Option on iTerm2 and
+ * Terminal.app, Option on macOS VS Code only with `terminal.integrated.macOptionClickForcesSelection`,
+ * Shift elsewhere (Windows Terminal, Ghostty, WezTerm, kitty, VS Code on Windows/Linux). Inside tmux
+ * the outer terminal decides and cannot be detected.
+ */
+export declare function selectionBypassHint(termProgram?: string, platform?: NodeJS.Platform): string;
 export interface AskUserAsyncWidgetOptions {
     request: QuestionRequest;
     draft: QuestionDraft;

package/dist/modes/interactive/components/ask-user-async-widget.js

@@ -87,6 +87,21 @@ export function renderAnswerHint() {
         theme.fg("muted", "or just type your reply"),
     ].join(theme.fg("muted", " · "));
 }
+/**
+ * The modifier that makes a drag select text while the app owns the mouse: Option on iTerm2 and
+ * Terminal.app, Option on macOS VS Code only with `terminal.integrated.macOptionClickForcesSelection`,
+ * Shift elsewhere (Windows Terminal, Ghostty, WezTerm, kitty, VS Code on Windows/Linux). Inside tmux
+ * the outer terminal decides and cannot be detected.
+ */
+export function selectionBypassHint(termProgram = process.env.TERM_PROGRAM ?? "", platform = process.platform) {
+    if (termProgram === "iTerm.app" || termProgram === "Apple_Terminal")
+        return "option+drag";
+    if (termProgram === "vscode" && platform === "darwin")
+        return "option+drag (with terminal.integrated.macOptionClickForcesSelection)";
+    if (termProgram === "tmux")
+        return "shift+drag (option+drag on iTerm2/Terminal.app)";
+    return "shift+drag";
+}
 export class AskUserAsyncWidget {
     constructor(options) {
         this.countdownLabel = "";
@@ -157,12 +172,11 @@ export class AskUserAsyncWidget {
         }
         if (this.pendingCount > 1)
             addAction(theme.fg("muted", `▸ +${this.pendingCount - 1} more · ${keyText("app.question.next")} next question`), "next");
-        if (this.options.mouseCaptureActive) {
-            const bypass = ["iTerm.app", "Apple_Terminal"].includes(process.env.TERM_PROGRAM ?? "")
-                ? "option+drag"
-                : "shift+drag";
-            lines.push(...new Text(theme.fg("muted", `click an option · ${bypass} to select text`), 0, 0).render(width));
-        }
+        const capture = this.options.mouseCaptureActive ? (this.options.tui?.mouseCaptureState() ?? "armed") : "off";
+        if (capture === "armed")
+            lines.push(...new Text(theme.fg("muted", `click an option · ${selectionBypassHint()} to select text`), 0, 0).render(width));
+        else if (capture === "yielded")
+            lines.push(...new Text(theme.fg("muted", "wheel scrolls · press any key to click options again"), 0, 0).render(width));
         lines.push(...new Text(renderAnswerHint(), 0, 0).render(width));
         return lines;
     }

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

@@ -836,6 +836,7 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
             case "clear_queue": {
                 ClientAdmissions.clearQueuedFor(session);
                 const cleared = session.clearQueue({ abortWillFollow: command.abortWillFollow ?? false });
+                await session.whenQueueClearRecorded();
                 return success(id, "clear_queue", {
                     steering: cleared.steering,
                     followUp: cleared.followUp,
@@ -888,6 +889,8 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                 return success(id, "get_state", buildRpcSessionState(session, lastAbortSource));
             case "get_effect_status":
                 return runGetEffectStatus(effectContext(), command);
+            case "get_pending_inputs":
+                return success(id, "get_pending_inputs", await session.getPendingInputs(command.knownClientMessageIds));
             // =================================================================
             // Model
             // =================================================================

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

@@ -150,10 +150,9 @@ export async function runQueuedInputChange(ctx, command) {
         });
     const clientMessageId = ctx.session.getQueuedInputs().find((input) => input.queuedId === queuedId)?.clientMessageId;
     const expected = command.expectedRevision === undefined ? undefined : { expectedRevision: command.expectedRevision };
-    const status = command.type === "dequeue_message"
-        ? ctx.session.dequeueQueuedInput(queuedId, expected)
-        : ctx.session.editQueuedInput(queuedId, command.text, expected);
-    // Read in the same synchronous step as the change: the revision the answer reports is the one it made or met.
+    const status = await ctx.session.changeQueuedInput(queuedId, command.type === "dequeue_message" ? undefined : command.text, { ...expected, ...(effectId === undefined ? {} : { effectId }) });
+    // Read right after the change, before anything else on this command: the revision the answer reports is the one
+    // it made or met.
     const current = ctx.session.getQueuedInputs().find((input) => input.queuedId === queuedId);
     // A durable input is restored from its admission record on reopen: that record must carry the edit too.
     if (status === "edited" && clientMessageId !== undefined && command.type === "edit_queued_message")

package/dist/modes/rpc/host-observe-request.js

@@ -31,6 +31,7 @@ const OBSERVING_COMMANDS = new Set([
     "subscribe_sessions",
     "unsubscribe_sessions",
     "get_effect_status",
+    "get_pending_inputs",
     "get_subscription_limits",
 ]);
 export function isObservingRequest(line) {

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

@@ -86,6 +86,11 @@ export type RpcEffectStatusAnswer = Extract<RpcResponse, {
     command: "get_effect_status";
     success: true;
 }>["data"];
+/** `get_pending_inputs`: pending inputs in durable custody, and an outcome for each known id. */
+export type RpcPendingInputsAnswer = Extract<RpcResponse, {
+    command: "get_pending_inputs";
+    success: true;
+}>["data"];
 export declare class RpcClientOpenInFlightError extends Error {
     readonly code: "open_session_in_flight";
     constructor();
@@ -251,6 +256,11 @@ export declare class RpcClient {
     getEffectStatus(effectId: string, options?: {
         readonly sessionPath?: string;
     }): Promise<RpcEffectStatusAnswer>;
+    /**
+     * The pending inputs in durable custody (queued, sending, failed) and an explicit outcome for each id in
+     * `knownClientMessageIds` (at most 64), consistent through `throughCursor`.
+     */
+    getPendingInputs(knownClientMessageIds?: readonly string[]): Promise<RpcPendingInputsAnswer>;
     /** Abort with host refusals and transport loss surfaced to machine callers. */
     abortStrict(): Promise<void>;
     abortCompaction(): Promise<void>;

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

@@ -480,6 +480,17 @@ export class RpcClient {
         };
         return this.getData(await this.send(command, options.sessionPath === undefined));
     }
+    /**
+     * The pending inputs in durable custody (queued, sending, failed) and an explicit outcome for each id in
+     * `knownClientMessageIds` (at most 64), consistent through `throughCursor`.
+     */
+    async getPendingInputs(knownClientMessageIds) {
+        const command = {
+            type: "get_pending_inputs",
+            ...(knownClientMessageIds === undefined ? {} : { knownClientMessageIds: [...knownClientMessageIds] }),
+        };
+        return this.getData(await this.send(command));
+    }
     /** Abort with host refusals and transport loss surfaced to machine callers. */
     async abortStrict() {
         this.getData(await this.send({ type: "abort" }));