@llamaventures/cli 1.15.0 → 1.16.0

package/lib/client.mjs

@@ -13,6 +13,7 @@ import path from "path";
 import { fileURLToPath } from "url";
 import { execFile as _execFile } from "child_process";
 import { promisify } from "util";
+import { randomUUID } from "crypto";
 
 const execFile = promisify(_execFile);
 
@@ -43,6 +44,19 @@ export function readBriefing() {
   }
 }
 
+let packageVersionCache = null;
+
+export function getPackageVersion() {
+  if (packageVersionCache) return packageVersionCache;
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, "package.json"), "utf8"));
+    packageVersionCache = String(pkg.version || "unknown");
+  } catch {
+    packageVersionCache = "unknown";
+  }
+  return packageVersionCache;
+}
+
 // Canonical entrypoint. `llama-command.onrender.com` also serves the API
 // but its NextAuth callback URL doesn't match, so browser login (needed
 // to mint a token at /settings/tokens) fails there with a server-config
@@ -54,6 +68,7 @@ export const DEFAULT_BASE_URL = "https://command.llamaventures.vc";
 // agent-discovery convention.
 export const TOKEN_DIR = path.join(os.homedir(), ".llama");
 export const TOKEN_FILE = path.join(TOKEN_DIR, "token");
+export const AGENT_SESSION_FILE = path.join(TOKEN_DIR, "agent-session.json");
 
 // Legacy location used by CLI v0.1. Read for back-compat (silent migrate
 // to canonical on first use); never written for the token, but still the
@@ -123,6 +138,269 @@ export function getToken() {
   return "";
 }
 
+let runtimeClient = "cli";
+let runtimeAgentClient = null;
+
+export function setClientRuntime(opts = {}) {
+  if (opts.client) runtimeClient = String(opts.client);
+  if (opts.agentClient) runtimeAgentClient = String(opts.agentClient);
+}
+
+function detectAgentClient() {
+  if (runtimeAgentClient) return runtimeAgentClient;
+  if (process.env.LLAMA_AGENT_CLIENT) return process.env.LLAMA_AGENT_CLIENT;
+  if (process.env.CODEX_SANDBOX || process.env.CODEX_CLI || process.env.OPENAI_CODEX) return "codex";
+  if (process.env.CLAUDECODE || process.env.CLAUDE_CODE || process.env.CLAUDE_CODE_ENTRYPOINT) {
+    return "claude-code";
+  }
+  if (process.env.CURSOR_AGENT || process.env.CURSOR_TRACE_ID) return "cursor";
+  return "unknown";
+}
+
+export function readAgentSession() {
+  try {
+    return JSON.parse(fs.readFileSync(AGENT_SESSION_FILE, "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+function writeAgentSession(session) {
+  try {
+    fs.mkdirSync(TOKEN_DIR, { recursive: true, mode: 0o700 });
+    fs.writeFileSync(AGENT_SESSION_FILE, `${JSON.stringify(session, null, 2)}\n`, { mode: 0o600 });
+    fs.chmodSync(AGENT_SESSION_FILE, 0o600);
+  } catch {
+    // Telemetry state is best-effort. Never break the actual CLI command.
+  }
+}
+
+function currentAgentSessionId() {
+  const session = readAgentSession();
+  if (session.sessionId) return session.sessionId;
+  const created = {
+    sessionId: randomUUID(),
+    createdAt: new Date().toISOString(),
+  };
+  writeAgentSession(created);
+  return created.sessionId;
+}
+
+export function getLastAgentEvent() {
+  const session = readAgentSession();
+  return session.lastEventId ? session : null;
+}
+
+function rememberAgentEvent(event) {
+  if (!event?.eventId) return;
+  const session = {
+    ...readAgentSession(),
+    sessionId: event.sessionId || currentAgentSessionId(),
+    lastEventId: event.eventId,
+    lastCandidateId: event.candidateId ?? null,
+    lastCommand: event.command ?? null,
+    lastQuery: event.query ?? null,
+    lastSurface: event.surface ?? null,
+    lastRecordedAt: new Date().toISOString(),
+  };
+  writeAgentSession(session);
+}
+
+function agentClientHeaders(command) {
+  return {
+    "X-Llama-Client": runtimeClient,
+    "X-Llama-Client-Version": getPackageVersion(),
+    "X-Llama-Agent-Client": detectAgentClient(),
+    "X-Llama-Agent-Session": currentAgentSessionId(),
+    "X-Llama-Command": command || "unknown",
+  };
+}
+
+const SECRET_KEY_RE = /(token|secret|password|authorization|cookie|api[_-]?key|keychain|jwt)/i;
+
+function truncateText(text, max = 2000) {
+  return text.length > max ? `${text.slice(0, max)}...[truncated]` : text;
+}
+
+function sanitizeTelemetryValue(value, depth = 0) {
+  if (depth > 4) return "[max-depth]";
+  if (value === null || value === undefined) return value;
+  if (typeof value === "string") return truncateText(value);
+  if (typeof value === "number" || typeof value === "boolean") return value;
+  if (Array.isArray(value)) {
+    return value.slice(0, 20).map((item) => sanitizeTelemetryValue(item, depth + 1));
+  }
+  if (typeof value === "object") {
+    const out = {};
+    for (const [key, val] of Object.entries(value).slice(0, 40)) {
+      out[key] = SECRET_KEY_RE.test(key) ? "[redacted]" : sanitizeTelemetryValue(val, depth + 1);
+    }
+    return out;
+  }
+  return String(value);
+}
+
+function parseEndpoint(endpoint) {
+  try {
+    return new URL(endpoint, "https://command.llamaventures.vc");
+  } catch {
+    return null;
+  }
+}
+
+function endpointArgs(endpoint, body) {
+  const args = {};
+  const url = parseEndpoint(endpoint);
+  if (url) {
+    for (const [key, value] of url.searchParams.entries()) args[key] = value;
+  }
+  if (body && typeof body === "object" && !Array.isArray(body)) {
+    Object.assign(args, body);
+  }
+  return sanitizeTelemetryValue(args);
+}
+
+function inferCommand(method, endpoint) {
+  const url = parseEndpoint(endpoint);
+  const pathname = url?.pathname || endpoint.split("?")[0] || "";
+  const verb = String(method || "GET").toUpperCase();
+  if (pathname === "/api/agent/client-events") return "telemetry.record";
+  if (pathname === "/api/agent/eval-feedback") return "eval.feedback";
+  if (pathname === "/api/wiki/search") return "wiki.search";
+  if (pathname === "/api/wiki/save") return "wiki.save";
+  if (/^\/api\/wiki\/[^/]+$/.test(pathname)) return verb === "GET" ? "wiki.read" : "wiki.write";
+  if (pathname === "/api/deals") return verb === "GET" ? "deal.search" : "deal.write";
+  if (pathname === "/api/deals/create") return "deal.create";
+  if (pathname === "/api/deals/update") return "deal.update";
+  if (/^\/api\/deals\/[^/]+\/threads\/[^/]+$/.test(pathname)) return "deal.agent.run";
+  if (/^\/api\/deals\/[^/]+\/threads$/.test(pathname)) return "deal.thread.create";
+  if (/^\/api\/deals\/[^/]+\/facts/.test(pathname)) return verb === "GET" ? "deal.fact.list" : "deal.fact.write";
+  if (/^\/api\/deals\/[^/]+\/posts$/.test(pathname)) return "deal.post";
+  if (/^\/api\/deals\/[^/]+\/blocks/.test(pathname)) return verb === "GET" ? "brief.blocks" : "brief.write";
+  if (/^\/api\/deals\/[^/]+$/.test(pathname)) return verb === "GET" ? "deal.show" : "deal.write";
+  if (pathname === "/api/me") return "auth.status";
+  if (pathname.startsWith("/api/agent/skills")) return "skills.read";
+  if (pathname === "/api/agent/manifest") return "agent.bootstrap";
+  if (pathname === "/api/agent/briefing") return "agent.briefing";
+  return `${verb.toLowerCase()} ${pathname || endpoint}`;
+}
+
+function queryForCommand(command, args) {
+  if (!command.endsWith(".search")) return null;
+  return args?.q || args?.search || args?.query || null;
+}
+
+function summarizeResultIds(data) {
+  const result = {};
+  const topDeals = [];
+  const topWiki = [];
+
+  const collectDeal = (deal) => {
+    const id = deal?.uuid || deal?.id || deal?.dealId || deal?.deal_uuid;
+    if (!id) return;
+    topDeals.push({ id, name: deal.companyName || deal.company_name || deal.name || null });
+  };
+  const collectWiki = (item) => {
+    if (!item?.slug) return;
+    topWiki.push({ slug: item.slug, title: item.title || null });
+  };
+
+  if (Array.isArray(data)) {
+    for (const item of data.slice(0, 20)) {
+      collectDeal(item);
+      collectWiki(item);
+    }
+    result.resultCount = data.length;
+  } else if (data && typeof data === "object") {
+    const deals = Array.isArray(data.deals) ? data.deals : [];
+    const articles = Array.isArray(data.articles) ? data.articles : [];
+    const results = Array.isArray(data.results) ? data.results : [];
+    for (const deal of deals.slice(0, 20)) collectDeal(deal);
+    for (const item of [...articles, ...results].slice(0, 20)) collectWiki(item);
+    if (typeof data.total === "number") result.total = data.total;
+    if (deals.length) result.resultCount = deals.length;
+    if (articles.length || results.length) result.resultCount = articles.length + results.length;
+  }
+
+  if (topDeals.length) result.deals = topDeals;
+  if (topWiki.length) result.wiki = topWiki;
+  return result;
+}
+
+function summarizeResult(data) {
+  if (data === null || data === undefined) return null;
+  if (Array.isArray(data)) return `${data.length} result(s)`;
+  if (typeof data === "object") {
+    if (Array.isArray(data.deals)) return `${data.deals.length} deal result(s); total=${data.total ?? "unknown"}`;
+    if (Array.isArray(data.results)) return `${data.results.length} result(s)`;
+    if (data.ok !== undefined) return `ok=${Boolean(data.ok)}`;
+  }
+  return truncateText(typeof data === "string" ? data : JSON.stringify(sanitizeTelemetryValue(data)), 2000);
+}
+
+function shouldSkipTelemetry(endpoint) {
+  if (process.env.LLAMA_TELEMETRY === "0") return true;
+  const pathname = parseEndpoint(endpoint)?.pathname || endpoint;
+  return pathname === "/api/agent/client-events" || pathname === "/api/agent/eval-feedback";
+}
+
+async function recordClientTelemetry({
+  authHeaders,
+  method,
+  endpoint,
+  body,
+  command,
+  status,
+  httpStatus,
+  latencyMs,
+  data,
+  errorMessage,
+}) {
+  if (shouldSkipTelemetry(endpoint)) return;
+  const args = endpointArgs(endpoint, body);
+  const sessionId = currentAgentSessionId();
+  const payload = {
+    client: runtimeClient,
+    clientVersion: getPackageVersion(),
+    agentClient: detectAgentClient(),
+    sessionId,
+    command,
+    method: String(method || "GET").toUpperCase(),
+    endpoint,
+    status,
+    httpStatus,
+    latencyMs,
+    args,
+    query: queryForCommand(command, args),
+    resultSummary: status === "success" ? summarizeResult(data) : null,
+    resultIds: status === "success" ? summarizeResultIds(data) : {},
+    errorMessage: errorMessage ? truncateText(String(errorMessage), 2000) : null,
+  };
+  try {
+    const res = await fetch(`${getBaseUrl()}/api/agent/client-events`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...agentClientHeaders("telemetry.record"),
+        ...authHeaders,
+      },
+      body: JSON.stringify(payload),
+    });
+    if (!res.ok) return;
+    const recorded = await res.json().catch(() => null);
+    rememberAgentEvent({
+      ...recorded,
+      sessionId,
+      command,
+      query: payload.query,
+      surface: command.startsWith("deal.") ? "deal" : command.startsWith("wiki.") ? "wiki" : null,
+    });
+  } catch {
+    // Best-effort by design. The actual llama command already succeeded or
+    // failed; telemetry must never alter that outcome.
+  }
+}
+
 // Try `gcloud auth print-identity-token`. Returns the JWT or null. Zero-config
 // win for any team member who has gcloud + their @llamaventures.vc account
 // already set up — the server's Bearer auth path verifies and auto-creates
@@ -227,10 +505,13 @@ export async function requestSse(method, endpoint, body, opts = {}) {
 async function requestWithRetry(method, endpoint, body, allowRetry) {
   const authHeaders = await getAuthHeaders();
   if (Object.keys(authHeaders).length === 0) throw noAuthError();
+  const command = inferCommand(method, endpoint);
+  const start = Date.now();
   const res = await fetch(`${getBaseUrl()}${endpoint}`, {
     method,
     headers: {
       "Content-Type": "application/json",
+      ...agentClientHeaders(command),
       ...authHeaders,
     },
     body: body === undefined ? undefined : JSON.stringify(body),
@@ -267,18 +548,45 @@ async function requestWithRetry(method, endpoint, body, allowRetry) {
   }
   if (!res.ok) {
     const message = typeof data === "object" && data?.error ? data.error : `HTTP ${res.status}`;
+    await recordClientTelemetry({
+      authHeaders,
+      method,
+      endpoint,
+      body,
+      command,
+      status: "error",
+      httpStatus: res.status,
+      latencyMs: Date.now() - start,
+      data: null,
+      errorMessage: message,
+    });
     throw new Error(message);
   }
+  await recordClientTelemetry({
+    authHeaders,
+    method,
+    endpoint,
+    body,
+    command,
+    status: "success",
+    httpStatus: res.status,
+    latencyMs: Date.now() - start,
+    data,
+    errorMessage: null,
+  });
   return data;
 }
 
 async function requestSseWithRetry(method, endpoint, body, opts, allowRetry) {
   const authHeaders = await getAuthHeaders();
   if (Object.keys(authHeaders).length === 0) throw noAuthError();
+  const command = inferCommand(method, endpoint);
+  const start = Date.now();
   const res = await fetch(`${getBaseUrl()}${endpoint}`, {
     method,
     headers: {
       "Content-Type": "application/json",
+      ...agentClientHeaders(command),
       ...authHeaders,
     },
     body: body === undefined ? undefined : JSON.stringify(body),
@@ -309,6 +617,18 @@ async function requestSseWithRetry(method, endpoint, body, opts, allowRetry) {
       data = text;
     }
     const message = typeof data === "object" && data?.error ? data.error : `HTTP ${res.status}`;
+    await recordClientTelemetry({
+      authHeaders,
+      method,
+      endpoint,
+      body,
+      command,
+      status: "error",
+      httpStatus: res.status,
+      latencyMs: Date.now() - start,
+      data: null,
+      errorMessage: message,
+    });
     throw new Error(message);
   }
 
@@ -343,6 +663,18 @@ async function requestSseWithRetry(method, endpoint, body, opts, allowRetry) {
     for (const frame of frames) handleFrame(frame);
   }
   if (buf.trim()) handleFrame(buf);
+  await recordClientTelemetry({
+    authHeaders,
+    method,
+    endpoint,
+    body,
+    command,
+    status: "success",
+    httpStatus: res.status,
+    latencyMs: Date.now() - start,
+    data: { ok: true, textLength: text.length, events: events.length },
+    errorMessage: null,
+  });
   return { text, events };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llamaventures/cli",
-  "version": "1.15.0",
+  "version": "1.16.0",
   "description": "CLI + MCP server for the Llama Ventures investment workbench (command.llamaventures.vc).",
   "type": "module",
   "scripts": {

package/scripts/verify-agent-routing.mjs

@@ -22,6 +22,7 @@ assert.equal(
 );
 const calls = [];
 let threadSeq = 0;
+let eventSeq = 0;
 
 async function readJson(req) {
   let raw = "";
@@ -65,11 +66,47 @@ const server = createServer(async (req, res) => {
       path: url.pathname,
       query: Object.fromEntries(url.searchParams.entries()),
       body,
+      headers: {
+        client: req.headers["x-llama-client"] ?? null,
+        clientVersion: req.headers["x-llama-client-version"] ?? null,
+        agentClient: req.headers["x-llama-agent-client"] ?? null,
+        session: req.headers["x-llama-agent-session"] ?? null,
+        command: req.headers["x-llama-command"] ?? null,
+      },
     });
 
+    if (req.method === "POST" && url.pathname === "/api/agent/client-events") {
+      eventSeq += 1;
+      writeJson(res, {
+        ok: true,
+        eventId: eventSeq,
+        candidateId: body?.command?.endsWith(".search") ? eventSeq + 1000 : null,
+      });
+      return;
+    }
+
+    if (req.method === "POST" && url.pathname === "/api/agent/eval-feedback") {
+      writeJson(res, {
+        ok: true,
+        candidate: {
+          id: 42,
+          source_event_id: body?.eventId ?? null,
+          feedback: body?.action ?? null,
+        },
+      });
+      return;
+    }
+
     if (req.method === "GET" && url.pathname === "/api/agent/manifest") {
       writeJson(res, {
         ok: true,
+        contract: {
+          contract_version: "agent-contract.v1",
+          cli: {
+            client_version: url.searchParams.get("clientVersion"),
+            status: "ok",
+          },
+        },
         briefing: "runtime briefing: use skills_search, skills_read, and object_inspect",
         llama_os: {
           visible_skill_count: 49,
@@ -85,6 +122,21 @@ const server = createServer(async (req, res) => {
       return;
     }
 
+    if (req.method === "GET" && url.pathname === "/api/agent/briefing") {
+      writeJson(res, {
+        ok: true,
+        contract: {
+          contract_version: "agent-contract.v1",
+          cli: {
+            client_version: url.searchParams.get("clientVersion"),
+            status: "ok",
+          },
+        },
+        briefing: "server-owned briefing: check CLI, use Pipeline First, prefer CLI/MCP",
+      });
+      return;
+    }
+
     if (req.method === "GET" && url.pathname === "/api/agent/skills") {
       writeJson(res, {
         ok: true,
@@ -136,6 +188,16 @@ const server = createServer(async (req, res) => {
       return;
     }
 
+    if (req.method === "GET" && url.pathname === "/api/wiki/search") {
+      writeJson(res, [
+        {
+          slug: "llama-weekly-2026-06-16",
+          title: "Llama Weekly 2026-06-16",
+        },
+      ]);
+      return;
+    }
+
     if (req.method === "POST" && /^\/api\/deals\/[^/]+\/threads$/.test(url.pathname)) {
       threadSeq += 1;
       writeJson(res, { id: `thread-${threadSeq}` });
@@ -191,25 +253,34 @@ function resetCalls() {
   threadSeq = 0;
 }
 
+function businessCalls() {
+  return calls.filter((call) => call.path !== "/api/agent/client-events");
+}
+
+function telemetryCalls() {
+  return calls.filter((call) => call.path === "/api/agent/client-events");
+}
+
 function paths() {
-  return calls.map((call) => `${call.method} ${call.path}`);
+  return businessCalls().map((call) => `${call.method} ${call.path}`);
 }
 
 function assertNoEnrichCall() {
   assert.equal(
-    calls.some((call) => call.path.endsWith("/enrich")),
+    businessCalls().some((call) => call.path.endsWith("/enrich")),
     false,
     `expected no /enrich call, got ${paths().join(", ")}`,
   );
 }
 
 function assertThreadRun({ title, messageIncludes }) {
-  assert.equal(calls.length, 2, `expected thread create + SSE run, got ${paths().join(", ")}`);
-  assert.match(calls[0].path, /^\/api\/deals\/[^/]+\/threads$/);
-  assert.equal(calls[0].body?.title, title);
-  assert.match(calls[1].path, /^\/api\/deals\/[^/]+\/threads\/thread-1$/);
+  const relevant = businessCalls();
+  assert.equal(relevant.length, 2, `expected thread create + SSE run, got ${paths().join(", ")}`);
+  assert.match(relevant[0].path, /^\/api\/deals\/[^/]+\/threads$/);
+  assert.equal(relevant[0].body?.title, title);
+  assert.match(relevant[1].path, /^\/api\/deals\/[^/]+\/threads\/thread-1$/);
   for (const needle of messageIncludes) {
-    assert.match(calls[1].body?.message ?? "", new RegExp(escapeRegExp(needle)));
+    assert.match(relevant[1].body?.message ?? "", new RegExp(escapeRegExp(needle)));
   }
 }
 
@@ -313,18 +384,29 @@ const baseUrl = `http://${address.address}:${address.port}`;
 const homeDir = await mkdtemp(path.join(os.tmpdir(), "llama-cli-routing-"));
 
 try {
+  resetCalls();
+  const onboardRun = await runCli(["agent-onboard"], baseUrl, homeDir);
+  assert.match(onboardRun.stdout, /server-owned briefing/);
+  assert.deepEqual(paths(), ["GET /api/agent/briefing"]);
+  assert.ok(businessCalls()[0].query.clientVersion, "agent-onboard passes clientVersion");
+  assert.equal(telemetryCalls()[0].body?.command, "agent.briefing");
+  assert.equal(telemetryCalls()[0].body?.client, "cli");
+  assert.ok(telemetryCalls()[0].body?.sessionId, "telemetry includes an agent session id");
+  assert.equal(businessCalls()[0].headers.command, "agent.briefing");
+
   resetCalls();
   const bootstrapRun = await runCli(["agent", "bootstrap", "--limit", "3"], baseUrl, homeDir);
   assert.match(bootstrapRun.stdout, /runtime briefing/);
   assert.deepEqual(paths(), ["GET /api/agent/manifest"]);
-  assert.equal(calls[0].query.limit, "3");
+  assert.equal(businessCalls()[0].query.limit, "3");
+  assert.ok(businessCalls()[0].query.clientVersion, "agent bootstrap passes clientVersion");
 
   resetCalls();
   const skillSearchRun = await runCli(["skills", "search", "pipeline", "--limit", "5"], baseUrl, homeDir);
   assert.match(skillSearchRun.stdout, /llama-command/);
   assert.deepEqual(paths(), ["GET /api/agent/skills"]);
-  assert.equal(calls[0].query.q, "pipeline");
-  assert.equal(calls[0].query.limit, "5");
+  assert.equal(businessCalls()[0].query.q, "pipeline");
+  assert.equal(businessCalls()[0].query.limit, "5");
 
   resetCalls();
   const skillShowRun = await runCli(["skills", "show", "llama-command"], baseUrl, homeDir);
@@ -336,7 +418,34 @@ try {
   assert.match(explainRun.stdout, /Status: deleted/);
   assert.match(explainRun.stdout, /Deleted by Kevin Yu/);
   assert.deepEqual(paths(), ["GET /api/agent/explain"]);
-  assert.equal(calls[0].query.q, "https://command.llamaventures.vc/wiki/missing-page");
+  assert.equal(businessCalls()[0].query.q, "https://command.llamaventures.vc/wiki/missing-page");
+
+  resetCalls();
+  const wikiRun = await runCli(["wiki", "search", "llama weekly"], baseUrl, homeDir);
+  assert.match(wikiRun.stdout, /llama-weekly-2026-06-16/);
+  assert.deepEqual(paths(), ["GET /api/wiki/search"]);
+  assert.equal(telemetryCalls()[0].body?.command, "wiki.search");
+  assert.equal(telemetryCalls()[0].body?.query, "llama weekly");
+
+  resetCalls();
+  const evalRun = await runCli(
+    [
+      "eval",
+      "bad",
+      "--last",
+      "--reason",
+      "missed dev weekly",
+      "--expect",
+      "wiki:llamaos-weekly-2026-06-17",
+    ],
+    baseUrl,
+    homeDir,
+  );
+  assert.match(evalRun.stdout, /"feedback": "bad"/);
+  assert.deepEqual(paths(), ["POST /api/agent/eval-feedback"]);
+  assert.equal(businessCalls()[0].body?.action, "bad");
+  assert.equal(businessCalls()[0].body?.eventId, 6);
+  assert.equal(businessCalls()[0].body?.expected?.wikiSlugs?.[0], "llamaos-weekly-2026-06-17");
 
   resetCalls();
   const enrichRun = await runCli(
@@ -369,9 +478,9 @@ try {
     homeDir,
   );
   assert.deepEqual(paths(), ["POST /api/deals/deal-cli/enrich"]);
-  assert.equal(calls[0].body?.apply, true);
-  assert.equal(calls[0].body?.dryRun, false);
-  assert.equal(calls[0].body?.executor, "server_agent");
+  assert.equal(businessCalls()[0].body?.apply, true);
+  assert.equal(businessCalls()[0].body?.dryRun, false);
+  assert.equal(businessCalls()[0].body?.executor, "server_agent");
 
   resetCalls();
   const agentRun = await runCli(
@@ -414,14 +523,16 @@ try {
   const bootstrapPayload = JSON.parse(mcpBootstrap.content?.[0]?.text ?? "{}");
   assert.equal(bootstrapPayload.ok, true);
   assert.deepEqual(paths(), ["GET /api/agent/manifest"]);
-  assert.equal(calls[0].query.limit, "2");
+  assert.equal(businessCalls()[0].query.limit, "2");
+  assert.ok(businessCalls()[0].query.clientVersion, "mcp agent_bootstrap passes clientVersion");
+  assert.equal(telemetryCalls()[0].body?.client, "mcp");
 
   resetCalls();
   const mcpSkills = await callMcpTool("skills_search", { q: "command", limit: 4 }, baseUrl, homeDir);
   const skillsPayload = JSON.parse(mcpSkills.content?.[0]?.text ?? "{}");
   assert.equal(skillsPayload.skills?.[0]?.slug, "llama-command");
   assert.deepEqual(paths(), ["GET /api/agent/skills"]);
-  assert.equal(calls[0].query.q, "command");
+  assert.equal(businessCalls()[0].query.q, "command");
 
   resetCalls();
   const mcpSkillRead = await callMcpTool("skills_read", { slug: "llama-command" }, baseUrl, homeDir);