refactor(telemetry): use child spans for phase timing instead of manual measurement

Replace performance.now() markers and setPhaseTimingAttributes with
cli.command.exec and cli.command.render child spans. Span durations
are the idiomatic way to measure phases — they appear in the trace
waterfall and don't require custom attributes.

Updated the 'Command Phase Breakdown' dashboard widget to query
span.duration grouped by span.op instead of custom phase.* attributes.

Author: BYK

src/lib/command.ts

@@ -60,11 +60,7 @@ import {
   parseLogLevel,
   setLogLevel,
 } from "./logger.js";
-import {
-  setArgsContext,
-  setFlagContext,
-  setPhaseTimingAttributes,
-} from "./telemetry.js";
+import { setArgsContext, setFlagContext, withTracing } from "./telemetry.js";
 
 /**
  * Parse a string input as a number.
@@ -526,8 +522,6 @@ export function buildCommand<
     flags: Record<string, unknown>,
     ...args: unknown[]
   ) {
-    const phaseStart = performance.now();
-
     applyLoggingFlags(
       flags[LOG_LEVEL_KEY] as LogLevelName | undefined,
       flags.verbose as boolean
@@ -579,9 +573,6 @@ export function buildCommand<
       throw err;
     };
 
-    // End of pre-command phase (flag parsing, context setup)
-    const preEnd = performance.now();
-
     // Iterate the generator using manual .next() instead of for-await-of
     // so we can capture the return value (done: true result). The return
     // value carries the final `hint` — for-await-of discards it.
@@ -595,30 +586,28 @@ export function buildCommand<
         throw new AuthError("not_authenticated");
       }
 
-      const generator = originalFunc.call(
-        this,
-        cleanFlags as FLAGS,
-        ...(args as unknown as ARGS)
+      // Execution phase: core command logic, API calls, org/project resolution
+      const returned = await withTracing(
+        "exec",
+        "cli.command.exec",
+        async () => {
+          const generator = originalFunc.call(
+            this,
+            cleanFlags as FLAGS,
+            ...(args as unknown as ARGS)
+          );
+          let result = await generator.next();
+          while (!result.done) {
+            handleYieldedValue(stdout, result.value, cleanFlags, renderer);
+            result = await generator.next();
+          }
+          return result.value as CommandReturn | undefined;
+        }
       );
-      let result = await generator.next();
-      while (!result.done) {
-        handleYieldedValue(stdout, result.value, cleanFlags, renderer);
-        result = await generator.next();
-      }
-
-      // End of execution phase (core command logic + API calls)
-      const execEnd = performance.now();
-
-      // Generator completed successfully — finalize with hint.
-      const returned = result.value as CommandReturn | undefined;
-      writeFinalization(stdout, returned?.hint, cleanFlags.json, renderer);
 
-      // Record phase timing on the active span
-      const renderEnd = performance.now();
-      setPhaseTimingAttributes({
-        preMs: preEnd - phaseStart,
-        execMs: execEnd - preEnd,
-        renderMs: renderEnd - execEnd,
+      // Render phase: output finalization
+      await withTracing("render", "cli.command.render", () => {
+        writeFinalization(stdout, returned?.hint, cleanFlags.json, renderer);
       });
     } catch (err) {
       // Finalize before error handling to close streaming state

src/lib/telemetry.ts

@@ -615,28 +615,6 @@ export function setArgsContext(args: readonly unknown[]): void {
   });
 }
 
-/**
- * Set phase timing attributes on the active span.
- *
- * Records how long each phase of command execution took, enabling
- * dashboard breakdown of pre-command (flag parsing, context setup),
- * execution (core logic + API calls), and render (output formatting) phases.
- *
- * @param phases - Timing data for each command phase in milliseconds
- */
-export function setPhaseTimingAttributes(phases: {
-  preMs: number;
-  execMs: number;
-  renderMs: number;
-}): void {
-  const span = Sentry.getActiveSpan();
-  if (span) {
-    span.setAttribute("phase.pre_ms", Math.round(phases.preMs));
-    span.setAttribute("phase.exec_ms", Math.round(phases.execMs));
-    span.setAttribute("phase.render_ms", Math.round(phases.renderMs));
-  }
-}
-
 /**
  * Wrap an operation with a Sentry span for tracing.
  *