githits 0.1.9 → 0.1.11

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   version
-} from "./shared/chunk-ey1zffpv.js";
+} from "./shared/chunk-hyfjv9fg.js";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -616,6 +616,158 @@ function isAreaEnabled(area) {
   return scopes.includes(area) || scopes.includes("*");
 }
 
+// src/shared/request-headers.ts
+import { createHash as createHash2, randomUUID } from "node:crypto";
+var MAX_HEADER_BYTES = 256;
+var SESSION_ENV_VARS = [
+  "TERM_SESSION_ID",
+  "ITERM_SESSION_ID",
+  "WEZTERM_PANE",
+  "KITTY_PID",
+  "ALACRITTY_SOCKET",
+  "WT_SESSION",
+  "VSCODE_PID",
+  "SUPERSET_PANE_ID",
+  "SUPERSET_WORKSPACE_ID",
+  "STARSHIP_SESSION_KEY",
+  "SSH_CONNECTION"
+];
+var cachedSessionId;
+function resolveRawSessionId(env = process.env, ppid = process.ppid) {
+  for (const key of SESSION_ENV_VARS) {
+    const value = env[key];
+    if (value && value.trim().length > 0) {
+      return value.trim();
+    }
+  }
+  if (typeof ppid === "number" && !Number.isNaN(ppid) && ppid > 0) {
+    return String(ppid);
+  }
+  return randomUUID();
+}
+function getSessionId(env, ppid) {
+  if (cachedSessionId !== undefined && env === undefined && ppid === undefined) {
+    return cachedSessionId;
+  }
+  const raw = resolveRawSessionId(env, ppid);
+  const hashed = hashValue(raw);
+  if (env === undefined && ppid === undefined) {
+    cachedSessionId = hashed;
+  }
+  return hashed;
+}
+function hashValue(input) {
+  return createHash2("sha256").update(input).digest("hex").slice(0, 16);
+}
+var AGENT_PROBES = [
+  { envVar: "OPENCODE", name: "opencode" },
+  { envVar: "CLAUDECODE", name: "claude-code" },
+  { envVar: "CURSOR_TRACE_ID", name: "cursor" },
+  { envVar: "WINDSURF_CONFIG_DIR", name: "windsurf" },
+  { envVar: "ZED_TERM", name: "zed" },
+  { envVar: "VSCODE_PID", name: "vscode" }
+];
+function parseAgentString(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0)
+    return;
+  const slashIndex = trimmed.indexOf("/");
+  if (slashIndex === -1)
+    return { name: trimmed };
+  const name = trimmed.slice(0, slashIndex);
+  const ver = trimmed.slice(slashIndex + 1);
+  if (name.length === 0)
+    return;
+  return { name, version: ver || undefined };
+}
+function formatAgentInfo(info) {
+  return info.version ? `${info.name}/${info.version}` : info.name;
+}
+function resolveAgentInfo(env = process.env) {
+  const explicit = env.GITHITS_AGENT;
+  if (explicit && explicit.trim().length > 0) {
+    return parseAgentString(explicit);
+  }
+  for (const probe of AGENT_PROBES) {
+    const value = env[probe.envVar];
+    if (value && value.trim().length > 0) {
+      return { name: probe.name };
+    }
+  }
+  return;
+}
+var currentAgentInfo;
+var agentInfoInitialized = false;
+var agentInfoExplicitlySet = false;
+var mcpClientVersionProvider;
+function setMcpClientVersionProvider(provider) {
+  mcpClientVersionProvider = provider;
+}
+function getAgentInfo(env) {
+  if (agentInfoExplicitlySet) {
+    return currentAgentInfo;
+  }
+  if (mcpClientVersionProvider) {
+    try {
+      const fromProvider = mcpClientVersionProvider();
+      if (fromProvider && fromProvider.name.trim().length > 0) {
+        return fromProvider;
+      }
+    } catch {}
+  }
+  if (!agentInfoInitialized || env !== undefined) {
+    currentAgentInfo = resolveAgentInfo(env);
+    if (env === undefined) {
+      agentInfoInitialized = true;
+    }
+  }
+  return currentAgentInfo;
+}
+var CONTROL_CHARS = /[\x00-\x1f\x7f-\x9f]/g;
+function sanitizeHeaderValue(value) {
+  if (value === undefined || value === null || typeof value !== "string") {
+    return;
+  }
+  const cleaned = value.replace(CONTROL_CHARS, "").trim();
+  if (cleaned.length === 0)
+    return;
+  if (Buffer.byteLength(cleaned, "utf8") > MAX_HEADER_BYTES)
+    return;
+  return cleaned;
+}
+var BASE_CLIENT_NAME = "githits-cli";
+var clientName = BASE_CLIENT_NAME;
+function setClientMode(mode) {
+  clientName = `${BASE_CLIENT_NAME}/${mode}`;
+}
+function buildClientHeaders(env, ppid) {
+  try {
+    const headers = {};
+    const name = sanitizeHeaderValue(clientName);
+    if (name) {
+      headers["x-githits-client-name"] = name;
+    }
+    const clientVersion = sanitizeHeaderValue(version);
+    if (clientVersion) {
+      headers["x-githits-client-version"] = clientVersion;
+    }
+    const agentInfo = getAgentInfo(env);
+    if (agentInfo) {
+      const agentValue = sanitizeHeaderValue(formatAgentInfo(agentInfo));
+      if (agentValue) {
+        headers["x-githits-agent"] = agentValue;
+      }
+    }
+    const sessionId = sanitizeHeaderValue(getSessionId(env, ppid));
+    if (sessionId) {
+      headers["x-githits-session-id"] = sessionId;
+    }
+    return headers;
+  } catch {
+    return {};
+  }
+}
+
 // src/shared/pkgseer-graphql.ts
 class PkgseerTransportError extends Error {
   constructor(message, options) {
@@ -634,6 +786,7 @@ async function postPkgseerGraphql(request) {
     response = await fetchFn(`${baseUrl(request.endpointUrl)}/api/graphql`, {
       method: "POST",
       headers: {
+        ...buildClientHeaders(),
         Authorization: `Bearer ${request.token}`,
         "Content-Type": "application/json",
         "User-Agent": userAgent
@@ -669,6 +822,157 @@ function parseJsonOrNull(body) {
   }
 }
 
+// src/shared/telemetry.ts
+import { writeSync } from "node:fs";
+var ENABLED_VALUES = new Set(["1", "true", "yes", "on"]);
+function isTelemetryEnabled(env = process.env) {
+  const raw = env.GITHITS_TELEMETRY?.trim().toLowerCase();
+  if (!raw)
+    return false;
+  return ENABLED_VALUES.has(raw);
+}
+
+class TelemetryCollector {
+  enabled;
+  now;
+  write;
+  sessionStartMs;
+  spans = [];
+  activeSpans = new Map;
+  nextId = 1;
+  flushed = false;
+  constructor(options = {}) {
+    this.enabled = isTelemetryEnabled(options.env);
+    this.now = options.now ?? (() => globalThis.performance.now());
+    this.write = options.write ?? ((text) => writeSync(process.stderr.fd, text));
+    this.sessionStartMs = this.now();
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  startSpan(name, attributes) {
+    if (!this.enabled)
+      return;
+    const span = {
+      id: this.nextId++,
+      name,
+      startMs: this.now(),
+      attributes: sanitiseAttributes(attributes)
+    };
+    this.spans.push(span);
+    this.activeSpans.set(span.id, span);
+    return { id: span.id };
+  }
+  endSpan(handle, attributes) {
+    if (!this.enabled || !handle)
+      return;
+    const span = this.activeSpans.get(handle.id);
+    if (!span || span.endMs !== undefined)
+      return;
+    span.endMs = this.now();
+    span.attributes = mergeAttributes(span.attributes, attributes);
+    this.activeSpans.delete(handle.id);
+  }
+  flush(exitCode = 0) {
+    if (!this.enabled || this.flushed)
+      return;
+    const nowMs = this.now();
+    for (const span of this.activeSpans.values()) {
+      if (span.endMs !== undefined)
+        continue;
+      span.endMs = nowMs;
+      span.endedAtExit = true;
+    }
+    this.activeSpans.clear();
+    this.write(formatTelemetryReport(this.spans, this.sessionStartMs, nowMs, exitCode));
+    this.flushed = true;
+  }
+}
+async function withTelemetrySpan(name, operation, attributes) {
+  const handle = telemetryCollector.startSpan(name, attributes);
+  try {
+    const result = await operation();
+    telemetryCollector.endSpan(handle);
+    return result;
+  } catch (error) {
+    telemetryCollector.endSpan(handle, { error: true });
+    throw error;
+  }
+}
+function withTelemetrySpanSync(name, operation, attributes) {
+  const handle = telemetryCollector.startSpan(name, attributes);
+  try {
+    const result = operation();
+    telemetryCollector.endSpan(handle);
+    return result;
+  } catch (error) {
+    telemetryCollector.endSpan(handle, { error: true });
+    throw error;
+  }
+}
+function startTelemetrySpan(name, attributes) {
+  return telemetryCollector.startSpan(name, attributes);
+}
+function endTelemetrySpan(handle, attributes) {
+  telemetryCollector.endSpan(handle, attributes);
+}
+function flushTelemetry(exitCode = 0) {
+  telemetryCollector.flush(exitCode);
+}
+var telemetryCollector = new TelemetryCollector;
+function sanitiseAttributes(attributes) {
+  if (!attributes)
+    return;
+  const entries = Object.entries(attributes).filter(([, value]) => value !== undefined);
+  if (entries.length === 0)
+    return;
+  return Object.fromEntries(entries);
+}
+function mergeAttributes(initial, extra) {
+  if (!initial && !extra)
+    return;
+  return sanitiseAttributes({
+    ...initial ?? {},
+    ...extra ?? {}
+  });
+}
+function formatTelemetryReport(spans, sessionStartMs, sessionEndMs, exitCode) {
+  const lines = [
+    "[githits telemetry]",
+    `exit: ${exitCode}`,
+    `total: ${formatMs(sessionEndMs - sessionStartMs)}`
+  ];
+  const orderedSpans = [...spans].sort((left, right) => {
+    if (left.startMs !== right.startMs) {
+      return left.startMs - right.startMs;
+    }
+    return left.id - right.id;
+  });
+  for (const span of orderedSpans) {
+    const endMs = span.endMs ?? sessionEndMs;
+    const details = [`start +${formatMs(span.startMs - sessionStartMs)}`];
+    if (span.endedAtExit) {
+      details.push("ended-at-exit");
+    }
+    const attrs = formatAttributes(span.attributes);
+    if (attrs) {
+      details.push(attrs);
+    }
+    lines.push(`- ${span.name}: ${formatMs(endMs - span.startMs)} (${details.join(", ")})`);
+  }
+  return `${lines.join(`
+`)}
+`;
+}
+function formatAttributes(attributes) {
+  if (!attributes)
+    return "";
+  return Object.entries(attributes).map(([key, value]) => `${key}=${String(value)}`).join(" ");
+}
+function formatMs(value) {
+  return `${value.toFixed(1)}ms`;
+}
+
 // src/services/githits-service.ts
 class AuthenticationError extends Error {
   constructor(message) {
@@ -697,47 +1001,54 @@ class GitHitsServiceImpl {
     this.token = token;
   }
   async search(params) {
-    const response = await fetch(`${this.apiUrl}/search`, {
-      method: "POST",
-      headers: this.headers(),
-      body: JSON.stringify({
-        query: params.query,
-        language: params.language,
-        license_mode: params.licenseMode ?? "strict",
-        include_explanation: params.includeExplanation ?? false
-      })
+    return withTelemetrySpan("githits.search.request", async () => {
+      const response = await fetch(`${this.apiUrl}/search`, {
+        method: "POST",
+        headers: this.headers(),
+        body: JSON.stringify({
+          query: params.query,
+          language: params.language,
+          license_mode: params.licenseMode ?? "strict",
+          include_explanation: params.includeExplanation ?? false
+        })
+      });
+      if (!response.ok) {
+        throw await this.createError(response);
+      }
+      return response.text();
     });
-    if (!response.ok) {
-      throw await this.createError(response);
-    }
-    return response.text();
   }
   async getLanguages() {
-    const response = await fetch(`${this.apiUrl}/languages`, {
-      headers: this.headers()
+    return withTelemetrySpan("githits.languages.request", async () => {
+      const response = await fetch(`${this.apiUrl}/languages`, {
+        headers: this.headers()
+      });
+      if (!response.ok) {
+        throw await this.createError(response);
+      }
+      return response.json();
     });
-    if (!response.ok) {
-      throw await this.createError(response);
-    }
-    return response.json();
   }
   async submitFeedback(params) {
-    const response = await fetch(`${this.apiUrl}/feedbacks`, {
-      method: "POST",
-      headers: this.headers(),
-      body: JSON.stringify({
-        solution_id: params.solutionId,
-        accepted: params.accepted,
-        feedback_text: params.feedbackText ?? null
-      })
+    return withTelemetrySpan("githits.feedback.request", async () => {
+      const response = await fetch(`${this.apiUrl}/feedbacks`, {
+        method: "POST",
+        headers: this.headers(),
+        body: JSON.stringify({
+          solution_id: params.solutionId,
+          accepted: params.accepted,
+          feedback_text: params.feedbackText ?? null
+        })
+      });
+      if (!response.ok) {
+        throw await this.createError(response);
+      }
+      return { success: true, message: "Feedback submitted successfully" };
     });
-    if (!response.ok) {
-      throw await this.createError(response);
-    }
-    return { success: true, message: "Feedback submitted successfully" };
   }
   headers() {
     return {
+      ...buildClientHeaders(),
       Authorization: `Bearer ${this.token}`,
       "Content-Type": "application/json",
       "User-Agent": `githits-cli/${version}`
@@ -962,7 +1273,7 @@ query SearchSymbols(
       hint
     }
     warning
-    indexingStatus
+    codeIndexState
     indexingRef
     availableVersions {
       version
@@ -1005,7 +1316,7 @@ var searchSymbolsResponseSchema = z.object({
     hint: z.string().nullable().optional()
   }).nullable().optional(),
   warning: z.string().nullable().optional(),
-  indexingStatus: z.string(),
+  codeIndexState: z.string(),
   indexingRef: z.string().nullable().optional(),
   availableVersions: z.array(availableVersionSchema).nullable().optional()
 });
@@ -1036,7 +1347,7 @@ var listRepoFilesResponseSchema = z.object({
   indexedVersion: z.string().nullable().optional(),
   resolution: navigationResolutionSchema,
   diagnostics: navigationDiagnosticsSchema,
-  indexingStatus: z.string(),
+  codeIndexState: z.string(),
   indexingRef: z.string().nullable().optional(),
   availableVersions: z.array(availableVersionSchema).nullable().optional()
 });
@@ -1086,7 +1397,7 @@ query ListRepoFiles(
     diagnostics {
       hint
     }
-    indexingStatus
+    codeIndexState
     indexingRef
     availableVersions {
       version
@@ -1104,7 +1415,7 @@ var codeContextResponseSchema = z.object({
   repoUrl: z.string().nullable().optional(),
   gitRef: z.string().nullable().optional(),
   isBinary: z.boolean().nullable().optional(),
-  indexingStatus: z.string(),
+  codeIndexState: z.string(),
   indexingRef: z.string().nullable().optional()
 });
 var fetchCodeContextGraphQLResponseSchema = z.object({
@@ -1145,7 +1456,7 @@ query FetchCodeContext(
     repoUrl
     gitRef
     isBinary
-    indexingStatus
+    codeIndexState
     indexingRef
   }
 }`;
@@ -1165,7 +1476,7 @@ var grepRepoFileResponseSchema = z.object({
   indexedVersion: z.string().nullable().optional(),
   resolution: navigationResolutionSchema,
   diagnostics: navigationDiagnosticsSchema,
-  indexingStatus: z.string(),
+  codeIndexState: z.string(),
   indexingRef: z.string().nullable().optional(),
   availableVersions: z.array(availableVersionSchema).nullable().optional()
 });
@@ -1221,7 +1532,7 @@ query GrepRepoFile(
     diagnostics {
       hint
     }
-    indexingStatus
+    codeIndexState
     indexingRef
     availableVersions {
       version
@@ -1301,13 +1612,13 @@ class CodeNavigationServiceImpl {
     if (!data) {
       throw new MalformedCodeNavigationResponseError("Malformed response from code navigation service.");
     }
-    if (data.indexingStatus === "INDEXING") {
+    if (data.codeIndexState === "INDEXING") {
       throw new CodeNavigationIndexingError(this.createIndexingMessage(data.indexingRef ?? undefined), data.indexingRef ?? undefined, data.availableVersions?.map((entry) => ({
         version: entry.version ?? undefined,
         ref: entry.ref
       })));
     }
-    if (data.indexingStatus === "UNRESOLVABLE") {
+    if (data.codeIndexState === "UNRESOLVABLE") {
       throw new CodeNavigationUnresolvableError("The requested target or version could not be resolved.");
     }
     return {
@@ -1410,7 +1721,7 @@ class CodeNavigationServiceImpl {
     return base;
   }
   throwIfIndexing(data) {
-    if (data.indexingStatus === "INDEXING") {
+    if (data.codeIndexState === "INDEXING") {
       throw new CodeNavigationIndexingError(this.createIndexingMessage(data.indexingRef ?? undefined), data.indexingRef ?? undefined, data.availableVersions?.map((entry) => ({
         version: entry.version ?? undefined,
         ref: entry.ref
@@ -1534,7 +1845,7 @@ class CodeNavigationServiceImpl {
       throw new MalformedCodeNavigationResponseError("Malformed response from code navigation service.");
     }
     this.throwIfIndexing({
-      indexingStatus: data.indexingStatus,
+      codeIndexState: data.codeIndexState,
       indexingRef: data.indexingRef
     });
     return {
@@ -1936,33 +2247,64 @@ class KeyringServiceImpl {
 class MigratingAuthStorage {
   primary;
   legacy;
-  constructor(primary, legacy) {
+  onPrimaryUnavailable;
+  primaryAvailable = true;
+  warnedOnPrimaryFailure = false;
+  constructor(primary, legacy, onPrimaryUnavailable = () => {}) {
     this.primary = primary;
     this.legacy = legacy;
+    this.onPrimaryUnavailable = onPrimaryUnavailable;
   }
   async loadTokens(baseUrl2) {
-    const tokens = await this.primary.loadTokens(baseUrl2);
-    if (tokens)
-      return tokens;
+    if (this.primaryAvailable) {
+      try {
+        const tokens = await this.primary.loadTokens(baseUrl2);
+        if (tokens)
+          return tokens;
+      } catch (error) {
+        if (!this.handlePrimaryFailure(error))
+          throw error;
+      }
+    }
     const legacyTokens = await this.legacy.loadTokens(baseUrl2);
-    if (legacyTokens) {
+    if (!legacyTokens)
+      return null;
+    if (!this.primaryAvailable)
+      return legacyTokens;
+    try {
       await this.primary.saveTokens(baseUrl2, legacyTokens);
-      try {
-        await this.legacy.clearTokens(baseUrl2);
-      } catch {}
+    } catch (error) {
+      if (!this.handlePrimaryFailure(error))
+        throw error;
       return legacyTokens;
     }
-    return null;
+    try {
+      await this.legacy.clearTokens(baseUrl2);
+    } catch {}
+    return legacyTokens;
   }
   async saveTokens(baseUrl2, data) {
-    await this.primary.saveTokens(baseUrl2, data);
+    if (this.primaryAvailable) {
+      try {
+        await this.primary.saveTokens(baseUrl2, data);
+        return;
+      } catch (error) {
+        if (!this.handlePrimaryFailure(error))
+          throw error;
+      }
+    }
+    await this.legacy.saveTokens(baseUrl2, data);
   }
   async clearTokens(baseUrl2) {
     let primaryError;
-    try {
-      await this.primary.clearTokens(baseUrl2);
-    } catch (error) {
-      primaryError = error;
+    if (this.primaryAvailable) {
+      try {
+        await this.primary.clearTokens(baseUrl2);
+      } catch (error) {
+        if (!this.handlePrimaryFailure(error)) {
+          primaryError = error;
+        }
+      }
     }
     try {
       await this.legacy.clearTokens(baseUrl2);
@@ -1971,28 +2313,55 @@ class MigratingAuthStorage {
       throw primaryError;
   }
   async loadClient(baseUrl2) {
-    const client = await this.primary.loadClient(baseUrl2);
-    if (client)
-      return client;
+    if (this.primaryAvailable) {
+      try {
+        const client = await this.primary.loadClient(baseUrl2);
+        if (client)
+          return client;
+      } catch (error) {
+        if (!this.handlePrimaryFailure(error))
+          throw error;
+      }
+    }
     const legacyClient = await this.legacy.loadClient(baseUrl2);
-    if (legacyClient) {
+    if (!legacyClient)
+      return null;
+    if (!this.primaryAvailable)
+      return legacyClient;
+    try {
       await this.primary.saveClient(baseUrl2, legacyClient);
-      try {
-        await this.legacy.clearClient(baseUrl2);
-      } catch {}
+    } catch (error) {
+      if (!this.handlePrimaryFailure(error))
+        throw error;
       return legacyClient;
     }
-    return null;
+    try {
+      await this.legacy.clearClient(baseUrl2);
+    } catch {}
+    return legacyClient;
   }
   async saveClient(baseUrl2, data) {
-    await this.primary.saveClient(baseUrl2, data);
+    if (this.primaryAvailable) {
+      try {
+        await this.primary.saveClient(baseUrl2, data);
+        return;
+      } catch (error) {
+        if (!this.handlePrimaryFailure(error))
+          throw error;
+      }
+    }
+    await this.legacy.saveClient(baseUrl2, data);
   }
   async clearClient(baseUrl2) {
     let primaryError;
-    try {
-      await this.primary.clearClient(baseUrl2);
-    } catch (error) {
-      primaryError = error;
+    if (this.primaryAvailable) {
+      try {
+        await this.primary.clearClient(baseUrl2);
+      } catch (error) {
+        if (!this.handlePrimaryFailure(error)) {
+          primaryError = error;
+        }
+      }
     }
     try {
       await this.legacy.clearClient(baseUrl2);
@@ -2001,7 +2370,18 @@ class MigratingAuthStorage {
       throw primaryError;
   }
   getStorageLocation() {
-    return this.primary.getStorageLocation();
+    return this.primaryAvailable ? this.primary.getStorageLocation() : this.legacy.getStorageLocation();
+  }
+  handlePrimaryFailure(error) {
+    if (!(error instanceof KeychainUnavailableError)) {
+      return false;
+    }
+    this.primaryAvailable = false;
+    if (!this.warnedOnPrimaryFailure) {
+      this.warnedOnPrimaryFailure = true;
+      this.onPrimaryUnavailable(error);
+    }
+    return true;
   }
 }
 // src/services/package-intelligence-service.ts
@@ -2302,13 +2682,50 @@ var directDependencySchema = z2.object({
   versionConstraint: z2.string().nullable().optional(),
   type: z2.string().nullable().optional()
 });
+var dependencyGraphNodeSchema = z2.object({
+  registry: z2.string(),
+  name: z2.string(),
+  version: z2.string().nullable().optional()
+});
+var dependencyGraphEdgeSchema = z2.object({
+  fromIndex: z2.number().int().nullable().optional(),
+  toIndex: z2.number().int(),
+  constraint: z2.string().nullable().optional(),
+  dependencyType: z2.string().nullable().optional()
+});
+var dependencyGraphSchema = z2.object({
+  formatVersion: z2.number().int(),
+  nodes: z2.array(dependencyGraphNodeSchema),
+  edges: z2.array(dependencyGraphEdgeSchema)
+});
+var dependencyConflictEdgeSchema = z2.object({
+  fromIndex: z2.number().int().nullable().optional(),
+  toIndex: z2.number().int(),
+  versionConstraint: z2.string(),
+  dependencyType: z2.string()
+});
+var dependencyConflictSchema = z2.object({
+  packageName: z2.string(),
+  requiredVersions: z2.array(z2.string()),
+  conflictingEdges: z2.array(dependencyConflictEdgeSchema)
+});
+var circularDependencyCycleSchema = z2.object({
+  cycleStart: z2.string(),
+  circularPath: z2.array(z2.string()),
+  displayChain: z2.string()
+});
+var environmentMarkerSchema = z2.object({
+  type: z2.string().nullable().optional(),
+  value: z2.string().nullable().optional(),
+  raw: z2.string().nullable().optional()
+});
 var transitiveDependencySchema = z2.object({
   totalEdges: z2.number().int().nullable().optional(),
   uniquePackagesCount: z2.number().int().nullable().optional(),
   uniqueDependencies: z2.array(z2.string()).nullable().optional(),
-  conflicts: z2.array(z2.unknown()).nullable().optional(),
-  circularDependencies: z2.array(z2.unknown()).nullable().optional(),
-  dag: z2.unknown().nullable().optional()
+  dependencyConflicts: z2.array(dependencyConflictSchema).nullable().optional(),
+  circularDependencyCycles: z2.array(circularDependencyCycleSchema).nullable().optional(),
+  dependencyGraph: dependencyGraphSchema.nullable().optional()
 }).nullable().optional();
 var dependencyBundleSchema = z2.object({
   direct: z2.array(directDependencySchema).nullable().optional(),
@@ -2332,7 +2749,7 @@ var dependencyGroupSchema = z2.object({
 });
 var dependencyGroupsInfoSchema = z2.object({
   primaryGroup: z2.string().nullable().optional(),
-  environmentConstraints: z2.array(z2.unknown()).nullable().optional(),
+  environmentMarkers: z2.array(environmentMarkerSchema).nullable().optional(),
   groups: z2.array(dependencyGroupSchema)
 }).nullable().optional();
 var dependencyReportResponseSchema = z2.object({
@@ -2382,14 +2799,44 @@ query PackageDependencies(
         totalEdges
         uniquePackagesCount
         uniqueDependencies
-        conflicts
-        circularDependencies
-        dag
+        dependencyConflicts {
+          packageName
+          requiredVersions
+          conflictingEdges {
+            fromIndex
+            toIndex
+            versionConstraint
+            dependencyType
+          }
+        }
+        circularDependencyCycles {
+          cycleStart
+          circularPath
+          displayChain
+        }
+        dependencyGraph {
+          formatVersion
+          nodes {
+            registry
+            name
+            version
+          }
+          edges {
+            fromIndex
+            toIndex
+            constraint
+            dependencyType
+          }
+        }
       }
     }
     dependencyGroups {
       primaryGroup
-      environmentConstraints
+      environmentMarkers {
+        type
+        value
+        raw
+      }
       groups {
         name
         lifecycle
@@ -2484,12 +2931,12 @@ class PackageIntelligenceServiceImpl {
     this.fetchFn = fetchFn;
   }
   async packageSummary(params) {
-    return executeWithTokenRefresh({
+    return withTelemetrySpan("pkg-intel.summary.request", () => executeWithTokenRefresh({
       getToken: () => this.tokenProvider.getToken(),
       forceRefresh: () => this.tokenProvider.forceRefresh(),
       shouldRefresh: (error) => error instanceof AuthenticationError,
       executeWithToken: (token) => this.executePackageSummary(token, params)
-    });
+    }));
   }
   async executePackageSummary(token, params) {
     let response;
@@ -2627,12 +3074,12 @@ class PackageIntelligenceServiceImpl {
     };
   }
   async packageVulnerabilities(params) {
-    return executeWithTokenRefresh({
+    return withTelemetrySpan("pkg-intel.vulnerabilities.request", () => executeWithTokenRefresh({
       getToken: () => this.tokenProvider.getToken(),
       forceRefresh: () => this.tokenProvider.forceRefresh(),
       shouldRefresh: (error) => error instanceof AuthenticationError,
       executeWithToken: (token) => this.executePackageVulnerabilities(token, params)
-    });
+    }));
   }
   async executePackageVulnerabilities(token, params) {
     let response;
@@ -2707,12 +3154,12 @@ class PackageIntelligenceServiceImpl {
     };
   }
   async packageDependencies(params) {
-    return executeWithTokenRefresh({
+    return withTelemetrySpan("pkg-intel.dependencies.request", () => executeWithTokenRefresh({
       getToken: () => this.tokenProvider.getToken(),
       forceRefresh: () => this.tokenProvider.forceRefresh(),
       shouldRefresh: (error) => error instanceof AuthenticationError,
       executeWithToken: (token) => this.executePackageDependencies(token, params)
-    });
+    }));
   }
   async executePackageDependencies(token, params) {
     let response;
@@ -2780,14 +3227,44 @@ class PackageIntelligenceServiceImpl {
         totalEdges: bundle.transitive.totalEdges ?? undefined,
         uniquePackagesCount: bundle.transitive.uniquePackagesCount ?? undefined,
         uniqueDependencies: bundle.transitive.uniqueDependencies ?? undefined,
-        conflicts: bundle.transitive.conflicts ?? undefined,
-        circularDependencies: bundle.transitive.circularDependencies ?? undefined,
-        dag: bundle.transitive.dag ?? undefined
+        dependencyConflicts: bundle.transitive.dependencyConflicts?.map((c) => ({
+          packageName: c.packageName,
+          requiredVersions: c.requiredVersions,
+          conflictingEdges: c.conflictingEdges.map((edge) => ({
+            fromIndex: edge.fromIndex ?? undefined,
+            toIndex: edge.toIndex,
+            versionConstraint: edge.versionConstraint,
+            dependencyType: edge.dependencyType
+          }))
+        })) ?? undefined,
+        circularDependencyCycles: bundle.transitive.circularDependencyCycles?.map((cycle) => ({
+          cycleStart: cycle.cycleStart,
+          circularPath: cycle.circularPath,
+          displayChain: cycle.displayChain
+        })) ?? undefined,
+        dependencyGraph: bundle.transitive.dependencyGraph ? {
+          formatVersion: bundle.transitive.dependencyGraph.formatVersion,
+          nodes: bundle.transitive.dependencyGraph.nodes.map((n) => ({
+            registry: n.registry,
+            name: n.name,
+            version: n.version ?? undefined
+          })),
+          edges: bundle.transitive.dependencyGraph.edges.map((e) => ({
+            fromIndex: e.fromIndex ?? undefined,
+            toIndex: e.toIndex,
+            constraint: e.constraint ?? undefined,
+            dependencyType: e.dependencyType ?? undefined
+          }))
+        } : undefined
       } : undefined
     } : undefined;
     const dependencyGroups = data.dependencyGroups ? {
       primaryGroup: data.dependencyGroups.primaryGroup ?? undefined,
-      environmentConstraints: data.dependencyGroups.environmentConstraints ?? undefined,
+      environmentMarkers: data.dependencyGroups.environmentMarkers?.map((m) => ({
+        type: m.type ?? undefined,
+        value: m.value ?? undefined,
+        raw: m.raw ?? undefined
+      })) ?? undefined,
       groups: data.dependencyGroups.groups.map((group) => ({
         name: group.name,
         lifecycle: group.lifecycle,
@@ -2811,12 +3288,12 @@ class PackageIntelligenceServiceImpl {
     };
   }
   async packageChangelog(params) {
-    return executeWithTokenRefresh({
+    return withTelemetrySpan("pkg-intel.changelog.request", () => executeWithTokenRefresh({
       getToken: () => this.tokenProvider.getToken(),
       forceRefresh: () => this.tokenProvider.forceRefresh(),
       shouldRefresh: (error) => error instanceof AuthenticationError,
       executeWithToken: (token) => this.executePackageChangelog(token, params)
-    });
+    }));
   }
   async executePackageChangelog(token, params) {
     let response;
@@ -3010,27 +3487,29 @@ class TokenManager {
     this.mcpUrl = deps.mcpUrl;
   }
   async getToken() {
-    if (!this.cachedToken) {
-      this.cachedToken = await this.authStorage.loadTokens(this.mcpUrl);
-      if (!this.cachedToken)
-        return;
-    }
-    const currentToken = this.cachedToken.accessToken;
-    const { expired, shouldRefresh } = shouldRefreshToken(this.cachedToken, PROACTIVE_REFRESH_RATIO, new Date);
-    if (!shouldRefresh) {
-      return currentToken;
-    }
-    const refreshedToken = await this.doRefresh();
-    if (refreshedToken) {
-      return refreshedToken;
-    }
-    if (!expired) {
-      return currentToken;
-    }
-    return;
+    return withTelemetrySpan("token-manager.get-token", async () => {
+      if (!this.cachedToken) {
+        this.cachedToken = await withTelemetrySpan("token-manager.load-tokens", () => this.authStorage.loadTokens(this.mcpUrl));
+        if (!this.cachedToken)
+          return;
+      }
+      const currentToken = this.cachedToken.accessToken;
+      const { expired, shouldRefresh } = shouldRefreshToken(this.cachedToken, PROACTIVE_REFRESH_RATIO, new Date);
+      if (!shouldRefresh) {
+        return currentToken;
+      }
+      const refreshedToken = await this.doRefresh();
+      if (refreshedToken) {
+        return refreshedToken;
+      }
+      if (!expired) {
+        return currentToken;
+      }
+      return;
+    });
   }
   async forceRefresh() {
-    return this.doRefresh();
+    return withTelemetrySpan("token-manager.force-refresh", () => this.doRefresh());
   }
   async doRefresh() {
     if (this.refreshPromise) {
@@ -3044,59 +3523,55 @@ class TokenManager {
     }
   }
   async executeRefresh() {
-    const tokens = this.cachedToken ?? await this.authStorage.loadTokens(this.mcpUrl);
-    if (!tokens)
-      return;
-    const client = await this.authStorage.loadClient(this.mcpUrl);
-    if (!client)
-      return;
-    let response;
-    try {
-      const metadata = await this.authService.discoverEndpoints(this.mcpUrl);
-      response = await this.authService.refreshAccessToken({
-        tokenEndpoint: metadata.tokenEndpoint,
-        clientId: client.clientId,
-        clientSecret: client.clientSecret,
-        refreshToken: tokens.refreshToken
-      });
-    } catch {
-      const isExpired = tokens.expiresAt ? new Date >= new Date(tokens.expiresAt) : false;
-      if (isExpired) {
-        this.cachedToken = null;
-        await this.authStorage.clearTokens(this.mcpUrl);
+    return withTelemetrySpan("token-manager.refresh", async () => {
+      const tokens = this.cachedToken ?? await withTelemetrySpan("token-manager.load-tokens", () => this.authStorage.loadTokens(this.mcpUrl));
+      if (!tokens)
+        return;
+      const client = await withTelemetrySpan("token-manager.load-client", () => this.authStorage.loadClient(this.mcpUrl));
+      if (!client)
+        return;
+      let response;
+      try {
+        const metadata = await withTelemetrySpan("token-manager.discover-endpoints", () => this.authService.discoverEndpoints(this.mcpUrl));
+        response = await withTelemetrySpan("token-manager.refresh-access-token", () => this.authService.refreshAccessToken({
+          tokenEndpoint: metadata.tokenEndpoint,
+          clientId: client.clientId,
+          clientSecret: client.clientSecret,
+          refreshToken: tokens.refreshToken
+        }));
+      } catch {
+        const isExpired = tokens.expiresAt ? new Date >= new Date(tokens.expiresAt) : false;
+        if (isExpired) {
+          this.cachedToken = null;
+          await withTelemetrySpan("token-manager.clear-tokens", () => this.authStorage.clearTokens(this.mcpUrl));
+        }
+        return;
       }
-      return;
-    }
-    const newTokenData = {
-      accessToken: response.accessToken,
-      refreshToken: response.refreshToken,
-      expiresAt: new Date(Date.now() + response.expiresIn * 1000).toISOString(),
-      createdAt: tokens.createdAt
-    };
-    await this.authStorage.saveTokens(this.mcpUrl, newTokenData);
-    this.cachedToken = newTokenData;
-    return response.accessToken;
+      const newTokenData = {
+        accessToken: response.accessToken,
+        refreshToken: response.refreshToken,
+        expiresAt: new Date(Date.now() + response.expiresIn * 1000).toISOString(),
+        createdAt: new Date().toISOString()
+      };
+      await withTelemetrySpan("token-manager.save-tokens", () => this.authStorage.saveTokens(this.mcpUrl, newTokenData));
+      this.cachedToken = newTokenData;
+      return response.accessToken;
+    });
   }
 }
 // src/container.ts
 function createAuthStorage(fileSystemService) {
-  const fileStorage = new AuthStorageImpl(fileSystemService);
-  try {
+  return withTelemetrySpanSync("container.create-auth-storage", () => {
+    const fileStorage = new AuthStorageImpl(fileSystemService);
     const rawKeyring = new KeyringServiceImpl;
     const keyring = process.platform === "win32" ? new ChunkingKeyringService(rawKeyring, WINDOWS_MAX_ENTRY_SIZE) : rawKeyring;
-    const probeKey = `__probe_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-    keyring.setPassword("githits", probeKey, "probe");
-    try {
-      keyring.deletePassword("githits", probeKey);
-    } catch {}
     const keychainStorage = new KeychainAuthStorage(keyring);
-    return new MigratingAuthStorage(keychainStorage, fileStorage);
-  } catch (error) {
-    if (!(error instanceof KeychainUnavailableError))
-      throw error;
-    console.error("Warning: System keychain unavailable. Falling back to file-based credential storage.");
-    return fileStorage;
-  }
+    return new MigratingAuthStorage(keychainStorage, fileStorage, (error) => {
+      if (!(error instanceof KeychainUnavailableError))
+        return;
+      console.error("Warning: System keychain unavailable. Falling back to file-based credential storage.");
+    });
+  });
 }
 function createStaticTokenProvider(token) {
   return {
@@ -3107,19 +3582,42 @@ function createStaticTokenProvider(token) {
   };
 }
 async function createContainer() {
-  const mcpUrl = getMcpUrl();
-  const apiUrl = getApiUrl();
-  const codeNavigationUrl = getCodeNavigationUrl();
-  const codeNavigationCliOverrideEnabled = isCodeNavigationCliOverrideEnabled();
-  const fileSystemService = new FileSystemServiceImpl;
-  const authStorage = createAuthStorage(fileSystemService);
-  const authService = new AuthServiceImpl;
-  const browserService = new BrowserServiceImpl;
-  const envToken = getEnvApiToken();
-  if (envToken) {
-    const tokenProvider = createStaticTokenProvider(envToken);
-    const codeNavigationService2 = codeNavigationUrl ? new CodeNavigationServiceImpl(codeNavigationUrl, tokenProvider) : undefined;
-    const packageIntelligenceService2 = codeNavigationUrl ? new PackageIntelligenceServiceImpl(codeNavigationUrl, tokenProvider) : undefined;
+  return withTelemetrySpan("container.create", async () => {
+    const mcpUrl = getMcpUrl();
+    const apiUrl = getApiUrl();
+    const codeNavigationUrl = getCodeNavigationUrl();
+    const codeNavigationCliOverrideEnabled = isCodeNavigationCliOverrideEnabled();
+    const fileSystemService = new FileSystemServiceImpl;
+    const authStorage = createAuthStorage(fileSystemService);
+    const authService = new AuthServiceImpl;
+    const browserService = new BrowserServiceImpl;
+    const envToken = getEnvApiToken();
+    if (envToken) {
+      const tokenProvider = createStaticTokenProvider(envToken);
+      const codeNavigationService2 = codeNavigationUrl ? new CodeNavigationServiceImpl(codeNavigationUrl, tokenProvider) : undefined;
+      const packageIntelligenceService2 = codeNavigationUrl ? new PackageIntelligenceServiceImpl(codeNavigationUrl, tokenProvider) : undefined;
+      return {
+        authStorage,
+        authService,
+        browserService,
+        fileSystemService,
+        mcpUrl,
+        apiUrl,
+        apiToken: envToken,
+        hasValidToken: true,
+        envApiToken: envToken,
+        codeNavigationCapability: getCodeNavigationCapability(envToken),
+        codeNavigationCliOverrideEnabled,
+        codeNavigationUrl,
+        codeNavigationService: codeNavigationService2,
+        packageIntelligenceService: packageIntelligenceService2,
+        githitsService: new GitHitsServiceImpl(apiUrl, envToken)
+      };
+    }
+    const tokenManager = new TokenManager({ authService, authStorage, mcpUrl });
+    const apiToken = await withTelemetrySpan("container.token.get", () => tokenManager.getToken());
+    const codeNavigationService = codeNavigationUrl ? new CodeNavigationServiceImpl(codeNavigationUrl, tokenManager) : undefined;
+    const packageIntelligenceService = codeNavigationUrl ? new PackageIntelligenceServiceImpl(codeNavigationUrl, tokenManager) : undefined;
     return {
       authStorage,
       authService,
@@ -3127,73 +3625,56 @@ async function createContainer() {
       fileSystemService,
       mcpUrl,
       apiUrl,
-      apiToken: envToken,
-      hasValidToken: true,
-      envApiToken: envToken,
-      codeNavigationCapability: getCodeNavigationCapability(envToken),
+      apiToken,
+      hasValidToken: apiToken !== undefined,
+      envApiToken: undefined,
+      codeNavigationCapability: getCodeNavigationCapability(apiToken),
       codeNavigationCliOverrideEnabled,
       codeNavigationUrl,
-      codeNavigationService: codeNavigationService2,
-      packageIntelligenceService: packageIntelligenceService2,
-      githitsService: new GitHitsServiceImpl(apiUrl, envToken)
+      codeNavigationService,
+      packageIntelligenceService,
+      githitsService: new RefreshingGitHitsService(apiUrl, tokenManager)
     };
-  }
-  const tokenManager = new TokenManager({ authService, authStorage, mcpUrl });
-  const apiToken = await tokenManager.getToken();
-  const codeNavigationService = codeNavigationUrl ? new CodeNavigationServiceImpl(codeNavigationUrl, tokenManager) : undefined;
-  const packageIntelligenceService = codeNavigationUrl ? new PackageIntelligenceServiceImpl(codeNavigationUrl, tokenManager) : undefined;
-  return {
-    authStorage,
-    authService,
-    browserService,
-    fileSystemService,
-    mcpUrl,
-    apiUrl,
-    apiToken,
-    hasValidToken: apiToken !== undefined,
-    envApiToken: undefined,
-    codeNavigationCapability: getCodeNavigationCapability(apiToken),
-    codeNavigationCliOverrideEnabled,
-    codeNavigationUrl,
-    codeNavigationService,
-    packageIntelligenceService,
-    githitsService: new RefreshingGitHitsService(apiUrl, tokenManager)
-  };
+  });
 }
 async function resolveStartupCodeNavigationRegistrationState() {
-  const envToken = getEnvApiToken();
-  if (envToken) {
+  return withTelemetrySpan("startup.resolve-code-nav-registration-state", async () => {
+    const envToken = getEnvApiToken();
+    if (envToken) {
+      return {
+        capability: getCodeNavigationCapability(envToken),
+        expiredStoredAuth: false
+      };
+    }
+    const tokens = await loadStartupTokens(getMcpUrl());
+    if (tokens?.expiresAt && new Date(tokens.expiresAt) < new Date) {
+      return { capability: "unknown", expiredStoredAuth: true };
+    }
     return {
-      capability: getCodeNavigationCapability(envToken),
+      capability: getCodeNavigationCapability(tokens?.accessToken),
       expiredStoredAuth: false
     };
-  }
-  const tokens = await loadStartupTokens(getMcpUrl());
-  if (tokens?.expiresAt && new Date(tokens.expiresAt) < new Date) {
-    return { capability: "unknown", expiredStoredAuth: true };
-  }
-  return {
-    capability: getCodeNavigationCapability(tokens?.accessToken),
-    expiredStoredAuth: false
-  };
+  });
 }
 async function loadStartupTokens(mcpUrl) {
-  const fileSystemService = new FileSystemServiceImpl;
-  const fileStorage = new AuthStorageImpl(fileSystemService);
-  try {
-    const rawKeyring = new KeyringServiceImpl;
-    const keyring = process.platform === "win32" ? new ChunkingKeyringService(rawKeyring, WINDOWS_MAX_ENTRY_SIZE) : rawKeyring;
-    const keychainStorage = new KeychainAuthStorage(keyring);
-    const keychainTokens = await keychainStorage.loadTokens(mcpUrl);
-    if (keychainTokens) {
-      return keychainTokens;
-    }
-  } catch (error) {
-    if (!(error instanceof KeychainUnavailableError)) {
-      throw error;
+  return withTelemetrySpan("startup.load-tokens", async () => {
+    const fileSystemService = new FileSystemServiceImpl;
+    const fileStorage = new AuthStorageImpl(fileSystemService);
+    try {
+      const rawKeyring = new KeyringServiceImpl;
+      const keyring = process.platform === "win32" ? new ChunkingKeyringService(rawKeyring, WINDOWS_MAX_ENTRY_SIZE) : rawKeyring;
+      const keychainStorage = new KeychainAuthStorage(keyring);
+      const keychainTokens = await keychainStorage.loadTokens(mcpUrl);
+      if (keychainTokens) {
+        return keychainTokens;
+      }
+    } catch (error) {
+      if (!(error instanceof KeychainUnavailableError)) {
+        throw error;
+      }
     }
-  }
-  return fileStorage.loadTokens(mcpUrl);
+    return fileStorage.loadTokens(mcpUrl);
+  });
 }
 
 // src/commands/auth-status.ts
@@ -3813,8 +4294,8 @@ function buildPackageDependenciesSuccessPayload(report, options = {}) {
     payload.requestedVersion = requestedEcho;
   }
   const bundle = report.dependencies;
-  const decodedDagForResolution = decodeDag(bundle?.transitive?.dag);
-  const directVersionByName = decodedDagForResolution ? buildDirectVersionLookup(decodedDagForResolution) : null;
+  const graph = bundle?.transitive?.dependencyGraph ?? null;
+  const directVersionByName = graph ? buildDirectVersionLookup(graph) : null;
   const directArray = bundle?.direct;
   if (directArray !== undefined) {
     const items = directArray.map((entry) => buildDirect(entry, directVersionByName));
@@ -3827,8 +4308,8 @@ function buildPackageDependenciesSuccessPayload(report, options = {}) {
     if (groupsInfo.primaryGroup) {
       groupsBlock.primaryGroup = groupsInfo.primaryGroup;
     }
-    if (groupsInfo.environmentConstraints && groupsInfo.environmentConstraints.length > 0) {
-      groupsBlock.environmentConstraints = groupsInfo.environmentConstraints.slice();
+    if (groupsInfo.environmentMarkers && groupsInfo.environmentMarkers.length > 0) {
+      groupsBlock.environmentMarkers = groupsInfo.environmentMarkers.map((m) => projectEnvironmentMarker(m));
     }
     payload.groups = groupsBlock;
   }
@@ -3845,15 +4326,18 @@ function buildPackageDependenciesSuccessPayload(report, options = {}) {
       if (options.maxDepth !== undefined) {
         block.depth = options.maxDepth;
       }
-      const packages = buildTransitivePackages(transitive.uniqueDependencies, decodedDagForResolution, options.includeImporters ?? false);
+      const packages = buildTransitivePackages(transitive.uniqueDependencies, graph, options.includeImporters ?? false);
       if (packages && packages.length > 0) {
         block.packages = packages;
       }
-      if (transitive.conflicts && transitive.conflicts.length > 0) {
-        block.conflicts = buildTypedConflicts(transitive.conflicts);
+      if (transitive.dependencyConflicts && transitive.dependencyConflicts.length > 0) {
+        block.conflicts = transitive.dependencyConflicts.map((c) => ({
+          name: c.packageName,
+          requiredVersions: c.requiredVersions.slice().sort()
+        }));
       }
-      if (transitive.circularDependencies && transitive.circularDependencies.length > 0) {
-        block.circularDependencies = buildTypedCycles(transitive.circularDependencies);
+      if (transitive.circularDependencyCycles && transitive.circularDependencyCycles.length > 0) {
+        block.circularDependencies = transitive.circularDependencyCycles.map((c) => ({ cycle: c.circularPath.slice() }));
       }
       payload.transitive = block;
     }
@@ -3863,6 +4347,16 @@ function buildPackageDependenciesSuccessPayload(report, options = {}) {
   }
   return payload;
 }
+function projectEnvironmentMarker(marker) {
+  const out = {};
+  if (marker.type !== undefined)
+    out.type = marker.type;
+  if (marker.value !== undefined)
+    out.value = marker.value;
+  if (marker.raw !== undefined)
+    out.raw = marker.raw;
+  return out;
+}
 function buildDirect(entry, directVersionByName) {
   const lean = { name: entry.name };
   if (entry.versionConstraint)
@@ -3872,15 +4366,14 @@ function buildDirect(entry, directVersionByName) {
     lean.version = resolved;
   return lean;
 }
-function buildDirectVersionLookup(dag) {
-  const rootIdx = findRootNodeIdx(dag);
-  if (rootIdx === null)
-    return null;
+function buildDirectVersionLookup(graph) {
+  const rootIdx = findRootNodeIdx(graph);
   const out = new Map;
-  for (const edge of dag.edges) {
-    if (edge.fromIdx !== rootIdx)
+  for (const edge of graph.edges) {
+    const fromRoot = edge.fromIndex === undefined || edge.fromIndex === null || edge.fromIndex === rootIdx;
+    if (!fromRoot)
       continue;
-    const node = dag.nodes[edge.toIdx];
+    const node = graph.nodes[edge.toIndex];
     if (!node || !node.version)
       continue;
     if (!out.has(node.name)) {
@@ -3889,12 +4382,12 @@ function buildDirectVersionLookup(dag) {
   }
   return out.size > 0 ? out : null;
 }
-function findRootNodeIdx(dag) {
+function findRootNodeIdx(graph) {
   const incoming = new Set;
-  for (const e of dag.edges)
-    incoming.add(e.toIdx);
+  for (const e of graph.edges)
+    incoming.add(e.toIndex);
   let root = null;
-  for (let i = 0;i < dag.nodes.length; i++) {
+  for (let i = 0;i < graph.nodes.length; i++) {
     if (!incoming.has(i)) {
       if (root !== null)
         return null;
@@ -3903,10 +4396,10 @@ function findRootNodeIdx(dag) {
   }
   return root;
 }
-function buildTransitivePackages(uniqueDependencies, dag, includeImporters) {
+function buildTransitivePackages(uniqueDependencies, graph, includeImporters) {
   if (!uniqueDependencies || uniqueDependencies.length === 0)
     return null;
-  const incoming = includeImporters && dag ? buildIncomingEdgeMap(dag) : null;
+  const incoming = includeImporters && graph ? buildIncomingEdgeMap(graph) : null;
   const out = [];
   for (const entry of uniqueDependencies) {
     const [name, version2] = parseNameAtVersion(entry);
@@ -3915,11 +4408,11 @@ function buildTransitivePackages(uniqueDependencies, dag, includeImporters) {
     const record = { name };
     if (version2)
       record.version = version2;
-    if (includeImporters && dag && incoming) {
-      const nodeIdx = findNodeIdx(dag, name, version2);
+    if (includeImporters && graph && incoming) {
+      const nodeIdx = findNodeIdx(graph, name, version2);
       if (nodeIdx !== null) {
         const edges = incoming.get(nodeIdx) ?? [];
-        const importers = buildImportersFromEdges(dag, edges);
+        const importers = buildImportersFromEdges(graph, edges);
         if (importers.length > 0)
           record.importers = importers;
       }
@@ -3937,21 +4430,21 @@ function parseNameAtVersion(raw) {
     return [trimmed, undefined];
   return [trimmed.slice(0, atIdx), trimmed.slice(atIdx + 1)];
 }
-function buildIncomingEdgeMap(dag) {
+function buildIncomingEdgeMap(graph) {
   const map = new Map;
-  for (const edge of dag.edges) {
-    const list = map.get(edge.toIdx);
+  for (const edge of graph.edges) {
+    const list = map.get(edge.toIndex);
     if (list)
       list.push(edge);
     else
-      map.set(edge.toIdx, [edge]);
+      map.set(edge.toIndex, [edge]);
   }
   return map;
 }
-function findNodeIdx(dag, name, version2) {
+function findNodeIdx(graph, name, version2) {
   let fallback = null;
-  for (let i = 0;i < dag.nodes.length; i++) {
-    const n = dag.nodes[i];
+  for (let i = 0;i < graph.nodes.length; i++) {
+    const n = graph.nodes[i];
     if (!n)
       continue;
     if (n.name !== name)
@@ -3965,11 +4458,13 @@ function findNodeIdx(dag, name, version2) {
   }
   return fallback;
 }
-function buildImportersFromEdges(dag, edges) {
+function buildImportersFromEdges(graph, edges) {
   const seen = new Set;
   const out = [];
   for (const edge of edges) {
-    const from = dag.nodes[edge.fromIdx];
+    if (edge.fromIndex === undefined || edge.fromIndex === null)
+      continue;
+    const from = graph.nodes[edge.fromIndex];
     if (!from)
       continue;
     const key = `${from.name}\x00${from.version ?? ""}\x00${edge.constraint ?? ""}`;
@@ -3996,60 +4491,6 @@ function buildImportersFromEdges(dag, edges) {
   });
   return out;
 }
-function buildTypedConflicts(raw) {
-  const typed = [];
-  for (const entry of raw) {
-    const decoded = decodeConflictEntryForEnvelope(entry);
-    if (!decoded)
-      return raw.slice();
-    typed.push(decoded);
-  }
-  return typed;
-}
-function decodeConflictEntryForEnvelope(raw) {
-  if (!raw || typeof raw !== "object")
-    return null;
-  const obj = raw;
-  const name = typeof obj.package_name === "string" ? obj.package_name : typeof obj.packageName === "string" ? obj.packageName : null;
-  if (!name)
-    return null;
-  const rangesRaw = obj.required_versions ?? obj.requiredVersions;
-  if (!Array.isArray(rangesRaw))
-    return null;
-  const ranges = [];
-  for (const r of rangesRaw) {
-    if (typeof r === "string" && r.length > 0 && !ranges.includes(r)) {
-      ranges.push(r);
-    }
-  }
-  if (ranges.length === 0)
-    return null;
-  ranges.sort();
-  return { name, requiredVersions: ranges };
-}
-function buildTypedCycles(raw) {
-  const typed = [];
-  for (const entry of raw) {
-    const decoded = decodeCycleEntryForEnvelope(entry);
-    if (!decoded)
-      return raw.slice();
-    typed.push({ cycle: decoded });
-  }
-  return typed;
-}
-function decodeCycleEntryForEnvelope(raw) {
-  if (Array.isArray(raw) && raw.every((x) => typeof x === "string")) {
-    return raw;
-  }
-  if (!raw || typeof raw !== "object")
-    return null;
-  const obj = raw;
-  const source = obj.cycle ?? obj.packages ?? obj.path;
-  if (!Array.isArray(source))
-    return null;
-  const names = source.filter((x) => typeof x === "string");
-  return names.length > 0 ? names : null;
-}
 function buildGroup(group) {
   const lean = {
     name: group.name,
@@ -4295,49 +4736,23 @@ function formatConflictsAndCycles(payload, verbose, useColors) {
     return "";
   if (conflicts.length > 0) {
     lines.push(colorize(`Conflicts (${conflicts.length}):`, "yellow", useColors));
-    const typed = isTypedConflictArray(conflicts) ? conflicts : null;
-    if (typed) {
-      const nameWidth = Math.max(...typed.map((c) => c.name.length));
-      const sorted = [...typed].sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
-      for (const c of sorted) {
-        const padded = `${c.name}:`.padEnd(nameWidth + 2);
-        lines.push(`  ${padded}  ${c.requiredVersions.join(", ")}`);
-      }
-    } else {
-      for (const c of conflicts)
-        lines.push(`  ${JSON.stringify(c)}`);
+    const nameWidth = Math.max(...conflicts.map((c) => c.name.length));
+    const sorted = [...conflicts].sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+    for (const c of sorted) {
+      const padded = `${c.name}:`.padEnd(nameWidth + 2);
+      lines.push(`  ${padded}  ${c.requiredVersions.join(", ")}`);
     }
   }
   if (cycles.length > 0) {
     if (conflicts.length > 0)
       lines.push("");
     lines.push(colorize(`Circular dependencies (${cycles.length}):`, "red", useColors));
-    const typed = isTypedCycleArray(cycles) ? cycles : null;
-    if (typed) {
-      for (const c of typed)
-        lines.push(`  ${c.cycle.join(" → ")}`);
-    } else {
-      for (const c of cycles)
-        lines.push(`  ${JSON.stringify(c)}`);
-    }
+    for (const c of cycles)
+      lines.push(`  ${c.cycle.join(" → ")}`);
   }
   return lines.join(`
 `);
 }
-function isTypedConflictArray(arr) {
-  const first = arr[0];
-  if (!first || typeof first !== "object")
-    return false;
-  const obj = first;
-  return typeof obj.name === "string" && Array.isArray(obj.requiredVersions);
-}
-function isTypedCycleArray(arr) {
-  const first = arr[0];
-  if (!first || typeof first !== "object")
-    return false;
-  const obj = first;
-  return Array.isArray(obj.cycle);
-}
 function formatGroupsBlock(payload, verbose, useColors) {
   const groups = payload.groups;
   const lines = [];
@@ -4350,10 +4765,10 @@ function formatGroupsBlock(payload, verbose, useColors) {
   const groupNoun = groups.items.length === 1 ? "group" : "groups";
   lines.push(colorize(`${groups.items.length} ${groupNoun} (${summary}):`, "bold", useColors));
   lines.push("");
-  if (verbose && groups.environmentConstraints && groups.environmentConstraints.length > 0) {
-    lines.push(dim(`environmentConstraints (${groups.environmentConstraints.length}):`, useColors));
-    for (const entry of groups.environmentConstraints) {
-      lines.push(dim(`  ${JSON.stringify(entry)}`, useColors));
+  if (verbose && groups.environmentMarkers && groups.environmentMarkers.length > 0) {
+    lines.push(dim(`environmentMarkers (${groups.environmentMarkers.length}):`, useColors));
+    for (const marker of groups.environmentMarkers) {
+      lines.push(dim(`  ${formatEnvironmentMarker(marker)}`, useColors));
     }
     lines.push("");
   }
@@ -4382,6 +4797,15 @@ function formatGroupsBlock(payload, verbose, useColors) {
   return lines.join(`
 `).trimEnd();
 }
+function formatEnvironmentMarker(marker) {
+  if (marker.type && marker.value)
+    return `${marker.type}: ${marker.value}`;
+  if (marker.value)
+    return marker.value;
+  if (marker.type)
+    return marker.type;
+  return marker.raw ?? "(empty marker)";
+}
 function formatGroupHeading(group, registry) {
   if (group.conditionType === "always") {
     return group.name;
@@ -4447,101 +4871,6 @@ function sortAlphabetically(items, key) {
     return ka < kb ? -1 : ka > kb ? 1 : 0;
   });
 }
-function decodeDag(raw) {
-  if (!raw || typeof raw !== "object")
-    return null;
-  const obj = raw;
-  const rawNodes = obj.n ?? obj.nodes;
-  const rawEdges = obj.e ?? obj.edges;
-  const nodes = decodeNodes(rawNodes);
-  if (!nodes)
-    return null;
-  const edges = decodeEdges(rawEdges);
-  if (!edges)
-    return null;
-  return { nodes, edges };
-}
-function decodeNodes(raw) {
-  if (Array.isArray(raw)) {
-    const result = [];
-    for (const entry of raw) {
-      if (!Array.isArray(entry)) {
-        if (typeof entry === "object" && entry !== null) {
-          const n = decodeObjectNode(entry);
-          if (!n)
-            return null;
-          result.push(n);
-          continue;
-        }
-        return null;
-      }
-      const [registry, name, version2] = entry;
-      if (typeof name !== "string")
-        return null;
-      result.push({
-        name,
-        version: typeof version2 === "string" ? version2 : undefined,
-        registry: typeof registry === "string" ? registry : undefined
-      });
-    }
-    return result;
-  }
-  if (raw && typeof raw === "object") {
-    const result = [];
-    for (const entry of Object.values(raw)) {
-      if (!entry || typeof entry !== "object")
-        return null;
-      const n = decodeObjectNode(entry);
-      if (!n)
-        return null;
-      result.push(n);
-    }
-    return result;
-  }
-  return null;
-}
-function decodeObjectNode(entry) {
-  const name = typeof entry.n === "string" ? entry.n : typeof entry.name === "string" ? entry.name : null;
-  if (!name)
-    return null;
-  const version2 = typeof entry.v === "string" ? entry.v : typeof entry.version === "string" ? entry.version : undefined;
-  return { name, version: version2 };
-}
-function decodeEdges(raw) {
-  if (!Array.isArray(raw))
-    return null;
-  const out = [];
-  for (const entry of raw) {
-    if (Array.isArray(entry)) {
-      const [from, to, constraint, lifecycle] = entry;
-      if (typeof from !== "number" || typeof to !== "number")
-        return null;
-      out.push({
-        fromIdx: from,
-        toIdx: to,
-        constraint: typeof constraint === "string" ? constraint : undefined,
-        lifecycle: typeof lifecycle === "string" ? lifecycle : undefined
-      });
-      continue;
-    }
-    if (entry && typeof entry === "object") {
-      const obj = entry;
-      const from = obj.f ?? obj.from;
-      const to = obj.t ?? obj.to;
-      if (typeof from !== "number" || typeof to !== "number")
-        return null;
-      out.push({
-        fromIdx: from,
-        toIdx: to,
-        constraint: typeof obj.c === "string" ? obj.c : undefined,
-        lifecycle: typeof obj.l === "string" ? obj.l : undefined
-      });
-      continue;
-    }
-    return null;
-  }
-  return out;
-}
 // src/shared/package-intelligence-error-map.ts
 function mapPackageIntelligenceError(error2) {
   const mapped = classify2(error2);
@@ -7117,6 +7446,113 @@ function registerFeedbackCommand(program) {
   });
 }
 // src/commands/init/setup-handlers.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepEqual(left, right) {
+  if (Object.is(left, right)) {
+    return true;
+  }
+  if (Array.isArray(left) && Array.isArray(right)) {
+    if (left.length !== right.length) {
+      return false;
+    }
+    for (let i = 0;i < left.length; i++) {
+      if (!deepEqual(left[i], right[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (isPlainObject(left) && isPlainObject(right)) {
+    const leftKeys = Object.keys(left).sort();
+    const rightKeys = Object.keys(right).sort();
+    if (!deepEqual(leftKeys, rightKeys)) {
+      return false;
+    }
+    for (const key of leftKeys) {
+      if (!deepEqual(left[key], right[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+}
+function isStringArray2(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isGitHitsPackageToken(token) {
+  return token.toLowerCase() === "githits@latest";
+}
+function isLocalGitHitsInvocation(invocation) {
+  if (invocation.length === 5) {
+    const [command, yesFlag, packageToken, subcommand, action] = invocation;
+    return command === "npx" && yesFlag === "-y" && typeof packageToken === "string" && isGitHitsPackageToken(packageToken) && subcommand === "mcp" && action === "start";
+  }
+  return false;
+}
+function extractInvocation(config) {
+  if (!isPlainObject(config)) {
+    return null;
+  }
+  const command = config.command;
+  if (typeof command === "string") {
+    const args = config.args;
+    if (!isStringArray2(args)) {
+      return null;
+    }
+    return [command, ...args];
+  }
+  if (isStringArray2(command)) {
+    return [...command];
+  }
+  return null;
+}
+function nonCommandFieldsEqual(existing, expected) {
+  for (const [key, value] of Object.entries(expected)) {
+    if (key === "command" || key === "args") {
+      continue;
+    }
+    if (!deepEqual(existing[key], value)) {
+      return false;
+    }
+  }
+  return true;
+}
+function hasLegacyRemoteIndicators(existing, expected) {
+  if ("url" in existing || "serverUrl" in existing) {
+    return true;
+  }
+  if ("type" in existing && !("type" in expected) && (existing.type === "http" || existing.type === "streamableHttp")) {
+    return true;
+  }
+  return false;
+}
+function isEquivalentConfiguredValue(existing, expected) {
+  if (deepEqual(existing, expected)) {
+    return true;
+  }
+  if (!isPlainObject(existing)) {
+    return false;
+  }
+  const expectedInvocation = extractInvocation(expected);
+  const existingInvocation = extractInvocation(existing);
+  if (!expectedInvocation || !existingInvocation) {
+    return false;
+  }
+  if (!isLocalGitHitsInvocation(expectedInvocation) || !isLocalGitHitsInvocation(existingInvocation)) {
+    return false;
+  }
+  if (hasLegacyRemoteIndicators(existing, expected)) {
+    return false;
+  }
+  return nonCommandFieldsEqual(existing, expected);
+}
+function getMatchingServerKeys(servers, serverName) {
+  const normalizedTarget = serverName.toLowerCase();
+  return Object.keys(servers).filter((key) => key.toLowerCase() === normalizedTarget);
+}
 function mergeServerConfig(existingContent, serversKey, serverName, serverConfig) {
   let content = existingContent;
   if (content.charCodeAt(0) === 65279) {
@@ -7152,12 +7588,17 @@ function mergeServerConfig(existingContent, serversKey, serverName, serverConfig
     };
   }
   const serversObj = servers;
-  if (serverName in serversObj) {
+  const matchingKeys = getMatchingServerKeys(serversObj, serverName);
+  if (matchingKeys.length === 1 && matchingKeys[0] === serverName && isEquivalentConfiguredValue(serversObj[serverName], serverConfig)) {
     return { status: "already_configured" };
   }
+  for (const key of matchingKeys) {
+    delete serversObj[key];
+  }
+  const hadExisting = matchingKeys.length > 0;
   serversObj[serverName] = serverConfig;
   return {
-    status: "added",
+    status: hadExisting ? "updated" : "added",
     content: `${JSON.stringify(config, null, 2)}
 `
   };
@@ -7195,7 +7636,12 @@ async function isAlreadyConfigured(config, fs) {
     if (typeof servers !== "object" || servers === null || Array.isArray(servers)) {
       return false;
     }
-    return config.serverName in servers;
+    const serversObj = servers;
+    const matchingKeys = getMatchingServerKeys(serversObj, config.serverName);
+    if (matchingKeys.length !== 1 || matchingKeys[0] !== config.serverName) {
+      return false;
+    }
+    return isEquivalentConfiguredValue(serversObj[config.serverName], config.serverConfig);
   } catch {
     return false;
   }
@@ -7325,6 +7771,13 @@ async function executeConfigFileSetup(setup, fs) {
 }
 
 // src/commands/init/agent-definitions.ts
+var GITHITS_SERVER_NAME = "GitHits";
+var GITHITS_MCP_COMMAND = "npx";
+var GITHITS_MCP_ARGS = ["-y", "githits@latest", "mcp", "start"];
+var GITHITS_MCP_INVOCATION = [
+  GITHITS_MCP_COMMAND,
+  ...GITHITS_MCP_ARGS
+];
 function getAppDataPath(fs, appName) {
   const home = fs.getHomeDir();
   switch (process.platform) {
@@ -7380,8 +7833,11 @@ var cursor = {
     method: "config-file",
     configPath: fs.joinPath(fs.getHomeDir(), ".cursor", "mcp.json"),
     serversKey: "mcpServers",
-    serverName: "GitHits",
-    serverConfig: { url: getMcpUrl() }
+    serverName: GITHITS_SERVER_NAME,
+    serverConfig: {
+      command: GITHITS_MCP_COMMAND,
+      args: [...GITHITS_MCP_ARGS]
+    }
   })
 };
 var windsurf = {
@@ -7394,8 +7850,11 @@ var windsurf = {
     method: "config-file",
     configPath: fs.joinPath(fs.getHomeDir(), ".codeium", "windsurf", "mcp_config.json"),
     serversKey: "mcpServers",
-    serverName: "GitHits",
-    serverConfig: { serverUrl: getMcpUrl() }
+    serverName: GITHITS_SERVER_NAME,
+    serverConfig: {
+      command: GITHITS_MCP_COMMAND,
+      args: [...GITHITS_MCP_ARGS]
+    }
   })
 };
 var claudeDesktop = {
@@ -7422,10 +7881,10 @@ var claudeDesktop = {
       method: "config-file",
       configPath: fs.joinPath(appData, "claude_desktop_config.json"),
       serversKey: "mcpServers",
-      serverName: "GitHits",
+      serverName: GITHITS_SERVER_NAME,
       serverConfig: {
-        command: "npx",
-        args: ["-y", "mcp-remote", getMcpUrl()]
+        command: GITHITS_MCP_COMMAND,
+        args: [...GITHITS_MCP_ARGS]
       }
     };
   }
@@ -7441,17 +7900,7 @@ var codexCli = {
     commands: [
       {
         command: "codex",
-        args: [
-          "mcp",
-          "add",
-          "githits",
-          "--",
-          "npx",
-          "-y",
-          "githits@latest",
-          "mcp",
-          "start"
-        ]
+        args: ["mcp", "add", "githits", "--", ...GITHITS_MCP_INVOCATION]
       }
     ],
     checkCommand: {
@@ -7476,8 +7925,11 @@ var vscode = {
       method: "config-file",
       configPath: fs.joinPath(appData, "User", "mcp.json"),
       serversKey: "servers",
-      serverName: "GitHits",
-      serverConfig: { url: getMcpUrl(), type: "http" }
+      serverName: GITHITS_SERVER_NAME,
+      serverConfig: {
+        command: GITHITS_MCP_COMMAND,
+        args: [...GITHITS_MCP_ARGS]
+      }
     };
   }
 };
@@ -7491,8 +7943,11 @@ var cline = {
     method: "config-file",
     configPath: fs.joinPath(fs.getHomeDir(), ".cline", "data", "settings", "cline_mcp_settings.json"),
     serversKey: "mcpServers",
-    serverName: "GitHits",
-    serverConfig: { url: getMcpUrl(), type: "streamableHttp" }
+    serverName: GITHITS_SERVER_NAME,
+    serverConfig: {
+      command: GITHITS_MCP_COMMAND,
+      args: [...GITHITS_MCP_ARGS]
+    }
   })
 };
 var geminiCli = {
@@ -7536,8 +7991,11 @@ var googleAntigravity = {
     method: "config-file",
     configPath: fs.joinPath(fs.getHomeDir(), ".gemini", "antigravity", "mcp_config.json"),
     serversKey: "mcpServers",
-    serverName: "GitHits",
-    serverConfig: { serverUrl: getMcpUrl() }
+    serverName: GITHITS_SERVER_NAME,
+    serverConfig: {
+      command: GITHITS_MCP_COMMAND,
+      args: [...GITHITS_MCP_ARGS]
+    }
   })
 };
 var openCode = {
@@ -7550,10 +8008,10 @@ var openCode = {
     method: "config-file",
     configPath: process.platform === "win32" ? fs.joinPath(process.env.APPDATA ?? fs.joinPath(fs.getHomeDir(), "AppData", "Roaming"), "opencode", "opencode.json") : fs.joinPath(fs.getHomeDir(), ".config", "opencode", "opencode.json"),
     serversKey: "mcp",
-    serverName: "GitHits",
+    serverName: GITHITS_SERVER_NAME,
     serverConfig: {
       type: "local",
-      command: ["npx", "-y", "githits@latest", "mcp", "start"],
+      command: [...GITHITS_MCP_INVOCATION],
       enabled: true
     }
   })
@@ -9142,8 +9600,23 @@ function createMcpServer(deps) {
   return server;
 }
 async function startMcpServer(deps) {
+  setClientMode("mcp");
   const server = createMcpServer(deps);
   const transport = new StdioServerTransport;
+  setMcpClientVersionProvider(() => {
+    try {
+      const clientVersion = server.server.getClientVersion();
+      if (!clientVersion?.name || typeof clientVersion.name !== "string" || clientVersion.name.trim().length === 0) {
+        return;
+      }
+      const name = clientVersion.name.trim();
+      const rawVersion = clientVersion.version;
+      const versionOut = typeof rawVersion === "string" && rawVersion.trim().length > 0 ? rawVersion.trim() : undefined;
+      return { name, version: versionOut };
+    } catch {
+      return;
+    }
+  });
   await server.connect(transport);
 }
 function showMcpSetupInstructions() {
@@ -9652,10 +10125,20 @@ function registerSearchCommand(program) {
 }
 // src/cli.ts
 var program = new Command;
-program.name("githits").description("Code examples from global open source for your AI assistant").version(version).option("--no-color", "Disable colored output").hook("preAction", (thisCommand) => {
+var commandSpans = new WeakMap;
+if (isTelemetryEnabled()) {
+  process.once("exit", (exitCode) => {
+    flushTelemetry(exitCode);
+  });
+}
+program.name("githits").description("Code examples from global open source for your AI assistant").version(version).option("--no-color", "Disable colored output").hook("preAction", (thisCommand, actionCommand) => {
   if (thisCommand.opts().color === false) {
     process.env.NO_COLOR = "1";
   }
+  const command = actionCommand ?? thisCommand;
+  commandSpans.set(command, startTelemetrySpan(getTelemetryCommandName(command)));
+}).hook("postAction", (_thisCommand, actionCommand) => {
+  endTelemetrySpan(commandSpans.get(actionCommand));
 }).addHelpText("after", `
 Getting started:
   githits init                           Set up MCP for your coding agents
@@ -9675,15 +10158,27 @@ registerLanguagesCommand(program);
 registerFeedbackCommand(program);
 var argv = process.argv.slice(2);
 if (shouldEagerLoadGatedCommandGroup(argv, "code")) {
-  await registerCodeCommandGroup(program);
+  await withTelemetrySpan("cli.register.code-group", () => registerCodeCommandGroup(program));
 }
 if (shouldEagerLoadGatedCommandGroup(argv, "pkg")) {
-  await registerPkgCommandGroup(program);
+  await withTelemetrySpan("cli.register.pkg-group", () => registerPkgCommandGroup(program));
 }
 var authCommand = program.command("auth").summary("Manage authentication").description("Manage authentication with GitHits.");
 registerAuthStatusCommand(authCommand);
-await program.parseAsync();
+await withTelemetrySpan("cli.parse", () => program.parseAsync());
 function shouldEagerLoadGatedCommandGroup(args, groupName) {
   const [firstArg] = args;
   return firstArg === groupName || firstArg === "help" || firstArg === "--help" || firstArg === "-h";
 }
+function getTelemetryCommandName(command) {
+  const names = [];
+  let current = command;
+  while (current) {
+    const name = current.name();
+    if (name && name !== "githits") {
+      names.unshift(name);
+    }
+    current = current.parent ?? null;
+  }
+  return `command.${names.join(".")}`;
+}