agent-yes 1.287.0 → 1.288.0

package/lab/ui/index.html

@@ -3622,12 +3622,6 @@
         // Always-on header-badge traffic ring (independent of the opt-in HUD below).
         if (kind === "in") traf.cin += n || 0;
         else if (kind === "out") traf.cout += n || 0;
-        // Also accumulate into the selected agent's per-agent ring (left-panel heatmap).
-        if (sel) {
-          const r = ioRing(sel);
-          if (kind === "in") r.i += n || 0;
-          else if (kind === "out") r.o += n || 0;
-        }
         if (!perfOn) return;
         if (kind === "in") {
           perf.inEvents++;
@@ -3725,28 +3719,9 @@
         traf.cin = traf.cout = 0;
         traf.hist = [];
       }
-      // Per-agent I/O ring for the LEFT-PANEL heatmap. Only the SELECTED agent has
-      // live I/O (the fwd/term.write hooks fire for it alone), so this map holds a
-      // rolling window of the traffic each agent saw while it was selected. Other
-      // rows keep their last-known window (empty → transparent). Mirrors traf's
-      // shape but is keyed by composite _key, sampled on the same 1s tick below.
-      const IO_N = 60;
-      const ioByKey = new Map();
-      function ioRing(key) {
-        let r = ioByKey.get(key);
-        if (!r) {
-          r = { i: 0, o: 0, hist: [] };
-          ioByKey.set(key, r);
-        }
-        return r;
-      }
-      function ioReset(key) {
-        const r = ioByKey.get(key);
-        if (r) {
-          r.i = r.o = 0;
-          r.hist = [];
-        }
-      }
+      // Cached /api/host response (system load + managed/unattributed split) for
+      // the room header line. Refreshed every list tick.
+      let hostRes = null;
       // The last winsize the agent's PTY reported (from /api/size), so the tooltip
       // can show OUR viewport vs the agent's render size. Reset on agent switch.
       let agentSize = null;
@@ -3881,15 +3856,9 @@
         traf.hist.push({ i: traf.cin, o: traf.cout });
         if (traf.hist.length > TRAF_N) traf.hist.shift();
         traf.cin = traf.cout = 0;
-        // Per-agent ring: sample the selected agent's current second, then repaint
-        // the list so its row heatmap advances (and paint the header badge).
-        const r = sel ? ioRing(sel) : null;
-        if (r) {
-          r.hist.push({ i: r.i, o: r.o });
-          if (r.hist.length > IO_N) r.hist.shift();
-          r.i = r.o = 0;
-          renderList();
-        }
+        // The per-agent heatmap now comes from the server sampler (/api/ls res
+        // field), refreshed on the 3s list poll — no front-end per-second
+        // sampling needed. Repaint the header badge (traffic tooltip) only.
         if (sel) paintHeaderBadge();
       }, 1000);
 
@@ -5934,6 +5903,28 @@ my.translate = async (text, lang) => {
       // as agent rows so the hierarchy reads as one tree. The room/peer layers
       // only appear here when there are ≥2 of them (single ones fold away in
       // layeredRows), so a header always disambiguates something real.
+      // Resource summary for the LOCAL room header line, sourced from /api/host:
+      //   XX%/YY% XXG/YYG of ZZG
+      // where XX = agent-yes managed, YY = unattributed (rest of the box). Only
+      // renders when hostRes has been fetched and the sampler has data.
+      function resLineHtml() {
+        if (!hostRes || !hostRes.resources) return "";
+        const r = hostRes.resources;
+        const memTotal = hostRes.mem && hostRes.mem.total ? hostRes.mem.total : null;
+        const managed = hsize(r.managed_rss);
+        const unattributed = hsize(r.unattributed_rss);
+        const total = memTotal ? hsize(memTotal) : null;
+        if (!total) return "";
+        return `  —  <span title="agent-yes managed / unattributed">${managed}/${unattributed}</span> of ${total}`;
+      }
+      function hsize(bytes) {
+        if (bytes === null || !Number.isFinite(bytes)) return "-";
+        if (bytes >= 1073741824) return (bytes / 1073741824).toFixed(1) + "G";
+        if (bytes >= 1048576) return Math.round(bytes / 1048576) + "M";
+        if (bytes >= 1024) return Math.round(bytes / 1024) + "K";
+        return bytes + "B";
+      }
+
       function headerHtml(r) {
         const icon = r.kind === "room" ? "▤" : "▣";
         // Peer headers carry their host's connection type (lan/wan/relay), so a
@@ -5942,7 +5933,8 @@ my.translate = async (text, lang) => {
           r.kind === "peer"
             ? connTagHtml(hostKinds.get((r.room || "") + " " + (r.host || "")))
             : "";
-        return `<div class="ghead g-${r.kind}">${r.branch ? `<span class="tbranch">${esc(r.branch)}</span>` : ""}<span class="gicon">${icon}</span><span class="glabel">${esc(r.label || "")}</span>${ctag}<span class="gkind">${r.kind}</span></div>`;
+        const resSuffix = r.kind === "room" ? resLineHtml() : "";
+        return `<div class="ghead g-${r.kind}">${r.branch ? `<span class="tbranch">${esc(r.branch)}</span>` : ""}<span class="gicon">${icon}</span><span class="glabel">${esc(r.label || "")}${resSuffix}</span>${ctag}<span class="gkind">${r.kind}</span></div>`;
       }
 
       // Extra row classes for collaborative presence: a yellow bar when a human
@@ -5982,29 +5974,42 @@ my.translate = async (text, lang) => {
           : "";
       }
 
-      // Build the low-contrast oklch heatmap backdrop for one agent row. The overlay
-      // sits BEHIND the text (absolute, low opacity), a horizontal gradient from
-      // transparent (old, left) → colour (recent, right). OUT (green) and IN (accent)
-      // are layered as two gradients so both directions read, but at low alpha so
-      // the agent name / status stay crisp on top.
-      function rowIoHeat(key) {
-        const r = ioByKey.get(key);
-        if (!r || !r.hist.length) return "";
-        const max = Math.max(1, ...r.hist.map((h) => Math.max(h.i, h.o)));
-        // A right-side "brightness ramp" is a hard-stop gradient; we approximate the
-        // per-second intensity by summing the last few buckets (rightmost = hottest).
-        const tail = Math.min(8, r.hist.length);
-        let o = 0, i = 0;
-        for (let k = r.hist.length - tail; k < r.hist.length; k++) { o += r.hist[k].o; i += r.hist[k].i; }
-        const aOut = Math.min(1, Math.log1p(o) / Math.log1p(max * tail));
-        const aIn = Math.min(1, Math.log1p(i) / Math.log1p(max * tail));
-        // Low-contrast: cap opacity well below what would muddle the label.
-        const oA = (aOut * 0.28).toFixed(2);
-        const iA = (aIn * 0.28).toFixed(2);
-        // oklch, two stacked linear-gradients, right-bright → left-fade.
-        return `<div class="ioheat" style="background:${JSON.stringify(
-          `linear-gradient(90deg, oklch(65% 0.14 152 / 0) 0%, oklch(65% 0.14 152 / ${oA}) 100%), linear-gradient(90deg, oklch(62% 0.16 255 / 0) 0%, oklch(62% 0.16 255 / ${iA}) 100%)`
-        )}"></div>`;
+      // Build the low-contrast oklch heatmap backdrop for one agent row, from the
+      // SERVER-side per-agent resource window (`entry.res`, fed by ayrs' sampler —
+      // CPU-seconds, RSS and process count per bucket, one point per minute-ish).
+      // Every row gets its own window (no selection required), painted BEHIND the
+      // text (absolute, low opacity). Two stacked rows: CPU (top, warm) and RSS
+      // (bottom, cool), each a per-bucket grid so a busy/fat burst reads as a solid
+      // block and idle as near-transparent. Right edge is the newest bucket.
+      function rowIoHeat(e) {
+        const res = e && e.res;
+        if (!res || !Array.isArray(res.cpu_seconds) || !res.cpu_seconds.length) return "";
+        const n = res.cpu_seconds.length;
+        const bucketSecs = res.bucket_secs || 60;
+        // CPU: normalize cpu_seconds (summed across the tree) to "fraction of one
+        // core" by dividing by the bucket width. Log-scaled so a 1% vs 100% spread
+        // reads better than a linear 0..1.
+        const cpuMax = Math.max(1e-9, ...res.cpu_seconds.map((s) => Math.abs(s) / bucketSecs));
+        const rssMax = Math.max(1, ...(res.rss || []).map((b) => b || 0));
+        const log1p = (v) => (v <= 0 ? 0 : Math.min(1, Math.log1p(v) / Math.log1p(cpuMax)));
+        const logRss = (v) =>
+          v <= 0 ? 0 : Math.min(1, Math.log1p(v / 1e6) / Math.log1p(rssMax / 1e6));
+        const w = 96,
+          h = 22,
+          colW = w / n,
+          rowH = (h - 2) / 2;
+        const cells = [];
+        for (let k = 0; k < n; k++) {
+          const x = k * colW;
+          const aCpu = log1p((res.cpu_seconds[k] || 0) / bucketSecs);
+          const aRss = logRss(res.rss ? res.rss[k] || 0 : 0);
+          // Low-contrast caps so the agent name / status stay crisp on top.
+          cells.push(
+            `<rect x="${x.toFixed(2)}" y="0" width="${(colW - 0.5).toFixed(2)}" height="${rowH.toFixed(2)}" fill="oklch(62% 0.15 35)" opacity="${(aCpu * 0.3).toFixed(2)}"/>`,
+            `<rect x="${x.toFixed(2)}" y="${(rowH + 2).toFixed(2)}" width="${(colW - 0.5).toFixed(2)}" height="${rowH.toFixed(2)}" fill="oklch(65% 0.14 262)" opacity="${(aRss * 0.3).toFixed(2)}"/>`,
+          );
+        }
+        return `<div class="ioheat"><svg width="${w}" height="${h}" viewBox="0 0 ${w} ${h}" preserveAspectRatio="none" shape-rendering="crispEdges" style="position:absolute;inset:0;width:100%;height:100%">${cells.join("")}</svg></div>`;
       }
       function renderList() {
         // The graph view (/r/) only exists on the hosted origin — a local
@@ -6049,7 +6054,7 @@ my.translate = async (text, lang) => {
                 const t = e.title || e.status_text || e.prompt || "";
                 const id = compactIdent(e, ctx, 3, r.parentEntry);
                 const cli = cliLabel(e);
-                return `<div class="row crow ${e._key === sel ? "sel" : ""}${rowFlags(e)}" data-key="${esc(e._key)}">${rowIoHeat(e._key)}
+                return `<div class="row crow ${e._key === sel ? "sel" : ""}${rowFlags(e)}" data-key="${esc(e._key)}">${rowIoHeat(e)}
         ${r.branch ? `<span class="tbranch">${esc(r.branch)}</span>` : ""}
         ${pinMarkHtml(e)}
         <span class="dot ${esc(e.status)}"></span>
@@ -6081,7 +6086,7 @@ my.translate = async (text, lang) => {
                     `<span class="rtag" data-k="${k}"><span style="opacity:.55">${k}:</span>${esc(v)}</span>`,
                 )
                 .join("");
-              return `<div class="row ${e._key === sel ? "sel" : ""}${rowFlags(e)}" data-key="${esc(e._key)}">${rowIoHeat(e._key)}
+              return `<div class="row ${e._key === sel ? "sel" : ""}${rowFlags(e)}" data-key="${esc(e._key)}">${rowIoHeat(e)}
         <div class="r1">${r.branch ? `<span class="tbranch">${esc(r.branch)}</span>` : ""}${pinMarkHtml(e)}<span class="dot ${esc(e.status)}"></span>
           <span class="name">${esc(cliLabel(e) || ident(e) || "agent")}</span>
           <span class="badge">pid ${e.pid}</span>
@@ -6157,6 +6162,14 @@ my.translate = async (text, lang) => {
       // so this stays a no-op on the wire for a modern fleet — it still re-renders
       // every tick, which keeps the relative "age" column fresh.
       async function loadList() {
+        // Refresh the local-host system snapshot for the room header line.
+        localTx
+          .fetchJSON("/api/host")
+          .then((h) => {
+            hostRes = h;
+          })
+          .catch(() => {});
+
         const srcs = [...sources.values()];
         await Promise.all(srcs.filter((s) => !s.streaming).map(listSource));
         mergeRender();
@@ -9430,9 +9443,18 @@ my.translate = async (text, lang) => {
           // The handle itself lives inside the tip; hit-test against it directly.
           if (!tip.contains(e.target)) return;
           if (e.clientY - tr.top > HANDLE) return;
-          drag = { id: e.pointerId, x: e.clientX, y: e.clientY, ox: tr.left, oy: tr.top, moved: false };
+          drag = {
+            id: e.pointerId,
+            x: e.clientX,
+            y: e.clientY,
+            ox: tr.left,
+            oy: tr.top,
+            moved: false,
+          };
           suppressClick = false;
-          try { tip.setPointerCapture(e.pointerId); } catch {}
+          try {
+            tip.setPointerCapture(e.pointerId);
+          } catch {}
           e.preventDefault();
         });
         pill.addEventListener("pointermove", (e) => {
@@ -9456,7 +9478,11 @@ my.translate = async (text, lang) => {
           const tip = tipEl();
           drag = null;
           if (tip) tip.classList.remove("dragging");
-          if (tip) { try { tip.releasePointerCapture(e.pointerId); } catch {} }
+          if (tip) {
+            try {
+              tip.releasePointerCapture(e.pointerId);
+            } catch {}
+          }
           if (!moved) return;
           if (tip) {
             pos = {
@@ -9464,7 +9490,9 @@ my.translate = async (text, lang) => {
               y: parseFloat(tip.style.top) || 8,
             };
           }
-          try { localStorage.setItem(KEY, JSON.stringify(pos)); } catch {}
+          try {
+            localStorage.setItem(KEY, JSON.stringify(pos));
+          } catch {}
           suppressClick = true;
           setTimeout(() => (suppressClick = false), 0);
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-yes",
-  "version": "1.287.0",
+  "version": "1.288.0",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "ai",
@@ -127,6 +127,7 @@
     "release": "standard-version && npm publish",
     "release:beta": "standard-version && npm publish --tag beta",
     "test": "vitest run",
+    "test:bun": "bun test --timeout 30000 .bun.",
     "test:coverage": "vitest run --coverage",
     "test:ui": "vitest run --config tests/ui-test/vitest.config.ts",
     "test:ui-dom": "vitest run --config tests/ui-dom/vitest.config.ts",

package/ts/JsonlStore.bun.spec.ts

@@ -0,0 +1,204 @@
+import { describe, expect, it, beforeEach, afterEach } from "bun:test";
+import { JsonlStore } from "./JsonlStore";
+import { rm, readFile, writeFile, mkdir } from "fs/promises";
+import path from "path";
+import os from "os";
+
+const TEST_DIR = path.join(os.tmpdir(), "jsonlstore-test-" + process.pid);
+const TEST_FILE = path.join(TEST_DIR, "test.jsonl");
+
+describe("JsonlStore", () => {
+  let store: JsonlStore;
+
+  beforeEach(async () => {
+    try {
+      await rm(TEST_DIR, { recursive: true, force: true });
+    } catch {
+      // ignore cleanup failures (e.g. Windows lock files from previous test)
+    }
+    await mkdir(TEST_DIR, { recursive: true });
+    store = new JsonlStore(TEST_FILE);
+  });
+
+  afterEach(async () => {
+    try {
+      await rm(TEST_DIR, { recursive: true, force: true });
+    } catch {
+      // ignore cleanup failures
+    }
+  });
+
+  describe("load", () => {
+    it("should return empty map for new file", async () => {
+      const docs = await store.load();
+      expect(docs.size).toBe(0);
+    });
+
+    it("should load existing JSONL data", async () => {
+      await writeFile(TEST_FILE, '{"_id":"1","name":"Alice"}\n{"_id":"2","name":"Bob"}\n');
+      const docs = await store.load();
+      expect(docs.size).toBe(2);
+      expect(docs.get("1")).toEqual({ _id: "1", name: "Alice" });
+    });
+
+    it("should merge duplicate IDs (last wins)", async () => {
+      await writeFile(
+        TEST_FILE,
+        '{"_id":"1","name":"Alice","age":30}\n{"_id":"1","name":"Alice Updated"}\n',
+      );
+      const docs = await store.load();
+      expect(docs.size).toBe(1);
+      expect(docs.get("1")).toEqual({ _id: "1", name: "Alice Updated", age: 30 });
+    });
+
+    it("should handle $$deleted tombstones", async () => {
+      await writeFile(TEST_FILE, '{"_id":"1","name":"Alice"}\n{"_id":"1","$$deleted":true}\n');
+      const docs = await store.load();
+      expect(docs.size).toBe(0);
+    });
+
+    it("should skip lines without _id", async () => {
+      await writeFile(TEST_FILE, '{"name":"no id"}\n{"_id":"1","name":"valid"}\n');
+      const docs = await store.load();
+      expect(docs.size).toBe(1);
+    });
+
+    it("should skip corrupt lines gracefully", async () => {
+      await writeFile(
+        TEST_FILE,
+        '{"_id":"1","name":"ok"}\n{corrupt json\n{"_id":"2","name":"also ok"}\n',
+      );
+      const docs = await store.load();
+      expect(docs.size).toBe(2);
+    });
+
+    it("should recover from temp file when main file missing", async () => {
+      const tempFile = TEST_FILE + "~";
+      await writeFile(tempFile, '{"_id":"1","name":"recovered"}\n');
+      const docs = await store.load();
+      expect(docs.size).toBe(1);
+      expect(docs.get("1")!.name).toBe("recovered");
+    });
+  });
+
+  describe("getAll / getById / find / findOne", () => {
+    beforeEach(async () => {
+      await writeFile(
+        TEST_FILE,
+        '{"_id":"1","name":"Alice","age":30}\n{"_id":"2","name":"Bob","age":25}\n{"_id":"3","name":"Charlie","age":35}\n',
+      );
+      await store.load();
+    });
+
+    it("getAll returns all documents", () => {
+      expect(store.getAll()).toHaveLength(3);
+    });
+
+    it("getById returns correct doc", () => {
+      expect(store.getById("2")).toEqual({ _id: "2", name: "Bob", age: 25 });
+    });
+
+    it("getById returns undefined for missing id", () => {
+      expect(store.getById("999")).toBeUndefined();
+    });
+
+    it("find returns matching docs", () => {
+      const result = store.find((d) => d.age > 28);
+      expect(result).toHaveLength(2);
+    });
+
+    it("findOne returns first match", () => {
+      const result = store.findOne((d) => d.age > 28);
+      expect(result).toBeDefined();
+      expect(result!.age).toBeGreaterThan(28);
+    });
+
+    it("findOne returns undefined when no match", () => {
+      expect(store.findOne((d) => d.age > 100)).toBeUndefined();
+    });
+  });
+
+  describe("append", () => {
+    it("should append and return doc with generated id", async () => {
+      await store.load();
+      const doc = await store.append({ name: "test" } as any);
+      expect(doc._id).toBeDefined();
+      expect(doc.name).toBe("test");
+      expect(store.getAll()).toHaveLength(1);
+    });
+
+    it("should append with provided _id", async () => {
+      await store.load();
+      const doc = await store.append({ _id: "custom-id", name: "test" } as any);
+      expect(doc._id).toBe("custom-id");
+    });
+
+    it("should merge with existing doc of same _id", async () => {
+      await store.load();
+      await store.append({ _id: "x", name: "first", value: 1 } as any);
+      await store.append({ _id: "x", name: "second" } as any);
+      const doc = store.getById("x")!;
+      expect(doc.name).toBe("second");
+      expect(doc.value).toBe(1);
+    });
+  });
+
+  describe("updateById", () => {
+    it("should update existing doc", async () => {
+      await store.load();
+      await store.append({ _id: "u1", name: "original", status: "active" } as any);
+      await store.updateById("u1", { status: "done" });
+      expect(store.getById("u1")!.status).toBe("done");
+      expect(store.getById("u1")!.name).toBe("original");
+    });
+
+    it("should no-op for non-existent id", async () => {
+      await store.load();
+      await store.updateById("nonexistent", { status: "done" });
+      expect(store.getAll()).toHaveLength(0);
+    });
+  });
+
+  describe("deleteById", () => {
+    it("should remove doc from memory and write tombstone", async () => {
+      await store.load();
+      await store.append({ _id: "d1", name: "to delete" } as any);
+      expect(store.getAll()).toHaveLength(1);
+
+      await store.deleteById("d1");
+      expect(store.getAll()).toHaveLength(0);
+      expect(store.getById("d1")).toBeUndefined();
+
+      // Tombstone should be written to file
+      const content = await readFile(TEST_FILE, "utf-8");
+      expect(content).toContain('"$$deleted":true');
+    });
+  });
+
+  describe("compact", () => {
+    it("should deduplicate entries", async () => {
+      await store.load();
+      await store.append({ _id: "c1", name: "v1" } as any);
+      await store.updateById("c1", { name: "v2" });
+      await store.updateById("c1", { name: "v3" });
+
+      // Before compact: 3 lines
+      const before = (await readFile(TEST_FILE, "utf-8")).trim().split("\n");
+      expect(before).toHaveLength(3);
+
+      await store.compact();
+
+      // After compact: 1 line
+      const after = (await readFile(TEST_FILE, "utf-8")).trim().split("\n");
+      expect(after).toHaveLength(1);
+      expect(JSON.parse(after[0]!).name).toBe("v3");
+    });
+
+    it("should handle empty store", async () => {
+      await store.load();
+      await store.compact();
+      const content = await readFile(TEST_FILE, "utf-8");
+      expect(content).toBe("");
+    });
+  });
+});

package/ts/ReadyManager.bun.spec.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from "bun:test";
+import { ReadyManager } from "./ReadyManager";
+
+describe("ReadyManager", () => {
+  it("should start in not ready state", () => {
+    const manager = new ReadyManager();
+    expect(manager.wait()).toBeInstanceOf(Promise);
+  });
+
+  it("should resolve wait when ready is called", async () => {
+    const manager = new ReadyManager();
+    const waitPromise = manager.wait();
+
+    manager.ready();
+
+    await expect(waitPromise).resolves.toBeUndefined();
+  });
+
+  it("should resolve immediately if already ready", async () => {
+    const manager = new ReadyManager();
+    manager.ready();
+
+    const result = manager.wait();
+    expect(result).toBeUndefined();
+  });
+
+  it("should handle multiple waiters", async () => {
+    const manager = new ReadyManager();
+    const wait1 = manager.wait();
+    const wait2 = manager.wait();
+    const wait3 = manager.wait();
+
+    manager.ready();
+
+    await Promise.all([
+      expect(wait1).resolves.toBeUndefined(),
+      expect(wait2).resolves.toBeUndefined(),
+      expect(wait3).resolves.toBeUndefined(),
+    ]);
+  });
+
+  it("should reset to not ready when unready is called", async () => {
+    const manager = new ReadyManager();
+    manager.ready();
+    manager.unready();
+
+    expect(manager.wait()).toBeInstanceOf(Promise);
+  });
+
+  it("should handle ready with no waiting queue", () => {
+    const manager = new ReadyManager();
+    manager.ready(); // Should not throw even if no one is waiting
+    expect(manager.wait()).toBeUndefined(); // Should be ready now
+  });
+
+  it("should handle multiple ready/unready cycles", async () => {
+    const manager = new ReadyManager();
+
+    // First cycle
+    const wait1 = manager.wait();
+    manager.ready();
+    await wait1;
+
+    // Reset
+    manager.unready();
+
+    // Second cycle
+    const wait2 = manager.wait();
+    manager.ready();
+    await expect(wait2).resolves.toBeUndefined();
+  });
+});

package/ts/agentNice.bun.spec.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "bun:test";
+import { agentNiceValue } from "./agentNice.ts";
+
+describe("agentNice.agentNiceValue", () => {
+  it("defaults to 5 when unset or empty", () => {
+    expect(agentNiceValue({})).toBe(5);
+    expect(agentNiceValue({ AGENT_YES_AGENT_NICE: "" })).toBe(5);
+  });
+
+  it("honors a valid positive value", () => {
+    expect(agentNiceValue({ AGENT_YES_AGENT_NICE: "10" })).toBe(10);
+    expect(agentNiceValue({ AGENT_YES_AGENT_NICE: "0" })).toBe(0); // 0 = disabled
+  });
+
+  it("clamps into the 0..19 nice range (never elevates)", () => {
+    expect(agentNiceValue({ AGENT_YES_AGENT_NICE: "-5" })).toBe(0); // no negative (needs CAP_SYS_NICE)
+    expect(agentNiceValue({ AGENT_YES_AGENT_NICE: "40" })).toBe(19);
+  });
+
+  it("falls back to the default on garbage", () => {
+    expect(agentNiceValue({ AGENT_YES_AGENT_NICE: "abc" })).toBe(5);
+    expect(agentNiceValue({ AGENT_YES_AGENT_NICE: "3.9" })).toBe(3); // truncates
+  });
+});