@vostride/agent-qa-analytics 0.0.1 → 0.2.1

package/dist/index.cjs

@@ -0,0 +1,961 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ANALYTICS_AGENT_PRODUCTS: () => ANALYTICS_AGENT_PRODUCTS,
+  ANALYTICS_CHAT_END_REASONS: () => ANALYTICS_CHAT_END_REASONS,
+  ANALYTICS_DAEMON_JOB_KINDS: () => ANALYTICS_DAEMON_JOB_KINDS,
+  ANALYTICS_DAEMON_JOB_OUTCOMES: () => ANALYTICS_DAEMON_JOB_OUTCOMES,
+  ANALYTICS_EMITTING_HOSTS: () => ANALYTICS_EMITTING_HOSTS,
+  ANALYTICS_EVENT_MEMBERS: () => ANALYTICS_EVENT_MEMBERS,
+  ANALYTICS_EVENT_NAMES: () => ANALYTICS_EVENT_NAMES,
+  ANALYTICS_EVENT_SCHEMA_BY_NAME: () => ANALYTICS_EVENT_SCHEMA_BY_NAME,
+  ANALYTICS_FAILURE_CATEGORIES: () => ANALYTICS_FAILURE_CATEGORIES,
+  ANALYTICS_INIT_MODES: () => ANALYTICS_INIT_MODES,
+  ANALYTICS_INIT_OUTCOMES: () => ANALYTICS_INIT_OUTCOMES,
+  ANALYTICS_KNOWN_ID_MARKER: () => ANALYTICS_KNOWN_ID_MARKER,
+  ANALYTICS_MCP_ERROR_CATEGORIES: () => ANALYTICS_MCP_ERROR_CATEGORIES,
+  ANALYTICS_MCP_SERVER_STATES: () => ANALYTICS_MCP_SERVER_STATES,
+  ANALYTICS_MCP_TOOL_NAMES: () => ANALYTICS_MCP_TOOL_NAMES,
+  ANALYTICS_MCP_TOOL_STATUSES: () => ANALYTICS_MCP_TOOL_STATUSES,
+  ANALYTICS_MCP_TRANSPORTS: () => ANALYTICS_MCP_TRANSPORTS,
+  ANALYTICS_PLATFORMS: () => ANALYTICS_PLATFORMS,
+  ANALYTICS_RUNNERS: () => ANALYTICS_RUNNERS,
+  ANALYTICS_RUNTIME_CONTEXTS: () => ANALYTICS_RUNTIME_CONTEXTS,
+  ANALYTICS_RUN_STATUSES: () => ANALYTICS_RUN_STATUSES,
+  ANALYTICS_SUITE_EXECUTION_MODES: () => ANALYTICS_SUITE_EXECUTION_MODES,
+  ANALYTICS_TRIGGER_SOURCES: () => ANALYTICS_TRIGGER_SOURCES,
+  ANALYTICS_USER_ID_PREFIX: () => ANALYTICS_USER_ID_PREFIX,
+  ANALYTICS_USER_ID_WORDS: () => ANALYTICS_USER_ID_WORDS,
+  ANALYTICS_VOCABULARY_META_KEY: () => ANALYTICS_VOCABULARY_META_KEY,
+  AgentQaAnalyticsEventSchema: () => AgentQaAnalyticsEventSchema,
+  RETIRED_V33_EVENT_NAMES: () => RETIRED_V33_EVENT_NAMES,
+  analyticsRunId: () => analyticsRunId,
+  analyticsSuiteId: () => analyticsSuiteId,
+  analyticsTestId: () => analyticsTestId,
+  assertNoUnconstrainedStrings: () => assertNoUnconstrainedStrings,
+  composeAnalytics: () => composeAnalytics,
+  createAnalyticsPort: () => createAnalyticsPort,
+  createAnalyticsRunSubscriber: () => createAnalyticsRunSubscriber,
+  createPosthogTransport: () => createPosthogTransport,
+  generateAnalyticsUserId: () => generateAnalyticsUserId,
+  getAnalyticsIdentityPath: () => getAnalyticsIdentityPath,
+  maskEventForSend: () => maskEventForSend,
+  readAnalyticsIdentity: () => readAnalyticsIdentity,
+  resolveAnalyticsAgentProduct: () => resolveAnalyticsAgentProduct,
+  resolveAnalyticsIdentity: () => resolveAnalyticsIdentity
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/port.ts
+var DEFAULT_ANALYTICS_SHUTDOWN_TIMEOUT_MS = 2e3;
+var BestEffortAnalyticsPort = class {
+  transport;
+  identity;
+  shutdownTimeoutMs;
+  inFlight = [];
+  capturedSinceFlush = 0;
+  sending = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.transport = options.transport;
+    this.identity = options.identity;
+    this.shutdownTimeoutMs = options.shutdownTimeoutMs ?? DEFAULT_ANALYTICS_SHUTDOWN_TIMEOUT_MS;
+  }
+  /**
+   * There is NO try/catch here, and the absence is deliberate — measured, not assumed.
+   *
+   * 2026-08-17 (Phase 398 plan 03, mutation leg M6). This method was first written with the v1
+   * module's `try { ... } catch {}` wrapper around the body. Deleting that wrapper outright left
+   * every cell green, including the one named "never throws into the host", because there is no
+   * synchronous throw for it to catch: an `async` function body's throw — including one out of the
+   * identity resolver, the only caller-supplied code reachable from here — becomes a REJECTED
+   * PROMISE, never a synchronous exception. The wrapper read like the boundary and guarded nothing.
+   *
+   * The real boundary is the `.catch` below, attached in the same tick the promise is created so a
+   * rejection cannot become an unhandled rejection even if `flush()` is never called — which is the
+   * normal case for a host that emits on a path it does not await. Leg M8 removes that `.catch` and
+   * reds; that is the guard this method actually has.
+   */
+  capture(event) {
+    const transport = this.transport;
+    if (transport === void 0) return;
+    this.capturedSinceFlush += 1;
+    this.inFlight.push(
+      (async () => {
+        const identity = await this.identity();
+        await transport.capture({
+          distinctId: identity.distinctId,
+          ...identity.isInternal === true ? { isInternal: true } : {},
+          event
+        });
+      })().catch(() => {
+      })
+    );
+  }
+  /**
+   * EDGE ANLY-01/empty. A flush with nothing captured touches the transport at ALL — not "makes no
+   * network call", but makes no call. The distinction matters because `flush` on the PostHog
+   * transport is a send, so a host that flushes on every command return would otherwise poke the
+   * wire once per invocation whether or not anything happened. Zero captures in, zero calls out,
+   * and the promise still resolves.
+   *
+   * 2026-10-21 (447-07, D-20): flush awaits the local captures and STARTS the send without awaiting
+   * it, so a stalled network never holds a run's verdict or a command's return; `shutdown` waits
+   * for the started sends inside its bound.
+   */
+  async flush() {
+    const transport = this.transport;
+    if (transport === void 0) return;
+    try {
+      const pending = this.inFlight;
+      const captured = this.capturedSinceFlush;
+      this.inFlight = [];
+      this.capturedSinceFlush = 0;
+      await Promise.all(pending);
+      if (captured === 0) return;
+      const send = (async () => {
+        await transport.flush();
+      })().catch(() => {
+      });
+      this.sending.add(send);
+      void send.finally(() => this.sending.delete(send));
+    } catch {
+    }
+  }
+  /**
+   * Shutdown always reaches the transport, even with an empty queue: it releases whatever the
+   * transport holds (a PostHog client owns timers), and "release nothing" is cheap while "leak a
+   * timer because the session happened to be silent" keeps a process alive.
+   */
+  async shutdown() {
+    const transport = this.transport;
+    if (transport === void 0) return;
+    let timer;
+    try {
+      await Promise.race([
+        (async () => {
+          await this.flush();
+          await Promise.all([...this.sending]);
+          await transport.shutdown();
+        })(),
+        new Promise((resolve) => {
+          timer = setTimeout(resolve, this.shutdownTimeoutMs);
+          if (typeof timer.unref === "function") timer.unref();
+        })
+      ]);
+    } catch {
+    } finally {
+      if (timer !== void 0) clearTimeout(timer);
+    }
+  }
+};
+function createAnalyticsPort(options) {
+  return new BestEffortAnalyticsPort(options);
+}
+
+// src/transports.ts
+var import_posthog_node = require("posthog-node");
+
+// src/masking-seam.ts
+function maskEventForSend(payload, context) {
+  if (context === void 0) return payload;
+  return {
+    ...payload,
+    // The distinct id IS a masked surface: it is the one caller-supplied string on the envelope, and
+    // if a registered secret is what a host handed in as an identity, that is precisely a leak.
+    distinctId: context.mask(payload.distinctId),
+    event: {
+      name: payload.event.name,
+      properties: maskLeaves(payload.event.properties, context)
+    }
+  };
+}
+function maskLeaves(value, context) {
+  if (typeof value === "string") return context.mask(value);
+  if (Array.isArray(value)) return value.map((entry) => maskLeaves(entry, context));
+  if (value !== null && typeof value === "object" && isPlainObject(value)) {
+    const out = {};
+    for (const [key, entry] of Object.entries(value)) {
+      out[key] = maskLeaves(entry, context);
+    }
+    return out;
+  }
+  return value;
+}
+function isPlainObject(value) {
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+// src/transports.ts
+var PosthogTransport = class {
+  client;
+  maskingContext;
+  constructor(options) {
+    this.maskingContext = options.maskingContext;
+    this.client = options.client ?? new import_posthog_node.PostHog(options.projectKey, {
+      host: options.host,
+      disableGeoip: options.disableGeoip ?? false,
+      ...options.fetch ? { fetch: options.fetch } : {}
+    });
+  }
+  /**
+   * THE SEND CHOKE POINT. Masking is the first thing that happens here and it happens exactly once
+   * (a cell counts the call sites in shipped source and refuses any number but one).
+   *
+   * `flush`/`shutdown` are not second seams: everything they drain arrived through this method, so
+   * masking here ranges the whole queue. `is_internal` is added AFTER the mask because it is a
+   * boolean this file writes — there is no caller string in it to mask. It is an event property,
+   * sent only when true (447-07, D-13).
+   */
+  capture(payload) {
+    let masked;
+    try {
+      masked = maskEventForSend(payload, this.maskingContext);
+    } catch {
+      return;
+    }
+    const properties = { ...masked.event.properties };
+    if (masked.isInternal === true) {
+      properties.is_internal = true;
+    }
+    this.client.capture({
+      distinctId: masked.distinctId,
+      event: masked.event.name,
+      properties
+    });
+  }
+  async flush() {
+    await this.client.flush();
+  }
+  async shutdown() {
+    await this.client.shutdown();
+  }
+};
+function createPosthogTransport(options) {
+  return new PosthogTransport(options);
+}
+
+// src/posthog-project.ts
+var AGENT_QA_POSTHOG_KEY = "phc_siDVZ3DEoSCiBSocn2GZMRhx5UcRwekJDVtap5Zteii3";
+var AGENT_QA_POSTHOG_HOST = "https://us.i.posthog.com";
+
+// src/compose.ts
+function composeAnalytics(options = {}) {
+  const optedOut = options.config?.analytics?.privacy === true;
+  const optOutReasons = optedOut ? ["config-privacy"] : [];
+  const { transport, transportKind } = optedOut ? NO_TRANSPORT : enabledTransport(options);
+  return {
+    port: createAnalyticsPort({
+      transport,
+      identity: options.identity ?? noIdentity
+    }),
+    transport,
+    optedOut,
+    optOutReasons,
+    transportKind
+  };
+}
+var noIdentity = () => Promise.reject(new Error("no analytics identity was supplied"));
+var NO_TRANSPORT = { transport: void 0, transportKind: "none" };
+function enabledTransport(options) {
+  if (options.transportOverride) {
+    return { transport: options.transportOverride, transportKind: "posthog" };
+  }
+  const projectKey = (options.projectKey ?? AGENT_QA_POSTHOG_KEY).trim();
+  if (projectKey === "") return NO_TRANSPORT;
+  const factory = options.posthogTransportFactory ?? createPosthogTransport;
+  return {
+    transport: factory({
+      projectKey,
+      host: options.projectHost ?? AGENT_QA_POSTHOG_HOST,
+      disableGeoip: false,
+      ...options.maskingContext ? { maskingContext: options.maskingContext } : {}
+    }),
+    transportKind: "posthog"
+  };
+}
+
+// src/events.ts
+var import_agent_qa_ids = require("@vostride/agent-qa-ids");
+var import_agent_qa_mcp = require("@vostride/agent-qa-mcp");
+var import_zod = require("zod");
+var ANALYTICS_VOCABULARY_META_KEY = "analyticsVocabulary";
+var ANALYTICS_KNOWN_ID_MARKER = "known-id";
+function knownId(codec, accepts) {
+  return import_zod.z.string().refine(accepts, { message: `expected a ${codec} id` }).meta({ [ANALYTICS_VOCABULARY_META_KEY]: ANALYTICS_KNOWN_ID_MARKER, analyticsCodec: codec });
+}
+var SEMVER_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/u;
+var AgentQaVersionSchema = import_zod.z.string().regex(SEMVER_PATTERN, "expected a semver version").meta({ [ANALYTICS_VOCABULARY_META_KEY]: ANALYTICS_KNOWN_ID_MARKER, analyticsCodec: "semver" });
+function analyticsRunId(value) {
+  return typeof value === "string" && (0, import_agent_qa_ids.isCanonicalRunId)(value) ? value : void 0;
+}
+function analyticsTestId(value) {
+  return typeof value === "string" && (0, import_agent_qa_ids.isCanonicalTestId)(value) ? value : void 0;
+}
+function analyticsSuiteId(value) {
+  return typeof value === "string" && (0, import_agent_qa_ids.isCanonicalSuiteId)(value) ? value : void 0;
+}
+var RunIdSchema = knownId("run", import_agent_qa_ids.isCanonicalRunId);
+var TestIdSchema = knownId("test", import_agent_qa_ids.isCanonicalTestId);
+var SuiteIdSchema = knownId("suite", import_agent_qa_ids.isCanonicalSuiteId);
+var NonNegativeInteger = import_zod.z.number().int().min(0);
+var NonNegativeNumber = import_zod.z.number().min(0);
+var ANALYTICS_EMITTING_HOSTS = ["cli", "chat", "mcp", "daemon"];
+var ANALYTICS_RUNTIME_CONTEXTS = ["user", "ci"];
+var ANALYTICS_AGENT_PRODUCTS = [
+  "claude_code",
+  "cursor",
+  "gemini_cli",
+  "augment",
+  "goose",
+  "opencode",
+  "codex",
+  "cline",
+  "amp",
+  "unknown"
+];
+var ANALYTICS_TRIGGER_SOURCES = ["cli", "chat", "mcp", "daemon", "unknown"];
+var ANALYTICS_RUNNERS = ["local", "browserstack", "unknown"];
+var ANALYTICS_PLATFORMS = ["web", "android", "ios", "unknown"];
+var ANALYTICS_RUN_STATUSES = [
+  "passed",
+  "failed",
+  "skipped",
+  "cancelled",
+  "timeout",
+  "unknown"
+];
+var ANALYTICS_SUITE_EXECUTION_MODES = ["sequential", "parallel", "unknown"];
+var ANALYTICS_FAILURE_CATEGORIES = [
+  "assertion",
+  "timeout",
+  "cancelled",
+  "setup",
+  "hook",
+  "appium",
+  "browser_install",
+  "llm_context",
+  "llm_provider",
+  "memory",
+  "framework",
+  "unknown"
+];
+var ANALYTICS_MCP_SERVER_STATES = ["started", "stopped"];
+var ANALYTICS_MCP_TRANSPORTS = ["stdio", "http"];
+var ANALYTICS_MCP_TOOL_STATUSES = ["success", "error"];
+var ANALYTICS_MCP_ERROR_CATEGORIES = [
+  "validation",
+  "scope_denied",
+  "unknown_tool",
+  "tool_error",
+  "unknown"
+];
+var ANALYTICS_DAEMON_JOB_KINDS = ["run", "suite", "recovery", "unknown"];
+var ANALYTICS_DAEMON_JOB_OUTCOMES = [
+  "completed",
+  "failed",
+  "cancelled",
+  "abandoned",
+  "unknown"
+];
+var ANALYTICS_INIT_MODES = ["interactive", "agent", "scaffold"];
+var ANALYTICS_INIT_OUTCOMES = ["created", "updated", "unchanged", "failed"];
+var ANALYTICS_CHAT_END_REASONS = ["exit", "interrupt", "error", "unknown"];
+var ANALYTICS_MCP_TOOL_NAMES = import_agent_qa_mcp.AGENT_QA_TOOL_PROJECTIONS.map(
+  (projection) => projection.name
+);
+var BaseProperties = {
+  agent_qa_version: AgentQaVersionSchema.optional(),
+  surface: import_zod.z.enum(ANALYTICS_EMITTING_HOSTS).optional(),
+  runtime_context: import_zod.z.enum(ANALYTICS_RUNTIME_CONTEXTS).optional(),
+  is_internal: import_zod.z.literal(true).optional(),
+  agent_product: import_zod.z.enum(ANALYTICS_AGENT_PRODUCTS).optional(),
+  // PostHog's own directive, a literal `false` and never anything else: it suppresses person-profile
+  // creation, which is what keeps an anonymous distinct id anonymous on their side too.
+  $process_person_profile: import_zod.z.literal(false).optional()
+};
+function member(name, shape) {
+  return import_zod.z.strictObject({
+    name: import_zod.z.literal(name),
+    properties: import_zod.z.strictObject({ ...BaseProperties, ...shape })
+  });
+}
+var RunCompletionShape = {
+  trigger_source: import_zod.z.enum(ANALYTICS_TRIGGER_SOURCES).optional(),
+  runner: import_zod.z.enum(ANALYTICS_RUNNERS).optional(),
+  platform: import_zod.z.enum(ANALYTICS_PLATFORMS).optional(),
+  status: import_zod.z.enum(ANALYTICS_RUN_STATUSES).optional(),
+  failure_category: import_zod.z.enum(ANALYTICS_FAILURE_CATEGORIES).optional(),
+  duration_ms: NonNegativeNumber.optional(),
+  run_id: RunIdSchema.optional(),
+  // 2026-08-28 (405-13, D-21/DETL-06). The parent-link property was deleted here. It was declared
+  // with no producer anywhere in this package — 402-09 put one run row per run and moved member
+  // identity onto handles, and 405-07 then deleted the column it named — so it could only ever
+  // have travelled as `undefined`. Same disposition and same reason as the healing counter below.
+  step_count: NonNegativeInteger.optional(),
+  passed_step_count: NonNegativeInteger.optional(),
+  failed_step_count: NonNegativeInteger.optional(),
+  skipped_step_count: NonNegativeInteger.optional(),
+  retry_count: NonNegativeInteger.optional(),
+  input_tokens: NonNegativeInteger.optional(),
+  output_tokens: NonNegativeInteger.optional(),
+  total_tokens: NonNegativeInteger.optional(),
+  is_flaky: import_zod.z.boolean().optional(),
+  memory_enabled: import_zod.z.boolean().optional()
+};
+var TestRunCompleted = member("agent-qa.test_run.completed", {
+  ...RunCompletionShape,
+  test_id: TestIdSchema.optional()
+});
+var SuiteRunCompleted = member("agent-qa.suite_run.completed", {
+  ...RunCompletionShape,
+  suite_id: SuiteIdSchema.optional(),
+  suite_child_count: NonNegativeInteger.optional(),
+  suite_passed_count: NonNegativeInteger.optional(),
+  suite_failed_count: NonNegativeInteger.optional(),
+  suite_skipped_count: NonNegativeInteger.optional(),
+  suite_execution_mode: import_zod.z.enum(ANALYTICS_SUITE_EXECUTION_MODES).optional()
+});
+var ChatSessionCompleted = member("agent-qa.chat.session.completed", {
+  duration_ms: NonNegativeNumber.optional(),
+  turn_count: NonNegativeInteger.optional(),
+  slash_command_count: NonNegativeInteger.optional(),
+  function_call_count: NonNegativeInteger.optional(),
+  end_reason: import_zod.z.enum(ANALYTICS_CHAT_END_REASONS).optional()
+});
+var ChatTurnCompleted = member("agent-qa.chat.turn.completed", {
+  duration_ms: NonNegativeNumber.optional(),
+  tool_call_count: NonNegativeInteger.optional(),
+  input_tokens: NonNegativeInteger.optional(),
+  output_tokens: NonNegativeInteger.optional(),
+  total_tokens: NonNegativeInteger.optional(),
+  errored: import_zod.z.boolean().optional()
+});
+var DaemonJobCompleted = member("agent-qa.daemon.job.completed", {
+  job_kind: import_zod.z.enum(ANALYTICS_DAEMON_JOB_KINDS).optional(),
+  outcome: import_zod.z.enum(ANALYTICS_DAEMON_JOB_OUTCOMES).optional(),
+  duration_ms: NonNegativeNumber.optional(),
+  attempt_count: NonNegativeInteger.optional(),
+  run_id: RunIdSchema.optional()
+});
+var McpServerLifecycle = member("agent-qa.mcp.server.lifecycle", {
+  mcp_server_state: import_zod.z.enum(ANALYTICS_MCP_SERVER_STATES).optional(),
+  mcp_transport: import_zod.z.enum(ANALYTICS_MCP_TRANSPORTS).optional(),
+  mcp_tool_count: NonNegativeInteger.optional()
+});
+var McpToolInvoked = member("agent-qa.mcp.tool.invoked", {
+  tool_name: import_zod.z.enum(ANALYTICS_MCP_TOOL_NAMES).optional(),
+  mcp_tool_status: import_zod.z.enum(ANALYTICS_MCP_TOOL_STATUSES).optional(),
+  mcp_error_category: import_zod.z.enum(ANALYTICS_MCP_ERROR_CATEGORIES).optional(),
+  mcp_transport: import_zod.z.enum(ANALYTICS_MCP_TRANSPORTS).optional(),
+  duration_ms: NonNegativeNumber.optional()
+});
+var InitCompleted = member("agent-qa.init.completed", {
+  init_mode: import_zod.z.enum(ANALYTICS_INIT_MODES).optional(),
+  outcome: import_zod.z.enum(ANALYTICS_INIT_OUTCOMES).optional(),
+  created_file_count: NonNegativeInteger.optional(),
+  duration_ms: NonNegativeNumber.optional()
+});
+var ExplainAnswered = member("agent-qa.explain.answered", {
+  cited_row_count: NonNegativeInteger.optional(),
+  duration_ms: NonNegativeNumber.optional()
+});
+var ExplainAbstained = member("agent-qa.explain.abstained", {
+  suggested_row_count: NonNegativeInteger.optional(),
+  catalog_empty: import_zod.z.boolean().optional(),
+  duration_ms: NonNegativeNumber.optional()
+});
+var ANALYTICS_EVENT_NAMES = [
+  "agent-qa.test_run.completed",
+  "agent-qa.suite_run.completed",
+  "agent-qa.chat.session.completed",
+  "agent-qa.chat.turn.completed",
+  "agent-qa.daemon.job.completed",
+  "agent-qa.mcp.server.lifecycle",
+  "agent-qa.mcp.tool.invoked",
+  "agent-qa.init.completed",
+  "agent-qa.explain.answered",
+  "agent-qa.explain.abstained"
+];
+var RETIRED_V33_EVENT_NAMES = [
+  "agent-qa.analytics.initialized",
+  "agent-qa.analytics.test_event",
+  "agent-qa.dashboard.opened",
+  "agent-qa.dashboard.live_mode.started",
+  "agent-qa.dashboard.entity.created"
+];
+var ANALYTICS_EVENT_SCHEMA_BY_NAME = {
+  "agent-qa.test_run.completed": TestRunCompleted,
+  "agent-qa.suite_run.completed": SuiteRunCompleted,
+  "agent-qa.chat.session.completed": ChatSessionCompleted,
+  "agent-qa.chat.turn.completed": ChatTurnCompleted,
+  "agent-qa.daemon.job.completed": DaemonJobCompleted,
+  "agent-qa.mcp.server.lifecycle": McpServerLifecycle,
+  "agent-qa.mcp.tool.invoked": McpToolInvoked,
+  "agent-qa.init.completed": InitCompleted,
+  "agent-qa.explain.answered": ExplainAnswered,
+  "agent-qa.explain.abstained": ExplainAbstained
+};
+var ANALYTICS_EVENT_MEMBERS = [
+  TestRunCompleted,
+  SuiteRunCompleted,
+  ChatSessionCompleted,
+  ChatTurnCompleted,
+  DaemonJobCompleted,
+  McpServerLifecycle,
+  McpToolInvoked,
+  InitCompleted,
+  ExplainAnswered,
+  ExplainAbstained
+];
+var AgentQaAnalyticsEventSchema = import_zod.z.discriminatedUnion("name", ANALYTICS_EVENT_MEMBERS);
+function assertNoUnconstrainedStrings(members) {
+  const offenders = [];
+  for (const memberSchema of members) {
+    const name = memberNameOf(memberSchema);
+    walk(memberSchema, "", name, offenders);
+  }
+  if (offenders.length > 0) {
+    throw new Error(
+      `analytics event union carries unconstrained string field(s):
+  ${offenders.join("\n  ")}`
+    );
+  }
+}
+function memberNameOf(schema) {
+  if (schema instanceof import_zod.z.ZodObject) {
+    const nameSchema = schema.shape.name;
+    if (nameSchema instanceof import_zod.z.ZodLiteral) {
+      const values = nameSchema.def.values;
+      const first = Array.isArray(values) ? values[0] : values;
+      if (typeof first === "string") return first;
+    }
+  }
+  return "<unnamed member>";
+}
+function walk(schema, path, member2, offenders) {
+  const unwrapped = unwrap(schema);
+  if (unwrapped instanceof import_zod.z.ZodObject) {
+    for (const [key, child] of Object.entries(unwrapped.shape)) {
+      walk(child, path === "" ? key : `${path}.${key}`, member2, offenders);
+    }
+    return;
+  }
+  if (unwrapped instanceof import_zod.z.ZodEnum || unwrapped instanceof import_zod.z.ZodLiteral) return;
+  if (unwrapped instanceof import_zod.z.ZodNumber || unwrapped instanceof import_zod.z.ZodBoolean || unwrapped instanceof import_zod.z.ZodNull || unwrapped instanceof import_zod.z.ZodUndefined) {
+    return;
+  }
+  if (unwrapped instanceof import_zod.z.ZodArray) {
+    walk(unwrapped.element, path, member2, offenders);
+    return;
+  }
+  if (unwrapped instanceof import_zod.z.ZodRecord) {
+    walk(unwrapped.keyType, path, member2, offenders);
+    walk(unwrapped.valueType, path, member2, offenders);
+    return;
+  }
+  if (unwrapped instanceof import_zod.z.ZodUnion) {
+    for (const option of unwrapped.options) {
+      walk(option, path, member2, offenders);
+    }
+    return;
+  }
+  if (unwrapped instanceof import_zod.z.ZodString) {
+    if (!isKnownIdCodec(unwrapped)) {
+      offenders.push(`${member2} :: ${path} | unconstrained string`);
+    }
+    return;
+  }
+  offenders.push(`${member2} :: ${path} | unrecognised construct, cannot prove it is constrained`);
+}
+function isKnownIdCodec(schema) {
+  const meta = schema.meta();
+  if (meta?.[ANALYTICS_VOCABULARY_META_KEY] !== ANALYTICS_KNOWN_ID_MARKER) return false;
+  return (schema.def.checks ?? []).length > 0;
+}
+function unwrap(schema) {
+  let current = schema;
+  for (; ; ) {
+    if (current instanceof import_zod.z.ZodOptional || current instanceof import_zod.z.ZodNullable || current instanceof import_zod.z.ZodReadonly) {
+      current = current.unwrap();
+      continue;
+    }
+    if (current instanceof import_zod.z.ZodDefault) {
+      current = current.def.innerType;
+      continue;
+    }
+    return current;
+  }
+}
+
+// src/identity.ts
+var import_node_crypto = require("crypto");
+var import_promises = require("fs/promises");
+var import_node_os = require("os");
+var import_node_path = require("path");
+var import_id_agent = require("id-agent");
+var ANALYTICS_USER_ID_PREFIX = "u";
+var ANALYTICS_USER_ID_WORDS = 10;
+var LOCAL_ANALYTICS_ID_PATTERN = /^u_([a-z]+-){9}[a-z]+$/;
+function getAnalyticsIdentityPath(env = process.env, homeDir = (0, import_node_os.homedir)()) {
+  if (env.XDG_DATA_HOME) return (0, import_node_path.join)(env.XDG_DATA_HOME, "agent-qa", "analytics.json");
+  return (0, import_node_path.join)(homeDir, ".agent-qa", "analytics.json");
+}
+function generateAnalyticsUserId() {
+  return (0, import_id_agent.idAgent)({ prefix: ANALYTICS_USER_ID_PREFIX, words: ANALYTICS_USER_ID_WORDS });
+}
+function parseAnalyticsIdentityStore(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const distinctId = value.distinctId;
+  if (typeof distinctId !== "string" || !LOCAL_ANALYTICS_ID_PATTERN.test(distinctId)) return null;
+  return { distinctId, is_internal: value.is_internal === true };
+}
+async function readStore(identityPath) {
+  let data;
+  try {
+    data = await (0, import_promises.readFile)(identityPath, "utf-8");
+  } catch (error) {
+    if (error.code === "ENOENT") return { kind: "missing" };
+    throw error;
+  }
+  try {
+    const record = parseAnalyticsIdentityStore(JSON.parse(data));
+    return record === null ? { kind: "invalid" } : { kind: "valid", record };
+  } catch {
+    return { kind: "invalid" };
+  }
+}
+async function placeNewRecord(identityPath, replace) {
+  await (0, import_promises.mkdir)((0, import_node_path.dirname)(identityPath), { recursive: true });
+  const temp = `${identityPath}.${(0, import_node_crypto.randomUUID)()}.tmp`;
+  const record = {
+    distinctId: generateAnalyticsUserId(),
+    is_internal: false
+  };
+  try {
+    await (0, import_promises.writeFile)(temp, JSON.stringify(record, null, 2), { mode: 384, flag: "wx" });
+    await (0, import_promises.chmod)(temp, 384);
+    if (replace) {
+      await (0, import_promises.rename)(temp, identityPath);
+    } else {
+      await (0, import_promises.link)(temp, identityPath).catch((error) => {
+        if (error.code !== "EEXIST") throw error;
+      });
+    }
+  } finally {
+    await (0, import_promises.rm)(temp, { force: true });
+  }
+}
+async function readAnalyticsIdentity(path) {
+  try {
+    const found = await readStore(path ?? getAnalyticsIdentityPath());
+    return found.kind === "valid" ? found.record : null;
+  } catch {
+    return null;
+  }
+}
+function resolveAnalyticsAgentProduct(env = process.env) {
+  if (env.CLAUDECODE !== void 0 || env.CLAUDE_CODE_ENTRYPOINT !== void 0) return "claude_code";
+  if (env.CURSOR_AGENT !== void 0) return "cursor";
+  if (env.GEMINI_CLI !== void 0) return "gemini_cli";
+  if (env.AUGMENT_AGENT !== void 0) return "augment";
+  if (env.GOOSE_TERMINAL !== void 0 || env.AGENT === "goose") return "goose";
+  if (env.OPENCODE_CLIENT !== void 0) return "opencode";
+  if (env.CODEX_SANDBOX !== void 0) return "codex";
+  if (env.CLINE_ACTIVE !== void 0) return "cline";
+  if (env.AGENT === "amp") return "amp";
+  if (typeof env.AGENT === "string" && env.AGENT.length > 0) return "unknown";
+  return void 0;
+}
+async function resolveAnalyticsIdentity(options = {}) {
+  const env = options.env ?? process.env;
+  const agentProduct = resolveAnalyticsAgentProduct(env);
+  const attribution = agentProduct === void 0 ? {} : { agentProduct };
+  if (options.ci === true) {
+    return { distinctId: "ci_" + (0, import_node_crypto.randomUUID)(), runtimeContext: "ci", ...attribution };
+  }
+  const identityPath = options.identityPath ?? getAnalyticsIdentityPath(env, options.homeDir);
+  const found = await readStore(identityPath);
+  if (found.kind !== "valid") await placeNewRecord(identityPath, found.kind === "invalid");
+  const stored = found.kind === "valid" ? found : await readStore(identityPath);
+  if (stored.kind !== "valid") {
+    throw new Error("the analytics identity store did not hold a valid record");
+  }
+  return {
+    distinctId: stored.record.distinctId,
+    runtimeContext: "user",
+    isInternal: stored.record.is_internal,
+    ...attribution
+  };
+}
+
+// src/run-subscriber.ts
+function emptyStepTally() {
+  return { step_count: 0, passed_step_count: 0, failed_step_count: 0, skipped_step_count: 0 };
+}
+function readString(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function readNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function readIndex(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : void 0;
+}
+function normalizeTriggerSource(value) {
+  return ANALYTICS_TRIGGER_SOURCES.find((candidate) => candidate === value) ?? "unknown";
+}
+function normalizeRunner(value) {
+  return ANALYTICS_RUNNERS.find((candidate) => candidate === value) ?? "unknown";
+}
+function outcomeToAnalyticsStatus(outcome) {
+  switch (outcome) {
+    case "passed":
+    case "healed":
+      return "passed";
+    case "failed":
+    case "timeout":
+      return "failed";
+    case "skipped":
+      return "skipped";
+    case "cancelled":
+      return "cancelled";
+    default:
+      return "unknown";
+  }
+}
+function definedProperties(properties) {
+  const output = {};
+  for (const [key, value] of Object.entries(properties)) {
+    if (value !== void 0) output[key] = value;
+  }
+  return output;
+}
+function createAnalyticsRunSubscriber(options) {
+  const port = options.port;
+  const standard = options.standardProperties ?? {};
+  const triggerSource = normalizeTriggerSource(options.triggerSource);
+  const runner = normalizeRunner(options.runner);
+  let runId;
+  let suiteId;
+  let finished = false;
+  let aggregateVerdict;
+  let sawSuite = false;
+  const members = /* @__PURE__ */ new Map();
+  const liveSteps = /* @__PURE__ */ new Map();
+  function stepTallyFor(testIndex) {
+    let tally = liveSteps.get(testIndex);
+    if (!tally) {
+      tally = emptyStepTally();
+      liveSteps.set(testIndex, tally);
+    }
+    return tally;
+  }
+  function handleTestStarted(payload) {
+    const testIndex = readIndex(payload.testIndex);
+    if (testIndex === void 0) return;
+    const payloadSuiteId = readString(payload.suiteId);
+    if (payloadSuiteId) {
+      sawSuite = true;
+      suiteId = analyticsSuiteId(payloadSuiteId) ?? suiteId;
+    }
+    liveSteps.set(testIndex, emptyStepTally());
+  }
+  function handleStepFinalized(payload) {
+    const testIndex = readIndex(payload.testIndex);
+    if (testIndex === void 0) return;
+    const tally = stepTallyFor(testIndex);
+    tally.step_count += 1;
+    switch (payload.status) {
+      case "passed":
+      case "healed":
+        tally.passed_step_count += 1;
+        break;
+      case "failed":
+      case "cancelled":
+        tally.failed_step_count += 1;
+        break;
+      case "skipped":
+        tally.skipped_step_count += 1;
+        break;
+      default:
+        break;
+    }
+    const usage = payload.tokenUsage;
+    if (usage !== void 0) {
+      const tokens = tally.tokens ?? { input: 0, output: 0, total: 0 };
+      tokens.input += usage.promptTokens;
+      tokens.output += usage.completionTokens;
+      tokens.total += usage.totalTokens;
+      tally.tokens = tokens;
+    }
+  }
+  function handleTestFinished(payload) {
+    const testIndex = readIndex(payload.testIndex);
+    if (testIndex === void 0) return;
+    const steps = liveSteps.get(testIndex) ?? emptyStepTally();
+    members.set(testIndex, {
+      testId: readString(payload.testId),
+      outcome: readString(payload.outcome) ?? "unknown",
+      durationMs: readNumber(payload.durationMs),
+      retryCount: readNumber(payload.retryCount),
+      steps
+    });
+    liveSteps.delete(testIndex);
+  }
+  function captureTestRun(record) {
+    const status = outcomeToAnalyticsStatus(record.outcome);
+    const testId = analyticsTestId(record.testId);
+    const { tokens: _tokens, ...steps } = record.steps;
+    const properties = definedProperties({
+      ...standard,
+      run_id: runId,
+      test_id: testId,
+      trigger_source: triggerSource,
+      runner,
+      status,
+      duration_ms: record.durationMs,
+      retry_count: record.retryCount,
+      is_flaky: record.retryCount !== void 0 ? status === "passed" && record.retryCount > 0 : void 0,
+      ...steps,
+      // 405 D-07. Spread in only when the member measured at least one step. `definedProperties`
+      // would drop three `undefined`s anyway, but building them unconditionally would mean writing
+      // `input_tokens: tokens?.input ?? 0` somewhere — and that `?? 0` is exactly the fabricated
+      // measurement this whole path refuses to make.
+      ...record.steps.tokens === void 0 ? {} : {
+        input_tokens: record.steps.tokens.input,
+        output_tokens: record.steps.tokens.output,
+        total_tokens: record.steps.tokens.total
+      }
+    });
+    port.capture({ name: "agent-qa.test_run.completed", properties });
+  }
+  function captureSuiteRun(records) {
+    const statuses = records.map((record) => outcomeToAnalyticsStatus(record.outcome));
+    const properties = definedProperties({
+      ...standard,
+      run_id: runId,
+      suite_id: suiteId,
+      trigger_source: triggerSource,
+      runner,
+      status: outcomeToAnalyticsStatus(aggregateVerdict),
+      duration_ms: records.reduce((sum, record) => sum + (record.durationMs ?? 0), 0),
+      suite_child_count: records.length,
+      suite_passed_count: statuses.filter((status) => status === "passed").length,
+      suite_failed_count: statuses.filter((status) => status === "failed").length,
+      suite_skipped_count: statuses.filter((status) => status === "skipped").length
+    });
+    port.capture({ name: "agent-qa.suite_run.completed", properties });
+  }
+  return {
+    handler(envelope) {
+      try {
+        runId = analyticsRunId(envelope.runId);
+        switch (envelope.type) {
+          case "testStarted":
+            handleTestStarted(envelope.payload);
+            break;
+          case "stepFinalized":
+            handleStepFinalized(envelope.payload);
+            break;
+          case "testRetryScheduled": {
+            const retryIndex = readIndex(envelope.payload.testIndex);
+            if (retryIndex !== void 0) liveSteps.delete(retryIndex);
+            break;
+          }
+          case "testFinished":
+            handleTestFinished(envelope.payload);
+            break;
+          case "verdict":
+            aggregateVerdict = readString(envelope.payload.verdict) ?? aggregateVerdict;
+            break;
+          case "runFinished":
+            aggregateVerdict = readString(envelope.payload.aggregateVerdict) ?? aggregateVerdict;
+            finished = true;
+            break;
+          default:
+            break;
+        }
+      } catch {
+      }
+    },
+    async flush() {
+      if (!finished) {
+        await port.flush();
+        return;
+      }
+      try {
+        const records = [...members.values()];
+        for (const record of records) captureTestRun(record);
+        if (sawSuite) captureSuiteRun(records);
+      } catch {
+      }
+      await port.flush();
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ANALYTICS_AGENT_PRODUCTS,
+  ANALYTICS_CHAT_END_REASONS,
+  ANALYTICS_DAEMON_JOB_KINDS,
+  ANALYTICS_DAEMON_JOB_OUTCOMES,
+  ANALYTICS_EMITTING_HOSTS,
+  ANALYTICS_EVENT_MEMBERS,
+  ANALYTICS_EVENT_NAMES,
+  ANALYTICS_EVENT_SCHEMA_BY_NAME,
+  ANALYTICS_FAILURE_CATEGORIES,
+  ANALYTICS_INIT_MODES,
+  ANALYTICS_INIT_OUTCOMES,
+  ANALYTICS_KNOWN_ID_MARKER,
+  ANALYTICS_MCP_ERROR_CATEGORIES,
+  ANALYTICS_MCP_SERVER_STATES,
+  ANALYTICS_MCP_TOOL_NAMES,
+  ANALYTICS_MCP_TOOL_STATUSES,
+  ANALYTICS_MCP_TRANSPORTS,
+  ANALYTICS_PLATFORMS,
+  ANALYTICS_RUNNERS,
+  ANALYTICS_RUNTIME_CONTEXTS,
+  ANALYTICS_RUN_STATUSES,
+  ANALYTICS_SUITE_EXECUTION_MODES,
+  ANALYTICS_TRIGGER_SOURCES,
+  ANALYTICS_USER_ID_PREFIX,
+  ANALYTICS_USER_ID_WORDS,
+  ANALYTICS_VOCABULARY_META_KEY,
+  AgentQaAnalyticsEventSchema,
+  RETIRED_V33_EVENT_NAMES,
+  analyticsRunId,
+  analyticsSuiteId,
+  analyticsTestId,
+  assertNoUnconstrainedStrings,
+  composeAnalytics,
+  createAnalyticsPort,
+  createAnalyticsRunSubscriber,
+  createPosthogTransport,
+  generateAnalyticsUserId,
+  getAnalyticsIdentityPath,
+  maskEventForSend,
+  readAnalyticsIdentity,
+  resolveAnalyticsAgentProduct,
+  resolveAnalyticsIdentity
+});
+//# sourceMappingURL=index.cjs.map