@yagni-app/code 1.0.5 → 1.0.7

package/dist/otel.d.ts

@@ -1,59 +1,55 @@
 /**
- * OTel export wiring (Updater pilot ask): bake the `pi-otel` extension into
- * every launch so a workspace can stream session traces — token usage, cost,
- * model tier, tool calls — to its own OTLP collector (e.g. Datadog) without
- * anyone hand-installing an extension.
+ * OTel export gate (Updater pilot ask, now Claude Code parity): decide
+ * whether a launch streams session telemetry — traces, metrics, and log
+ * events — to the workspace's own OTLP collector (Datadog, Grafana, an
+ * in-house collector), and hand the session the standard OpenTelemetry env
+ * it needs. The exporter itself lives in the bundled extension
+ * (`pi-extension-yagni/src/telemetry`), so there is nothing extra to load and
+ * nothing that can go missing on a customer's `npm install`.
  *
- * Three deliberate policies, all enforced here rather than left to defaults:
+ * Three deliberate policies, enforced here rather than left to defaults:
  *
- * 1. GATED, not always-on. pi-otel ships `enabled: true` pointed at
- *    `localhost:4317`, so loading it unconditionally would have every session
- *    probing a collector nobody runs. We only pass the extension to pi when an
- *    OTLP endpoint is actually configured: `OTEL_EXPORTER_OTLP_ENDPOINT` in the
- *    environment, or `otel.endpoint` in the repo's committed `.pi/settings.json`
- *    (the file pi-otel itself reads, so teams can configure once per repo).
+ * 1. GATED, not always-on. Nothing exports unless an OTLP destination is
+ *    configured: the user's own OTEL_* env, the workspace's admin-set config
+ *    (fetched fail-soft and cached), or the repo's committed
+ *    `.pi/settings.json`. The gate result travels to the session as
+ *    `YAGNI_OTEL_EXPORT=1` plus the OTLP variables; children (/go stages,
+ *    subagents) inherit the env and export too.
  *
- * 2. METADATA-ONLY, enforced. Cost, tokens, model, finish reasons and tool-call
- *    ids export; prompt and response text never do. `PI_OTEL_CAPTURE_CONTENT`
- *    is pinned in the child env, and env beats settings in pi-otel's own
- *    precedence — a repo settings file asking for "full" is overridden, not
- *    honored. Session content leaving the machine is a contract change, not a
- *    config knob.
+ * 2. METADATA-ONLY, in code. Token counts, cost, tier, durations, tool names,
+ *    and sizes export; prompt, response, and tool content never do. The
+ *    extension enforces this without a knob — no env var re-enables content.
  *
- * 3. Cost is the customer's SELL rate. pi-otel exports pi's `usage.cost.total`
- *    verbatim (as `pi.cost.usd`), and pi computes that from the catalog's
- *    tier rates (YAG-381) — so the collector sees contracted prices, and the
- *    exported model name is the opaque tier id, never the backing model.
+ * 3. Cost is the customer's SELL rate. Usage cost is pi's `usage.cost.total`,
+ *    computed from the catalog's tier rates (YAG-381), and the exported model
+ *    name is the opaque tier id, never the backing model.
  *
- * Everything here is fail-soft: telemetry must never block a launch, so a
- * missing package or unreadable settings file resolves to "disabled".
+ * Everything here is fail-soft: telemetry must never block a launch, so an
+ * unreadable settings file or an offline backend resolves to "disabled" or
+ * to last-known config.
  */
 import { readFileSync } from "node:fs";
-/**
- * Env var carrying the resolved pi-otel entry path to /go stage children and
- * subagents: they build their own pi argv inside pi-extension-yagni (which
- * cannot import this package), so the path crosses over env. The extension
- * reads the same literal in `pipeline/runner.ts`.
- */
-export declare const OTEL_EXTENSION_PATH_ENV = "YAGNI_OTEL_EXTENSION_PATH";
+/** The launcher's "this session exports" gate, read by the bundled extension. */
+export declare const OTEL_EXPORT_ENV = "YAGNI_OTEL_EXPORT";
 /** The service name a collector sees unless the user set their own. */
 export declare const DEFAULT_OTEL_SERVICE_NAME = "yagni-code";
+/** The standard per-signal endpoint variables, generic first (its precedence). */
+declare const ENDPOINT_ENV_VARS: readonly ["OTEL_EXPORTER_OTLP_ENDPOINT", "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT", "OTEL_EXPORTER_OTLP_METRICS_ENDPOINT", "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT"];
+export type EndpointEnvVar = (typeof ENDPOINT_ENV_VARS)[number];
 export interface OtelLaunchConfig {
-    /** Absolute path to pi-otel's extension entry. */
-    extensionPath: string;
     /**
-     * Where the enablement signal came from. "workspace" additionally carries
-     * protocol/headers/serviceName, delivered as env to the session (the other
-     * sources leave those to whatever the user/repo already configured).
+     * Where the enablement signal came from. "workspace" and "project-settings"
+     * carry endpoint/protocol/headers/serviceName that the launcher delivers as
+     * env; "env" is the user's own setup, passed through untouched.
      */
     source: "env" | "workspace" | "project-settings";
-    /** The configured OTLP endpoint (for doctor display; env for workspace source). */
+    /** The env var the endpoint came from (env source only; doctor names it). */
+    envVar?: EndpointEnvVar;
+    /** The configured endpoint: a BASE URL for workspace/project sources. */
     endpoint: string;
-    /** Workspace-configured OTLP protocol (workspace source only). */
     protocol?: string;
-    /** Workspace-configured collector headers (workspace source only; carries secrets). */
+    /** Collector headers (workspace / project sources; carries secrets). */
     headers?: Record<string, string>;
-    /** Workspace-configured service name (workspace source only). */
     serviceName?: string;
 }
 /**
@@ -69,34 +65,44 @@ export interface WorkspaceOtelConfig {
     headers?: Record<string, string>;
 }
 /**
- * Decide whether this launch exports OTel traces, and with which pi-otel entry.
- * Returns undefined when export stays off: no endpoint configured anywhere,
- * `PI_OTEL_DISABLED` set, or the pi-otel package unresolvable (never fatal).
+ * Reduce an endpoint that carries a signal path to its base
+ * (`https://otlp.datadoghq.com/v1/traces` → `https://otlp.datadoghq.com`).
+ * The extension appends `/v1/<signal>` per signal for http transports, so a
+ * workspace config saved before logs and metrics existed keeps exporting all
+ * three without an admin re-save. Mirrors the extension's own helper.
+ */
+export declare function stripSignalPath(endpoint: string): string;
+/** Personal kill switch: beats every source. Both spellings accepted. */
+export declare function envDisabled(env: NodeJS.ProcessEnv): boolean;
+/**
+ * Decide whether this launch exports, from the user's env and the repo's
+ * settings. Returns undefined when export stays off: no endpoint configured,
+ * or a kill switch set.
+ *
+ * Any of the standard endpoint variables enables export — the generic
+ * `OTEL_EXPORTER_OTLP_ENDPOINT` or a per-signal one — so a machine that
+ * carries a Claude Code telemetry env (typically all three per-signal
+ * endpoints) lights up with no translation. The extension reads the same
+ * variables, per signal, following the OTLP exporter spec.
  */
 export declare function resolveOtelLaunch(opts: {
     env: NodeJS.ProcessEnv;
     cwd: string;
-    /** Injectable seams for tests. */
-    resolveExtension?: () => string;
+    /** Injectable seam for tests. */
     readFile?: typeof readFileSync;
 }): OtelLaunchConfig | undefined;
 /**
- * Absolute path to pi-otel's extension entry (its package main IS the pi
- * extension entry, `dist/index.js`). Resolved ESM-native like `paths.ts` does
- * for pi itself. Throws when the package is missing — callers treat that as
- * "export off", not an error.
- */
-export declare function resolveOtelExtensionPath(): string;
-/**
- * The env keys an OTel-exporting child must carry. `PI_OTEL_CAPTURE_CONTENT`
- * is pinned unconditionally (policy 2 above); the service name only fills in
- * when the user has not chosen their own.
+ * The env keys an exporting child must carry. `YAGNI_OTEL_EXPORT=1` is the
+ * gate the extension reads; the service name only fills in when the user has
+ * not chosen their own.
  *
- * A "workspace"-sourced config additionally delivers the admin-set endpoint,
- * protocol, and collector headers over the standard OTel env vars — but any
- * of those the USER already set in their own environment wins (local env >
- * workspace config), so an engineer can point one session at a scratch
- * collector without an admin change.
+ * A "workspace" or "project-settings" config delivers its endpoint (as the
+ * generic BASE endpoint — the extension derives the per-signal URLs),
+ * protocol, headers, and service name over the standard OTel env vars — but
+ * any of those the USER already set in their own environment wins (local
+ * env > workspace config), so an engineer can point one session at a
+ * scratch collector without an admin change. An "env" config is the user's
+ * own setup and passes through untouched.
  */
 export declare function otelChildEnv(config: OtelLaunchConfig, baseEnv: NodeJS.ProcessEnv): Record<string, string>;
 export interface WorkspaceOtelFetchDeps {
@@ -125,10 +131,10 @@ export declare function fetchWorkspaceOtel(creds: {
     token: string;
 }, profileName: string, deps?: WorkspaceOtelFetchDeps): Promise<WorkspaceOtelConfig | null>;
 /**
- * Full launch-time resolution, all three sources in precedence order:
+ * Full launch-time resolution, all four sources in precedence order:
  *
- *   1. `PI_OTEL_DISABLED`      — personal kill switch, beats everything.
- *   2. env `OTEL_EXPORTER_OTLP_ENDPOINT` — the user's own setup, untouched.
+ *   1. `PI_OTEL_DISABLED` / `YAGNI_OTEL_DISABLED` — personal kill switch.
+ *   2. env `OTEL_EXPORTER_OTLP_*_ENDPOINT` — the user's own setup, untouched.
  *   3. workspace config        — admin-set in the web app, fetched/cached.
  *   4. repo `.pi/settings.json` — committed per-repo config.
  *
@@ -142,9 +148,9 @@ export declare function resolveOtelLaunchWithWorkspace(opts: {
         token: string;
     } | null;
     profileName?: string;
-    resolveExtension?: () => string;
     readFile?: typeof readFileSync;
     fetchDeps?: WorkspaceOtelFetchDeps;
     fetchWorkspace?: typeof fetchWorkspaceOtel;
 }): Promise<OtelLaunchConfig | undefined>;
+export {};
 //# sourceMappingURL=otel.d.ts.map

package/dist/otel.js

@@ -1,53 +1,72 @@
 /**
- * OTel export wiring (Updater pilot ask): bake the `pi-otel` extension into
- * every launch so a workspace can stream session traces — token usage, cost,
- * model tier, tool calls — to its own OTLP collector (e.g. Datadog) without
- * anyone hand-installing an extension.
+ * OTel export gate (Updater pilot ask, now Claude Code parity): decide
+ * whether a launch streams session telemetry — traces, metrics, and log
+ * events — to the workspace's own OTLP collector (Datadog, Grafana, an
+ * in-house collector), and hand the session the standard OpenTelemetry env
+ * it needs. The exporter itself lives in the bundled extension
+ * (`pi-extension-yagni/src/telemetry`), so there is nothing extra to load and
+ * nothing that can go missing on a customer's `npm install`.
  *
- * Three deliberate policies, all enforced here rather than left to defaults:
+ * Three deliberate policies, enforced here rather than left to defaults:
  *
- * 1. GATED, not always-on. pi-otel ships `enabled: true` pointed at
- *    `localhost:4317`, so loading it unconditionally would have every session
- *    probing a collector nobody runs. We only pass the extension to pi when an
- *    OTLP endpoint is actually configured: `OTEL_EXPORTER_OTLP_ENDPOINT` in the
- *    environment, or `otel.endpoint` in the repo's committed `.pi/settings.json`
- *    (the file pi-otel itself reads, so teams can configure once per repo).
+ * 1. GATED, not always-on. Nothing exports unless an OTLP destination is
+ *    configured: the user's own OTEL_* env, the workspace's admin-set config
+ *    (fetched fail-soft and cached), or the repo's committed
+ *    `.pi/settings.json`. The gate result travels to the session as
+ *    `YAGNI_OTEL_EXPORT=1` plus the OTLP variables; children (/go stages,
+ *    subagents) inherit the env and export too.
  *
- * 2. METADATA-ONLY, enforced. Cost, tokens, model, finish reasons and tool-call
- *    ids export; prompt and response text never do. `PI_OTEL_CAPTURE_CONTENT`
- *    is pinned in the child env, and env beats settings in pi-otel's own
- *    precedence — a repo settings file asking for "full" is overridden, not
- *    honored. Session content leaving the machine is a contract change, not a
- *    config knob.
+ * 2. METADATA-ONLY, in code. Token counts, cost, tier, durations, tool names,
+ *    and sizes export; prompt, response, and tool content never do. The
+ *    extension enforces this without a knob — no env var re-enables content.
  *
- * 3. Cost is the customer's SELL rate. pi-otel exports pi's `usage.cost.total`
- *    verbatim (as `pi.cost.usd`), and pi computes that from the catalog's
- *    tier rates (YAG-381) — so the collector sees contracted prices, and the
- *    exported model name is the opaque tier id, never the backing model.
+ * 3. Cost is the customer's SELL rate. Usage cost is pi's `usage.cost.total`,
+ *    computed from the catalog's tier rates (YAG-381), and the exported model
+ *    name is the opaque tier id, never the backing model.
  *
- * Everything here is fail-soft: telemetry must never block a launch, so a
- * missing package or unreadable settings file resolves to "disabled".
+ * Everything here is fail-soft: telemetry must never block a launch, so an
+ * unreadable settings file or an offline backend resolves to "disabled" or
+ * to last-known config.
  */
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { fileURLToPath } from "node:url";
 import { credentialsDir } from "./credentials.js";
-/**
- * Env var carrying the resolved pi-otel entry path to /go stage children and
- * subagents: they build their own pi argv inside pi-extension-yagni (which
- * cannot import this package), so the path crosses over env. The extension
- * reads the same literal in `pipeline/runner.ts`.
- */
-export const OTEL_EXTENSION_PATH_ENV = "YAGNI_OTEL_EXTENSION_PATH";
+/** The launcher's "this session exports" gate, read by the bundled extension. */
+export const OTEL_EXPORT_ENV = "YAGNI_OTEL_EXPORT";
 /** The service name a collector sees unless the user set their own. */
 export const DEFAULT_OTEL_SERVICE_NAME = "yagni-code";
 /**
- * Read `otel.endpoint` from the repo's `.pi/settings.json`, the project-level
- * file pi-otel itself resolves config from. Returns undefined on any problem —
- * a malformed settings file must not block a launch (pi-otel will surface its
- * own complaint in-session).
+ * Headers that belong on the TRACES request only. Datadog's LLM Observability
+ * routes OTLP traces to its LLM product when `dd-otlp-source=llmobs` rides
+ * along; the same header on the metrics and logs intakes is meaningless at
+ * best, so the launcher scopes it to `OTEL_EXPORTER_OTLP_TRACES_HEADERS`.
+ */
+const TRACE_ONLY_HEADERS = new Set(["dd-otlp-source"]);
+/** The standard per-signal endpoint variables, generic first (its precedence). */
+const ENDPOINT_ENV_VARS = [
+    "OTEL_EXPORTER_OTLP_ENDPOINT",
+    "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT",
+    "OTEL_EXPORTER_OTLP_METRICS_ENDPOINT",
+    "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT",
+];
+/** Trailing `/v1/<signal>` on a URL — the shape pre-parity configs stored. */
+const SIGNAL_PATH_RE = /\/v1\/(traces|metrics|logs)\/?$/i;
+/**
+ * Reduce an endpoint that carries a signal path to its base
+ * (`https://otlp.datadoghq.com/v1/traces` → `https://otlp.datadoghq.com`).
+ * The extension appends `/v1/<signal>` per signal for http transports, so a
+ * workspace config saved before logs and metrics existed keeps exporting all
+ * three without an admin re-save. Mirrors the extension's own helper.
  */
-function projectOtelEndpoint(cwd, readFile) {
+export function stripSignalPath(endpoint) {
+    return endpoint.replace(SIGNAL_PATH_RE, "").replace(/\/+$/, "");
+}
+/**
+ * Read the `otel` block from the repo's `.pi/settings.json`, the project-level
+ * file a team commits once so every clone exports. Returns undefined on any
+ * problem — a malformed settings file must not block a launch.
+ */
+function projectOtelSettings(cwd, readFile) {
     try {
         const raw = readFile(join(cwd, ".pi", "settings.json"), "utf8");
         const parsed = JSON.parse(String(raw));
@@ -56,92 +75,126 @@ function projectOtelEndpoint(cwd, readFile) {
         const otel = parsed.otel;
         if (typeof otel !== "object" || otel === null)
             return undefined;
-        const endpoint = otel.endpoint;
-        return typeof endpoint === "string" && endpoint.trim() !== "" ? endpoint.trim() : undefined;
+        const o = otel;
+        if (o.enabled === false)
+            return undefined;
+        const endpoint = typeof o.endpoint === "string" && o.endpoint.trim() !== "" ? o.endpoint.trim() : undefined;
+        if (!endpoint)
+            return undefined;
+        const headers = {};
+        if (typeof o.headers === "object" && o.headers !== null) {
+            for (const [k, v] of Object.entries(o.headers)) {
+                // Headers travel to the session as the comma-separated
+                // OTEL_EXPORTER_OTLP_HEADERS list; a comma in a value would corrupt
+                // every pair after it, so such a header is dropped (same rule the
+                // workspace settings enforce at save time).
+                if (typeof v === "string" && !v.includes(",") && !k.includes(","))
+                    headers[k] = v;
+            }
+        }
+        return {
+            endpoint,
+            ...(typeof o.protocol === "string" && o.protocol.trim() ? { protocol: o.protocol.trim() } : {}),
+            ...(Object.keys(headers).length > 0 ? { headers } : {}),
+            ...(typeof o.serviceName === "string" && o.serviceName.trim() ? { serviceName: o.serviceName.trim() } : {}),
+        };
     }
     catch {
         return undefined;
     }
 }
-/** Truthy per pi-otel's own convention for PI_OTEL_DISABLED. */
-function envDisabled(env) {
-    return env.PI_OTEL_DISABLED === "1" || env.PI_OTEL_DISABLED === "true";
+/** Personal kill switch: beats every source. Both spellings accepted. */
+export function envDisabled(env) {
+    const truthy = (v) => v === "1" || v === "true";
+    return truthy(env.PI_OTEL_DISABLED) || truthy(env.YAGNI_OTEL_DISABLED);
+}
+/** The first configured endpoint variable in the user's env, generic first. */
+function envEndpoint(env) {
+    for (const envVar of ENDPOINT_ENV_VARS) {
+        const value = env[envVar]?.trim();
+        if (value)
+            return { envVar, endpoint: value };
+    }
+    return undefined;
 }
 /**
- * Decide whether this launch exports OTel traces, and with which pi-otel entry.
- * Returns undefined when export stays off: no endpoint configured anywhere,
- * `PI_OTEL_DISABLED` set, or the pi-otel package unresolvable (never fatal).
+ * Decide whether this launch exports, from the user's env and the repo's
+ * settings. Returns undefined when export stays off: no endpoint configured,
+ * or a kill switch set.
+ *
+ * Any of the standard endpoint variables enables export — the generic
+ * `OTEL_EXPORTER_OTLP_ENDPOINT` or a per-signal one — so a machine that
+ * carries a Claude Code telemetry env (typically all three per-signal
+ * endpoints) lights up with no translation. The extension reads the same
+ * variables, per signal, following the OTLP exporter spec.
  */
 export function resolveOtelLaunch(opts) {
     const { env, cwd } = opts;
     if (envDisabled(env))
         return undefined;
-    const envEndpoint = env.OTEL_EXPORTER_OTLP_ENDPOINT?.trim();
-    const settingsEndpoint = envEndpoint
-        ? undefined
-        : projectOtelEndpoint(cwd, opts.readFile ?? readFileSync);
-    if (!envEndpoint && !settingsEndpoint)
+    const fromEnv = envEndpoint(env);
+    if (fromEnv)
+        return { source: "env", envVar: fromEnv.envVar, endpoint: fromEnv.endpoint };
+    const settings = projectOtelSettings(cwd, opts.readFile ?? readFileSync);
+    if (!settings)
         return undefined;
-    let extensionPath;
-    try {
-        extensionPath = (opts.resolveExtension ?? resolveOtelExtensionPath)();
-    }
-    catch {
-        return undefined;
-    }
-    return envEndpoint
-        ? { extensionPath, source: "env", endpoint: envEndpoint }
-        : { extensionPath, source: "project-settings", endpoint: settingsEndpoint };
+    return {
+        source: "project-settings",
+        endpoint: settings.endpoint,
+        ...(settings.protocol ? { protocol: settings.protocol } : {}),
+        ...(settings.headers ? { headers: settings.headers } : {}),
+        ...(settings.serviceName ? { serviceName: settings.serviceName } : {}),
+    };
 }
-/**
- * Absolute path to pi-otel's extension entry (its package main IS the pi
- * extension entry, `dist/index.js`). Resolved ESM-native like `paths.ts` does
- * for pi itself. Throws when the package is missing — callers treat that as
- * "export off", not an error.
- */
-export function resolveOtelExtensionPath() {
-    const path = fileURLToPath(import.meta.resolve("pi-otel"));
-    if (!existsSync(path)) {
-        throw new Error(`pi-otel entry not found at ${path}`);
-    }
-    return path;
+/** Render a header record as the comma-separated `k=v` list the OTel env carries. */
+function headerList(headers) {
+    return Object.entries(headers)
+        .map(([k, v]) => `${k}=${v}`)
+        .join(",");
 }
 /**
- * The env keys an OTel-exporting child must carry. `PI_OTEL_CAPTURE_CONTENT`
- * is pinned unconditionally (policy 2 above); the service name only fills in
- * when the user has not chosen their own.
+ * The env keys an exporting child must carry. `YAGNI_OTEL_EXPORT=1` is the
+ * gate the extension reads; the service name only fills in when the user has
+ * not chosen their own.
  *
- * A "workspace"-sourced config additionally delivers the admin-set endpoint,
- * protocol, and collector headers over the standard OTel env vars — but any
- * of those the USER already set in their own environment wins (local env >
- * workspace config), so an engineer can point one session at a scratch
- * collector without an admin change.
+ * A "workspace" or "project-settings" config delivers its endpoint (as the
+ * generic BASE endpoint — the extension derives the per-signal URLs),
+ * protocol, headers, and service name over the standard OTel env vars — but
+ * any of those the USER already set in their own environment wins (local
+ * env > workspace config), so an engineer can point one session at a
+ * scratch collector without an admin change. An "env" config is the user's
+ * own setup and passes through untouched.
  */
 export function otelChildEnv(config, baseEnv) {
-    const workspace = {};
-    if (config.source === "workspace") {
-        if (!baseEnv.OTEL_EXPORTER_OTLP_ENDPOINT) {
-            workspace.OTEL_EXPORTER_OTLP_ENDPOINT = config.endpoint;
+    const out = {};
+    if (config.source === "workspace" || config.source === "project-settings") {
+        const userHasEndpoint = ENDPOINT_ENV_VARS.some((v) => baseEnv[v]?.trim());
+        if (!userHasEndpoint) {
+            out.OTEL_EXPORTER_OTLP_ENDPOINT = stripSignalPath(config.endpoint);
         }
         if (config.protocol && !baseEnv.OTEL_EXPORTER_OTLP_PROTOCOL) {
-            workspace.OTEL_EXPORTER_OTLP_PROTOCOL = config.protocol;
+            out.OTEL_EXPORTER_OTLP_PROTOCOL = config.protocol;
         }
         if (config.headers && Object.keys(config.headers).length > 0 && !baseEnv.OTEL_EXPORTER_OTLP_HEADERS) {
-            workspace.OTEL_EXPORTER_OTLP_HEADERS = Object.entries(config.headers)
-                .map(([k, v]) => `${k}=${v}`)
-                .join(",");
+            const shared = {};
+            const traceOnly = {};
+            for (const [k, v] of Object.entries(config.headers)) {
+                (TRACE_ONLY_HEADERS.has(k.toLowerCase()) ? traceOnly : shared)[k] = v;
+            }
+            if (Object.keys(shared).length > 0)
+                out.OTEL_EXPORTER_OTLP_HEADERS = headerList(shared);
+            if (Object.keys(traceOnly).length > 0 && !baseEnv.OTEL_EXPORTER_OTLP_TRACES_HEADERS) {
+                out.OTEL_EXPORTER_OTLP_TRACES_HEADERS = headerList(traceOnly);
+            }
         }
         if (config.serviceName && !baseEnv.OTEL_SERVICE_NAME) {
-            workspace.OTEL_SERVICE_NAME = config.serviceName;
+            out.OTEL_SERVICE_NAME = config.serviceName;
         }
     }
     return {
-        ...workspace,
-        [OTEL_EXTENSION_PATH_ENV]: config.extensionPath,
-        PI_OTEL_CAPTURE_CONTENT: "metadata_only",
-        ...(baseEnv.OTEL_SERVICE_NAME || workspace.OTEL_SERVICE_NAME
-            ? {}
-            : { OTEL_SERVICE_NAME: DEFAULT_OTEL_SERVICE_NAME }),
+        ...out,
+        [OTEL_EXPORT_ENV]: "1",
+        ...(baseEnv.OTEL_SERVICE_NAME || out.OTEL_SERVICE_NAME ? {} : { OTEL_SERVICE_NAME: DEFAULT_OTEL_SERVICE_NAME }),
     };
 }
 // ── Workspace-configured export (admin sets it once in the web app) ─────────
@@ -235,10 +288,10 @@ function readWorkspaceOtelCache(cachePath) {
     }
 }
 /**
- * Full launch-time resolution, all three sources in precedence order:
+ * Full launch-time resolution, all four sources in precedence order:
  *
- *   1. `PI_OTEL_DISABLED`      — personal kill switch, beats everything.
- *   2. env `OTEL_EXPORTER_OTLP_ENDPOINT` — the user's own setup, untouched.
+ *   1. `PI_OTEL_DISABLED` / `YAGNI_OTEL_DISABLED` — personal kill switch.
+ *   2. env `OTEL_EXPORTER_OTLP_*_ENDPOINT` — the user's own setup, untouched.
  *   3. workspace config        — admin-set in the web app, fetched/cached.
  *   4. repo `.pi/settings.json` — committed per-repo config.
  *
@@ -249,27 +302,14 @@ export async function resolveOtelLaunchWithWorkspace(opts) {
     if (envDisabled(env))
         return undefined;
     // Source 2: the user's own env config short-circuits — no fetch needed.
-    if (env.OTEL_EXPORTER_OTLP_ENDPOINT?.trim()) {
-        return resolveOtelLaunch({
-            env,
-            cwd,
-            ...(opts.resolveExtension ? { resolveExtension: opts.resolveExtension } : {}),
-            ...(opts.readFile ? { readFile: opts.readFile } : {}),
-        });
+    if (envEndpoint(env)) {
+        return resolveOtelLaunch({ env, cwd, ...(opts.readFile ? { readFile: opts.readFile } : {}) });
     }
     // Source 3: workspace config.
     if (opts.creds?.token && opts.profileName) {
         const workspace = await (opts.fetchWorkspace ?? fetchWorkspaceOtel)({ baseUrl: opts.creds.baseUrl, token: opts.creds.token }, opts.profileName, opts.fetchDeps ?? {});
         if (workspace) {
-            let extensionPath;
-            try {
-                extensionPath = (opts.resolveExtension ?? resolveOtelExtensionPath)();
-            }
-            catch {
-                return undefined;
-            }
             return {
-                extensionPath,
                 source: "workspace",
                 endpoint: workspace.endpoint,
                 ...(workspace.protocol ? { protocol: workspace.protocol } : {}),
@@ -281,11 +321,6 @@ export async function resolveOtelLaunchWithWorkspace(opts) {
         }
     }
     // Source 4: repo-committed settings.
-    return resolveOtelLaunch({
-        env,
-        cwd,
-        ...(opts.resolveExtension ? { resolveExtension: opts.resolveExtension } : {}),
-        ...(opts.readFile ? { readFile: opts.readFile } : {}),
-    });
+    return resolveOtelLaunch({ env, cwd, ...(opts.readFile ? { readFile: opts.readFile } : {}) });
 }
 //# sourceMappingURL=otel.js.map

package/dist/paths.d.ts

@@ -19,6 +19,12 @@
  * fall back to resolving the workspace-linked package, which keeps `pnpm test`
  * and a fresh checkout working before anything is bundled.
  */
+/**
+ * Absolute path to this CLI's entry (`dist/cli.js`). Forwarded to sessions as
+ * `YAGNI_CLI_PATH` so the extension's `/plugin` panel can run
+ * `yagni plugin …` with the exact binary that launched it.
+ */
+export declare function resolveCliPath(): string;
 export declare function resolveExtensionPath(): string;
 /**
  * Absolute path to the extension's headless pipeline entry
@@ -29,6 +35,13 @@ export declare function resolveExtensionPath(): string;
  * it pulls in the pipeline alone, with none of pi's TUI surface.
  */
 export declare function resolveHeadlessGoPath(): string;
+/**
+ * Absolute path to the extension's telemetry probe (`telemetry/probe.js`),
+ * the module `yagni doctor` imports to send one real record per signal.
+ * Same derivation as `resolveHeadlessGoPath`; only this module (and the OTel
+ * SDK it pulls in) loads, none of pi's TUI surface.
+ */
+export declare function resolveTelemetryProbePath(): string;
 /**
  * Absolute path to the extension's session-worktree entry
  * (`pipeline/sessionWorktree.js`), the module `yagni -w` imports.

package/dist/paths.js

@@ -25,6 +25,14 @@ function resolveModulePath(specifier) {
  * fall back to resolving the workspace-linked package, which keeps `pnpm test`
  * and a fresh checkout working before anything is bundled.
  */
+/**
+ * Absolute path to this CLI's entry (`dist/cli.js`). Forwarded to sessions as
+ * `YAGNI_CLI_PATH` so the extension's `/plugin` panel can run
+ * `yagni plugin …` with the exact binary that launched it.
+ */
+export function resolveCliPath() {
+    return fileURLToPath(new URL("./cli.js", import.meta.url));
+}
 export function resolveExtensionPath() {
     const bundled = fileURLToPath(new URL("./extension/index.js", import.meta.url));
     if (existsSync(bundled))
@@ -43,6 +51,16 @@ export function resolveHeadlessGoPath() {
     const entry = resolveExtensionPath();
     return join(dirname(entry), "pipeline", "headlessGo.js");
 }
+/**
+ * Absolute path to the extension's telemetry probe (`telemetry/probe.js`),
+ * the module `yagni doctor` imports to send one real record per signal.
+ * Same derivation as `resolveHeadlessGoPath`; only this module (and the OTel
+ * SDK it pulls in) loads, none of pi's TUI surface.
+ */
+export function resolveTelemetryProbePath() {
+    const entry = resolveExtensionPath();
+    return join(dirname(entry), "telemetry", "probe.js");
+}
 /**
  * Absolute path to the extension's session-worktree entry
  * (`pipeline/sessionWorktree.js`), the module `yagni -w` imports.