open-agents-ai 0.103.87 → 0.103.89

package/dist/index.js

@@ -11057,9 +11057,9 @@ function getVersion(binary) {
   }
 }
 function installOpencode() {
-  const platform4 = process.platform;
+  const platform5 = process.platform;
   try {
-    if (platform4 === "win32") {
+    if (platform5 === "win32") {
       execSync19('powershell -Command "irm https://opencode.ai/install | iex"', {
         stdio: "pipe",
         timeout: 12e4
@@ -11331,9 +11331,9 @@ function getVersion2(binary) {
   }
 }
 function installDroid() {
-  const platform4 = process.platform;
+  const platform5 = process.platform;
   try {
-    if (platform4 === "win32") {
+    if (platform5 === "win32") {
       execSync20('powershell -Command "irm https://app.factory.ai/cli/windows | iex"', {
         stdio: "pipe",
         timeout: 12e4
@@ -16925,8 +16925,8 @@ var init_code_retriever = __esm({
         });
       }
       async getFileContent(filePath, startLine, endLine) {
-        const { readFile: readFile17 } = await import("node:fs/promises");
-        const content = await readFile17(filePath, "utf-8");
+        const { readFile: readFile18 } = await import("node:fs/promises");
+        const content = await readFile18(filePath, "utf-8");
         if (startLine === void 0)
           return content;
         const lines = content.split("\n");
@@ -22272,8 +22272,8 @@ function isTranscribablePath(path) {
   return isAudioPath(path) || isVideoPath(path);
 }
 function findMicCaptureCommand() {
-  const platform4 = process.platform;
-  if (platform4 === "linux") {
+  const platform5 = process.platform;
+  if (platform5 === "linux") {
     try {
       execSync23("which arecord", { stdio: "pipe" });
       return {
@@ -22283,7 +22283,7 @@ function findMicCaptureCommand() {
     } catch {
     }
   }
-  if (platform4 === "darwin") {
+  if (platform5 === "darwin") {
     try {
       execSync23("which sox", { stdio: "pipe" });
       return {
@@ -22295,7 +22295,7 @@ function findMicCaptureCommand() {
   }
   try {
     execSync23("which ffmpeg", { stdio: "pipe" });
-    if (platform4 === "linux") {
+    if (platform5 === "linux") {
       return {
         cmd: "ffmpeg",
         args: [
@@ -22314,7 +22314,7 @@ function findMicCaptureCommand() {
           "pipe:1"
         ]
       };
-    } else if (platform4 === "darwin") {
+    } else if (platform5 === "darwin") {
       return {
         cmd: "ffmpeg",
         args: [
@@ -22397,9 +22397,9 @@ function ensureTranscribeCliBackground() {
     } catch {
     }
     try {
-      const { exec: exec3 } = await import("node:child_process");
+      const { exec: exec4 } = await import("node:child_process");
       return new Promise((resolve31) => {
-        exec3("npm i -g transcribe-cli", { timeout: 18e4 }, (err) => {
+        exec4("npm i -g transcribe-cli", { timeout: 18e4 }, (err) => {
           resolve31(!err);
         });
       });
@@ -36125,7 +36125,7 @@ async function handleUpdate(subcommand, ctx) {
   process.stdout.write("\n");
   const checkSpinner = startInlineSpinner(`Checking for updates ${c2.dim(`(current: v${currentVersion})`)}`);
   const info = await checkForUpdate(currentVersion, true);
-  const { exec: exec3, execSync: es2 } = await import("node:child_process");
+  const { exec: exec4, execSync: es2 } = await import("node:child_process");
   let needsSudo = false;
   try {
     const prefix = es2("npm prefix -g", { encoding: "utf8", timeout: 5e3 }).trim();
@@ -36139,7 +36139,7 @@ async function handleUpdate(subcommand, ctx) {
   }
   let installError = "";
   const runInstall2 = (cmd) => new Promise((resolve31) => {
-    const child = exec3(cmd, { timeout: 18e4 }, (err, _stdout, stderr) => {
+    const child = exec4(cmd, { timeout: 18e4 }, (err, _stdout, stderr) => {
       if (err)
         installError = (stderr || err.message || "").trim();
       resolve31(!err);
@@ -36226,7 +36226,7 @@ async function handleUpdate(subcommand, ctx) {
   }
   const rebuildSpinner = startInlineSpinner("Rebuilding native modules");
   const rebuildOk = await new Promise((resolve31) => {
-    const child = exec3(`${sudoPrefix}npm rebuild -g open-agents-ai 2>/dev/null || true`, { timeout: 12e4 }, () => resolve31(true));
+    const child = exec4(`${sudoPrefix}npm rebuild -g open-agents-ai 2>/dev/null || true`, { timeout: 12e4 }, () => resolve31(true));
     child.stdout?.resume();
     child.stderr?.resume();
   });
@@ -36259,7 +36259,7 @@ async function handleUpdate(subcommand, ctx) {
   if (fsExists(venvPip)) {
     const pySpinner = startInlineSpinner("Upgrading Python venv packages");
     const pyOk = await new Promise((resolve31) => {
-      const child = exec3(`"${venvPip}" install --upgrade moondream-station pytesseract Pillow opencv-python-headless numpy 2>/dev/null || true`, { timeout: 3e5 }, (err) => resolve31(!err));
+      const child = exec4(`"${venvPip}" install --upgrade moondream-station pytesseract Pillow opencv-python-headless numpy 2>/dev/null || true`, { timeout: 3e5 }, (err) => resolve31(!err));
       child.stdout?.resume();
       child.stderr?.resume();
     });
@@ -36406,15 +36406,15 @@ function fmtUptime(ms) {
 }
 function getLocalSystemMetrics() {
   const os = __require("node:os");
-  const cpus2 = os.cpus();
+  const cpus3 = os.cpus();
   const loads = os.loadavg();
   const totalMem = os.totalmem();
   const freeMem = os.freemem();
   const usedMem = totalMem - freeMem;
   const result = {
-    cpuModel: cpus2[0]?.model?.trim() ?? "unknown",
-    cpuCores: cpus2.length,
-    cpuUtil: Math.min(100, Math.round(loads[0] / cpus2.length * 100)),
+    cpuModel: cpus3[0]?.model?.trim() ?? "unknown",
+    cpuCores: cpus3.length,
+    cpuUtil: Math.min(100, Math.round(loads[0] / cpus3.length * 100)),
     memTotalGB: Math.round(totalMem / (1024 * 1024 * 1024) * 10) / 10,
     memUsedGB: Math.round(usedMem / (1024 * 1024 * 1024) * 10) / 10,
     memUtil: Math.round(usedMem / totalMem * 100),
@@ -45719,6 +45719,267 @@ var init_braille_spinner = __esm({
   }
 });
 
+// packages/cli/dist/tui/system-metrics.js
+import { loadavg as loadavg2, cpus as cpus2, totalmem as totalmem2, freemem as freemem2, platform as platform4 } from "node:os";
+import { exec as exec3 } from "node:child_process";
+import { readFile as readFile16 } from "node:fs/promises";
+function formatRate(bytesPerSec) {
+  if (bytesPerSec < 1024)
+    return `${Math.round(bytesPerSec)}B`;
+  if (bytesPerSec < 1024 * 1024)
+    return `${(bytesPerSec / 1024).toFixed(1)}K`;
+  if (bytesPerSec < 1024 * 1024 * 1024)
+    return `${(bytesPerSec / (1024 * 1024)).toFixed(1)}M`;
+  return `${(bytesPerSec / (1024 * 1024 * 1024)).toFixed(2)}G`;
+}
+async function readProcNetDev() {
+  try {
+    const data = await readFile16("/proc/net/dev", "utf8");
+    let rxTotal = 0;
+    let txTotal = 0;
+    for (const line of data.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("Inter") || trimmed.startsWith("face") || trimmed.startsWith("lo:"))
+        continue;
+      const match = trimmed.match(/^\S+:\s*(\d+)\s+\d+\s+\d+\s+\d+\s+\d+\s+\d+\s+\d+\s+\d+\s+(\d+)/);
+      if (match) {
+        rxTotal += parseInt(match[1], 10);
+        txTotal += parseInt(match[2], 10);
+      }
+    }
+    return { rxBytes: rxTotal, txBytes: txTotal };
+  } catch {
+    return null;
+  }
+}
+async function collectNetworkMetrics() {
+  const now = Date.now();
+  const plat = platform4();
+  if (plat === "linux") {
+    const snap = await readProcNetDev();
+    if (!snap)
+      return { rxBytesPerSec: 0, txBytesPerSec: 0 };
+    const current = { rxBytes: snap.rxBytes, txBytes: snap.txBytes, timestamp: now };
+    if (!_lastNetSnapshot) {
+      _lastNetSnapshot = current;
+      return { rxBytesPerSec: 0, txBytesPerSec: 0 };
+    }
+    const dtSec = Math.max(0.1, (now - _lastNetSnapshot.timestamp) / 1e3);
+    const rxRate = Math.max(0, (current.rxBytes - _lastNetSnapshot.rxBytes) / dtSec);
+    const txRate = Math.max(0, (current.txBytes - _lastNetSnapshot.txBytes) / dtSec);
+    _lastNetSnapshot = current;
+    return { rxBytesPerSec: rxRate, txBytesPerSec: txRate };
+  }
+  if (plat === "darwin") {
+    try {
+      const output = await new Promise((resolve31, reject) => {
+        exec3("netstat -ib 2>/dev/null | head -30", { encoding: "utf8", timeout: 3e3 }, (err, stdout) => err ? reject(err) : resolve31(stdout));
+      });
+      let rxBytes = 0, txBytes = 0;
+      for (const line of output.split("\n")) {
+        if (line.includes("en0") && !line.includes("Name")) {
+          const parts = line.trim().split(/\s+/);
+          if (parts.length >= 10) {
+            rxBytes = parseInt(parts[6] ?? "0", 10) || 0;
+            txBytes = parseInt(parts[9] ?? "0", 10) || 0;
+            break;
+          }
+        }
+      }
+      const current = { rxBytes, txBytes, timestamp: now };
+      if (!_lastNetSnapshot) {
+        _lastNetSnapshot = current;
+        return { rxBytesPerSec: 0, txBytesPerSec: 0 };
+      }
+      const dtSec = Math.max(0.1, (now - _lastNetSnapshot.timestamp) / 1e3);
+      const rxRate = Math.max(0, (current.rxBytes - _lastNetSnapshot.rxBytes) / dtSec);
+      const txRate = Math.max(0, (current.txBytes - _lastNetSnapshot.txBytes) / dtSec);
+      _lastNetSnapshot = current;
+      return { rxBytesPerSec: rxRate, txBytesPerSec: txRate };
+    } catch {
+      return { rxBytesPerSec: 0, txBytesPerSec: 0 };
+    }
+  }
+  return { rxBytesPerSec: 0, txBytesPerSec: 0 };
+}
+async function collectGpuMetrics() {
+  const noGpu = { available: false, name: "", utilization: 0, vramUsedMB: 0, vramTotalMB: 0, vramUtilization: 0 };
+  if (_nvidiaSmiAvailable === false)
+    return noGpu;
+  try {
+    const smi = await new Promise((resolve31, reject) => {
+      exec3("nvidia-smi --query-gpu=utilization.gpu,memory.used,memory.total,name --format=csv,noheader,nounits 2>/dev/null", { encoding: "utf8", timeout: 3e3 }, (err, stdout) => err ? reject(err) : resolve31(stdout));
+    });
+    _nvidiaSmiAvailable = true;
+    const line = smi.trim().split("\n")[0];
+    if (!line)
+      return noGpu;
+    const parts = line.split(",").map((s) => s.trim());
+    const vramUsed = parseInt(parts[1] ?? "0", 10) || 0;
+    const vramTotal = parseInt(parts[2] ?? "0", 10) || 0;
+    return {
+      available: true,
+      utilization: parseInt(parts[0] ?? "0", 10) || 0,
+      vramUsedMB: vramUsed,
+      vramTotalMB: vramTotal,
+      name: parts[3] ?? "",
+      vramUtilization: vramTotal > 0 ? Math.round(vramUsed / vramTotal * 100) : 0
+    };
+  } catch {
+    _nvidiaSmiAvailable = false;
+    return noGpu;
+  }
+}
+function collectCpuRam() {
+  const [l1] = loadavg2();
+  const cores = cpus2().length;
+  const cpuModel = cpus2()[0]?.model ?? "";
+  const totalMem = totalmem2();
+  const usedMem = totalMem - freemem2();
+  return {
+    cpuUtil: Math.min(100, Math.round(l1 / cores * 100)),
+    cpuCores: cores,
+    cpuModel,
+    memUtil: Math.round(usedMem / totalMem * 100),
+    memUsedGB: Math.round(usedMem / 1024 ** 3 * 10) / 10,
+    memTotalGB: Math.round(totalMem / 1024 ** 3 * 10) / 10
+  };
+}
+async function collectLocalMetrics() {
+  const cpuRam = collectCpuRam();
+  const [gpu, network] = await Promise.all([
+    collectGpuMetrics(),
+    collectNetworkMetrics()
+  ]);
+  return {
+    source: "local",
+    hardware: {
+      cpuUtil: cpuRam.cpuUtil,
+      cpuCores: cpuRam.cpuCores,
+      cpuModel: cpuRam.cpuModel,
+      gpuUtil: gpu.available ? gpu.utilization : -1,
+      gpuName: gpu.name,
+      vramUtil: gpu.available ? gpu.vramUtilization : -1,
+      vramUsedMB: gpu.vramUsedMB,
+      vramTotalMB: gpu.vramTotalMB,
+      memUtil: cpuRam.memUtil,
+      memUsedGB: cpuRam.memUsedGB,
+      memTotalGB: cpuRam.memTotalGB
+    },
+    network
+  };
+}
+var _lastNetSnapshot, _nvidiaSmiAvailable, SystemMetricsCollector;
+var init_system_metrics = __esm({
+  "packages/cli/dist/tui/system-metrics.js"() {
+    "use strict";
+    _lastNetSnapshot = null;
+    _nvidiaSmiAvailable = null;
+    SystemMetricsCollector = class {
+      _timer = null;
+      _source = "local";
+      _callback = null;
+      _latest = null;
+      _intervalMs = 3e3;
+      _collecting = false;
+      /** Current metrics snapshot (may be null before first poll) */
+      get latest() {
+        return this._latest;
+      }
+      /** Current source mode */
+      get source() {
+        return this._source;
+      }
+      /**
+       * Start collecting LOCAL metrics on an interval.
+       * @param callback Called each time new metrics arrive
+       * @param intervalMs Polling interval (default 3000ms)
+       */
+      startLocal(callback, intervalMs = 3e3) {
+        this.stop();
+        this._source = "local";
+        this._callback = callback;
+        this._intervalMs = intervalMs;
+        this._poll();
+        this._timer = setInterval(() => this._poll(), intervalMs);
+      }
+      /**
+       * Switch to REMOTE mode — stops local polling, accepts pushed metrics.
+       * Call pushRemoteMetrics() to feed data from the remote provider.
+       */
+      startRemote(callback) {
+        this.stop();
+        this._source = "remote";
+        this._callback = callback;
+        this._timer = setInterval(() => this._pollNetworkOnly(), this._intervalMs);
+        this._pollNetworkOnly();
+      }
+      /**
+       * Push hardware metrics received from a remote /expose provider.
+       * Network metrics are always collected locally regardless.
+       */
+      pushRemoteMetrics(hw) {
+        if (this._source !== "remote")
+          return;
+        const hardware = {
+          cpuUtil: hw.cpuUtil ?? -1,
+          cpuCores: hw.cpuCores ?? 0,
+          cpuModel: hw.cpuModel ?? "",
+          gpuUtil: hw.gpuUtil ?? -1,
+          gpuName: hw.gpuName ?? "",
+          vramUtil: hw.vramUtil ?? -1,
+          vramUsedMB: hw.vramUsedMB ?? 0,
+          vramTotalMB: hw.vramTotalMB ?? 0,
+          memUtil: hw.memUtil ?? -1,
+          memUsedGB: hw.memUsedGB ?? 0,
+          memTotalGB: hw.memTotalGB ?? 0
+        };
+        this._latest = {
+          source: "remote",
+          hardware,
+          network: this._latest?.network ?? { rxBytesPerSec: 0, txBytesPerSec: 0 }
+        };
+        this._callback?.(this._latest);
+      }
+      /** Stop all polling and clear state */
+      stop() {
+        if (this._timer) {
+          clearInterval(this._timer);
+          this._timer = null;
+        }
+        this._latest = null;
+        this._callback = null;
+        this._collecting = false;
+      }
+      /** Whether the collector is active */
+      get isActive() {
+        return this._timer !== null;
+      }
+      async _poll() {
+        if (this._collecting)
+          return;
+        this._collecting = true;
+        try {
+          this._latest = await collectLocalMetrics();
+          this._callback?.(this._latest);
+        } catch {
+        }
+        this._collecting = false;
+      }
+      async _pollNetworkOnly() {
+        try {
+          const network = await collectNetworkMetrics();
+          if (this._latest) {
+            this._latest = { ...this._latest, network };
+            this._callback?.(this._latest);
+          }
+        } catch {
+        }
+      }
+    };
+  }
+});
+
 // packages/cli/dist/tui/status-bar.js
 var EXPERT_TOOL_BASELINES, CONTEXT_SWITCH_OVERHEAD, TURN_PLANNING_OVERHEAD, DEFAULT_TOOL_BASELINE, CODE_READ_CHARS_PER_SEC, PROSE_READ_CHARS_PER_SEC, MIN_CONTENT_FOR_READING, CODE_CONTENT_TOOLS, PROSE_CONTENT_TOOLS, HumanSpeedTracker, StatusBar;
 var init_status_bar = __esm({
@@ -45726,6 +45987,7 @@ var init_status_bar = __esm({
     "use strict";
     init_render();
     init_braille_spinner();
+    init_system_metrics();
     EXPERT_TOOL_BASELINES = {
       file_read: 12,
       structured_read: 15,
@@ -46145,39 +46407,77 @@ var init_status_bar = __esm({
         if (this.active)
           this.renderFooterPreserveCursor();
       }
-      /** Remote host metrics (when connected to a remote endpoint) */
-      _remoteMetrics = null;
+      /** Unified system metrics collector (local or remote) */
+      _metricsCollector = new SystemMetricsCollector();
+      /** Cached unified metrics snapshot — updated by collector callback */
+      _unifiedMetrics = null;
+      /** Legacy remote metrics polling timer (for peer/HTTP polling) */
       _remoteMetricsTimer = null;
       /** Update remote host system metrics (from polling /v1/system/metrics) */
       setRemoteMetrics(metrics) {
-        this._remoteMetrics = {
-          ...metrics,
+        if (!this._metricsCollector.isActive || this._metricsCollector.source !== "remote") {
+          this._metricsCollector.startRemote((m) => {
+            this._unifiedMetrics = m;
+            if (this.active)
+              this.renderFooterPreserveCursor();
+          });
+        }
+        this._metricsCollector.pushRemoteMetrics({
+          cpuUtil: metrics.cpuUtil,
           cpuCores: metrics.cpuCores ?? 0,
           cpuModel: metrics.cpuModel ?? "",
+          gpuUtil: metrics.gpuUtil,
+          gpuName: metrics.gpuName,
+          vramUtil: metrics.vramUtil,
           vramUsedMB: metrics.vramUsedMB ?? 0,
           vramTotalMB: metrics.vramTotalMB ?? 0,
+          memUtil: metrics.memUtil,
           memTotalGB: metrics.memTotalGB ?? 0,
           memUsedGB: metrics.memUsedGB ?? 0
-        };
-        if (this.active)
-          this.renderFooterPreserveCursor();
+        });
       }
-      /** Clear remote metrics (e.g. when switching to local endpoint) */
+      /** Clear remote metrics and switch back to local collection */
       clearRemoteMetrics() {
-        this._remoteMetrics = null;
+        this._unifiedMetrics = null;
         if (this._remoteMetricsTimer) {
           clearInterval(this._remoteMetricsTimer);
           this._remoteMetricsTimer = null;
         }
+        this.startLocalMetrics();
         if (this.active)
           this.renderFooterPreserveCursor();
       }
+      /**
+       * Start collecting LOCAL system metrics (CPU/RAM/GPU + network I/O).
+       * Called automatically on startup when endpoint is local.
+       */
+      startLocalMetrics(intervalMs = 3e3) {
+        this._metricsCollector.startLocal((m) => {
+          this._unifiedMetrics = m;
+          if (this.active)
+            this.renderFooterPreserveCursor();
+        }, intervalMs);
+      }
+      /** Stop all metrics collection (local and remote) */
+      stopAllMetrics() {
+        this._metricsCollector.stop();
+        this._unifiedMetrics = null;
+        if (this._remoteMetricsTimer) {
+          clearInterval(this._remoteMetricsTimer);
+          this._remoteMetricsTimer = null;
+        }
+      }
       /**
        * Start polling a remote endpoint for system metrics.
        * Call when /endpoint is set to a remote URL that has /v1/system/metrics.
        */
       startRemoteMetricsPolling(endpointUrl, authKey) {
         this.stopRemoteMetricsPolling();
+        this._metricsCollector.startRemote((m) => {
+          this._unifiedMetrics = m;
+          if (this.active)
+            this.renderFooterPreserveCursor();
+        });
         const poll = async () => {
           try {
             const url = new URL("/v1/system/metrics", endpointUrl);
@@ -46208,6 +46508,11 @@ var init_status_bar = __esm({
        */
       startPeerMetricsPolling(sendCommand, peerId, authKey) {
         this.stopRemoteMetricsPolling();
+        this._metricsCollector.startRemote((m) => {
+          this._unifiedMetrics = m;
+          if (this.active)
+            this.renderFooterPreserveCursor();
+        });
         const poll = async () => {
           try {
             const queryData = { type: "query" };
@@ -46288,7 +46593,7 @@ var init_status_bar = __esm({
           clearInterval(this._remoteMetricsTimer);
           this._remoteMetricsTimer = null;
         }
-        this._remoteMetrics = null;
+        this._unifiedMetrics = null;
       }
       /** Update token metrics from a token_usage event */
       updateMetrics(update) {
@@ -46349,10 +46654,14 @@ var init_status_bar = __esm({
         this.applyScrollRegion();
         this.renderFooterAndPositionInput();
         this.hookStdin();
+        if (!this._metricsCollector.isActive) {
+          this.startLocalMetrics();
+        }
       }
       /** Deactivate — restore full-screen scroll region */
       deactivate() {
         this.active = false;
+        this.stopAllMetrics();
         const rows = process.stdout.rows ?? 24;
         process.stdout.write(`\x1B[1;${rows}r`);
       }
@@ -46422,28 +46731,28 @@ var init_status_bar = __esm({
         const pos = this.rowPositions(rows);
         const w = getTermWidth();
         const sep = c2.dim("\u2500".repeat(w));
-        let clearBuf = "";
-        if (prevRows > 0 && (rows !== prevRows || cols !== prevCols)) {
-          const wrapFactor = cols > 0 ? Math.ceil(prevCols / cols) : 1;
-          const extraWrappedRows = Math.max(0, (wrapFactor - 1) * 3);
-          const safetyMargin = extraWrappedRows + 2;
-          const clearFrom = Math.max(1, pos.bufferRow - safetyMargin);
-          clearBuf = "\x1B[1;" + rows + `r\x1B[${clearFrom};1H\x1B[J`;
-        }
         if (this.writeDepth > 0) {
           const inputWrap = this.wrapInput(w);
-          let buf = clearBuf + `\x1B[${this.scrollRegionTop};${pos.scrollEnd}r\x1B[?25l\x1B[?7l\x1B[${pos.bufferRow};1H\x1B[2K${this.buildBufferContent(w)}\x1B[${pos.topSepRow};1H\x1B[2K${sep}`;
+          let buf = `\x1B[${this.scrollRegionTop};${pos.scrollEnd}r\x1B[?25l\x1B[?7l`;
+          for (let row = pos.bufferRow; row <= rows; row++) {
+            buf += `\x1B[${row};1H\x1B[2K`;
+          }
+          buf += `\x1B[${pos.bufferRow};1H${this.buildBufferContent(w)}\x1B[${pos.topSepRow};1H${sep}`;
           for (let i = 0; i < inputWrap.lines.length; i++) {
             const row = pos.inputStartRow + i;
             const prefix = i === 0 ? this.promptText : " ".repeat(this.promptWidth);
-            buf += `\x1B[${row};1H\x1B[2K${prefix}${inputWrap.lines[i]}`;
+            buf += `\x1B[${row};1H${prefix}${inputWrap.lines[i]}`;
           }
-          buf += `\x1B[${pos.bottomSepRow};1H\x1B[2K${sep}\x1B[${pos.metricsRow};1H\x1B[2K${this.buildMetricsLine()}\x1B[?7h\x1B[${pos.scrollEnd};1H`;
+          buf += `\x1B[${pos.bottomSepRow};1H${sep}\x1B[${pos.metricsRow};1H${this.buildMetricsLine()}\x1B[?7h\x1B[${pos.scrollEnd};1H`;
           process.stdout.write(buf);
         } else {
-          if (clearBuf)
-            process.stdout.write(clearBuf);
           this.applyScrollRegion();
+          let clearBuf = "\x1B[?7l";
+          for (let row = pos.bufferRow; row <= rows; row++) {
+            clearBuf += `\x1B[${row};1H\x1B[2K`;
+          }
+          clearBuf += "\x1B[?7h";
+          process.stdout.write(clearBuf);
           this.renderFooterAndPositionInput();
         }
       }
@@ -46688,47 +46997,59 @@ var init_status_bar = __esm({
             empty: false
           });
         }
-        if (this._remoteMetrics) {
-          const rm2 = this._remoteMetrics;
-          const cpuColor = rm2.cpuUtil > 80 ? c2.red : rm2.cpuUtil > 50 ? c2.yellow : c2.green;
-          const cpuCoresInfo = rm2.cpuCores > 0 ? ` (${rm2.cpuCores}c` + (rm2.cpuModel ? " " + rm2.cpuModel.replace(/\s+/g, " ").slice(0, 30) : "") + ")" : "";
-          const cpuExpStr = `CPU:${cpuColor(rm2.cpuUtil + "%")}${c2.dim(cpuCoresInfo)}`;
-          const cpuCompStr = `CPU:${cpuColor(rm2.cpuUtil + "%")}`;
-          const cpuExpW = 4 + `${rm2.cpuUtil}%`.length + cpuCoresInfo.length;
-          const cpuCompW = 4 + `${rm2.cpuUtil}%`.length;
-          const memColor = rm2.memUtil > 80 ? c2.red : rm2.memUtil > 50 ? c2.yellow : c2.green;
-          const memDetail = rm2.memTotalGB > 0 ? ` (${rm2.memUsedGB}/${rm2.memTotalGB}GB)` : "";
-          const memExpStr = ` RAM:${memColor(rm2.memUtil + "%")}${c2.dim(memDetail)}`;
-          const memCompStr = ` RAM:${memColor(rm2.memUtil + "%")}`;
-          const memExpW = 5 + `${rm2.memUtil}%`.length + memDetail.length;
-          const memCompW = 5 + `${rm2.memUtil}%`.length;
-          let gpuExpStr = "";
-          let gpuCompStr = "";
-          let gpuExpW = 0;
-          let gpuCompW = 0;
+        if (this._unifiedMetrics) {
+          const um = this._unifiedMetrics;
+          const rm2 = um.hardware;
+          const isLocal = um.source === "local";
+          const srcTag = isLocal ? pastel2(120, "L") : pastel2(117, "R");
+          const srcW = 1;
+          let hwExpStr = "";
+          let hwCompStr = "";
+          let hwExpW = 0;
+          let hwCompW = 0;
+          if (rm2.cpuUtil >= 0) {
+            const cpuColor = rm2.cpuUtil > 80 ? c2.red : rm2.cpuUtil > 50 ? c2.yellow : c2.green;
+            const cpuCoresInfo = rm2.cpuCores > 0 ? ` (${rm2.cpuCores}c` + (rm2.cpuModel ? " " + rm2.cpuModel.replace(/\s+/g, " ").slice(0, 30) : "") + ")" : "";
+            hwExpStr += `CPU:${cpuColor(rm2.cpuUtil + "%")}${c2.dim(cpuCoresInfo)}`;
+            hwCompStr += `CPU:${cpuColor(rm2.cpuUtil + "%")}`;
+            hwExpW += 4 + `${rm2.cpuUtil}%`.length + cpuCoresInfo.length;
+            hwCompW += 4 + `${rm2.cpuUtil}%`.length;
+          }
+          if (rm2.memUtil >= 0) {
+            const memColor = rm2.memUtil > 80 ? c2.red : rm2.memUtil > 50 ? c2.yellow : c2.green;
+            const memDetail = rm2.memTotalGB > 0 ? ` (${rm2.memUsedGB}/${rm2.memTotalGB}GB)` : "";
+            hwExpStr += ` RAM:${memColor(rm2.memUtil + "%")}${c2.dim(memDetail)}`;
+            hwCompStr += ` RAM:${memColor(rm2.memUtil + "%")}`;
+            hwExpW += 5 + `${rm2.memUtil}%`.length + memDetail.length;
+            hwCompW += 5 + `${rm2.memUtil}%`.length;
+          }
           if (rm2.gpuUtil >= 0) {
             const gpuColor = rm2.gpuUtil > 80 ? c2.red : rm2.gpuUtil > 50 ? c2.yellow : c2.green;
             const gpuNameShort = rm2.gpuName ? ` (${rm2.gpuName.slice(0, 20)})` : "";
-            gpuExpStr = ` GPU:${gpuColor(rm2.gpuUtil + "%")}${c2.dim(gpuNameShort)}`;
-            gpuCompStr = ` GPU:${gpuColor(rm2.gpuUtil + "%")}`;
-            gpuExpW = 5 + `${rm2.gpuUtil}%`.length + gpuNameShort.length;
-            gpuCompW = 5 + `${rm2.gpuUtil}%`.length;
+            hwExpStr += ` GPU:${gpuColor(rm2.gpuUtil + "%")}${c2.dim(gpuNameShort)}`;
+            hwCompStr += ` GPU:${gpuColor(rm2.gpuUtil + "%")}`;
+            hwExpW += 5 + `${rm2.gpuUtil}%`.length + gpuNameShort.length;
+            hwCompW += 5 + `${rm2.gpuUtil}%`.length;
           }
-          let vramStr = "";
-          let vramW = 0;
           if (rm2.vramUtil >= 0) {
             const vramColor = rm2.vramUtil > 80 ? c2.red : rm2.vramUtil > 50 ? c2.yellow : c2.green;
             const vramDetail = rm2.vramTotalMB > 0 ? ` (${rm2.vramUsedMB}/${rm2.vramTotalMB}MB)` : "";
-            vramStr = ` VRAM:${vramColor(rm2.vramUtil + "%")}${c2.dim(vramDetail)}`;
-            vramW = 6 + `${rm2.vramUtil}%`.length + vramDetail.length;
-          }
-          const remoteExpanded = pastel2(117, "\u{1F4E1}") + " " + cpuExpStr + memExpStr + gpuExpStr + vramStr;
-          const remoteCompact = pastel2(117, "\u{1F4E1}") + " " + cpuCompStr + gpuCompStr;
+            hwExpStr += ` VRAM:${vramColor(rm2.vramUtil + "%")}${c2.dim(vramDetail)}`;
+            hwExpW += 6 + `${rm2.vramUtil}%`.length + vramDetail.length;
+          }
+          const net = um.network;
+          const rxStr = formatRate(net.rxBytesPerSec);
+          const txStr = formatRate(net.txBytesPerSec);
+          const netExpStr = ` ${c2.dim("i:")}${pastel2(116, rxStr)} ${c2.dim("o:")}${pastel2(218, txStr)}`;
+          const netCompStr = ` ${c2.dim("i:")}${pastel2(116, rxStr)} ${c2.dim("o:")}${pastel2(218, txStr)}`;
+          const netW = 3 + rxStr.length + 3 + txStr.length;
+          const sysExpanded = srcTag + " " + hwExpStr + netExpStr;
+          const sysCompact = srcTag + " " + hwCompStr + netCompStr;
           sections.push({
-            expanded: remoteExpanded,
-            compact: remoteCompact,
-            expandedW: 3 + cpuExpW + memExpW + gpuExpW + vramW,
-            compactW: 3 + cpuCompW + gpuCompW,
+            expanded: sysExpanded,
+            compact: sysCompact,
+            expandedW: srcW + 1 + hwExpW + netW,
+            compactW: srcW + 1 + hwCompW + netW,
             empty: false
           });
         }
@@ -50227,8 +50548,8 @@ NEW TASK: ${fullInput}`;
       try {
         const updateInfo = await checkForUpdate(version);
         if (updateInfo) {
-          const { exec: exec3 } = await import("node:child_process");
-          exec3(`npm install -g open-agents-ai@latest --prefer-online`, { timeout: 18e4 }, (err) => {
+          const { exec: exec4 } = await import("node:child_process");
+          exec4(`npm install -g open-agents-ai@latest --prefer-online`, { timeout: 18e4 }, (err) => {
             if (!err) {
               writeContent(() => renderInfo(`Updated to v${updateInfo.latestVersion} in background. Takes effect next session.`));
             }
@@ -50526,7 +50847,7 @@ var init_run = __esm({
 // packages/indexer/dist/codebase-indexer.js
 import { glob } from "glob";
 import ignore from "ignore";
-import { readFile as readFile16, stat as stat4 } from "node:fs/promises";
+import { readFile as readFile17, stat as stat4 } from "node:fs/promises";
 import { createHash as createHash4 } from "node:crypto";
 import { join as join51, relative as relative3, extname as extname10, basename as basename15 } from "node:path";
 var DEFAULT_EXCLUDE, LANGUAGE_MAP, CodebaseIndexer;
@@ -50572,7 +50893,7 @@ var init_codebase_indexer = __esm({
         const ig = ignore.default();
         if (this.config.respectGitignore) {
           try {
-            const gitignoreContent = await readFile16(join51(this.config.rootDir, ".gitignore"), "utf-8");
+            const gitignoreContent = await readFile17(join51(this.config.rootDir, ".gitignore"), "utf-8");
             ig.add(gitignoreContent);
           } catch {
           }
@@ -50592,7 +50913,7 @@ var init_codebase_indexer = __esm({
             const fileStat = await stat4(fullPath);
             if (fileStat.size > this.config.maxFileSize)
               continue;
-            const content = await readFile16(fullPath);
+            const content = await readFile17(fullPath);
             const hash = createHash4("sha256").update(content).digest("hex");
             const ext = extname10(relativePath);
             indexed.push({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.103.87",
+  "version": "0.103.89",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",