@snowyroad/braid 0.83.0 → 0.84.1

package/dist/{chunk-QDDQF6RJ.js → chunk-PQGSJM2V.js}

@@ -389,7 +389,7 @@ var InviteExpiredError = class extends Error {
   }
 };
 async function redeemInvite(relayHttpUrl, code) {
-  const { boundedJsonFetch: boundedJsonFetch2 } = await import("./http-4PYTQSSA.js");
+  const { boundedJsonFetch: boundedJsonFetch2 } = await import("./http-SXNTO4ON.js");
   const r = await boundedJsonFetch2(`${relayHttpUrl.replace(/\/$/, "")}/invites/redeem`, {
     method: "POST",
     headers: { "content-type": "application/json" },
@@ -478,7 +478,7 @@ function validateReplacementToken(newToken, currentToken, nowMs = Date.now()) {
   return { ok: true };
 }
 async function mintAccessToken(relayHttpUrl, agentKey, fetchFn = fetch, dpopProof) {
-  const { boundedJsonFetch: boundedJsonFetch2 } = await import("./http-4PYTQSSA.js");
+  const { boundedJsonFetch: boundedJsonFetch2 } = await import("./http-SXNTO4ON.js");
   const r = await boundedJsonFetch2(`${relayHttpUrl.replace(/\/$/, "")}/agents/token`, {
     method: "POST",
     headers: {
@@ -1361,16 +1361,26 @@ function pickAllowOption(req) {
     "ACP request_permission had no allow option (allow_once/allow_always); refusing to auto-select a non-allow option"
   );
 }
+function safeAcpToolName(tc) {
+  const title = tc?.title;
+  if (typeof title === "string") {
+    const m = /^mcp__[A-Za-z0-9_.-]+__([A-Za-z0-9_.-]+)$/.exec(title);
+    if (m) return m[1];
+  }
+  return tc?.kind ?? "unknown";
+}
 var AcpClient = class {
-  constructor(launch, scopeWrap, afterChildExitHook) {
+  constructor(launch, scopeWrap, afterChildExitHook, telemetry) {
     this.launch = launch;
     this.scopeWrap = scopeWrap;
     this.afterChildExitHook = afterChildExitHook;
+    this.telemetry = telemetry;
     this.policy = launch.policy ?? { mode: "readonly", configDirAbs: configDir(process.env) };
   }
   launch;
   scopeWrap;
   afterChildExitHook;
+  telemetry;
   /** The tool permission policy; defaults FAIL-SAFE to readonly (never to approval). */
   policy;
   child = null;
@@ -1544,6 +1554,12 @@ var AcpClient = class {
           };
         }
         console.warn(`[braid] denied agent tool permission: ${sanitizeForTty(verdict.reason)}`);
+        this.telemetry?.captureBridgeEvent("tool_call_blocked", {
+          tool: safeAcpToolName(req.toolCall),
+          mode,
+          path: "acp",
+          reason: verdict.deniedByMode ? "mode" : "tripwire"
+        });
         if (verdict.deniedByMode) {
           const cause = this.currentTurnOverrideMode === "readonly" && this.policy.mode !== "readonly" ? "channel" : "operator";
           const hint = takeDenialHint(this.policy, cause);
@@ -3894,8 +3910,26 @@ var RelayClient = class {
     this.bumpCursor(m.channelId, m.seq);
     this.inboundCbs.forEach((cb) => cb(m));
   }
+  /** Returns whether the frame was actually written (WS open) — callers that
+   *  don't care (the vast majority) simply ignore the return value. The
+   *  telemetry seam's pre-connect latch (BL-177 whole-branch review) relies on
+   *  this signal via sendTelemetry below. */
   send(obj) {
-    if (this.ws && this.ws.readyState === 1) this.ws.send(JSON.stringify(obj));
+    if (this.ws && this.ws.readyState === 1) {
+      this.ws.send(JSON.stringify(obj));
+      return true;
+    }
+    return false;
+  }
+  /** Public wrapper for the telemetry seam (BL-177 Task 4): forwards an already-
+   *  built, already-allowlisted frame (src/telemetry.ts owns consent/allowlist/
+   *  debounce) to the guarded protected send() — so a telemetry frame goes out
+   *  under the SAME WS-open discipline as everything else and is silently
+   *  dropped when the socket isn't open (no queue, per design). Deliberately
+   *  dumb: no validation here. Returns delivered=true/false so the seam can
+   *  latch an undelivered pre-connect frame (single-slot, D5). */
+  sendTelemetry(frame) {
+    return this.send(frame);
   }
   /** Emit a typing/thinking activity for a channel. `activityOverride` (start only)
    *  forces the broadcast label — used by the warm-up path to show "coming_online".
@@ -5783,10 +5817,12 @@ function makeInputQueue() {
   };
 }
 var ClaudeAdapter = class {
-  constructor(policy = defaultToolPolicy()) {
+  constructor(policy = defaultToolPolicy(), telemetry) {
     this.policy = policy;
+    this.telemetry = telemetry;
   }
   policy;
+  telemetry;
   // mcpServers/env from AgentStartOptions are ignored here: the generic (bundled Claude
   // SDK) path does not advertise stdio MCP servers to a subprocess. Default no-MCP path.
   async start(opts) {
@@ -5811,6 +5847,12 @@ var ClaudeAdapter = class {
           const verdict = evaluateSdkTool(mode, policy.configDirAbs, toolName, toolInput);
           if (verdict.allow) return { behavior: "allow", updatedInput: toolInput };
           console.warn(`[braid] denied agent tool use: ${sanitizeForTty(verdict.reason)}`);
+          this.telemetry?.captureBridgeEvent("tool_call_blocked", {
+            tool: toolName,
+            mode,
+            path: "sdk",
+            reason: verdict.deniedByMode ? "mode" : "tripwire"
+          });
           if (verdict.deniedByMode) {
             const hint = takeDenialHint(policy);
             if (hint) console.warn(sanitizeForTty(hint));
@@ -5859,14 +5901,14 @@ var ClaudeAdapter = class {
     };
   }
 };
-function createAdapter(cfg, channelId) {
+function createAdapter(cfg, channelId, telemetry) {
   const policy = {
     mode: cfg.toolMode,
     configDirAbs: resolve2(configDir(process.env)),
     agentName: cfg.agentName
     // for the once-per-process "braid tools full <name>" denial hint
   };
-  if (cfg.agentMode !== "acp") return new ClaudeAdapter(policy);
+  if (cfg.agentMode !== "acp") return new ClaudeAdapter(policy, telemetry);
   if (channelId) {
     const prev = detectProviderSwitch(configDir(process.env), cfg.relayWsUrl, cfg.agentName, channelId, cfg.agent);
     if (prev) {
@@ -5888,7 +5930,8 @@ function createAdapter(cfg, channelId) {
   const makeClient = (launch) => new AcpClient(
     launch,
     (l) => scopedLaunch(l, cfg, cfg.agent),
-    afterChildExit
+    afterChildExit,
+    telemetry
   );
   return new AcpAdapter(cfg.agent, makeClient, void 0, policy, session, usageSource, cfg.agentName, cfg.stripEnvKeys, cfg.fallbackModel);
 }
@@ -6163,7 +6206,7 @@ function loadConfig(env) {
 function wsToHttp(relayWsUrl) {
   return relayWsUrl.replace(/^wss:\/\//i, "https://").replace(/^ws:\/\//i, "http://");
 }
-async function buildFromStoredAgent(dir, stored, env, flags) {
+async function buildFromStoredAgent(dir, stored, env, flags, telemetry) {
   if (stored.provider !== void 0 && !ACP_AGENT_IDS.includes(stored.provider)) {
     throw new Error(
       `Invalid provider in saved agent config: ${stored.provider}. Expected one of: ${ACP_AGENT_IDS.join(", ")}`
@@ -6187,8 +6230,10 @@ async function buildFromStoredAgent(dir, stored, env, flags) {
   let toolMode;
   if (flags?.tools) {
     toolMode = flags.tools;
+    telemetry?.captureBridgeEvent("tool_mode_selected", { mode: toolMode, surface: "flag", persisted: false });
   } else if (envToolMode) {
     toolMode = parseToolMode(env);
+    telemetry?.captureBridgeEvent("tool_mode_selected", { mode: toolMode, surface: "env", persisted: false });
   } else if (current.toolMode) {
     toolMode = current.toolMode;
   } else {
@@ -6198,6 +6243,7 @@ async function buildFromStoredAgent(dir, stored, env, flags) {
       current = { ...current, toolMode };
       saveAgent(dir, current);
     }
+    telemetry?.captureBridgeEvent("tool_mode_selected", { mode: toolMode, surface: "prompt", persisted: choice.persist });
   }
   let signingPrivateJwk = current.signingPrivateJwk;
   if (!signingPrivateJwk) {
@@ -6323,7 +6369,7 @@ function parseToolModeForJoin(env) {
   );
   return void 0;
 }
-async function loadConfigFromInvite(code, env, flags) {
+async function loadConfigFromInvite(code, env, flags, telemetry) {
   resolveAgentSelection(env, flags?.provider);
   const joinToolMode = flags?.tools ?? parseToolModeForJoin(env);
   const envForBuild = env.BRAID_TOOL_MODE && joinToolMode === void 0 ? { ...env, BRAID_TOOL_MODE: void 0 } : env;
@@ -6365,7 +6411,7 @@ async function loadConfigFromInvite(code, env, flags) {
   const file = saveAgent(dir, stored);
   const cmdName = isShellSafeName(bundle.agentName) ? bundle.agentName : "<agent-name>";
   console.log(`[braid] credential saved to ${file} (restart later with: npx @snowyroad/braid start ${cmdName})`);
-  return buildFromStoredAgent(dir, stored, envForBuild, flags);
+  return buildFromStoredAgent(dir, stored, envForBuild, flags, telemetry);
 }
 function buildJoinScopeBlock(flags, env) {
   const split = (v) => v ? v.split(/[,:]/).map((s) => s.trim()).filter((s) => s.length > 0) : [];
@@ -6384,10 +6430,10 @@ function buildJoinScopeBlock(flags, env) {
     ...disabled ? { disabled: true } : {}
   };
 }
-async function loadConfigFromStore(agentName, env, flags, io) {
+async function loadConfigFromStore(agentName, env, flags, io, telemetry) {
   const dir = configDir(env);
   const entry = await resolveStoredAgent(dir, agentName, io);
-  return buildFromStoredAgent(dir, entry.agent, env, flags);
+  return buildFromStoredAgent(dir, entry.agent, env, flags, telemetry);
 }
 async function resolveStoredAgent(dir, agentName, io) {
   const name = agentName?.trim();
@@ -6408,7 +6454,7 @@ function getFlag(argv, name) {
   }
   return void 0;
 }
-async function resolveConfig(argv, env) {
+async function resolveConfig(argv, env, telemetry) {
   const parsed = parseRunFlags(argv);
   if (!parsed.ok) throw new Error(parsed.error);
   const { flags, rest } = parsed;
@@ -6416,12 +6462,12 @@ async function resolveConfig(argv, env) {
   if (positional[0] === "join") {
     const code = positional[1];
     if (!code || code.trim() === "") throw new Error("Missing value for join");
-    return loadConfigFromInvite(code.trim(), env, flags);
+    return loadConfigFromInvite(code.trim(), env, flags, telemetry);
   }
   if (positional[0] === "start") {
     const restAfter = positional.slice(1);
     const name = restAfter[0] && !restAfter[0].startsWith("-") ? restAfter[0].trim() : void 0;
-    if (name) return loadConfigFromStore(name, env, flags);
+    if (name) return loadConfigFromStore(name, env, flags, void 0, telemetry);
     positional = restAfter;
   }
   const argInvite = getFlag(positional, "--invite");
@@ -6429,9 +6475,9 @@ async function resolveConfig(argv, env) {
     throw new Error("Missing value for --invite");
   }
   const invite = (argInvite ?? env.BRAID_INVITE)?.trim();
-  if (invite) return loadConfigFromInvite(invite, env, flags);
+  if (invite) return loadConfigFromInvite(invite, env, flags, telemetry);
   if (env.BRAID_TOKEN && env.BRAID_TOKEN.trim() !== "") return loadConfig(env);
-  return loadConfigFromStore(void 0, env, flags);
+  return loadConfigFromStore(void 0, env, flags, void 0, telemetry);
 }
 function parseClaudeConfigModel(jsonText) {
   try {

package/dist/cli.js

@@ -70,7 +70,7 @@ import {
   toolStatusLine,
   validateRelayWsUrl,
   wsToHttp
-} from "./chunk-QDDQF6RJ.js";
+} from "./chunk-PQGSJM2V.js";
 import {
   externalSourceLabel,
   externalUntrustedPreamble,
@@ -2758,6 +2758,7 @@ async function createAndStartBridge(cfg, deps = {}) {
     wsFactory,
     fetchFn: deps.fetchFn ?? fetch
   });
+  deps.onRelayCreated?.(relay);
   let handle = null;
   relay.onFatal(
     deps.onFatal ?? ((codeOrError, reason) => {
@@ -2777,7 +2778,8 @@ async function createAndStartBridge(cfg, deps = {}) {
       void drainAndExit(handle ? handle.sessions.values() : [], exitCode, void 0, handle?.brokers.values());
     })
   );
-  const makeAdapter = deps.makeAdapter ?? createAdapter;
+  const rawMakeAdapter = deps.makeAdapter ?? createAdapter;
+  const makeAdapter = (c, channelId) => rawMakeAdapter(c, channelId, deps.telemetry);
   handle = await startBridge(cfg, relay, { makeAdapter, onReady: deps.onReady, cardCache: deps.cardCache, controlSocket: deps.controlSocket });
   return { relay, sessions: handle.sessions, channelNames: handle.channelNames, brokers: handle.brokers, hub: handle.hub, ensureSession: handle.ensureSession, controlSocketClose: handle.controlSocketClose };
 }
@@ -2829,7 +2831,7 @@ function startUpdateNotifier(opts) {
 }
 
 // src/cli.ts
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/cliArgs.ts
@@ -2859,6 +2861,10 @@ Commands:
                   (no network; local inspection only)
   scope allow <agent> <host>
                   Approve a custom model endpoint host for a saved agent (BL-148)
+  telemetry [status|enable|disable]
+                  Show or change anonymous usage telemetry (tool-mode +
+                  blocked-tool-call signals only; never content, paths, or
+                  names). Machine-level, no saved agent required. Default: status
   service <install|uninstall|start|stop|restart|status|logs> [name]
                   Run a saved agent as a background service that starts at login
                   and restarts on crashes (launchd on macOS, systemd user unit on
@@ -2911,6 +2917,7 @@ var SERVICE_VERBS = /* @__PURE__ */ new Set([
   "status",
   "logs"
 ]);
+var TELEMETRY_VERBS = /* @__PURE__ */ new Set(["status", "enable", "disable"]);
 function parseCliArgs(argv) {
   const first = argv[0];
   if (first === "list") return { kind: "list" };
@@ -2987,6 +2994,20 @@ function parseCliArgs(argv) {
   if (first === "update") {
     return { kind: "update" };
   }
+  if (first === "telemetry") {
+    const verbArg = argv[1];
+    const verb = verbArg ?? "status";
+    if (!TELEMETRY_VERBS.has(verb)) {
+      return {
+        kind: "usage",
+        error: `Unknown telemetry subcommand: ${verbArg}. Expected status|enable|disable`
+      };
+    }
+    if (argv.length > 2) {
+      return { kind: "usage", error: `Unexpected argument for telemetry: ${argv[2]}` };
+    }
+    return { kind: "telemetry", verb };
+  }
   if (first === "attach") {
     const agent = argv[1] && !argv[1].startsWith("-") ? argv[1].trim() : void 0;
     return { kind: "attach", agent };
@@ -3322,17 +3343,25 @@ async function runGuidedStart(flags, deps) {
     if (chosen.persist) patch.toolMode = chosen.mode;
   }
   let ephemeralToolMode = toolsPending && patch.toolMode === void 0;
+  let toolModePersistedOnFile = false;
   if (patch.provider !== void 0 || patch.toolMode !== void 0) {
     const persisted = deps.persist(patch);
     if (persisted === false) {
       deps.err(
         `[braid] ${displayName}'s setup answers could not be saved \u2014 it may already be running on this machine. Stop it first, then run: braid start ${cmdName}`
       );
+      if (toolsPending) {
+        deps.telemetry.captureBridgeEvent("tool_mode_selected", { mode: toolMode, surface: "guided", persisted: false });
+      }
       return { action: "continue" };
     }
     provider = persisted.provider ?? provider;
     toolMode = persisted.toolMode ?? toolMode;
     ephemeralToolMode = toolsPending && patch.toolMode === void 0 && persisted.toolMode === void 0;
+    toolModePersistedOnFile = persisted.toolMode !== void 0;
+  }
+  if (toolsPending) {
+    deps.telemetry.captureBridgeEvent("tool_mode_selected", { mode: toolMode, surface: "guided", persisted: toolModePersistedOnFile });
   }
   const cont = () => ephemeralToolMode ? { action: "continue", runToolMode: toolMode } : { action: "continue" };
   const wantBackground = await deps.askBackground(buildBackgroundQuestion(displayName));
@@ -4528,13 +4557,125 @@ function renderStatusJson(input) {
   return JSON.stringify({ agents }, null, 2);
 }
 
+// src/telemetry.ts
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, renameSync as renameSync3, chmodSync as chmodSync4 } from "fs";
+import { dirname as dirname5, join as join7 } from "path";
+var EVENT_PROP_ALLOWLIST = {
+  tool_mode_selected: ["mode", "surface", "persisted"],
+  tool_call_blocked: ["tool", "mode", "path", "reason"]
+};
+var DEBOUNCE_KEY_PROPS = ["tool", "mode", "path", "reason"];
+var DEBOUNCE_MS = 6e4;
+var DISCLOSURE_LINE = "[braid] anonymous usage telemetry is on (tool-mode + blocked-tool-call signals; never content, paths, or names). Disable: braid telemetry disable";
+function isDoNotTrackSet(env) {
+  const v = env.DO_NOT_TRACK;
+  if (v === void 0) return false;
+  return /^(1|true|yes)$/i.test(v.trim());
+}
+function telemetryConfigPath(dir) {
+  return join7(dir, "telemetry.json");
+}
+function readTelemetryConfig(dir) {
+  try {
+    const raw = readFileSync6(telemetryConfigPath(dir), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+function writeTelemetryConfig(dir, cfg) {
+  const file = telemetryConfigPath(dir);
+  mkdirSync5(dirname5(file), { recursive: true, mode: 448 });
+  const tmp = `${file}.tmp-${process.pid}`;
+  writeFileSync5(tmp, JSON.stringify(cfg, null, 2) + "\n", { mode: 384 });
+  renameSync3(tmp, file);
+  try {
+    chmodSync4(file, 384);
+  } catch {
+  }
+}
+function createBridgeTelemetry(deps) {
+  let cachedConfig;
+  const debounceLast = /* @__PURE__ */ new Map();
+  let pendingFrame = null;
+  function loadConfigCached() {
+    if (cachedConfig === void 0) cachedConfig = readTelemetryConfig(deps.configDir);
+    return cachedConfig;
+  }
+  function captureBridgeEvent(name, props) {
+    try {
+      if (isDoNotTrackSet(deps.env)) return;
+      const cfg = loadConfigCached();
+      if (cfg.disabled === true) return;
+      const allowedKeys = EVENT_PROP_ALLOWLIST[name];
+      if (!allowedKeys) return;
+      const filteredProps = {};
+      for (const key of allowedKeys) {
+        if (Object.prototype.hasOwnProperty.call(props, key)) filteredProps[key] = props[key];
+      }
+      if (name === "tool_call_blocked") {
+        const debounceKey = DEBOUNCE_KEY_PROPS.map((k) => String(filteredProps[k])).join("|");
+        const nowMs = deps.now();
+        const last = debounceLast.get(debounceKey);
+        if (last !== void 0 && nowMs - last < DEBOUNCE_MS) return;
+        debounceLast.set(debounceKey, nowMs);
+      }
+      if (!cfg.noticeShown) {
+        deps.out(DISCLOSURE_LINE);
+        cachedConfig = { ...cfg, noticeShown: true };
+        try {
+          writeTelemetryConfig(deps.configDir, cachedConfig);
+        } catch {
+        }
+      }
+      const frame = { type: "telemetry", event: name, props: filteredProps };
+      const delivered = deps.send(frame);
+      if (delivered !== true) pendingFrame = frame;
+    } catch {
+    }
+  }
+  function flushPending() {
+    try {
+      if (pendingFrame === null) return;
+      const frame = pendingFrame;
+      pendingFrame = null;
+      deps.send(frame);
+    } catch {
+    }
+  }
+  return { captureBridgeEvent, flushPending };
+}
+function telemetryStatus(dir, env) {
+  const cfg = readTelemetryConfig(dir);
+  const forcedOffByDoNotTrack = isDoNotTrackSet(env);
+  return {
+    enabled: !forcedOffByDoNotTrack && cfg.disabled !== true,
+    forcedOffByDoNotTrack,
+    configPath: telemetryConfigPath(dir)
+  };
+}
+function renderTelemetryStatusLines(view) {
+  const lines = [];
+  const state = view.enabled ? "ON" : "OFF";
+  lines.push(`[braid] telemetry: ${state}`);
+  if (view.forcedOffByDoNotTrack) {
+    lines.push("  forced off by DO_NOT_TRACK (unset it to allow telemetry)");
+  }
+  lines.push(`  config: ${view.configPath}`);
+  return lines;
+}
+
 // src/service/cli.ts
 import { execFile } from "child_process";
 import { homedir as homedir5 } from "os";
 
 // src/service/manager.ts
-import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync6, rmSync as rmSync2, existsSync as existsSync5 } from "fs";
-import { join as join8 } from "path";
+import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync7, rmSync as rmSync2, existsSync as existsSync5 } from "fs";
+import { join as join9 } from "path";
 
 // src/service/templates.ts
 function escapeXml(s) {
@@ -4705,18 +4846,18 @@ function schtasksXml(p) {
 }
 
 // src/service/win32.ts
-import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync5, readdirSync as readdirSync4, readFileSync as readFileSync6, unlinkSync as unlinkSync3 } from "fs";
-import { join as join7 } from "path";
+import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync6, readdirSync as readdirSync4, readFileSync as readFileSync7, unlinkSync as unlinkSync3 } from "fs";
+import { join as join8 } from "path";
 function win32LogDir(homeDir) {
-  return join7(homeDir, "AppData", "Local", "braid", "logs");
+  return join8(homeDir, "AppData", "Local", "braid", "logs");
 }
 function win32Manager(ctx) {
-  const serviceDir = join7(ctx.braidDir, "service");
+  const serviceDir = join8(ctx.braidDir, "service");
   const task = (name) => schtasksLabel(name);
   const legacyTask = (name) => legacySchtasksLabel(name);
-  const xmlPath = (name) => join7(serviceDir, `${task(name)}.xml`);
-  const wrapperPath = (name) => join7(serviceDir, `${task(name)}.cmd`);
-  const launcherPath = (name) => join7(serviceDir, `${task(name)}.vbs`);
+  const xmlPath = (name) => join8(serviceDir, `${task(name)}.xml`);
+  const wrapperPath = (name) => join8(serviceDir, `${task(name)}.cmd`);
+  const launcherPath = (name) => join8(serviceDir, `${task(name)}.vbs`);
   const st = (...args) => ctx.exec("schtasks", args);
   const stx = async (...args) => {
     const res = await st(...args);
@@ -4727,18 +4868,18 @@ function win32Manager(ctx) {
   };
   const killBridgeProcess = async (name) => {
     const legacyAgents = legacyTwinPath(ctx.braidDir, ["agents"]);
-    const agentDirs = [join7(ctx.braidDir, "agents"), ...legacyAgents ? [legacyAgents] : []];
+    const agentDirs = [join8(ctx.braidDir, "agents"), ...legacyAgents ? [legacyAgents] : []];
     const hostDirs = [];
     for (const agentsDir of agentDirs) {
       try {
-        for (const host of readdirSync4(agentsDir)) hostDirs.push(join7(agentsDir, host));
+        for (const host of readdirSync4(agentsDir)) hostDirs.push(join8(agentsDir, host));
       } catch {
       }
     }
     for (const hostDir of hostDirs) {
       let pid = NaN;
       try {
-        pid = Number(readFileSync6(join7(hostDir, `${name}.json.lock`), "utf8").trim());
+        pid = Number(readFileSync7(join8(hostDir, `${name}.json.lock`), "utf8").trim());
       } catch {
         continue;
       }
@@ -4754,15 +4895,15 @@ function win32Manager(ctx) {
     }
   };
   const write = (name) => {
-    mkdirSync5(serviceDir, { recursive: true });
+    mkdirSync6(serviceDir, { recursive: true });
     const entryPath = pinnedEntryPath({ braidDir: ctx.braidDir, platform: "win32" });
     const cmd = schtasksWrapperCmd({ name, nodePath: ctx.nodePath, entryPath });
-    writeFileSync5(wrapperPath(name), cmd);
+    writeFileSync6(wrapperPath(name), cmd);
     const vbs = schtasksLauncherVbs({ wrapperPath: wrapperPath(name) });
-    writeFileSync5(launcherPath(name), vbs);
+    writeFileSync6(launcherPath(name), vbs);
     const xml = schtasksXml({ name, launcherPath: launcherPath(name) });
     const path2 = xmlPath(name);
-    writeFileSync5(path2, Buffer.concat([Buffer.from([255, 254]), Buffer.from(xml, "utf16le")]));
+    writeFileSync6(path2, Buffer.concat([Buffer.from([255, 254]), Buffer.from(xml, "utf16le")]));
     return path2;
   };
   return {
@@ -4782,7 +4923,7 @@ function win32Manager(ctx) {
       await st("/delete", "/tn", task(name), "/f");
       await st("/delete", "/tn", legacyTask(name), "/f");
       try {
-        unlinkSync3(join7(runDir(ctx.braidDir), `${name}.token`));
+        unlinkSync3(join8(runDir(ctx.braidDir), `${name}.token`));
       } catch {
       }
       const legacyToken = legacyTwinPath(ctx.braidDir, ["run", `${name}.token`]);
@@ -4820,7 +4961,7 @@ function win32Manager(ctx) {
       return { installed, loaded, running };
     },
     logsPath(name) {
-      return join7(win32LogDir(ctx.homeDir), `${name}.err.log`);
+      return join8(win32LogDir(ctx.homeDir), `${name}.err.log`);
     }
   };
 }
@@ -4834,7 +4975,7 @@ var NotSupportedError = class extends Error {
 };
 function makeServiceManager(platform, exec, deps = {}) {
   const homeDir = deps.homeDir ?? process.env.HOME ?? "";
-  const braidDir = deps.braidDir ?? join8(homeDir, ".braid");
+  const braidDir = deps.braidDir ?? join9(homeDir, ".braid");
   const uid = deps.uid ?? (typeof process.getuid === "function" ? process.getuid() : 0);
   const nodePath = deps.nodePath ?? process.execPath;
   const entryPath = pinnedEntryPath({ braidDir });
@@ -4859,18 +5000,18 @@ function notSupportedManager(platform) {
   };
 }
 function darwinManager(ctx) {
-  const launchAgentsDir = join8(ctx.homeDir, "Library", "LaunchAgents");
-  const logDir = join8(ctx.homeDir, "Library", "Logs", "braid");
-  const legacyLogDir = join8(ctx.homeDir, "Library", "Logs", "arp-bridge");
-  const plistPath = (name) => join8(launchAgentsDir, `${launchdLabel(name)}.plist`);
-  const legacyPlistPath = (name) => join8(launchAgentsDir, `${legacyLaunchdLabel(name)}.plist`);
+  const launchAgentsDir = join9(ctx.homeDir, "Library", "LaunchAgents");
+  const logDir = join9(ctx.homeDir, "Library", "Logs", "braid");
+  const legacyLogDir = join9(ctx.homeDir, "Library", "Logs", "arp-bridge");
+  const plistPath = (name) => join9(launchAgentsDir, `${launchdLabel(name)}.plist`);
+  const legacyPlistPath = (name) => join9(launchAgentsDir, `${legacyLaunchdLabel(name)}.plist`);
   const legacyInstalled = (name) => !existsSync5(plistPath(name)) && existsSync5(legacyPlistPath(name));
   const domainTarget = `gui/${ctx.uid}`;
   const serviceTarget = (name) => `${domainTarget}/${legacyInstalled(name) ? legacyLaunchdLabel(name) : launchdLabel(name)}`;
   const write = (name) => {
-    mkdirSync6(launchAgentsDir, { recursive: true });
-    mkdirSync6(logDir, { recursive: true });
-    writeFileSync6(
+    mkdirSync7(launchAgentsDir, { recursive: true });
+    mkdirSync7(logDir, { recursive: true });
+    writeFileSync7(
       plistPath(name),
       launchdPlist({ name, nodePath: ctx.nodePath, entryPath: ctx.entryPath, logDir }),
       { mode: 420 }
@@ -4928,23 +5069,23 @@ function darwinManager(ctx) {
       };
     },
     logsPath(name) {
-      return join8(legacyInstalled(name) ? legacyLogDir : logDir, `${name}.err.log`);
+      return join9(legacyInstalled(name) ? legacyLogDir : logDir, `${name}.err.log`);
     }
   };
 }
 function linuxManager(ctx) {
-  const unitDir = join8(ctx.homeDir, ".config", "systemd", "user");
+  const unitDir = join9(ctx.homeDir, ".config", "systemd", "user");
   const newUnitName = (name) => `braid-${name}.service`;
   const legacyUnitName = (name) => `arp-bridge-${name}.service`;
-  const newUnitPath = (name) => join8(unitDir, newUnitName(name));
-  const legacyUnitPath = (name) => join8(unitDir, legacyUnitName(name));
+  const newUnitPath = (name) => join9(unitDir, newUnitName(name));
+  const legacyUnitPath = (name) => join9(unitDir, legacyUnitName(name));
   const legacyInstalled = (name) => !existsSync5(newUnitPath(name)) && existsSync5(legacyUnitPath(name));
   const unitName = (name) => legacyInstalled(name) ? legacyUnitName(name) : newUnitName(name);
   const unitPath = (name) => legacyInstalled(name) ? legacyUnitPath(name) : newUnitPath(name);
   const sc = (...args) => ctx.exec("systemctl", ["--user", ...args]);
   const write = (name) => {
-    mkdirSync6(unitDir, { recursive: true });
-    writeFileSync6(
+    mkdirSync7(unitDir, { recursive: true });
+    writeFileSync7(
       newUnitPath(name),
       systemdUnit({ name, nodePath: ctx.nodePath, entryPath: ctx.entryPath }),
       { mode: 420 }
@@ -5218,17 +5359,17 @@ function printStatusHuman(name, st, logsPath) {
 }
 
 // src/service/serviceLog.ts
-import { createWriteStream, mkdirSync as mkdirSync7 } from "fs";
-import { dirname as dirname5, join as join9 } from "path";
+import { createWriteStream, mkdirSync as mkdirSync8 } from "fs";
+import { dirname as dirname6, join as join10 } from "path";
 
 // src/service/logRotation.ts
 import {
   existsSync as existsSync6,
   statSync as statSync2,
-  renameSync as renameSync3,
+  renameSync as renameSync4,
   rmSync as rmSync3,
-  readFileSync as readFileSync7,
-  writeFileSync as writeFileSync7
+  readFileSync as readFileSync8,
+  writeFileSync as writeFileSync8
 } from "fs";
 import { gzipSync } from "zlib";
 var DEFAULT_MAX_BYTES = 10 * 1024 * 1024;
@@ -5252,18 +5393,18 @@ function rotateLogFileIfNeeded(logPath, opts = {}) {
     }
     for (let n = keepCount - 1; n >= 1; n--) {
       try {
-        if (existsSync6(gz(n))) renameSync3(gz(n), gz(n + 1));
+        if (existsSync6(gz(n))) renameSync4(gz(n), gz(n + 1));
       } catch {
       }
     }
     try {
-      const raw = readFileSync7(logPath);
-      writeFileSync7(gz(1), gzipSync(raw));
+      const raw = readFileSync8(logPath);
+      writeFileSync8(gz(1), gzipSync(raw));
     } catch {
       return;
     }
     try {
-      writeFileSync7(logPath, "");
+      writeFileSync8(logPath, "");
     } catch {
     }
   } catch {
@@ -5272,16 +5413,16 @@ function rotateLogFileIfNeeded(logPath, opts = {}) {
 
 // src/service/serviceLog.ts
 function darwinLogDir(homeDir) {
-  return join9(homeDir, "Library", "Logs", "braid");
+  return join10(homeDir, "Library", "Logs", "braid");
 }
 function serviceLogTargets(name, platform, homeDir) {
   if (platform === "darwin") {
     const d = darwinLogDir(homeDir);
-    return [join9(d, `${name}.out.log`), join9(d, `${name}.err.log`)];
+    return [join10(d, `${name}.out.log`), join10(d, `${name}.err.log`)];
   }
   if (platform === "win32") {
     const d = win32LogDir(homeDir);
-    return [join9(d, `${name}.out.log`), join9(d, `${name}.err.log`)];
+    return [join10(d, `${name}.out.log`), join10(d, `${name}.err.log`)];
   }
   return [];
 }
@@ -5331,7 +5472,7 @@ function initServiceLogging(opts) {
   };
 }
 function defaultTeeStream(path2) {
-  mkdirSync7(dirname5(path2), { recursive: true });
+  mkdirSync8(dirname6(path2), { recursive: true });
   const stream = createWriteStream(path2, { flags: "a" });
   stream.on("error", () => {
   });
@@ -5373,7 +5514,7 @@ function printStatus(agentName, json) {
   }
   const readTextFile = (p) => {
     try {
-      return readFileSync8(p, "utf8");
+      return readFileSync9(p, "utf8");
     } catch {
       return null;
     }
@@ -5464,7 +5605,7 @@ function printScope(agentName) {
   }
   const readTextFile = (p) => {
     try {
-      return readFileSync8(p, "utf8");
+      return readFileSync9(p, "utf8");
     } catch {
       return null;
     }
@@ -5504,7 +5645,7 @@ function scopeAllow(agentName, host) {
   const { agent: provider } = resolveAgentSelection(process.env);
   const readTextFile = (p) => {
     try {
-      return readFileSync8(p, "utf8");
+      return readFileSync9(p, "utf8");
     } catch {
       return null;
     }
@@ -5538,6 +5679,19 @@ Set the provider's config to use ${normalizedHost} and try again, or check BRAID
   console.log(`[braid] pinned: ${normalizedHost}  (source: ${match.source})`);
   console.log(`[braid] restart the bridge for the change to take effect.`);
 }
+function runTelemetryVerb(verb) {
+  const dir = configDir(process.env);
+  if (verb === "disable") {
+    const cfg = readTelemetryConfig(dir);
+    writeTelemetryConfig(dir, { ...cfg, disabled: true });
+  } else if (verb === "enable") {
+    const cfg = readTelemetryConfig(dir);
+    const { disabled, ...rest } = cfg;
+    writeTelemetryConfig(dir, rest);
+  }
+  const view = telemetryStatus(dir, process.env);
+  for (const line of renderTelemetryStatusLines(view)) console.log(line);
+}
 var resolvedAgentName = "";
 async function main() {
   applyEnvAliases();
@@ -5580,6 +5734,10 @@ async function main() {
     scopeAllow(invocation.agent, invocation.host);
     return;
   }
+  if (invocation.kind === "telemetry") {
+    runTelemetryVerb(invocation.verb);
+    return;
+  }
   if (invocation.kind === "status") {
     printStatus(invocation.agent, invocation.json);
     return;
@@ -5609,6 +5767,14 @@ async function main() {
       recover: invocation.recover
     }));
   }
+  const relayRef = { current: null };
+  const telemetry = createBridgeTelemetry({
+    env: process.env,
+    configDir: configDir(process.env),
+    now: Date.now,
+    out: (line) => console.log(line),
+    send: (frame) => relayRef.current ? relayRef.current.sendTelemetry(frame) : false
+  });
   {
     const parsed = parseRunFlags(invocation.argv);
     const gate = parsed.ok ? shouldOfferGuidedStart(parsed.rest, process.env) : { offer: false };
@@ -5680,7 +5846,8 @@ async function main() {
         printStatus: (name) => printStatus(name, false),
         verbose: invocation.argv.includes("--verbose"),
         out: (line) => console.log(line),
-        err: (line) => console.error(line)
+        err: (line) => console.error(line),
+        telemetry
       });
       if (outcome.action === "exit") process.exit(outcome.code);
       if (outcome.runToolMode !== void 0) {
@@ -5688,7 +5855,7 @@ async function main() {
       }
     }
   }
-  const cfg = await resolveConfig(invocation.argv, process.env);
+  const cfg = await resolveConfig(invocation.argv, process.env, telemetry);
   resolvedAgentName = cfg.agentName ?? "";
   {
     const decision = shouldSuppressStart(
@@ -5740,7 +5907,7 @@ async function main() {
     const epScopeOff = process.env.BRAID_SCOPE === "off" || cfg.scope?.disabled === true;
     const readTextFile = (p) => {
       try {
-        return readFileSync8(p, "utf8");
+        return readFileSync9(p, "utf8");
       } catch {
         return null;
       }
@@ -5900,11 +6067,14 @@ async function main() {
     // Honest status: declare "connected" only after the relay confirms the agent
     // (auth succeeded), never optimistically on factory return. Rendered as the
     // operator-guidance block: mode + keys, distinct from stream noise.
-    onReady: () => console.log(banner("braid", "CONNECTED", connectedBannerLines({
-      keysLive,
-      serviceEligible,
-      agentName: cfg.agentName ? sanitizeForTty(cfg.agentName) : void 0
-    }))),
+    onReady: () => {
+      telemetry.flushPending();
+      console.log(banner("braid", "CONNECTED", connectedBannerLines({
+        keysLive,
+        serviceEligible,
+        agentName: cfg.agentName ? sanitizeForTty(cfg.agentName) : void 0
+      })));
+    },
     // Disk-backed card cache: skips the expensive elicit subprocess on reconnects
     // when the agent's skill inventory hasn't changed (BL-003).
     cardCache: {
@@ -5913,6 +6083,13 @@ async function main() {
         return r && r.fingerprint === fp ? r : null;
       },
       save: (c, fp, card) => saveCachedCard(c, fp, card)
+    },
+    // BL-177 Task 4: the SAME telemetry instance constructed above, now wired to
+    // the live RelayClient the instant it exists (onRelayCreated) so the two
+    // denial-path capture sites (ACP/SDK, wired via makeAdapter) reach the wire.
+    telemetry,
+    onRelayCreated: (relay) => {
+      relayRef.current = relay;
     }
   });
   if (cfg.runtimeVersion) {

package/dist/{http-4PYTQSSA.js → http-SXNTO4ON.js}

@@ -4,7 +4,7 @@ import {
   boundedJsonFetch,
   resetHttpMetricsForTest,
   snapshotHttpMetrics
-} from "./chunk-QDDQF6RJ.js";
+} from "./chunk-PQGSJM2V.js";
 import "./chunk-BDOF72CL.js";
 export {
   assertHttpEndpoint,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowyroad/braid",
-  "version": "0.83.0",
+  "version": "0.84.1",
   "description": "Braid: connect your own coding agent (Claude Code, Codex, Gemini, Grok) to a Braid channel and collaborate with other agents and humans.",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "SnowyRoad",
@@ -51,7 +51,7 @@
     "@anthropic-ai/sandbox-runtime": "0.0.63",
     "@anthropic-ai/sdk": "0.104.1",
     "@modelcontextprotocol/sdk": "1.29.0",
-    "@snowyroad/braid-tui": "0.0.21",
+    "@snowyroad/braid-tui": "0.0.22",
     "canonicalize": "^3.0.0",
     "jose": "^6.2.3",
     "ws": "8.21.0",

package/service-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@snowyroad/braid",
-  "version": "0.83.0",
+  "version": "0.84.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@snowyroad/braid",
-      "version": "0.83.0",
+      "version": "0.84.1",
       "license": "SEE LICENSE IN LICENSE.md",
       "dependencies": {
         "@agentclientprotocol/sdk": "0.25.1",
@@ -14,7 +14,7 @@
         "@anthropic-ai/sandbox-runtime": "0.0.63",
         "@anthropic-ai/sdk": "0.104.1",
         "@modelcontextprotocol/sdk": "1.29.0",
-        "@snowyroad/braid-tui": "0.0.21",
+        "@snowyroad/braid-tui": "0.0.22",
         "canonicalize": "^3.0.0",
         "jose": "^6.2.3",
         "ws": "8.21.0",
@@ -1183,9 +1183,9 @@
       ]
     },
     "node_modules/@snowyroad/braid-tui": {
-      "version": "0.0.21",
-      "resolved": "https://registry.npmjs.org/@snowyroad/braid-tui/-/braid-tui-0.0.21.tgz",
-      "integrity": "sha512-D4f2feEDibI4kldlkCGHGea5VCTuptmu/065nmiKa3f5aT20uQ/HhMqhTb+/xShVo3slB4L5ns8ukN0NLVk6KQ==",
+      "version": "0.0.22",
+      "resolved": "https://registry.npmjs.org/@snowyroad/braid-tui/-/braid-tui-0.0.22.tgz",
+      "integrity": "sha512-Sgsn8Dl8v6qLwZjRnlPUKJEXM6nOLFu0B/d2bOAJycSu1AI35LyzWjrOoui6TIwDB7KKBYVkbdOKqfwUtHFbyA==",
       "license": "SEE LICENSE IN LICENSE.md",
       "dependencies": {
         "ink": "^5.2.0",