@zgeoff/atc 1.0.0 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zgeoff/atc",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Terminal control tower for Claude Code sessions",
   "homepage": "https://github.com/zgeoff/atc#readme",
   "bugs": "https://github.com/zgeoff/atc/issues",

package/src/client/plan-vacated-rows.ts

@@ -0,0 +1,26 @@
+export interface BoxExtent {
+  readonly top: number;
+  readonly height: number;
+}
+
+/**
+ * The screen rows the previous box covered that the next one does not. A
+ * centered box shifts and shrinks as its row count changes, so a redraw
+ * erases these rows first — otherwise the old box's edges linger as ghost
+ * lines above and below the new one.
+ */
+export function planVacatedRows(prev: BoxExtent | null, next: BoxExtent): number[] {
+  if (prev === null) {
+    return [];
+  }
+
+  const vacated: number[] = [];
+
+  for (let row = prev.top; row < prev.top + prev.height; row++) {
+    if (row < next.top || row >= next.top + next.height) {
+      vacated.push(row);
+    }
+  }
+
+  return vacated;
+}

package/src/client/ui.ts

@@ -4,6 +4,8 @@ import type { SessionState } from '../daemon/sessions';
 import { RESET_INPUT_MODES } from '../shared/reset-input-modes';
 import { formatDir } from './dirs';
 import { formatOverlayAgentMark } from './format-overlay-agent-mark';
+import { planVacatedRows } from './plan-vacated-rows';
+import type { BoxExtent } from './plan-vacated-rows';
 
 // The slice of a session the drawing layer needs; satisfied by both the
 // daemon's sessions and the wire descriptors a client mirrors.
@@ -119,12 +121,24 @@ interface Row {
   readonly width: number;
 }
 
+// The extent of the last box drawn, so the next draw can erase the rows a
+// shrinking or shifting box leaves behind. Erasing an already-blank row is a
+// no-op, so a stale extent after a full clear is harmless.
+let lastBoxExtent: BoxExtent | null = null;
+
 function drawBox(rowsList: readonly Row[]) {
   const boxWidth = Math.max(...rowsList.map((r) => r.width));
   const top = Math.max(1, Math.floor((rows() - 1 - rowsList.length) / 2));
   const left = Math.max(1, Math.floor((cols() - boxWidth) / 2));
+  const extent: BoxExtent = { top, height: rowsList.length };
   let buf = ansi.hideCursor;
 
+  for (const row of planVacatedRows(lastBoxExtent, extent)) {
+    buf += `${ansi.moveTo(row, 1)}${ESC}[2K`;
+  }
+
+  lastBoxExtent = extent;
+
   for (const [i, r] of rowsList.entries()) {
     buf += ansi.moveTo(top + i, left) + r.styled;
   }

package/src/daemon/daemon.ts

@@ -481,7 +481,12 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
       attachments.attach(sessionID, client, dims);
       mgr.attach(sessionID);
 
-      scheduleResize(sessionID);
+      // The PTY and screen model take the new effective size before the
+      // replay renders, so the repaint arrives at the attaching terminal's
+      // own dims instead of the previous attachment's — a replay at stale
+      // dims paints vertically misaligned and the agent's resize repaint
+      // only redraws its live region, never the rows above it.
+      applyEffectiveDims(sessionID);
       void sendReplay(sessionID, client);
 
       return 'ok';

package/src/daemon/screen-model.ts

@@ -84,10 +84,19 @@ export class ScreenModel {
     });
   }
 
-  // The terminal parses asynchronously; the replay waits for every recorded
-  // byte to land in the buffer before serializing.
+  // The terminal parses asynchronously, and bytes recorded while a flush is
+  // awaited re-arm it — so the replay drains until no newer write is
+  // pending. Serializing earlier would omit bytes already streamed live to
+  // clients, and the replay's leading clear would erase them from the
+  // client's screen for good.
   async renderReplay(): Promise<string> {
-    await this.flushed;
+    let pending: Promise<void>;
+
+    do {
+      pending = this.flushed;
+
+      await pending;
+    } while (pending !== this.flushed);
 
     return RESET_INPUT_MODES + this.serializer.serialize() + this.renderInputModes();
   }