@yagni-app/code 1.0.6 → 1.0.8

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

package/dist/extension/telemetry/probe.js

@@ -0,0 +1,122 @@
+/**
+ * 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 { metrics, trace } from "@opentelemetry/api";
+import { logs, SeverityNumber } from "@opentelemetry/api-logs";
+import { PREFIX } from "./attrs.js";
+import { enabledSignals, resolveTelemetryConfig } from "./config.js";
+import { createTelemetrySdk, makeLogExporter, makeMetricExporter, makeTraceExporter, unrefTimer } from "./sdk.js";
+const PROBE_TIMEOUT_MS = 8_000;
+/**
+ * Wrap an exporter so its export callback's result is observable. Every
+ * other member (the metric exporter's temporality selector, for one) is
+ * forwarded by prototype so the wrapper stays a drop-in.
+ */
+function observe(inner) {
+    let resolveResult = () => { };
+    const result = new Promise((resolve) => {
+        resolveResult = resolve;
+    });
+    const wrapped = Object.create(inner);
+    wrapped.export = (items, cb) => {
+        inner.export(items, (r) => {
+            resolveResult(r);
+            cb(r);
+        });
+    };
+    return { wrapped, result };
+}
+function describe(r) {
+    if (!r)
+        return "no export attempted (timed out)";
+    if (r.code === 0)
+        return undefined;
+    const e = r.error;
+    if (!e)
+        return "export failed";
+    // The OTLP http exporter's error carries the status code as `code` and the
+    // status text as the message ("Forbidden"); name the code so a reader can
+    // tell a bad key (401/403) from a bad path (404) at a glance.
+    const status = e.code;
+    const prefix = typeof status === "number" ? `HTTP ${status}: ` : "";
+    const msg = `${prefix}${e.message || String(e)}`;
+    return msg.length > 300 ? `${msg.slice(0, 300)}…` : msg;
+}
+function withTimeout(p, ms) {
+    return Promise.race([p, new Promise((resolve) => unrefTimer(setTimeout(resolve, ms)))]);
+}
+/**
+ * Run the probe against a config resolved from `env` (the launcher passes the
+ * exact child env a session would get). Never throws.
+ */
+export async function probeTelemetryExport(env) {
+    const config = resolveTelemetryConfig({ ...env, YAGNI_OTEL_EXPORT: "1" });
+    const results = [];
+    const signals = enabledSignals(config);
+    if (signals.length === 0)
+        return { config, results };
+    const traceProbe = config.traces.enabled
+        ? observe(makeTraceExporter(config.traces))
+        : undefined;
+    const metricProbe = config.metrics.enabled
+        ? observe(makeMetricExporter(config.metrics, config.metricsTemporality))
+        : undefined;
+    const logProbe = config.logs.enabled
+        ? observe(makeLogExporter(config.logs))
+        : undefined;
+    const sdk = createTelemetrySdk(config, {
+        simpleProcessors: true,
+        exporters: {
+            ...(traceProbe ? { traces: traceProbe.wrapped } : {}),
+            ...(metricProbe ? { metrics: metricProbe.wrapped } : {}),
+            ...(logProbe ? { logs: logProbe.wrapped } : {}),
+        },
+    });
+    try {
+        if (traceProbe) {
+            const span = trace.getTracer(PREFIX).startSpan(`${PREFIX}.doctor.probe`, {
+                attributes: { [`${PREFIX}.probe`]: true },
+            });
+            span.end();
+        }
+        if (metricProbe) {
+            metrics.getMeter(PREFIX).createCounter(`${PREFIX}.doctor.probe`, { unit: "1" }).add(1);
+        }
+        if (logProbe) {
+            logs.getLogger(PREFIX).emit({
+                eventName: `${PREFIX}.doctor.probe`,
+                severityNumber: SeverityNumber.INFO,
+                body: `${PREFIX}.doctor.probe`,
+                attributes: { "event.name": "doctor.probe" },
+            });
+        }
+        await sdk.forceFlush();
+        const settle = async (signal, probe) => {
+            if (!probe)
+                return;
+            const r = await withTimeout(probe.result, PROBE_TIMEOUT_MS);
+            const error = describe(r);
+            results.push({
+                signal,
+                url: config[signal].url,
+                protocol: config[signal].protocol,
+                ok: error === undefined,
+                ...(error ? { error } : {}),
+            });
+        };
+        await Promise.all([settle("traces", traceProbe), settle("metrics", metricProbe), settle("logs", logProbe)]);
+    }
+    finally {
+        await sdk.shutdown();
+    }
+    results.sort((a, b) => signals.indexOf(a.signal) - signals.indexOf(b.signal));
+    return { config, results };
+}
+//# sourceMappingURL=probe.js.map

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

@@ -0,0 +1,47 @@
+/**
+ * Wire pi's lifecycle events into the session telemetry tracker.
+ *
+ * Registered from the extension entry on every launch; it is a no-op unless
+ * the launcher set `YAGNI_OTEL_EXPORT=1` (an OTLP destination is configured)
+ * and no kill switch is set. /go stage children and subagents load this same
+ * extension with the inherited env, so their spend is traced without any
+ * extra plumbing.
+ *
+ * The OTel SDK and exporter graph (a couple of hundred modules) is loaded
+ * LAZILY, at the first session_start of an exporting session, so the common
+ * case — no collector configured — never pays for it.
+ *
+ * Every handler is wrapped so a telemetry bug can never break a session:
+ * exceptions are swallowed, and the SDK degrades to "not exporting" with one
+ * notice.
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { type TelemetryConfig } from "./config.js";
+import type { TelemetrySdk, TelemetrySdkOptions } from "./sdk.js";
+import { SessionTelemetry, type ToolDecisionInput } from "./tracker.js";
+export interface TelemetryHandle {
+    /** Whether this process is configured to export. */
+    readonly enabled: boolean;
+    readonly config: TelemetryConfig;
+    /** The gate calls this at every terminal tool_call outcome. */
+    toolDecision(input: ToolDecisionInput): void;
+    /** The mode holder calls this on every /mode (or shift-tab) change. */
+    permissionModeChanged(fromMode: string, toMode: string): void;
+    /**
+     * The entry calls this with the account email the /context boot fetch
+     * returned. A launcher-forwarded `YAGNI_USER_EMAIL` wins; otherwise every
+     * span, metric, and event from here on carries `user.email` (still subject
+     * to the `includeAccountId` gate).
+     */
+    setUserEmail(email: string | undefined): void;
+    /** Test/introspection seam: the live tracker once the SDK is up. */
+    readonly tracker: SessionTelemetry | null;
+}
+export interface RegisterTelemetryDeps {
+    env?: NodeJS.ProcessEnv;
+    /** Override SDK construction (tests inject in-memory exporters). */
+    createSdk?: (config: TelemetryConfig, opts: TelemetrySdkOptions) => TelemetrySdk;
+    now?: () => number;
+}
+export declare function registerTelemetry(pi: ExtensionAPI, deps?: RegisterTelemetryDeps): TelemetryHandle;
+//# sourceMappingURL=register.d.ts.map

package/dist/extension/telemetry/register.js

@@ -0,0 +1,207 @@
+/**
+ * Wire pi's lifecycle events into the session telemetry tracker.
+ *
+ * Registered from the extension entry on every launch; it is a no-op unless
+ * the launcher set `YAGNI_OTEL_EXPORT=1` (an OTLP destination is configured)
+ * and no kill switch is set. /go stage children and subagents load this same
+ * extension with the inherited env, so their spend is traced without any
+ * extra plumbing.
+ *
+ * The OTel SDK and exporter graph (a couple of hundred modules) is loaded
+ * LAZILY, at the first session_start of an exporting session, so the common
+ * case — no collector configured — never pays for it.
+ *
+ * Every handler is wrapped so a telemetry bug can never break a session:
+ * exceptions are swallowed, and the SDK degrades to "not exporting" with one
+ * notice.
+ */
+import { basename } from "node:path";
+import { metrics, trace } from "@opentelemetry/api";
+import { logs } from "@opentelemetry/api-logs";
+import { logEvent } from "../errorSink.js";
+import { PREFIX } from "./attrs.js";
+import { resolveTelemetryConfig } from "./config.js";
+import { countContentLines, countPatchLines, byteLength, SessionTelemetry } from "./tracker.js";
+const NOOP_HANDLE = (config) => ({
+    enabled: false,
+    config,
+    toolDecision: () => { },
+    permissionModeChanged: () => { },
+    setUserEmail: () => { },
+    tracker: null,
+});
+export function registerTelemetry(pi, deps = {}) {
+    const env = deps.env ?? process.env;
+    const config = resolveTelemetryConfig(env);
+    if (!config.enabled)
+        return NOOP_HANDLE(config);
+    if (!config.traces.enabled && !config.metrics.enabled && !config.logs.enabled)
+        return NOOP_HANDLE(config);
+    let ctx0;
+    let sdk = null;
+    let tracker = null;
+    /** Set once construction failed: never retry, never notify twice. */
+    let failed = false;
+    const notify = (message, severity) => {
+        try {
+            ctx0?.ui?.notify?.(message, severity);
+        }
+        catch {
+            // best-effort
+        }
+    };
+    // Telemetry must never break the session — but a swallowed error must
+    // leave a trail in the local error sink (~/.yagni-code error log), so a
+    // "why is nothing in Datadog" investigation has something to read.
+    const guard = (name, fn) => (...args) => {
+        try {
+            fn(...args);
+        }
+        catch (err) {
+            logEvent({
+                source: "telemetry",
+                level: "warn",
+                event: "handler_error",
+                fields: { handler: name, error: err instanceof Error ? `${err.name}: ${err.message}` : String(err) },
+            });
+        }
+    };
+    /** Load the SDK graph and build the tracker; idempotent, fail-soft. */
+    async function ensureSdk() {
+        if (sdk || failed)
+            return;
+        try {
+            const createSdk = deps.createSdk ?? (await import("./sdk.js")).createTelemetrySdk;
+            sdk = createSdk(config, {
+                onExportError: (message) => notify(`Telemetry export failed: ${message}. Run \`yagni doctor\` to test the endpoint.`, "warning"),
+            });
+            const version = config.serviceVersion ?? "0.0.0";
+            tracker = new SessionTelemetry({
+                tracer: trace.getTracer(PREFIX, version),
+                meter: metrics.getMeter(PREFIX, version),
+                logger: logs.getLogger(PREFIX, version),
+                config,
+                ...(deps.now ? { now: deps.now } : {}),
+            });
+        }
+        catch (err) {
+            failed = true;
+            sdk = null;
+            tracker = null;
+            notify(`Telemetry export could not start: ${err?.message ?? String(err)}`, "warning");
+        }
+    }
+    pi.on("session_start", async (_event, ctx) => {
+        ctx0 = ctx;
+        await ensureSdk();
+        if (!tracker)
+            return;
+        try {
+            let sessionId;
+            try {
+                const file = ctx.sessionManager?.getSessionFile?.();
+                if (file)
+                    sessionId = basename(file, ".jsonl");
+            }
+            catch {
+                // ephemeral session
+            }
+            tracker.sessionStart(sessionId ?? env.YAGNI_SESSION_ID);
+        }
+        catch {
+            // never break session start
+        }
+    });
+    pi.on("before_agent_start", guard("before_agent_start", (event) => tracker?.interactionStart(event?.prompt)));
+    pi.on("turn_start", guard("turn_start", (event) => tracker?.turnStart(event?.turnIndex)));
+    pi.on("turn_end", guard("turn_end", () => tracker?.turnEnd()));
+    pi.on("before_provider_request", guard("before_provider_request", (event) => {
+        const payload = event?.payload;
+        const model = payload?.model ?? payload?.modelId;
+        tracker?.llmStart(typeof model === "string" ? model : undefined);
+    }));
+    pi.on("after_provider_response", guard("after_provider_response", (event) => {
+        tracker?.llmResponseHeaders(event?.status, event?.headers);
+    }));
+    pi.on("message_end", guard("message_end", (event) => {
+        const msg = event?.message;
+        if (!msg || msg.role !== "assistant")
+            return;
+        tracker?.assistantMessageEnd(msg);
+    }));
+    pi.on("tool_execution_start", guard("tool_execution_start", (event) => {
+        if (!event?.toolCallId || !event?.toolName)
+            return;
+        tracker?.toolStart(event.toolCallId, event.toolName, event.args);
+    }));
+    pi.on("tool_execution_end", guard("tool_execution_end", (event) => {
+        if (!event?.toolCallId)
+            return;
+        tracker?.toolEnd(event.toolCallId, { isError: !!event.isError, resultBytes: byteLength(event.result) });
+    }));
+    // tool_result carries the typed details (edit patch, bash command): the
+    // productivity counters (lines of code, commits, PRs) come from here.
+    pi.on("tool_result", guard("tool_result", (event) => {
+        if (!event || event.isError || !tracker)
+            return;
+        if (event.toolName === "edit") {
+            const patch = event.details?.patch;
+            const { added, removed } = countPatchLines(patch);
+            tracker.linesOfCode(added, removed);
+        }
+        else if (event.toolName === "write") {
+            tracker.linesOfCode(countContentLines(event.input?.content), 0);
+        }
+        else if (event.toolName === "bash") {
+            const command = event.input?.command;
+            tracker.bashSucceeded(typeof command === "string" ? command : undefined);
+        }
+    }));
+    pi.on("agent_end", guard("agent_end", () => tracker?.interactionEnd()));
+    // Quit: flush and shut down, bounded, so a blackholing collector cannot
+    // hold the exit. Session replacement (/new, /resume, /fork, reload): close
+    // the open spans and flush in the background — the process lives on and
+    // the same providers serve the next session, so nothing waits.
+    pi.on("session_shutdown", async (event) => {
+        try {
+            tracker?.close();
+            if (!sdk)
+                return;
+            if (event?.reason === "quit") {
+                await sdk.shutdown();
+                sdk = null;
+                tracker = null;
+            }
+            else {
+                void sdk.forceFlush().catch(() => { });
+            }
+        }
+        catch {
+            // never block exit
+        }
+    });
+    return {
+        enabled: true,
+        config,
+        get tracker() {
+            return tracker;
+        },
+        toolDecision: guard("tool_decision", (input) => tracker?.toolDecision(input)),
+        permissionModeChanged: guard("permission_mode_changed", (from, to) => tracker?.permissionModeChanged(from, to)),
+        // Precedence, lowest to highest: this call (the /context boot fetch) <
+        // the launcher's YAGNI_USER_EMAIL, which resolveTelemetryConfig already
+        // placed on `identity`. So an identity that is set is never overwritten,
+        // whichever writer set it; a new writer must slot into this order
+        // explicitly rather than rely on call timing. The tracker reads
+        // `config.identity` on every attribute set, so this applies whether the
+        // SDK is already up or still lazy-loading.
+        setUserEmail: (email) => {
+            if (config.identity.userEmail)
+                return;
+            const trimmed = typeof email === "string" ? email.trim() : "";
+            if (trimmed)
+                config.identity.userEmail = trimmed;
+        },
+    };
+}
+//# sourceMappingURL=register.js.map