refactor: split command instrumentation and tighten telemetry API

Split instrumentation/commands.ts into workspaceOpen.ts, diagnostics.ts,
and shared outcomes.ts to mirror a future commands.ts split. Unify trace
methods on the cancel/fail/succeed* trio, shorten trace<Noun> names, and
make ExportTelemetryObserver a required structural subset of
DiagnosticTrace so callers pass their trace directly.

Commands now keep business bodies in named run* methods instead of
inline closures, the open source defaults to "command" rather than
being inferred from argument presence, and the dead openWorkspace
wrapper is gone. Restore workspaceName on workspace.update.prompted and
workspace.start.prompted to match the other operation traces. Rename
the telemetry-only test to updateWorkspace.telemetry.test.ts.

Author: EhabY

src/commands.ts

@@ -0,0 +1,77 @@
+import { recordCancelled, recordFailure } from "./outcomes";
+
+import type { SpeedtestResult } from "@repo/shared";
+
+import type { TelemetryReporter } from "../telemetry/reporter";
+import type { Span } from "../telemetry/span";
+
+import type { WorkspacePickerFailureCategory } from "./workspaceOpen";
+
+export type DiagnosticCommand =
+	| "speed_test"
+	| "support_bundle"
+	| "export_telemetry";
+export type DiagnosticFailureCategory =
+	| WorkspacePickerFailureCategory
+	| "parse_error"
+	| "unsupported_cli"
+	| "error";
+export type DiagnosticCancelStage =
+	| "workspace_picker"
+	| "input"
+	| "prompt"
+	| "save_dialog"
+	| "progress";
+
+export interface DiagnosticTrace {
+	cancel(stage: DiagnosticCancelStage): void;
+	fail(category?: DiagnosticFailureCategory): void;
+	setRequestedDuration(seconds: number): void;
+	succeedSpeedtest(result: SpeedtestResult): void;
+	succeedExport(format: string, eventCount: number): void;
+}
+
+/** Emits `command.diagnostic.completed` around each diagnostic command. */
+export class DiagnosticTelemetry {
+	public constructor(private readonly telemetry: TelemetryReporter) {}
+
+	public trace(
+		command: DiagnosticCommand,
+		fn: (trace: DiagnosticTrace) => Promise<void>,
+	): Promise<void> {
+		return this.telemetry.trace(
+			"command.diagnostic.completed",
+			(span) => fn(new SpanDiagnosticTrace(span)),
+			{ command },
+		);
+	}
+}
+
+class SpanDiagnosticTrace implements DiagnosticTrace {
+	public constructor(private readonly span: Span) {}
+
+	public cancel(stage: DiagnosticCancelStage): void {
+		recordCancelled(this.span, stage);
+	}
+
+	public fail(category: DiagnosticFailureCategory = "error"): void {
+		recordFailure(this.span, category);
+	}
+
+	public setRequestedDuration(seconds: number): void {
+		this.span.setMeasurement("requested_duration_seconds", seconds);
+	}
+
+	public succeedSpeedtest(result: SpeedtestResult): void {
+		this.span.setMeasurement("interval_count", result.intervals.length);
+		this.span.setMeasurement(
+			"throughput_mbits",
+			result.overall.throughput_mbits,
+		);
+	}
+
+	public succeedExport(format: string, eventCount: number): void {
+		this.span.setProperty("format", format);
+		this.span.setMeasurement("event_count", eventCount);
+	}
+}