@mentiko/pty-mgr 1.4.1 → 1.4.3

package/CHANGELOG.md

@@ -1,5 +1,65 @@
 # Changelog
 
+## 1.4.3 - 2026-07-07
+
+### Fixed
+
+- `p attach` now sizes the session to the attaching client's terminal instead of
+  resizing the client to the session. The old app-driven CSI-8 resize is ignored
+  inside tmux/iTerm panes (or resizes the whole window), so a session viewed in a
+  smaller pane kept its default winsize — which made a full-frame TUI (e.g. Claude
+  Code) flicker its status line and pushed its bottom row off-screen. The client
+  now sends its size in the attach request and the daemon resizes the session
+  (SIGWINCHing the child) to match.
+
+### Added
+
+- Live-resize while attached: when the client's terminal changes size, the
+  session (and its child) resize to follow. The client sends an out-of-band APC
+  control frame that the daemon strips from the raw input stream, so it never
+  reaches the pty as keystrokes.
+
+## 1.4.2 - 2026-07-07
+
+### Changed
+
+- Internal refactor of `lib/pty-manager.mjs`: the two near-identical socket
+  clients collapse into one `requestSocket`, and the terminal-size clamps,
+  `--log` wiring, telegram send, capture-stability check, and transcript
+  listing move to shared helpers. No behavior or public API change.
+
+### Fixed
+
+- Hardened error handling on three paths that could take the daemon down: the
+  socket client now turns a malformed or truncated reply into a rejection
+  instead of an uncaught throw in its data handler; the log write stream gets an
+  `error` listener (a disk-full / permission error drops logging instead of
+  crashing); and attach-mode input is guarded so a keystroke sent to a
+  just-exited session no longer throws in the socket handler.
+
+## 1.4.1 - 2026-07-07
+
+### Fixed
+
+- `p attach` replays the session's full terminal state via the xterm
+  serialize-addon (scrollback, colors, cursor, modes). Normal-buffer sessions
+  (a shell, Claude Code, …) are no longer forced into the alternate screen —
+  which had discarded scrollback — so history stays scrollable in the client.
+  Alt-screen TUIs still get the alt-screen switch, and the client pops back to
+  its normal screen on detach.
+
+## 1.4.0 - 2026-07-07
+
+### Added
+
+- `p attach` replays full scrollback history on connect, not just the visible
+  screen.
+- Layered flow config resolution: flows merge from the packaged defaults, the
+  XDG user config, and a project `pty-mgr.config.json` (project overrides user
+  overrides default). `p flow list` tags each flow with its source layer,
+  `p flow new [--global]` scaffolds a project (or user) flow, and `p open
+  config` opens the config directory.
+
 ## 1.3.1 - 2026-07-02
 
 ### Fixed

package/lib/pty-manager.mjs

@@ -1,30 +1,27 @@
 #!/usr/bin/env bun
 /**
- * pty-manager.mjs - PTY-based agent session manager
+ * pty-manager.mjs (v2) - PTY-based agent session manager
  *
  * Uses:
  *   - Bun.spawn        native PTY support (no python, no native addons)
  *   - @xterm/headless   terminal emulator (parses escape codes into screen)
  *
- * capture() returns the actual rendered screen state, not raw output.
+ * capture() returns the actual rendered screen state, not raw output:
  * spinners, progress bars, cursor movements, and TUI redraws are all
  * resolved into clean text.
  *
- * API:
- *   mgr.spawn(name, cmd)       create session
- *   mgr.sendKeys(name, text)   send keystrokes
- *   mgr.capture(name, lines)   capture rendered screen
- *   mgr.has(name)              check if session exists
- *   mgr.kill(name)             kill session
- *   mgr.list()                 list sessions
- *   mgr.pid(name)              get child process pid
+ * v2 refactor: deduplicated the socket client, terminal-size clamps,
+ * capture-stability check, `--log` wiring, telegram send, and transcript
+ * listing; hardened error handling on the socket read path, the attach
+ * input path, and the log write stream. Behavior and the public API are
+ * unchanged (see the test suite).
  *
- * Usage:
- *   import { PtyManager } from './pty-manager.mjs';
+ * Library API:
  *   const mgr = new PtyManager();
- *   mgr.spawn('agent-1', 'claude', ['--print']);
- *   mgr.sendKeys('agent-1', 'fix the bug\r');
- *   console.log(mgr.capture('agent-1', 40));
+ *   mgr.spawn('agent-1', 'claude', ['--print']);  // create session
+ *   mgr.sendKeys('agent-1', 'fix the bug\r');      // send keystrokes
+ *   mgr.capture('agent-1', 40);                    // rendered screen
+ *   mgr.has(name) / mgr.kill(name) / mgr.list() / mgr.pid(name)
  */
 
 import { EventEmitter } from "node:events";
@@ -39,12 +36,13 @@ import {
   readdirSync,
   statSync,
   writeFileSync,
+  appendFileSync,
 } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { spawn as spawnChild } from "node:child_process";
 
 // kept in sync by scripts/version-sync.cjs (rewrites this literal on release)
-export const VERSION = "1.4.1";
+export const VERSION = "1.4.3";
 import xterm from "@xterm/headless";
 import { SerializeAddon } from "@xterm/addon-serialize";
 
@@ -68,6 +66,15 @@ export function validateSessionName(name) {
   }
 }
 
+// terminal-size clamps: keep buffers sane, prevent memory exhaustion from a
+// hostile/typo'd size. shared by PtySession.resize and the daemon spawn/wrap.
+function clampCols(value, fallback) {
+  return Math.max(20, Math.min(500, value || fallback));
+}
+function clampRows(value, fallback) {
+  return Math.max(5, Math.min(200, value || fallback));
+}
+
 class PtySession {
   constructor(name, opts = {}) {
     this.name = name;
@@ -152,16 +159,9 @@ class PtySession {
   }
 
   /**
-   * capture the rendered screen buffer.
-   *
-   * returns what you'd actually see on the terminal right now.
-   * escape codes, cursor movements, line erases -- all resolved.
-   * equivalent of reading the full terminal screen buffer.
-   *
-   * @param {number} [tailLines] - last N lines (0 or omit = visible screen)
-   * @param {object} [opts] - options
-   * @param {boolean} [opts.screen] - only capture visible rows (skip scrollback)
-   * @returns {string}
+   * capture the rendered screen: what you'd see now, with escape codes, cursor
+   * moves and line-erases all resolved. tailLines>0 returns the last N lines;
+   * opts.screen limits to visible rows (skips scrollback).
    */
   capture(tailLines, opts = {}) {
     const buf = this.terminal.buffer.active;
@@ -187,21 +187,15 @@ class PtySession {
     return lines.join("\n");
   }
 
-  /**
-   * capture the rendered screen with ANSI color/attribute escape codes.
-   * uses @xterm/addon-serialize to preserve colors, bold, etc.
-   * @returns {string}
-   */
+  /** rendered screen with ANSI color/attribute codes (via addon-serialize). */
   captureAnsi() {
     return this._serializer.serialize();
   }
 
   /**
-   * capture visible content with ANSI colors, trimmed of empty lines.
-   * reads cells individually to build colored output line by line.
-   * result starts from line 0 (no leading empty rows).
-   * @param {number} [tailLines] - last N lines (0 = all content)
-   * @returns {string}
+   * visible content with ANSI colors, trimmed of leading/trailing empty lines.
+   * reads cells individually (line by line) so colors/attributes survive.
+   * tailLines>0 = last N lines.
    */
   captureAnsiCompact(tailLines) {
     const buf = this.terminal.buffer.active;
@@ -289,14 +283,10 @@ class PtySession {
     return lines.join("\r\n");
   }
 
-  /**
-   * resize the PTY and headless terminal.
-   * @param {number} cols
-   * @param {number} rows
-   */
+  /** resize the PTY and headless terminal (clamped to sane bounds). */
   resize(cols, rows) {
-    cols = Math.max(20, Math.min(500, cols));
-    rows = Math.max(5, Math.min(200, rows));
+    cols = clampCols(cols, cols);
+    rows = clampRows(rows, rows);
     this.terminal.resize(cols, rows);
     if (this._pty && !this.exited) {
       try { this._pty.resize(cols, rows); } catch {}
@@ -335,15 +325,10 @@ class PtySession {
   }
 
   /**
-   * start logging session output to a file.
-   *
-   * format:
+   * start logging session output to a file. format:
    *   "raw"      - raw PTY bytes (escape codes included, replayable)
-   *   "rendered"  - clean screen snapshots on each data event
-   *   "jsonl"     - timestamped JSON lines { t, type, data }
-   *
-   * @param {string} logPath - file path to write to
-   * @param {string} [format="raw"] - log format
+   *   "rendered" - clean screen snapshots on each data event
+   *   "jsonl"    - timestamped JSON lines { t, type, data }
    */
   startLog(logPath, format = "raw") {
     if (this._logStream) this.stopLog();
@@ -354,6 +339,10 @@ class PtySession {
     this._logPath = logPath;
     this._logFormat = format;
     this._logStream = createWriteStream(logPath, { flags: "a" });
+    // a write error (disk full, perms, unlinked path) emits 'error'; without a
+    // listener node throws it as uncaught and takes the daemon down. drop
+    // logging on error rather than crash the session.
+    this._logStream.on("error", () => { try { this.stopLog(); } catch {} });
 
     // write header for jsonl
     if (format === "jsonl") {
@@ -470,18 +459,9 @@ export class PtyManager {
   }
 
   /**
-   * spawn a command inside a real PTY with terminal emulation
-   *
-   * @param {string} name - unique session name
-   * @param {string} cmd - command to run
-   * @param {string[]} [args] - arguments
-   * @param {object} [opts]
-   * @param {string} [opts.cwd] - working directory
-   * @param {object} [opts.env] - extra env vars
-   * @param {number} [opts.cols] - terminal columns (default 200)
-   * @param {number} [opts.rows] - terminal rows (default 50)
-   * @param {number} [opts.scrollback] - scrollback lines (default 5000)
-   * @returns {string} session name
+   * spawn a command inside a real PTY with terminal emulation. opts: cwd, env
+   * (extra vars), cols (default 100), rows (default 35), scrollback (5000).
+   * returns the session name.
    */
   spawn(name, cmd, args = [], opts = {}) {
     validateSessionName(name);
@@ -720,6 +700,54 @@ function socketPath(name) {
 const { daemon: DAEMON_NAME, args: CLI_ARGS } = splitDaemonArgs(process.argv.slice(2));
 const SOCKET_PATH = socketPath(DAEMON_NAME);
 
+// ── attach input: out-of-band resize control frames ──────────────────
+// While attached, the socket carries raw keystrokes. A client signals a live
+// terminal resize with an APC control frame the daemon pulls out of the stream
+// instead of forwarding to the pty:  ESC _ ptymgr:resize:<cols>:<rows> ESC \
+// APC (ESC _) is ignored by terminals and is never produced by a keyboard, so
+// it cannot collide with real input.
+const RESIZE_PREFIX = Buffer.from("\x1b_ptymgr:resize:");
+const RESIZE_ST = Buffer.from("\x1b\\");
+
+// longest k (>=1) where buf's last k bytes equal prefix's first k bytes.
+function suffixPrefixOverlap(buf, prefix) {
+  for (let k = Math.min(buf.length, prefix.length - 1); k > 0; k--) {
+    if (buf.subarray(buf.length - k).equals(prefix.subarray(0, k))) return k;
+  }
+  return 0;
+}
+
+// Split raw attach input into pty keystrokes and resize frames. Returns
+// { forward: Buffer for the pty, resizes: [{cols,rows}], rest: Buffer to
+// prepend to the next chunk }. `rest` holds an incomplete frame, or a trailing
+// "ESC _…" that may begin one, so a frame split across reads reassembles. A
+// lone trailing ESC is NOT held (that's the Escape key or a CSI start) so it
+// forwards immediately.
+export function parseAttachInput(buf) {
+  const forward = [];
+  const resizes = [];
+  let i = 0;
+  while (i < buf.length) {
+    const start = buf.indexOf(RESIZE_PREFIX, i);
+    if (start === -1) break;
+    if (start > i) forward.push(buf.subarray(i, start));
+    const st = buf.indexOf(RESIZE_ST, start + RESIZE_PREFIX.length);
+    if (st === -1) {
+      // incomplete frame: forward what precedes it, hold the rest
+      return { forward: Buffer.concat(forward), resizes, rest: buf.subarray(start) };
+    }
+    const body = buf.subarray(start + RESIZE_PREFIX.length, st).toString("latin1");
+    const m = body.match(/^(\d+):(\d+)$/);
+    if (m) resizes.push({ cols: Number(m[1]), rows: Number(m[2]) });
+    i = st + RESIZE_ST.length;
+  }
+  const tail = buf.subarray(i);
+  let keep = suffixPrefixOverlap(tail, RESIZE_PREFIX);
+  if (keep < 2) keep = 0; // never hold a lone ESC (Escape key / CSI start)
+  if (tail.length > keep) forward.push(tail.subarray(0, tail.length - keep));
+  return { forward: Buffer.concat(forward), resizes, rest: tail.subarray(tail.length - keep) };
+}
+
 /**
  * daemon: long-running process that holds all sessions.
  * clients connect via unix socket, send JSON commands, get JSON responses.
@@ -766,6 +794,7 @@ function startDaemon() {
     const server = createServer((conn) => {
       let buf = "";
       let attached = false; // true when in attach streaming mode
+      let attachInBuf = Buffer.alloc(0); // carries a split resize frame across reads
 
       // suppress connection errors (client disconnect, etc.)
       conn.on("error", () => {});
@@ -776,9 +805,21 @@ function startDaemon() {
       });
 
       conn.on("data", async (data) => {
-        // in attach mode, forward raw input to the pty
+        // in attach mode: pull out any resize control frames (applied to the
+        // session), forward the rest as raw keystrokes to the pty. the session
+        // can exit between attach and this write (write() throws once exited);
+        // swallow so a late keystroke can't crash the daemon's data handler.
         if (attached) {
-          attached.write(data.toString());
+          const { forward, resizes, rest } = parseAttachInput(
+            attachInBuf.length ? Buffer.concat([attachInBuf, data]) : data
+          );
+          attachInBuf = rest;
+          for (const { cols, rows } of resizes) {
+            try { attached.resize(cols, rows); } catch {}
+          }
+          if (forward.length) {
+            try { attached.write(forward.toString()); } catch {}
+          }
           return;
         }
 
@@ -799,6 +840,15 @@ function startDaemon() {
             // attach is special: switches to streaming mode
             if (req.cmd === "attach") {
               const session = mgr.get(req.name);
+              // size the session to the attaching client's terminal so the
+              // child's winsize matches what the user actually sees. A pane
+              // (tmux/iTerm split) ignores an app's own CSI-8 window resize --
+              // and honoring it would resize the user's whole window -- so we
+              // resize the session TO the client, the way tmux/ssh do. resize()
+              // SIGWINCHes the child, which repaints at the new size; a mismatch
+              // here is what makes a full-frame TUI's status line flicker and
+              // pushes its bottom row off-screen. No size sent => leave as-is.
+              if (req.cols && req.rows) session.resize(req.cols, req.rows);
               const cols = session.terminal.cols;
               const rows = session.terminal.rows;
               const alt = session.terminal.buffer.active.type === "alternate";
@@ -837,6 +887,7 @@ function startDaemon() {
 
               // forward client input to pty
               attached = session;
+              attachInBuf = Buffer.alloc(0);
 
               // cleanup on disconnect
               conn.on("close", () => {
@@ -878,15 +929,9 @@ function startDaemon() {
 
     async function tgSend(chatId, text) {
       const token = process.env.TELEGRAM_BOT_TOKEN;
-      // telegram max message length is 4096
-      const chunks = [];
-      for (let i = 0; i < text.length; i += 4000) chunks.push(text.slice(i, i + 4000));
-      for (const chunk of chunks) {
-        await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
-          method: "POST",
-          headers: { "content-type": "application/json" },
-          body: JSON.stringify({ chat_id: chatId, text: chunk }),
-        });
+      // telegram max message length is 4096; chunk under it
+      for (let i = 0; i < text.length; i += 4000) {
+        await telegramSend(token, chatId, text.slice(i, i + 4000));
       }
     }
 
@@ -1088,6 +1133,15 @@ export function buildSafeEnv(extra) {
   return safeEnv;
 }
 
+// start default jsonl logging for a session, under the session's own cwd (the
+// client's dir, not the daemon's frozen cwd). used by the `--log` shortcut on
+// spawn/wrap; the `log` command does its own format/dir handling. returns path.
+function startDefaultLog(mgr, name) {
+  const logPath = join(mgr.get(name).cwd, "agents", "logs", `${name}-${Date.now()}.jsonl`);
+  mgr.get(name).startLog(logPath, "jsonl");
+  return logPath;
+}
+
 // POSIX single-quote escaping: wrap in '...' and replace each ' with '\''.
 // Makes a token literal to the shell -- no expansion, no command substitution,
 // no word splitting. Used to build the `zsh -lic` command line for `wrap`.
@@ -1095,6 +1149,17 @@ export function shellQuote(arg) {
   return `'${String(arg).replace(/'/g, "'\\''")}'`;
 }
 
+// one place that talks to the Telegram Bot API. returns the fetch promise so
+// callers keep their existing error semantics (handleCommand's try/catch for
+// the tg-send/tg-wait commands; the poller's own catch for notifications).
+function telegramSend(token, chatId, text) {
+  return fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ chat_id: chatId, text }),
+  });
+}
+
 async function handleCommand(mgr, req, daemonStartedAt, config, tgState = {}) {
   const { cmd, name, args } = req;
 
@@ -1153,8 +1218,8 @@ async function handleCommand(mgr, req, daemonStartedAt, config, tgState = {}) {
       const cmdToRun = args?.cmd || "zsh";
       const cmdArgs = args?.args || [];
       // clamp terminal size to prevent memory exhaustion
-      const cols = Math.max(20, Math.min(500, args?.cols || config.cols));
-      const rows = Math.max(5, Math.min(200, args?.rows || config.rows));
+      const cols = clampCols(args?.cols, config.cols);
+      const rows = clampRows(args?.rows, config.rows);
       const safeEnv = buildSafeEnv(args?.env);
       safeEnv.PTY_MGR_SESSION = name;
       const opts = {
@@ -1165,14 +1230,7 @@ async function handleCommand(mgr, req, daemonStartedAt, config, tgState = {}) {
       };
       mgr.spawn(name, cmdToRun, cmdArgs, opts);
       const res = { ok: true, name, pid: mgr.pid(name) };
-      // auto-start logging if --log flag. logs live under the session's own
-      // cwd (client's dir), not the daemon's frozen cwd.
-      if (args?.log) {
-        const logDir = join(mgr.get(name).cwd, "agents", "logs");
-        const logPath = join(logDir, `${name}-${Date.now()}.jsonl`);
-        mgr.get(name).startLog(logPath, "jsonl");
-        res.logPath = logPath;
-      }
+      if (args?.log) res.logPath = startDefaultLog(mgr, name);
       return res;
     }
     case "wrap": {
@@ -1195,8 +1253,8 @@ async function handleCommand(mgr, req, daemonStartedAt, config, tgState = {}) {
       if (maxNum === 0) maxNum = 1;
       const nextName = `${baseName}-${maxNum}`;
 
-      const cols = Math.max(20, Math.min(500, args?.cols || config.cols));
-      const rows = Math.max(5, Math.min(200, args?.rows || config.rows));
+      const cols = clampCols(args?.cols, config.cols);
+      const rows = clampRows(args?.rows, config.rows);
 
       // wrap spawns through user's login shell so shell functions/aliases work
       // (like tmux does). this means glm, nvm, conda, etc. all resolve.
@@ -1223,13 +1281,7 @@ async function handleCommand(mgr, req, daemonStartedAt, config, tgState = {}) {
 
       mgr.spawn(nextName, shellCmd, shellArgs, { cwd: clientCwd, env: wrapEnv, cols, rows });
       const res = { ok: true, name: nextName, pid: mgr.pid(nextName) };
-
-      if (args?.log) {
-        const logDir = join(clientCwd, "agents", "logs");
-        const logPath = join(logDir, `${nextName}-${Date.now()}.jsonl`);
-        mgr.get(nextName).startLog(logPath, "jsonl");
-        res.logPath = logPath;
-      }
+      if (args?.log) res.logPath = startDefaultLog(mgr, nextName);
       return res;
     }
     case "send": {
@@ -1346,11 +1398,7 @@ async function handleCommand(mgr, req, daemonStartedAt, config, tgState = {}) {
       const msg = req.args?.message;
       if (!msg) return { ok: false, error: "message required" };
       if (req.args?.session) tgState.lastSession = req.args.session;
-      await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ chat_id: chatId, text: msg }),
-      });
+      await telegramSend(token, chatId, msg);
       return { ok: true };
     }
     case "tg-wait": {
@@ -1360,11 +1408,7 @@ async function handleCommand(mgr, req, daemonStartedAt, config, tgState = {}) {
       if (tgState.waiter) return { ok: false, error: "ALREADY_WAITING" };
       const msg = req.args?.message;
       const timeoutMs = req.args?.timeout ?? 60000;
-      await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ chat_id: chatId, text: msg }),
-      });
+      await telegramSend(token, chatId, msg);
       const sessionName = req.args?.session;
       return new Promise((resolve) => {
         const timer = setTimeout(() => {
@@ -1389,58 +1433,55 @@ async function handleCommand(mgr, req, daemonStartedAt, config, tgState = {}) {
 }
 
 /**
- * client: send a single command to the daemon, print result.
+ * client: send one newline-framed JSON command to a daemon socket and resolve
+ * with the parsed JSON reply. Rejects with a friendly message when the daemon
+ * is absent, and — unlike a bare JSON.parse in the data handler — turns a
+ * malformed or truncated reply into a rejection instead of an uncaught throw.
  */
-function sendCommandTo(sock, req) {
+function requestSocket(sock, req, notRunningMsg) {
   return new Promise((resolve, reject) => {
     const conn = createConnection(sock);
+    let buf = "";
+    let settled = false;
+    const settle = (fn, value) => {
+      if (settled) return;
+      settled = true;
+      try { conn.end(); } catch {}
+      fn(value);
+    };
+    const parseAndSettle = (chunk) => {
+      try { settle(resolve, JSON.parse(chunk)); }
+      catch (err) { settle(reject, new Error(`bad response from daemon: ${err.message}`)); }
+    };
     conn.on("error", (err) => {
-      if (err.code === "ENOENT" || err.code === "ECONNREFUSED") {
-        reject(new Error("daemon not running"));
-      } else {
-        reject(err);
-      }
+      if (err.code === "ENOENT" || err.code === "ECONNREFUSED") settle(reject, new Error(notRunningMsg));
+      else settle(reject, err);
     });
     conn.on("connect", () => {
-      conn.write(JSON.stringify(req) + "\n");
+      try { conn.write(JSON.stringify(req) + "\n"); }
+      catch (err) { settle(reject, err); }
     });
-    let buf = "";
     conn.on("data", (data) => {
       buf += data.toString();
       const nl = buf.indexOf("\n");
-      if (nl !== -1) {
-        const res = JSON.parse(buf.slice(0, nl));
-        conn.end();
-        resolve(res);
-      }
+      if (nl !== -1) parseAndSettle(buf.slice(0, nl));
+    });
+    conn.on("end", () => {
+      if (settled) return;
+      if (buf) parseAndSettle(buf); // reply without a trailing newline
+      else settle(reject, new Error(notRunningMsg));
     });
   });
 }
 
+// send to a specific socket file (used by `stop all` sweeping ~/.pty-manager).
+function sendCommandTo(sock, req) {
+  return requestSocket(sock, req, "daemon not running");
+}
+
+// send to the daemon selected by @name / --daemon / $PTY_DAEMON.
 function sendCommand(req) {
-  return new Promise((resolve, reject) => {
-    const conn = createConnection(SOCKET_PATH);
-    conn.on("error", (err) => {
-      if (err.code === "ENOENT" || err.code === "ECONNREFUSED") {
-        reject(new Error("daemon not running. start with: pty-mgr daemon"));
-      } else {
-        reject(err);
-      }
-    });
-    conn.on("connect", () => {
-      conn.write(JSON.stringify(req) + "\n");
-    });
-    let buf = "";
-    conn.on("data", (data) => {
-      buf += data.toString();
-      const nl = buf.indexOf("\n");
-      if (nl !== -1) {
-        const res = JSON.parse(buf.slice(0, nl));
-        conn.end();
-        resolve(res);
-      }
-    });
-  });
+  return requestSocket(SOCKET_PATH, req, "daemon not running. start with: pty-mgr daemon");
 }
 
 /**
@@ -1465,11 +1506,19 @@ function attachToSession(name) {
     });
 
     conn.on("connect", () => {
-      // send attach request
-      conn.write(JSON.stringify({ cmd: "attach", name }) + "\n");
+      // send attach request with our real terminal size so the daemon can size
+      // the session (and its child) to us. undefined when stdout isn't a TTY;
+      // the daemon then leaves the session size unchanged.
+      conn.write(JSON.stringify({
+        cmd: "attach",
+        name,
+        cols: process.stdout.columns,
+        rows: process.stdout.rows,
+      }) + "\n");
 
       let gotAck = false;
       let headerBuf = "";
+      let onStdoutResize = null;
 
       // last-seen alt-screen state: detach pops the client back to its
       // normal screen only if the session left it in the alternate buffer
@@ -1509,11 +1558,11 @@ function attachToSession(name) {
           gotAck = true;
           altActive = !!ack.alt;
 
-          // resize client terminal to match session
-          if (ack.cols && ack.rows) {
-            // CSI 8 ; rows ; cols t  = resize terminal window
-            process.stdout.write(`\x1b[8;${ack.rows};${ack.cols}t`);
-          }
+          // NOTE: we do NOT resize our own terminal to the session. The daemon
+          // has already sized the session to us (we sent our size in the attach
+          // request). An app-driven CSI-8 window resize is ignored inside
+          // tmux/iTerm panes and, where honored, resizes the user's entire
+          // window -- which is what caused the flicker and the missing bottom row.
 
           // put terminal in raw mode
           process.stdin.setRawMode(true);
@@ -1537,6 +1586,15 @@ function attachToSession(name) {
             conn.write(key);
           });
 
+          // live-resize: when our terminal changes size, tell the daemon so it
+          // resizes the session (and its child's winsize) to match. Sent as an
+          // out-of-band APC frame the daemon strips from the input stream.
+          onStdoutResize = () => {
+            const c = process.stdout.columns, r = process.stdout.rows;
+            if (c && r) { try { conn.write(`\x1b_ptymgr:resize:${c}:${r}\x1b\\`); } catch {} }
+          };
+          process.stdout.on("resize", onStdoutResize);
+
           return;
         }
 
@@ -1553,6 +1611,10 @@ function attachToSession(name) {
       function detach() {
         if (detached || failed) return;
         detached = true;
+        if (onStdoutResize) {
+          process.stdout.removeListener("resize", onStdoutResize);
+          onStdoutResize = null;
+        }
         if (process.stdin.isRaw) {
           process.stdin.setRawMode(false);
           process.stdin.pause();
@@ -1994,6 +2056,20 @@ function capturePayloadText(res) {
   return res.output || "";
 }
 
+// capture a session (or glob/all) twice, intervalMs apart, and report whether
+// the rendered bottom-100 lines are stable ("done") or still changing
+// ("working"). shared by `p watch` and the flow engine's turn-completion check.
+async function captureStability(name, intervalMs) {
+  const capture = () => sendCommand({ cmd: "capture", name, args: { lines: 100 } });
+  const first = await capture();
+  if (!first.ok) throw new Error(first.error || `failed to capture ${name}`);
+  const firstHash = hashText(capturePayloadText(first));
+  await sleep(intervalMs);
+  const second = await capture();
+  if (!second.ok) throw new Error(second.error || `failed to capture ${name}`);
+  return firstHash === hashText(capturePayloadText(second)) ? "done" : "working";
+}
+
 function expandHome(value) {
   if (!value) return value;
   if (value === "~") return homedir();
@@ -2191,11 +2267,14 @@ export function transcriptRootsForKind(kind, config, cwd = process.cwd()) {
     .filter((root, index, roots) => existsSync(root) || index === roots.length - 1);
 }
 
+// flatten every .jsonl transcript under a kind's configured roots.
+function transcriptFiles(kind, config, cwd = process.cwd()) {
+  return transcriptRootsForKind(kind, config, cwd).flatMap((root) => walkJsonlFiles(root));
+}
+
 export function findNewestTranscript({ kind, cwd = process.cwd(), sinceMs = 0, config }) {
   const adapter = adapterForKind(kind, config);
-  const roots = transcriptRootsForKind(kind, config, cwd);
-  const candidates = roots
-    .flatMap((root) => walkJsonlFiles(root))
+  const candidates = transcriptFiles(kind, config, cwd)
     .map((path) => {
       const mtimeMs = statSync(path).mtimeMs;
       const startedMs = transcriptStartedAtMs(path, adapter);
@@ -2338,8 +2417,7 @@ export function findTranscriptForSentMessage({
 }) {
   if (file) return findSentMessageInTranscript(file, kind, text, config);
 
-  const candidates = transcriptRootsForKind(kind, config, cwd)
-    .flatMap((root) => walkJsonlFiles(root))
+  const candidates = transcriptFiles(kind, config, cwd)
     .map((path) => ({ path, mtimeMs: statSync(path).mtimeMs }))
     .sort((a, b) => b.mtimeMs - a.mtimeMs);
 
@@ -2489,14 +2567,7 @@ async function sendFlowMessageConfirmed(meta, text, config, deps = {}) {
 
 async function watchFlowSession(session, intervalMs, deps = {}) {
   if (deps.watchSession) return deps.watchSession(session, intervalMs);
-  const first = await sendCommand({ cmd: "capture", name: session, args: { lines: 100 } });
-  if (!first.ok) throw new Error(first.error || `failed to capture ${session}`);
-  const firstHash = hashText(capturePayloadText(first));
-  await sleep(intervalMs);
-  const second = await sendCommand({ cmd: "capture", name: session, args: { lines: 100 } });
-  if (!second.ok) throw new Error(second.error || `failed to capture ${session}`);
-  const secondHash = hashText(capturePayloadText(second));
-  return firstHash === secondHash ? "done" : "working";
+  return captureStability(session, intervalMs);
 }
 
 async function waitForFlowMessage({
@@ -2674,8 +2745,6 @@ function detectRcFile() {
 }
 
 async function runSetup() {
-  const { appendFileSync, readFileSync, writeFileSync } = await import("node:fs");
-
   console.log("pty-mgr setup");
   console.log("wrap CLI tools in managed PTY sessions.\n");
   console.log("when you type a wrapped command (e.g. claude), pty-mgr will:");
@@ -2952,12 +3021,11 @@ async function cli() {
   if (command === "daemon") {
     // fork into background as a true daemon (survives terminal close)
     if (!process.env.__PTY_DAEMON_CHILD) {
-      const { spawn: cpSpawn } = await import("node:child_process");
       // re-exec ourselves with the same args
       // process.execPath = bun (dev) or the compiled binary
       // filter out internal /$bunfs/ paths from argv
       const realArgs = process.argv.slice(1).filter(a => !a.startsWith("/$bunfs/"));
-      const child = cpSpawn(process.execPath, realArgs, {
+      const child = spawnChild(process.execPath, realArgs, {
         detached: true,
         stdio: ["ignore", "ignore", "ignore", "ipc"],
         env: { ...process.env, __PTY_DAEMON_CHILD: "1" },
@@ -2991,7 +3059,6 @@ async function cli() {
     const target = args[0]; // "all" or undefined (= current daemon)
     if (target === "all") {
       // find all pty-manager sockets and shut them down
-      const { readdirSync } = await import("node:fs");
       const dir = join(homedir(), ".pty-manager");
       let socks = [];
       try {
@@ -3079,20 +3146,7 @@ async function cli() {
     }
 
     try {
-      const first = await sendCommand({ cmd: "capture", name, args: { lines: 100 } });
-      if (!first.ok) {
-        console.error("error:", first.error);
-        process.exit(1);
-      }
-      const firstHash = hashText(capturePayloadText(first));
-      await sleep(intervalMs);
-      const second = await sendCommand({ cmd: "capture", name, args: { lines: 100 } });
-      if (!second.ok) {
-        console.error("error:", second.error);
-        process.exit(1);
-      }
-      const secondHash = hashText(capturePayloadText(second));
-      console.log(firstHash === secondHash ? "done" : "working");
+      console.log(await captureStability(name, intervalMs));
       process.exit(0);
     } catch (err) {
       console.error(err.message);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentiko/pty-mgr",
-  "version": "1.4.1",
+  "version": "1.4.3",
   "description": "PTY session manager with terminal emulation for programmatic session control.",
   "type": "module",
   "main": "lib/pty-manager.mjs",
@@ -26,10 +26,10 @@
     "@xterm/headless": "^6.0.0"
   },
   "optionalDependencies": {
-    "@mentiko/pty-mgr-linux-x64": "1.4.1",
-    "@mentiko/pty-mgr-linux-arm64": "1.4.1",
-    "@mentiko/pty-mgr-darwin-x64": "1.4.1",
-    "@mentiko/pty-mgr-darwin-arm64": "1.4.1"
+    "@mentiko/pty-mgr-linux-x64": "1.4.3",
+    "@mentiko/pty-mgr-linux-arm64": "1.4.3",
+    "@mentiko/pty-mgr-darwin-x64": "1.4.3",
+    "@mentiko/pty-mgr-darwin-arm64": "1.4.3"
   },
   "engines": {
     "bun": ">=1.0"