ragent-cli 1.4.5 → 1.5.1

package/dist/index.js

@@ -31,7 +31,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "ragent-cli",
-      version: "1.4.5",
+      version: "1.5.1",
       description: "CLI agent for rAgent Live \u2014 browser-first terminal control plane for AI coding agents",
       main: "dist/index.js",
       bin: {
@@ -102,7 +102,7 @@ var require_package = __commonJS({
 });
 
 // src/index.ts
-var fs5 = __toESM(require("fs"));
+var fs6 = __toESM(require("fs"));
 var import_commander = require("commander");
 
 // src/constants.ts
@@ -257,12 +257,12 @@ async function maybeWarnUpdate() {
 }
 
 // src/commands/connect.ts
-var os7 = __toESM(require("os"));
+var os8 = __toESM(require("os"));
 
 // src/agent.ts
-var fs3 = __toESM(require("fs"));
-var os6 = __toESM(require("os"));
-var path2 = __toESM(require("path"));
+var fs4 = __toESM(require("fs"));
+var os7 = __toESM(require("os"));
+var path3 = __toESM(require("path"));
 var import_ws5 = __toESM(require("ws"));
 
 // src/auth.ts
@@ -2409,17 +2409,19 @@ var ControlDispatcher = class {
   streamer;
   inventory;
   connection;
+  transcriptWatcher;
   options;
   /** Set to true when a reconnect was requested (restart-agent, disconnect). */
   reconnectRequested = false;
   /** Set to false to stop the agent. */
   shouldRun = true;
-  constructor(shell, streamer, inventory, connection, options) {
+  constructor(shell, streamer, inventory, connection, options, transcriptWatcher) {
     this.shell = shell;
     this.streamer = streamer;
     this.inventory = inventory;
     this.connection = connection;
     this.options = options;
+    this.transcriptWatcher = transcriptWatcher ?? null;
   }
   /** Update options (e.g., after token refresh). */
   updateOptions(options) {
@@ -2534,6 +2536,15 @@ var ControlDispatcher = class {
       case "stop-stream":
         if (sessionId) this.streamer.stopStream(sessionId);
         return;
+      case "prefer-markdown":
+        this.handlePreferMarkdown(sessionId, payload);
+        return;
+      case "sync-markdown":
+        if (sessionId && this.transcriptWatcher) {
+          const fromSeq = typeof payload.fromSeq === "number" ? payload.fromSeq : void 0;
+          this.transcriptWatcher.handleSyncRequest(sessionId, fromSeq);
+        }
+        return;
       default:
     }
   }
@@ -2548,32 +2559,14 @@ var ControlDispatcher = class {
       this.streamer.writeInput(sessionId, data);
     }
   }
-  /** Handle resize routing. */
+  /** Handle resize routing (PTY and screen/zellij only — tmux panes are never resized by the portal). */
   handleResize(cols, rows, sessionId) {
     if (!sessionId || sessionId.startsWith("pty:")) {
       this.shell.resize(cols, rows);
-    } else if (sessionId.startsWith("tmux:")) {
-      this.resizeTmuxPane(sessionId, cols, rows);
     } else if (sessionId.startsWith("screen:") || sessionId.startsWith("zellij:")) {
       this.streamer.resize(sessionId, cols, rows);
     }
   }
-  /** Resize a tmux pane to match the viewer's terminal dimensions. */
-  resizeTmuxPane(sessionId, cols, rows) {
-    const paneTarget = sessionId.slice("tmux:".length);
-    if (!paneTarget) return;
-    const cleanEnv = { ...process.env };
-    delete cleanEnv.TMUX;
-    delete cleanEnv.TMUX_PANE;
-    try {
-      (0, import_child_process4.execFileSync)("tmux", ["resize-pane", "-t", paneTarget, "-x", String(cols), "-y", String(rows)], {
-        env: cleanEnv,
-        timeout: 5e3,
-        stdio: "ignore"
-      });
-    } catch {
-    }
-  }
   /** Handle provision request from dashboard. */
   async handleProvision(payload) {
     const provReq = payload;
@@ -2601,6 +2594,23 @@ var ControlDispatcher = class {
       });
     }
   }
+  handlePreferMarkdown(sessionId, payload) {
+    if (!sessionId || !this.transcriptWatcher) return;
+    const enabled = payload.enabled === true;
+    if (enabled) {
+      const agentType = typeof payload.agentType === "string" ? payload.agentType : void 0;
+      const success = this.transcriptWatcher.enableMarkdown(sessionId, agentType);
+      if (!success) {
+        console.log(`[rAgent] Could not enable markdown for ${sessionId}`);
+      }
+    } else {
+      this.transcriptWatcher.disableMarkdown(sessionId);
+    }
+  }
+  /** Stop all transcript watchers (called on disconnect/cleanup). */
+  stopTranscriptWatchers() {
+    this.transcriptWatcher?.stopAll();
+  }
   async syncInventory(force = false) {
     await this.inventory.syncInventory(
       this.connection.activeSocket,
@@ -2645,6 +2655,30 @@ var ControlDispatcher = class {
     }
     await this.syncInventory(true);
   }
+  /** Query the actual cols/rows of a tmux pane (non-critical). */
+  queryPaneDimensions(sessionId) {
+    if (!sessionId.startsWith("tmux:")) return {};
+    const paneTarget = sessionId.slice("tmux:".length);
+    if (!paneTarget) return {};
+    const cleanEnv = { ...process.env };
+    delete cleanEnv.TMUX;
+    delete cleanEnv.TMUX_PANE;
+    try {
+      const info = (0, import_child_process4.execFileSync)(
+        "tmux",
+        ["display-message", "-t", paneTarget, "-p", "#{pane_width} #{pane_height}"],
+        { env: cleanEnv, timeout: 5e3, encoding: "utf-8" }
+      ).trim();
+      const parts = info.split(" ");
+      if (parts.length === 2) {
+        const cols = parseInt(parts[0], 10);
+        const rows = parseInt(parts[1], 10);
+        if (cols > 0 && rows > 0) return { cols, rows };
+      }
+    } catch {
+    }
+    return {};
+  }
   handleStreamSession(sessionId) {
     if (!sessionId) return;
     const ws = this.connection.activeSocket;
@@ -2657,7 +2691,8 @@ var ControlDispatcher = class {
           if (alreadyStreaming) {
             this.streamer.resyncStream(sessionId);
           }
-          sendToGroup(ws, group, { type: "stream-started", sessionId });
+          const dims = this.queryPaneDimensions(sessionId);
+          sendToGroup(ws, group, { type: "stream-started", sessionId, ...dims });
         } else {
           sendToGroup(ws, group, {
             type: "stream-error",
@@ -2678,13 +2713,493 @@ var ControlDispatcher = class {
   }
 };
 
+// src/transcript-watcher.ts
+var fs3 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var os6 = __toESM(require("os"));
+var import_child_process5 = require("child_process");
+var ClaudeCodeParser = class {
+  name = "claude-code";
+  /** Maps tool_use id → tool name for matching results back to tools. */
+  pendingTools = /* @__PURE__ */ new Map();
+  parseLine(line) {
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      return null;
+    }
+    if (!obj.message?.content) return null;
+    if (obj.type === "assistant") {
+      return this.parseAssistant(obj);
+    }
+    if (obj.type === "user") {
+      return this.parseUserToolResults(obj);
+    }
+    return null;
+  }
+  parseAssistant(obj) {
+    const content = obj.message.content;
+    const textBlocks = [];
+    const tools = [];
+    for (const block of content) {
+      if (block.type === "text" && typeof block.text === "string") {
+        textBlocks.push(block.text);
+      } else if (block.type === "tool_use" && block.name) {
+        if (block.id) {
+          this.pendingTools.set(block.id, block.name);
+        }
+        tools.push({
+          name: block.name,
+          input: block.input,
+          status: "started"
+        });
+      }
+    }
+    if (this.pendingTools.size > 500) {
+      const keys = [...this.pendingTools.keys()];
+      for (let i = 0; i < 250; i++) {
+        this.pendingTools.delete(keys[i]);
+      }
+    }
+    const text = textBlocks.join("\n").trim();
+    if (!text && tools.length === 0) return null;
+    return {
+      turnId: obj.uuid ?? `turn-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      role: "assistant",
+      content: text,
+      tools: tools.length > 0 ? tools : void 0,
+      timestamp: obj.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  parseUserToolResults(obj) {
+    const content = obj.message.content;
+    const tools = [];
+    for (const block of content) {
+      if (block.type !== "tool_result") continue;
+      const toolName = (block.tool_use_id && this.pendingTools.get(block.tool_use_id)) ?? "Tool";
+      const resultText = this.extractToolResultText(block);
+      if (block.tool_use_id) {
+        this.pendingTools.delete(block.tool_use_id);
+      }
+      tools.push({
+        name: toolName,
+        status: block.is_error ? "error" : "completed",
+        result: resultText || void 0
+      });
+    }
+    if (tools.length === 0) return null;
+    return {
+      turnId: obj.uuid ?? `result-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      role: "user",
+      content: "",
+      tools,
+      timestamp: obj.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  extractToolResultText(block) {
+    const rc = block.content;
+    if (typeof rc === "string") return rc;
+    if (Array.isArray(rc)) {
+      return rc.filter((item) => item.type === "text" && typeof item.text === "string").map((item) => item.text).join("\n");
+    }
+    return "";
+  }
+};
+var CodexCliParser = class {
+  name = "codex-cli";
+  parseLine(line) {
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      return null;
+    }
+    const item = obj.response_item;
+    if (!item) return null;
+    if (item.type === "response.output_item.done" && item.item?.type === "message") {
+      const textParts = (item.item.content ?? []).filter((c) => c.type === "text" && typeof c.text === "string").map((c) => c.text);
+      const text = textParts.join("\n").trim();
+      if (!text) return null;
+      return {
+        turnId: item.id ?? `codex-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        role: "assistant",
+        content: text,
+        timestamp: obj.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+    return null;
+  }
+};
+function discoverViaProc(panePid) {
+  try {
+    const children = (0, import_child_process5.execFileSync)("pgrep", ["-P", String(panePid)], {
+      encoding: "utf-8",
+      timeout: 3e3
+    }).trim().split("\n").filter(Boolean);
+    for (const childPid of children) {
+      const fdDir = `/proc/${childPid}/fd`;
+      try {
+        const fds = fs3.readdirSync(fdDir);
+        for (const fd of fds) {
+          try {
+            const target = fs3.readlinkSync(path2.join(fdDir, fd));
+            if (target.endsWith(".jsonl") && target.includes("/.claude/")) {
+              return target;
+            }
+          } catch {
+          }
+        }
+      } catch {
+      }
+      try {
+        const grandchildren = (0, import_child_process5.execFileSync)("pgrep", ["-P", childPid], {
+          encoding: "utf-8",
+          timeout: 3e3
+        }).trim().split("\n").filter(Boolean);
+        for (const gcPid of grandchildren) {
+          const gcFdDir = `/proc/${gcPid}/fd`;
+          try {
+            const fds = fs3.readdirSync(gcFdDir);
+            for (const fd of fds) {
+              try {
+                const target = fs3.readlinkSync(path2.join(gcFdDir, fd));
+                if (target.endsWith(".jsonl") && target.includes("/.claude/")) {
+                  return target;
+                }
+              } catch {
+              }
+            }
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function discoverViaCwd(paneCwd) {
+  const claudeProjectsDir = path2.join(os6.homedir(), ".claude", "projects");
+  if (!fs3.existsSync(claudeProjectsDir)) return null;
+  const resolvedCwd = fs3.realpathSync(paneCwd);
+  const expectedDirName = resolvedCwd.replace(/\//g, "-");
+  const projectDir = path2.join(claudeProjectsDir, expectedDirName);
+  if (!fs3.existsSync(projectDir)) return null;
+  try {
+    const jsonlFiles = fs3.readdirSync(projectDir).filter((f) => f.endsWith(".jsonl")).map((f) => {
+      const fullPath = path2.join(projectDir, f);
+      const stat = fs3.statSync(fullPath);
+      return { path: fullPath, mtime: stat.mtimeMs };
+    }).sort((a, b) => b.mtime - a.mtime);
+    return jsonlFiles.length > 0 ? jsonlFiles[0].path : null;
+  } catch {
+    return null;
+  }
+}
+function discoverCodexTranscript() {
+  const codexSessionsDir = path2.join(os6.homedir(), ".codex", "sessions");
+  if (!fs3.existsSync(codexSessionsDir)) return null;
+  try {
+    const dateDirs = fs3.readdirSync(codexSessionsDir).filter((d) => /^\d{4}-\d{2}-\d{2}/.test(d)).sort().reverse();
+    for (const dateDir of dateDirs.slice(0, 3)) {
+      const fullDir = path2.join(codexSessionsDir, dateDir);
+      const jsonlFiles = fs3.readdirSync(fullDir).filter((f) => f.startsWith("rollout-") && f.endsWith(".jsonl")).map((f) => {
+        const fp = path2.join(fullDir, f);
+        const stat = fs3.statSync(fp);
+        return { path: fp, mtime: stat.mtimeMs };
+      }).sort((a, b) => b.mtime - a.mtime);
+      if (jsonlFiles.length > 0) return jsonlFiles[0].path;
+    }
+  } catch {
+  }
+  return null;
+}
+function discoverTranscriptFile(sessionId, agentType) {
+  if (agentType === "Codex CLI") {
+    return discoverCodexTranscript();
+  }
+  if (sessionId.startsWith("tmux:")) {
+    const paneTarget = sessionId.slice("tmux:".length);
+    if (!paneTarget) return null;
+    const cleanEnv = { ...process.env };
+    delete cleanEnv.TMUX;
+    delete cleanEnv.TMUX_PANE;
+    try {
+      const pidStr = (0, import_child_process5.execFileSync)(
+        "tmux",
+        ["display-message", "-t", paneTarget, "-p", "#{pane_pid}"],
+        { env: cleanEnv, timeout: 5e3, encoding: "utf-8" }
+      ).trim();
+      const panePid = parseInt(pidStr, 10);
+      if (panePid > 0) {
+        const procResult = discoverViaProc(panePid);
+        if (procResult) return procResult;
+      }
+    } catch {
+    }
+    try {
+      const paneCwd = (0, import_child_process5.execFileSync)(
+        "tmux",
+        ["display-message", "-t", paneTarget, "-p", "#{pane_current_path}"],
+        { env: cleanEnv, timeout: 5e3, encoding: "utf-8" }
+      ).trim();
+      if (paneCwd) return discoverViaCwd(paneCwd);
+    } catch {
+    }
+  }
+  return null;
+}
+var MAX_PARTIAL_BUFFER = 256 * 1024;
+var MAX_REPLAY_TURNS = 200;
+var POLL_INTERVAL_MS = 800;
+var TranscriptWatcher = class {
+  filePath;
+  parser;
+  callbacks;
+  offset = 0;
+  inode = 0;
+  partialLine = "";
+  seq = 0;
+  turns = [];
+  watcher = null;
+  pollTimer = null;
+  stopped = false;
+  subscriberCount = 0;
+  constructor(filePath, parser, callbacks) {
+    this.filePath = filePath;
+    this.parser = parser;
+    this.callbacks = callbacks;
+  }
+  /** Start watching the file. Returns false if file doesn't exist. */
+  start() {
+    try {
+      const stat = fs3.statSync(this.filePath);
+      this.inode = stat.ino;
+      this.offset = stat.size;
+    } catch {
+      return false;
+    }
+    this.stopped = false;
+    this.subscriberCount++;
+    if (this.subscriberCount === 1) {
+      this.startWatching();
+    }
+    return true;
+  }
+  /** Add a subscriber (for concurrent viewers). */
+  addSubscriber() {
+    this.subscriberCount++;
+  }
+  /** Remove a subscriber. Stops watching when last subscriber leaves. */
+  removeSubscriber() {
+    this.subscriberCount = Math.max(0, this.subscriberCount - 1);
+    if (this.subscriberCount === 0) {
+      this.stop();
+    }
+  }
+  /** Stop watching. */
+  stop() {
+    this.stopped = true;
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+  }
+  /** Get accumulated turns for replay (up to MAX_REPLAY_TURNS). */
+  getReplayTurns(fromSeq) {
+    if (fromSeq !== void 0) {
+      return this.turns.filter((_, i) => i >= fromSeq).slice(-MAX_REPLAY_TURNS);
+    }
+    return this.turns.slice(-MAX_REPLAY_TURNS);
+  }
+  /** Get current sequence number. */
+  get currentSeq() {
+    return this.seq;
+  }
+  /** Read and replay the full transcript from the start of the file. */
+  replayFromStart() {
+    const savedOffset = this.offset;
+    this.offset = 0;
+    this.partialLine = "";
+    this.readNewData();
+    if (this.offset < savedOffset) {
+      this.offset = savedOffset;
+    }
+  }
+  startWatching() {
+    try {
+      this.watcher = fs3.watch(this.filePath, () => {
+        if (!this.stopped) this.readNewData();
+      });
+      this.watcher.on("error", () => {
+        this.watcher?.close();
+        this.watcher = null;
+      });
+    } catch {
+    }
+    this.pollTimer = setInterval(() => {
+      if (!this.stopped) {
+        this.checkForRotation();
+        this.readNewData();
+      }
+    }, POLL_INTERVAL_MS);
+  }
+  checkForRotation() {
+    try {
+      const stat = fs3.statSync(this.filePath);
+      if (stat.ino !== this.inode) {
+        this.inode = stat.ino;
+        this.offset = 0;
+        this.partialLine = "";
+      } else if (stat.size < this.offset) {
+        this.offset = 0;
+        this.partialLine = "";
+      }
+    } catch {
+    }
+  }
+  readNewData() {
+    let fd;
+    try {
+      fd = fs3.openSync(this.filePath, "r");
+    } catch {
+      return;
+    }
+    try {
+      const stat = fs3.fstatSync(fd);
+      if (stat.size <= this.offset) return;
+      const readSize = Math.min(stat.size - this.offset, 256 * 1024);
+      const buffer = Buffer.alloc(readSize);
+      const bytesRead = fs3.readSync(fd, buffer, 0, readSize, this.offset);
+      if (bytesRead === 0) return;
+      this.offset += bytesRead;
+      const chunk = buffer.subarray(0, bytesRead).toString("utf-8");
+      this.processChunk(chunk);
+    } finally {
+      fs3.closeSync(fd);
+    }
+  }
+  processChunk(chunk) {
+    const combined = this.partialLine + chunk;
+    const lines = combined.split("\n");
+    this.partialLine = lines.pop() ?? "";
+    if (this.partialLine.length > MAX_PARTIAL_BUFFER) {
+      this.callbacks.onError?.("Partial line buffer exceeded limit, discarding");
+      this.partialLine = "";
+    }
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      const turn = this.parser.parseLine(trimmed);
+      if (turn) {
+        this.seq++;
+        this.turns.push({
+          turnId: turn.turnId,
+          role: turn.role,
+          content: turn.content,
+          tools: turn.tools,
+          timestamp: turn.timestamp
+        });
+        if (this.turns.length > MAX_REPLAY_TURNS * 2) {
+          this.turns = this.turns.slice(-MAX_REPLAY_TURNS);
+        }
+        this.callbacks.onTurn(turn, this.seq);
+      }
+    }
+  }
+};
+var PARSERS = {
+  "Claude Code": new ClaudeCodeParser(),
+  "Codex CLI": new CodexCliParser()
+};
+function getParser(agentType) {
+  if (!agentType) return void 0;
+  return PARSERS[agentType];
+}
+var TranscriptWatcherManager = class {
+  active = /* @__PURE__ */ new Map();
+  sendFn;
+  sendSnapshotFn;
+  constructor(sendFn, sendSnapshotFn) {
+    this.sendFn = sendFn;
+    this.sendSnapshotFn = sendSnapshotFn;
+  }
+  /** Enable markdown streaming for a session. */
+  enableMarkdown(sessionId, agentType) {
+    const existing = this.active.get(sessionId);
+    if (existing) {
+      existing.watcher.addSubscriber();
+      return true;
+    }
+    const parser = getParser(agentType);
+    if (!parser) {
+      console.log(`[rAgent] No transcript parser for agent type "${agentType}"`);
+      return false;
+    }
+    const filePath = discoverTranscriptFile(sessionId, agentType);
+    if (!filePath) {
+      console.log(`[rAgent] No transcript file found for session ${sessionId}`);
+      return false;
+    }
+    console.log(`[rAgent] Watching transcript: ${filePath} (${parser.name})`);
+    const watcher = new TranscriptWatcher(filePath, parser, {
+      onTurn: (turn, seq) => {
+        this.sendFn(sessionId, turn, seq);
+      },
+      onError: (error) => {
+        console.warn(`[rAgent] Transcript watcher error (${sessionId}): ${error}`);
+      }
+    });
+    if (!watcher.start()) {
+      console.warn(`[rAgent] Failed to start watching ${filePath}`);
+      return false;
+    }
+    this.active.set(sessionId, { watcher, filePath, agentType: agentType ?? "" });
+    watcher.replayFromStart();
+    return true;
+  }
+  /** Disable markdown streaming for a session. */
+  disableMarkdown(sessionId) {
+    const session = this.active.get(sessionId);
+    if (!session) return;
+    session.watcher.removeSubscriber();
+    this.active.delete(sessionId);
+    console.log(`[rAgent] Stopped watching transcript for ${sessionId}`);
+  }
+  /** Handle sync-markdown request — send replay snapshot. */
+  handleSyncRequest(sessionId, fromSeq) {
+    const session = this.active.get(sessionId);
+    if (!session) return;
+    const turns = session.watcher.getReplayTurns(fromSeq);
+    this.sendSnapshotFn(sessionId, turns, session.watcher.currentSeq);
+  }
+  /** Stop all watchers. */
+  stopAll() {
+    for (const [sessionId, session] of this.active) {
+      session.watcher.stop();
+      console.log(`[rAgent] Stopped transcript watcher for ${sessionId}`);
+    }
+    this.active.clear();
+  }
+  /** Check if a session has an active watcher. */
+  isWatching(sessionId) {
+    return this.active.has(sessionId);
+  }
+};
+
 // src/agent.ts
 function pidFilePath(hostId) {
-  return path2.join(CONFIG_DIR, `agent-${hostId}.pid`);
+  return path3.join(CONFIG_DIR, `agent-${hostId}.pid`);
 }
 function readPidFile(filePath) {
   try {
-    const raw = fs3.readFileSync(filePath, "utf8").trim();
+    const raw = fs4.readFileSync(filePath, "utf8").trim();
     const pid = Number.parseInt(raw, 10);
     return Number.isInteger(pid) && pid > 0 ? pid : null;
   } catch {
@@ -2709,7 +3224,7 @@ function acquirePidLock(hostId) {
 Stop it first with: kill ${existingPid}  \u2014 or: ragent service stop`
     );
   }
-  fs3.writeFileSync(lockPath, `${process.pid}
+  fs4.writeFileSync(lockPath, `${process.pid}
 `, "utf8");
   return lockPath;
 }
@@ -2717,7 +3232,7 @@ function releasePidLock(lockPath) {
   try {
     const currentPid = readPidFile(lockPath);
     if (currentPid === process.pid) {
-      fs3.unlinkSync(lockPath);
+      fs4.unlinkSync(lockPath);
     }
   } catch {
   }
@@ -2726,7 +3241,7 @@ function resolveRunOptions(commandOptions) {
   const config = loadConfig();
   const portal = commandOptions.portal || config.portal || DEFAULT_PORTAL;
   const hostId = sanitizeHostId(commandOptions.id || config.hostId || inferHostId());
-  const hostName = commandOptions.name || config.hostName || os6.hostname();
+  const hostName = commandOptions.name || config.hostName || os7.hostname();
   const command = commandOptions.command || config.command || "bash";
   const agentToken = commandOptions.agentToken || config.agentToken || "";
   return { portal, hostId, hostName, command, agentToken };
@@ -2777,12 +3292,53 @@ async function runAgent(rawOptions) {
       sendToGroup(conn.activeSocket, conn.activeGroups.privateGroup, { type: "output", data: chunk, sessionId: ptySessionId });
     }
   };
+  const transcriptWatcher = new TranscriptWatcherManager(
+    (sessionId, turn, seq) => {
+      if (!conn.isReady()) return;
+      const payload = {
+        type: "markdown",
+        subtype: "delta",
+        sessionId,
+        seq,
+        turnId: turn.turnId,
+        role: turn.role,
+        content: turn.content,
+        tools: turn.tools,
+        timestamp: turn.timestamp
+      };
+      if (conn.sessionKey) {
+        const contentStr = JSON.stringify(payload);
+        const { enc, iv } = encryptPayload(contentStr, conn.sessionKey);
+        sendToGroup(conn.activeSocket, conn.activeGroups.privateGroup, { type: "markdown", enc, iv, sessionId });
+      } else {
+        sendToGroup(conn.activeSocket, conn.activeGroups.privateGroup, payload);
+      }
+    },
+    (sessionId, turns, seq) => {
+      if (!conn.isReady()) return;
+      const payload = {
+        type: "markdown",
+        subtype: "snapshot",
+        sessionId,
+        seq,
+        turns
+      };
+      if (conn.sessionKey) {
+        const contentStr = JSON.stringify(payload);
+        const { enc, iv } = encryptPayload(contentStr, conn.sessionKey);
+        sendToGroup(conn.activeSocket, conn.activeGroups.privateGroup, { type: "markdown", enc, iv, sessionId });
+      } else {
+        sendToGroup(conn.activeSocket, conn.activeGroups.privateGroup, payload);
+      }
+    }
+  );
   const shell = new ShellManager(options.command, sendOutput);
   const inventory = new InventoryManager(options);
-  const dispatcher = new ControlDispatcher(shell, sessionStreamer, inventory, conn, options);
+  const dispatcher = new ControlDispatcher(shell, sessionStreamer, inventory, conn, options, transcriptWatcher);
   shell.spawn();
   const onSignal = () => {
     dispatcher.shouldRun = false;
+    dispatcher.stopTranscriptWatchers();
     conn.cleanup({ stopStreams: true });
     shell.stop();
     releasePidLock(lockPath);
@@ -2818,7 +3374,7 @@ async function runAgent(rawOptions) {
             sendToGroup(ws, groups.privateGroup, {
               type: "register",
               hostName: options.hostName,
-              environment: os6.platform()
+              environment: os7.platform()
             });
             conn.replayBufferedOutput((chunk) => {
               sendToGroup(ws, groups.privateGroup, {
@@ -2908,6 +3464,7 @@ async function runAgent(rawOptions) {
       conn.reconnectDelay = Math.min(conn.reconnectDelay * 1.5, MAX_RECONNECT_DELAY_MS);
     }
   } finally {
+    dispatcher.stopTranscriptWatchers();
     conn.cleanup({ stopStreams: true });
     shell.stop();
     releasePidLock(lockPath);
@@ -3004,7 +3561,7 @@ function printCommandArt(title, subtitle = "remote agent control") {
 async function connectMachine(opts) {
   const portal = opts.portal || DEFAULT_PORTAL;
   const hostId = sanitizeHostId(opts.id || inferHostId());
-  const hostName = opts.name || os7.hostname();
+  const hostName = opts.name || os8.hostname();
   const command = opts.command || "bash";
   if (!opts.token) {
     throw new Error("Connection token is required.");
@@ -3078,12 +3635,12 @@ function registerRunCommand(program2) {
 }
 
 // src/commands/doctor.ts
-var os8 = __toESM(require("os"));
+var os9 = __toESM(require("os"));
 async function runDoctor(opts) {
   const options = resolveRunOptions(opts);
   const checks = [];
-  const platformOk = os8.platform() === "linux";
-  checks.push({ name: "platform", ok: platformOk, detail: os8.platform() });
+  const platformOk = os9.platform() === "linux";
+  checks.push({ name: "platform", ok: platformOk, detail: os9.platform() });
   checks.push({
     name: "node",
     ok: Number(process.versions.node.split(".")[0]) >= 20,
@@ -3258,7 +3815,7 @@ function registerServiceCommand(program2) {
 }
 
 // src/commands/uninstall.ts
-var fs4 = __toESM(require("fs"));
+var fs5 = __toESM(require("fs"));
 async function uninstallAgent(opts) {
   const config = loadConfig();
   const hostName = config.hostName || config.hostId || "this machine";
@@ -3289,8 +3846,8 @@ async function uninstallAgent(opts) {
   }
   console.log("[rAgent] Stopping and removing service...");
   await uninstallService().catch(() => void 0);
-  if (fs4.existsSync(CONFIG_DIR)) {
-    fs4.rmSync(CONFIG_DIR, { recursive: true, force: true });
+  if (fs5.existsSync(CONFIG_DIR)) {
+    fs5.rmSync(CONFIG_DIR, { recursive: true, force: true });
     console.log(`[rAgent] Removed config directory: ${CONFIG_DIR}`);
   }
   try {
@@ -3339,7 +3896,7 @@ function showStatus() {
   ragent v${CURRENT_VERSION}
 `);
   try {
-    const raw = fs5.readFileSync(CONFIG_FILE, "utf8");
+    const raw = fs6.readFileSync(CONFIG_FILE, "utf8");
     const config = JSON.parse(raw);
     if (config.portal && config.agentToken) {
       console.log(`  Status:   Connected`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ragent-cli",
-  "version": "1.4.5",
+  "version": "1.5.1",
   "description": "CLI agent for rAgent Live — browser-first terminal control plane for AI coding agents",
   "main": "dist/index.js",
   "bin": {