fix(telemetry): instrument delta upgrade with spans and error capture

Delta upgrade failures were completely invisible in Sentry:
- No spans for the delta attempt (only DB queries visible in traces)
- Errors caught and logged at debug level (invisible without --verbose)
- No captureException — errors never reported to Sentry

This made it impossible to diagnose the ETXTBSY/SIGKILL issues
(PRs #339, #340, #343) from telemetry alone — they were found
through code analysis and local reproduction.

Changes:
- Wrap attemptDeltaUpgrade in withTracingSpan for a 'upgrade.delta' span
- Record delta.from_version, delta.to_version, delta.channel as attributes
- On success: record patch_bytes and sha256 prefix
- On unavailable (no patch): record delta.result='unavailable'
- On error: captureException with warning level + delta context tags,
  record delta.result='error' and delta.error message on span
- Upgrade log.debug to log.warn for failure messages so users see them

Now delta failures will appear as:
1. A span in the upgrade trace (with error status + attributes)
2. A warning-level exception in Sentry Issues (with delta context)
3. A visible stderr message to the user

Author: BYK

src/lib/delta-upgrade.ts

@@ -19,6 +19,8 @@
 
 import { unlinkSync } from "node:fs";
 
+import { captureException } from "@sentry/bun";
+
 import {
   GITHUB_RELEASES_URL,
   getPlatformBinaryName,
@@ -34,6 +36,7 @@ import {
   type OciManifest,
 } from "./ghcr.js";
 import { logger } from "./logger.js";
+import { withTracingSpan } from "./telemetry.js";
 
 /** Scoped logger for delta upgrade operations */
 const log = logger.withTag("delta-upgrade");
@@ -563,29 +566,76 @@ export async function resolveNightlyChain(
  * @param destPath - Path to write the patched binary
  * @returns Delta result with SHA-256 and size info, or null if delta is unavailable
  */
-export async function attemptDeltaUpgrade(
+export function attemptDeltaUpgrade(
   targetVersion: string,
   oldBinaryPath: string,
   destPath: string
 ): Promise<DeltaResult | null> {
   if (!canAttemptDelta(targetVersion)) {
-    return null;
+    return Promise.resolve(null);
   }
 
-  log.debug(`Attempting delta upgrade from ${CLI_VERSION} to ${targetVersion}`);
+  const channel = isNightlyVersion(targetVersion) ? "nightly" : "stable";
 
-  try {
-    if (isNightlyVersion(targetVersion)) {
-      return await resolveNightlyDelta(targetVersion, oldBinaryPath, destPath);
-    }
-    return await resolveStableDelta(targetVersion, oldBinaryPath, destPath);
-  } catch (error) {
-    // Any error during delta upgrade → fall back to full download.
-    // Log at debug so --verbose reveals the root cause (ETXTBSY, network, etc.)
-    const msg = error instanceof Error ? error.message : String(error);
-    log.debug(`Delta upgrade failed (${msg}), falling back to full download`);
-    return null;
-  }
+  return withTracingSpan(
+    "delta-upgrade",
+    "upgrade.delta",
+    async (span) => {
+      span.setAttribute("delta.from_version", CLI_VERSION);
+      span.setAttribute("delta.to_version", targetVersion);
+      span.setAttribute("delta.channel", channel);
+
+      log.debug(
+        `Attempting delta upgrade from ${CLI_VERSION} to ${targetVersion}`
+      );
+
+      try {
+        const result =
+          channel === "nightly"
+            ? await resolveNightlyDelta(targetVersion, oldBinaryPath, destPath)
+            : await resolveStableDelta(targetVersion, oldBinaryPath, destPath);
+
+        if (result) {
+          span.setAttribute("delta.patch_bytes", result.patchBytes);
+          span.setAttribute("delta.sha256", result.sha256.slice(0, 12));
+          span.setStatus({ code: 1 }); // OK
+        } else {
+          // No patch available — not an error, just unavailable
+          span.setAttribute("delta.result", "unavailable");
+          span.setStatus({ code: 1 }); // OK — graceful fallback
+        }
+        return result;
+      } catch (error) {
+        // Record the error in Sentry so we can see delta failures in telemetry.
+        // Marked non-fatal: the upgrade continues via full download.
+        captureException(error, {
+          level: "warning",
+          tags: {
+            "delta.from_version": CLI_VERSION,
+            "delta.to_version": targetVersion,
+            "delta.channel": channel,
+          },
+          contexts: {
+            delta_upgrade: {
+              from_version: CLI_VERSION,
+              to_version: targetVersion,
+              channel,
+              old_binary_path: oldBinaryPath,
+            },
+          },
+        });
+
+        const msg = error instanceof Error ? error.message : String(error);
+        log.warn(
+          `Delta upgrade failed (${msg}), falling back to full download`
+        );
+        span.setAttribute("delta.result", "error");
+        span.setAttribute("delta.error", msg);
+        return null;
+      }
+    },
+    { "delta.channel": channel }
+  );
 }
 
 /**