@hank-warren/pi-statusline 0.1.1 → 0.1.2

package/README.md

@@ -30,7 +30,9 @@ PR lookups use the `gh` CLI when available and degrade gracefully without it.
 
 Pi's fullscreen renderer only re-emits terminal rows whose rendered content changed. The worktree and session-ID lines are static for the life of a session, so if their cells ever desync from Pi's row cache — stale transcript text, a process sharing the tty, a stray escape sequence — nothing repaints them and the artifact persists.
 
-To repair that, the extension asks Pi for a forced full redraw at turn boundaries and on a 30-second idle sweep, throttled to at most one every five seconds. Both are skipped entirely in regular TUI mode, which reprints its whole block each frame and therefore self-heals. A forced redraw drops a scrollback text selection highlight for a single frame.
+To repair that promptly without repeatedly clearing the screen, a one-second sweep changes an invisible marker on the fullscreen footer and requests a targeted differential render. Only the statusline rows compare as changed, so they repaint at most once per second even while the rest of Pi is actively rendering. A 30-second forced full redraw remains as a fallback for corruption outside the footer, throttled to at most one every five seconds and also requested at turn boundaries.
+
+Both repair layers are skipped entirely in regular TUI mode, which reprints its whole block each frame and therefore self-heals. Only the slower forced fallback can drop a scrollback text selection highlight for a single frame.
 
 ## Install
 

package/index.ts

@@ -178,17 +178,19 @@ export default function statuslineExtension(pi: ExtensionAPI): void {
 					const cwd = basename(ctx.cwd) || ctx.cwd;
 					const model = ctx.model?.id.split("/").pop() || "no-model";
 
-					return renderStatusline(
-						{
-							model,
-							cwd,
-							cwdGit,
-							contextTokens: usage?.tokens ?? null,
-							contextWindow: usage?.contextWindow ?? ctx.model?.contextWindow ?? 0,
-							worktrees: tracker?.getWorktrees() ?? [],
-							sessionId: ctx.sessionManager.getSessionId(),
-						},
-						width,
+					return fullRedraw.decorate(
+						renderStatusline(
+							{
+								model,
+								cwd,
+								cwdGit,
+								contextTokens: usage?.tokens ?? null,
+								contextWindow: usage?.contextWindow ?? ctx.model?.contextWindow ?? 0,
+								worktrees: tracker?.getWorktrees() ?? [],
+								sessionId: ctx.sessionManager.getSessionId(),
+							},
+							width,
+						),
 					);
 				},
 			};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hank-warren/pi-statusline",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Compact Pi footer statusline: model ID, git branch/dirty/behind state, linked worktrees with PR numbers, context usage, and session ID.",
   "type": "module",
   "keywords": [

package/redraw.ts

@@ -3,24 +3,30 @@
  *
  * Pi's fullscreen (alt-screen) renderer writes rows differentially: a row whose
  * rendered content is byte-identical to the previous frame is never re-emitted.
- * That is normally invisible, but this statusline is the only thing on screen
- * with permanently static rows — the worktree line barely changes and the
- * session id never changes at all. Once those terminal cells desync from Pi's
- * row cache (stale transcript text, a process sharing the tty, a stray escape
- * sequence), nothing repaints them and the garbage persists for the whole
- * session.
+ * Once terminal cells desync from Pi's row cache, static statusline rows can
+ * therefore retain stale text indefinitely.
  *
- * `requestRender(true)` resets the renderer's row cache and repaints every row,
- * which repairs the damage. It is heavier than a normal frame, so this
- * scheduler keeps forced redraws rare: fullscreen only, throttled to a minimum
- * gap, driven by turn boundaries plus a slow idle sweep.
+ * This scheduler repairs the footer in two layers:
+ *
+ * 1. A short timer alternates between two visually equivalent ANSI reset
+ *    prefixes and requests a normal render. Only the statusline rows compare as
+ *    changed, even when Pi is otherwise idle.
+ * 2. `request()` keeps the slower forced full redraw fallback for corruption
+ *    outside the footer.
+ *
+ * Both layers are fullscreen-only. Regular mode already reprints its block and
+ * does not need a periodic render.
  */
 
 /** Minimum spacing between forced full redraws. */
 export const DEFAULT_MIN_GAP_MS = 5_000;
-/** Idle cadence so artifacts also heal without any agent activity. */
+/** Idle cadence for targeted statusline-row repainting. */
+export const DEFAULT_ROW_REFRESH_INTERVAL_MS = 1_000;
+/** Slow fallback cadence for corruption outside the footer. */
 export const DEFAULT_IDLE_INTERVAL_MS = 30_000;
 
+const ANSI_RESET = "\x1b[0m";
+
 /** The subset of Pi's TUI surface this scheduler needs. */
 export interface RedrawTarget {
 	readonly mode: string;
@@ -29,6 +35,7 @@ export interface RedrawTarget {
 
 export interface FullRedrawSchedulerOptions {
 	minGapMs?: number;
+	rowRefreshIntervalMs?: number;
 	idleIntervalMs?: number;
 	now?: () => number;
 	schedule?: (callback: () => void, intervalMs: number) => unknown;
@@ -48,9 +55,12 @@ function defaultCancel(handle: unknown): void {
 
 export class FullRedrawScheduler {
 	private target: RedrawTarget | undefined;
-	private handle: unknown;
+	private rowRefreshHandle: unknown;
+	private fullRedrawHandle: unknown;
 	private lastRedrawAt = Number.NEGATIVE_INFINITY;
+	private decorationPhase = 0;
 	private readonly minGapMs: number;
+	private readonly rowRefreshIntervalMs: number;
 	private readonly idleIntervalMs: number;
 	private readonly now: () => number;
 	private readonly schedule: (callback: () => void, intervalMs: number) => unknown;
@@ -58,34 +68,65 @@ export class FullRedrawScheduler {
 
 	constructor(options: FullRedrawSchedulerOptions = {}) {
 		this.minGapMs = options.minGapMs ?? DEFAULT_MIN_GAP_MS;
+		this.rowRefreshIntervalMs = options.rowRefreshIntervalMs ?? DEFAULT_ROW_REFRESH_INTERVAL_MS;
 		this.idleIntervalMs = options.idleIntervalMs ?? DEFAULT_IDLE_INTERVAL_MS;
 		this.now = options.now ?? Date.now;
 		this.schedule = options.schedule ?? defaultSchedule;
 		this.cancel = options.cancel ?? defaultCancel;
 	}
 
-	/** Bind to the TUI that owns the footer and start the idle sweep. */
+	/** Bind to the TUI that owns the footer and start both repair sweeps. */
 	attach(target: RedrawTarget): void {
 		this.detach();
 		this.target = target;
-		this.handle = this.schedule(() => {
+		this.lastRedrawAt = Number.NEGATIVE_INFINITY;
+		this.decorationPhase = 0;
+		this.rowRefreshHandle = this.schedule(() => {
+			this.requestRowRefresh();
+		}, this.rowRefreshIntervalMs);
+		this.fullRedrawHandle = this.schedule(() => {
 			this.request();
 		}, this.idleIntervalMs);
 	}
 
 	detach(): void {
-		if (this.handle !== undefined) this.cancel(this.handle);
-		this.handle = undefined;
+		if (this.rowRefreshHandle !== undefined) this.cancel(this.rowRefreshHandle);
+		if (this.fullRedrawHandle !== undefined) this.cancel(this.fullRedrawHandle);
+		this.rowRefreshHandle = undefined;
+		this.fullRedrawHandle = undefined;
 		this.target = undefined;
 	}
 
+	/**
+	 * Make footer rows byte-different without changing their visible contents.
+	 * Pi will then clear and repaint those rows during an ordinary differential
+	 * render instead of requiring a full-screen clear.
+	 */
+	decorate(lines: string[]): string[] {
+		if (this.target?.mode !== "fullscreen") return lines;
+		const prefix = this.decorationPhase === 0 ? ANSI_RESET : `${ANSI_RESET}${ANSI_RESET}`;
+		return lines.map((line) => `${prefix}${line}`);
+	}
+
+	/**
+	 * Advance the invisible footer marker and request an ordinary render. The
+	 * timer calls this at most once per interval, so active Pi frames do not
+	 * repeatedly repaint otherwise-static statusline rows.
+	 */
+	requestRowRefresh(): boolean {
+		const target = this.target;
+		if (!target || target.mode !== "fullscreen") return false;
+		this.decorationPhase = (this.decorationPhase + 1) % 2;
+		target.requestRender();
+		return true;
+	}
+
 	/**
 	 * Ask for a forced full redraw. No-ops outside fullscreen mode and while
 	 * throttled. Returns whether a redraw was actually requested.
 	 */
 	request(): boolean {
 		const target = this.target;
-		// Regular mode reprints its whole block every frame, so it self-heals.
 		if (!target || target.mode !== "fullscreen") return false;
 		const now = this.now();
 		if (now - this.lastRedrawAt < this.minGapMs) return false;