@yagni-app/code 1.0.5 → 1.0.7

package/dist/extension/telemetry/attrs.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Attribute, metric, and event names.
+ *
+ * Two vocabularies ride on every signal on purpose:
+ *
+ *   - Claude Code's telemetry shape (`session.id`, `input_tokens`,
+ *     `tool_name`, the `<prefix>.token.usage` counter, the `api_request`
+ *     event …) so a team's existing Claude Code dashboards swap to YAGNI Code
+ *     by changing the prefix from `claude_code` to `yagni_code`;
+ *   - the OpenTelemetry GenAI semantic conventions (`gen_ai.*`) on the LLM
+ *     and tool spans, which is what vendor LLM-observability products
+ *     (Datadog LLM Observability, Grafana's GenAI views) key on.
+ *
+ * Names are literal strings rather than semconv-package imports: the set is
+ * small, stable, and part of our documented customer contract.
+ */
+export declare const PREFIX = "yagni_code";
+export declare const ATTR_SESSION_ID = "session.id";
+export declare const ATTR_APP_VERSION = "app.version";
+export declare const ATTR_APP_ENTRYPOINT = "app.entrypoint";
+export declare const ATTR_ORGANIZATION_ID = "organization.id";
+export declare const ATTR_USER_EMAIL = "user.email";
+export declare const ATTR_TERMINAL_TYPE = "terminal.type";
+export declare const ATTR_GEN_AI_OPERATION_NAME = "gen_ai.operation.name";
+export declare const ATTR_GEN_AI_PROVIDER_NAME = "gen_ai.provider.name";
+export declare const ATTR_GEN_AI_SYSTEM = "gen_ai.system";
+export declare const ATTR_GEN_AI_REQUEST_MODEL = "gen_ai.request.model";
+export declare const ATTR_GEN_AI_RESPONSE_MODEL = "gen_ai.response.model";
+export declare const ATTR_GEN_AI_RESPONSE_ID = "gen_ai.response.id";
+export declare const ATTR_GEN_AI_FINISH_REASONS = "gen_ai.response.finish_reasons";
+/**
+ * Token usage. The semconv registry says `gen_ai.usage.input_tokens` "SHOULD
+ * include all types of input tokens, including cached tokens", and defines the
+ * cache counters as subsets of it. pi reports the Anthropic way (non-cached
+ * input, cache read, cache write as three disjoint numbers), so the tracker
+ * adds them up for the `gen_ai.*` layer. Consumers such as Datadog LLM
+ * Observability divide cache_read by input_tokens; feeding them the disjoint
+ * number produced cache ratios in the tens of thousands of percent.
+ *
+ * The flat Claude Code attributes (`input_tokens`, `cache_read_tokens`, …) and
+ * the `<prefix>.token.usage` metric deliberately keep Claude Code's disjoint
+ * semantics so cross-harness comparisons stay apples to apples.
+ */
+export declare const ATTR_GEN_AI_INPUT_TOKENS = "gen_ai.usage.input_tokens";
+export declare const ATTR_GEN_AI_OUTPUT_TOKENS = "gen_ai.usage.output_tokens";
+export declare const ATTR_GEN_AI_TOTAL_TOKENS = "gen_ai.usage.total_tokens";
+export declare const ATTR_GEN_AI_CACHE_READ_TOKENS = "gen_ai.usage.cache_read.input_tokens";
+export declare const ATTR_GEN_AI_CACHE_WRITE_TOKENS = "gen_ai.usage.cache_write.input_tokens";
+/** Pre-semconv spellings emitted through 1.0.x; kept for one release so
+ * dashboards keyed on them keep working. */
+export declare const ATTR_GEN_AI_CACHE_READ_TOKENS_LEGACY = "gen_ai.usage.cache_read_input_tokens";
+export declare const ATTR_GEN_AI_CACHE_CREATION_TOKENS_LEGACY = "gen_ai.usage.cache_creation_input_tokens";
+/** The one cost attribute Datadog's OTLP ingestion documents. Carries the
+ * same sell-rate figure as the flat `cost_usd`, so the vendor Cost view
+ * populates for the opaque tier id, which no vendor price table knows.
+ * Unit is NANODOLLARS (integer), not dollars: Datadog copies the value
+ * unscaled into its nanodollar cost metric. */
+export declare const ATTR_GEN_AI_COST_ESTIMATED_TOTAL = "gen_ai.cost.estimated_total";
+export declare const ATTR_GEN_AI_CONVERSATION_ID = "gen_ai.conversation.id";
+export declare const ATTR_GEN_AI_AGENT_NAME = "gen_ai.agent.name";
+export declare const ATTR_GEN_AI_TOOL_NAME = "gen_ai.tool.name";
+export declare const ATTR_GEN_AI_TOOL_CALL_ID = "gen_ai.tool.call.id";
+export declare const ATTR_GEN_AI_TOOL_TYPE = "gen_ai.tool.type";
+export declare const ATTR_ERROR_TYPE = "error.type";
+export declare const ATTR_HTTP_STATUS_CODE = "http.response.status_code";
+/** The provider name every span carries. The backing model is never exposed:
+ * `gen_ai.request.model` is the opaque YAGNI tier id. */
+export declare const GEN_AI_PROVIDER = "yagni";
+export declare const SPAN_INTERACTION = "yagni_code.interaction";
+export declare const SPAN_TURN = "yagni_code.turn";
+export declare const SPAN_LLM_REQUEST = "yagni_code.llm_request";
+export declare const SPAN_TOOL = "yagni_code.tool";
+export declare const METRIC_SESSION_COUNT = "yagni_code.session.count";
+export declare const METRIC_LINES_OF_CODE = "yagni_code.lines_of_code.count";
+export declare const METRIC_PULL_REQUEST_COUNT = "yagni_code.pull_request.count";
+export declare const METRIC_COMMIT_COUNT = "yagni_code.commit.count";
+export declare const METRIC_COST_USAGE = "yagni_code.cost.usage";
+export declare const METRIC_TOKEN_USAGE = "yagni_code.token.usage";
+export declare const METRIC_CODE_EDIT_DECISION = "yagni_code.code_edit_tool.decision";
+export declare const METRIC_ACTIVE_TIME = "yagni_code.active_time.total";
+export declare const EVENT_USER_PROMPT = "user_prompt";
+export declare const EVENT_ASSISTANT_RESPONSE = "assistant_response";
+export declare const EVENT_TOOL_RESULT = "tool_result";
+export declare const EVENT_API_REQUEST = "api_request";
+export declare const EVENT_API_ERROR = "api_error";
+export declare const EVENT_TOOL_DECISION = "tool_decision";
+export declare const EVENT_PERMISSION_MODE_CHANGED = "permission_mode_changed";
+/** Claude Code token-type values on `<prefix>.token.usage`. */
+export type TokenType = "input" | "output" | "cacheRead" | "cacheCreation";
+/** Claude Code decision sources on tool_decision / code_edit_tool.decision. */
+export type DecisionSource = "config" | "hook" | "user_permanent" | "user_temporary" | "user_abort" | "user_reject";
+export type Decision = "accept" | "reject";
+export declare function clampString(s: string, max?: number): string;
+/** Language label from a file path's extension (Claude Code's `language` attr). */
+export declare function languageFromPath(path: string | undefined): string | undefined;
+//# sourceMappingURL=attrs.d.ts.map

package/dist/extension/telemetry/attrs.js

@@ -0,0 +1,149 @@
+/**
+ * Attribute, metric, and event names.
+ *
+ * Two vocabularies ride on every signal on purpose:
+ *
+ *   - Claude Code's telemetry shape (`session.id`, `input_tokens`,
+ *     `tool_name`, the `<prefix>.token.usage` counter, the `api_request`
+ *     event …) so a team's existing Claude Code dashboards swap to YAGNI Code
+ *     by changing the prefix from `claude_code` to `yagni_code`;
+ *   - the OpenTelemetry GenAI semantic conventions (`gen_ai.*`) on the LLM
+ *     and tool spans, which is what vendor LLM-observability products
+ *     (Datadog LLM Observability, Grafana's GenAI views) key on.
+ *
+ * Names are literal strings rather than semconv-package imports: the set is
+ * small, stable, and part of our documented customer contract.
+ */
+export const PREFIX = "yagni_code";
+// ── Resource / standard attributes ──────────────────────────────────────────
+export const ATTR_SESSION_ID = "session.id";
+export const ATTR_APP_VERSION = "app.version";
+export const ATTR_APP_ENTRYPOINT = "app.entrypoint";
+export const ATTR_ORGANIZATION_ID = "organization.id";
+export const ATTR_USER_EMAIL = "user.email";
+export const ATTR_TERMINAL_TYPE = "terminal.type";
+// ── GenAI semantic conventions ──────────────────────────────────────────────
+export const ATTR_GEN_AI_OPERATION_NAME = "gen_ai.operation.name";
+export const ATTR_GEN_AI_PROVIDER_NAME = "gen_ai.provider.name";
+export const ATTR_GEN_AI_SYSTEM = "gen_ai.system";
+export const ATTR_GEN_AI_REQUEST_MODEL = "gen_ai.request.model";
+export const ATTR_GEN_AI_RESPONSE_MODEL = "gen_ai.response.model";
+export const ATTR_GEN_AI_RESPONSE_ID = "gen_ai.response.id";
+export const ATTR_GEN_AI_FINISH_REASONS = "gen_ai.response.finish_reasons";
+/**
+ * Token usage. The semconv registry says `gen_ai.usage.input_tokens` "SHOULD
+ * include all types of input tokens, including cached tokens", and defines the
+ * cache counters as subsets of it. pi reports the Anthropic way (non-cached
+ * input, cache read, cache write as three disjoint numbers), so the tracker
+ * adds them up for the `gen_ai.*` layer. Consumers such as Datadog LLM
+ * Observability divide cache_read by input_tokens; feeding them the disjoint
+ * number produced cache ratios in the tens of thousands of percent.
+ *
+ * The flat Claude Code attributes (`input_tokens`, `cache_read_tokens`, …) and
+ * the `<prefix>.token.usage` metric deliberately keep Claude Code's disjoint
+ * semantics so cross-harness comparisons stay apples to apples.
+ */
+export const ATTR_GEN_AI_INPUT_TOKENS = "gen_ai.usage.input_tokens";
+export const ATTR_GEN_AI_OUTPUT_TOKENS = "gen_ai.usage.output_tokens";
+export const ATTR_GEN_AI_TOTAL_TOKENS = "gen_ai.usage.total_tokens";
+export const ATTR_GEN_AI_CACHE_READ_TOKENS = "gen_ai.usage.cache_read.input_tokens";
+export const ATTR_GEN_AI_CACHE_WRITE_TOKENS = "gen_ai.usage.cache_write.input_tokens";
+/** Pre-semconv spellings emitted through 1.0.x; kept for one release so
+ * dashboards keyed on them keep working. */
+export const ATTR_GEN_AI_CACHE_READ_TOKENS_LEGACY = "gen_ai.usage.cache_read_input_tokens";
+export const ATTR_GEN_AI_CACHE_CREATION_TOKENS_LEGACY = "gen_ai.usage.cache_creation_input_tokens";
+/** The one cost attribute Datadog's OTLP ingestion documents. Carries the
+ * same sell-rate figure as the flat `cost_usd`, so the vendor Cost view
+ * populates for the opaque tier id, which no vendor price table knows.
+ * Unit is NANODOLLARS (integer), not dollars: Datadog copies the value
+ * unscaled into its nanodollar cost metric. */
+export const ATTR_GEN_AI_COST_ESTIMATED_TOTAL = "gen_ai.cost.estimated_total";
+export const ATTR_GEN_AI_CONVERSATION_ID = "gen_ai.conversation.id";
+export const ATTR_GEN_AI_AGENT_NAME = "gen_ai.agent.name";
+export const ATTR_GEN_AI_TOOL_NAME = "gen_ai.tool.name";
+export const ATTR_GEN_AI_TOOL_CALL_ID = "gen_ai.tool.call.id";
+export const ATTR_GEN_AI_TOOL_TYPE = "gen_ai.tool.type";
+export const ATTR_ERROR_TYPE = "error.type";
+export const ATTR_HTTP_STATUS_CODE = "http.response.status_code";
+/** The provider name every span carries. The backing model is never exposed:
+ * `gen_ai.request.model` is the opaque YAGNI tier id. */
+export const GEN_AI_PROVIDER = "yagni";
+// ── Span names (Claude Code's beta trace tree, prefixed) ────────────────────
+export const SPAN_INTERACTION = `${PREFIX}.interaction`;
+export const SPAN_TURN = `${PREFIX}.turn`;
+export const SPAN_LLM_REQUEST = `${PREFIX}.llm_request`;
+export const SPAN_TOOL = `${PREFIX}.tool`;
+// ── Metric names (Claude Code's eight counters, prefixed) ───────────────────
+export const METRIC_SESSION_COUNT = `${PREFIX}.session.count`;
+export const METRIC_LINES_OF_CODE = `${PREFIX}.lines_of_code.count`;
+export const METRIC_PULL_REQUEST_COUNT = `${PREFIX}.pull_request.count`;
+export const METRIC_COMMIT_COUNT = `${PREFIX}.commit.count`;
+export const METRIC_COST_USAGE = `${PREFIX}.cost.usage`;
+export const METRIC_TOKEN_USAGE = `${PREFIX}.token.usage`;
+export const METRIC_CODE_EDIT_DECISION = `${PREFIX}.code_edit_tool.decision`;
+export const METRIC_ACTIVE_TIME = `${PREFIX}.active_time.total`;
+// ── Event names (Claude Code's log events, prefixed in the body) ────────────
+export const EVENT_USER_PROMPT = "user_prompt";
+export const EVENT_ASSISTANT_RESPONSE = "assistant_response";
+export const EVENT_TOOL_RESULT = "tool_result";
+export const EVENT_API_REQUEST = "api_request";
+export const EVENT_API_ERROR = "api_error";
+export const EVENT_TOOL_DECISION = "tool_decision";
+export const EVENT_PERMISSION_MODE_CHANGED = "permission_mode_changed";
+/** Cap on any string attribute (Claude Code's 60 KB content limit). */
+const MAX_ATTR_BYTES = 60 * 1024;
+export function clampString(s, max = MAX_ATTR_BYTES) {
+    if (Buffer.byteLength(s, "utf8") <= max)
+        return s;
+    let end = max;
+    while (end > 0 && Buffer.byteLength(s.slice(0, end), "utf8") > max - 16)
+        end -= 64;
+    return `${s.slice(0, Math.max(0, end))}…[truncated]`;
+}
+/** Language label from a file path's extension (Claude Code's `language` attr). */
+export function languageFromPath(path) {
+    if (!path)
+        return undefined;
+    const m = /\.([A-Za-z0-9]+)$/.exec(path);
+    if (!m)
+        return undefined;
+    const ext = m[1].toLowerCase();
+    const map = {
+        ts: "typescript",
+        tsx: "typescript",
+        mts: "typescript",
+        cts: "typescript",
+        js: "javascript",
+        jsx: "javascript",
+        mjs: "javascript",
+        cjs: "javascript",
+        py: "python",
+        rb: "ruby",
+        go: "go",
+        rs: "rust",
+        java: "java",
+        kt: "kotlin",
+        swift: "swift",
+        c: "c",
+        h: "c",
+        cc: "cpp",
+        cpp: "cpp",
+        hpp: "cpp",
+        cs: "csharp",
+        php: "php",
+        sh: "shell",
+        bash: "shell",
+        zsh: "shell",
+        sql: "sql",
+        md: "markdown",
+        json: "json",
+        yaml: "yaml",
+        yml: "yaml",
+        toml: "toml",
+        html: "html",
+        css: "css",
+        scss: "scss",
+    };
+    return map[ext] ?? ext;
+}
+//# sourceMappingURL=attrs.js.map

package/dist/extension/telemetry/config.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Telemetry export configuration, resolved from the standard OpenTelemetry
+ * environment contract (the same variables Claude Code reads), so a machine
+ * or workspace already configured for Claude Code lights up YAGNI Code with
+ * no translation.
+ *
+ * Pure: reads an env record, never the network or disk. The launcher decides
+ * WHETHER a session exports (see the CLI's otel.ts: env, workspace settings,
+ * or a repo's committed config) and sets `YAGNI_OTEL_EXPORT=1` plus the OTLP
+ * variables in the child env; this module turns that env into per-signal
+ * exporter settings.
+ *
+ * Endpoint rules follow the OTLP exporter spec:
+ *   - a per-signal endpoint (`OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`, …) is used
+ *     verbatim;
+ *   - the generic `OTEL_EXPORTER_OTLP_ENDPOINT` is a BASE: http transports
+ *     append `/v1/<signal>`, gRPC uses it as-is;
+ *   - nothing configured falls back to the local-collector defaults.
+ *
+ * Content policy is enforced here, not configurable: prompt and response
+ * text never export. `OTEL_LOG_USER_PROMPTS` and `OTEL_LOG_TOOL_DETAILS` are
+ * deliberately NOT honored — session content leaving the machine is a
+ * contract change, not an env knob.
+ */
+export type OtlpProtocol = "grpc" | "http/protobuf" | "http/json";
+export type Signal = "traces" | "metrics" | "logs";
+export declare const SIGNALS: readonly Signal[];
+export interface SignalConfig {
+    enabled: boolean;
+    protocol: OtlpProtocol;
+    /** The fully resolved URL this signal exports to. */
+    url: string;
+    headers: Record<string, string>;
+    /** Batch / periodic export interval in ms. */
+    exportIntervalMs: number;
+}
+export interface TelemetryIdentity {
+    /** Bound workspace id (YAGNI_WORKSPACE_ID) → `organization.id`. */
+    organizationId?: string;
+    /** The signed-in user's email when the launcher forwards it → `user.email`. */
+    userEmail?: string;
+    /** Shipping CLI version (YAGNI_CODE_VERSION) → `app.version`. */
+    appVersion?: string;
+    /** Detected terminal (TERM_PROGRAM / TMUX) → `terminal.type`. */
+    terminalType?: string;
+    /** `cli` for an interactive launch, `sdk-cli` for a headless /go run. */
+    entrypoint: "cli" | "sdk-cli";
+}
+export interface TelemetryConfig {
+    enabled: boolean;
+    serviceName: string;
+    serviceVersion?: string;
+    /** OTEL_RESOURCE_ATTRIBUTES, decoded. Applied to the resource and (by
+     * default) to every metric and event. */
+    resourceAttributes: Record<string, string>;
+    traces: SignalConfig;
+    metrics: SignalConfig;
+    logs: SignalConfig;
+    metricsTemporality: "delta" | "cumulative";
+    /** Cardinality controls (Claude Code parity). */
+    includeSessionId: boolean;
+    includeVersion: boolean;
+    includeAccountId: boolean;
+    includeResourceAttributes: boolean;
+    includeEntrypoint: boolean;
+    identity: TelemetryIdentity;
+}
+export declare const DEFAULT_SERVICE_NAME = "yagni-code";
+type Env = Record<string, string | undefined>;
+export declare function normalizeProtocol(p: string | undefined): OtlpProtocol | undefined;
+/**
+ * Parse a `k=v,k2=v2` list (OTEL_EXPORTER_OTLP_HEADERS / OTEL_RESOURCE_ATTRIBUTES).
+ * Values may be percent-encoded per the W3C baggage rules the spec references;
+ * a malformed escape keeps the raw value. Splits on the FIRST `=` only so a
+ * base64 value's trailing `==` survives.
+ */
+export declare function parseKvList(s: string | undefined): Record<string, string>;
+/**
+ * Reduce an endpoint that carries a signal path to its base
+ * (`https://otlp.datadoghq.com/v1/traces` → `https://otlp.datadoghq.com`).
+ * Pre-parity workspace configs stored the full trace URL; treating it as a
+ * base keeps them exporting all three signals without an admin re-save.
+ */
+export declare function stripSignalPath(endpoint: string): string;
+/**
+ * Resolve one signal's URL from the env, per the OTLP exporter spec.
+ * Exported for the launcher's doctor so its report names the exact URL a
+ * session will post to.
+ */
+export declare function resolveSignalUrl(env: Env, signal: Signal, protocol: OtlpProtocol): string;
+/** Personal kill switch, beats every other source (both spellings accepted). */
+export declare function telemetryDisabled(env: Env): boolean;
+/** The launcher's "this session exports" gate. */
+export declare const OTEL_EXPORT_ENV = "YAGNI_OTEL_EXPORT";
+export declare function resolveTelemetryConfig(env?: Env): TelemetryConfig;
+/** Signals this config will actually export (for doctor / status lines). */
+export declare function enabledSignals(config: TelemetryConfig): Signal[];
+export {};
+//# sourceMappingURL=config.d.ts.map

package/dist/extension/telemetry/config.js

@@ -0,0 +1,193 @@
+/**
+ * Telemetry export configuration, resolved from the standard OpenTelemetry
+ * environment contract (the same variables Claude Code reads), so a machine
+ * or workspace already configured for Claude Code lights up YAGNI Code with
+ * no translation.
+ *
+ * Pure: reads an env record, never the network or disk. The launcher decides
+ * WHETHER a session exports (see the CLI's otel.ts: env, workspace settings,
+ * or a repo's committed config) and sets `YAGNI_OTEL_EXPORT=1` plus the OTLP
+ * variables in the child env; this module turns that env into per-signal
+ * exporter settings.
+ *
+ * Endpoint rules follow the OTLP exporter spec:
+ *   - a per-signal endpoint (`OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`, …) is used
+ *     verbatim;
+ *   - the generic `OTEL_EXPORTER_OTLP_ENDPOINT` is a BASE: http transports
+ *     append `/v1/<signal>`, gRPC uses it as-is;
+ *   - nothing configured falls back to the local-collector defaults.
+ *
+ * Content policy is enforced here, not configurable: prompt and response
+ * text never export. `OTEL_LOG_USER_PROMPTS` and `OTEL_LOG_TOOL_DETAILS` are
+ * deliberately NOT honored — session content leaving the machine is a
+ * contract change, not an env knob.
+ */
+export const SIGNALS = ["traces", "metrics", "logs"];
+export const DEFAULT_SERVICE_NAME = "yagni-code";
+const DEFAULT_GRPC_ENDPOINT = "http://localhost:4317";
+const DEFAULT_HTTP_ENDPOINT = "http://localhost:4318";
+const DEFAULT_INTERVALS_MS = { traces: 5_000, metrics: 60_000, logs: 5_000 };
+const SIGNAL_ENV = { traces: "TRACES", metrics: "METRICS", logs: "LOGS" };
+function envTrue(v) {
+    return v === "1" || v === "true";
+}
+function envBool(v, fallback) {
+    if (v === undefined || v.trim() === "")
+        return fallback;
+    const s = v.trim().toLowerCase();
+    if (s === "1" || s === "true" || s === "yes")
+        return true;
+    if (s === "0" || s === "false" || s === "no")
+        return false;
+    return fallback;
+}
+export function normalizeProtocol(p) {
+    if (!p)
+        return undefined;
+    const v = p.trim().toLowerCase();
+    if (v === "grpc")
+        return "grpc";
+    if (v === "http/protobuf" || v === "http-protobuf" || v === "http")
+        return "http/protobuf";
+    if (v === "http/json")
+        return "http/json";
+    return undefined;
+}
+/**
+ * Parse a `k=v,k2=v2` list (OTEL_EXPORTER_OTLP_HEADERS / OTEL_RESOURCE_ATTRIBUTES).
+ * Values may be percent-encoded per the W3C baggage rules the spec references;
+ * a malformed escape keeps the raw value. Splits on the FIRST `=` only so a
+ * base64 value's trailing `==` survives.
+ */
+export function parseKvList(s) {
+    const out = {};
+    if (!s)
+        return out;
+    for (const pair of s.split(",")) {
+        const eq = pair.indexOf("=");
+        if (eq <= 0)
+            continue;
+        const k = pair.slice(0, eq).trim();
+        if (!k)
+            continue;
+        const raw = pair.slice(eq + 1).trim();
+        let v = raw;
+        try {
+            v = decodeURIComponent(raw);
+        }
+        catch {
+            v = raw;
+        }
+        out[k] = v;
+    }
+    return out;
+}
+/** Trailing `/v1/<signal>` on a URL — the shape older workspace 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`).
+ * Pre-parity workspace configs stored the full trace URL; treating it as a
+ * base keeps them exporting all three signals without an admin re-save.
+ */
+export function stripSignalPath(endpoint) {
+    return endpoint.replace(SIGNAL_PATH_RE, "").replace(/\/+$/, "");
+}
+/**
+ * Resolve one signal's URL from the env, per the OTLP exporter spec.
+ * Exported for the launcher's doctor so its report names the exact URL a
+ * session will post to.
+ */
+export function resolveSignalUrl(env, signal, protocol) {
+    const specific = env[`OTEL_EXPORTER_OTLP_${SIGNAL_ENV[signal]}_ENDPOINT`]?.trim();
+    if (specific)
+        return specific;
+    const generic = env.OTEL_EXPORTER_OTLP_ENDPOINT?.trim();
+    if (protocol === "grpc")
+        return generic || DEFAULT_GRPC_ENDPOINT;
+    const base = stripSignalPath(generic || DEFAULT_HTTP_ENDPOINT);
+    return `${base}/v1/${signal}`;
+}
+/** Whether any per-signal endpoint variable is set. */
+function anyPerSignalEndpoint(env) {
+    return SIGNALS.some((s) => Boolean(env[`OTEL_EXPORTER_OTLP_${SIGNAL_ENV[s]}_ENDPOINT`]?.trim()));
+}
+function resolveSignal(env, signal) {
+    const tag = SIGNAL_ENV[signal];
+    const protocol = normalizeProtocol(env[`OTEL_EXPORTER_OTLP_${tag}_PROTOCOL`]) ??
+        normalizeProtocol(env.OTEL_EXPORTER_OTLP_PROTOCOL) ??
+        "grpc";
+    const exporterSetting = env[`OTEL_${tag}_EXPORTER`]?.trim().toLowerCase();
+    // Claude Code gates each signal on OTEL_<SIGNAL>_EXPORTER; absent means on
+    // here (the launcher already decided this session exports), "none" turns
+    // one signal off.
+    const switchedOn = exporterSetting === undefined || exporterSetting === "" ? true : exporterSetting !== "none";
+    // A per-signal-only env (e.g. just OTEL_EXPORTER_OTLP_TRACES_ENDPOINT, no
+    // generic endpoint) means the user configured exactly those signals: the
+    // others must not fall back to the localhost defaults and spray
+    // ECONNREFUSED at a collector nobody runs.
+    const hasOwnEndpoint = Boolean(env[`OTEL_EXPORTER_OTLP_${tag}_ENDPOINT`]?.trim());
+    const hasGenericEndpoint = Boolean(env.OTEL_EXPORTER_OTLP_ENDPOINT?.trim());
+    const orphaned = !hasOwnEndpoint && !hasGenericEndpoint && anyPerSignalEndpoint(env);
+    const enabled = switchedOn && !orphaned;
+    const headers = {
+        ...parseKvList(env.OTEL_EXPORTER_OTLP_HEADERS),
+        ...parseKvList(env[`OTEL_EXPORTER_OTLP_${tag}_HEADERS`]),
+    };
+    const intervalRaw = Number(signal === "metrics"
+        ? env.OTEL_METRIC_EXPORT_INTERVAL
+        : signal === "logs"
+            ? env.OTEL_LOGS_EXPORT_INTERVAL
+            : env.OTEL_TRACES_EXPORT_INTERVAL);
+    const exportIntervalMs = Number.isFinite(intervalRaw) && intervalRaw > 0 ? intervalRaw : DEFAULT_INTERVALS_MS[signal];
+    return { enabled, protocol, url: resolveSignalUrl(env, signal, protocol), headers, exportIntervalMs };
+}
+function detectTerminal(env) {
+    if (env.TMUX)
+        return "tmux";
+    const tp = env.TERM_PROGRAM?.trim();
+    if (tp)
+        return tp;
+    return undefined;
+}
+/** Personal kill switch, beats every other source (both spellings accepted). */
+export function telemetryDisabled(env) {
+    return envTrue(env.PI_OTEL_DISABLED) || envTrue(env.YAGNI_OTEL_DISABLED);
+}
+/** The launcher's "this session exports" gate. */
+export const OTEL_EXPORT_ENV = "YAGNI_OTEL_EXPORT";
+export function resolveTelemetryConfig(env = process.env) {
+    const enabled = envTrue(env[OTEL_EXPORT_ENV]) && !telemetryDisabled(env);
+    const temporality = env.OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE?.trim().toLowerCase();
+    const appVersion = env.YAGNI_CODE_VERSION?.trim() || undefined;
+    const organizationId = env.YAGNI_WORKSPACE_ID?.trim() || undefined;
+    const userEmail = env.YAGNI_USER_EMAIL?.trim() || undefined;
+    const terminalType = detectTerminal(env);
+    return {
+        enabled,
+        serviceName: env.OTEL_SERVICE_NAME?.trim() || DEFAULT_SERVICE_NAME,
+        ...(appVersion ? { serviceVersion: appVersion } : {}),
+        resourceAttributes: parseKvList(env.OTEL_RESOURCE_ATTRIBUTES),
+        traces: resolveSignal(env, "traces"),
+        metrics: resolveSignal(env, "metrics"),
+        logs: resolveSignal(env, "logs"),
+        metricsTemporality: temporality === "cumulative" ? "cumulative" : "delta",
+        includeSessionId: envBool(env.OTEL_METRICS_INCLUDE_SESSION_ID, true),
+        includeVersion: envBool(env.OTEL_METRICS_INCLUDE_VERSION, false),
+        includeAccountId: envBool(env.OTEL_METRICS_INCLUDE_ACCOUNT_UUID, true),
+        includeResourceAttributes: envBool(env.OTEL_METRICS_INCLUDE_RESOURCE_ATTRIBUTES, true),
+        includeEntrypoint: envBool(env.OTEL_METRICS_INCLUDE_ENTRYPOINT, false),
+        identity: {
+            ...(organizationId ? { organizationId } : {}),
+            ...(userEmail ? { userEmail } : {}),
+            ...(appVersion ? { appVersion } : {}),
+            ...(terminalType ? { terminalType } : {}),
+            entrypoint: env.YAGNI_GO_HEADLESS === "1" ? "sdk-cli" : "cli",
+        },
+    };
+}
+/** Signals this config will actually export (for doctor / status lines). */
+export function enabledSignals(config) {
+    return SIGNALS.filter((s) => config[s].enabled);
+}
+//# sourceMappingURL=config.js.map

package/dist/extension/telemetry/index.d.ts

@@ -0,0 +1,7 @@
+export { DEFAULT_SERVICE_NAME, OTEL_EXPORT_ENV, SIGNALS, enabledSignals, normalizeProtocol, parseKvList, resolveSignalUrl, resolveTelemetryConfig, stripSignalPath, telemetryDisabled, type OtlpProtocol, type Signal, type SignalConfig, type TelemetryConfig, type TelemetryIdentity, } from "./config.js";
+export { PREFIX, type Decision, type DecisionSource } from "./attrs.js";
+export { registerTelemetry, type RegisterTelemetryDeps, type TelemetryHandle } from "./register.js";
+export { SessionTelemetry, countContentLines, countPatchLines, type ToolDecisionInput } from "./tracker.js";
+export { createTelemetrySdk, type TelemetrySdk, type TelemetrySdkOptions } from "./sdk.js";
+export { probeTelemetryExport, type SignalProbeResult, type TelemetryProbeReport } from "./probe.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/extension/telemetry/index.js

@@ -0,0 +1,7 @@
+export { DEFAULT_SERVICE_NAME, OTEL_EXPORT_ENV, SIGNALS, enabledSignals, normalizeProtocol, parseKvList, resolveSignalUrl, resolveTelemetryConfig, stripSignalPath, telemetryDisabled, } from "./config.js";
+export { PREFIX } from "./attrs.js";
+export { registerTelemetry } from "./register.js";
+export { SessionTelemetry, countContentLines, countPatchLines } from "./tracker.js";
+export { createTelemetrySdk } from "./sdk.js";
+export { probeTelemetryExport } from "./probe.js";
+//# sourceMappingURL=index.js.map

package/dist/extension/telemetry/probe.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Doctor probe: send one real record per enabled signal and report the
+ * exporter's verdict. This is what `yagni doctor` runs, so its "otel export"
+ * line means "the collector ACCEPTED a span/metric/log with these headers",
+ * not "port 443 answered" — a wrong API key (403), a wrong path (404), or a
+ * protocol mismatch all show up as the real status.
+ *
+ * The probe records are tiny and clearly named (`yagni_code.doctor.probe`)
+ * so a customer can find them in their backend as proof the pipe works.
+ */
+import { type Signal, type TelemetryConfig } from "./config.js";
+export interface SignalProbeResult {
+    signal: Signal;
+    url: string;
+    protocol: string;
+    ok: boolean;
+    /** One-line failure reason (status code, connection error) when !ok. */
+    error?: string;
+}
+export interface TelemetryProbeReport {
+    config: TelemetryConfig;
+    results: SignalProbeResult[];
+}
+/**
+ * Run the probe against a config resolved from `env` (the launcher passes the
+ * exact child env a session would get). Never throws.
+ */
+export declare function probeTelemetryExport(env: NodeJS.ProcessEnv): Promise<TelemetryProbeReport>;
+//# sourceMappingURL=probe.d.ts.map