ragent-cli 1.8.0 → 1.9.0

package/dist/index.js

@@ -31,7 +31,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "ragent-cli",
-      version: "1.8.0",
+      version: "1.9.0",
       description: "CLI agent for rAgent Live \u2014 browser-first terminal control plane for AI coding agents",
       main: "dist/index.js",
       bin: {
@@ -43,6 +43,8 @@ var require_package = __commonJS({
         test: "vitest run",
         typecheck: "tsc --noEmit",
         lint: "eslint src/",
+        sbom: "cyclonedx-npm --omit dev --output-reproducible --validate --mc-type application -o dist/sbom.json",
+        "verify-package": "bash scripts/verify-package.sh",
         changeset: "changeset",
         "version-packages": "changeset version",
         release: "npm run build && npm run test && changeset publish"
@@ -75,7 +77,8 @@ var require_package = __commonJS({
         "linux"
       ],
       files: [
-        "dist"
+        "dist",
+        "SECURITY.md"
       ],
       dependencies: {
         "@azure/web-pubsub-client": "^1.0.2",
@@ -87,6 +90,7 @@ var require_package = __commonJS({
       devDependencies: {
         "@changesets/changelog-github": "^0.5.2",
         "@changesets/cli": "^2.29.8",
+        "@cyclonedx/cyclonedx-npm": "^4.2.1",
         "@eslint/js": "^10.0.1",
         "@types/figlet": "^1.7.0",
         "@types/node": "^20.17.0",
@@ -102,7 +106,7 @@ var require_package = __commonJS({
 });
 
 // src/index.ts
-var fs6 = __toESM(require("fs"));
+var fs7 = __toESM(require("fs"));
 var import_commander = require("commander");
 
 // src/constants.ts
@@ -231,9 +235,9 @@ async function checkForUpdate(opts = {}) {
   const config = loadConfig();
   const lastChecked = config.updateCheckedAt ? new Date(config.updateCheckedAt).getTime() : 0;
   const intervalMs = 12 * 60 * 60 * 1e3;
-  const now = Date.now();
+  const now2 = Date.now();
   let latestVersion = null;
-  if (!force && lastChecked > 0 && now - lastChecked < intervalMs) {
+  if (!force && lastChecked > 0 && now2 - lastChecked < intervalMs) {
     latestVersion = config.latestKnownVersion || null;
   } else {
     latestVersion = await fetchLatestVersion();
@@ -260,7 +264,7 @@ async function maybeWarnUpdate() {
 var os9 = __toESM(require("os"));
 
 // src/agent.ts
-var fs4 = __toESM(require("fs"));
+var fs5 = __toESM(require("fs"));
 var os8 = __toESM(require("os"));
 var path4 = __toESM(require("path"));
 var import_ws5 = __toESM(require("ws"));
@@ -269,6 +273,7 @@ var import_ws5 = __toESM(require("ws"));
 var os4 = __toESM(require("os"));
 
 // src/sessions.ts
+var fs2 = __toESM(require("fs"));
 var os3 = __toESM(require("os"));
 
 // src/system.ts
@@ -361,6 +366,95 @@ async function installTmuxInteractively() {
 
 // src/sessions.ts
 var isMac = os3.platform() === "darwin";
+function getProcessStartTime(pid) {
+  if (isMac) return null;
+  try {
+    const stat = fs2.readFileSync(`/proc/${pid}/stat`, "utf8");
+    const closeParen = stat.lastIndexOf(")");
+    if (closeParen < 0) return null;
+    const rest = stat.slice(closeParen + 2).split(" ");
+    const starttime = Number(rest[19]);
+    return Number.isFinite(starttime) && starttime >= 0 ? starttime : null;
+  } catch {
+    return null;
+  }
+}
+function collectStartTimes(pids) {
+  return pids.map((pid) => getProcessStartTime(pid) ?? 0);
+}
+async function detectVscodeEnvironment(pid) {
+  if (!isMac) {
+    try {
+      const environ = fs2.readFileSync(`/proc/${pid}/environ`, "utf8");
+      if (environ.includes("VSCODE_PID=") || environ.includes("TERM_PROGRAM=vscode")) {
+        return true;
+      }
+    } catch {
+    }
+  }
+  try {
+    const raw = await execAsync(`ps -p ${pid} -o ppid=`);
+    const ppid = Number(raw.trim());
+    if (ppid > 1) {
+      const parentInfo = await execAsync(`ps -p ${ppid} -o comm=`);
+      const parentComm = parentInfo.trim().toLowerCase();
+      if (parentComm === "code" || parentComm === "code-server") {
+        return true;
+      }
+    }
+  } catch {
+  }
+  return false;
+}
+function classifyAgent(command, options) {
+  if (command) {
+    const result = classifyFromCommand(command);
+    if (result) return result;
+  }
+  if (options?.workingDir) {
+    const dirName = options.workingDir.split("/").pop()?.toLowerCase() ?? "";
+    const cwdAgentMap = {
+      ".claude": "Claude Code",
+      "claude-code": "Claude Code",
+      ".codex": "Codex CLI",
+      ".aider": "aider"
+    };
+    const agentType = cwdAgentMap[dirName];
+    if (agentType) {
+      return { agentType, confidence: 0.5 };
+    }
+  }
+  if (options?.parentCommand) {
+    const parentAgent = detectAgentType(options.parentCommand);
+    if (parentAgent) {
+      return { agentType: parentAgent, confidence: 0.6 };
+    }
+  }
+  return null;
+}
+function classifyFromCommand(command) {
+  const agentType = detectAgentType(command);
+  if (!agentType) return null;
+  const cmd = command.toLowerCase();
+  const parts = cmd.split(/\s+/);
+  const binary = parts[0]?.split("/").pop() ?? "";
+  const exactMatches = {
+    "claude": "Claude Code",
+    "claude-code": "Claude Code",
+    "codex": "Codex CLI",
+    "aider": "aider",
+    "cursor": "Cursor",
+    "windsurf": "Windsurf",
+    "gemini": "Gemini CLI",
+    "amazon-q": "Amazon Q",
+    "amazon_q": "Amazon Q",
+    "copilot": "Copilot CLI"
+  };
+  if (exactMatches[binary] === agentType) {
+    return { agentType, confidence: 1 };
+  }
+  return { agentType, confidence: 0.7 };
+}
 async function collectTmuxSessions() {
   try {
     await execAsync("tmux -V");
@@ -399,21 +493,26 @@ async function collectTmuxSessions() {
       const pids = [];
       const pid = Number(panePid);
       if (pid > 0) pids.push(pid);
+      const classification = classifyAgent(command, { workingDir: paneCurrentPath });
+      const vscodeDetected = pid > 0 ? await detectVscodeEnvironment(pid) : false;
       results.push({
         id,
         type: "tmux",
         name: `${sessionName}:${windowIndex}.${paneIndex}`,
         status: activeFlag === "1" ? "active" : "detached",
         command,
-        agentType: detectAgentType(command),
+        agentType: classification?.agentType,
+        agentConfidence: classification?.confidence,
         runningCommand: command || void 0,
         windowLayout: windowLayout || void 0,
         workingDir: paneCurrentPath || void 0,
+        environment: vscodeDetected ? "vscode" : void 0,
         windowName: windowName || void 0,
         paneTitle: paneTitle || void 0,
         isZoomed: windowFlags?.includes("Z") ?? false,
         lastActivityAt,
         pids,
+        startTimes: pids.length > 0 ? collectStartTimes(pids) : void 0,
         sessionGroup: sessionGroup || void 0
       });
     }
@@ -440,15 +539,19 @@ async function collectScreenSessions() {
       const childInfo = await getChildAgentInfo(pid);
       if (!childInfo) continue;
       const id = `screen:${sessionName}:${screenPid}`;
+      const allPids = [pid, ...childInfo.childPids];
+      const classification = classifyAgent(childInfo.command);
       sessions.push({
         id,
         type: "screen",
         name: `${sessionName}`,
         status: state === "Attached" ? "active" : "detached",
         command: childInfo.command,
-        agentType: childInfo.agentType,
+        agentType: classification?.agentType ?? childInfo.agentType,
+        agentConfidence: classification?.confidence,
         lastActivityAt: (/* @__PURE__ */ new Date()).toISOString(),
-        pids: [pid, ...childInfo.childPids]
+        pids: allPids,
+        startTimes: collectStartTimes(allPids)
       });
     }
     return sessions;
@@ -488,15 +591,19 @@ async function collectZellijSessions() {
       }
       if (!foundAgent) continue;
       const id = `zellij:${sessionName}`;
+      const allPids = [...serverPids, ...allChildPids];
+      const classification = classifyAgent(foundAgent.command);
       sessions.push({
         id,
         type: "zellij",
         name: sessionName,
         status: "active",
         command: foundAgent.command,
-        agentType: foundAgent.agentType,
+        agentType: classification?.agentType ?? foundAgent.agentType,
+        agentConfidence: classification?.confidence,
         lastActivityAt: (/* @__PURE__ */ new Date()).toISOString(),
-        pids: [...serverPids, ...allChildPids]
+        pids: allPids,
+        startTimes: collectStartTimes(allPids)
       });
     }
     return sessions;
@@ -539,14 +646,15 @@ async function collectBareAgentProcesses(excludePids) {
       const stat = parts[2];
       const args = parts.slice(4).join(" ");
       if (stat.startsWith("Z")) continue;
-      const agentType = detectAgentType(args);
-      if (!agentType) continue;
+      const workingDir = await getProcessWorkingDir(pid);
+      const classification = classifyAgent(args, { workingDir: workingDir ?? void 0 });
+      if (!classification) continue;
       if (excludePids?.has(pid)) continue;
       if (seen.has(pid)) continue;
       seen.add(pid);
-      const workingDir = await getProcessWorkingDir(pid);
       const dirName = workingDir ? workingDir.split("/").pop() : null;
-      const displayName = dirName && dirName !== "/" && dirName !== "" ? `${agentType} (${dirName})` : `${agentType} (pid ${pid})`;
+      const displayName = dirName && dirName !== "/" && dirName !== "" ? `${classification.agentType} (${dirName})` : `${classification.agentType} (pid ${pid})`;
+      const vscodeDetected = await detectVscodeEnvironment(pid);
       const id = `process:${pid}`;
       sessions.push({
         id,
@@ -554,10 +662,13 @@ async function collectBareAgentProcesses(excludePids) {
         name: displayName,
         status: "active",
         command: args,
-        agentType,
+        agentType: classification.agentType,
+        agentConfidence: classification.confidence,
         workingDir: workingDir || void 0,
+        environment: vscodeDetected ? "vscode" : void 0,
         lastActivityAt: (/* @__PURE__ */ new Date()).toISOString(),
-        pids: [pid]
+        pids: [pid],
+        startTimes: collectStartTimes([pid])
       });
     }
     return sessions;
@@ -590,13 +701,15 @@ async function collectSessionInventory(hostId, command) {
     }
   }
   const bare = await collectBareAgentProcesses(multiplexerPids);
+  const ptyClassification = classifyAgent(command);
   const ptySession = {
     id: `pty:${hostId}`,
     type: "pty",
     name: command,
     status: "active",
     command,
-    agentType: detectAgentType(command),
+    agentType: ptyClassification?.agentType,
+    agentConfidence: ptyClassification?.confidence,
     lastActivityAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   return [...tmux, ...screen, ...zellij, ...bare, ptySession];
@@ -2147,7 +2260,7 @@ var import_ws4 = __toESM(require("ws"));
 
 // src/service.ts
 var import_child_process2 = require("child_process");
-var fs2 = __toESM(require("fs"));
+var fs3 = __toESM(require("fs"));
 var os6 = __toESM(require("os"));
 var path2 = __toESM(require("path"));
 function assertConfiguredAgentToken() {
@@ -2161,8 +2274,8 @@ function getConfiguredServiceBackend() {
   if (config.serviceBackend === "systemd" || config.serviceBackend === "pidfile") {
     return config.serviceBackend;
   }
-  if (fs2.existsSync(SERVICE_FILE)) return "systemd";
-  if (fs2.existsSync(FALLBACK_PID_FILE)) return "pidfile";
+  if (fs3.existsSync(SERVICE_FILE)) return "systemd";
+  if (fs3.existsSync(FALLBACK_PID_FILE)) return "pidfile";
   return null;
 }
 async function canUseSystemdUser() {
@@ -2205,8 +2318,8 @@ WantedBy=default.target
 }
 async function installSystemdService(opts = {}) {
   assertConfiguredAgentToken();
-  fs2.mkdirSync(SERVICE_DIR, { recursive: true });
-  fs2.writeFileSync(SERVICE_FILE, buildSystemdUnit(), "utf8");
+  fs3.mkdirSync(SERVICE_DIR, { recursive: true });
+  fs3.writeFileSync(SERVICE_FILE, buildSystemdUnit(), "utf8");
   await runSystemctlUser(["daemon-reload"]);
   if (opts.enable !== false) {
     await runSystemctlUser(["enable", SERVICE_NAME]);
@@ -2219,7 +2332,7 @@ async function installSystemdService(opts = {}) {
 }
 function readFallbackPid() {
   try {
-    const raw = fs2.readFileSync(FALLBACK_PID_FILE, "utf8").trim();
+    const raw = fs3.readFileSync(FALLBACK_PID_FILE, "utf8").trim();
     const pid = Number.parseInt(raw, 10);
     return Number.isInteger(pid) ? pid : null;
   } catch {
@@ -2238,14 +2351,14 @@ function isProcessRunning(pid) {
 var LOG_ROTATION_MAX_BYTES = 10 * 1024 * 1024;
 function rotateLogIfNeeded() {
   try {
-    const stat = fs2.statSync(FALLBACK_LOG_FILE);
+    const stat = fs3.statSync(FALLBACK_LOG_FILE);
     if (stat.size > LOG_ROTATION_MAX_BYTES) {
       const rotated = `${FALLBACK_LOG_FILE}.1`;
       try {
-        fs2.unlinkSync(rotated);
+        fs3.unlinkSync(rotated);
       } catch {
       }
-      fs2.renameSync(FALLBACK_LOG_FILE, rotated);
+      fs3.renameSync(FALLBACK_LOG_FILE, rotated);
     }
   } catch {
   }
@@ -2259,7 +2372,7 @@ async function startPidfileService() {
   }
   ensureConfigDir();
   rotateLogIfNeeded();
-  const logFd = fs2.openSync(FALLBACK_LOG_FILE, "a");
+  const logFd = fs3.openSync(FALLBACK_LOG_FILE, "a");
   const child = (0, import_child_process2.spawn)(process.execPath, [__filename, "run"], {
     detached: true,
     stdio: ["ignore", logFd, logFd],
@@ -2267,8 +2380,8 @@ async function startPidfileService() {
     env: process.env
   });
   child.unref();
-  fs2.closeSync(logFd);
-  fs2.writeFileSync(FALLBACK_PID_FILE, `${child.pid}
+  fs3.closeSync(logFd);
+  fs3.writeFileSync(FALLBACK_PID_FILE, `${child.pid}
 `, "utf8");
   saveConfigPatch({ serviceBackend: "pidfile" });
   console.log(`[rAgent] Started fallback background service (pid ${child.pid})`);
@@ -2278,7 +2391,7 @@ async function stopPidfileService() {
   const pid = readFallbackPid();
   if (!pid || !isProcessRunning(pid)) {
     try {
-      fs2.unlinkSync(FALLBACK_PID_FILE);
+      fs3.unlinkSync(FALLBACK_PID_FILE);
     } catch {
     }
     console.log("[rAgent] Service is not running.");
@@ -2293,7 +2406,7 @@ async function stopPidfileService() {
     process.kill(pid, "SIGKILL");
   }
   try {
-    fs2.unlinkSync(FALLBACK_PID_FILE);
+    fs3.unlinkSync(FALLBACK_PID_FILE);
   } catch {
   }
   console.log(`[rAgent] Stopped fallback background service (pid ${pid})`);
@@ -2338,12 +2451,12 @@ async function stopService() {
 }
 function killStaleAgentProcesses() {
   try {
-    const entries = fs2.readdirSync(CONFIG_DIR);
+    const entries = fs3.readdirSync(CONFIG_DIR);
     for (const entry of entries) {
       if (!entry.startsWith("agent-") || !entry.endsWith(".pid")) continue;
       const pidPath = path2.join(CONFIG_DIR, entry);
       try {
-        const raw = fs2.readFileSync(pidPath, "utf8").trim();
+        const raw = fs3.readFileSync(pidPath, "utf8").trim();
         const pid = Number.parseInt(raw, 10);
         if (!Number.isInteger(pid) || pid <= 0) continue;
         try {
@@ -2352,7 +2465,7 @@ function killStaleAgentProcesses() {
           console.log(`[rAgent] Stopped stale agent process (pid ${pid})`);
         } catch {
         }
-        fs2.unlinkSync(pidPath);
+        fs3.unlinkSync(pidPath);
       } catch {
       }
     }
@@ -2415,7 +2528,7 @@ async function printServiceLogs(opts) {
     process.stdout.write(output);
     return;
   }
-  if (!fs2.existsSync(FALLBACK_LOG_FILE)) {
+  if (!fs3.existsSync(FALLBACK_LOG_FILE)) {
     console.log(`[rAgent] No log file found at ${FALLBACK_LOG_FILE}`);
     return;
   }
@@ -2428,7 +2541,7 @@ async function printServiceLogs(opts) {
     });
     return;
   }
-  const content = fs2.readFileSync(FALLBACK_LOG_FILE, "utf8");
+  const content = fs3.readFileSync(FALLBACK_LOG_FILE, "utf8");
   const tail = content.split("\n").slice(-lines).join("\n");
   process.stdout.write(`${tail}${tail.endsWith("\n") ? "" : "\n"}`);
 }
@@ -2438,7 +2551,7 @@ async function uninstallService() {
     await runSystemctlUser(["stop", SERVICE_NAME]).catch(() => void 0);
     await runSystemctlUser(["disable", SERVICE_NAME]).catch(() => void 0);
     try {
-      fs2.unlinkSync(SERVICE_FILE);
+      fs3.unlinkSync(SERVICE_FILE);
     } catch {
     }
     await runSystemctlUser(["daemon-reload"]).catch(() => void 0);
@@ -2462,7 +2575,7 @@ function requestStopSelfService() {
   }
   if (backend === "pidfile") {
     try {
-      fs2.unlinkSync(FALLBACK_PID_FILE);
+      fs3.unlinkSync(FALLBACK_PID_FILE);
     } catch {
     }
   }
@@ -2681,6 +2794,7 @@ var ControlDispatcher = class {
   connection;
   transcriptWatcher;
   options;
+  _approvalEnforcer = null;
   /** Set to true when a reconnect was requested (restart-agent, disconnect). */
   reconnectRequested = false;
   /** Set to false to stop the agent. */
@@ -2697,6 +2811,25 @@ var ControlDispatcher = class {
   updateOptions(options) {
     this.options = options;
   }
+  /** Get or lazily create the approval enforcer. Returns null if no session key. */
+  get approvalEnforcer() {
+    return this._approvalEnforcer;
+  }
+  /** Set the approval enforcer (called when connection is established with a session key). */
+  setApprovalEnforcer(enforcer) {
+    this._approvalEnforcer?.stopAll();
+    this._approvalEnforcer = enforcer;
+  }
+  /**
+   * Handle an incoming approval response message from the portal.
+   * Routes `subtype: "response"` to the ApprovalEnforcer.
+   */
+  handleApprovalMessage(payload) {
+    if (payload.subtype !== "response" || !this._approvalEnforcer) return;
+    const response = payload.response;
+    if (!response || typeof response !== "object" || Array.isArray(response)) return;
+    this._approvalEnforcer.handleResponse(response);
+  }
   /**
    * Verify HMAC-SHA256 signature on a control message.
    * Returns true if valid or no session key is available (backward compat).
@@ -3050,11 +3183,788 @@ function validateProvisionRequest(payload) {
   };
 }
 
+// src/approval-policy.ts
+var import_node_crypto2 = require("crypto");
+function hasToken(cmd, token) {
+  const lower = cmd.toLowerCase();
+  const t = token.toLowerCase();
+  const idx = lower.indexOf(t);
+  if (idx === -1) return false;
+  const before = idx > 0 ? lower[idx - 1] : " ";
+  const after = idx + t.length < lower.length ? lower[idx + t.length] : " ";
+  const boundaryChars = " 	\n|;&(){}\"'`.";
+  return boundaryChars.includes(before) && (boundaryChars.includes(after) || after === void 0);
+}
+function has(cmd, substr) {
+  return cmd.toLowerCase().includes(substr.toLowerCase());
+}
+var MATCHERS = [
+  // ── Critical ──────────────────────────────────────────────────────
+  {
+    test: (cmd) => {
+      if (!has(cmd, "rm ")) return false;
+      const lower = cmd.toLowerCase();
+      const rmIdx = lower.indexOf("rm ");
+      const afterRm = lower.slice(rmIdx + 3);
+      if (!afterRm.includes("r")) return false;
+      return has(afterRm, " /") || has(afterRm, " ~/") || has(afterRm, " ~") || has(afterRm, "$home") || has(afterRm, " /*");
+    },
+    action: "file-delete",
+    severity: "critical",
+    description: "Recursive deletion of root, home, or wildcard path"
+  },
+  {
+    test: (cmd) => has(cmd, "> /dev/sd") || has(cmd, ">/dev/sd"),
+    action: "destructive-command",
+    severity: "critical",
+    description: "Direct write to block device"
+  },
+  {
+    test: (cmd) => {
+      const lower = cmd.toLowerCase();
+      return has(lower, "drop table") || has(lower, "drop database") || has(lower, "drop schema");
+    },
+    action: "database-drop",
+    severity: "critical",
+    description: "SQL DROP TABLE/DATABASE/SCHEMA"
+  },
+  {
+    test: (cmd) => hasToken(cmd, "mkfs"),
+    action: "destructive-command",
+    severity: "critical",
+    description: "Filesystem format command"
+  },
+  {
+    test: (cmd) => has(cmd, "dd ") && has(cmd, "if="),
+    action: "destructive-command",
+    severity: "critical",
+    description: "Low-level disk copy (dd)"
+  },
+  // ── High ──────────────────────────────────────────────────────────
+  {
+    test: (cmd) => {
+      if (!has(cmd, "git ") || !has(cmd, "push")) return false;
+      return has(cmd, "--force") || has(cmd, " -f") || has(cmd, " -f ");
+    },
+    action: "git-force-push",
+    severity: "high",
+    description: "Git force push"
+  },
+  {
+    test: (cmd) => has(cmd, "git ") && has(cmd, "reset") && has(cmd, "--hard"),
+    action: "git-reset-hard",
+    severity: "high",
+    description: "Git hard reset"
+  },
+  // ── Medium ────────────────────────────────────────────────────────
+  {
+    test: (cmd) => has(cmd, "kill ") && has(cmd, "-9"),
+    action: "process-kill",
+    severity: "medium",
+    description: "Forceful process kill (SIGKILL)"
+  },
+  {
+    test: (cmd) => hasToken(cmd, "killall"),
+    action: "process-kill",
+    severity: "medium",
+    description: "Kill processes by name"
+  },
+  {
+    test: (cmd) => has(cmd, "chmod ") && has(cmd, "777"),
+    action: "destructive-command",
+    severity: "medium",
+    description: "World-writable permission change"
+  }
+];
+var DEFAULT_APPROVAL_POLICY = {
+  patterns: MATCHERS.map((m) => ({
+    match: "",
+    // Not used — string matching via MATCHERS
+    action: m.action,
+    severity: m.severity,
+    description: m.description
+  })),
+  defaultTimeoutMs: 12e4,
+  fallbackOnDisconnect: "deny"
+};
+function matchPolicy(command, _policy = DEFAULT_APPROVAL_POLICY, hostId = "", sessionId = "") {
+  for (const matcher of MATCHERS) {
+    if (matcher.test(command)) {
+      return {
+        requestId: (0, import_node_crypto2.randomUUID)(),
+        hostId,
+        sessionId,
+        action: matcher.action,
+        severity: matcher.severity,
+        description: matcher.description,
+        command,
+        timeoutMs: _policy.defaultTimeoutMs,
+        requestedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+  }
+  return null;
+}
+
+// src/approval-crypto.ts
+var crypto3 = __toESM(require("crypto"));
+function canonicalise(grant) {
+  return JSON.stringify(grant, Object.keys(grant).sort());
+}
+function signApprovalGrant(grant, secret) {
+  const payload = canonicalise(grant);
+  return crypto3.createHmac("sha256", secret).update(payload).digest("hex");
+}
+function verifyApprovalGrant(grant, secret) {
+  if (!grant.jti || typeof grant.jti !== "string") return false;
+  if (!grant.signature || typeof grant.signature !== "string") return false;
+  if (!/^[0-9a-f]{64}$/i.test(grant.signature)) return false;
+  if (isGrantExpired(grant)) return false;
+  const { signature: _sig, ...unsigned } = grant;
+  const expected = signApprovalGrant(unsigned, secret);
+  return crypto3.timingSafeEqual(
+    Buffer.from(grant.signature, "hex"),
+    Buffer.from(expected, "hex")
+  );
+}
+function isGrantExpired(grant) {
+  const expiry = new Date(grant.expiresAt).getTime();
+  if (Number.isNaN(expiry)) return true;
+  return Date.now() > expiry;
+}
+
+// src/approval-enforcer.ts
+var ApprovalEnforcer = class {
+  policy;
+  secret;
+  pendingRequests = /* @__PURE__ */ new Map();
+  /** Map of JTI → expiry timestamp for one-time grant enforcement. */
+  usedGrantJtis = /* @__PURE__ */ new Map();
+  sendRequestFn;
+  constructor(options) {
+    this.policy = options.policy ?? DEFAULT_APPROVAL_POLICY;
+    this.secret = options.secret;
+    this.sendRequestFn = options.sendRequest;
+  }
+  // -----------------------------------------------------------------------
+  // Public API
+  // -----------------------------------------------------------------------
+  /**
+   * Check a command against the policy. If it matches, emit an approval
+   * request and return a promise that resolves when approved / denied /
+   * timed out. Returns `null` if no policy match (command is safe).
+   */
+  async checkCommand(command, hostId, sessionId) {
+    const request = matchPolicy(command, this.policy, hostId, sessionId);
+    if (!request) return null;
+    console.log(
+      `[rAgent] Approval: ${request.action} (${request.severity}) \u2014 pending [${request.requestId}]`
+    );
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(request.requestId);
+        const response = { type: "timeout" };
+        console.log(
+          `[rAgent] Approval: ${request.action} (${request.severity}) \u2014 timeout [${request.requestId}]`
+        );
+        resolve(response);
+      }, request.timeoutMs);
+      this.pendingRequests.set(request.requestId, { request, resolve, timer });
+      this.sendRequestFn(request);
+    });
+  }
+  /**
+   * Handle an incoming approval response from the portal.
+   * Routes to the pending promise for the corresponding request ID.
+   */
+  handleResponse(response) {
+    const requestId = response.type === "approved" ? response.grant.requestId : response.type === "denied" ? response.denial.requestId : null;
+    if (!requestId) return;
+    const pending = this.pendingRequests.get(requestId);
+    if (!pending) {
+      console.warn(
+        `[rAgent] Approval: received response for unknown request [${requestId}]`
+      );
+      return;
+    }
+    if (response.type === "approved") {
+      if (!this.acceptGrant(response.grant)) {
+        console.log(
+          `[rAgent] Approval: ${pending.request.action} (${pending.request.severity}) \u2014 rejected (invalid grant) [${requestId}]`
+        );
+        clearTimeout(pending.timer);
+        this.pendingRequests.delete(requestId);
+        pending.resolve({ type: "denied", denial: { requestId, deniedBy: "system", deniedAt: (/* @__PURE__ */ new Date()).toISOString(), reason: "Invalid or expired grant" } });
+        return;
+      }
+      console.log(
+        `[rAgent] Approval: ${pending.request.action} (${pending.request.severity}) \u2014 approved [${requestId}]`
+      );
+    } else if (response.type === "denied") {
+      const reason = response.denial.reason ? ` (${response.denial.reason})` : "";
+      console.log(
+        `[rAgent] Approval: ${pending.request.action} (${pending.request.severity}) \u2014 denied${reason} [${requestId}]`
+      );
+    }
+    clearTimeout(pending.timer);
+    this.pendingRequests.delete(requestId);
+    pending.resolve(response);
+  }
+  /**
+   * Clean up expired pending requests and stale used-JTI entries.
+   *
+   * Call periodically (e.g. every 5 minutes) to bound memory usage of the
+   * `usedGrantJtis` set. In practice, JTIs are only relevant for the
+   * lifetime of the grant (a few minutes), so clearing the set periodically
+   * is safe.
+   */
+  cleanup() {
+    const now2 = Date.now();
+    for (const [id, entry] of this.pendingRequests) {
+      const requestedAt = new Date(entry.request.requestedAt).getTime();
+      if (!Number.isNaN(requestedAt) && now2 - requestedAt > entry.request.timeoutMs * 2) {
+        clearTimeout(entry.timer);
+        this.pendingRequests.delete(id);
+        entry.resolve({ type: "timeout" });
+      }
+    }
+    const jtiNow = Date.now();
+    for (const [jti, expiresAt] of this.usedGrantJtis) {
+      if (expiresAt < jtiNow) this.usedGrantJtis.delete(jti);
+    }
+  }
+  /**
+   * Stop all pending requests, resolving each with a timeout response.
+   */
+  stopAll() {
+    for (const [id, entry] of this.pendingRequests) {
+      clearTimeout(entry.timer);
+      this.pendingRequests.delete(id);
+      console.log(
+        `[rAgent] Approval: ${entry.request.action} (${entry.request.severity}) \u2014 stopped [${id}]`
+      );
+      entry.resolve({ type: "timeout" });
+    }
+  }
+  /** Number of pending requests (exposed for testing). */
+  get pendingCount() {
+    return this.pendingRequests.size;
+  }
+  // -----------------------------------------------------------------------
+  // Private
+  // -----------------------------------------------------------------------
+  /**
+   * Verify and accept a grant. Returns `true` if the grant is valid,
+   * correctly signed, not expired, and its JTI has not been seen before.
+   */
+  acceptGrant(grant) {
+    if (!verifyApprovalGrant(grant, this.secret)) return false;
+    if (this.usedGrantJtis.has(grant.jti)) return false;
+    const expiresAt = new Date(grant.expiresAt).getTime();
+    this.usedGrantJtis.set(grant.jti, Number.isNaN(expiresAt) ? Date.now() + 6e5 : expiresAt);
+    return true;
+  }
+};
+
 // src/transcript-watcher.ts
-var fs3 = __toESM(require("fs"));
+var fs4 = __toESM(require("fs"));
 var path3 = __toESM(require("path"));
 var os7 = __toESM(require("os"));
 var import_child_process5 = require("child_process");
+
+// src/transcript-parser-v2.ts
+var blockCounter = 0;
+function genBlockId(prefix) {
+  return `${prefix}-${Date.now()}-${(++blockCounter).toString(36)}`;
+}
+function now() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function makeTextBlock(blockId, text, isComplete) {
+  const ts = now();
+  return {
+    blockId,
+    kind: "text",
+    format: "markdown",
+    text,
+    isComplete,
+    createdAt: ts,
+    updatedAt: ts
+  };
+}
+function makeToolBlock(blockId, callId, toolName, state, input, isComplete = false) {
+  const ts = now();
+  return {
+    blockId,
+    kind: "tool",
+    callId,
+    toolName,
+    state,
+    input,
+    isComplete,
+    createdAt: ts,
+    updatedAt: ts
+  };
+}
+var ClaudeCodeParserV2 = class {
+  name = "claude-code-v2";
+  /**
+   * Maps tool_use id → { blockId, toolName } for correlating results.
+   * The blockId is the V2 block key so we can update the same ToolBlock
+   * when the tool_result arrives in a later user message.
+   */
+  pendingTools = /* @__PURE__ */ new Map();
+  parseLine(line) {
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      return [];
+    }
+    if (!obj.message?.content) return [];
+    if (obj.type === "assistant") {
+      return this.parseAssistant(obj);
+    }
+    if (obj.type === "user") {
+      return this.parseUserToolResults(obj);
+    }
+    return [];
+  }
+  parseAssistant(obj) {
+    const content = obj.message.content;
+    const ops = [];
+    const turnId = obj.uuid ?? `turn-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const timestamp = obj.timestamp ?? now();
+    ops.push({
+      op: "upsert_turn",
+      turn: {
+        turnId,
+        role: "assistant",
+        startedAt: timestamp,
+        updatedAt: timestamp,
+        isComplete: false
+      }
+    });
+    for (const block of content) {
+      if (block.type === "text" && typeof block.text === "string") {
+        const text = block.text.trim();
+        if (!text) continue;
+        const blockId = genBlockId("txt");
+        ops.push({
+          op: "insert_block",
+          turnId,
+          block: makeTextBlock(blockId, text, true)
+        });
+      } else if (block.type === "tool_use" && block.name) {
+        const callId = block.id ?? genBlockId("call");
+        const blockId = genBlockId("tool");
+        this.pendingTools.set(callId, { blockId, toolName: block.name });
+        ops.push({
+          op: "insert_block",
+          turnId,
+          block: makeToolBlock(
+            blockId,
+            callId,
+            block.name,
+            "running",
+            block.input
+          )
+        });
+      }
+    }
+    ops.push({
+      op: "complete_turn",
+      turnId,
+      endedAt: timestamp,
+      updatedAt: timestamp
+    });
+    if (this.pendingTools.size > 500) {
+      const keys = [...this.pendingTools.keys()];
+      for (let i = 0; i < 250; i++) {
+        this.pendingTools.delete(keys[i]);
+      }
+    }
+    return ops;
+  }
+  parseUserToolResults(obj) {
+    const content = obj.message.content;
+    const ops = [];
+    const turnId = obj.uuid ?? `result-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const timestamp = obj.timestamp ?? now();
+    const userTextParts = [];
+    for (const block of content) {
+      if (block.type === "tool_result") {
+        const callId = block.tool_use_id;
+        const pending = callId ? this.pendingTools.get(callId) : void 0;
+        const resultText = this.extractToolResultText(block);
+        if (pending) {
+          this.pendingTools.delete(callId);
+          const newState = block.is_error ? "error" : "completed";
+          if (resultText) {
+            ops.push({
+              op: "append_tool_output",
+              turnId: "",
+              // Will be resolved by the reducer (block lookup by blockId)
+              blockId: pending.blockId,
+              text: resultText
+            });
+          }
+          ops.push({
+            op: "set_tool_state",
+            turnId: "",
+            blockId: pending.blockId,
+            state: newState,
+            errorText: block.is_error ? resultText || "Tool error" : void 0,
+            isComplete: true
+          });
+          ops.push({
+            op: "complete_block",
+            turnId: "",
+            blockId: pending.blockId,
+            updatedAt: timestamp
+          });
+        } else {
+          if (!ops.some((o) => o.op === "upsert_turn")) {
+            ops.unshift({
+              op: "upsert_turn",
+              turn: {
+                turnId,
+                role: "user",
+                startedAt: timestamp,
+                updatedAt: timestamp,
+                isComplete: false
+              }
+            });
+          }
+          const blockId = genBlockId("tool");
+          ops.push({
+            op: "insert_block",
+            turnId,
+            block: makeToolBlock(
+              blockId,
+              callId ?? genBlockId("call"),
+              "Tool",
+              block.is_error ? "error" : "completed",
+              void 0,
+              true
+            )
+          });
+          if (resultText) {
+            ops.push({
+              op: "append_tool_output",
+              turnId,
+              blockId,
+              text: resultText
+            });
+          }
+        }
+      } else if (block.type === "text" && typeof block.text === "string") {
+        const t = block.text.trim();
+        if (t && !t.startsWith("<") && !t.startsWith("[Request interrupted")) {
+          userTextParts.push(t);
+        }
+      }
+    }
+    if (userTextParts.length > 0) {
+      if (!ops.some((o) => o.op === "upsert_turn")) {
+        ops.unshift({
+          op: "upsert_turn",
+          turn: {
+            turnId,
+            role: "user",
+            startedAt: timestamp,
+            updatedAt: timestamp,
+            isComplete: false
+          }
+        });
+      }
+      const blockId = genBlockId("txt");
+      ops.push({
+        op: "insert_block",
+        turnId,
+        block: makeTextBlock(blockId, userTextParts.join("\n"), true)
+      });
+    }
+    if (ops.some((o) => o.op === "upsert_turn")) {
+      ops.push({
+        op: "complete_turn",
+        turnId,
+        endedAt: timestamp,
+        updatedAt: timestamp
+      });
+    }
+    return ops;
+  }
+  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 CodexCliParserV2 = class {
+  name = "codex-cli-v2";
+  parseLine(line) {
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      return [];
+    }
+    const item = obj.response_item;
+    if (!item) return [];
+    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 [];
+      const turnId = item.id ?? `codex-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+      const timestamp = obj.timestamp ?? now();
+      const blockId = genBlockId("txt");
+      return [
+        {
+          op: "upsert_turn",
+          turn: {
+            turnId,
+            role: "assistant",
+            startedAt: timestamp,
+            updatedAt: timestamp,
+            isComplete: false
+          }
+        },
+        {
+          op: "insert_block",
+          turnId,
+          block: makeTextBlock(blockId, text, true)
+        },
+        {
+          op: "complete_turn",
+          turnId,
+          endedAt: timestamp,
+          updatedAt: timestamp
+        }
+      ];
+    }
+    return [];
+  }
+};
+var V2_FACTORIES = {
+  "Claude Code": () => new ClaudeCodeParserV2(),
+  "Codex CLI": () => new CodexCliParserV2()
+};
+function getParserV2(agentType) {
+  if (!agentType) return void 0;
+  const factory = V2_FACTORIES[agentType];
+  return factory ? factory() : void 0;
+}
+
+// src/transcript-protocol.ts
+var TRANSCRIPT_SCHEMA_VERSION = 2;
+
+// src/transcript-reducer.ts
+function createEmptySnapshot(sessionId) {
+  return {
+    schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
+    sessionId,
+    turnOrder: [],
+    turns: {}
+  };
+}
+function applyOps(state, ops) {
+  const turns = { ...state.turns };
+  const turnOrder = [...state.turnOrder];
+  for (const op of ops) {
+    switch (op.op) {
+      case "upsert_turn": {
+        const { turn } = op;
+        const existing = turns[turn.turnId];
+        if (existing) {
+          turns[turn.turnId] = {
+            ...existing,
+            ...turn,
+            blockOrder: turn.blockOrder ?? existing.blockOrder,
+            blocks: turn.blocks ? { ...existing.blocks, ...turn.blocks } : existing.blocks
+          };
+        } else {
+          turns[turn.turnId] = {
+            ...turn,
+            blockOrder: turn.blockOrder ?? [],
+            blocks: turn.blocks ?? {}
+          };
+          if (!turnOrder.includes(turn.turnId)) {
+            turnOrder.push(turn.turnId);
+          }
+        }
+        break;
+      }
+      case "insert_block": {
+        const turn = turns[op.turnId];
+        if (!turn) break;
+        const newBlocks = { ...turn.blocks, [op.block.blockId]: op.block };
+        const newBlockOrder = [...turn.blockOrder];
+        if (op.afterBlockId) {
+          const idx = newBlockOrder.indexOf(op.afterBlockId);
+          if (idx >= 0) {
+            newBlockOrder.splice(idx + 1, 0, op.block.blockId);
+          } else {
+            newBlockOrder.push(op.block.blockId);
+          }
+        } else {
+          newBlockOrder.push(op.block.blockId);
+        }
+        turns[op.turnId] = {
+          ...turn,
+          blocks: newBlocks,
+          blockOrder: newBlockOrder,
+          updatedAt: op.block.updatedAt
+        };
+        break;
+      }
+      case "replace_block": {
+        const turn = turns[op.turnId];
+        if (!turn || !turn.blocks[op.block.blockId]) break;
+        turns[op.turnId] = {
+          ...turn,
+          blocks: { ...turn.blocks, [op.block.blockId]: op.block },
+          updatedAt: op.block.updatedAt
+        };
+        break;
+      }
+      case "append_text": {
+        const block = findBlock(turns, op.turnId, op.blockId);
+        if (!block) break;
+        if (block.kind === "text" || block.kind === "reasoning") {
+          const updated = {
+            ...block,
+            text: block.text + op.text,
+            updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          setBlock(turns, op.turnId, op.blockId, updated);
+        }
+        break;
+      }
+      case "append_tool_output": {
+        const block = findBlock(turns, op.turnId, op.blockId);
+        if (!block || block.kind !== "tool") {
+          const found = findBlockAcrossTurns(turns, op.blockId);
+          if (found && found.block.kind === "tool") {
+            const updated2 = {
+              ...found.block,
+              outputText: (found.block.outputText ?? "") + op.text,
+              updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+            };
+            setBlock(turns, found.turnId, op.blockId, updated2);
+          }
+          break;
+        }
+        const updated = {
+          ...block,
+          outputText: (block.outputText ?? "") + op.text,
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        setBlock(turns, op.turnId, op.blockId, updated);
+        break;
+      }
+      case "set_tool_state": {
+        let block = findBlock(turns, op.turnId, op.blockId);
+        let resolvedTurnId = op.turnId;
+        if (!block || block.kind !== "tool") {
+          const found = findBlockAcrossTurns(turns, op.blockId);
+          if (found && found.block.kind === "tool") {
+            block = found.block;
+            resolvedTurnId = found.turnId;
+          } else {
+            break;
+          }
+        }
+        const updated = {
+          ...block,
+          state: op.state,
+          ...op.exitCode !== void 0 && { exitCode: op.exitCode },
+          ...op.errorText !== void 0 && { errorText: op.errorText },
+          ...op.isComplete !== void 0 && { isComplete: op.isComplete },
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        setBlock(turns, resolvedTurnId, op.blockId, updated);
+        break;
+      }
+      case "complete_block": {
+        let block = findBlock(turns, op.turnId, op.blockId);
+        let resolvedTurnId = op.turnId;
+        if (!block) {
+          const found = findBlockAcrossTurns(turns, op.blockId);
+          if (found) {
+            block = found.block;
+            resolvedTurnId = found.turnId;
+          } else {
+            break;
+          }
+        }
+        const updated = {
+          ...block,
+          isComplete: true,
+          updatedAt: op.updatedAt
+        };
+        setBlock(turns, resolvedTurnId, op.blockId, updated);
+        break;
+      }
+      case "complete_turn": {
+        const turn = turns[op.turnId];
+        if (!turn) break;
+        turns[op.turnId] = {
+          ...turn,
+          isComplete: true,
+          endedAt: op.endedAt,
+          updatedAt: op.updatedAt
+        };
+        break;
+      }
+    }
+  }
+  return {
+    ...state,
+    turnOrder,
+    turns
+  };
+}
+function findBlock(turns, turnId, blockId) {
+  return turns[turnId]?.blocks[blockId];
+}
+function findBlockAcrossTurns(turns, blockId) {
+  for (const [turnId, turn] of Object.entries(turns)) {
+    const block = turn.blocks[blockId];
+    if (block) return { turnId, block };
+  }
+  return void 0;
+}
+function setBlock(turns, turnId, blockId, block) {
+  const turn = turns[turnId];
+  if (!turn) return;
+  turns[turnId] = {
+    ...turn,
+    blocks: { ...turn.blocks, [blockId]: block },
+    updatedAt: block.updatedAt
+  };
+}
+var MAX_SNAPSHOT_TURNS = 200;
+function trimSnapshot(snapshot, maxTurns = MAX_SNAPSHOT_TURNS) {
+  if (snapshot.turnOrder.length <= maxTurns) return snapshot;
+  const keptOrder = snapshot.turnOrder.slice(-maxTurns);
+  const keptTurns = {};
+  for (const id of keptOrder) {
+    if (snapshot.turns[id]) {
+      keptTurns[id] = snapshot.turns[id];
+    }
+  }
+  return {
+    ...snapshot,
+    turnOrder: keptOrder,
+    turns: keptTurns
+  };
+}
+
+// src/transcript-watcher.ts
 var ClaudeCodeParser = class {
   name = "claude-code";
   /** Maps tool_use id → tool name for matching results back to tools. */
@@ -3185,10 +4095,10 @@ function discoverViaProc(panePid) {
     for (const childPid of children) {
       const fdDir = `/proc/${childPid}/fd`;
       try {
-        const fds = fs3.readdirSync(fdDir);
+        const fds = fs4.readdirSync(fdDir);
         for (const fd of fds) {
           try {
-            const target = fs3.readlinkSync(path3.join(fdDir, fd));
+            const target = fs4.readlinkSync(path3.join(fdDir, fd));
             if (target.endsWith(".jsonl") && target.includes("/.claude/")) {
               return target;
             }
@@ -3205,10 +4115,10 @@ function discoverViaProc(panePid) {
         for (const gcPid of grandchildren) {
           const gcFdDir = `/proc/${gcPid}/fd`;
           try {
-            const fds = fs3.readdirSync(gcFdDir);
+            const fds = fs4.readdirSync(gcFdDir);
             for (const fd of fds) {
               try {
-                const target = fs3.readlinkSync(path3.join(gcFdDir, fd));
+                const target = fs4.readlinkSync(path3.join(gcFdDir, fd));
                 if (target.endsWith(".jsonl") && target.includes("/.claude/")) {
                   return target;
                 }
@@ -3227,15 +4137,15 @@ function discoverViaProc(panePid) {
 }
 function discoverViaCwd(paneCwd) {
   const claudeProjectsDir = path3.join(os7.homedir(), ".claude", "projects");
-  if (!fs3.existsSync(claudeProjectsDir)) return null;
-  const resolvedCwd = fs3.realpathSync(paneCwd);
+  if (!fs4.existsSync(claudeProjectsDir)) return null;
+  const resolvedCwd = fs4.realpathSync(paneCwd);
   const expectedDirName = resolvedCwd.replace(/\//g, "-");
   const projectDir = path3.join(claudeProjectsDir, expectedDirName);
-  if (!fs3.existsSync(projectDir)) return null;
+  if (!fs4.existsSync(projectDir)) return null;
   try {
-    const jsonlFiles = fs3.readdirSync(projectDir).filter((f) => f.endsWith(".jsonl")).map((f) => {
+    const jsonlFiles = fs4.readdirSync(projectDir).filter((f) => f.endsWith(".jsonl")).map((f) => {
       const fullPath = path3.join(projectDir, f);
-      const stat = fs3.statSync(fullPath);
+      const stat = fs4.statSync(fullPath);
       return { path: fullPath, mtime: stat.mtimeMs };
     }).sort((a, b) => b.mtime - a.mtime);
     return jsonlFiles.length > 0 ? jsonlFiles[0].path : null;
@@ -3245,14 +4155,14 @@ function discoverViaCwd(paneCwd) {
 }
 function discoverCodexTranscript() {
   const codexSessionsDir = path3.join(os7.homedir(), ".codex", "sessions");
-  if (!fs3.existsSync(codexSessionsDir)) return null;
+  if (!fs4.existsSync(codexSessionsDir)) return null;
   try {
-    const dateDirs = fs3.readdirSync(codexSessionsDir).filter((d) => /^\d{4}-\d{2}-\d{2}/.test(d)).sort().reverse();
+    const dateDirs = fs4.readdirSync(codexSessionsDir).filter((d) => /^\d{4}-\d{2}-\d{2}/.test(d)).sort().reverse();
     for (const dateDir of dateDirs.slice(0, 3)) {
       const fullDir = path3.join(codexSessionsDir, dateDir);
-      const jsonlFiles = fs3.readdirSync(fullDir).filter((f) => f.startsWith("rollout-") && f.endsWith(".jsonl")).map((f) => {
+      const jsonlFiles = fs4.readdirSync(fullDir).filter((f) => f.startsWith("rollout-") && f.endsWith(".jsonl")).map((f) => {
         const fp = path3.join(fullDir, f);
-        const stat = fs3.statSync(fp);
+        const stat = fs4.statSync(fp);
         return { path: fp, mtime: stat.mtimeMs };
       }).sort((a, b) => b.mtime - a.mtime);
       if (jsonlFiles.length > 0) return jsonlFiles[0].path;
@@ -3303,25 +4213,30 @@ var REDISCOVERY_INTERVAL_MS = 5e3;
 var TranscriptWatcher = class {
   filePath;
   parser;
+  parserV2;
   callbacks;
   offset = 0;
   inode = 0;
   partialLine = "";
   seq = 0;
   turns = [];
+  /** V2 normalized snapshot state. */
+  snapshot;
   watcher = null;
   pollTimer = null;
   stopped = false;
   subscriberCount = 0;
-  constructor(filePath, parser, callbacks) {
+  constructor(filePath, parser, callbacks, parserV2, sessionId) {
     this.filePath = filePath;
     this.parser = parser;
+    this.parserV2 = parserV2;
     this.callbacks = callbacks;
+    this.snapshot = createEmptySnapshot(sessionId ?? "");
   }
   /** Start watching the file. Returns false if file doesn't exist. */
   start() {
     try {
-      const stat = fs3.statSync(this.filePath);
+      const stat = fs4.statSync(this.filePath);
       this.inode = stat.ino;
       this.offset = stat.size;
     } catch {
@@ -3368,6 +4283,10 @@ var TranscriptWatcher = class {
   get currentSeq() {
     return this.seq;
   }
+  /** Get the V2 normalized snapshot. */
+  getSnapshot() {
+    return trimSnapshot(this.snapshot);
+  }
   /** Read and replay the full transcript from the start of the file. */
   replayFromStart() {
     const savedOffset = this.offset;
@@ -3380,7 +4299,7 @@ var TranscriptWatcher = class {
   }
   startWatching() {
     try {
-      this.watcher = fs3.watch(this.filePath, () => {
+      this.watcher = fs4.watch(this.filePath, () => {
         if (!this.stopped) this.readNewData();
       });
       this.watcher.on("error", () => {
@@ -3398,7 +4317,7 @@ var TranscriptWatcher = class {
   }
   checkForRotation() {
     try {
-      const stat = fs3.statSync(this.filePath);
+      const stat = fs4.statSync(this.filePath);
       if (stat.ino !== this.inode) {
         this.inode = stat.ino;
         this.offset = 0;
@@ -3413,22 +4332,22 @@ var TranscriptWatcher = class {
   readNewData() {
     let fd;
     try {
-      fd = fs3.openSync(this.filePath, "r");
+      fd = fs4.openSync(this.filePath, "r");
     } catch {
       return;
     }
     try {
-      const stat = fs3.fstatSync(fd);
+      const stat = fs4.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);
+      const bytesRead = fs4.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);
+      fs4.closeSync(fd);
     }
   }
   processChunk(chunk) {
@@ -3442,9 +4361,20 @@ var TranscriptWatcher = class {
     for (const line of lines) {
       const trimmed = line.trim();
       if (!trimmed) continue;
+      if (this.parserV2 && this.callbacks.onOps) {
+        const ops = this.parserV2.parseLine(trimmed);
+        if (ops.length > 0) {
+          this.seq++;
+          this.snapshot = applyOps(this.snapshot, ops);
+          this.snapshot = trimSnapshot(this.snapshot);
+          this.callbacks.onOps(ops, this.seq);
+        }
+      }
       const turn = this.parser.parseLine(trimmed);
       if (turn) {
-        this.seq++;
+        if (!this.parserV2 || !this.callbacks.onOps) {
+          this.seq++;
+        }
         this.turns.push({
           turnId: turn.turnId,
           role: turn.role,
@@ -3460,22 +4390,27 @@ var TranscriptWatcher = class {
     }
   }
 };
-var PARSERS = {
-  "Claude Code": new ClaudeCodeParser(),
-  "Codex CLI": new CodexCliParser()
+var PARSER_FACTORIES = {
+  "Claude Code": () => new ClaudeCodeParser(),
+  "Codex CLI": () => new CodexCliParser()
 };
 function getParser(agentType) {
   if (!agentType) return void 0;
-  return PARSERS[agentType];
+  const factory = PARSER_FACTORIES[agentType];
+  return factory ? factory() : void 0;
 }
 var TranscriptWatcherManager = class {
   active = /* @__PURE__ */ new Map();
   rediscoveryTimers = /* @__PURE__ */ new Map();
   sendFn;
   sendSnapshotFn;
-  constructor(sendFn, sendSnapshotFn) {
+  sendOpsFn;
+  sendV2SnapshotFn;
+  constructor(sendFn, sendSnapshotFn, sendOpsFn, sendV2SnapshotFn) {
     this.sendFn = sendFn;
     this.sendSnapshotFn = sendSnapshotFn;
+    this.sendOpsFn = sendOpsFn;
+    this.sendV2SnapshotFn = sendV2SnapshotFn;
   }
   /** Enable markdown streaming for a session. */
   enableMarkdown(sessionId, agentType) {
@@ -3495,14 +4430,24 @@ var TranscriptWatcherManager = class {
       return false;
     }
     console.log(`[rAgent] Watching transcript: ${filePath} (${parser.name})`);
-    const watcher = new TranscriptWatcher(filePath, parser, {
-      onTurn: (turn, seq) => {
-        this.sendFn(sessionId, turn, seq);
+    const v2Parser = getParserV2(agentType);
+    const watcher = new TranscriptWatcher(
+      filePath,
+      parser,
+      {
+        onTurn: (turn, seq) => {
+          this.sendFn(sessionId, turn, seq);
+        },
+        onOps: this.sendOpsFn ? (ops, seq) => {
+          this.sendOpsFn(sessionId, ops, seq);
+        } : void 0,
+        onError: (error) => {
+          console.warn(`[rAgent] Transcript watcher error (${sessionId}): ${error}`);
+        }
       },
-      onError: (error) => {
-        console.warn(`[rAgent] Transcript watcher error (${sessionId}): ${error}`);
-      }
-    });
+      v2Parser,
+      sessionId
+    );
     if (!watcher.start()) {
       console.warn(`[rAgent] Failed to start watching ${filePath}`);
       return false;
@@ -3536,14 +4481,24 @@ var TranscriptWatcherManager = class {
       session.watcher.stop();
       const parser = getParser(agentType);
       if (!parser) return;
-      const newWatcher = new TranscriptWatcher(newPath, parser, {
-        onTurn: (turn, seq) => {
-          this.sendFn(sessionId, turn, seq);
+      const newV2Parser = getParserV2(agentType);
+      const newWatcher = new TranscriptWatcher(
+        newPath,
+        parser,
+        {
+          onTurn: (turn, seq) => {
+            this.sendFn(sessionId, turn, seq);
+          },
+          onOps: this.sendOpsFn ? (ops, seq) => {
+            this.sendOpsFn(sessionId, ops, seq);
+          } : void 0,
+          onError: (error) => {
+            console.warn(`[rAgent] Transcript watcher error (${sessionId}): ${error}`);
+          }
         },
-        onError: (error) => {
-          console.warn(`[rAgent] Transcript watcher error (${sessionId}): ${error}`);
-        }
-      });
+        newV2Parser,
+        sessionId
+      );
       if (!newWatcher.start()) {
         console.warn(`[rAgent] Failed to start watching new transcript ${newPath}`);
         return;
@@ -3562,12 +4517,16 @@ var TranscriptWatcherManager = class {
       this.rediscoveryTimers.delete(sessionId);
     }
   }
-  /** Handle sync-markdown request — send replay snapshot. */
+  /** Handle sync-markdown request — send replay snapshot (V1 + V2). */
   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);
+    if (this.sendV2SnapshotFn) {
+      const snapshot = session.watcher.getSnapshot();
+      this.sendV2SnapshotFn(sessionId, snapshot, session.watcher.currentSeq);
+    }
   }
   /** Stop all watchers. */
   stopAll() {
@@ -3591,7 +4550,7 @@ function pidFilePath(hostId) {
 }
 function readPidFile(filePath) {
   try {
-    const raw = fs4.readFileSync(filePath, "utf8").trim();
+    const raw = fs5.readFileSync(filePath, "utf8").trim();
     const pid = Number.parseInt(raw, 10);
     return Number.isInteger(pid) && pid > 0 ? pid : null;
   } catch {
@@ -3616,7 +4575,7 @@ function acquirePidLock(hostId) {
 Stop it first with: kill ${existingPid}  \u2014 or: ragent service stop`
     );
   }
-  fs4.writeFileSync(lockPath, `${process.pid}
+  fs5.writeFileSync(lockPath, `${process.pid}
 `, "utf8");
   return lockPath;
 }
@@ -3624,7 +4583,7 @@ function releasePidLock(lockPath) {
   try {
     const currentPid = readPidFile(lockPath);
     if (currentPid === process.pid) {
-      fs4.unlinkSync(lockPath);
+      fs5.unlinkSync(lockPath);
     }
   } catch {
   }
@@ -3730,6 +4689,44 @@ async function runAgent(rawOptions) {
       } else {
         sendToGroup(conn.activeSocket, conn.activeGroups.privateGroup, payload);
       }
+    },
+    // V2: send block-level delta ops
+    (sessionId, ops, seq) => {
+      if (!conn.isReady()) return;
+      const payload = {
+        type: "markdown",
+        subtype: "delta",
+        schemaVersion: 2,
+        sessionId,
+        seq,
+        ops
+      };
+      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);
+      }
+    },
+    // V2: send full snapshot
+    (sessionId, snapshot, seq) => {
+      if (!conn.isReady()) return;
+      const payload = {
+        type: "markdown",
+        subtype: "snapshot",
+        schemaVersion: 2,
+        sessionId,
+        seq,
+        snapshot
+      };
+      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);
@@ -3766,6 +4763,24 @@ async function runAgent(rawOptions) {
         await new Promise((resolve) => {
           const ws = new import_ws5.default(negotiated.url, "json.webpubsub.azure.v1");
           conn.setConnection(ws, groups, negotiated.sessionKey ?? null);
+          if (negotiated.sessionKey) {
+            const enforcer = new ApprovalEnforcer({
+              secret: negotiated.sessionKey,
+              sendRequest: (request) => {
+                if (conn.isReady()) {
+                  sendToGroup(ws, groups.privateGroup, {
+                    type: "approval",
+                    subtype: "request",
+                    sessionId: request.sessionId,
+                    request
+                  });
+                }
+              }
+            });
+            dispatcher.setApprovalEnforcer(enforcer);
+          } else {
+            dispatcher.setApprovalEnforcer(null);
+          }
           ws.on("open", async () => {
             console.log("[rAgent] Connector connected to relay.");
             conn.resetReconnectDelay();
@@ -3833,6 +4848,8 @@ async function runAgent(rawOptions) {
                 await dispatcher.handleControlAction({ ...payload, action: "start-agent" });
               } else if (payload.type === "provision") {
                 await dispatcher.handleControlAction({ ...payload, action: "provision" });
+              } else if (payload.type === "approval") {
+                dispatcher.handleApprovalMessage(payload);
               }
             }
             if (msg.type === "message" && msg.group === groups.registryGroup) {
@@ -4257,7 +5274,7 @@ function registerServiceCommand(program2) {
 }
 
 // src/commands/uninstall.ts
-var fs5 = __toESM(require("fs"));
+var fs6 = __toESM(require("fs"));
 async function uninstallAgent(opts) {
   const config = loadConfig();
   const hostName = config.hostName || config.hostId || "this machine";
@@ -4288,8 +5305,8 @@ async function uninstallAgent(opts) {
   }
   console.log("[rAgent] Stopping and removing service...");
   await uninstallService().catch(() => void 0);
-  if (fs5.existsSync(CONFIG_DIR)) {
-    fs5.rmSync(CONFIG_DIR, { recursive: true, force: true });
+  if (fs6.existsSync(CONFIG_DIR)) {
+    fs6.rmSync(CONFIG_DIR, { recursive: true, force: true });
     console.log(`[rAgent] Removed config directory: ${CONFIG_DIR}`);
   }
   try {
@@ -4312,6 +5329,58 @@ function registerUninstallCommand(parent) {
   });
 }
 
+// src/commands/discover.ts
+async function discoverSessions() {
+  const [tmux, screen, zellij] = await Promise.all([
+    collectTmuxSessions(),
+    collectScreenSessions(),
+    collectZellijSessions()
+  ]);
+  const multiplexerPids = /* @__PURE__ */ new Set();
+  for (const s of [...tmux, ...screen, ...zellij]) {
+    if (s.pids) s.pids.forEach((p) => multiplexerPids.add(p));
+  }
+  const bare = await collectBareAgentProcesses(multiplexerPids);
+  return [...tmux, ...screen, ...zellij, ...bare];
+}
+function formatSessionTable(sessions) {
+  if (sessions.length === 0) return "No agent sessions discovered.";
+  const headers = ["TYPE", "NAME", "AGENT", "CONF", "ENV", "COMMAND", "PID", "WORKING DIR"];
+  const rows = sessions.map((s) => [
+    s.type,
+    s.name,
+    s.agentType || "-",
+    s.agentConfidence !== void 0 ? s.agentConfidence.toFixed(1) : "-",
+    s.environment || "-",
+    truncate(s.command || "-", 40),
+    s.pids?.join(",") || "-",
+    truncate(s.workingDir || "-", 30)
+  ]);
+  const widths = headers.map(
+    (h, i) => Math.max(h.length, ...rows.map((r) => r[i].length))
+  );
+  const headerLine = headers.map((h, i) => h.padEnd(widths[i])).join("  ");
+  const separator = widths.map((w) => "-".repeat(w)).join("  ");
+  const dataLines = rows.map(
+    (row) => row.map((cell, i) => cell.padEnd(widths[i])).join("  ")
+  );
+  return [headerLine, separator, ...dataLines].join("\n");
+}
+function truncate(s, max) {
+  return s.length > max ? s.slice(0, max - 1) + "\u2026" : s;
+}
+function registerDiscoverCommand(program2) {
+  program2.command("discover").description("Scan for running AI agent sessions (one-shot)").option("--json", "Output as JSON").action(async (opts) => {
+    const sessions = await discoverSessions();
+    if (opts.json) {
+      console.log(JSON.stringify(sessions, null, 2));
+    } else {
+      console.log(formatSessionTable(sessions));
+    }
+    process.exitCode = sessions.length > 0 ? 0 : 1;
+  });
+}
+
 // src/index.ts
 process.on("unhandledRejection", (reason) => {
   const message = reason instanceof Error ? reason.stack || reason.message : String(reason);
@@ -4325,6 +5394,7 @@ registerUpdateCommand(import_commander.program);
 registerSessionsCommand(import_commander.program);
 registerServiceCommand(import_commander.program);
 registerUninstallCommand(import_commander.program);
+registerDiscoverCommand(import_commander.program);
 import_commander.program.hook("preAction", async (_thisCommand, actionCommand) => {
   if (actionCommand.name() === "update") return;
   await maybeWarnUpdate();
@@ -4338,7 +5408,7 @@ function showStatus() {
   ragent v${CURRENT_VERSION}
 `);
   try {
-    const raw = fs6.readFileSync(CONFIG_FILE, "utf8");
+    const raw = fs7.readFileSync(CONFIG_FILE, "utf8");
     const config = JSON.parse(raw);
     if (config.portal && config.agentToken) {
       console.log(`  Status:   Connected`);