@arcadeai/hypotenuse 0.13.1 → 0.14.1

package/dist/hypotenuse.js

@@ -343,7 +343,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@arcadeai/hypotenuse",
-  version: "0.13.1",
+  version: "0.14.1",
   description: "Hypotenuse \u2014 run coding agents on your machine for Linear agent sessions",
   type: "module",
   license: "Apache-2.0",
@@ -385,6 +385,7 @@ var package_default = {
     "@modelcontextprotocol/sdk": "1.32.1",
     commander: "^14.0.3",
     nanospinner: "^1.2.2",
+    protobufjs: "^8.8.1",
     "smol-toml": "^1.9.1",
     upgradr: "^0.4.1",
     zod: "^4.3.6"
@@ -753,86 +754,226 @@ function isPreset(name) {
 import { basename } from "path";
 
 // ../protocol/src/capabilities.ts
+import { z as z2 } from "zod";
+
+// ../protocol/src/telemetry.ts
 import { z } from "zod";
+var CONTENT_LEVELS = ["metadata", "content", "full"];
+var ContentLevel = z.enum(CONTENT_LEVELS);
+function levelRank(level) {
+  return CONTENT_LEVELS.indexOf(level);
+}
+function minLevel(a, b) {
+  return levelRank(a) <= levelRank(b) ? a : b;
+}
+var LEVEL_ATTRIBUTE = "hypotenuse.telemetry.level";
+var CONTENT_ATTRIBUTE_PREFIX = "hypotenuse.content.";
+var CONTENT_CAP_BYTES = 64 * 1024;
+var TRUNCATED_SUFFIX = ".original_bytes";
+var TELEMETRY_WORK_ITEM_HEADER = "X-Hypotenuse-Work-Item";
+var TELEMETRY_SIGNAL_HEADER = "X-Hypotenuse-Signal";
+var TRACEPARENT_HEADER = "traceparent";
+var MAX_TELEMETRY_BODY_BYTES = 1024 * 1024;
+var MAX_TELEMETRY_INFLATED_BYTES = 8 * 1024 * 1024;
+var ClaimTelemetry = z.looseObject({
+  traceparent: z.string().describe("The turn's root span; every daemon:* call for it carries it"),
+  sampled: z.boolean().describe("Whether any exporter keeps this turn's spans and logs"),
+  content: ContentLevel.describe("The level to collect at, already lowered to this runner's cap"),
+  agentNative: z.boolean().describe("Whether to capture the coding agent's own telemetry")
+});
+var TelemetryCapability = z.strictObject({
+  enabled: z.boolean(),
+  maxContent: ContentLevel,
+  agentNative: z.boolean()
+});
+var TelemetryResponse = z.looseObject({
+  accepted: z.boolean()
+});
+function randomHex(bytes) {
+  for (;; ) {
+    const buf = crypto.getRandomValues(new Uint8Array(bytes));
+    if (buf.some((b) => b !== 0))
+      return Buffer.from(buf).toString("hex");
+  }
+}
+function newSpanId() {
+  return randomHex(8);
+}
+function formatTraceparent(ctx) {
+  return `00-${ctx.traceId}-${ctx.spanId}-${ctx.sampled ? "01" : "00"}`;
+}
+function parseTraceparent(value) {
+  const match = /^00-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})$/.exec((value ?? "").trim().toLowerCase());
+  if (!match)
+    return null;
+  const [, traceId, spanId, flags] = match;
+  if (/^0+$/.test(traceId) || /^0+$/.test(spanId))
+    return null;
+  return { traceId, spanId, sampled: (Number.parseInt(flags, 16) & 1) === 1 };
+}
+function capContent(text) {
+  const bytes = Buffer.byteLength(text);
+  if (bytes <= CONTENT_CAP_BYTES)
+    return { text, originalBytes: null };
+  let cut = Buffer.from(text).subarray(0, CONTENT_CAP_BYTES).toString("utf8");
+  if (cut.endsWith("\uFFFD"))
+    cut = cut.slice(0, -1);
+  return { text: cut, originalBytes: bytes };
+}
+var SECRET_PATTERNS = [
+  /hyp_(?:rt|cli)_[A-Za-z0-9_-]{8,}/g,
+  /sk-(?:ant-|proj-)?[A-Za-z0-9_-]{16,}/g,
+  /lin_(?:api|oauth)_[A-Za-z0-9]{16,}/g,
+  /gh[pousr]_[A-Za-z0-9]{20,}/g,
+  /github_pat_[A-Za-z0-9_]{20,}/g,
+  /xox[abposr]-[A-Za-z0-9-]{10,}/g,
+  /AIza[0-9A-Za-z_-]{30,}/g,
+  /AKIA[0-9A-Z]{16}/g,
+  /eyJ[A-Za-z0-9_-]{8,}\.eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g,
+  /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
+  /\b(Bearer|Basic)\s+[A-Za-z0-9._~+/=-]{8,}/g
+];
+var REDACTED = "[REDACTED]";
+var SECRET_KEY = /((^|[._-])(authorization|cookie|set-cookie|token|secret|password|passwd)$)|([a-z0-9][_-](key|token)$)/i;
+var MIN_SECRET_LENGTH = 6;
+function redactText(text, values) {
+  let out = text;
+  for (const v of values)
+    if (out.includes(v))
+      out = out.split(v).join(REDACTED);
+  for (const p of SECRET_PATTERNS)
+    out = out.replace(p, REDACTED);
+  return out;
+}
+function redactOtlp(request, options = {}) {
+  const values = [...new Set(options.values ?? [])].filter((v) => v.length >= MIN_SECRET_LENGTH).sort((a, b) => b.length - a.length);
+  const keys = new Set(options.keys ?? []);
+  const isSecretKey = (k) => keys.has(k) || SECRET_KEY.test(k);
+  const walk = (value, key) => {
+    if (typeof value === "string") {
+      if (key === "traceId" || key === "spanId" || key === "parentSpanId")
+        return value;
+      return redactText(value, values);
+    }
+    if (Array.isArray(value))
+      return value.map((v) => walk(v, key));
+    if (value && typeof value === "object") {
+      const obj = value;
+      if (typeof obj.key === "string" && "value" in obj && isSecretKey(obj.key))
+        return { key: obj.key, value: { stringValue: REDACTED } };
+      const out = {};
+      for (const [k, v] of Object.entries(obj))
+        out[k] = walk(v, k);
+      return out;
+    }
+    return value;
+  };
+  return walk(request, "");
+}
+function stampResource(signal, request, attrs) {
+  const groups = signal === "traces" ? request.resourceSpans : signal === "logs" ? request.resourceLogs : request.resourceMetrics;
+  const keys = new Set(attrs.map((a) => a.key));
+  for (const group of groups ?? []) {
+    const existing = (group.resource?.attributes ?? []).filter((a) => !keys.has(a.key));
+    group.resource = { ...group.resource, attributes: [...existing, ...attrs] };
+  }
+  return request;
+}
+function mergeRequests(signal, requests) {
+  if (signal === "traces")
+    return {
+      resourceSpans: requests.flatMap((r) => r.resourceSpans ?? [])
+    };
+  if (signal === "logs")
+    return {
+      resourceLogs: requests.flatMap((r) => r.resourceLogs ?? [])
+    };
+  return {
+    resourceMetrics: requests.flatMap((r) => r.resourceMetrics ?? [])
+  };
+}
+
+// ../protocol/src/capabilities.ts
 var RUNNER_ROLES = ["manager", "worker"];
-var RunnerRole = z.enum(RUNNER_ROLES);
-var identifier = z.string().trim().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "letters, digits, `.`, `_`, `-`");
-var AgentCapability = z.strictObject({
+var RunnerRole = z2.enum(RUNNER_ROLES);
+var identifier = z2.string().trim().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "letters, digits, `.`, `_`, `-`");
+var AgentCapability = z2.strictObject({
   id: identifier.describe("The agent's id in the config file"),
   preset: identifier.describe("The preset it is built on, e.g. claude"),
-  available: z.boolean().describe("Whether the daemon's probe succeeded"),
-  version: z.string().max(128).optional().describe("The agent's version"),
-  roles: z.array(RunnerRole).max(RUNNER_ROLES.length).optional().describe("The roles this agent plays; absent means every role"),
-  error: z.string().max(1024).optional().describe("Why the probe failed, when it did")
+  available: z2.boolean().describe("Whether the daemon's probe succeeded"),
+  version: z2.string().max(128).optional().describe("The agent's version"),
+  roles: z2.array(RunnerRole).max(RUNNER_ROLES.length).optional().describe("The roles this agent plays; absent means every role"),
+  error: z2.string().max(1024).optional().describe("Why the probe failed, when it did")
 });
-var RepositoryCapability = z.strictObject({
+var RepositoryCapability = z2.strictObject({
   name: identifier.describe("The repository's name in the config file"),
-  remote: z.string().trim().min(1).max(512).describe("Its git remote; the server normalizes it to host/owner/name"),
-  baseBranch: z.string().trim().min(1).max(255).describe("The base branch")
+  remote: z2.string().trim().min(1).max(512).describe("Its git remote; the server normalizes it to host/owner/name"),
+  baseBranch: z2.string().trim().min(1).max(255).describe("The base branch")
 });
-var subscriptionValues = z.array(z.string().trim().min(1).max(255)).max(200).default([]);
-var Subscriptions = z.strictObject({
+var subscriptionValues = z2.array(z2.string().trim().min(1).max(255)).max(200).default([]);
+var Subscriptions = z2.strictObject({
   teams: subscriptionValues.describe("Team keys, e.g. ENG"),
   projects: subscriptionValues.describe("Project ids"),
   labels: subscriptionValues.describe("Label names (matched lowercased)")
 });
-var RunnerCapabilities = z.strictObject({
-  roles: z.array(RunnerRole).max(RUNNER_ROLES.length),
-  agents: z.array(AgentCapability).max(64),
-  repositories: z.array(RepositoryCapability).max(256),
-  subscriptions: Subscriptions
+var RunnerCapabilities = z2.strictObject({
+  roles: z2.array(RunnerRole).max(RUNNER_ROLES.length),
+  agents: z2.array(AgentCapability).max(64),
+  repositories: z2.array(RepositoryCapability).max(256),
+  subscriptions: Subscriptions,
+  telemetry: TelemetryCapability.optional().describe("The runner owner's cap on what telemetry leaves the machine; absent from older daemons, which send none")
 });
-var cap = z.number().int().min(0).max(1000);
-var RunnerLimits = z.strictObject({
-  maxParallelJobs: z.number().int().min(1).max(1000),
-  roles: z.partialRecord(RunnerRole, cap).optional(),
-  agents: z.record(identifier, cap).optional()
+var cap = z2.number().int().min(0).max(1000);
+var RunnerLimits = z2.strictObject({
+  maxParallelJobs: z2.number().int().min(1).max(1000),
+  roles: z2.partialRecord(RunnerRole, cap).optional(),
+  agents: z2.record(identifier, cap).optional()
 });
 // ../protocol/src/complete.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 var COMPLETE_OUTCOMES = ["completed", "failed", "cancelled"];
-var CompleteRequest = z2.strictObject({
-  workItemId: z2.number().int().positive(),
-  outcome: z2.enum(COMPLETE_OUTCOMES),
-  error: z2.string().max(4096).nullable().optional(),
-  acpSessionId: z2.string().max(255).nullable().optional(),
-  branch: z2.string().max(255).nullable().optional(),
-  answersConsumed: z2.array(z2.number().int().positive()).max(100).optional().describe("The activity ids of delivered answers the turn took as answers; any other answer becomes the session's next prompt")
+var CompleteRequest = z3.strictObject({
+  workItemId: z3.number().int().positive(),
+  outcome: z3.enum(COMPLETE_OUTCOMES),
+  error: z3.string().max(4096).nullable().optional(),
+  acpSessionId: z3.string().max(255).nullable().optional(),
+  branch: z3.string().max(255).nullable().optional(),
+  answersConsumed: z3.array(z3.number().int().positive()).max(100).optional().describe("The activity ids of delivered answers the turn took as answers; any other answer becomes the session's next prompt")
 });
-var CompleteResponse = z2.looseObject({
-  alreadyTerminal: z2.boolean()
+var CompleteResponse = z3.looseObject({
+  alreadyTerminal: z3.boolean()
 });
 // ../protocol/src/connect.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // ../protocol/src/heartbeat.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var ACTIVE_STATES = ["starting", "running", "cancelling"];
-var ActiveItem = z3.strictObject({
-  workItemId: z3.number().int().positive(),
-  agentSessionId: z3.number().int().positive(),
+var ActiveItem = z4.strictObject({
+  workItemId: z4.number().int().positive(),
+  agentSessionId: z4.number().int().positive(),
   role: RunnerRole,
-  agentId: z3.string().min(1).max(64),
-  state: z3.enum(ACTIVE_STATES)
+  agentId: z4.string().min(1).max(64),
+  state: z4.enum(ACTIVE_STATES)
 });
-var MachineId = z3.string().regex(/^sha256:[0-9a-f]{1,64}$/, "sha256:<hex>").describe("A stable hash of the OS machine id, `sha256:<hex>`");
-var HeartbeatRequest = z3.strictObject({
-  protocolVersion: z3.number().int().positive(),
-  daemonVersion: z3.string().trim().min(1).max(64),
-  platform: z3.string().trim().min(1).max(64),
-  hostname: z3.string().trim().min(1).max(256),
-  draining: z3.boolean(),
+var MachineId = z4.string().regex(/^sha256:[0-9a-f]{1,64}$/, "sha256:<hex>").describe("A stable hash of the OS machine id, `sha256:<hex>`");
+var HeartbeatRequest = z4.strictObject({
+  protocolVersion: z4.number().int().positive(),
+  daemonVersion: z4.string().trim().min(1).max(64),
+  platform: z4.string().trim().min(1).max(64),
+  hostname: z4.string().trim().min(1).max(256),
+  draining: z4.boolean(),
   machineId: MachineId,
   limits: RunnerLimits,
-  active: z3.array(ActiveItem).max(1000),
+  active: z4.array(ActiveItem).max(1000),
   capabilities: RunnerCapabilities,
-  dryRun: z3.boolean().optional().describe("Validate and answer without recording anything: no presence, no capabilities, no leases, no offers")
+  dryRun: z4.boolean().optional().describe("Validate and answer without recording anything: no presence, no capabilities, no leases, no offers")
 });
-var DryRunRunner = z3.looseObject({
-  id: z3.number().int().positive(),
-  name: z3.string(),
-  projectId: z3.number().int().positive(),
-  projectSlug: z3.string()
+var DryRunRunner = z4.looseObject({
+  id: z4.number().int().positive(),
+  name: z4.string(),
+  projectId: z4.number().int().positive(),
+  projectSlug: z4.string()
 });
 var OFFER_KINDS = [
   "session_created",
@@ -840,12 +981,12 @@ var OFFER_KINDS = [
   "dispatch",
   "review"
 ];
-var Offer = z3.looseObject({
-  workItemId: z3.number().int().positive(),
-  agentSessionId: z3.number().int().positive(),
-  kind: z3.enum(OFFER_KINDS),
+var Offer = z4.looseObject({
+  workItemId: z4.number().int().positive(),
+  agentSessionId: z4.number().int().positive(),
+  kind: z4.enum(OFFER_KINDS),
   role: RunnerRole,
-  offerExpiresAt: z3.number().int()
+  offerExpiresAt: z4.number().int()
 });
 var CANCEL_REASONS = [
   "stop",
@@ -856,11 +997,11 @@ var CANCEL_REASONS = [
   "integration_revoked",
   "superseded"
 ];
-var Cancel = z3.looseObject({
-  workItemId: z3.number().int().positive(),
-  reason: z3.union([z3.enum(CANCEL_REASONS), z3.string().min(1).max(64)]),
-  by: z3.string().min(1).max(200).optional(),
-  said: z3.string().min(1).max(2000).optional()
+var Cancel = z4.looseObject({
+  workItemId: z4.number().int().positive(),
+  reason: z4.union([z4.enum(CANCEL_REASONS), z4.string().min(1).max(64)]),
+  by: z4.string().min(1).max(200).optional(),
+  said: z4.string().min(1).max(2000).optional()
 });
 var STOP_QUOTE_MAX = 500;
 function stopQuote(said) {
@@ -874,87 +1015,87 @@ function stopQuote(said) {
 `).join(`
 > `)}`;
 }
-var Answer = z3.looseObject({
-  workItemId: z3.number().int().positive(),
-  activityId: z3.number().int().positive(),
-  body: z3.string()
+var Answer = z4.looseObject({
+  workItemId: z4.number().int().positive(),
+  activityId: z4.number().int().positive(),
+  body: z4.string()
 });
-var HeartbeatResponse = z3.looseObject({
-  serverTime: z3.number().int(),
-  heartbeatIntervalMs: z3.number().int().positive(),
-  leaseMs: z3.number().int().positive(),
-  offers: z3.array(Offer),
-  cancels: z3.array(Cancel),
-  unknownActive: z3.array(z3.number().int().positive()),
-  answers: z3.array(Answer).default([]).describe("Replies to questions held turns are waiting on, oldest first"),
+var HeartbeatResponse = z4.looseObject({
+  serverTime: z4.number().int(),
+  heartbeatIntervalMs: z4.number().int().positive(),
+  leaseMs: z4.number().int().positive(),
+  offers: z4.array(Offer),
+  cancels: z4.array(Cancel),
+  unknownActive: z4.array(z4.number().int().positive()),
+  answers: z4.array(Answer).default([]).describe("Replies to questions held turns are waiting on, oldest first"),
   runner: DryRunRunner.optional().describe("A dry run only: the runner the token is"),
-  unknownSubscriptions: z3.looseObject({ teams: z3.array(z3.string()) }).nullable().optional().describe("A dry run only: subscribed team keys the project's Linear connection cannot see; null when it could not be asked")
+  unknownSubscriptions: z4.looseObject({ teams: z4.array(z4.string()) }).nullable().optional().describe("A dry run only: subscribed team keys the project's Linear connection cannot see; null when it could not be asked")
 });
 
 // ../protocol/src/connect.ts
-var ConnectRequest = z4.strictObject({
+var ConnectRequest = z5.strictObject({
   machineId: MachineId
 });
-var ConnectResponse = z4.looseObject({
-  runnerId: z4.number().int().positive(),
-  channel: z4.string().regex(/^runner:\d+$/),
-  heartbeatIntervalMs: z4.number().int().positive(),
-  leaseMs: z4.number().int().positive(),
-  serverTime: z4.number().int()
+var ConnectResponse = z5.looseObject({
+  runnerId: z5.number().int().positive(),
+  channel: z5.string().regex(/^runner:\d+$/),
+  heartbeatIntervalMs: z5.number().int().positive(),
+  leaseMs: z5.number().int().positive(),
+  serverTime: z5.number().int()
 });
 var MACHINE_IN_USE = "MACHINE_IN_USE";
 var RUNNER_FRAME_EVENTS = ["work", "cancel", "revoked"];
-var RunnerFrame = z4.object({ event: z4.enum(RUNNER_FRAME_EVENTS) });
+var RunnerFrame = z5.object({ event: z5.enum(RUNNER_FRAME_EVENTS) });
 function runnerChannel(runnerId) {
   return `runner:${runnerId}`;
 }
 // ../protocol/src/events.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var MAX_EVENTS_PER_BATCH = 100;
 var MAX_EVENTS_BATCH_BYTES = 256 * 1024;
 var NOT_YOUR_WORK = "NOT_YOUR_WORK";
 var SEQ_REGRESSION = "SEQ_REGRESSION";
-var body = z5.string().trim().min(1).max(64 * 1024);
+var body = z6.string().trim().min(1).max(64 * 1024);
 var envelope = {
-  eventId: z5.uuid({ version: "v4" }).describe("Generated by the daemon; the idempotency key end to end (the Linear activity's client id)"),
-  seq: z5.number().int().positive().describe("Per work item, from 1, never going backwards"),
-  at: z5.number().int().describe("When the daemon saw it, epoch ms")
+  eventId: z6.uuid({ version: "v4" }).describe("Generated by the daemon; the idempotency key end to end (the Linear activity's client id)"),
+  seq: z6.number().int().positive().describe("Per work item, from 1, never going backwards"),
+  at: z6.number().int().describe("When the daemon saw it, epoch ms")
 };
-var SelectMetadata = z5.strictObject({
-  options: z5.array(z5.strictObject({
-    label: z5.string().trim().min(1).max(255).optional(),
-    value: z5.string().trim().min(1).max(1024)
+var SelectMetadata = z6.strictObject({
+  options: z6.array(z6.strictObject({
+    label: z6.string().trim().min(1).max(255).optional(),
+    value: z6.string().trim().min(1).max(1024)
   })).min(1).max(25)
 });
-var AuthProvider = z5.string().regex(/^[a-z0-9][a-z0-9._-]{0,63}$/).describe("An agent id, `github`, or a git host");
-var AuthMetadata = z5.strictObject({
-  url: z5.url().optional(),
+var AuthProvider = z6.string().regex(/^[a-z0-9][a-z0-9._-]{0,63}$/).describe("An agent id, `github`, or a git host");
+var AuthMetadata = z6.strictObject({
+  url: z6.url().optional(),
   provider: AuthProvider.optional(),
-  userId: z5.string().max(255).optional(),
-  providerName: z5.string().max(255).optional()
+  userId: z6.string().max(255).optional(),
+  providerName: z6.string().max(255).optional()
 }).refine((m) => m.url !== undefined || m.provider !== undefined, {
   message: "an auth elicitation needs a url or a provider"
 });
-var ThoughtEvent = z5.strictObject({
+var ThoughtEvent = z6.strictObject({
   ...envelope,
-  type: z5.literal("thought"),
+  type: z6.literal("thought"),
   body,
-  ephemeral: z5.boolean().default(false)
+  ephemeral: z6.boolean().default(false)
 });
-var ActionEvent = z5.strictObject({
+var ActionEvent = z6.strictObject({
   ...envelope,
-  type: z5.literal("action"),
-  action: z5.string().trim().min(1).max(255),
-  parameter: z5.string().trim().min(1).max(4096),
-  result: z5.string().max(64 * 1024).optional(),
-  ephemeral: z5.boolean().default(false)
+  type: z6.literal("action"),
+  action: z6.string().trim().min(1).max(255),
+  parameter: z6.string().trim().min(1).max(4096),
+  result: z6.string().max(64 * 1024).optional(),
+  ephemeral: z6.boolean().default(false)
 });
-var ElicitationEvent = z5.strictObject({
+var ElicitationEvent = z6.strictObject({
   ...envelope,
-  type: z5.literal("elicitation"),
+  type: z6.literal("elicitation"),
   body,
-  signal: z5.enum(["select", "auth"]).optional(),
-  signalMetadata: z5.record(z5.string(), z5.unknown()).optional()
+  signal: z6.enum(["select", "auth"]).optional(),
+  signalMetadata: z6.record(z6.string(), z6.unknown()).optional()
 }).superRefine((event, ctx) => {
   if (!event.signal) {
     if (event.signalMetadata) {
@@ -976,14 +1117,14 @@ var ElicitationEvent = z5.strictObject({
     });
   }
 });
-var ResponseEvent = z5.strictObject({
+var ResponseEvent = z6.strictObject({
   ...envelope,
-  type: z5.literal("response"),
+  type: z6.literal("response"),
   body
 });
-var ErrorEvent = z5.strictObject({
+var ErrorEvent = z6.strictObject({
   ...envelope,
-  type: z5.literal("error"),
+  type: z6.literal("error"),
   body
 });
 var PLAN_ENTRY_STATUSES = [
@@ -992,33 +1133,33 @@ var PLAN_ENTRY_STATUSES = [
   "completed",
   "canceled"
 ];
-var PlanEvent = z5.strictObject({
+var PlanEvent = z6.strictObject({
   ...envelope,
-  type: z5.literal("plan"),
-  entries: z5.array(z5.strictObject({
-    content: z5.string().trim().min(1).max(1024),
-    status: z5.enum(PLAN_ENTRY_STATUSES)
+  type: z6.literal("plan"),
+  entries: z6.array(z6.strictObject({
+    content: z6.string().trim().min(1).max(1024),
+    status: z6.enum(PLAN_ENTRY_STATUSES)
   })).max(100)
 });
-var SummaryEvent = z5.strictObject({
+var SummaryEvent = z6.strictObject({
   ...envelope,
-  type: z5.literal("summary"),
-  title: z5.string().min(1).max(255).regex(/^[^\r\n\0]*$/, "one line").refine((t) => t.trim().length > 0, "not blank")
+  type: z6.literal("summary"),
+  title: z6.string().min(1).max(255).regex(/^[^\r\n\0]*$/, "one line").refine((t) => t.trim().length > 0, "not blank")
 });
-var ExternalUrlEvent = z5.strictObject({
+var ExternalUrlEvent = z6.strictObject({
   ...envelope,
-  type: z5.literal("external_url"),
-  label: z5.string().trim().min(1).max(255),
-  url: z5.url()
+  type: z6.literal("external_url"),
+  label: z6.string().trim().min(1).max(255),
+  url: z6.url()
 });
-var UsageEvent = z5.strictObject({
+var UsageEvent = z6.strictObject({
   ...envelope,
-  type: z5.literal("usage"),
-  inputTokens: z5.number().int().min(0).optional(),
-  outputTokens: z5.number().int().min(0).optional(),
-  costUsd: z5.number().min(0).optional(),
-  contextUsed: z5.number().int().min(0).optional(),
-  contextSize: z5.number().int().min(0).optional()
+  type: z6.literal("usage"),
+  inputTokens: z6.number().int().min(0).optional(),
+  outputTokens: z6.number().int().min(0).optional(),
+  costUsd: z6.number().min(0).optional(),
+  contextUsed: z6.number().int().min(0).optional(),
+  contextSize: z6.number().int().min(0).optional()
 });
 var STATUS_EVENT_STATES = [
   "starting",
@@ -1026,12 +1167,12 @@ var STATUS_EVENT_STATES = [
   "waiting_permission",
   "finishing"
 ];
-var StatusEvent = z5.strictObject({
+var StatusEvent = z6.strictObject({
   ...envelope,
-  type: z5.literal("status"),
-  state: z5.enum(STATUS_EVENT_STATES)
+  type: z6.literal("status"),
+  state: z6.enum(STATUS_EVENT_STATES)
 });
-var SessionEvent = z5.discriminatedUnion("type", [
+var SessionEvent = z6.discriminatedUnion("type", [
   ThoughtEvent,
   ActionEvent,
   ElicitationEvent,
@@ -1043,16 +1184,302 @@ var SessionEvent = z5.discriminatedUnion("type", [
   UsageEvent,
   StatusEvent
 ]);
-var EventsRequest = z5.strictObject({
-  workItemId: z5.number().int().positive(),
-  events: z5.array(SessionEvent).min(1).max(MAX_EVENTS_PER_BATCH)
+var EventsRequest = z6.strictObject({
+  workItemId: z6.number().int().positive(),
+  events: z6.array(SessionEvent).min(1).max(MAX_EVENTS_PER_BATCH)
 });
-var EventsResponse = z5.looseObject({
-  accepted: z5.number().int().min(0),
-  duplicates: z5.number().int().min(0),
-  dropped: z5.number().int().min(0),
-  cancelRequested: z5.boolean()
+var EventsResponse = z6.looseObject({
+  accepted: z6.number().int().min(0),
+  duplicates: z6.number().int().min(0),
+  dropped: z6.number().int().min(0),
+  cancelRequested: z6.boolean()
 });
+// ../protocol/src/otlp.ts
+import protobuf from "protobufjs/light.js";
+var SPAN_KIND = {
+  internal: 1,
+  server: 2,
+  client: 3,
+  producer: 4,
+  consumer: 5
+};
+var STATUS_CODE = { unset: 0, ok: 1, error: 2 };
+var TEMPORALITY = { delta: 1, cumulative: 2 };
+var SEVERITY = { debug: 5, info: 9, warn: 13, error: 17 };
+var rep = (type, id) => ({ rule: "repeated", type, id });
+var DESCRIPTOR = {
+  nested: {
+    AnyValue: {
+      oneofs: {
+        value: {
+          oneof: [
+            "stringValue",
+            "boolValue",
+            "intValue",
+            "doubleValue",
+            "arrayValue",
+            "kvlistValue",
+            "bytesValue"
+          ]
+        }
+      },
+      fields: {
+        stringValue: { type: "string", id: 1 },
+        boolValue: { type: "bool", id: 2 },
+        intValue: { type: "int64", id: 3 },
+        doubleValue: { type: "double", id: 4 },
+        arrayValue: { type: "ArrayValue", id: 5 },
+        kvlistValue: { type: "KeyValueList", id: 6 },
+        bytesValue: { type: "bytes", id: 7 }
+      }
+    },
+    ArrayValue: { fields: { values: rep("AnyValue", 1) } },
+    KeyValueList: { fields: { values: rep("KeyValue", 1) } },
+    KeyValue: {
+      fields: {
+        key: { type: "string", id: 1 },
+        value: { type: "AnyValue", id: 2 }
+      }
+    },
+    InstrumentationScope: {
+      fields: {
+        name: { type: "string", id: 1 },
+        version: { type: "string", id: 2 },
+        attributes: rep("KeyValue", 3),
+        droppedAttributesCount: { type: "uint32", id: 4 }
+      }
+    },
+    Resource: {
+      fields: {
+        attributes: rep("KeyValue", 1),
+        droppedAttributesCount: { type: "uint32", id: 2 }
+      }
+    },
+    ExportTraceServiceRequest: {
+      fields: { resourceSpans: rep("ResourceSpans", 1) }
+    },
+    ResourceSpans: {
+      fields: {
+        resource: { type: "Resource", id: 1 },
+        scopeSpans: rep("ScopeSpans", 2),
+        schemaUrl: { type: "string", id: 3 }
+      }
+    },
+    ScopeSpans: {
+      fields: {
+        scope: { type: "InstrumentationScope", id: 1 },
+        spans: rep("Span", 2),
+        schemaUrl: { type: "string", id: 3 }
+      }
+    },
+    Span: {
+      fields: {
+        traceId: { type: "bytes", id: 1 },
+        spanId: { type: "bytes", id: 2 },
+        traceState: { type: "string", id: 3 },
+        parentSpanId: { type: "bytes", id: 4 },
+        flags: { type: "fixed32", id: 16 },
+        name: { type: "string", id: 5 },
+        kind: { type: "int32", id: 6 },
+        startTimeUnixNano: { type: "fixed64", id: 7 },
+        endTimeUnixNano: { type: "fixed64", id: 8 },
+        attributes: rep("KeyValue", 9),
+        droppedAttributesCount: { type: "uint32", id: 10 },
+        events: rep("SpanEvent", 11),
+        droppedEventsCount: { type: "uint32", id: 12 },
+        links: rep("SpanLink", 13),
+        droppedLinksCount: { type: "uint32", id: 14 },
+        status: { type: "SpanStatus", id: 15 }
+      }
+    },
+    SpanEvent: {
+      fields: {
+        timeUnixNano: { type: "fixed64", id: 1 },
+        name: { type: "string", id: 2 },
+        attributes: rep("KeyValue", 3),
+        droppedAttributesCount: { type: "uint32", id: 4 }
+      }
+    },
+    SpanLink: {
+      fields: {
+        traceId: { type: "bytes", id: 1 },
+        spanId: { type: "bytes", id: 2 },
+        traceState: { type: "string", id: 3 },
+        attributes: rep("KeyValue", 4),
+        droppedAttributesCount: { type: "uint32", id: 5 },
+        flags: { type: "fixed32", id: 6 }
+      }
+    },
+    SpanStatus: {
+      fields: {
+        message: { type: "string", id: 2 },
+        code: { type: "int32", id: 3 }
+      }
+    },
+    ExportLogsServiceRequest: {
+      fields: { resourceLogs: rep("ResourceLogs", 1) }
+    },
+    ResourceLogs: {
+      fields: {
+        resource: { type: "Resource", id: 1 },
+        scopeLogs: rep("ScopeLogs", 2),
+        schemaUrl: { type: "string", id: 3 }
+      }
+    },
+    ScopeLogs: {
+      fields: {
+        scope: { type: "InstrumentationScope", id: 1 },
+        logRecords: rep("LogRecord", 2),
+        schemaUrl: { type: "string", id: 3 }
+      }
+    },
+    LogRecord: {
+      fields: {
+        timeUnixNano: { type: "fixed64", id: 1 },
+        observedTimeUnixNano: { type: "fixed64", id: 11 },
+        severityNumber: { type: "int32", id: 2 },
+        severityText: { type: "string", id: 3 },
+        body: { type: "AnyValue", id: 5 },
+        attributes: rep("KeyValue", 6),
+        droppedAttributesCount: { type: "uint32", id: 7 },
+        flags: { type: "fixed32", id: 8 },
+        traceId: { type: "bytes", id: 9 },
+        spanId: { type: "bytes", id: 10 },
+        eventName: { type: "string", id: 12 }
+      }
+    },
+    ExportMetricsServiceRequest: {
+      fields: { resourceMetrics: rep("ResourceMetrics", 1) }
+    },
+    ResourceMetrics: {
+      fields: {
+        resource: { type: "Resource", id: 1 },
+        scopeMetrics: rep("ScopeMetrics", 2),
+        schemaUrl: { type: "string", id: 3 }
+      }
+    },
+    ScopeMetrics: {
+      fields: {
+        scope: { type: "InstrumentationScope", id: 1 },
+        metrics: rep("Metric", 2),
+        schemaUrl: { type: "string", id: 3 }
+      }
+    },
+    Metric: {
+      oneofs: { data: { oneof: ["gauge", "sum", "histogram"] } },
+      fields: {
+        name: { type: "string", id: 1 },
+        description: { type: "string", id: 2 },
+        unit: { type: "string", id: 3 },
+        gauge: { type: "Gauge", id: 5 },
+        sum: { type: "Sum", id: 7 },
+        histogram: { type: "Histogram", id: 9 },
+        metadata: rep("KeyValue", 12)
+      }
+    },
+    Gauge: { fields: { dataPoints: rep("NumberDataPoint", 1) } },
+    Sum: {
+      fields: {
+        dataPoints: rep("NumberDataPoint", 1),
+        aggregationTemporality: { type: "int32", id: 2 },
+        isMonotonic: { type: "bool", id: 3 }
+      }
+    },
+    Histogram: {
+      fields: {
+        dataPoints: rep("HistogramDataPoint", 1),
+        aggregationTemporality: { type: "int32", id: 2 }
+      }
+    },
+    NumberDataPoint: {
+      oneofs: { value: { oneof: ["asDouble", "asInt"] } },
+      fields: {
+        attributes: rep("KeyValue", 7),
+        startTimeUnixNano: { type: "fixed64", id: 2 },
+        timeUnixNano: { type: "fixed64", id: 3 },
+        asDouble: { type: "double", id: 4 },
+        asInt: { type: "sfixed64", id: 6 },
+        flags: { type: "uint32", id: 8 }
+      }
+    },
+    HistogramDataPoint: {
+      fields: {
+        attributes: rep("KeyValue", 9),
+        startTimeUnixNano: { type: "fixed64", id: 2 },
+        timeUnixNano: { type: "fixed64", id: 3 },
+        count: { type: "fixed64", id: 4 },
+        sum: { type: "double", id: 5, options: { proto3_optional: true } },
+        bucketCounts: { ...rep("fixed64", 6), options: { packed: true } },
+        explicitBounds: { ...rep("double", 7), options: { packed: true } },
+        flags: { type: "uint32", id: 10 },
+        min: { type: "double", id: 11, options: { proto3_optional: true } },
+        max: { type: "double", id: 12, options: { proto3_optional: true } }
+      }
+    }
+  }
+};
+var root = protobuf.Root.fromJSON(DESCRIPTOR);
+var REQUEST_TYPES = {
+  traces: root.lookupType("ExportTraceServiceRequest"),
+  metrics: root.lookupType("ExportMetricsServiceRequest"),
+  logs: root.lookupType("ExportLogsServiceRequest")
+};
+var HEX_ID_FIELDS = new Set(["traceId", "spanId", "parentSpanId"]);
+function toJson(value, key = "") {
+  if (value instanceof Uint8Array) {
+    return HEX_ID_FIELDS.has(key) ? Buffer.from(value).toString("hex") : Buffer.from(value).toString("base64");
+  }
+  if (Array.isArray(value))
+    return value.map((v) => toJson(v, key));
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value))
+      out[k] = toJson(v, k);
+    return out;
+  }
+  return value;
+}
+function decodeOtlpProtobuf(signal, bytes) {
+  const type = REQUEST_TYPES[signal];
+  const object = type.toObject(type.decode(bytes), {
+    longs: String,
+    defaults: false,
+    arrays: false
+  });
+  return toJson(object);
+}
+function decodeOtlpBody(signal, bytes, contentType) {
+  if ((contentType ?? "").toLowerCase().includes("json")) {
+    const parsed = JSON.parse(new TextDecoder().decode(bytes));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      throw new Error("not an OTLP request");
+    return parsed;
+  }
+  return decodeOtlpProtobuf(signal, bytes);
+}
+function signalOfPath(path) {
+  const match = /\/v1\/(traces|metrics|logs)\/?$/.exec(path);
+  return match ? match[1] : null;
+}
+function attribute(key, value) {
+  if (value === null || value === undefined)
+    return null;
+  if (typeof value === "boolean")
+    return { key, value: { boolValue: value } };
+  if (typeof value === "number") {
+    return Number.isInteger(value) ? { key, value: { intValue: String(value) } } : { key, value: { doubleValue: value } };
+  }
+  return { key, value: { stringValue: value } };
+}
+function attributes(values) {
+  return Object.entries(values).flatMap(([k, v]) => {
+    const a = attribute(k, v);
+    return a ? [a] : [];
+  });
+}
+function unixNano(ms) {
+  return (BigInt(Math.round(ms * 1000)) * 1000n).toString();
+}
 // ../protocol/src/remote.ts
 function normalizeRemote(remote) {
   let rest = remote.trim();
@@ -1076,14 +1503,14 @@ function normalizeRemote(remote) {
   return path ? `${host.toLowerCase()}/${path}` : host.toLowerCase();
 }
 // ../protocol/src/tools.ts
-import { z as z6 } from "zod";
-var issueRef = z6.string().trim().min(1).max(100).describe("An issue identifier like ENG-123, or the issue's id");
-var teamRef = z6.string().trim().min(1).max(100).describe("A team key like ENG, or the team's id");
-var projectRef = z6.string().trim().min(1).max(255).describe("A project's id or its exact name");
-var markdown = (what) => z6.string().min(1).describe(`${what}, in Markdown. Mention people and issues by their Linear URLs, not @names; put long logs or diffs in a collapsible section (+++ Title \u2026 +++)`);
-var labels = z6.array(z6.string().trim().min(1).max(255)).max(50).describe("Label names or ids (see linear_list_labels); replaces the issue's labels");
-var priority = z6.number().int().min(0).max(4).describe("0 none, 1 urgent, 2 high, 3 medium, 4 low");
-var first = z6.number().int().min(1).max(25).optional().describe("How many to return, at most 25 (default 25)");
+import { z as z7 } from "zod";
+var issueRef = z7.string().trim().min(1).max(100).describe("An issue identifier like ENG-123, or the issue's id");
+var teamRef = z7.string().trim().min(1).max(100).describe("A team key like ENG, or the team's id");
+var projectRef = z7.string().trim().min(1).max(255).describe("A project's id or its exact name");
+var markdown = (what) => z7.string().min(1).describe(`${what}, in Markdown. Mention people and issues by their Linear URLs, not @names; put long logs or diffs in a collapsible section (+++ Title \u2026 +++)`);
+var labels = z7.array(z7.string().trim().min(1).max(255)).max(50).describe("Label names or ids (see linear_list_labels); replaces the issue's labels");
+var priority = z7.number().int().min(0).max(4).describe("0 none, 1 urgent, 2 high, 3 medium, 4 low");
+var first = z7.number().int().min(1).max(25).optional().describe("How many to return, at most 25 (default 25)");
 var ISSUE_STATE_TYPES = [
   "triage",
   "backlog",
@@ -1111,7 +1538,7 @@ var HYPOTENUSE_TOOLS = [
     roles: BOTH,
     kind: "read",
     description: "Read a Linear issue: title, description, state, priority, labels, assignee, delegate, parent, sub-issues, relations, project, team, and URL. Defaults to the issue you are working on. People are listed with their profile URLs; use those URLs to mention someone.",
-    input: z6.strictObject({ issue: issueRef.optional() })
+    input: z7.strictObject({ issue: issueRef.optional() })
   }),
   tool({
     name: "linear_list_comments",
@@ -1120,10 +1547,10 @@ var HYPOTENUSE_TOOLS = [
     roles: BOTH,
     kind: "read",
     description: "Read the comments on a Linear issue, oldest first, replies under the comment they answer. Defaults to the issue you are working on. Pass `after` (from the last page) to read further.",
-    input: z6.strictObject({
+    input: z7.strictObject({
       issue: issueRef.optional(),
       first,
-      after: z6.string().trim().min(1).max(512).optional().describe("The cursor the previous page returned")
+      after: z7.string().trim().min(1).max(512).optional().describe("The cursor the previous page returned")
     })
   }),
   tool({
@@ -1133,10 +1560,10 @@ var HYPOTENUSE_TOOLS = [
     roles: BOTH,
     kind: "write",
     description: "Post a comment on a Linear issue, as Hypotenuse. Your final answer already appears in Linear as a comment in this session's thread, so never use this to repeat it: use it to answer a question someone left elsewhere on the issue, or to note a blocker for someone who is not following this session. Pass `parentId` to reply in an existing thread.",
-    input: z6.strictObject({
+    input: z7.strictObject({
       body: markdown("The comment"),
       issue: issueRef.optional().describe("The issue to comment on; defaults to the issue you are working on"),
-      parentId: z6.string().trim().min(1).max(100).optional().describe("The id of the comment to reply to")
+      parentId: z7.string().trim().min(1).max(100).optional().describe("The id of the comment to reply to")
     })
   }),
   tool({
@@ -1146,8 +1573,8 @@ var HYPOTENUSE_TOOLS = [
     roles: BOTH,
     kind: "write",
     description: `Move a Linear issue to a workflow state, by the state's name ("In Review") or its type (triage, backlog, unstarted, started, completed, canceled). Defaults to the issue you are working on. A worker cannot complete or cancel an issue, and a manager can only where the project allows it: a person decides when work is done.`,
-    input: z6.strictObject({
-      state: z6.string().trim().min(1).max(255).describe("A state name, or a state type"),
+    input: z7.strictObject({
+      state: z7.string().trim().min(1).max(255).describe("A state name, or a state type"),
       issue: issueRef.optional()
     })
   }),
@@ -1158,10 +1585,10 @@ var HYPOTENUSE_TOOLS = [
     roles: BOTH,
     kind: "write",
     description: "Replace this session's plan in Linear with the whole list of steps. Only needed if your own plan updates do not already appear there.",
-    input: z6.strictObject({
-      steps: z6.array(z6.strictObject({
-        content: z6.string().trim().min(1).max(1024).describe("The step"),
-        status: z6.enum(PLAN_STEP_STATUSES).describe("pending, inProgress, completed, or canceled")
+    input: z7.strictObject({
+      steps: z7.array(z7.strictObject({
+        content: z7.string().trim().min(1).max(1024).describe("The step"),
+        status: z7.enum(PLAN_STEP_STATUSES).describe("pending, inProgress, completed, or canceled")
       })).min(1).max(100).describe("Every step, in order")
     })
   }),
@@ -1172,11 +1599,11 @@ var HYPOTENUSE_TOOLS = [
     roles: BOTH,
     kind: "write",
     description: "Ask the person a question in Linear when you need their decision to go on. With `options`, Linear shows them as choices (a GitHub repository URL as a value renders as that repository). Their answer arrives as your next prompt: after calling this, end your turn at once without a further message.",
-    input: z6.strictObject({
-      question: z6.string().trim().min(1).max(1e4).describe("The question"),
-      options: z6.array(z6.strictObject({
-        label: z6.string().trim().min(1).max(255).describe("What the person sees"),
-        value: z6.string().trim().min(1).max(2048).optional().describe("What you get back; defaults to the label")
+    input: z7.strictObject({
+      question: z7.string().trim().min(1).max(1e4).describe("The question"),
+      options: z7.array(z7.strictObject({
+        label: z7.string().trim().min(1).max(255).describe("What the person sees"),
+        value: z7.string().trim().min(1).max(2048).optional().describe("What you get back; defaults to the label")
       })).min(2).max(10).optional().describe("2 to 10 choices; omit for a free-text answer")
     })
   }),
@@ -1187,8 +1614,8 @@ var HYPOTENUSE_TOOLS = [
     roles: BOTH,
     kind: "write",
     description: "Link the pull request you opened to this session in Linear. Call it as soon as the pull request exists. It must be a pull request on this session's repository.",
-    input: z6.strictObject({
-      url: z6.url().max(2048).describe("The pull request's URL")
+    input: z7.strictObject({
+      url: z7.url().max(2048).describe("The pull request's URL")
     })
   }),
   tool({
@@ -1198,11 +1625,11 @@ var HYPOTENUSE_TOOLS = [
     roles: BOTH,
     kind: "read",
     description: "Search Linear issues by text in their title or description, narrowed by team, state type, label, or project. At most 25 results.",
-    input: z6.strictObject({
-      query: z6.string().trim().min(1).max(255).optional().describe("Text to find in titles and descriptions"),
+    input: z7.strictObject({
+      query: z7.string().trim().min(1).max(255).optional().describe("Text to find in titles and descriptions"),
       team: teamRef.optional(),
-      stateType: z6.enum(ISSUE_STATE_TYPES).optional().describe("Only issues in states of this type"),
-      label: z6.string().trim().min(1).max(255).optional().describe("Only issues with this label name"),
+      stateType: z7.enum(ISSUE_STATE_TYPES).optional().describe("Only issues in states of this type"),
+      label: z7.string().trim().min(1).max(255).optional().describe("Only issues with this label name"),
       project: projectRef.optional(),
       first
     })
@@ -1214,8 +1641,8 @@ var HYPOTENUSE_TOOLS = [
     roles: MANAGER,
     kind: "write",
     description: "Create a Linear issue. Defaults to the team of the issue you are working on. Never assigns anyone: hand work to a worker with hypotenuse_dispatch.",
-    input: z6.strictObject({
-      title: z6.string().trim().min(1).max(255).describe("The title"),
+    input: z7.strictObject({
+      title: z7.string().trim().min(1).max(255).describe("The title"),
       description: markdown("The description").optional(),
       team: teamRef.optional(),
       labels: labels.optional(),
@@ -1231,14 +1658,14 @@ var HYPOTENUSE_TOOLS = [
     roles: MANAGER,
     kind: "write",
     description: "Edit a Linear issue you manage: its title, description, labels, priority, project, or estimate. It cannot change the assignee.",
-    input: z6.strictObject({
+    input: z7.strictObject({
       issue: issueRef,
-      title: z6.string().trim().min(1).max(255).optional().describe("The title"),
+      title: z7.string().trim().min(1).max(255).optional().describe("The title"),
       description: markdown("The description").optional(),
       labels: labels.optional(),
       priority: priority.optional(),
       project: projectRef.optional(),
-      estimate: z6.number().int().min(0).max(100).optional().describe("The estimate, in the team's points")
+      estimate: z7.number().int().min(0).max(100).optional().describe("The estimate, in the team's points")
     })
   }),
   tool({
@@ -1248,9 +1675,9 @@ var HYPOTENUSE_TOOLS = [
     roles: MANAGER,
     kind: "write",
     description: "Create a sub-issue under an issue you manage \u2014 how a plan is broken into tickets. It goes in the parent's team unless you name another.",
-    input: z6.strictObject({
+    input: z7.strictObject({
       parent: issueRef.describe("The parent issue"),
-      title: z6.string().trim().min(1).max(255).describe("The title"),
+      title: z7.string().trim().min(1).max(255).describe("The title"),
       description: markdown("The description").optional(),
       team: teamRef.optional(),
       labels: labels.optional(),
@@ -1265,10 +1692,10 @@ var HYPOTENUSE_TOOLS = [
     roles: MANAGER,
     kind: "write",
     description: "Relate two Linear issues: `blocks` (issue blocks relatedIssue), `related`, or `duplicate` (issue duplicates relatedIssue). At least one of them must be an issue you manage.",
-    input: z6.strictObject({
+    input: z7.strictObject({
       issue: issueRef,
       relatedIssue: issueRef.describe("The other issue"),
-      type: z6.enum(["blocks", "related", "duplicate"]).describe("blocks, related, or duplicate")
+      type: z7.enum(["blocks", "related", "duplicate"]).describe("blocks, related, or duplicate")
     })
   }),
   tool({
@@ -1278,7 +1705,7 @@ var HYPOTENUSE_TOOLS = [
     roles: MANAGER,
     kind: "read",
     description: "Read a Linear project: its name, summary, content (the PRD), status, lead, how many issues are in each state, and its documents. Defaults to the project of the issue you are working on.",
-    input: z6.strictObject({ project: projectRef.optional() })
+    input: z7.strictObject({ project: projectRef.optional() })
   }),
   tool({
     name: "linear_update_project",
@@ -1287,11 +1714,11 @@ var HYPOTENUSE_TOOLS = [
     roles: MANAGER,
     kind: "write",
     description: "Write a Linear project's content (the PRD, in Markdown), its one-line summary, or its status. Only the project of the issue you are working on. It never changes the lead or the members.",
-    input: z6.strictObject({
+    input: z7.strictObject({
       project: projectRef.optional(),
       content: markdown("The project's content (the PRD)").optional(),
-      summary: z6.string().trim().min(1).max(255).optional().describe("The one-line summary shown under the project's name"),
-      status: z6.string().trim().min(1).max(255).optional().describe("A project status name, or its type (backlog, planned, started, paused, completed, canceled)")
+      summary: z7.string().trim().min(1).max(255).optional().describe("The one-line summary shown under the project's name"),
+      status: z7.string().trim().min(1).max(255).optional().describe("A project status name, or its type (backlog, planned, started, paused, completed, canceled)")
     })
   }),
   tool({
@@ -1301,8 +1728,8 @@ var HYPOTENUSE_TOOLS = [
     roles: MANAGER,
     kind: "write",
     description: "Create a Linear document attached to a project or an issue you manage. Defaults to the project of the issue you are working on.",
-    input: z6.strictObject({
-      title: z6.string().trim().min(1).max(255).describe("The title"),
+    input: z7.strictObject({
+      title: z7.string().trim().min(1).max(255).describe("The title"),
       content: markdown("The document"),
       project: projectRef.optional(),
       issue: issueRef.optional().describe("Attach it to this issue instead of a project")
@@ -1315,10 +1742,10 @@ var HYPOTENUSE_TOOLS = [
     roles: MANAGER,
     kind: "write",
     description: "Replace a Linear document's content (and optionally its title): one this session created, or one attached to the project of the issue you are working on.",
-    input: z6.strictObject({
-      document: z6.string().trim().min(1).max(100).describe("The document's id"),
+    input: z7.strictObject({
+      document: z7.string().trim().min(1).max(100).describe("The document's id"),
       content: markdown("The document's new content"),
-      title: z6.string().trim().min(1).max(255).optional().describe("A new title")
+      title: z7.string().trim().min(1).max(255).optional().describe("A new title")
     })
   }),
   tool({
@@ -1328,7 +1755,7 @@ var HYPOTENUSE_TOOLS = [
     roles: MANAGER,
     kind: "read",
     description: "List the labels you can put on a team's issues (the team's own and the workspace's). Defaults to the team of the issue you are working on.",
-    input: z6.strictObject({ team: teamRef.optional() })
+    input: z7.strictObject({ team: teamRef.optional() })
   }),
   tool({
     name: "hypotenuse_dispatch",
@@ -1337,11 +1764,11 @@ var HYPOTENUSE_TOOLS = [
     roles: MANAGER,
     kind: "write",
     description: 'Hand an issue you manage to a Hypotenuse worker: it is delegated to Hypotenuse and a worker session starts on it on whichever runner can take it. Only dispatch an issue whose acceptance criteria are written, one call per issue. When the worker finishes, you get a review turn with its result: accept it, request changes with mode "changes" and specific instructions, or file follow-up issues. Workers cannot dispatch, you cannot dispatch the issue you are working on, and you may have only a few dispatched issues in progress at once.',
-    input: z6.strictObject({
+    input: z7.strictObject({
       issue: issueRef,
-      instructions: z6.string().trim().min(1).max(8192).optional().describe('Context for the worker that does not belong in the issue; for mode "changes", exactly what to change'),
-      agentPreference: z6.string().trim().min(1).max(64).optional().describe("An agent id the worker's runner should prefer (a preference, not a requirement)"),
-      mode: z6.enum(["new", "changes"]).optional().describe("new (default): start a worker on the issue. changes: send a finished worker back to the same session and branch with your instructions")
+      instructions: z7.string().trim().min(1).max(8192).optional().describe('Context for the worker that does not belong in the issue; for mode "changes", exactly what to change'),
+      agentPreference: z7.string().trim().min(1).max(64).optional().describe("An agent id the worker's runner should prefer (a preference, not a requirement)"),
+      mode: z7.enum(["new", "changes"]).optional().describe("new (default): start a worker on the issue. changes: send a finished worker back to the same session and branch with your instructions")
     })
   })
 ];
@@ -1351,10 +1778,10 @@ function toolsForRole(role) {
 function toolByName(name) {
   return HYPOTENUSE_TOOLS.find((t) => t.name === name);
 }
-var ToolResult = z6.looseObject({
-  result: z6.looseObject({
-    text: z6.string(),
-    data: z6.record(z6.string(), z6.unknown())
+var ToolResult = z7.looseObject({
+  result: z7.looseObject({
+    text: z7.string(),
+    data: z7.record(z7.string(), z7.unknown())
   })
 });
 var TOOL_RESULT_MAX_BYTES = 16 * 1024;
@@ -1364,98 +1791,99 @@ var PROTOCOL_VERSION = 1;
 var PROTOCOL_HEADER = "X-Hypotenuse-Protocol";
 var PROTOCOL_UNSUPPORTED = "PROTOCOL_UNSUPPORTED";
 // ../protocol/src/work.ts
-import { z as z7 } from "zod";
-var ClaimRequest = z7.strictObject({
-  workItemIds: z7.array(z7.number().int().positive()).max(100).optional().describe("Claim only these work items; omitted means any offer")
+import { z as z8 } from "zod";
+var ClaimRequest = z8.strictObject({
+  workItemIds: z8.array(z8.number().int().positive()).max(100).optional().describe("Claim only these work items; omitted means any offer")
 });
-var AssignmentRepository = z7.looseObject({
-  remote: z7.string(),
-  baseBranch: z7.string().nullable()
+var AssignmentRepository = z8.looseObject({
+  remote: z8.string(),
+  baseBranch: z8.string().nullable()
 });
-var AssignmentIssue = z7.looseObject({
-  id: z7.string(),
-  identifier: z7.string().nullable(),
-  title: z7.string().nullable(),
-  description: z7.string().nullable(),
-  url: z7.string().nullable(),
-  teamKey: z7.string().nullable(),
-  labels: z7.array(z7.string()),
-  state: z7.looseObject({ name: z7.string(), type: z7.string() }).nullable(),
-  parent: z7.looseObject({ id: z7.string() }).nullable(),
-  project: z7.looseObject({ id: z7.string(), name: z7.string() }).nullable()
+var AssignmentIssue = z8.looseObject({
+  id: z8.string(),
+  identifier: z8.string().nullable(),
+  title: z8.string().nullable(),
+  description: z8.string().nullable(),
+  url: z8.string().nullable(),
+  teamKey: z8.string().nullable(),
+  labels: z8.array(z8.string()),
+  state: z8.looseObject({ name: z8.string(), type: z8.string() }).nullable(),
+  parent: z8.looseObject({ id: z8.string() }).nullable(),
+  project: z8.looseObject({ id: z8.string(), name: z8.string() }).nullable()
 });
-var AssignmentGuidance = z7.looseObject({
-  origin: z7.enum(["team", "workspace"]),
-  teamKey: z7.string().nullable().optional(),
-  body: z7.string()
+var AssignmentGuidance = z8.looseObject({
+  origin: z8.enum(["team", "workspace"]),
+  teamKey: z8.string().nullable().optional(),
+  body: z8.string()
 });
-var HistoryEntry = z7.looseObject({
-  seq: z7.number().int(),
-  activityId: z7.number().int(),
-  direction: z7.enum(["inbound", "outbound"]),
-  type: z7.string(),
-  body: z7.string().nullable(),
-  signal: z7.string().nullable()
+var HistoryEntry = z8.looseObject({
+  seq: z8.number().int(),
+  activityId: z8.number().int(),
+  direction: z8.enum(["inbound", "outbound"]),
+  type: z8.string(),
+  body: z8.string().nullable(),
+  signal: z8.string().nullable()
 });
-var PromptEntry = z7.looseObject({
-  activityId: z7.number().int(),
-  body: z7.string()
+var PromptEntry = z8.looseObject({
+  activityId: z8.number().int(),
+  body: z8.string()
 });
-var AssignmentLink = z7.looseObject({
-  label: z7.string(),
-  url: z7.string()
+var AssignmentLink = z8.looseObject({
+  label: z8.string(),
+  url: z8.string()
 });
 var DISPATCH_MODES = ["new", "changes"];
-var AssignmentDispatch = z7.looseObject({
-  mode: z7.enum(DISPATCH_MODES),
-  reviewRound: z7.number().int().min(0),
-  instructions: z7.string().nullable().describe("Extra context from the planning agent; for `changes`, what to change"),
-  agentPreference: z7.string().nullable().describe("An [agents] id the planning agent prefers; a preference only"),
-  parent: z7.looseObject({
-    agentSessionId: z7.number().int().positive(),
-    issueIdentifier: z7.string().nullable(),
-    issueUrl: z7.string().nullable()
+var AssignmentDispatch = z8.looseObject({
+  mode: z8.enum(DISPATCH_MODES),
+  reviewRound: z8.number().int().min(0),
+  instructions: z8.string().nullable().describe("Extra context from the planning agent; for `changes`, what to change"),
+  agentPreference: z8.string().nullable().describe("An [agents] id the planning agent prefers; a preference only"),
+  parent: z8.looseObject({
+    agentSessionId: z8.number().int().positive(),
+    issueIdentifier: z8.string().nullable(),
+    issueUrl: z8.string().nullable()
   })
 });
 var REVIEW_OUTCOMES = ["completed", "failed", "cancelled"];
-var AssignmentReview = z7.looseObject({
-  childAgentSessionId: z7.number().int().positive(),
-  childIssueIdentifier: z7.string().nullable(),
-  childIssueUrl: z7.string().nullable(),
-  reviewRound: z7.number().int().min(0),
-  outcome: z7.enum(REVIEW_OUTCOMES),
-  finalResponse: z7.string().nullable().describe("The body of the worker's last response or error"),
-  plan: z7.array(z7.looseObject({ content: z7.string(), status: z7.string() })).nullable(),
-  pullRequests: z7.array(AssignmentLink)
+var AssignmentReview = z8.looseObject({
+  childAgentSessionId: z8.number().int().positive(),
+  childIssueIdentifier: z8.string().nullable(),
+  childIssueUrl: z8.string().nullable(),
+  reviewRound: z8.number().int().min(0),
+  outcome: z8.enum(REVIEW_OUTCOMES),
+  finalResponse: z8.string().nullable().describe("The body of the worker's last response or error"),
+  plan: z8.array(z8.looseObject({ content: z8.string(), status: z8.string() })).nullable(),
+  pullRequests: z8.array(AssignmentLink)
 });
-var WorkAssignment = z7.looseObject({
-  workItemId: z7.number().int().positive(),
-  agentSessionId: z7.number().int().positive(),
-  type: z7.string(),
-  externalSessionId: z7.string(),
-  externalSessionUrl: z7.string().nullable(),
-  dashboardUrl: z7.string(),
-  kind: z7.enum(OFFER_KINDS),
+var WorkAssignment = z8.looseObject({
+  workItemId: z8.number().int().positive(),
+  agentSessionId: z8.number().int().positive(),
+  type: z8.string(),
+  externalSessionId: z8.string(),
+  externalSessionUrl: z8.string().nullable(),
+  dashboardUrl: z8.string(),
+  kind: z8.enum(OFFER_KINDS),
   role: RunnerRole,
-  agentId: z7.string().nullable(),
-  fresh: z7.boolean(),
+  agentId: z8.string().nullable(),
+  fresh: z8.boolean(),
   repository: AssignmentRepository.nullable(),
-  branch: z7.string().nullable(),
+  branch: z8.string().nullable(),
   issue: AssignmentIssue,
-  instruction: z7.string().nullable().describe("What the mention said, a matched role prefix stripped; null for a delegation"),
-  promptContext: z7.string().nullable(),
-  guidance: z7.array(AssignmentGuidance),
-  previousComments: z7.array(z7.record(z7.string(), z7.unknown())).nullable(),
-  history: z7.array(HistoryEntry),
-  prompt: z7.array(PromptEntry).nullable(),
-  origin: z7.string(),
-  creator: z7.looseObject({ name: z7.string().nullable(), email: z7.string().nullable() }).nullable().optional().describe("Who started the session; null when an automation did"),
-  humanDelegated: z7.boolean(),
-  leaseExpiresAt: z7.number().int(),
+  instruction: z8.string().nullable().describe("What the mention said, a matched role prefix stripped; null for a delegation"),
+  promptContext: z8.string().nullable(),
+  guidance: z8.array(AssignmentGuidance),
+  previousComments: z8.array(z8.record(z8.string(), z8.unknown())).nullable(),
+  history: z8.array(HistoryEntry),
+  prompt: z8.array(PromptEntry).nullable(),
+  origin: z8.string(),
+  creator: z8.looseObject({ name: z8.string().nullable(), email: z8.string().nullable() }).nullable().optional().describe("Who started the session; null when an automation did"),
+  humanDelegated: z8.boolean(),
+  leaseExpiresAt: z8.number().int(),
   dispatch: AssignmentDispatch.nullable().optional().describe("Set when a manager session dispatched this worker turn"),
-  review: AssignmentReview.nullable().optional().describe("Set on a manager's review turn: the worker result to review")
+  review: AssignmentReview.nullable().optional().describe("Set on a manager's review turn: the worker result to review"),
+  telemetry: ClaimTelemetry.nullable().optional().describe("The turn's trace and what to collect for the project's exporters; null when nothing is exported")
 });
-var ClaimResponse = z7.looseObject({
+var ClaimResponse = z8.looseObject({
   assignment: WorkAssignment.nullable()
 });
 // src/config/resolve.ts
@@ -1625,7 +2053,7 @@ function objectKeys(schema) {
 
 // src/config/schema.ts
 import { cpus, hostname } from "os";
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/config/durations.ts
 var DURATION_UNITS = {
@@ -1772,83 +2200,83 @@ function machineContext(baseDir, env = process.env) {
   return { baseDir, env, cpuCount: cpus().length || 1, hostname: hostname() };
 }
 function buildConfigSchema(ctx) {
-  const path = () => z8.string().trim().min(1).transform((value) => expandPath(value, ctx.baseDir, ctx.env));
-  const duration = () => z8.string().regex(DURATION_PATTERN, "expected a duration such as 45s, 10m, 2h, or 7d").transform(parseDuration);
-  const size = () => z8.string().regex(SIZE_PATTERN, "expected a size such as 500MB or 2GB").transform(parseSize);
-  const parallel = () => z8.number().int().min(1).max(32);
-  const strings = () => z8.array(z8.string().trim().min(1));
-  const stringTable = () => z8.record(z8.string(), z8.string());
-  const permissionPolicy = (fallback) => z8.union([
-    z8.enum(POLICIES),
-    z8.strictObject({
-      default: z8.enum(POLICIES).optional(),
-      ...Object.fromEntries(TOOL_KINDS.map((kind) => [kind, z8.enum(POLICIES).optional()]))
+  const path = () => z9.string().trim().min(1).transform((value) => expandPath(value, ctx.baseDir, ctx.env));
+  const duration = () => z9.string().regex(DURATION_PATTERN, "expected a duration such as 45s, 10m, 2h, or 7d").transform(parseDuration);
+  const size = () => z9.string().regex(SIZE_PATTERN, "expected a size such as 500MB or 2GB").transform(parseSize);
+  const parallel = () => z9.number().int().min(1).max(32);
+  const strings = () => z9.array(z9.string().trim().min(1));
+  const stringTable = () => z9.record(z9.string(), z9.string());
+  const permissionPolicy = (fallback) => z9.union([
+    z9.enum(POLICIES),
+    z9.strictObject({
+      default: z9.enum(POLICIES).optional(),
+      ...Object.fromEntries(TOOL_KINDS.map((kind) => [kind, z9.enum(POLICIES).optional()]))
     })
   ]).default(typeof fallback === "string" ? fallback : { ...fallback }).describe('allow, ask, or deny every permission request \u2014 or a table by ACP tool kind, e.g. { default = "allow", execute = "ask" }. Defaults: worker "allow"; manager read-only, { default = "allow", edit = "deny", delete = "deny", move = "deny", execute = "deny" }');
-  const mcpServer = z8.strictObject({
-    name: z8.string().trim().min(1).describe("Unique within the role; `hypotenuse` is reserved"),
+  const mcpServer = z9.strictObject({
+    name: z9.string().trim().min(1).describe("Unique within the role; `hypotenuse` is reserved"),
     command: strings().min(1).optional().describe("A stdio MCP server's command"),
     env: stringTable().optional().describe("Added to the server's environment; $VAR allowed"),
-    url: z8.url().optional().describe("An HTTP MCP server's URL"),
+    url: z9.url().optional().describe("An HTTP MCP server's URL"),
     headers: stringTable().optional().describe("HTTP headers; $VAR allowed")
   });
-  const role = (fallbackPolicy) => z8.strictObject({
-    agent: z8.string().trim().min(1).describe("An [agents.<id>] id or a preset name"),
-    prompt: z8.string().min(1).optional().describe("The role's entry prompt template, inline"),
+  const role = (fallbackPolicy) => z9.strictObject({
+    agent: z9.string().trim().min(1).describe("An [agents.<id>] id or a preset name"),
+    prompt: z9.string().min(1).optional().describe("The role's entry prompt template, inline"),
     prompt_file: path().optional().describe("A Markdown prompt template file"),
     permission_policy: permissionPolicy(fallbackPolicy),
     max_parallel: parallel().optional().describe("Jobs of this role at once"),
-    mode: z8.string().trim().min(1).optional().describe("The ACP session mode to select"),
+    mode: z9.string().trim().min(1).optional().describe("The ACP session mode to select"),
     turn_timeout: duration().optional().describe("Overrides [sessions] turn_timeout"),
-    additional_directories: z8.array(path()).default([]).describe("Extra directories the agent may read and write"),
-    extra_mcp_servers: z8.array(mcpServer).default([]).describe("More MCP servers for the agent")
+    additional_directories: z9.array(path()).default([]).describe("Extra directories the agent may read and write"),
+    extra_mcp_servers: z9.array(mcpServer).default([]).describe("More MCP servers for the agent")
   });
-  const agent = z8.strictObject({
-    preset: z8.enum(PRESET_NAMES).optional().describe("A built-in agent launch command"),
+  const agent = z9.strictObject({
+    preset: z9.enum(PRESET_NAMES).optional().describe("A built-in agent launch command"),
     command: strings().min(1).optional().describe("The full launch command of an ACP agent on stdio"),
     args: strings().default([]).describe("Appended to the preset's or command's arguments"),
     env: stringTable().default({}).describe("Added to the agent's environment; $VAR allowed"),
-    auth_method: z8.string().trim().min(1).optional().describe("Which advertised ACP authMethod to use"),
+    auth_method: z9.string().trim().min(1).optional().describe("Which advertised ACP authMethod to use"),
     startup_timeout: duration().prefault("60s").describe("Time allowed to answer initialize"),
     max_parallel: parallel().optional().describe("Jobs using this agent at once")
   });
-  const cleanup = z8.enum(["on-complete", "on-merge", "ttl", "never"]);
-  const worktrees = z8.enum(["always", "never"]);
-  const repository = z8.strictObject({
-    name: z8.string().trim().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "letters, digits, `.`, `_`, `-`").max(64).optional().describe("Unique; used in worktree paths"),
+  const cleanup = z9.enum(["on-complete", "on-merge", "ttl", "never"]);
+  const worktrees = z9.enum(["always", "never"]);
+  const repository = z9.strictObject({
+    name: z9.string().trim().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "letters, digits, `.`, `_`, `-`").max(64).optional().describe("Unique; used in worktree paths"),
     path: path().describe("An existing git clone"),
-    remote: z8.string().trim().min(1).optional().describe("The repository's remote; must match origin"),
-    base_branch: z8.string().trim().min(1).optional().describe("The branch worktrees start from"),
+    remote: z9.string().trim().min(1).optional().describe("The repository's remote; must match origin"),
+    base_branch: z9.string().trim().min(1).optional().describe("The branch worktrees start from"),
     setup: strings().default([]).describe("Shell commands run in each new worktree"),
     setup_timeout: duration().prefault("10m").describe("Per setup command"),
-    branch_prefix: z8.string().trim().min(1).default("hypotenuse").describe("Branch name prefix"),
+    branch_prefix: z9.string().trim().min(1).default("hypotenuse").describe("Branch name prefix"),
     worktrees: worktrees.optional().describe("Overrides [sessions] worktrees"),
     cleanup: cleanup.optional().describe("Overrides [sessions] cleanup"),
     pr_url_patterns: strings().default([]).describe("Extra PR URL regexes for self-hosted forges")
   });
-  return z8.strictObject({
-    config_version: z8.number().int().describe(`The config format; must be ${CONFIG_VERSION}`),
-    server: z8.strictObject({
-      url: z8.url().optional().describe("The Hypotenuse server"),
-      project: z8.string().trim().min(1).optional().describe("The runner's project, by slug or id")
+  return z9.strictObject({
+    config_version: z9.number().int().describe(`The config format; must be ${CONFIG_VERSION}`),
+    server: z9.strictObject({
+      url: z9.url().optional().describe("The Hypotenuse server"),
+      project: z9.string().trim().min(1).optional().describe("The runner's project, by slug or id")
     }).prefault({}),
-    runner: z8.strictObject({
-      name: z8.string().trim().min(1).max(64).default(ctx.hostname.replace(/\.local$/i, "").slice(0, 64) || "runner").describe("Display name"),
-      max_parallel_jobs: z8.number().int().min(1).max(32).default(defaultMaxParallelJobs(ctx.cpuCount)).describe("Jobs running at once on this machine"),
-      roles: z8.array(z8.enum(RUNNER_ROLES)).min(1).default(["worker"]).describe("The roles this runner plays")
+    runner: z9.strictObject({
+      name: z9.string().trim().min(1).max(64).default(ctx.hostname.replace(/\.local$/i, "").slice(0, 64) || "runner").describe("Display name"),
+      max_parallel_jobs: z9.number().int().min(1).max(32).default(defaultMaxParallelJobs(ctx.cpuCount)).describe("Jobs running at once on this machine"),
+      roles: z9.array(z9.enum(RUNNER_ROLES)).min(1).default(["worker"]).describe("The roles this runner plays")
     }).prefault({}),
-    subscriptions: z8.strictObject({
+    subscriptions: z9.strictObject({
       teams: strings().default([]).describe("Linear team keys"),
       projects: strings().default([]).describe("Linear project ids or names"),
       labels: strings().default([]).describe("Label names; an issue needs one")
     }).prefault({}),
-    agents: z8.record(z8.string().regex(/^[a-z0-9][a-z0-9-]*$/, "lowercase letters, digits, and `-`"), agent).default({}),
-    roles: z8.strictObject({
+    agents: z9.record(z9.string().regex(/^[a-z0-9][a-z0-9-]*$/, "lowercase letters, digits, and `-`"), agent).default({}),
+    roles: z9.strictObject({
       manager: role(MANAGER_DEFAULT_POLICY).optional(),
       worker: role("allow").optional()
     }).prefault({}),
-    repositories: z8.array(repository).default([]),
-    sessions: z8.strictObject({
+    repositories: z9.array(repository).default([]),
+    sessions: z9.strictObject({
       worktrees: worktrees.default("always").describe("Whether sessions get a worktree"),
       worktree_root: path().prefault("~/.hypotenuse/worktrees").describe("Where worktrees live"),
       cleanup: cleanup.default("on-complete").describe("When a worktree may be removed"),
@@ -1859,10 +2287,16 @@ function buildConfigSchema(ctx) {
       keepalive_interval: duration().prefault("10m").describe("Silence before a keepalive thought"),
       stop_grace: duration().prefault("10s").describe("Wind-down time after a stop"),
       min_free_disk: size().prefault("2GB").describe("Free space needed for a new worktree"),
-      co_author: z8.string().default("Hypotenuse <noreply@hypotenuse.cloud>").describe("Co-Authored-By trailer on the agent's commits; empty for none")
+      co_author: z9.string().default("Hypotenuse <noreply@hypotenuse.cloud>").describe("Co-Authored-By trailer on the agent's commits; empty for none")
     }).prefault({}),
-    log: z8.strictObject({
-      level: z8.enum(["error", "warn", "info", "debug", "trace"]).default("info").describe("Log level"),
+    telemetry: z9.strictObject({
+      enabled: z9.boolean().default(true).describe("Send this machine's telemetry for the project's exporters; false sends none"),
+      max_content: z9.enum(CONTENT_LEVELS).default("full").describe("The most this runner sends: metadata, content, or full \u2014 lower than an exporter's level wins"),
+      agent_native: z9.boolean().default(true).describe("Capture the coding agent's own OpenTelemetry; false never starts the receiver or sets OTEL_* variables"),
+      buffer_mb: z9.number().int().min(1).max(1024).default(32).describe("The in-memory telemetry queue, in MB; when full the oldest logs, then spans, are dropped and counted")
+    }).prefault({}),
+    log: z9.strictObject({
+      level: z9.enum(["error", "warn", "info", "debug", "trace"]).default("info").describe("Log level"),
       file: path().optional().describe("The daemon log file")
     }).prefault({})
   });
@@ -1874,7 +2308,7 @@ var ConfigSchema = buildConfigSchema({
   hostname: "runner"
 });
 function configJsonSchema() {
-  const schema = z8.toJSONSchema(ConfigSchema, {
+  const schema = z9.toJSONSchema(ConfigSchema, {
     io: "input",
     unrepresentable: "any"
   });
@@ -2347,7 +2781,7 @@ function failedResult(call) {
 `).find((l) => l.trim()) ?? "";
   return first ? `Failed: ${truncate(first.trim(), 500)}` : "Failed";
 }
-var SECRET_PATTERNS = [
+var SECRET_PATTERNS2 = [
   /\bsk-[A-Za-z0-9_-]{16,}/g,
   /\bsk_(?:live|test)_[A-Za-z0-9]{16,}/g,
   /\bgh[pousr]_[A-Za-z0-9]{20,}/g,
@@ -2361,7 +2795,7 @@ var SECRET_PATTERNS = [
 ];
 function redact(text) {
   let out = text;
-  for (const pattern of SECRET_PATTERNS) {
+  for (const pattern of SECRET_PATTERNS2) {
     out = out.replace(pattern, (match, prefix) => typeof prefix === "string" && /^Bearer/i.test(match) ? `${prefix}[redacted]` : "[redacted]");
   }
   return out;
@@ -2556,7 +2990,7 @@ class ApiClient {
       response = await fetch(url, {
         method,
         headers,
-        body: options.body === undefined ? undefined : JSON.stringify(options.body),
+        body: options.body !== undefined ? JSON.stringify(options.body) : options.rawBody ? new Uint8Array(options.rawBody) : undefined,
         signal: options.timeoutMs ? AbortSignal.timeout(options.timeoutMs) : undefined
       });
     } catch (error) {
@@ -3061,32 +3495,32 @@ import {
   writeFileSync
 } from "fs";
 import { dirname as dirname4 } from "path";
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 function credentialsPathFor(env) {
   return credentialsPath(env);
 }
-var LoginSchema = z9.object({
-  token: z9.string(),
-  cliTokenId: z9.number(),
-  device: z9.string(),
-  email: z9.string().optional(),
-  expiresAt: z9.number().optional()
+var LoginSchema = z10.object({
+  token: z10.string(),
+  cliTokenId: z10.number(),
+  device: z10.string(),
+  email: z10.string().optional(),
+  expiresAt: z10.number().optional()
 });
-var RunnerCredentialSchema = z9.object({
-  runnerId: z9.number(),
-  projectId: z9.number(),
-  name: z9.string(),
-  token: z9.string()
+var RunnerCredentialSchema = z10.object({
+  runnerId: z10.number(),
+  projectId: z10.number(),
+  name: z10.string(),
+  token: z10.string()
 });
-var ServerEntrySchema = z9.object({
+var ServerEntrySchema = z10.object({
   login: LoginSchema.nullable().default(null),
-  project: z9.number().nullable().default(null),
+  project: z10.number().nullable().default(null),
   runner: RunnerCredentialSchema.nullable().default(null)
 });
-var CredentialsSchema = z9.object({
-  version: z9.literal(1),
-  current: z9.string().nullable().default(null),
-  servers: z9.record(z9.string(), ServerEntrySchema).default({})
+var CredentialsSchema = z10.object({
+  version: z10.literal(1),
+  current: z10.string().nullable().default(null),
+  servers: z10.record(z10.string(), ServerEntrySchema).default({})
 });
 function emptyCredentials() {
   return { version: 1, current: null, servers: {} };
@@ -3164,6 +3598,13 @@ async function resolveProjectId(client, selector) {
     }
   }
 }
+async function onlyProject(client) {
+  const { projects, pagination } = await client.request("GET", "/projects", { query: { page: 1, limit: 2 } });
+  return {
+    project: pagination.total === 1 ? projects[0] ?? null : null,
+    total: pagination.total
+  };
+}
 
 // src/api/url.ts
 import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
@@ -3318,10 +3759,14 @@ class CliContext {
   }
   async projectId() {
     const selector = this.options.project ?? this.env.HYPOTENUSE_PROJECT ?? (this.credentials.servers[this.server.origin]?.project != null ? String(this.credentials.servers[this.server.origin]?.project) : undefined);
-    if (!selector) {
-      throw new Error("No project selected. Pass --project <id|slug> or run `hypotenuse project use <id|slug>`.");
+    if (selector)
+      return resolveProjectId(this.signedInClient(), selector);
+    const { project, total } = await onlyProject(this.signedInClient());
+    if (project) {
+      logger.info(`Using project ${project.slug}, the only one you are in.`);
+      return project.id;
     }
-    return resolveProjectId(this.signedInClient(), selector);
+    throw new Error(total === 0 ? "You are not in any project yet. Create one in the dashboard, or accept an invite." : "No project selected, and you are in several. Pass --project <id|slug> or run `hypotenuse project use <id|slug>`.");
   }
 }
 function contextFor(command) {
@@ -3602,6 +4047,389 @@ import { join as join10 } from "path";
 import { mkdirSync as mkdirSync6, readFileSync as readFileSync7 } from "fs";
 import { join as join8 } from "path";
 
+// src/telemetry/acp.ts
+import { isAbsolute as isAbsolute4, relative as relative3 } from "path";
+class AcpTelemetry {
+  turn;
+  cwd;
+  tools = new Map;
+  spawn = null;
+  prompt = null;
+  chunk = null;
+  promptSpanId = newSpanId();
+  constructor(turn, cwd) {
+    this.turn = turn;
+    this.cwd = cwd;
+  }
+  get traceparent() {
+    return this.turn?.traceparentFor(this.promptSpanId) ?? null;
+  }
+  rel(path) {
+    if (!isAbsolute4(path))
+      return path;
+    const r = relative3(this.cwd, path);
+    return r.startsWith("..") ? path : r || ".";
+  }
+  begin(name, attrs = {}) {
+    return this.turn?.span(name, attrs, this.prompt) ?? null;
+  }
+  async around(name, attrs, fn) {
+    const span = this.begin(name, attrs);
+    try {
+      return await fn(span);
+    } catch (error) {
+      span?.fail(error instanceof Error ? error.message : String(error));
+      throw error;
+    } finally {
+      span?.end();
+    }
+  }
+  spawned(attrs, command) {
+    this.spawn = this.begin("agent.spawn", attrs);
+    this.spawn?.content("agent.command", command);
+  }
+  initialized(attrs) {
+    this.spawn?.set(attrs);
+  }
+  exited(exitCode) {
+    this.spawn?.end({ "process.exit.code": exitCode ?? null });
+  }
+  promptStarted(attrs, text) {
+    if (!this.turn)
+      return;
+    this.prompt = this.turn.span("acp.prompt", { "gen_ai.operation.name": "invoke_agent", ...attrs }, null, "client", this.promptSpanId);
+    this.prompt.content("prompt", text);
+    this.turn.promptSpan = this.prompt;
+  }
+  promptEnded(attrs, error) {
+    this.flushChunk();
+    for (const [, span] of this.tools)
+      span.end({ "hypotenuse.tool.finished": false });
+    this.tools.clear();
+    if (error)
+      this.prompt?.fail(error);
+    this.prompt?.end(attrs);
+    if (this.turn)
+      this.turn.promptSpan = null;
+    const input = attrs["gen_ai.usage.input_tokens"];
+    const output = attrs["gen_ai.usage.output_tokens"];
+    if (typeof input === "number" || typeof output === "number")
+      this.turn?.usage({
+        inputTokens: typeof input === "number" ? input : undefined,
+        outputTokens: typeof output === "number" ? output : undefined
+      });
+  }
+  flushChunk() {
+    const chunk = this.chunk;
+    this.chunk = null;
+    if (!chunk || !this.prompt || !this.turn)
+      return;
+    this.prompt.event(`agent.${chunk.kind}`, this.turn.contentAttrs("text", chunk.text));
+  }
+  update(update) {
+    if (!this.turn || !this.prompt)
+      return;
+    const u = update;
+    const kind = String(u.sessionUpdate);
+    if (kind === "agent_thought_chunk" || kind === "agent_message_chunk") {
+      const content = u.content;
+      if (content?.type !== "text")
+        return;
+      const which = kind === "agent_thought_chunk" ? "thought" : "message";
+      if (this.chunk && this.chunk.kind !== which)
+        this.flushChunk();
+      this.chunk ??= { kind: which, text: "" };
+      this.chunk.text += content.text ?? "";
+      return;
+    }
+    this.flushChunk();
+    switch (kind) {
+      case "tool_call": {
+        const id = String(u.toolCallId);
+        const span = this.turn.span("tool_call", {
+          "gen_ai.operation.name": "execute_tool",
+          "gen_ai.tool.call.id": id,
+          "gen_ai.tool.type": typeof u.kind === "string" ? u.kind : null,
+          "hypotenuse.tool.status": typeof u.status === "string" ? u.status : "pending"
+        }, this.prompt);
+        span.content("tool.title", typeof u.title === "string" ? u.title : null);
+        this.toolDetail(span, u);
+        this.tools.set(id, span);
+        if (u.status === "completed" || u.status === "failed")
+          this.endTool(id, u);
+        return;
+      }
+      case "tool_call_update": {
+        const id = String(u.toolCallId);
+        const span = this.tools.get(id);
+        if (!span)
+          return;
+        if (typeof u.kind === "string")
+          span.set({ "gen_ai.tool.type": u.kind });
+        if (typeof u.title === "string")
+          span.content("tool.title", u.title);
+        this.toolDetail(span, u);
+        if (u.status === "completed" || u.status === "failed")
+          this.endTool(id, u);
+        return;
+      }
+      case "plan": {
+        const entries = u.entries ?? [];
+        this.prompt.event("plan", {
+          "hypotenuse.plan.entries": entries.length,
+          "hypotenuse.plan.completed": entries.filter((e) => e.status === "completed").length,
+          ...this.turn.contentAttrs("plan", JSON.stringify(entries))
+        });
+        return;
+      }
+      case "usage_update": {
+        const cost = u.cost;
+        this.prompt.event("usage", {
+          "hypotenuse.context.used": typeof u.used === "number" ? u.used : null,
+          "hypotenuse.context.size": typeof u.size === "number" ? u.size : null,
+          "hypotenuse.usage.cost": cost?.amount ?? null,
+          "hypotenuse.usage.currency": cost?.currency ?? null
+        });
+        return;
+      }
+      case "current_mode_update":
+        this.prompt.event("mode", {
+          "hypotenuse.mode": typeof u.currentModeId === "string" ? u.currentModeId : null
+        });
+        return;
+      default:
+        this.prompt.event("session_update", { "hypotenuse.update.kind": kind });
+    }
+  }
+  toolDetail(span, u) {
+    const locations = Array.isArray(u.locations) ? u.locations : null;
+    if (locations?.length)
+      span.set({
+        "hypotenuse.tool.locations": locations.map((l) => l.path ? this.rel(l.path) : "").filter(Boolean).join(",")
+      });
+    if (u.rawInput !== undefined)
+      span.content("tool.input", JSON.stringify(u.rawInput));
+    if (u.rawOutput !== undefined)
+      span.content("tool.output", JSON.stringify(u.rawOutput));
+    else if (Array.isArray(u.content) && u.content.length)
+      span.content("tool.output", JSON.stringify(u.content));
+  }
+  endTool(id, u) {
+    const span = this.tools.get(id);
+    this.tools.delete(id);
+    if (!span)
+      return;
+    if (u.status === "failed")
+      span.fail("the tool call failed");
+    span.end({ "hypotenuse.tool.status": String(u.status) });
+  }
+  permission(toolCall, policy, options) {
+    const parent = this.tools.get(toolCall.toolCallId) ?? this.prompt;
+    const span = this.turn?.span("permission.wait", {
+      "gen_ai.tool.call.id": toolCall.toolCallId,
+      "gen_ai.tool.type": toolCall.kind ?? null,
+      "hypotenuse.permission.policy": policy,
+      "hypotenuse.permission.options": options.map((o) => o.kind ?? o.optionId).join(",")
+    }, parent) ?? null;
+    span?.content("tool.title", toolCall.title ?? null);
+    return (answer) => span?.end({
+      "hypotenuse.permission.outcome": answer.outcome,
+      "hypotenuse.permission.option": answer.optionId ?? null,
+      "hypotenuse.permission.decided_by": answer.decidedBy
+    });
+  }
+  fs(op, path) {
+    const span = this.begin(`fs.${op}`, { "file.path": this.rel(path) });
+    return (result) => {
+      if (result.refused)
+        span?.fail(result.refused);
+      span?.end({
+        "hypotenuse.fs.bytes": result.bytes ?? null,
+        "hypotenuse.fs.refused": result.refused ?? null
+      });
+    };
+  }
+  frame(line, message) {
+    this.turn?.frame(line, message, this.prompt);
+  }
+  stderr(line) {
+    this.turn?.log({
+      body: line,
+      level: "content",
+      eventName: "agent.stderr",
+      severity: "warn",
+      span: this.spawn
+    });
+  }
+}
+
+// src/telemetry/native.ts
+var NATIVE_TELEMETRY_PRESETS = {
+  claude: "native",
+  codex: "native",
+  gemini: "native",
+  qwen: "native",
+  goose: "standard-otel",
+  opencode: "standard-otel"
+};
+function nativeTelemetrySupport(preset) {
+  return preset && NATIVE_TELEMETRY_PRESETS[preset] || "unknown";
+}
+function dropInheritedOtel(env) {
+  for (const key of Object.keys(env))
+    if (key.startsWith("OTEL_"))
+      delete env[key];
+}
+function nativeTelemetryLaunch(preset, target) {
+  const full = target.level === "full";
+  const env = {
+    HYPOTENUSE_OTLP_ENDPOINT: target.endpoint,
+    OTEL_EXPORTER_OTLP_ENDPOINT: target.endpoint,
+    OTEL_EXPORTER_OTLP_PROTOCOL: "http/json",
+    OTEL_TRACES_EXPORTER: "otlp",
+    OTEL_METRICS_EXPORTER: "otlp",
+    OTEL_LOGS_EXPORTER: "otlp",
+    OTEL_METRIC_EXPORT_INTERVAL: "5000",
+    OTEL_LOGS_EXPORT_INTERVAL: "2000",
+    OTEL_BSP_SCHEDULE_DELAY: "1000"
+  };
+  const args = [];
+  switch (preset) {
+    case "claude":
+      env.CLAUDE_CODE_ENABLE_TELEMETRY = "1";
+      env.CLAUDE_CODE_ENHANCED_TELEMETRY_BETA = "1";
+      if (full) {
+        env.OTEL_LOG_USER_PROMPTS = "1";
+        env.OTEL_LOG_TOOL_DETAILS = "1";
+      }
+      break;
+    case "gemini":
+    case "qwen": {
+      const prefix = preset === "gemini" ? "GEMINI" : "QWEN";
+      env[`${prefix}_TELEMETRY_ENABLED`] = "true";
+      env[`${prefix}_TELEMETRY_TARGET`] = "local";
+      env[`${prefix}_TELEMETRY_OTLP_ENDPOINT`] = target.endpoint;
+      env[`${prefix}_TELEMETRY_OTLP_PROTOCOL`] = "http";
+      env[`${prefix}_TELEMETRY_LOG_PROMPTS`] = full ? "true" : "false";
+      break;
+    }
+    case "codex":
+      args.push("-c", `otel.exporter={otlp-http={endpoint="${target.endpoint}",protocol="json"}}`, "-c", `otel.log_user_prompt=${full ? "true" : "false"}`);
+      break;
+  }
+  return { env, args };
+}
+
+// src/telemetry/receiver.ts
+var MAX_BODY_BYTES = 8 * 1024 * 1024;
+var DRAIN_MS = 1500;
+
+class NativeReceiver {
+  turn;
+  nonce = Buffer.from(crypto.getRandomValues(new Uint8Array(18))).toString("base64url");
+  server = null;
+  received = {
+    traces: 0,
+    metrics: 0,
+    logs: 0
+  };
+  lastReceivedAt = 0;
+  constructor(turn) {
+    this.turn = turn;
+  }
+  start() {
+    this.server = Bun.serve({
+      hostname: "127.0.0.1",
+      port: 0,
+      maxRequestBodySize: MAX_BODY_BYTES,
+      fetch: (req) => this.handle(req)
+    });
+    return this.endpoint;
+  }
+  get endpoint() {
+    return `http://127.0.0.1:${this.server?.port ?? 0}/${this.nonce}`;
+  }
+  async handle(req) {
+    const url = new URL(req.url);
+    const prefix = `/${this.nonce}/`;
+    const signal = signalOfPath(url.pathname);
+    if (req.method !== "POST" || !url.pathname.startsWith(prefix) || !signal)
+      return new Response(null, { status: 404 });
+    const contentType = req.headers.get("content-type");
+    try {
+      let bytes = new Uint8Array(await req.arrayBuffer());
+      if ((req.headers.get("content-encoding") ?? "").includes("gzip"))
+        bytes = new Uint8Array(Bun.gunzipSync(bytes));
+      if (bytes.byteLength > MAX_BODY_BYTES)
+        throw new Error("too large");
+      this.accept(signal, decodeOtlpBody(signal, bytes, contentType));
+    } catch {
+      return new Response(null, { status: 400 });
+    }
+    const json = (contentType ?? "").includes("json");
+    return new Response(json ? "{}" : new Uint8Array(0), {
+      status: 200,
+      headers: {
+        "Content-Type": json ? "application/json" : "application/x-protobuf"
+      }
+    });
+  }
+  accept(signal, request) {
+    this.received[signal]++;
+    this.lastReceivedAt = Date.now();
+    const turn = this.turn;
+    const level = {
+      key: LEVEL_ATTRIBUTE,
+      value: { stringValue: turn.level }
+    };
+    const tag = (attrs) => [
+      ...(attrs ?? []).filter((a) => a.key !== LEVEL_ATTRIBUTE),
+      level
+    ];
+    if (signal === "traces") {
+      if (!turn.sampled)
+        return;
+      for (const rs of request.resourceSpans ?? [])
+        for (const ss of rs.scopeSpans ?? []) {
+          ss.spans = (ss.spans ?? []).map((s) => {
+            const root = !s.parentSpanId || /^0+$/.test(s.parentSpanId);
+            return {
+              ...s,
+              traceId: turn.traceId,
+              ...root ? { parentSpanId: turn.turnSpan.spanId } : {},
+              attributes: tag(s.attributes)
+            };
+          });
+        }
+    } else if (signal === "logs") {
+      if (!turn.sampled)
+        return;
+      for (const rl of request.resourceLogs ?? [])
+        for (const sl of rl.scopeLogs ?? [])
+          sl.logRecords = (sl.logRecords ?? []).map((l) => ({
+            ...l,
+            traceId: turn.traceId,
+            ...l.traceId && l.traceId !== turn.traceId ? { spanId: turn.turnSpan.spanId } : {},
+            attributes: tag(l.attributes)
+          }));
+    }
+    stampResource(signal, request, [
+      ...turn.resourceAttributes.filter((a) => a.key !== "hypotenuse.source" && !a.key.startsWith("service.")),
+      ...attributes({ "hypotenuse.source": "agent_native" })
+    ]);
+    turn.enqueue(signal, request);
+  }
+  async close(drainMs = DRAIN_MS) {
+    if (!this.server)
+      return;
+    const quietFor = Date.now() - this.lastReceivedAt;
+    if (quietFor < drainMs)
+      await Bun.sleep(drainMs - quietFor);
+    this.server.stop(true);
+    this.server = null;
+  }
+}
+
 // src/worktree/co-author.ts
 import { chmodSync as chmodSync2, mkdirSync as mkdirSync3, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "fs";
 import { join as join5 } from "path";
@@ -4620,7 +5448,7 @@ import {
   rmSync as rmSync3,
   writeFileSync as writeFileSync4
 } from "fs";
-import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute4, join as join7, resolve as resolve2, sep } from "path";
+import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute5, join as join7, resolve as resolve2, sep } from "path";
 
 class OutsideWorktree extends Error {
   path;
@@ -4679,7 +5507,7 @@ class ConfinedFs {
     const root = this.roots[0];
     if (!root)
       throw new OutsideWorktree(path);
-    return isAbsolute4(path) ? resolve2(path) : resolve2(root, path);
+    return isAbsolute5(path) ? resolve2(path) : resolve2(root, path);
   }
   read(path, line, limit) {
     const real = this.resolveExisting(path);
@@ -4973,7 +5801,7 @@ function callText(call) {
 }
 
 // src/acp/mcp-servers.ts
-import { isAbsolute as isAbsolute5 } from "path";
+import { isAbsolute as isAbsolute6 } from "path";
 var HYPOTENUSE_SERVER_NAME = "hypotenuse";
 var VARIABLE = /\$(?:\{([A-Za-z_][A-Za-z0-9_]*)\}|([A-Za-z_][A-Za-z0-9_]*))/g;
 
@@ -5023,7 +5851,7 @@ function turnMcpServers(role, caps, env, hypotenuse) {
       const [command, ...args] = s.command;
       servers.push({
         name: s.name,
-        command: isAbsolute5(command) ? command : Bun.which(command, { PATH: env.PATH ?? "" }) ?? command,
+        command: isAbsolute6(command) ? command : Bun.which(command, { PATH: env.PATH ?? "" }) ?? command,
         args,
         env: pairs(s.name, s.env, env)
       });
@@ -5473,6 +6301,8 @@ class Turn {
   where;
   readOnly;
   agentNote;
+  otel;
+  receiver = null;
   constructor(ctx, options) {
     this.ctx = ctx;
     this.options = options;
@@ -5498,6 +6328,7 @@ class Turn {
       }
     };
     this.mapper = new TurnMapper(this.mapperOptions);
+    this.otel = new AcpTelemetry(ctx.telemetry ?? null, this.cwd);
     this.questions = new QuestionQueue({
       post: (event) => this.emit(event),
       waiting: (waiting) => {
@@ -5609,6 +6440,7 @@ class Turn {
       throw error;
     } finally {
       clearInterval(timer);
+      this.otel.promptEnded({ "hypotenuse.end_reason": this.endReason }, this.endReason && this.endReason !== "stop" ? this.endReason : null);
       await this.shutdown();
       await this.workspace?.release().catch((error) => ctx.log.warn(`releasing the workspace failed: ${errorMessage(error)}`, {
         session: ctx.assignment.agentSessionId
@@ -5619,10 +6451,28 @@ class Turn {
     const { ctx } = this;
     const { assignment } = ctx;
     if (ctx.prepareWorkspace) {
+      const prepare = ctx.prepareWorkspace;
       try {
-        this.workspace = await ctx.prepareWorkspace({
-          output: (line) => this.log.note(line),
-          env: (branch) => sessionEnvironment(ctx.env, sessionVariables(assignment, branch))
+        this.workspace = await this.otel.around("worktree.prepare", {
+          "hypotenuse.repository": assignment.repository?.remote ?? null,
+          "hypotenuse.work_item.fresh": assignment.fresh
+        }, async (span) => {
+          const workspace = await prepare({
+            output: (line) => {
+              this.log.note(line);
+              this.otel.turn?.log({
+                body: line,
+                eventName: "worktree.output",
+                span
+              });
+            },
+            env: (branch) => sessionEnvironment(ctx.env, sessionVariables(assignment, branch))
+          });
+          span?.set({
+            "hypotenuse.worktree.mode": workspace.mode,
+            "vcs.ref.head.name": workspace.branch
+          });
+          return workspace;
         });
       } catch (error) {
         const remote = ctx.assignment.repository?.remote ?? null;
@@ -5656,6 +6506,7 @@ class Turn {
     if (this.endReason)
       throw new TurnFailure("stopped");
     this.mapperOptions.cwd = this.cwd;
+    this.otel.cwd = this.cwd;
     const remote = this.workspace?.repository?.remote ?? null;
     if (remote) {
       this.mapperOptions.pullRequests = new PrDetector(remote, this.workspace?.repositoryConfig?.pr_url_patterns ?? [], ctx.pullRequests ?? []);
@@ -5684,13 +6535,17 @@ class Turn {
     if (coAuthor && this.workspace?.repository) {
       Object.assign(launch.env, coAuthorEnvironment(launch.env, installCoAuthorHooks(ctx.stateDir), coAuthor));
     }
+    this.withTelemetry(launch);
     this.log.note(`spawn ${launch.command.join(" ")} in ${this.cwd}`);
     try {
       this.conn = AcpConnection.spawn({
         command: launch.command,
         cwd: this.cwd,
         env: launch.env,
-        stderr: (line) => this.log.stderr(line),
+        stderr: (line) => {
+          this.log.stderr(line);
+          this.otel.stderr(line);
+        },
         noise: (line) => this.noise(line),
         trace: (line, message) => {
           if (line.startsWith("<-")) {
@@ -5698,37 +6553,45 @@ class Turn {
             this.noiseInARow = 0;
           }
           this.log.rpc(line, message);
+          this.otel.frame(line, message);
         },
         handlers: {
           update: (n) => {
             if (this.acpSessionId && n.sessionId !== this.acpSessionId)
               return;
+            this.otel.update(n.update);
             this.emitAll(this.mapper.update(n.update));
           },
           requestPermission: (params) => this.permission(params),
           readTextFile: async (params) => {
+            const done = this.otel.fs("read", params.path);
             try {
-              return {
-                content: this.fs.read(params.path, params.line, params.limit)
-              };
+              const content = this.fs.read(params.path, params.line, params.limit);
+              done({ bytes: Buffer.byteLength(content) });
+              return { content };
             } catch (error) {
+              done({ refused: errorMessage(error) });
               throw this.fsError(error);
             }
           },
           writeTextFile: async (params) => {
+            const done = this.otel.fs("write", params.path);
             if (this.readOnly) {
               this.log.note(`refused a write (read-only): ${params.path}`);
+              done({ refused: "read-only" });
               throw new AcpError(RESOURCE_REFUSED, READ_ONLY_MESSAGE, {
                 path: params.path
               });
             }
             try {
               this.fs.write(params.path, params.content);
+              done({ bytes: Buffer.byteLength(params.content) });
             } catch (error) {
+              done({ refused: errorMessage(error) });
               throw this.fsError(error);
             }
           },
-          createElicitation: (params) => this.questions.ask(elicitationQuestion(params, this.agentTitle, providerSlug(this.agentId))),
+          createElicitation: (params) => this.otel.around("elicitation.wait", {}, () => this.questions.ask(elicitationQuestion(params, this.agentTitle, providerSlug(this.agentId)))),
           unknown: (method) => this.log.note(`unhandled ${method}`)
         }
       });
@@ -5739,7 +6602,20 @@ class Turn {
     const conn = this.conn;
     ctx.setPid(conn.pid);
     ctx.setState("starting");
-    const init = await this.guard(conn.initialize(package_default.version), launch.startupTimeoutMs, `${this.agentId} did not answer initialize within ${launch.startupTimeoutMs / 1000}s (\`${launch.command.join(" ")}\`).`, true);
+    this.otel.spawned({
+      "process.pid": conn.pid,
+      "hypotenuse.agent.id": this.agentId,
+      "hypotenuse.agent.preset": launch.preset ?? "custom",
+      "hypotenuse.telemetry.native": this.receiver !== null
+    }, launch.command.join(" "));
+    const init = await this.otel.around("acp.initialize", { "rpc.method": "initialize" }, () => this.guard(conn.initialize(package_default.version), launch.startupTimeoutMs, `${this.agentId} did not answer initialize within ${launch.startupTimeoutMs / 1000}s (\`${launch.command.join(" ")}\`).`, true));
+    this.otel.initialized({
+      "gen_ai.agent.name": init.agentInfo?.name ?? this.agentId,
+      "hypotenuse.agent.version": init.agentInfo?.version ?? null,
+      "hypotenuse.acp.protocol_version": init.protocolVersion,
+      "hypotenuse.acp.load_session": Boolean(init.agentCapabilities?.loadSession),
+      "hypotenuse.acp.auth_methods": (init.authMethods ?? []).length
+    });
     this.agentTitle = init.agentInfo?.title ?? init.agentInfo?.name ?? this.agentId;
     this.agentVersion = init.agentInfo?.version ?? null;
     ctx.log.debug(`${this.agentId} initialized: ${init.agentInfo?.name ?? "?"} ${init.agentInfo?.version ?? ""}`, { session: assignment.agentSessionId });
@@ -5795,7 +6671,7 @@ class Turn {
         if (!method)
           throw new AuthRequired(this.loginNeed(), "not logged in");
         this.log.note(`authenticate ${method}`);
-        await this.guard(this.conn.authenticate(method), 0, "");
+        await this.otel.around("acp.authenticate", { "hypotenuse.acp.auth_method": method }, () => this.guard(this.conn.authenticate(method), 0, ""));
         authenticated = true;
       }
     }
@@ -5823,12 +6699,12 @@ class Turn {
     if (previousAcpSessionId && !assignment.fresh && assignment.kind === "prompt") {
       try {
         if (caps.sessionCapabilities?.resume) {
-          const answer = await this.guard(conn.resumeSession({
+          const answer = await this.otel.around("acp.session.resume", {}, () => this.guard(conn.resumeSession({
             sessionId: previousAcpSessionId,
             cwd: this.cwd,
             mcpServers,
             ...directories
-          }), 0, "");
+          }), 0, ""));
           this.acpSessionId = previousAcpSessionId;
           this.resumed = true;
           await this.applyMode(answer);
@@ -5838,12 +6714,12 @@ class Turn {
           this.acpSessionId = previousAcpSessionId;
           this.mapper.replaying = true;
           try {
-            const answer = await this.guard(conn.loadSession({
+            const answer = await this.otel.around("acp.session.load", {}, () => this.guard(conn.loadSession({
               sessionId: previousAcpSessionId,
               cwd: this.cwd,
               mcpServers,
               ...directories
-            }), 0, "");
+            }), 0, ""));
             this.resumed = true;
             await this.applyMode(answer);
             return;
@@ -5859,7 +6735,7 @@ class Turn {
         this.ctx.log.info(`could not resume the agent's session; starting a new one with the history in the prompt: ${errorMessage(error)}`, { session: assignment.agentSessionId });
       }
     }
-    const created = await this.guard(conn.newSession({ cwd: this.cwd, mcpServers, ...directories }), 0, "");
+    const created = await this.otel.around("acp.session.new", { "hypotenuse.mcp.servers": mcpServers.length }, () => this.guard(conn.newSession({ cwd: this.cwd, mcpServers, ...directories }), 0, ""));
     this.acpSessionId = created.sessionId;
     await this.applyMode(created);
   }
@@ -5931,6 +6807,17 @@ class Turn {
     }, (name) => ctx.log.warn(`the prompt template uses an unknown variable {{${name}}}; it rendered empty`));
     this.promptStartedAt = this.now();
     this.lastTraffic = this.now();
+    const promptText = blocks.map((b) => b.text ?? "").join(`
+
+`);
+    this.otel.promptStarted({
+      "hypotenuse.prompt.blocks": blocks.length,
+      "hypotenuse.prompt.bytes": Buffer.byteLength(promptText),
+      "hypotenuse.prompt.history": ctx.assignment.history.length,
+      "hypotenuse.prompt.guidance": ctx.assignment.guidance.length,
+      "hypotenuse.prompt.context_bytes": Buffer.byteLength(ctx.assignment.promptContext ?? ""),
+      "hypotenuse.acp.resumed": this.resumed
+    }, promptText);
     const request = conn.prompt(sessionId, blocks);
     this.promptSettled = request.then(() => {}, () => {});
     const answer = await this.guard(request, 0, "").catch((error) => {
@@ -5938,6 +6825,12 @@ class Turn {
         throw error;
       throw new TurnFailure(`${this.agentId} failed the turn: ${errorMessage(error)}${quoteTail(this.log.tail())}`);
     });
+    const usage = answer.usage;
+    this.otel.promptEnded({
+      "gen_ai.response.finish_reasons": answer.stopReason,
+      "gen_ai.usage.input_tokens": usage?.inputTokens,
+      "gen_ai.usage.output_tokens": usage?.outputTokens
+    }, answer.stopReason === "end_turn" || answer.stopReason === "cancelled" ? null : `stopReason: ${answer.stopReason}`);
     if (this.endReason)
       return await this.stopped();
     this.emit({ type: "status", state: "finishing" });
@@ -6022,6 +6915,33 @@ class Turn {
     await within(conn.exited, 2000, null);
   }
   async shutdown() {
+    await this.closeAgent();
+    if (this.conn)
+      this.otel.exited(await within(this.conn.exited, 500, null));
+    await this.receiver?.close();
+    this.receiver = null;
+  }
+  withTelemetry(launch) {
+    const turn = this.ctx.telemetry;
+    if (!turn)
+      return;
+    const traceparent = this.otel.traceparent;
+    if (traceparent)
+      launch.env.TRACEPARENT = traceparent;
+    if (!turn.agentNative)
+      return;
+    this.receiver = new NativeReceiver(turn);
+    const endpoint = this.receiver.start();
+    turn.addSecret(this.receiver.nonce);
+    dropInheritedOtel(launch.env);
+    const native = nativeTelemetryLaunch(launch.preset, {
+      endpoint,
+      level: turn.level
+    });
+    Object.assign(launch.env, native.env);
+    launch.command = [...launch.command, ...native.args];
+  }
+  async closeAgent() {
     const conn = this.conn;
     if (!conn)
       return;
@@ -6074,13 +6994,26 @@ class Turn {
   async permission(params) {
     const policy = this.role?.permission_policy ?? "allow";
     const decision = decide(policy, params.toolCall.kind);
+    const waited = this.otel.permission(params.toolCall, typeof policy === "string" ? policy : JSON.stringify(policy), params.options);
     if (decision !== "ask") {
       const optionId = automaticOption(params.options, decision);
       this.log.note(`permission ${params.toolCall.toolCallId}: ${decision} \u2192 ${optionId ?? "cancelled"}`);
+      waited({
+        outcome: optionId ? "selected" : "cancelled",
+        optionId: optionId ?? undefined,
+        decidedBy: "policy"
+      });
       return optionId ? { outcome: { outcome: "selected", optionId } } : { outcome: { outcome: "cancelled" } };
     }
     this.emitAll(this.mapper.flushThought(true));
-    return this.questions.ask(permissionQuestion(params, this.where, this.cwd));
+    const answer = await this.questions.ask(permissionQuestion(params, this.where, this.cwd));
+    const outcome = answer.outcome;
+    waited({
+      outcome: outcome?.outcome ?? "cancelled",
+      optionId: outcome?.optionId,
+      decidedBy: "person"
+    });
+    return answer;
   }
   fsError(error) {
     if (error instanceof OutsideWorktree) {
@@ -6282,6 +7215,9 @@ class DaemonApi {
       "User-Agent": `hypotenuse/${package_default.version} (${platform()})`
     };
   }
+  traced(traceparent) {
+    return traceparent ? { ...this.headers, [TRACEPARENT_HEADER]: traceparent } : this.headers;
+  }
   async heartbeat(body) {
     const answer = await this.client.request("POST", "/daemon/heartbeat", {
       body,
@@ -6309,26 +7245,41 @@ class DaemonApi {
     });
     return ClaimResponse.parse(answer).assignment;
   }
-  async events(body) {
+  async events(body, traceparent) {
     const answer = await this.client.request("POST", "/daemon/events", {
       body,
-      headers: this.headers,
+      headers: this.traced(traceparent),
       timeoutMs: REQUEST_TIMEOUT_MS
     });
     return EventsResponse.parse(answer);
   }
-  async complete(body) {
+  async complete(body, traceparent) {
     const answer = await this.client.request("POST", "/daemon/complete", {
       body,
-      headers: this.headers,
+      headers: this.traced(traceparent),
       timeoutMs: REQUEST_TIMEOUT_MS
     });
     return CompleteResponse.parse(answer);
   }
-  async tool(route, body) {
+  async telemetry(batch) {
+    const answer = await this.client.request("POST", "/daemon/telemetry", {
+      rawBody: batch.gzipped,
+      headers: {
+        ...this.headers,
+        "Content-Type": "application/json",
+        "Content-Encoding": "gzip",
+        [TELEMETRY_SIGNAL_HEADER]: batch.signal,
+        [TELEMETRY_WORK_ITEM_HEADER]: String(batch.workItemId),
+        [TRACEPARENT_HEADER]: batch.traceparent
+      },
+      timeoutMs: REQUEST_TIMEOUT_MS
+    });
+    return TelemetryResponse.parse(answer);
+  }
+  async tool(route, body, traceparent) {
     const answer = await this.client.request("POST", route, {
       body,
-      headers: this.headers,
+      headers: this.traced(traceparent),
       timeoutMs: TOOL_REQUEST_TIMEOUT_MS
     });
     return ToolResult.parse(answer).result;
@@ -6953,11 +7904,575 @@ class StateDb {
 
 // src/daemon/supervisor.ts
 import { hostname as hostname3 } from "os";
-import { isAbsolute as isAbsolute6 } from "path";
+import { isAbsolute as isAbsolute7 } from "path";
+
+// src/telemetry/collector.ts
+var SCOPE = { name: "hypotenuse.daemon", version: package_default.version };
+var TOKEN_BOUNDS = [
+  100,
+  1000,
+  1e4,
+  50000,
+  1e5,
+  250000,
+  500000,
+  1e6
+];
+
+class SpanHandle {
+  turn;
+  name;
+  parentSpanId;
+  kind;
+  spanId;
+  startMs;
+  attrs = {};
+  events = [];
+  ended = false;
+  error = null;
+  constructor(turn, name, parentSpanId, kind = "internal", attrs = {}, spanId = newSpanId()) {
+    this.turn = turn;
+    this.name = name;
+    this.parentSpanId = parentSpanId;
+    this.kind = kind;
+    this.spanId = spanId;
+    this.startMs = turn.now();
+    Object.assign(this.attrs, attrs);
+  }
+  set(attrs) {
+    Object.assign(this.attrs, attrs);
+    return this;
+  }
+  content(key, text) {
+    Object.assign(this.attrs, this.turn.contentAttrs(key, text));
+    return this;
+  }
+  event(name, attrs = {}) {
+    if (!this.ended)
+      this.events?.push({
+        name,
+        timeUnixNano: unixNano(this.turn.now()),
+        attributes: attributes(attrs)
+      });
+    return this;
+  }
+  fail(message) {
+    this.error = message.slice(0, 1024);
+    return this;
+  }
+  get traceparent() {
+    return this.turn.traceparentFor(this.spanId);
+  }
+  get isEnded() {
+    return this.ended;
+  }
+  end(attrs = {}) {
+    if (this.ended)
+      return;
+    this.ended = true;
+    Object.assign(this.attrs, attrs);
+    this.turn.record({
+      traceId: this.turn.traceId,
+      spanId: this.spanId,
+      parentSpanId: this.parentSpanId,
+      name: this.name,
+      kind: SPAN_KIND[this.kind],
+      startTimeUnixNano: unixNano(this.startMs),
+      endTimeUnixNano: unixNano(this.turn.now()),
+      attributes: attributes(this.attrs),
+      events: this.events,
+      status: this.error ? { code: STATUS_CODE.error, message: this.error } : { code: STATUS_CODE.unset }
+    });
+  }
+}
+
+class TurnTelemetry {
+  options;
+  traceId;
+  rootSpanId;
+  level;
+  sampled;
+  agentNative;
+  now;
+  turnSpan;
+  resource;
+  finished = false;
+  extraSecrets = [];
+  promptSpan = null;
+  constructor(options) {
+    this.options = options;
+    const ctx = parseTraceparent(options.claim.traceparent);
+    this.traceId = ctx?.traceId ?? "0".repeat(32);
+    this.rootSpanId = ctx?.spanId ?? "0".repeat(16);
+    this.level = options.claim.content;
+    this.sampled = options.claim.sampled && ctx !== null;
+    this.agentNative = options.claim.agentNative;
+    this.now = options.now ?? Date.now;
+    const a = options.assignment;
+    this.resource = attributes({
+      "service.name": "hypotenuse-daemon",
+      "service.namespace": "hypotenuse",
+      "service.version": package_default.version,
+      "hypotenuse.source": "daemon",
+      ...this.turnAttributes(),
+      "hypotenuse.repository": a.repository?.remote ?? null
+    });
+    this.turnSpan = new SpanHandle(this, "daemon.turn", this.rootSpanId, "internal", {
+      ...this.turnAttributes(),
+      "hypotenuse.work_item.kind": a.kind,
+      "hypotenuse.work_item.fresh": a.fresh,
+      "hypotenuse.telemetry.content": this.level,
+      "hypotenuse.telemetry.agent_native": this.agentNative
+    });
+  }
+  turnAttributes() {
+    const a = this.options.assignment;
+    return {
+      "hypotenuse.session.id": a.agentSessionId,
+      "hypotenuse.work_item.id": a.workItemId,
+      "hypotenuse.role": a.role,
+      "hypotenuse.runner.name": this.options.runner.name,
+      "hypotenuse.agent.id": this.options.agentId,
+      "hypotenuse.agent.preset": this.options.preset ?? "custom",
+      "hypotenuse.repository": a.repository?.remote ?? null,
+      "linear.issue.identifier": a.issue.identifier,
+      "linear.agent_session.id": a.externalSessionId,
+      "linear.team.key": a.issue.teamKey
+    };
+  }
+  addSecret(value) {
+    this.extraSecrets.push(value);
+  }
+  get resourceAttributes() {
+    return this.resource;
+  }
+  collects(level) {
+    return levelRank(this.level) >= levelRank(level);
+  }
+  traceparentFor(spanId = this.turnSpan.spanId) {
+    return formatTraceparent({
+      traceId: this.traceId,
+      spanId,
+      sampled: this.sampled
+    });
+  }
+  span(name, attrs = {}, parent = null, kind = "internal", spanId) {
+    return new SpanHandle(this, name, (parent ?? this.turnSpan).spanId, kind, attrs, spanId);
+  }
+  contentAttrs(key, text) {
+    if (text === null || text === undefined)
+      return {};
+    const out = {
+      [`hypotenuse.${key}.bytes`]: Buffer.byteLength(text)
+    };
+    if (!this.collects("content"))
+      return out;
+    const { text: kept, originalBytes } = capContent(text);
+    out[`${CONTENT_ATTRIBUTE_PREFIX}${key}`] = kept;
+    if (originalBytes !== null)
+      out[`${CONTENT_ATTRIBUTE_PREFIX}${key}${TRUNCATED_SUFFIX}`] = originalBytes;
+    return out;
+  }
+  record(span) {
+    if (!this.sampled || this.finished)
+      return;
+    this.enqueue("traces", {
+      resourceSpans: [
+        {
+          resource: { attributes: this.resource },
+          scopeSpans: [{ scope: SCOPE, spans: [span] }]
+        }
+      ]
+    });
+  }
+  log(record) {
+    const level = record.level ?? "content";
+    if (!this.sampled || this.finished || !this.collects(level))
+      return;
+    const { text, originalBytes } = capContent(record.body);
+    this.enqueue("logs", {
+      resourceLogs: [
+        {
+          resource: { attributes: this.resource },
+          scopeLogs: [
+            {
+              scope: SCOPE,
+              logRecords: [
+                {
+                  timeUnixNano: unixNano(this.now()),
+                  observedTimeUnixNano: unixNano(this.now()),
+                  severityNumber: SEVERITY[record.severity ?? "info"],
+                  severityText: (record.severity ?? "info").toUpperCase(),
+                  body: { stringValue: text },
+                  ...record.eventName ? { eventName: record.eventName } : {},
+                  attributes: attributes({
+                    ...record.attrs ?? {},
+                    [LEVEL_ATTRIBUTE]: level,
+                    ...originalBytes !== null ? {
+                      [`hypotenuse.body${TRUNCATED_SUFFIX}`]: originalBytes
+                    } : {}
+                  }),
+                  traceId: this.traceId,
+                  spanId: (record.span ?? this.turnSpan).spanId
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    });
+  }
+  frame(direction, message, span) {
+    if (!this.collects("full"))
+      return;
+    const m = message;
+    this.log({
+      body: typeof message === "string" ? message : JSON.stringify(message),
+      level: "full",
+      eventName: "acp.frame",
+      attrs: {
+        "hypotenuse.acp.direction": direction.startsWith("<-") ? "in" : "out",
+        "rpc.method": typeof m?.method === "string" ? m.method : null,
+        "rpc.jsonrpc.request_id": typeof m?.id === "string" || typeof m?.id === "number" ? String(m.id) : null
+      },
+      span
+    });
+  }
+  usage(usage) {
+    if (this.finished)
+      return;
+    const points = [
+      ["input", usage.inputTokens],
+      ["output", usage.outputTokens]
+    ].flatMap(([type, n]) => typeof n === "number" ? [
+      {
+        attributes: attributes({
+          "gen_ai.token.type": type,
+          "gen_ai.agent.name": this.options.agentId
+        }),
+        timeUnixNano: unixNano(this.now()),
+        count: "1",
+        sum: n,
+        bucketCounts: [
+          ...TOKEN_BOUNDS.map((b, i) => n <= b && (i === 0 || n > TOKEN_BOUNDS[i - 1]) ? "1" : "0"),
+          n > TOKEN_BOUNDS.at(-1) ? "1" : "0"
+        ],
+        explicitBounds: TOKEN_BOUNDS,
+        min: n,
+        max: n
+      }
+    ] : []);
+    if (points.length === 0)
+      return;
+    this.metric({
+      name: "gen_ai.client.token.usage",
+      unit: "{token}",
+      histogram: {
+        aggregationTemporality: TEMPORALITY.delta,
+        dataPoints: points
+      }
+    });
+  }
+  slots(slots) {
+    const at = unixNano(this.now());
+    this.metric({
+      name: "hypotenuse.runner.slots",
+      unit: "{slot}",
+      gauge: {
+        dataPoints: [
+          {
+            attributes: attributes({ "hypotenuse.slot.state": "capacity" }),
+            timeUnixNano: at,
+            asInt: String(slots.capacity)
+          },
+          {
+            attributes: attributes({ "hypotenuse.slot.state": "in_use" }),
+            timeUnixNano: at,
+            asInt: String(slots.inUse)
+          }
+        ]
+      }
+    });
+  }
+  metric(metric) {
+    this.enqueue("metrics", {
+      resourceMetrics: [
+        {
+          resource: { attributes: this.resource },
+          scopeMetrics: [{ scope: SCOPE, metrics: [metric] }]
+        }
+      ]
+    });
+  }
+  enqueue(signal, body) {
+    const refused = this.options.queue.isRefused(this.options.assignment.workItemId);
+    this.options.queue.add({
+      workItemId: this.options.assignment.workItemId,
+      traceparent: this.traceparentFor(),
+      signal,
+      body: refused ? body : redactOtlp(body, {
+        values: [...this.options.secrets(), ...this.extraSecrets]
+      })
+    }, this.resource);
+  }
+  finish(outcome, error) {
+    if (this.finished)
+      return;
+    if (error)
+      this.turnSpan.fail(error);
+    this.turnSpan.end({ "hypotenuse.outcome": outcome });
+    this.finished = true;
+  }
+}
+
+// src/telemetry/queue.ts
+var FLUSH_INTERVAL_MS = 2000;
+var FLUSH_BYTES = 1024 * 1024;
+
+class TelemetryQueue {
+  sender;
+  capacityBytes;
+  log;
+  now;
+  batches = [];
+  bytes = 0;
+  timer = null;
+  flushing = null;
+  backoffUntil = 0;
+  failures = 0;
+  refused = new Set;
+  losses = new Map;
+  droppedTotal = new Map;
+  constructor(sender, capacityBytes, log = () => {}, now = Date.now) {
+    this.sender = sender;
+    this.capacityBytes = capacityBytes;
+    this.log = log;
+    this.now = now;
+  }
+  start() {
+    if (this.timer)
+      return;
+    this.timer = setInterval(() => void this.flush(), FLUSH_INTERVAL_MS);
+    this.timer.unref?.();
+  }
+  stop() {
+    if (this.timer)
+      clearInterval(this.timer);
+    this.timer = null;
+  }
+  get pendingBytes() {
+    return this.bytes;
+  }
+  isRefused(workItemId) {
+    return this.refused.has(workItemId);
+  }
+  add(batch, resource = []) {
+    if (this.refused.has(batch.workItemId)) {
+      this.countLoss(batch, resource);
+      return;
+    }
+    const bytes = JSON.stringify(batch.body).length;
+    this.batches.push({ ...batch, bytes });
+    this.bytes += bytes;
+    if (!this.losses.has(batch.workItemId))
+      this.losses.set(batch.workItemId, {
+        spans: 0,
+        logs: 0,
+        resource,
+        traceparent: batch.traceparent
+      });
+    this.evict();
+    if (this.bytes >= FLUSH_BYTES)
+      this.flush();
+  }
+  countLoss(batch, resource = []) {
+    const loss = this.losses.get(batch.workItemId) ?? {
+      spans: 0,
+      logs: 0,
+      resource,
+      traceparent: batch.traceparent
+    };
+    const n = countRecords(batch.signal, batch.body);
+    if (batch.signal === "traces")
+      loss.spans += n;
+    else if (batch.signal === "logs")
+      loss.logs += n;
+    this.losses.set(batch.workItemId, loss);
+    this.droppedTotal.set(batch.workItemId, (this.droppedTotal.get(batch.workItemId) ?? 0) + n);
+  }
+  evict() {
+    for (const signal of ["logs", "traces"]) {
+      while (this.bytes > this.capacityBytes) {
+        const index = this.batches.findIndex((b) => b.signal === signal);
+        if (index === -1)
+          break;
+        const [gone] = this.batches.splice(index, 1);
+        if (!gone)
+          break;
+        this.bytes -= gone.bytes;
+        this.countLoss(gone);
+      }
+    }
+  }
+  reportLosses() {
+    for (const [workItemId, loss] of this.losses) {
+      if (this.refused.has(workItemId))
+        continue;
+      if (loss.spans === 0 && loss.logs === 0)
+        continue;
+      const at = unixNano(this.now());
+      const point = (kind, n) => ({
+        attributes: attributes({ "hypotenuse.telemetry.kind": kind }),
+        timeUnixNano: at,
+        asInt: String(n)
+      });
+      const metrics = {
+        resourceMetrics: [
+          {
+            resource: { attributes: loss.resource },
+            scopeMetrics: [
+              {
+                scope: { name: "hypotenuse.daemon" },
+                metrics: [
+                  {
+                    name: "hypotenuse.telemetry.dropped",
+                    unit: "{record}",
+                    sum: {
+                      aggregationTemporality: TEMPORALITY.delta,
+                      isMonotonic: true,
+                      dataPoints: [
+                        ...loss.spans ? [point("span", loss.spans)] : [],
+                        ...loss.logs ? [point("log", loss.logs)] : []
+                      ]
+                    }
+                  }
+                ]
+              }
+            ]
+          }
+        ]
+      };
+      loss.spans = 0;
+      loss.logs = 0;
+      const bytes = JSON.stringify(metrics).length;
+      this.batches.push({
+        workItemId,
+        traceparent: loss.traceparent,
+        signal: "metrics",
+        body: metrics,
+        bytes
+      });
+      this.bytes += bytes;
+    }
+  }
+  flush() {
+    this.flushing ??= this.flushOnce().finally(() => {
+      this.flushing = null;
+    });
+    return this.flushing;
+  }
+  async flushOnce() {
+    if (this.now() < this.backoffUntil)
+      return;
+    this.reportLosses();
+    if (this.batches.length === 0)
+      return;
+    const taken = this.batches;
+    this.batches = [];
+    this.bytes = 0;
+    const groups = new Map;
+    for (const b of taken) {
+      const key = `${b.workItemId}|${b.signal}`;
+      groups.set(key, [...groups.get(key) ?? [], b]);
+    }
+    const retry = [];
+    let failed = false;
+    for (const group of groups.values()) {
+      const first = group[0];
+      if (this.refused.has(first.workItemId)) {
+        for (const b of group)
+          this.countLoss(b);
+        continue;
+      }
+      if (failed) {
+        retry.push(...group);
+        continue;
+      }
+      const body = mergeRequests(first.signal, group.map((b) => b.body));
+      try {
+        await this.sender.telemetry({
+          workItemId: first.workItemId,
+          traceparent: first.traceparent,
+          signal: first.signal,
+          gzipped: Bun.gzipSync(new TextEncoder().encode(JSON.stringify(body)))
+        });
+        this.failures = 0;
+      } catch (error) {
+        if (error instanceof ApiError && (error.status === 409 || error.status === 410 || error.status === 400)) {
+          this.refused.add(first.workItemId);
+          for (const b of group)
+            this.countLoss(b);
+          this.log(`telemetry for work item ${first.workItemId} refused (${error.status}): ${error.message}`);
+          continue;
+        }
+        failed = true;
+        retry.push(...group);
+        this.failures++;
+        const wait = error instanceof ApiError && error.retryAfterMs ? error.retryAfterMs : Math.min(1000 * 2 ** (this.failures - 1), 60000);
+        this.backoffUntil = this.now() + wait;
+      }
+    }
+    this.batches = [...retry, ...this.batches];
+    this.bytes = this.batches.reduce((n, b) => n + b.bytes, 0);
+    this.evict();
+  }
+  async drain(timeoutMs) {
+    const deadline = this.now() + timeoutMs;
+    for (;; ) {
+      this.backoffUntil = Math.min(this.backoffUntil, this.now());
+      await this.flush();
+      if (this.batches.length === 0)
+        return true;
+      if (this.now() >= deadline)
+        return false;
+      await Bun.sleep(Math.min(500, Math.max(0, deadline - this.now())));
+    }
+  }
+}
+function countRecords(signal, body) {
+  if (signal === "traces")
+    return (body.resourceSpans ?? []).reduce((n, rs) => n + (rs.scopeSpans ?? []).reduce((m, s) => m + (s.spans?.length ?? 0), 0), 0);
+  if (signal === "logs")
+    return (body.resourceLogs ?? []).reduce((n, rl) => n + (rl.scopeLogs ?? []).reduce((m, s) => m + (s.logRecords?.length ?? 0), 0), 0);
+  return 0;
+}
+
+// src/telemetry/redact.ts
+function resolvedConfigSecrets(config, env) {
+  const out = [];
+  const take = (table) => {
+    for (const value of Object.values(table ?? {})) {
+      if (!value.includes("$"))
+        continue;
+      const resolved = expandVariables(value, env);
+      if (resolved)
+        out.push(resolved);
+    }
+  };
+  for (const agent of Object.values(config.agents))
+    take(agent.env);
+  for (const role of [config.roles.manager, config.roles.worker]) {
+    for (const server of role?.extra_mcp_servers ?? []) {
+      take(server.env);
+      take(server.headers);
+    }
+  }
+  return out;
+}
 
 // src/worktree/cleanup.ts
 import { existsSync as existsSync15, readdirSync, rmSync as rmSync7 } from "fs";
-import { join as join9, relative as relative3, resolve as resolve3 } from "path";
+import { join as join9, relative as relative4, resolve as resolve3 } from "path";
 
 // src/worktree/merge-state.ts
 var MERGE_STATE_TTL_MS = 10 * 60000;
@@ -7136,7 +8651,7 @@ class WorktreeCleaner {
         const branch = /^branch refs\/heads\/(.+)$/m.exec(block)?.[1];
         if (!path || !branch || known.has(path))
           continue;
-        const rel = relative3(root, path);
+        const rel = relative4(root, path);
         if (rel.startsWith("..") || rel === "")
           continue;
         const session = await this.git(["config", "--worktree", "--get", "hypotenuse.session"], { cwd: path });
@@ -7361,6 +8876,11 @@ function buildCapabilities(config, machine, repositories) {
       teams: config.subscriptions.teams,
       projects: config.subscriptions.projects,
       labels: config.subscriptions.labels
+    },
+    telemetry: {
+      enabled: config.telemetry.enabled,
+      maxContent: config.telemetry.max_content,
+      agentNative: config.telemetry.agent_native
     }
   };
 }
@@ -7434,6 +8954,7 @@ class EventSink {
   backoff = new Backoff;
   batchLimit = new Map;
   closed = false;
+  traceparents = new Map;
   constructor(state, api, log, hooks) {
     this.state = state;
     this.api = api;
@@ -7460,6 +8981,12 @@ class EventSink {
     this.kick();
     return { eventId, seq };
   }
+  trace(workItemId, traceparent) {
+    if (traceparent)
+      this.traceparents.set(workItemId, traceparent);
+    else
+      this.traceparents.delete(workItemId);
+  }
   complete(completion) {
     this.state.queueCompletion(completion.request.workItemId, completion);
     this.kick();
@@ -7574,7 +9101,7 @@ class EventSink {
         const answer = await this.api.events({
           workItemId,
           events: batch.map((row) => row.payload)
-        });
+        }, this.traceparents.get(workItemId));
         this.state.deleteEvents(ids);
         this.log.debug("events sent", {
           workItem: workItemId,
@@ -7632,7 +9159,8 @@ class EventSink {
       return;
     const { request } = row.payload;
     try {
-      const answer = await this.api.complete(request);
+      const answer = await this.api.complete(request, this.traceparents.get(workItemId));
+      this.traceparents.delete(workItemId);
       this.log.info(`reported work item ${request.outcome}`, {
         workItem: workItemId,
         alreadyTerminal: answer.alreadyTerminal
@@ -7702,7 +9230,7 @@ class ReadCache {
 }
 
 // src/mcp/tools.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var CACHED_TOOLS = new Set([
   "linear_get_issue",
   "linear_list_comments",
@@ -7710,7 +9238,7 @@ var CACHED_TOOLS = new Set([
   "linear_list_labels"
 ]);
 function describeTool(tool) {
-  const { $schema: _schema, ...schema } = z10.toJSONSchema(tool.input);
+  const { $schema: _schema, ...schema } = z11.toJSONSchema(tool.input);
   return {
     name: tool.name,
     description: tool.description,
@@ -7789,11 +9317,14 @@ class McpBroker {
     if (!checked.ok)
       return { text: checked.message, isError: true };
     const { tool, input } = checked;
+    const span = turn.trace?.(tool.name, input) ?? null;
     const cached = CACHED_TOOLS.has(tool.name);
     if (cached) {
       const hit = this.cache.get(turn.workItemId, tool.name, input);
-      if (hit)
+      if (hit) {
+        span?.end({ isError: false, cached: true, text: hit.text });
         return hit;
+      }
     }
     if (tool.kind === "write")
       this.cache.invalidate(turn.workItemId);
@@ -7808,15 +9339,17 @@ class McpBroker {
       const result = await this.transport.tool(tool.route, {
         ...input,
         agentSessionId: turn.agentSessionId
-      });
+      }, span?.traceparent);
       answer = { text: result.text, data: result.data };
     } catch (error) {
       if (asking)
         turn.askingUser(false);
       answer = { text: toolErrorText(error), isError: true };
       this.log(`${tool.name} failed: ${answer.text}`);
+      span?.end({ isError: true, cached: false, text: answer.text });
       return answer;
     }
+    span?.end({ isError: false, cached: false, text: answer.text });
     if (cached)
       this.cache.set(turn.workItemId, tool.name, input, answer);
     if (tool.name === "linear_report_pr" && answer.data?.linked)
@@ -8133,6 +9666,8 @@ class Supervisor {
   sweepTimer = null;
   diskWasLow = false;
   broker;
+  telemetryQueue;
+  secrets = [];
   constructor(options) {
     this.options = options;
     this.config = options.config;
@@ -8154,6 +9689,8 @@ class Supervisor {
       }
     });
     this.broker = new McpBroker(options.api, (line) => options.log.info(line));
+    this.telemetryQueue = new TelemetryQueue(options.api, this.config.telemetry.buffer_mb * 1024 * 1024, (line) => options.log.info(line));
+    this.secrets = this.baseSecrets();
     this.sink = new EventSink(options.state, options.api, options.log, {
       onCancelRequested: (id) => this.stop(id, "stop"),
       onNotYours: (id) => this.silence(id),
@@ -8183,10 +9720,42 @@ class Supervisor {
     }
     this.link.start();
     this.sink.kick(true);
+    this.telemetryQueue.start();
     this.sweepTimer = setInterval(() => void this.cleanup({}), this.options.sweepIntervalMs ?? SWEEP_INTERVAL_MS);
     this.sweepTimer.unref?.();
     return interrupted;
   }
+  baseSecrets() {
+    return [
+      ...this.options.secrets ?? [],
+      ...resolvedConfigSecrets(this.config, this.options.env)
+    ];
+  }
+  turnTelemetry(assignment, agentId, slot) {
+    const claim = assignment.telemetry;
+    if (!claim || !this.config.telemetry.enabled)
+      return null;
+    const preset = this.config.agents[agentId]?.preset ?? (isPreset(agentId) ? agentId : null);
+    const max = this.config.telemetry.max_content;
+    const telemetry = new TurnTelemetry({
+      claim: {
+        ...claim,
+        content: minLevel(claim.content, max),
+        agentNative: claim.agentNative && this.config.telemetry.agent_native
+      },
+      assignment,
+      runner: { name: this.config.runner.name },
+      agentId,
+      preset,
+      queue: this.telemetryQueue,
+      secrets: () => slot.nonce ? [...this.secrets, slot.nonce] : this.secrets
+    });
+    telemetry.slots({
+      capacity: this.config.runner.max_parallel_jobs,
+      inUse: this.slots.size
+    });
+    return telemetry;
+  }
   worktreeInUse(wt) {
     if (wt.state === "active")
       return true;
@@ -8392,6 +9961,9 @@ class Supervisor {
     };
     this.slots.set(assignment.workItemId, slot);
     const mcpCommand = this.options.mcpCommand === undefined ? selfCommand() : this.options.mcpCommand;
+    const telemetry = this.turnTelemetry(assignment, agentId, slot);
+    if (telemetry)
+      this.sink.trace(assignment.workItemId, telemetry.traceparentFor());
     if (mcpCommand) {
       slot.nonce = this.broker.register({
         agentSessionId: assignment.agentSessionId,
@@ -8405,7 +9977,25 @@ class Supervisor {
         reportedPullRequest: (url) => {
           this.options.state.addPullRequest(slot.agentSessionId, url);
           slot.onReportedPullRequest?.(url);
-        }
+        },
+        trace: telemetry ? (tool, input) => {
+          const span = telemetry.span("mcp.call", {
+            "gen_ai.operation.name": "execute_tool",
+            "gen_ai.tool.name": tool,
+            "hypotenuse.mcp.server": "hypotenuse"
+          }, telemetry.promptSpan, "client").content("mcp.arguments", JSON.stringify(input));
+          return {
+            traceparent: span.traceparent,
+            end: (result) => {
+              if (result.isError)
+                span.fail(result.text.slice(0, 500));
+              span.content("mcp.result", result.text).end({
+                "hypotenuse.mcp.cached": result.cached,
+                "hypotenuse.mcp.result.bytes": Buffer.byteLength(result.text)
+              });
+            }
+          };
+        } : undefined
       });
     }
     log.info(`claimed ${assignment.kind} for ${assignment.issue.identifier ?? "an issue"}`, {
@@ -8473,7 +10063,8 @@ class Supervisor {
       },
       onReportedPullRequest: (handler) => {
         slot.onReportedPullRequest = handler;
-      }
+      },
+      telemetry
     };
     slot.done = this.runTurn(slot, ctx);
   }
@@ -8527,8 +10118,18 @@ class Supervisor {
     });
     this.link.beatNow();
     const worktreeId = this.options.state.session(slot.agentSessionId)?.worktreeId;
-    if (worktreeId)
-      await this.cleanup({ only: [worktreeId] });
+    const telemetry = ctx.telemetry ?? null;
+    if (worktreeId) {
+      const span = telemetry?.span("worktree.cleanup", {
+        "hypotenuse.worktree.id": worktreeId
+      });
+      const report = await this.cleanup({ only: [worktreeId] });
+      span?.end({
+        "hypotenuse.worktree.removed": (report?.removed.length ?? 0) > 0,
+        "hypotenuse.worktree.kept": (report?.kept.length ?? 0) > 0
+      });
+    }
+    telemetry?.finish(slot.silent ? "taken_away" : result.outcome, result.error);
   }
   stop(workItemId, reason) {
     const slot = this.slots.get(workItemId);
@@ -8587,6 +10188,7 @@ class Supervisor {
       await this.waitIdle(this.config.sessions.stop_grace + 5000);
     }
     const flushed = await this.sink.drain(5000);
+    await this.telemetryQueue.drain(5000);
     this.link.beatNow();
     return { drained: this.slots.size === 0 && flushed, cancelled };
   }
@@ -8648,6 +10250,8 @@ class Supervisor {
     }
     this.config = merged;
     this.options.log.level = merged.log.level;
+    this.telemetryQueue.capacityBytes = merged.telemetry.buffer_mb * 1024 * 1024;
+    this.secrets = this.baseSecrets();
     this.repositories = daemonRepositories(merged, this.options.machine);
     this.capabilities = this.buildCapabilities();
     this.options.log.info("config reloaded", {
@@ -8742,6 +10346,7 @@ class Supervisor {
     this.sweepTimer = null;
     this.link.stop();
     this.sink.close();
+    this.telemetryQueue.stop();
   }
 }
 function changedKeys(a, b, prefix = "") {
@@ -8756,7 +10361,7 @@ function changedKeys(a, b, prefix = "") {
   return JSON.stringify(a) === JSON.stringify(b) ? [] : [prefix];
 }
 function resolveCommand(command, env) {
-  if (isAbsolute6(command))
+  if (isAbsolute7(command))
     return command;
   return Bun.which(command, { PATH: env.PATH ?? "" }) ?? command;
 }
@@ -8854,6 +10459,7 @@ async function runDaemon(options) {
   let state;
   let origin;
   let runner;
+  let credentials;
   try {
     const read = readDaemonConfig(options, env);
     if (!read.config)
@@ -8862,7 +10468,6 @@ async function runDaemon(options) {
     paths = daemonPaths(read.path, options.stateDir, config.log.file, env);
     log = new DaemonLog(paths.log, config.log.level, !options.detachedChild);
     const credentialsFile = credentialsPath(env);
-    let credentials;
     try {
       credentials = loadCredentials(credentialsFile);
     } catch (error) {
@@ -8938,7 +10543,11 @@ async function runDaemon(options) {
     stateDir: paths.stateDir,
     env,
     readConfig: () => readDaemonConfig(options, env),
-    requestExit
+    requestExit,
+    secrets: [
+      runner.token,
+      ...Object.values(credentials.servers).flatMap((s) => s.login ? [s.login.token] : [])
+    ]
   });
   control = new ControlServer(paths.socket, {
     status: () => supervisor.status({ pid: process.pid, configPath: paths.config }),
@@ -10337,6 +11946,20 @@ async function runDoctor(ctx, options) {
   if (options.agent && !resolveAgents(config).some((a) => a.id === options.agent)) {
     list.fail("agents", `no agent "${options.agent}" in the config`);
   }
+  const t = config.telemetry;
+  if (!t.enabled)
+    list.ok("telemetry", "off: this runner sends no telemetry (`[telemetry] enabled = false`)");
+  else {
+    list.ok("telemetry", `sends up to \`${t.max_content}\` for the project's exporters; buffer ${t.buffer_mb} MB`);
+    const agents = resolveAgents(config).filter((a) => a.roles.length > 0);
+    if (!t.agent_native)
+      list.ok("telemetry", "agents' own telemetry is not captured");
+    else
+      for (const agent of agents) {
+        const support = nativeTelemetrySupport(agent.preset);
+        list.ok("telemetry", support === "native" ? `${agent.id}: contributes its own telemetry (model requests, tokens, cost)` : support === "standard-otel" ? `${agent.id}: contributes its own telemetry if it reads the standard OTEL_* variables` : `${agent.id}: a custom command \u2014 it gets OTEL_EXPORTER_OTLP_ENDPOINT and HYPOTENUSE_OTLP_ENDPOINT`);
+      }
+  }
   for (const repo of daemonRepositories(config, machine)) {
     if (options.offline) {
       list.ok("repositories", `${repo.name}: ${repo.remote} (${repo.baseBranch})`);
@@ -12003,6 +13626,161 @@ function registerTagCommands(program) {
   }
 }
 
+// src/commands/telemetry.ts
+function collect2(value, previous = []) {
+  return [...previous, value];
+}
+function parsePairs(pairs, what) {
+  const out = {};
+  for (const pair of pairs) {
+    const at = pair.indexOf("=");
+    if (at <= 0)
+      throw new Error(`${what} must be KEY=VALUE, got "${pair}"`);
+    out[pair.slice(0, at).trim()] = pair.slice(at + 1);
+  }
+  return out;
+}
+function exporterHealth(e) {
+  if (!e.enabled)
+    return "paused";
+  if (e.lastErrorAt && (!e.lastExportAt || e.lastErrorAt > e.lastExportAt))
+    return `error ${when(e.lastErrorAt)}: ${e.lastError ?? ""}`;
+  return e.lastExportAt ? `ok ${when(e.lastExportAt)}` : "nothing yet";
+}
+function describeExporter(e) {
+  const attrs = Object.entries(e.resourceAttributes).map(([k, v]) => `${k}=${v}`).join(", ");
+  return [
+    `${e.name} (id ${e.id})${e.enabled ? "" : "  paused"}`,
+    `endpoint     ${e.endpoint}`,
+    `protocol     ${e.protocol}`,
+    `content      ${e.content}`,
+    `signals      ${e.signals.join(", ")}`,
+    `sampled      ${Math.round(e.traceSampleRatio * 100)}% of turns`,
+    `agent's own  ${e.agentNative ? "captured" : "not captured"}`,
+    `headers      ${e.headerNames.length ? e.headerNames.join(", ") : "none"} (values are never shown)`,
+    `attributes   ${attrs || "none"}`,
+    `last export  ${when(e.lastExportAt)}`,
+    `last error   ${e.lastError ? `${when(e.lastErrorAt)}: ${e.lastError}` : "-"}`
+  ].join(`
+`);
+}
+function exporterBody(opts) {
+  const body = {};
+  if (opts.name !== undefined)
+    body.name = opts.name;
+  if (opts.endpoint !== undefined)
+    body.endpoint = opts.endpoint;
+  if (opts.protocol !== undefined)
+    body.protocol = opts.protocol;
+  if (opts.clearHeaders)
+    body.headers = {};
+  else if (opts.header?.length)
+    body.headers = parsePairs(opts.header, "--header");
+  if (opts.signals !== undefined)
+    body.signals = opts.signals.split(",").map((s) => s.trim()).filter(Boolean);
+  if (opts.content !== undefined)
+    body.content = opts.content;
+  if (opts.agentNative !== undefined)
+    body.agentNative = opts.agentNative;
+  if (opts.sample !== undefined)
+    body.traceSampleRatio = Number(opts.sample);
+  if (opts.attribute?.length)
+    body.resourceAttributes = parsePairs(opts.attribute, "--attribute");
+  if (opts.enabled !== undefined)
+    body.enabled = opts.enabled;
+  return body;
+}
+function exporterOptions(command, adding) {
+  if (adding)
+    command.requiredOption("--name <name>", "what it is called, unique in the project").requiredOption("--endpoint <url>", "the collector's OTLP/HTTP base URL (https; /v1/<signal> is appended)");
+  else
+    command.option("--name <name>", "a new name").option("--endpoint <url>", "a new endpoint");
+  return command.option("--protocol <protocol>", "http/protobuf (default) or http/json").option("--header <KEY=VALUE>", "a header sent with every export, e.g. an API key; repeat for more (replaces all; never printed)", collect2).option("--content <level>", "metadata (default), content, or full \u2014 full sends prompts and source code").option("--signals <list>", "comma-separated: traces,metrics,logs").option("--sample <ratio>", "0\u20131: the share of turns whose traces are kept").option("--attribute <KEY=VALUE>", "an extra resource attribute; repeat for more (replaces all)", collect2).option("--agent-native", "capture the coding agent's own telemetry").option("--no-agent-native", "do not capture the agent's own telemetry");
+}
+function registerTelemetryCommands(program) {
+  const telemetry = program.command("telemetry").description("Where the selected project's OpenTelemetry goes");
+  const exporter = telemetry.command("exporter").description("The project's OpenTelemetry collectors");
+  withPaging(exporter.command("list").description("List exporters")).action(async function() {
+    await runCommand(this, async (ctx) => {
+      const projectId = await ctx.projectId();
+      const result = await ctx.signedInClient().request("GET", "/telemetry-exporters", {
+        query: { projectId, ...pageQuery(this) }
+      });
+      emit(ctx, result, () => table(result.telemetryExporters.map((e) => ({
+        id: e.id,
+        name: e.name,
+        endpoint: e.endpoint,
+        content: e.content,
+        signals: e.signals.join(","),
+        sampled: `${Math.round(e.traceSampleRatio * 100)}%`,
+        headers: e.headerNames.join(",") || "-",
+        health: exporterHealth(e)
+      })), [
+        { key: "id" },
+        { key: "name", maxWidth: 30 },
+        { key: "endpoint", maxWidth: 50 },
+        { key: "content" },
+        { key: "signals" },
+        { key: "sampled" },
+        { key: "headers", maxWidth: 30 },
+        { key: "health", maxWidth: 60 }
+      ]) + pageFooter(result.pagination));
+    });
+  });
+  exporter.command("view <id>").description("Show one exporter (header names only)").action(async function(id) {
+    await runCommand(this, async (ctx) => {
+      const projectId = await ctx.projectId();
+      const result = await ctx.signedInClient().request("GET", `/telemetry-exporter/${id}`, { query: { projectId } });
+      emit(ctx, result, () => describeExporter(result.telemetryExporter));
+    });
+  });
+  exporterOptions(exporter.command("add").description("Export the project's telemetry to a collector (admin)"), true).option("--disabled", "create it paused").action(async function() {
+    await runCommand(this, async (ctx) => {
+      const opts = this.opts();
+      const projectId = await ctx.projectId();
+      const result = await ctx.signedInClient().request("PUT", "/telemetry-exporter", {
+        body: {
+          projectId,
+          ...exporterBody(opts),
+          ...opts.disabled ? { enabled: false } : {}
+        }
+      });
+      emit(ctx, result, () => `Added exporter ${result.telemetryExporter.name} (id ${result.telemetryExporter.id}) at ${result.telemetryExporter.content}; \`hypotenuse telemetry exporter test ${result.telemetryExporter.id}\` sends a probe`);
+    });
+  });
+  exporterOptions(exporter.command("edit <id>").description("Change an exporter; headers are kept unless given (admin)"), false).option("--clear-headers", "send no headers from now on").option("--enable", "resume exporting").option("--disable", "pause exporting").action(async function(id) {
+    await runCommand(this, async (ctx) => {
+      const opts = this.opts();
+      const projectId = await ctx.projectId();
+      const body = exporterBody({
+        ...opts,
+        enabled: opts.enable ? true : opts.disable ? false : undefined
+      });
+      const result = await ctx.signedInClient().request("POST", `/telemetry-exporter/${id}`, { body: { projectId, ...body } });
+      emit(ctx, result, () => describeExporter(result.telemetryExporter));
+    });
+  });
+  exporter.command("remove <id>").description("Stop exporting to a collector and forget its headers (admin)").action(async function(id) {
+    await runCommand(this, async (ctx) => {
+      const projectId = await ctx.projectId();
+      const result = await ctx.signedInClient().request("DELETE", `/telemetry-exporter/${id}`, {
+        body: { projectId }
+      });
+      emit(ctx, result, () => `Removed exporter ${id}`);
+    });
+  });
+  exporter.command("test <id>").description("Send the collector a probe span, log, and metric, and show its answers (admin)").action(async function(id) {
+    await runCommand(this, async (ctx) => {
+      const projectId = await ctx.projectId();
+      const result = await ctx.signedInClient().request("POST", `/telemetry-exporter/${id}/test`, { body: { projectId } });
+      emit(ctx, result, () => result.results.map((r) => `${glyph(r.ok ? "complete" : "error")} ${r.signal.padEnd(8)} ${r.status || "-"}${r.error ? `  ${r.error}` : ""}`).join(`
+`));
+      if (!result.ok)
+        process.exitCode = 1;
+    });
+  });
+}
+
 // src/commands/upgrade.ts
 var UPGRADE_DRAIN_MS = 10 * 60000;
 async function restartRunningDaemon(socketPath, call = callDaemon) {
@@ -12272,6 +14050,7 @@ function buildProgram() {
   registerEventCommands(program);
   registerRunnerCommands(program);
   registerRoutingCommands(program);
+  registerTelemetryCommands(program);
   registerIdentityCommands(program);
   registerConfigCommands(program);
   registerDaemonCommands(program);