@proagentstore/cli 0.4.74 → 0.4.76

package/dist/browser-runner/coding/engine-turn.js

@@ -29,17 +29,39 @@ export const MAX_TURN_DETAIL = 240;
 export const MAX_TURN_TAIL_LINES = 60;
 export const MAX_TURN_TAIL_LINE = 400;
 export const MAX_TURN_TAIL_CHARS = 8000;
-/** Append one line of the turn's own output to its tail, keeping the newest within the bounds above. */
+/** Leads a tail that has lost its oldest lines, with how many (#898). */
+const DROPPED_LINE = /^\[(\d+) earlier lines? of this turn not kept\]$/;
+/**
+ * Append one line of the turn's own output to its tail, keeping the newest within the bounds above.
+ *
+ * What falls off the front is COUNTED, in a first line that says so (#898): the cloud reports "the
+ * last N lines", and a tail that silently lost its head made N read as all the turn printed.
+ */
 export function appendTurnTail(tail, line) {
     const text = line.trim();
     if (!text)
         return;
+    const marked = tail.length ? DROPPED_LINE.exec(tail[0]) : null;
+    let dropped = marked ? Number(marked[1]) : 0;
+    if (marked)
+        tail.shift();
     tail.push(text.length > MAX_TURN_TAIL_LINE ? `${text.slice(0, MAX_TURN_TAIL_LINE)}…` : text);
-    while (tail.length > MAX_TURN_TAIL_LINES)
+    while (tail.length > MAX_TURN_TAIL_LINES - 1) {
         tail.shift();
+        dropped++;
+    }
     let total = tail.reduce((n, l) => n + l.length + 1, 0);
-    while (total > MAX_TURN_TAIL_CHARS && tail.length > 1)
+    // Room is kept for the count line itself, so the tail stays inside its total bound.
+    while (total > MAX_TURN_TAIL_CHARS - 48 && tail.length > 1) {
         total -= tail.shift().length + 1;
+        dropped++;
+    }
+    if (dropped)
+        tail.unshift(`[${dropped} earlier line${dropped === 1 ? "" : "s"} of this turn not kept]`);
+}
+/** The engine's last line within {@link MAX_TURN_DETAIL}, with an ellipsis when it was cut (#898). */
+function detailOf(text) {
+    return text.length > MAX_TURN_DETAIL ? `${text.slice(0, MAX_TURN_DETAIL)}…` : text;
 }
 /**
  * A one-shot turn's process has exited — say what that means, and nothing more.
@@ -49,7 +71,7 @@ export function appendTurnTail(tail, line) {
  * failure would let three slow builds read as a broken CLI.
  */
 export function turnReportFromExit(code, signal, lastLine = "", now = Date.now(), tail = []) {
-    const detail = (lastLine.trim() || tail.at(-1) || "").slice(0, MAX_TURN_DETAIL);
+    const detail = detailOf(lastLine.trim() || tail.at(-1) || "");
     const verdict = signal !== null ? "killed" : code === 0 ? "ok" : "failed";
     return {
         verdict,
@@ -68,7 +90,7 @@ export function turnReportFromExit(code, signal, lastLine = "", now = Date.now()
  * case that runs most.
  */
 export function turnReportFromResult(isError, detail = "", now = Date.now(), tail = []) {
-    const text = detail.trim().slice(0, MAX_TURN_DETAIL);
+    const text = detailOf(detail.trim());
     return {
         verdict: isError ? "failed" : "ok",
         exitCode: null,

package/dist/browser-runner/coding/headless.js

@@ -59,6 +59,8 @@ export class HeadlessSession {
     proc = null;
     buf = "";
     transcript = [];
+    /** Records trimmed off the front of {@link transcript} — said in the pane, never silent (#898). */
+    droppedRecords = 0;
     run = "idle";
     /** Claude Code's own session id (from the init event) — used to --resume. */
     claudeSessionId = null;
@@ -293,6 +295,10 @@ export class HeadlessSession {
     get lastTurn() {
         return this.turnReport;
     }
+    /** The engine process's pid while one is running — what per-session resource attribution reads (#924). */
+    get pid() {
+        return this.procAlive ? (this.proc?.pid ?? null) : null;
+    }
     /** Is a process running THIS instant? The persistent engine's liveness, and the spawn guard. */
     get procAlive() {
         return this.proc !== null && this.proc.exitCode === null && this.proc.signalCode === null;
@@ -351,7 +357,8 @@ export class HeadlessSession {
     }
     /** The rendered conversation the brain/console reads (Claude's real output). */
     snapshot() {
-        return this.transcript.join("\n");
+        const text = this.transcript.join("\n");
+        return this.droppedRecords > 0 ? `[${this.droppedRecords} earlier lines of this session's output are no longer kept]\n${text}` : text;
     }
     /** Launch (or resume) the agent process. Idempotent if already alive. */
     /**
@@ -691,6 +698,10 @@ export class HeadlessSession {
         if (this.buf.length > cap) {
             if (this.mode === "raw")
                 this.pushRaw(this.buf);
+            // Said in the pane (#898): an event this size was discarded whole, and a reader could not
+            // tell a dropped tool result from one that never came.
+            else
+                this.push(`[a ${this.buf.length.toLocaleString("en-US")}-character line of engine output was too large to keep and was dropped]`);
             this.buf = "";
         }
     }
@@ -730,8 +741,14 @@ export class HeadlessSession {
             // never scraped back out of the rendered pane.
             this.turnLastLine = clean.trim();
         }
-        if (this.transcript.length > 4000)
-            this.transcript = this.transcript.slice(-3000);
+        this.trimTranscript();
+    }
+    /** Keep the newest 3,000 records once past 4,000, and COUNT what went (#898). */
+    trimTranscript() {
+        if (this.transcript.length <= 4000)
+            return;
+        this.droppedRecords += this.transcript.length - 3000;
+        this.transcript = this.transcript.slice(-3000);
     }
     handle(line) {
         const events = this.adapter.parseLine(line);
@@ -808,8 +825,7 @@ export class HeadlessSession {
         // Keep the in-memory transcript bounded. Counts ENTRIES, and an entry may now be a
         // multi-line block (a result, or a long assistant reply) rather than one line — the
         // character bound that matters is `MAX_PANE` in runtime.ts, applied on the way out.
-        if (this.transcript.length > 4000)
-            this.transcript = this.transcript.slice(-3000);
+        this.trimTranscript();
         return events.length > 0;
     }
     push(line) {

package/dist/browser-runner/coding/inspect.js

@@ -272,7 +272,9 @@ export function repoSearch(workDir, opts) {
     const limit = Math.max(1, Math.min(SEARCH_MAX_RESULTS, Math.floor(opts.maxResults ?? SEARCH_MAX_RESULTS)));
     const relPath = opts.path ? relative(workDir, resolveInside(workDir, opts.path)) : undefined;
     const argv = mode === "content"
-        ? ["grep", "-n", "-I", "-i", "-F", "--untracked", "--max-count", String(SEARCH_PER_FILE), "-e", pattern]
+        ? // No `--max-count` (#898): git stopped at 5 per file and `total` counted only those, so a
+            // file with 200 matches read as one with 5. The per-file cap is applied below, COUNTED.
+            ["grep", "-n", "-I", "-i", "-F", "--untracked", "-e", pattern]
         : // Tracked PLUS untracked-not-ignored: a file created ten minutes ago is exactly the one
             // somebody is trying to find, and `ls-files` alone would deny it exists.
             ["ls-files", "--cached", "--others", "--exclude-standard"];
@@ -297,12 +299,33 @@ export function repoSearch(workDir, opts) {
             throw new InspectError(err.message || `git ${mode} search failed`);
     }
     const lines = out.split("\n").filter((l) => l !== "");
-    const all = mode === "content"
-        ? lines.map(parseGrepLine).filter((m) => m !== null)
-        : // The pattern never reaches git here — the filter is a plain case-insensitive substring
-            // over the path, which is what "find the file called X" actually means.
-            lines.filter((p) => p.toLowerCase().includes(pattern.toLowerCase())).map((p) => ({ path: p }));
-    return { mode, pattern, matches: all.slice(0, limit), shown: Math.min(all.length, limit), total: all.length, truncated: all.length > limit };
+    if (mode === "path") {
+        // The pattern never reaches git here — the filter is a plain case-insensitive substring
+        // over the path, which is what "find the file called X" actually means.
+        const all = lines.filter((p) => p.toLowerCase().includes(pattern.toLowerCase())).map((p) => ({ path: p }));
+        return { mode, pattern, matches: all.slice(0, limit), shown: Math.min(all.length, limit), total: all.length, truncated: all.length > limit };
+    }
+    const all = lines.map(parseGrepLine).filter((m) => m !== null);
+    const perFile = new Map();
+    const omittedPerFile = {};
+    const capped = all.filter((m) => {
+        const n = (perFile.get(m.path) ?? 0) + 1;
+        perFile.set(m.path, n);
+        if (n <= SEARCH_PER_FILE)
+            return true;
+        omittedPerFile[m.path] = (omittedPerFile[m.path] ?? 0) + 1;
+        return false;
+    });
+    const matches = capped.slice(0, limit);
+    return {
+        mode,
+        pattern,
+        matches,
+        shown: matches.length,
+        total: all.length,
+        truncated: matches.length < all.length,
+        ...(Object.keys(omittedPerFile).length ? { omittedPerFile } : {}),
+    };
 }
 /** `path:line:text` — split on the FIRST two colons only, since code is full of them. */
 function parseGrepLine(line) {
@@ -315,7 +338,9 @@ function parseGrepLine(line) {
     const n = Number.parseInt(line.slice(first + 1, second), 10);
     if (!Number.isFinite(n))
         return null;
-    return { path: line.slice(0, first), line: n, text: line.slice(second + 1).trim().slice(0, SEARCH_MAX_LINE) };
+    const text = line.slice(second + 1).trim();
+    // Marked (#898): a cut line read as the whole line. `repo_read_file` with `startLine` has the rest.
+    return { path: line.slice(0, first), line: n, text: text.length > SEARCH_MAX_LINE ? `${text.slice(0, SEARCH_MAX_LINE)}…` : text };
 }
 /** The deepest `maxDepth` this will honour. Named because the TOOL has to say it (#508). */
 export const TREE_MAX_DEPTH = 4;
@@ -342,6 +367,10 @@ export function repoTree(workDir, relPath = ".", maxDepth = 3, maxEntries = 500)
     const queue = [{ dir: start, depth: 0 }];
     let truncated = false;
     let truncatedByDepth = false;
+    // Dot-entries ARE listed now (#898): `.github/`, `.env.example`, `.claude/` were hidden with
+    // nothing saying so. What is still skipped is named in `skipped`, so absence is never a claim.
+    const skipped = new Set();
+    const result = () => ({ root: relPath, entries, truncated, truncatedByDepth, depthCap, ...(skipped.size ? { skipped: [...skipped].sort() } : {}) });
     while (queue.length) {
         const { dir, depth } = queue.shift();
         let items;
@@ -352,11 +381,13 @@ export function repoTree(workDir, relPath = ".", maxDepth = 3, maxEntries = 500)
             continue;
         }
         for (const it of items) {
-            if (it.name.startsWith(".") || IGNORE_DIRS.has(it.name))
+            if (IGNORE_DIRS.has(it.name)) {
+                skipped.add(it.name);
                 continue;
+            }
             if (entries.length >= entryCap) {
                 truncated = true;
-                return { root: relPath, entries, truncated, truncatedByDepth, depthCap };
+                return result();
             }
             const abs = resolve(dir, it.name);
             const rel = relative(workDir, abs);
@@ -387,7 +418,7 @@ export function repoTree(workDir, relPath = ".", maxDepth = 3, maxEntries = 500)
             }
         }
     }
-    return { root: relPath, entries, truncated, truncatedByDepth, depthCap };
+    return result();
 }
 export const SYNC_FETCH_TTL_MS = 60_000;
 /** Per work-tree root: when the last fetch attempt was made and how it went. */

package/dist/browser-runner/coding/runtime.js

@@ -189,10 +189,12 @@ export class CodingRuntime {
         // `[exited with code N]` / `[error]` lines recorded on exit. Blanking it when the
         // process is dead lost exactly the output + failure reason the brain/console needs
         // to diagnose a crash or read a one-shot CLI's final result.
-        const pane = clip(session.snapshot());
+        const full = session.snapshot();
+        const pane = clip(full);
         return {
             sessionId,
             pane,
+            paneChars: full.length,
             alive,
             ready: alive ? session.ready : false,
             runState: alive ? session.runState() : "idle",
@@ -284,6 +286,10 @@ export class CodingRuntime {
             runState: s.runState(),
         }));
     }
+    /** Every session with a live engine process, and its pid — the roots resource attribution walks (#924). */
+    enginePids() {
+        return [...this.sessions.entries()].flatMap(([sessionId, s]) => (s.pid ? [{ sessionId, engineLabel: s.engineLabel, pid: s.pid }] : []));
+    }
     /** Rich diagnostics for every tracked session — the console's transparency view. */
     diagnostics() {
         return [...this.sessions.entries()].map(([sessionId, s]) => ({
@@ -391,6 +397,7 @@ export class CodingRuntime {
         return session;
     }
 }
+/** The tail, marked (#898): the head it drops is said, with both numbers, at the top. */
 function clip(pane) {
-    return pane.length > MAX_PANE ? pane.slice(pane.length - MAX_PANE) : pane;
+    return pane.length > MAX_PANE ? `[cut: showing the last ${MAX_PANE} of ${pane.length} characters]\n${pane.slice(pane.length - MAX_PANE)}` : pane;
 }

package/dist/browser-runner/coding/session-resources.js

@@ -0,0 +1,67 @@
+/**
+ * Which coding session is using the machine (#924).
+ *
+ * The heartbeat says a machine is loaded; this says WHICH agent is loading it. Each session's engine
+ * is a child process that spawns its own (an engine's tools, a test runner, a build), so a session's
+ * share is its engine process plus every descendant. One `ps` per heartbeat reads the whole process
+ * table — the attribution is computed here from it, never by a `ps` per session.
+ *
+ * Not on Windows (no `ps`): the reading is absent there, which the platform reports as "not
+ * reported", never as zero.
+ */
+import { execFileSync } from "node:child_process";
+/** `ps -A -o pid=,ppid=,rss=,pcpu=` output → rows. A line that does not parse is skipped. */
+export function parsePs(text) {
+    const rows = [];
+    for (const line of text.split("\n")) {
+        const [pid, ppid, rss, cpu] = line.trim().split(/\s+/).map(Number);
+        if ([pid, ppid, rss, cpu].every((n) => Number.isFinite(n)))
+            rows.push({ pid, ppid, rssKb: rss, cpuPct: cpu });
+    }
+    return rows;
+}
+/** Each root's own row plus all its descendants', summed. Pure, so the tree walk is testable. */
+export function attribute(rows, roots) {
+    const children = new Map();
+    const byPid = new Map();
+    for (const r of rows) {
+        byPid.set(r.pid, r);
+        children.set(r.ppid, [...(children.get(r.ppid) ?? []), r]);
+    }
+    return roots.flatMap((root) => {
+        const top = byPid.get(root.pid);
+        if (!top)
+            return [];
+        let processes = 0;
+        let rssKb = 0;
+        let cpuPct = 0;
+        const seen = new Set();
+        const stack = [top];
+        while (stack.length) {
+            const r = stack.pop();
+            if (seen.has(r.pid))
+                continue;
+            seen.add(r.pid);
+            processes++;
+            rssKb += r.rssKb;
+            cpuPct += r.cpuPct;
+            stack.push(...(children.get(r.pid) ?? []));
+        }
+        return [{ sessionId: root.sessionId, engineLabel: root.engineLabel, pid: root.pid, processes, rssBytes: rssKb * 1024, cpuPct: Math.round(cpuPct * 10) / 10 }];
+    });
+}
+/** Read the process table once and attribute it to the live engines. Null when it cannot be read. */
+export function readSessionResources(roots) {
+    if (process.platform === "win32")
+        return null;
+    if (!roots.length)
+        return [];
+    try {
+        const out = execFileSync("ps", ["-A", "-o", "pid=,ppid=,rss=,pcpu="], { encoding: "utf-8", timeout: 2000, maxBuffer: 8 * 1024 * 1024 });
+        return attribute(parsePs(out), roots);
+    }
+    catch {
+        // A `ps` that failed or timed out is "not read this beat", which the null says — never zeros.
+        return null;
+    }
+}

package/dist/browser-runner/server.js

@@ -199,6 +199,11 @@ async function route(runner, req, res) {
     if (req.method === "GET" && path === "/coding/sessions") {
         return json(res, 200, { sessions: runner.coding.list() });
     }
+    // Per-session CPU and memory, for the heartbeat (#924): which agent is loading this machine.
+    if (req.method === "GET" && path === "/coding/resources") {
+        const { readSessionResources } = await import("./coding/session-resources.js");
+        return json(res, 200, { sessions: readSessionResources(runner.coding.enginePids()) });
+    }
     if ((req.method === "GET" || req.method === "POST") && path === "/coding/diagnostics") {
         // No tmux figures here any more (#247). The coding engine spawns a child process
         // directly, so `pagsTmuxTotal` was structurally always 0 and `tmuxTotal` counted the
@@ -304,15 +309,16 @@ async function route(runner, req, res) {
         const raw = (b.dir || "~").replace(/^~(?=$|\/)/, homedir());
         const dir = resolve(raw);
         try {
-            const entries = readdirSync(dir, { withFileTypes: true })
-                .filter((e) => !e.name.startsWith("."))
+            const visible = readdirSync(dir, { withFileTypes: true }).filter((e) => !e.name.startsWith("."));
+            const entries = visible
                 .slice(0, 200)
                 .map((e) => ({
                 name: e.name,
                 type: e.isDirectory() ? "dir" : "file",
                 size: e.isFile() ? statSync(resolve(dir, e.name)).size : undefined,
             }));
-            return json(res, 200, { dir, entries });
+            // Said, not silent (#898): a folder of 500 entries read as one of 200.
+            return json(res, 200, { dir, entries, ...(visible.length > entries.length ? { total: visible.length, truncated: true } : {}) });
         }
         catch (e) {
             return json(res, 400, { error: e instanceof Error ? e.message : String(e), dir });

package/dist/index.js

@@ -1205,10 +1205,40 @@ async function waitForLocalRunner(opts, timeoutMs = 15e3) {
 import { hostname as hostname3 } from "os";
 
 // src/commands/runner/resources.ts
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync5, statfsSync, writeFileSync as writeFileSync4 } from "fs";
 import os from "os";
-function sampleResources(read = os, now = Date.now()) {
+import { dirname as dirname2, join as join6 } from "path";
+var CHECKOUT_ROOT = join6(os.homedir(), ".config", "proagentstore", "repos");
+function sampleDisk(path = CHECKOUT_ROOT, statfs = statfsSync) {
+  for (const p of [path, os.homedir()]) {
+    try {
+      const s = statfs(p);
+      return { path: p, totalBytes: Number(s.blocks) * Number(s.bsize), freeBytes: Number(s.bavail) * Number(s.bsize), inodesTotal: Number(s.files), inodesFree: Number(s.ffree) };
+    } catch {
+    }
+  }
+  return null;
+}
+var STARTS_FILE = join6(os.homedir(), ".config", "proagentstore", "runner-starts.json");
+function recordRunnerStart(now = Date.now(), file = STARTS_FILE) {
+  let starts = [];
+  try {
+    const parsed = JSON.parse(readFileSync5(file, "utf-8"));
+    if (Array.isArray(parsed)) starts = parsed.filter((t) => typeof t === "number" && Number.isFinite(t));
+  } catch {
+  }
+  starts = [...starts.filter((t) => now - t < 24 * 60 * 60 * 1e3), now].slice(-200);
+  try {
+    mkdirSync4(dirname2(file), { recursive: true });
+    writeFileSync4(file, JSON.stringify(starts));
+  } catch {
+  }
+  return starts.length;
+}
+function sampleResources(read = os, now = Date.now(), extra = {}) {
   const [l1 = 0, l5 = 0, l15 = 0] = read.loadavg();
   return {
+    ...Object.fromEntries(Object.entries(extra).filter(([, v]) => v !== void 0)),
     loadAvg: [l1, l5, l15],
     // `availableParallelism` would be better, but `cpus()` is what every supported Node has.
     cpus: Math.max(1, read.cpus().length),
@@ -1413,6 +1443,9 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
     }
   };
   const attached = /* @__PURE__ */ new Map();
+  const processStartedAt = Date.now();
+  const starts24h = recordRunnerStart(processStartedAt);
+  let relayReconnects = 0;
   const blocked = /* @__PURE__ */ new Set();
   let syncing = Promise.resolve();
   const forceNext = /* @__PURE__ */ new Set();
@@ -1528,6 +1561,7 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
         // and taken when it did not — which is how a register lost to a boot-time
         // `fetch failed` finally gets a second chance.
         async (openedId, reconnect) => {
+          if (reconnect) relayReconnects++;
           if (!shouldRegisterOnOpen(reconnect, registered.has(openedId))) return;
           await registerRuntime(openedId, reconnect ? false : force);
           reportRegistration();
@@ -1559,7 +1593,14 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
   const heartbeat = () => {
     const timer = setTimeout(async () => {
       let failure = null;
-      const resources = sampleResources();
+      const first = attached.values().next().value;
+      const [relayRttMs, sessions] = await Promise.all([first ? first.probeRtt() : Promise.resolve(null), readSessionResources(localUrl, runnerToken)]);
+      const resources = sampleResources(void 0, void 0, {
+        disk: sampleDisk() ?? void 0,
+        runner: { startedAt: processStartedAt, uptimeSec: Math.round(process.uptime()), starts24h, relayReconnects },
+        relayRttMs,
+        sessions: sessions ?? void 0
+      });
       for (const id of [...attached.keys()]) {
         try {
           await requestPags("POST", `/v1/instances/${apiPathSegment(id)}/runtime/heartbeat`, opts, { runnerNode, resources });
@@ -1639,6 +1680,18 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
     tick();
   }
 }
+async function readSessionResources(localUrl, runnerToken) {
+  try {
+    const res = await fetch(`${localUrl}/coding/resources`, { headers: { Authorization: `Bearer ${runnerToken}` }, signal: AbortSignal.timeout(3e3) });
+    if (!res.ok) return null;
+    const body = await res.json();
+    return Array.isArray(body.sessions) ? body.sessions : null;
+  } catch {
+    return null;
+  }
+}
+var RTT_PROBE_PREFIX = "rtt:";
+var RTT_ECHO_PREFIX = "rtt-echo:";
 function openRelaySocket(instanceId, wsBase, mintToken, localUrl, runnerToken, force = false, onConflict, onOpen, onControl, runnerNode = hostname3()) {
   let backoffMs = 1e3;
   let reconnecting = false;
@@ -1646,6 +1699,7 @@ function openRelaySocket(instanceId, wsBase, mintToken, localUrl, runnerToken, f
   let opened = false;
   let socket = null;
   let retryTimer = null;
+  const rttWaiters = /* @__PURE__ */ new Map();
   const connect = async () => {
     if (closed) return;
     let relayToken;
@@ -1686,6 +1740,10 @@ function openRelaySocket(instanceId, wsBase, mintToken, localUrl, runnerToken, f
         }
         return;
       }
+      if (text.startsWith(RTT_ECHO_PREFIX)) {
+        rttWaiters.get(text.slice(RTT_ECHO_PREFIX.length))?.(Date.now());
+        return;
+      }
       let cmd;
       try {
         cmd = JSON.parse(text);
@@ -1718,7 +1776,7 @@ function openRelaySocket(instanceId, wsBase, mintToken, localUrl, runnerToken, f
         try {
           result = text2 ? JSON.parse(text2) : {};
         } catch {
-          result = { raw: text2.slice(0, 500) };
+          result = text2.length > 500 ? { raw: text2.slice(0, 500), rawChars: text2.length, truncated: true } : { raw: text2 };
         }
         try {
           ws.send(JSON.stringify({ id: cmd.id, status: res.status, result }));
@@ -1766,6 +1824,31 @@ function openRelaySocket(instanceId, wsBase, mintToken, localUrl, runnerToken, f
       } catch {
       }
       socket = null;
+    },
+    probeRtt(timeoutMs = 5e3) {
+      const ws = socket;
+      if (!ws || ws.readyState !== WebSocket.OPEN) return Promise.resolve(null);
+      const id = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+      const sentAt = Date.now();
+      return new Promise((resolveRtt) => {
+        const timer = setTimeout(() => {
+          rttWaiters.delete(id);
+          resolveRtt(null);
+        }, timeoutMs);
+        timer.unref?.();
+        rttWaiters.set(id, (echoedAt) => {
+          clearTimeout(timer);
+          rttWaiters.delete(id);
+          resolveRtt(echoedAt - sentAt);
+        });
+        try {
+          ws.send(`${RTT_PROBE_PREFIX}${id}`);
+        } catch {
+          clearTimeout(timer);
+          rttWaiters.delete(id);
+          resolveRtt(null);
+        }
+      });
     }
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proagentstore/cli",
-  "version": "0.4.74",
+  "version": "0.4.76",
   "description": "CLI for creating, publishing, and running ProAgentStore agents",
   "license": "MIT",
   "type": "module",