@zhuxixi/pi-agent-board 0.4.1 → 0.4.3

package/src/core/locks.mjs

@@ -1,6 +1,14 @@
 /**
  * Tiny dependency-free synchronous file lock helpers for local agent-board artifacts.
  * Locks use atomic mkdir on a sibling .lock directory and are cleaned up in finally.
+ *
+ * Failure model (issue #33): acquisition failures are classified.
+ * - EEXIST (contention): wait in 20ms ticks until the stale window passes, then
+ *   force-steal (bounded to MAX_STEAL_ATTEMPTS). This preserves the original
+ *   wait/steal contract (see test/locks.test.mjs).
+ * - Anything else (deleted parent, read-only fs, permissions, disk full, ...):
+ *   MAX_ENV_ATTEMPTS quick retries — each retry re-runs ensureDir so a parent
+ *   deleted mid-acquisition self-heals — then throw LOCK_TIMEOUT. Never spin.
  */
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import * as path from "node:path";
@@ -8,22 +16,33 @@ import { ensureDir } from "./atomic.mjs";
 import * as P from "./paths.mjs";
 
 const DEFAULT_STALE_MS = 30_000;
+/** Minimum contention window before a fresh lock can be force-stolen. */
+const MIN_WINDOW_MS = 250;
+const WAIT_TICK_MS = 20;
+/** Max stale-lock steal attempts before giving up. */
+const MAX_STEAL_ATTEMPTS = 2;
+/** Max quick retries for environmental failures before giving up. */
+const MAX_ENV_ATTEMPTS = 3;
+
+export const defaultLocksFs = Object.freeze({ existsSync, mkdirSync, readFileSync, rmSync, writeFileSync });
 
 /**
  * @template T
  * @param {string} lockPath
  * @param {() => T} fn
- * @param {{ staleMs?: number }} [opts]
+ * @param {{ staleMs?: number, fs?: typeof defaultLocksFs }} [opts]
  * @returns {T}
  */
 export function withFileLockSync(lockPath, fn, opts = {}) {
-	const staleMs = opts.staleMs ?? DEFAULT_STALE_MS;
-	acquireLock(lockPath, staleMs);
+	const fs = opts.fs ?? defaultLocksFs;
+	acquireLock(lockPath, opts.staleMs ?? DEFAULT_STALE_MS, fs);
+	let result;
 	try {
-		return fn();
+		result = fn();
 	} finally {
-		releaseLock(lockPath);
+		releaseLock(lockPath, fs);
 	}
+	return result;
 }
 
 /**
@@ -32,37 +51,74 @@ export function withFileLockSync(lockPath, fn, opts = {}) {
  * @param {string} viewId
  * @param {string} name
  * @param {() => T} fn
- * @param {{ staleMs?: number }} [opts]
+ * @param {{ staleMs?: number, fs?: typeof defaultLocksFs }} [opts]
  * @returns {T}
  */
 export function withViewLockSync(root, viewId, name, fn, opts = {}) {
 	return withFileLockSync(P.viewLockPath(root, viewId, name), fn, opts);
 }
 
-/** @param {string} lockPath @param {number} staleMs */
-function acquireLock(lockPath, staleMs) {
-	ensureDir(path.dirname(lockPath));
-	const started = Date.now();
-	while (true) {
+/** @param {string} lockPath @param {number} staleMs @param {typeof defaultLocksFs} fs */
+function acquireLock(lockPath, staleMs, fs) {
+	const deadline = Date.now() + Math.max(MIN_WINDOW_MS, staleMs);
+	let steals = 0;
+	let envAttempts = 0;
+	for (;;) {
+		let created = false;
 		try {
-			mkdirSync(lockPath);
-			writeFileSync(path.join(lockPath, "owner.json"), JSON.stringify({ pid: process.pid, at: Date.now() }), "utf8");
+			// Re-run every attempt: a parent deleted mid-acquisition self-heals here.
+			ensureDir(path.dirname(lockPath));
+			fs.mkdirSync(lockPath);
+			created = true;
+			fs.writeFileSync(
+				path.join(lockPath, "owner.json"),
+				JSON.stringify({ pid: process.pid, at: Date.now() }),
+				"utf8",
+			);
 			return;
 		} catch (err) {
-			if (!isLockStale(lockPath, staleMs) && Date.now() - started < Math.max(250, staleMs)) {
-				Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20);
+			if (err && err.code === "EEXIST") {
+				const expired = Date.now() >= deadline;
+				if (isLockStale(lockPath, staleMs, fs) || expired) {
+					if (steals >= MAX_STEAL_ATTEMPTS) {
+						throw lockError(lockPath, `stale lock could not be stolen after ${steals} attempts`);
+					}
+					steals += 1;
+					releaseLock(lockPath, fs);
+					continue;
+				}
+				sleep(WAIT_TICK_MS);
 				continue;
 			}
-			releaseLock(lockPath);
+			// Environmental failure: bounded quick retries, then fail fast.
+			if (created) releaseLock(lockPath, fs);
+			envAttempts += 1;
+			if (envAttempts >= MAX_ENV_ATTEMPTS) {
+				const reason = (err && (err.code || err.message)) || "unknown error";
+				throw lockError(lockPath, `lock path unusable (${reason})`);
+			}
+			sleep(WAIT_TICK_MS);
 		}
 	}
 }
 
-/** @param {string} lockPath @param {number} staleMs */
-function isLockStale(lockPath, staleMs) {
+/** @param {string} lockPath @param {string} reason */
+function lockError(lockPath, reason) {
+	const err = new Error(`file lock unavailable: ${lockPath} (${reason})`);
+	err.code = "LOCK_TIMEOUT";
+	return err;
+}
+
+/** @param {number} ms */
+function sleep(ms) {
+	Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+/** @param {string} lockPath @param {number} staleMs @param {typeof defaultLocksFs} fs */
+function isLockStale(lockPath, staleMs, fs) {
 	try {
-		if (!existsSync(lockPath)) return false;
-		const raw = readFileSync(path.join(lockPath, "owner.json"), "utf8");
+		if (!fs.existsSync(lockPath)) return false;
+		const raw = fs.readFileSync(path.join(lockPath, "owner.json"), "utf8");
 		const owner = JSON.parse(raw);
 		return Date.now() - Number(owner.at ?? 0) > staleMs;
 	} catch {
@@ -70,10 +126,10 @@ function isLockStale(lockPath, staleMs) {
 	}
 }
 
-/** @param {string} lockPath */
-function releaseLock(lockPath) {
+/** @param {string} lockPath @param {typeof defaultLocksFs} fs */
+function releaseLock(lockPath, fs) {
 	try {
-		rmSync(lockPath, { recursive: true, force: true });
+		fs.rmSync(lockPath, { recursive: true, force: true });
 	} catch {
 		/* best effort */
 	}

package/src/core/pty-attach-jiggle-controller.mjs

@@ -1,17 +1,35 @@
 /**
- * Injectable orchestration for the attach jiggle-retry chain.
+ * Injectable orchestration for the attach shrink-and-hold jiggle protocol.
  *
- * Owns the retry state machine, backoff timers, cross-chunk scanning, and the
- * one-shot re-arm on the child TUI's first frame (\x1b[?2026h). The attach
- * component (and the cold-start E2E) drive it through injected callbacks, so
- * the whole choreography is testable without a TUI or socket.
+ * Replaces the pulse-pair jiggle (shrink → 200ms → restore) with a
+ * shrink-and-hold protocol: on connect we resize the child PTY down one
+ * column/row and KEEP it there until the child's own rendering proves it
+ * observed the width change (a full clear, \x1b[2J, which pi-tui emits from
+ * fullRender(true) whenever widthChanged fires). Because there is no
+ * "restore" that can cancel the shrink before a clear is seen, event-loop
+ * coalescing on either side (outer dashboard timers or the child's
+ * SIGWINCH/render throttle) can no longer collapse a jiggle into a
+ * net-zero size change.
  *
- * Cold-start design (issue #10): the chain starts at socket connect, but a cold
- * child pi-tui installs its SIGWINCH listener only ~5s in — every early jiggle
- * is lost. When the first TUI frame arrives we re-arm once with a fresh budget,
- * so the next jiggle lands on a live TUI and its fullRender emits \x1b[2J,
- * which stops the chain. If pi-tui ever drops the 2026h sequence, this degrades
- * to the plain connect-time chain (still better than the old one-shot).
+ * Cold-start (issue #25): if the child TUI starts rendering AFTER we shrink,
+ * its first frame baselines at the shrunk size and never clears. The
+ * re-arm — the first \x1b[?2026h frame — therefore restores the original
+ * size: the now-rendering child sees a width different from its baseline
+ * and fullRenders. Guards:
+ *   G1 NO_FRAME_RESTORE_MS — no TUI frame within 6s → restore (no renderer
+ *      to trigger; continuing to hold has no purpose). If the TUI boots even
+ *      later, its first frame re-arms a fresh hold (F1 slow-boot probe), so
+ *      healing still fires the moment the child actually starts rendering.
+ *   G2 backoff budget exhausted without a clear → restore (non-pi children,
+ *      dead sessions).
+ *   G3 restoreAndStop() — component close/detach restores while the socket
+ *      is still usable.
+ *   G4 notifyExternalResize() — a real user resize cancels the hold and
+ *      adopts the new size.
+ *   G5 start() restores any previous hold before arming a new one (reconnect).
+ *
+ * If pi-tui ever drops the 2026h sequence, re-arm degrades to G1: the PTY
+ * is restored within 6s — still better than the pre-#10 behavior.
  */
 import {
 	advanceRetry,
@@ -21,92 +39,187 @@ import {
 	stopRetry,
 } from "./pty-attach-jiggle-retry.mjs";
 
+/** Restore the held (shrunk) child PTY when no TUI frame arrives this long. */
+const NO_FRAME_RESTORE_MS = 6000;
+
 /**
  * @typedef {Object} JiggleRetryControllerDeps
- * @property {() => void} sendJiggle - Fire one resize jiggle at the child.
+ * @property {(cols: number, rows: number) => void} sendResize - Resize the child PTY.
  * @property {(fn: () => void, ms: number) => unknown} setTimeoutFn - Timer factory.
  * @property {(timer: unknown) => void} clearTimeoutFn - Timer canceller.
- * @property {() => boolean} [shouldFire] - Guard on retry fire; false stops the chain without firing.
  */
 
 /**
  * @param {JiggleRetryControllerDeps} deps
  */
 export function createJiggleRetryController(deps) {
-	const { sendJiggle, setTimeoutFn, clearTimeoutFn, shouldFire } = deps;
+	const { sendResize, setTimeoutFn, clearTimeoutFn } = deps;
 	let state = createJiggleRetryState();
 	let carry = "";
 	let tuiFrameSeen = false;
+	/** True while the child PTY is parked at the shrunk size. */
+	let held = false;
+	/** True once the original size has been sent back (restore is one-shot). */
+	let restored = false;
+	/** @type {[number, number]} */
+	let originalCols = 0;
+	let originalRows = 0;
 	/** @type {unknown | null} */
-	let timer = null;
+	let chainTimer = null;
+	/** @type {unknown | null} */
+	let g1Timer = null;
+
+	function clearChainTimer() {
+		if (chainTimer === null) return;
+		clearTimeoutFn(chainTimer);
+		chainTimer = null;
+	}
+
+	function clearG1Timer() {
+		if (g1Timer === null) return;
+		clearTimeoutFn(g1Timer);
+		g1Timer = null;
+	}
 
-	function clearTimer() {
-		if (timer === null) return;
-		clearTimeoutFn(timer);
-		timer = null;
+	function clearAllTimers() {
+		clearChainTimer();
+		clearG1Timer();
 	}
 
-	function scheduleNext() {
+	/**
+	 * Restore the child PTY to the original size exactly once. No-op while
+	 * not held or after the restore already happened.
+	 */
+	function restoreIfHeld() {
+		if (!held || restored) return;
+		sendResize(originalCols, originalRows);
+		restored = true;
+		held = false;
+	}
+
+	/**
+	 * Backoff chain is a pure countdown under the hold protocol: firing a
+	 * retry schedules the next backoff (no pulse is sent — the shrink is
+	 * already held). When the budget runs out, G2 restores the size.
+	 */
+	function scheduleNextRetry() {
 		const delay = nextRetryDelay(state);
 		if (delay === null) {
 			state = stopRetry(state);
+			restoreIfHeld(); // G2
 			return;
 		}
-		timer = setTimeoutFn(() => {
-			timer = null;
-			if (shouldFire && !shouldFire()) {
-				state = stopRetry(state);
-				return;
-			}
-			sendJiggle();
+		chainTimer = setTimeoutFn(() => {
+			chainTimer = null;
 			state = advanceRetry(state);
-			scheduleNext();
+			scheduleNextRetry();
 		}, delay);
 	}
 
-	/** Reset everything (fresh connection) and schedule the first retry. */
-	function start() {
-		clearTimer();
+	function armG1() {
+		clearG1Timer();
+		g1Timer = setTimeoutFn(() => {
+			g1Timer = null;
+			if (!tuiFrameSeen) restoreIfHeld(); // G1
+		}, NO_FRAME_RESTORE_MS);
+	}
+
+	/**
+	 * Arm a fresh hold for a (re)connected attach at the given PTY size.
+	 * Restores any previous hold first (G5), then shrinks and holds.
+	 * @param {number} cols
+	 * @param {number} rows
+	 */
+	function start(cols, rows) {
+		clearAllTimers();
+		if (held) {
+			sendResize(originalCols, originalRows); // G5: unwind previous hold
+			restored = true;
+			held = false;
+		}
 		state = createJiggleRetryState();
 		carry = "";
 		tuiFrameSeen = false;
-		scheduleNext();
+		originalCols = cols;
+		originalRows = rows;
+		sendResize(cols, rows);
+		sendResize(cols - 1, rows - 1);
+		held = true;
+		restored = false;
+		armG1();
+		scheduleNextRetry();
 	}
 
 	/**
-	 * Feed one socket output chunk. Clear detection wins over re-arm when both
-	 * sequences appear in one chunk (a hot attach's first frame is often the
-	 * fullRender we were waiting for). Re-arm fires at most once per start().
+	 * Feed one socket output chunk. A clear wins over the re-arm when both
+	 * appear in one chunk. The first TUI frame restores the held size (the
+	 * child is now rendering and will fullRender on the width delta) and
+	 * does NOT reschedule the chain; if G1 already released the hold before
+	 * the TUI booted, the frame instead re-arms a fresh hold so the running
+	 * child still sees a width delta (F1 slow-boot probe).
 	 * @param {string} data
 	 */
 	function feed(data) {
 		if (state.clearDetected) return; // chain done; nothing left to detect
+		if (state.stopped) return; // chain ended (G2/G3/G4); output is inert
 		const result = feedOutput(state, data, carry);
 		state = result.state;
 		carry = result.carry;
 		if (result.clearFound) {
-			clearTimer();
+			clearAllTimers();
+			restoreIfHeld();
 			state = stopRetry({ ...state, clearDetected: true });
 			return;
 		}
-		if (result.frameStartFound && !tuiFrameSeen && !state.clearDetected) {
+		if (result.frameStartFound && !tuiFrameSeen) {
 			tuiFrameSeen = true;
-			clearTimer();
-			state = createJiggleRetryState();
-			scheduleNext();
+			clearG1Timer();
+			if (held) {
+				restoreIfHeld(); // fast path: child is rendering, width delta now lands
+			} else {
+				// Slow boot: G1 released the hold before the TUI came up, so the
+				// child baselined at the original size. Re-arm a fresh hold — its
+				// next frame then sees a width delta and fullRenders. Guards: the
+				// clear path (primary) and G2 budget exhaustion (chain still
+				// ticking). G1 is NOT re-armed: frames are now flowing.
+				sendResize(originalCols - 1, originalRows - 1);
+				held = true;
+				restored = false;
+			}
 		}
 	}
 
-	/** Stop the chain (component closed, etc.). */
-	function stop() {
-		clearTimer();
+	/**
+	 * Restore the held size (if any) and stop all chain activity. Used by the
+	 * component on close/detach while the socket is still usable (G3).
+	 */
+	function restoreAndStop() {
+		clearAllTimers();
+		restoreIfHeld();
+		state = stopRetry(state);
+	}
+
+	/**
+	 * A real user resize supersedes the hold protocol: cancel all timers,
+	 * mark the hold void, adopt the new size as the new original, and stop
+	 * the chain (G4).
+	 * @param {number} cols
+	 * @param {number} rows
+	 */
+	function notifyExternalResize(cols, rows) {
+		clearAllTimers();
+		held = false;
+		restored = false;
+		originalCols = cols;
+		originalRows = rows;
 		state = stopRetry(state);
 	}
 
 	return {
 		start,
 		feed,
-		stop,
-		getState: () => ({ ...state, tuiFrameSeen }),
+		restoreAndStop,
+		notifyExternalResize,
+		getState: () => ({ ...state, held, tuiFrameSeen, originalCols, originalRows }),
 	};
 }

package/src/ui/pty-attach.ts

@@ -8,6 +8,7 @@ import { CURSOR_MARKER, Key, matchesKey, truncateToWidth, visibleWidth } from "@
 import { isProbablyEmptyPiInputLine } from "../core/pty-input.mjs";
 import { findHttpUrlAtCells, findWordRangeAtCells } from "../core/pty-links.mjs";
 import { createAttachOutputRenderScheduler, nextAttachRender, projectPtyCursor, shouldScheduleAttachRenderForMessage } from "../core/pty-attach-render.mjs";
+import { installImeCursorCoalesce } from "../core/ime-cursor-coalesce.mjs";
 import { createJiggleRetryController } from "../core/pty-attach-jiggle-controller.mjs";
 import { clampInt, parseMouseInputChunk, resolveWheelLines, scrollViewportTop, selectionDragScrollLines } from "../core/pty-scroll.mjs";
 
@@ -47,11 +48,6 @@ const OSC52_MAX_BYTES = 1_000_000;
 const OSC52_CARRY_MAX_BYTES = OSC52_MAX_BYTES + 4096;
 const TERMINAL_PASSTHROUGH_MAX_BYTES = 5_000_000;
 const TERMINAL_PASSTHROUGH_CARRY_MAX_BYTES = TERMINAL_PASSTHROUGH_MAX_BYTES + 4096;
-/** Delay between the shrink and restore halves of a resize jiggle. 200ms keeps
- * the two SIGWINCHs apart well beyond pi-tui's 16ms render throttle, so a busy
- * (booting) child processes them as two separate renders instead of coalescing
- * the pair into a net-zero size change. */
-const JIGGLE_RESTORE_MS = 200;
 const KITTY_IMAGE_PREFIX = "\x1b_G";
 const ITERM2_FILE_PREFIX = "\x1b]1337;File=";
 
@@ -117,16 +113,16 @@ export class PtyAttachComponent implements Component {
 	private parserBuffer = "";
 	private retryTimer: ReturnType<typeof setTimeout> | null = null;
 	private loadingTimer: ReturnType<typeof setInterval> | null = null;
-	private redrawTimer: ReturnType<typeof setTimeout> | null = null;
 	private mouseRefreshTimers: Array<ReturnType<typeof setTimeout>> = [];
-	// Jiggle retry chain: re-send resize jiggle until we see a full-clear sequence
-	// in the PTY output, proving the child pi-tui did a fullRender and the replay
-	// garbage has been flushed. The controller re-arms once on the child TUI's
-	// first frame so cold-start attaches get a fresh budget exactly when the
-	// child can finally observe a resize (issue #10).
+	// Shrink-and-hold jiggle protocol (issue #25): on attach we resize the child to
+	// (cols-1, rows-1) and hold it there until the child emits a full clear
+	// (\x1b[2J) — any render the child makes while held sees a width delta and
+	// must fullRender, so boot-storm coalescing of ±1 pulses can no longer
+	// produce a net-zero change. The controller restores the original size on
+	// clear / first TUI frame (re-arm) / no-frame 6s guard / budget exhaustion /
+	// close / external resize (guards G1-G5, see controller module).
 	private readonly jiggleRetry = createJiggleRetryController({
-		sendJiggle: () => this.forceChildRedraw(),
-		shouldFire: () => !this.closed && this.connected,
+		sendResize: (cols, rows) => this.sendResize(cols, rows),
 		setTimeoutFn: (fn, ms) => {
 			const t = setTimeout(fn, ms);
 			t.unref?.();
@@ -170,6 +166,10 @@ export class PtyAttachComponent implements Component {
 	// into many small chunks; painting after each chunk would drive the outer TUI to its
 	// frame cap and expose intermediate frames (visible as flicker on a busy session).
 	private readonly outputRenderScheduler = createAttachOutputRenderScheduler(() => this.scheduleRender());
+	// Fold pi-tui's post-frame cursor-park writes back into the frame's sync block so the
+	// terminal reports one stable IME cursor rect per frame instead of two (issue #28).
+	// Never active when AGENT_BOARD_IME_FIX=0; no-op passthrough if pi-tui changes shape.
+	private readonly imeCoalesceUninstall: (() => void) | null;
 
 	constructor(
 		private readonly tui: TUI,
@@ -181,6 +181,9 @@ export class PtyAttachComponent implements Component {
 		const size = this.currentSize();
 		this.cols = size.cols;
 		this.rows = size.rows;
+		// Assigned in the body (not as a field initializer) so it runs after the `tui`
+		// parameter property is set regardless of the TS loader's field-init semantics.
+		this.imeCoalesceUninstall = installImeCursorCoalesce(this.tui);
 		this.term = new Terminal({ cols: this.cols, rows: this.rows, scrollback: 2000, allowProposedApi: true });
 		// Keep mouse reporting enabled by default so wheel scrolling and local drag-to-copy
 		// selection can coexist inside the attach surface. Set AGENT_BOARD_ATTACH_MOUSE=0
@@ -324,9 +327,7 @@ export class PtyAttachComponent implements Component {
 			this.connected = true;
 			this.status = "attached";
 			this.send({ type: "hello", clientId: `ui-${Date.now()}`, wantOutput: true });
-			this.sendResize();
-			this.forceChildRedraw();
-			this.jiggleRetry.start();
+			this.jiggleRetry.start(this.cols, this.rows);
 			this.enableMouseScroll();
 			this.scheduleRender();
 			this.startAttachSettle();
@@ -390,7 +391,7 @@ export class PtyAttachComponent implements Component {
 	/**
 	 * Attach transition lifecycle. Keep the loading banner up while the screen-log replay
 	 * and the initial resize-jiggle redraws settle, so the buffer doesn't visibly scroll or
-	 * flash through the viewport on attach. Each `forceChildRedraw` defers the settle
+	 * flash through the viewport on attach. Each output chunk defers the settle
 	 * window; a hard timeout guards against a session that never produces output.
 	 */
 	private startAttachSettle(): void {
@@ -435,13 +436,6 @@ export class PtyAttachComponent implements Component {
 		this.scheduleRender(true);
 	}
 
-	private clearRedrawTimer(): void {
-		if (this.redrawTimer) {
-			clearTimeout(this.redrawTimer);
-			this.redrawTimer = null;
-		}
-	}
-
 	private clearMouseRefreshTimers(): void {
 		for (const timer of this.mouseRefreshTimers) clearTimeout(timer);
 		this.mouseRefreshTimers = [];
@@ -784,6 +778,9 @@ export class PtyAttachComponent implements Component {
 		if (size.cols === this.cols && size.rows === this.rows) return;
 		this.cols = size.cols;
 		this.rows = size.rows;
+		// A real terminal resize supersedes the hold protocol: cancel any armed
+		// hold and adopt the new size as the baseline (guard G4, issue #25).
+		this.jiggleRetry.notifyExternalResize(size.cols, size.rows);
 		this.term.resize(this.cols, this.rows);
 		this.sendResize();
 		this.enableMouseScroll();
@@ -794,28 +791,6 @@ export class PtyAttachComponent implements Component {
 		this.clampViewportTop(this.bodyHeight());
 	}
 
-	private forceChildRedraw(): void {
-		this.clearRedrawTimer();
-		if (!this.connected) return;
-		const cols = this.cols;
-		const rows = this.rows;
-		const jiggle = localResizeJiggleSize(cols, rows);
-		if (!jiggle) return;
-		// A completed-session reattach often starts from an old screen.log recorded at
-		// a different terminal size. Real terminal zoom fixes that by causing SIGWINCH;
-		// do the same proactively so the child Pi redraws for the attach viewport.
-		this.sendResize(jiggle.cols, jiggle.rows);
-		this.deferAttachSettle();
-		this.redrawTimer = setTimeout(() => {
-			this.redrawTimer = null;
-			if (!this.closed && this.connected) {
-				this.sendResize(cols, rows);
-				this.deferAttachSettle();
-			}
-		}, JIGGLE_RESTORE_MS);
-		this.redrawTimer.unref?.();
-	}
-
 	/** Feed socket output into the jiggle retry controller (clear/frame detection). */
 	private checkClearSequence(data: string): void {
 		this.jiggleRetry.feed(data);
@@ -984,13 +959,13 @@ export class PtyAttachComponent implements Component {
 
 	private close(): void {
 		this.closed = true;
-		this.jiggleRetry.stop();
+		this.imeCoalesceUninstall?.();
+		this.jiggleRetry.restoreAndStop();
 		this.disableMouseScroll();
 		this.clearMouseRefreshTimers();
 		this.clearPendingClick();
 		this.clearSelectionAutoScroll();
 		this.clearRetry();
-		this.clearRedrawTimer();
 		this.stopLoadingTicker();
 		this.outputRenderScheduler.dispose();
 		if (this.attachSettleTimer) {
@@ -1009,13 +984,6 @@ export class PtyAttachComponent implements Component {
 	}
 }
 
-function localResizeJiggleSize(cols: number, rows: number): { cols: number; rows: number } | null {
-	if (cols > 21 && rows > 6) return { cols: cols - 1, rows: rows - 1 };
-	if (rows > 6) return { cols, rows: rows - 1 };
-	if (cols > 21) return { cols: cols - 1, rows };
-	return null;
-}
-
 function sameMousePoint(a: MousePoint, b: MousePoint): boolean {
 	return a.line === b.line && Math.abs(a.col - b.col) <= 1;
 }