agentradar-cli 0.2.4 → 0.2.6

package/dist/agent-guard/scripts/guard.mjs

@@ -32,6 +32,7 @@ const RULES = [
   "Answer every message in the channel it came from, and a human first: someone is waiting.",
   `Acknowledge what you handled: ${call("acknowledge_messages")} --args '{"eventIds":[...]}' for messages, ${call("acknowledge_task")} --issueId <id> for a task you take on.`,
   "Talk is not a task: reply conversationally, and create a task only for trackable, billable work.",
+  "Write so a 13-year-old would understand: short, plain words, one next step, no ids or tool names unless asked. Say it once.",
   `Before you go idle, run ${call("agent_obligations")}: "owed" must be 0, and every in-progress task must be moving or waiting on someone who knows it.`,
 ];
 const MUST_NOTS = [

package/dist/agent-guard/skills/agentradar-discipline/SKILL.md

@@ -24,6 +24,7 @@ The Stop hook runs the same check and will not let you stop while something is o
 
 - Answer every message in the channel it came from. A human who wrote is waiting for you; answer them first.
 - Talk is not a task. Reply conversationally by default; create a task only for trackable, billable work.
+- Write to people so a 13-year-old would understand: a few short lines in plain words, ending with one next step (not a menu of options), no ids, tool names or internal terms unless asked. Say a thing once. Follow what they told you for the rest of the chat, and never offer to contact anyone else unless they ask.
 - Never ask for, print or pass on a credential. AgentRadar holds the keys.
 - When you ask another agent or a human something, call `expect_reply` on that thread with the time you need the answer by. If nobody answers, `next_event` wakes you with kind `followup`: chase them in the thread. If they stay silent, you may escalate to the next human up the chain from the person you wait on; that is your call, never required.
 - Only a human accepts your work. Asked to "mark it done": record the final state with `append_task_log`, then reply that it is finished and ready for them to accept. Never call `decide_outcome` or `declare_outcome` on your own task.

package/dist/agentradar-vendor/SKILL.md

@@ -20,8 +20,14 @@ You work on the vendor's computer and connect to AgentRadar through the `agentra
 
 Call `get_my_context` on the AgentRadar MCP FIRST, before any other tool. It returns your client organisation, your role and function, your goals, your metrics with their current quotas, your superior, your direct reports and your colleagues. It also carries your memory snapshot, the Markdown files in your personal vault: `recall` fetches newer files and `remember` saves a durable fact, preference or correction.
 
+In your first session, call `read_onboarding_obligations` once (reading them acknowledges the safety rules), then `read_readiness`.
+
 Your primary objective is to reach your quotas and drive the organisation forward in your role. Report each metric you own with `report_metric`. You may create metrics for yourself; you can never change your own quota — your superior sets it. Talk only in shared spaces (channels and tasks). You can create one-off tasks (`create_task`) and repeated tasks (`create_recurring_task`) for yourself, your colleagues and your direct subordinates — only for real trackable work, never for conversation.
 
+## Talking to people
+
+Write to people so a 13-year-old would understand: a few short plain lines, then one next step, not a menu. No ids, tool names or internal terms unless asked (say "the owner", "your team", "company memory"; name a plan with its monthly price). Answer only what was asked, and say it once. Keep to what a person told you all chat, say so before a step they may not expect (a web search, sending, hiring), and never offer to contact anyone unless asked. Never talk about how messages reach you. Do the obvious thing for "undo that"; if unclear, offer short choices. Check your tools before saying what is scheduled or done; never answer from memory.
+
 ## Work loop
 
 1. Use the AgentRadar MCP to receive the next event or assigned work.

package/dist/setup.js

@@ -7,6 +7,7 @@ import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
 import * as tls from "node:tls";
 import { promisify } from "node:util";
+import { syncJoinedSkills } from "./skill-install.js";
 const DEFAULT_API_URL = "https://vendor.agentradar.com/api";
 /** The service's CLI build (the CLI itself and the agent-guard plugin): `installCli` keeps it current, never the npx cache. */
 const cliDist = (home) => join(home, ".agentradar", "cli", "current", "dist");
@@ -604,6 +605,10 @@ export async function joinOrganisation(enrolmentUrl, deps = {}) {
         const runnerEnv = await installRunner(home, projectPath, { status: "approved", agentId, runnerId, installation, harness }, { sessionId, env });
         await saved?.();
         log(`Runner installed → ${runnerEnv}`);
+        // Best effort: a failed first sync never stops the join; the service's feeder syncs them again.
+        await syncJoinedSkills(runnerId, { home, fetch: fetchImpl, log }).catch((error) => {
+            log(`Your AgentRadar skills are not installed yet (${String(error?.message ?? error).split("\n")[0]}); the runner installs them once it is running.`);
+        });
         try {
             await (deps.installService ?? ((id) => installAgentService(id, home, env)))(runnerId);
         }

package/dist/skill-install.js

@@ -1,6 +1,9 @@
-import { chmod, lstat, mkdir, readFile, realpath, rename, unlink, writeFile } from "node:fs/promises";
+import { chmod, lstat, mkdir, readFile, readdir, realpath, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
-import { join } from "node:path";
+import { dirname, isAbsolute, join, normalize, sep } from "node:path";
+import { awpRequest, envValue } from "./tool-run.js";
+const MANAGED_MARK = ".agentradar-managed";
+const SKILL_NAME = /^[a-z0-9][a-z0-9-]{0,99}$/;
 async function ensureDirectory(path) {
     try {
         const info = await lstat(path);
@@ -38,7 +41,98 @@ export async function installVendorSkill(deps = {}) {
         });
     }
     // The runner keeps this skill current from AgentRadar; the marker says the folder is AgentRadar's to replace.
-    await writeFile(join(skillDir, ".agentradar-managed"), "Written by AgentRadar; replaced on every sync.\n");
+    await writeFile(join(skillDir, MANAGED_MARK), "Written by AgentRadar; replaced on every sync.\n");
     (deps.log ?? console.log)("AgentRadar vendor skill installed for this project.");
 }
+const isManaged = async (dir) => (await lstat(dir).then((info) => info.isDirectory(), () => false)) && (await lstat(join(dir, MANAGED_MARK)).then(() => true, () => false));
+/**
+ * The feeder's `writeManagedSkills` (templates/vendor-runner/feeder.mjs), for the CLI: the server's answer is
+ * untrusted input to this box, so names and paths are checked, each skill is staged then renamed into place,
+ * a folder without the marker (the vendor's own) is never touched, and a managed skill no longer listed goes.
+ */
+const sameSkill = async (dir, files) => {
+    try {
+        const have = [];
+        for (const p of await readdir(dir, { recursive: true }))
+            if (p !== MANAGED_MARK && (await stat(join(dir, p))).isFile())
+                have.push(p);
+        for (const f of files)
+            if (await readFile(join(dir, f.path), "utf8") !== f.content)
+                return false;
+        return have.length === files.length;
+    }
+    catch {
+        return false;
+    }
+};
+export async function writeManagedSkills(skillsDir, skills) {
+    await mkdir(skillsDir, { recursive: true });
+    const written = new Set();
+    for (const skill of skills) {
+        const name = String(skill?.name ?? "");
+        const target = join(skillsDir, name);
+        if (!SKILL_NAME.test(name))
+            continue;
+        if (await lstat(target).then(() => true, () => false) && !(await isManaged(target)))
+            continue;
+        const files = (Array.isArray(skill.files) ? skill.files : []);
+        if (files.some((f) => typeof f?.path !== "string" || typeof f?.content !== "string" || isAbsolute(f.path)
+            || normalize(f.path).split(sep).includes("..") || [".", MANAGED_MARK].includes(normalize(f.path))))
+            continue;
+        // An unchanged skill is not rewritten: the agent's CLI may be reading it.
+        if (await sameSkill(target, files)) {
+            written.add(name);
+            continue;
+        }
+        const staging = join(skillsDir, `.${name}.sync-${process.pid}`);
+        const old = join(skillsDir, `.${name}.old-${process.pid}`);
+        try {
+            await rm(staging, { recursive: true, force: true });
+            for (const f of files) {
+                await mkdir(dirname(join(staging, f.path)), { recursive: true });
+                await writeFile(join(staging, f.path), f.content);
+            }
+            await writeFile(join(staging, MANAGED_MARK), "Written by the AgentRadar runner; replaced on every sync.\n");
+            // Rename aside, then into place: the skill is missing for two renames, not for a recursive delete.
+            await rm(old, { recursive: true, force: true });
+            await rename(target, old).catch((err) => { if (err?.code !== "ENOENT")
+                throw err; });
+            await rename(staging, target);
+            await rm(old, { recursive: true, force: true });
+            written.add(name);
+        }
+        catch {
+            await rm(staging, { recursive: true, force: true });
+            if (!(await lstat(target).then(() => true, () => false)))
+                await rename(old, target).catch(() => { });
+            if (await isManaged(target))
+                written.add(name);
+        }
+    }
+    for (const entry of await readdir(skillsDir)) {
+        if (!written.has(entry) && await isManaged(join(skillsDir, entry)))
+            await rm(join(skillsDir, entry), { recursive: true, force: true });
+    }
+    return [...written];
+}
+/**
+ * R650 — a joined agent's AgentRadar skills (`my_skills`: the bundled set plus the ones linked to it), written
+ * at join into the directory its CLI reads, the feeder's `skillsDirFor`: Claude `$AR_BASE/.claude/skills`,
+ * Codex `$CODEX_HOME/skills`. Done here because a session that acts only through `agentradar run` has no
+ * feeder; where the service runs, its feeder keeps them current.
+ */
+export async function syncJoinedSkills(runnerId, deps) {
+    const env = await readFile(join(deps.home, ".agentradar", "agents", `${runnerId}.env`), "utf8");
+    const root = envValue(env, "AR_AGENT_HARNESS") === "codex" ? envValue(env, "CODEX_HOME") : envValue(env, "AR_BASE");
+    if (!root)
+        return;
+    const skillsDir = envValue(env, "AR_AGENT_HARNESS") === "codex" ? join(root, "skills") : join(root, ".claude", "skills");
+    const body = await awpRequest(runnerId, "tools/call", { name: "my_skills", arguments: {} }, { home: deps.home, fetch: deps.fetch, logError: deps.log });
+    const text = body?.result?.content?.find((c) => c.type === "text")?.text;
+    const answer = (text ? JSON.parse(text) : {});
+    if (!answer.ok || !Array.isArray(answer.skills))
+        throw new Error("AgentRadar did not return your skills");
+    const written = await writeManagedSkills(skillsDir, answer.skills);
+    deps.log(`Installed ${written.length} AgentRadar skill(s) in ${skillsDir}.`);
+}
 //# sourceMappingURL=skill-install.js.map

package/dist/tool-run.js

@@ -203,7 +203,7 @@ export async function callAwpTool(runnerId, name, toolArguments, deps) {
 }
 const RUNNER_ID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
 /** One JSON-RPC request on the runner's AWP MCP endpoint with the runner's own key; null after logging why it failed. */
-async function awpRequest(runnerId, method, params, deps) {
+export async function awpRequest(runnerId, method, params, deps) {
     const logError = deps.logError ?? console.error;
     if (!RUNNER_ID.test(runnerId)) {
         logError("Invalid runner ID");

package/dist/vendor-runner/feeder.mjs

@@ -663,6 +663,14 @@ const isManaged = (dir) => {
   const st = fs.lstatSync(dir, { throwIfNoEntry: false });
   return Boolean(st?.isDirectory() && fs.existsSync(join(dir, MANAGED_MARK)));
 };
+const sameSkill = (dir, files) => {
+  try {
+    const have = fs.readdirSync(dir, { recursive: true }).filter((p) => p !== MANAGED_MARK && fs.statSync(join(dir, p)).isFile());
+    return have.length === files.length && files.every((f) => fs.readFileSync(join(dir, f.path), "utf8") === f.content);
+  } catch {
+    return false;
+  }
+};
 
 export function writeManagedSkills(skillsDir, skills) {
   fs.mkdirSync(skillsDir, { recursive: true });
@@ -679,7 +687,11 @@ export function writeManagedSkills(skillsDir, skills) {
     const bad = files.find((f) => typeof f?.path !== "string" || typeof f?.content !== "string" || isAbsolute(f.path)
       || normalize(f.path).split(sep).includes("..") || [".", MANAGED_MARK].includes(normalize(f.path)));
     if (bad) { console.warn(`[feeder] skill sync: ${name} has an unsafe file path, skipped`); continue; }
+    // An unchanged skill is not rewritten: the agent's CLI may be reading it (Codex skipped a SKILL.md that a
+    // periodic resync had just removed).
+    if (sameSkill(target, files)) { written.add(name); continue; }
     const staging = join(skillsDir, `.${name}.sync-${process.pid}`);
+    const old = join(skillsDir, `.${name}.old-${process.pid}`);
     try {
       fs.rmSync(staging, { recursive: true, force: true });
       for (const f of files) {
@@ -687,12 +699,16 @@ export function writeManagedSkills(skillsDir, skills) {
         fs.writeFileSync(join(staging, f.path), f.content);
       }
       fs.writeFileSync(join(staging, MANAGED_MARK), "Written by the AgentRadar runner; replaced on every sync.\n");
-      fs.rmSync(target, { recursive: true, force: true });
+      // Rename aside, then into place: the skill is missing for two renames, not for a recursive delete.
+      fs.rmSync(old, { recursive: true, force: true });
+      if (fs.existsSync(target)) fs.renameSync(target, old);
       fs.renameSync(staging, target);
+      fs.rmSync(old, { recursive: true, force: true });
       written.add(name);
     } catch (err) {
       // One skill that cannot be written keeps its previous copy and does not stop the rest of the sync.
       fs.rmSync(staging, { recursive: true, force: true });
+      if (!fs.existsSync(target) && fs.existsSync(old)) fs.renameSync(old, target);
       if (isManaged(target)) written.add(name);
       console.warn(`[feeder] skill sync: ${name} not written: ${err instanceof Error ? err.message : String(err)}`);
     }

package/dist/vendor-runner/terminal-bridge.mjs

@@ -2,10 +2,11 @@
 //
 // Opens a persistent OUTBOUND WebSocket to the AgentRadar server (the mini INITIATES; the server never
 // connects inbound — phone-home preserved) and bridges the agent's tmux pane:
-//   - server {attach}  → start `tmux pipe-pane` → stream pane output as {output} frames (+ an initial
-//                        capture-pane so a late viewer sees the current screen).
-//   - server {detach}  → stop piping (idle agents cost nothing).
-//   - pane GEOMETRY    → {hello cols,rows} on connect + {geometry cols,rows} on change while attached (#9).
+//   - server {attach}  → attach a read-only tmux CONTROL-MODE client (`tmux -C attach -r`) → stream the pane's
+//                        `%output` as {output} frames, after a scrollback snapshot (`capture-pane -S -2000`) so a
+//                        late viewer can scroll back and lands on the current screen.
+//   - server {detach}  → kill the control client (idle agents cost nothing).
+//   - pane GEOMETRY    → {hello cols,rows} on connect + {geometry cols,rows} on each `%layout-change` (#9).
 //                        The server has no other way to know the pane size, and without it the client
 //                        watch-terminal renders every agent at a hardcoded 120×30.
 //   - server {input}   → `tmux send-keys -l` (VENDOR keystrokes; the server already dropped client input).
@@ -26,22 +27,20 @@ import { createHash, randomBytes } from "node:crypto";
 import fs from "node:fs";
 import http from "node:http";
 import https from "node:https";
-import os from "node:os";
-import path from "node:path";
+import { StringDecoder } from "node:string_decoder";
 
 const AWP_MCP_ENDPOINT = process.env.AWP_MCP_URL ?? "https://staging.agentradar.com/api/mcp";
-const AWP_BEARER = (() => {
+// Re-read on every connect: a hosted supervisor rewrites the file when it refreshes the run token.
+export function readBearer() {
   const f = process.env.AWP_BEARER_FILE;
-  if (f) {
-    try {
-      return fs.readFileSync(f, "utf8").trim();
-    } catch (e) {
-      console.error(`[bridge] FATAL: AWP_BEARER_FILE unreadable (${f}): ${e.message}`);
-      process.exit(1);
-    }
+  if (!f) return process.env.AWP_BEARER ?? "";
+  try {
+    return fs.readFileSync(f, "utf8").trim();
+  } catch (e) {
+    console.error(`[bridge] AWP_BEARER_FILE unreadable (${f}): ${e.message}`);
+    return "";
   }
-  return process.env.AWP_BEARER ?? "";
-})();
+}
 const TMUX_SESSION = process.env.TMUX_SESSION ?? "agent";
 // Resolve the tmux binary robustly: a bare "tmux" only works if it's on PATH, but the bridge is often
 // launched from a supervisor / LaunchAgent whose PATH excludes e.g. /opt/homebrew/bin — then every tmux
@@ -67,11 +66,7 @@ const RECONNECT_MAX_MS = Number(process.env.BRIDGE_RECONNECT_MAX_MS ?? "15000");
 // force-closed it — i.e. a ~5 min live-terminal blackout on EVERY deploy. Watch for ping silence ourselves so
 // recovery is ours, not the load balancer's.
 const SERVER_PING_TIMEOUT_MS = Number(process.env.BRIDGE_PING_TIMEOUT_MS ?? "90000"); // 3× the 30s server ping
-// #9: how often the pane size is re-read WHILE A VIEWER IS ATTACHED. tmux gives us no resize event, so the
-// only way to notice a pane change is to ask. The poll runs only between attach and detach, so an unwatched
-// agent still costs nothing, and a frame is sent only when the size actually CHANGED — an unchanged read is
-// one cheap tmux call and no traffic.
-const GEOMETRY_POLL_MS = Number(process.env.BRIDGE_GEOMETRY_POLL_MS ?? "5000");
+const SNAPSHOT_LINES = 2000;
 
 /**
  * #18: run `fn` at most once, however many times the returned function is called.
@@ -206,12 +201,37 @@ export function parsePaneGeometry(stdout) {
   return { cols, rows };
 }
 
+/**
+ * One line of tmux control-mode output → `{ type: "output", pane, data: Buffer }`, `{ type: "layout" }`,
+ * `{ type: "exit" }`, or null for everything else. `%output` data has bytes below 0x20 and `\` octal-escaped
+ * (`\015`); other bytes, UTF-8 included, pass through raw, so the line is handled as bytes (latin1), never text.
+ */
+export function parseControlLine(line) {
+  const s = Buffer.isBuffer(line) ? line.toString("latin1") : line;
+  if (s.startsWith("%output ")) {
+    const sp = s.indexOf(" ", 8);
+    if (sp < 0) return null;
+    const data = s.slice(sp + 1).replace(/\\([0-7]{3})/g, (_, o) => String.fromCharCode(parseInt(o, 8)));
+    return { type: "output", pane: s.slice(8, sp), data: Buffer.from(data, "latin1") };
+  }
+  if (s.startsWith("%layout-change ")) return { type: "layout" };
+  if (s.startsWith("%exit")) return { type: "exit" };
+  return null;
+}
+
+/**
+ * The scrollback snapshot as terminal text: history + visible screen, then the cursor put back where the pane
+ * has it, so live output that follows (relative cursor moves) lands in the right place.
+ */
+export function snapshotText(captured, cursor) {
+  const body = captured.replace(/\n$/, "");
+  return cursor ? `${body}\x1b[${cursor.y + 1};${cursor.x + 1}H` : body;
+}
+
 class TerminalBridge {
   constructor() {
     this.sock = null;
-    this.piping = false;
-    this.fifoPath = null;
-    this.fifoStream = null;
+    this.control = null; // the read-only tmux control-mode client while a viewer is attached
     this.recvBuf = Buffer.alloc(0);
     this.backoff = RECONNECT_MIN_MS;
     this.pingTimer = null;
@@ -219,7 +239,6 @@ class TerminalBridge {
     // Reset to null on every (re)connect — a reconnect may land on a different server task with no memory
     // of this session, so the new peer must be told even if the pane never moved.
     this.geometry = null;
-    this.geometryTimer = null;
   }
 
   /**
@@ -275,57 +294,52 @@ class TerminalBridge {
     this.send({ type: "geometry", cols: g.cols, rows: g.rows });
   }
 
-  startGeometryPoll() {
-    if (this.geometryTimer) return;
-    this.geometryTimer = setInterval(() => this.reportGeometry(), GEOMETRY_POLL_MS);
-    if (typeof this.geometryTimer.unref === "function") this.geometryTimer.unref();
-  }
-
-  stopGeometryPoll() {
-    if (!this.geometryTimer) return;
-    clearInterval(this.geometryTimer);
-    this.geometryTimer = null;
-  }
-
   startPipe() {
-    if (this.piping) return;
-    this.piping = true;
+    if (this.control) return;
     // #9: a viewer just attached — publish the real pane size before the first bytes, so the client sizes
     // its grid correctly rather than painting the replay into a fallback grid and re-flowing a moment later.
     this.reportGeometry(true);
-    this.startGeometryPoll();
-    // Initial screen so a viewer attaching mid-session sees current state.
-    const cap = tmux(["capture-pane", "-ep", "-t", TMUX_SESSION]);
-    if (cap.status === 0 && cap.stdout) this.send({ type: "output", data: cap.stdout });
-    // Stream new output via a fifo that tmux pipe-pane writes into.
-    this.fifoPath = path.join(os.tmpdir(), `ar-bridge-${process.pid}-${Date.now()}.fifo`);
-    spawnSync("mkfifo", [this.fifoPath]);
-    tmux(["pipe-pane", "-t", TMUX_SESSION, `cat >> ${this.fifoPath}`]);
-    this.fifoStream = fs.createReadStream(this.fifoPath);
-    this.fifoStream.on("data", (chunk) => this.send({ type: "output", data: chunk.toString("utf8") }));
-    this.fifoStream.on("error", () => {});
+    const pane = tmux(["display-message", "-p", "-t", TMUX_SESSION, "#{pane_id} #{cursor_x} #{cursor_y}"]);
+    const [paneId, cx, cy] = pane.status === 0 ? pane.stdout.trim().split(" ") : [];
+    const cap = tmux(["capture-pane", "-p", "-e", "-J", "-S", `-${SNAPSHOT_LINES}`, "-t", TMUX_SESSION]);
+    if (cap.status === 0 && cap.stdout) {
+      const cursor = cx !== undefined && cy !== undefined ? { x: Number(cx), y: Number(cy) } : null;
+      this.send({ type: "output", data: snapshotText(cap.stdout, cursor) });
+    }
+    // Read-only + ignore-size: the bridge can neither type into nor shrink the vendor's pane.
+    const child = spawn(TMUX_BIN, ["-C", "attach-session", "-r", "-t", TMUX_SESSION], {
+      stdio: ["pipe", "pipe", "ignore"],
+    });
+    this.control = child;
+    const decoder = new StringDecoder("utf8"); // a UTF-8 character can straddle two %output lines
+    let buf = Buffer.alloc(0);
+    child.stdout.on("data", (chunk) => {
+      buf = Buffer.concat([buf, chunk]);
+      let nl;
+      while ((nl = buf.indexOf(0x0a)) >= 0) {
+        const msg = parseControlLine(buf.subarray(0, nl));
+        buf = buf.subarray(nl + 1);
+        if (msg?.type === "output" && (!paneId || msg.pane === paneId)) {
+          const text = decoder.write(msg.data);
+          if (text) this.send({ type: "output", data: text });
+        } else if (msg?.type === "layout") this.reportGeometry();
+        else if (msg?.type === "exit") this.stopPipe();
+      }
+    });
+    child.on("error", () => {});
+    child.on("exit", () => {
+      if (this.control === child) this.control = null;
+    });
   }
 
   stopPipe() {
-    if (!this.piping) return;
-    this.piping = false;
-    this.stopGeometryPoll(); // #9: nobody is watching → stop asking tmux anything
-    tmux(["pipe-pane", "-t", TMUX_SESSION]); // empty command → stop piping
-    if (this.fifoStream) {
-      try {
-        this.fifoStream.destroy();
-      } catch {
-        /* ignore */
-      }
-      this.fifoStream = null;
-    }
-    if (this.fifoPath) {
-      try {
-        fs.unlinkSync(this.fifoPath);
-      } catch {
-        /* ignore */
-      }
-      this.fifoPath = null;
+    const child = this.control;
+    if (!child) return;
+    this.control = null;
+    try {
+      child.kill();
+    } catch {
+      /* already gone */
     }
   }
 
@@ -355,6 +369,8 @@ class TerminalBridge {
   }
 
   connect() {
+    const bearer = readBearer();
+    if (!bearer) return this.scheduleReconnect();
     const url = feederWsUrl();
     const key = randomBytes(16).toString("base64");
     const lib = url.protocol === "wss:" ? https : http;
@@ -369,7 +385,7 @@ class TerminalBridge {
         "Sec-WebSocket-Version": "13",
         "Sec-WebSocket-Key": key,
         // Auth rides the subprotocol (never a query param); NEVER logged.
-        "Sec-WebSocket-Protocol": `agentradar-feeder, ${AWP_BEARER}`,
+        "Sec-WebSocket-Protocol": `agentradar-feeder, ${bearer}`,
       },
     });
     req.on("upgrade", (res, socket) => {
@@ -459,7 +475,7 @@ class TerminalBridge {
 
 // Only auto-run when executed directly (not when imported by the unit test).
 if (import.meta.url === `file://${process.argv[1]}`) {
-  if (!AWP_BEARER) {
+  if (!readBearer()) {
     console.error("[bridge] FATAL: no AWP bearer (set AWP_BEARER_FILE or AWP_BEARER)");
     process.exit(1);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentradar-cli",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "engines": {
     "node": ">=20"
   },