@@ -808,6 +808,7 @@ public class io/sentry/android/core/performance/AppStartMetrics : io/sentry/andr
 	public fun getPendingExtendedAppStartSpan ()Lio/sentry/android/core/ExtendedAppStartSpan;
 	public fun getSdkInitTimeSpan ()Lio/sentry/android/core/performance/TimeSpan;
 	public fun isAppLaunchedInForeground ()Z
+	public fun isAppStartExtended ()Z
 	public fun isExtendedAppStartPending ()Z
 	public fun markExtendedAppStartMaterialized ()V
 	public fun onActivityCreated (Landroid/app/Activity;Landroid/os/Bundle;)V
 
@@ -65,6 +65,8 @@ public final class ActivityLifecycleIntegration
   static final String APP_START_COLD = "app.start.cold";
   static final String TTID_OP = "ui.load.initial_display";
   static final String TTFD_OP = "ui.load.full_display";
+  static final String APP_START_EXTENDED_OP = "app.start.extended_app_start";
+  static final String APP_START_EXTENDED_DESC = "Extended App Start";
   static final long TTFD_TIMEOUT_MILLIS = 25000;
   // If a headless app start and the following activity's ui.load are more than this far apart, they
   // are treated as unrelated and not connected into the same trace.
@@ -277,6 +279,13 @@ private void startTracing(final @NotNull Activity activity) {
           appStartTransactionOptions.setStartTimestamp(appStartTime);
           appStartTransactionOptions.setAppStartTransaction(appStartSamplingDecision != null);
           appStartTransactionOptions.setOrigin(APP_START_TRACE_ORIGIN);
+          // When the app start is being extended, hold the transaction open until the extended span
+          // finishes (or the deadline forces it).
+          if (AppStartMetrics.getInstance().isExtendedAppStartPending()) {
+            appStartTransactionOptions.setWaitForChildren(true);
+            appStartTransactionOptions.setDeadlineTimeout(
+                deadlineTimeoutMillis <= 0 ? null : deadlineTimeoutMillis);
+          }
 
           appStartTransaction =
               scopes.startTransaction(
@@ -291,6 +300,7 @@ private void startTracing(final @NotNull Activity activity) {
           if (appStartReason != null) {
             appStartTransaction.setData(APP_START_REASON_DATA, appStartReason);
           }
+          materializeExtendedAppStart(appStartTransaction);
         }
 
         // Continue either the foreground app.start above or an earlier headless app.start.
@@ -349,6 +359,9 @@ && isWithinAppStartContinuationWindow(ttidStartTime)) {
                     spanOptions);
 
             finishAppStartSpan();
+            // The ui.load transaction already waits for children + has a deadline, so parenting the
+            // extended span here keeps it open until the extension finishes.
+            materializeExtendedAppStart(appStartSpan);
           }
         }
         final @NotNull ISpan ttidSpan =
@@ -400,6 +413,30 @@ private void setSpanOrigin(final @NotNull SpanOptions spanOptions) {
     spanOptions.setOrigin(TRACE_ORIGIN);
   }
 
+  /**
+   * Materializes a pending extended app start span as a child of {@code parent}. The parent's
+   * transaction must have {@code waitForChildren} + a deadline set so it stays open until the
+   * extension finishes (or the deadline forces it).
+   */
+  private void materializeExtendedAppStart(final @NotNull ISpan parent) {
+    final @NotNull AppStartMetrics metrics = AppStartMetrics.getInstance();
+    final @Nullable ExtendedAppStartSpan ext = metrics.getPendingExtendedAppStartSpan();
+    if (ext == null) {
+      return;
+    }
+    final SpanOptions spanOptions = new SpanOptions();
+    setSpanOrigin(spanOptions);
+    final @NotNull ISpan child =
+        parent.startChild(
+            APP_START_EXTENDED_OP,
+            APP_START_EXTENDED_DESC,
+            ext.getStartDate(),
+            Instrumenter.SENTRY,
+            spanOptions);
+    ext.materialize(child);
+    metrics.markExtendedAppStartMaterialized();
+  }
+
   /**
    * Whether the ui.load starting at {@code uiLoadStartTime} is close enough in time to the headless
    * app start to belong to the same trace. If they are more than {@link
@@ -998,6 +1035,13 @@ private void onHeadlessAppStart() {
     txnOptions.setBindToScope(false);
     txnOptions.setStartTimestamp(startTime);
     txnOptions.setOrigin(APP_START_TRACE_ORIGIN);
+    // When the app start is being extended, hold the headless transaction open until the extended
+    // span finishes (or the deadline forces it).
+    if (metrics.isExtendedAppStartPending()) {
+      txnOptions.setWaitForChildren(true);
+      final long deadlineTimeoutMillis = options.getDeadlineTimeout();
+      txnOptions.setDeadlineTimeout(deadlineTimeoutMillis <= 0 ? null : deadlineTimeoutMillis);
+    }
 
     final @NotNull TransactionContext txnContext =
         new TransactionContext(
@@ -1020,6 +1064,7 @@ private void onHeadlessAppStart() {
     // time to continue this trace.
     metrics.setAppStartEndTime(endTime);
 
+    materializeExtendedAppStart(transaction);
     transaction.finish(SpanStatus.OK, endTime);
   }
 }
@@ -10,6 +10,7 @@
 import io.sentry.Hint;
 import io.sentry.ISentryLifecycleToken;
 import io.sentry.MeasurementUnit;
+import io.sentry.SentryDate;
 import io.sentry.SentryEvent;
 import io.sentry.SpanContext;
 import io.sentry.SpanDataConvention;
@@ -29,6 +30,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.TimeUnit;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -101,20 +103,45 @@ public SentryEvent process(@NotNull SentryEvent event, @NotNull Hint hint) {
               isHeadlessStandaloneAppStartTxn
                   ? appStartMetrics.getAppStartTimeSpanForHeadless()
                   : appStartMetrics.getAppStartTimeSpanWithFallback(options);
-          final long appStartUpDurationMs = appStartTimeSpan.getDurationMs();
 
-          // if appStartUpDurationMs is 0, metrics are not ready to be sent
-          if (appStartUpDurationMs != 0) {
-            final MeasurementValue value =
-                new MeasurementValue(
-                    (float) appStartUpDurationMs, MeasurementUnit.Duration.MILLISECOND.apiName());
+          final long appStartUpDurationMs;
+          // Whether the app start is ready to be finalized (spans attached, marked sent). When not
+          // ready (duration 0), we leave it for a later transaction to retry.
+          final boolean appStartReady;
+          if (appStartMetrics.isAppStartExtended()) {
+            final @Nullable SentryDate extendedEnd = appStartMetrics.getExtendedAppStartEndTime();
+            if (extendedEnd != null && appStartTimeSpan.hasStarted()) {
+              // The user finished the extension: measure from process start to the extended end.
+              // The end stays within the 1-minute cap thanks to the 30s deadline timeout.
+              appStartUpDurationMs =
+                  TimeUnit.NANOSECONDS.toMillis(extendedEnd.nanoTimestamp())
+                      - appStartTimeSpan.getStartTimestampMs();
+              appStartReady = appStartUpDurationMs != 0;
+            } else {
+              // The extension hit the deadline (or no valid start): suppress the measurement so we
+              // never emit an artificially inflated value, but still finalize the app start spans.
+              appStartUpDurationMs = 0;
+              appStartReady = appStartTimeSpan.hasStarted();
+            }
+          } else {
+            appStartUpDurationMs = appStartTimeSpan.getDurationMs();
+            // if appStartUpDurationMs is 0, metrics are not ready to be sent
+            appStartReady = appStartUpDurationMs != 0;
+          }
+
+          if (appStartReady) {
+            if (appStartUpDurationMs != 0) {
+              final MeasurementValue value =
+                  new MeasurementValue(
+                      (float) appStartUpDurationMs, MeasurementUnit.Duration.MILLISECOND.apiName());
 
-            final String appStartKey =
-                appStartMetrics.getAppStartType() == AppStartMetrics.AppStartType.COLD
-                    ? MeasurementValue.KEY_APP_START_COLD
-                    : MeasurementValue.KEY_APP_START_WARM;
+              final String appStartKey =
+                  appStartMetrics.getAppStartType() == AppStartMetrics.AppStartType.COLD
+                      ? MeasurementValue.KEY_APP_START_COLD
+                      : MeasurementValue.KEY_APP_START_WARM;
 
-            transaction.getMeasurements().put(appStartKey, value);
+              transaction.getMeasurements().put(appStartKey, value);
+            }
 
             attachAppStartSpans(appStartMetrics, transaction);
             appStartMetrics.onAppStartSpansSent();
 
@@ -292,6 +292,9 @@ public void onAppStartSpansSent() {
     shouldSendStartMeasurements = false;
     contentProviderOnCreates.clear();
     activityLifecycles.clear();
+    // Reset extension state so a stale extended span can't affect a later (e.g. warm) app start.
+    extendedAppStartSpan = null;
+    extendedAppStartMaterialized = false;
   }
 
   public boolean shouldSendStartMeasurements(final boolean ignoreForegroundCheck) {
@@ -359,7 +362,11 @@ public void extendAppStart() {
             .log(SentryLevel.WARNING, "App start is already being extended.");
         return;
       }
-      if (!shouldSendStartMeasurements()
+      // Ignore the foreground check: headless app starts (broadcast/service) run in a
+      // non-foreground process but can still be extended. The window guards below still reject an
+      // extension once an activity was created, the first frame was drawn, or measurements were
+      // already sent.
+      if (!shouldSendStartMeasurements(true)
           || activeActivitiesCounter.get() > 0
           || firstDrawDone.get()) {
         Sentry.getCurrentScopes()
@@ -391,6 +398,11 @@ public void finishAppStart() {
     return NoOpSpan.getInstance();
   }
 
+  /** Whether the app start was extended (regardless of materialization or finish state). */
+  public boolean isAppStartExtended() {
+    return extendedAppStartSpan != null;
+  }
+
   /** Whether an extension has been requested but not yet materialized into a real child span. */
   public boolean isExtendedAppStartPending() {
     return extendedAppStartSpan != null && !extendedAppStartMaterialized;
 
@@ -323,6 +323,93 @@ class ActivityLifecycleIntegrationTest {
     assertNull(appStartTransaction.getData("app.vitals.start.reason"))
   }
 
+  // region extended app start
+
+  @Test
+  fun `extended standalone app start span keeps the transaction open until finished`() {
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    sut.register(fixture.scopes, fixture.options)
+
+    setAppStartTime()
+    AppStartMetrics.getInstance().extendAppStart()
+
+    val activity = mock<Activity>()
+    sut.onActivityCreated(activity, fixture.bundle)
+
+    val appStartTransaction =
+      fixture.createdTransactions.single {
+        it.spanContext.operation == ActivityLifecycleIntegration.STANDALONE_APP_START_OP
+      }
+    assertTrue(
+      appStartTransaction.children.any {
+        it.operation == ActivityLifecycleIntegration.APP_START_EXTENDED_OP
+      }
+    )
+
+    // waitForChildren keeps the app start transaction open until the extension finishes
+    appStartTransaction.finish(SpanStatus.OK)
+    assertFalse(appStartTransaction.isFinished)
+
+    AppStartMetrics.getInstance().finishAppStart()
+    assertTrue(appStartTransaction.isFinished)
+  }
+
+  @Test
+  fun `extended non-standalone app start span is attached under the ui load transaction`() {
+    val sut = fixture.getSut { it.tracesSampleRate = 1.0 }
+    sut.register(fixture.scopes, fixture.options)
+
+    setAppStartTime()
+    AppStartMetrics.getInstance().extendAppStart()
+
+    val activity = mock<Activity>()
+    sut.onActivityCreated(activity, fixture.bundle)
+
+    val uiLoadTransaction =
+      fixture.createdTransactions.single {
+        it.spanContext.operation == ActivityLifecycleIntegration.UI_LOAD_OP
+      }
+    assertTrue(
+      uiLoadTransaction.children.any {
+        it.operation == ActivityLifecycleIntegration.APP_START_EXTENDED_OP
+      }
+    )
+  }
+
+  @Test
+  fun `extended headless app start span keeps the transaction open until finished`() {
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    sut.register(fixture.scopes, fixture.options)
+
+    prepareHeadlessAppStart(appStartType = AppStartType.COLD)
+    AppStartMetrics.getInstance().extendAppStart()
+
+    driveHeadlessAppStart()
+
+    val transaction = fixture.createdTransactions.single()
+    assertTrue(
+      transaction.children.any {
+        it.operation == ActivityLifecycleIntegration.APP_START_EXTENDED_OP
+      }
+    )
+
+    // headless finishes immediately, but waitForChildren keeps it open until the extension finishes
+    assertFalse(transaction.isFinished)
+
+    AppStartMetrics.getInstance().finishAppStart()
+    assertTrue(transaction.isFinished)
+  }
+
+  // endregion
+
   @Test
   @Config(sdk = [Build.VERSION_CODES.VANILLA_ICE_CREAM])
   fun `Headless standalone app start transaction carries app start reason when available`() {
 
@@ -4,7 +4,9 @@ import android.content.ContentProvider
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import io.sentry.Hint
 import io.sentry.IScopes
+import io.sentry.ISpan
 import io.sentry.MeasurementUnit
+import io.sentry.SentryLongDate
 import io.sentry.SentryTracer
 import io.sentry.SpanContext
 import io.sentry.SpanDataConvention
@@ -192,6 +194,59 @@ class PerformanceAndroidEventProcessorTest {
     assertEquals(20f, tr.measurements[MeasurementValue.KEY_APP_START_COLD]?.value)
   }
 
+  // region extended app start
+
+  private fun extendAppStartFinishedWith(status: SpanStatus, endMs: Long) {
+    val metrics = AppStartMetrics.getInstance()
+    metrics.extendAppStart()
+    val child = mock<ISpan>()
+    whenever(child.isFinished).thenReturn(true)
+    whenever(child.status).thenReturn(status)
+    whenever(child.finishDate).thenReturn(SentryLongDate(endMs * 1_000_000L))
+    metrics.pendingExtendedAppStartSpan!!.materialize(child)
+  }
+
+  @Test
+  fun `extended app start uses the extended end for the cold start measurement`() {
+    val sut = fixture.getSut(enablePerformanceV2 = true)
+    val metrics = AppStartMetrics.getInstance()
+    metrics.appStartType = AppStartType.COLD
+    metrics.isAppLaunchedInForeground = true
+    metrics.appStartTimeSpan.apply {
+      setStartedAt(1)
+      setStoppedAt(100)
+    }
+    val startMs = metrics.appStartTimeSpan.startTimestampMs
+    extendAppStartFinishedWith(SpanStatus.OK, startMs + 500)
+
+    var tr = createUiLoadTransactionWithAppStartChildSpan()
+    tr = sut.process(tr, Hint())
+
+    assertEquals(500f, tr.measurements[MeasurementValue.KEY_APP_START_COLD]?.value)
+  }
+
+  @Test
+  fun `extended app start that hit the deadline suppresses the measurement`() {
+    val sut = fixture.getSut(enablePerformanceV2 = true)
+    val metrics = AppStartMetrics.getInstance()
+    metrics.appStartType = AppStartType.COLD
+    metrics.isAppLaunchedInForeground = true
+    metrics.appStartTimeSpan.apply {
+      setStartedAt(1)
+      setStoppedAt(100)
+    }
+    val startMs = metrics.appStartTimeSpan.startTimestampMs
+    extendAppStartFinishedWith(SpanStatus.DEADLINE_EXCEEDED, startMs + 30_000)
+
+    var tr = createUiLoadTransactionWithAppStartChildSpan()
+    tr = sut.process(tr, Hint())
+
+    assertFalse(tr.measurements.containsKey(MeasurementValue.KEY_APP_START_COLD))
+    assertFalse(tr.measurements.containsKey(MeasurementValue.KEY_APP_START_WARM))
+  }
+
+  // endregion
+
   @Test
   fun `add cold start measurement for performance-v2`() {
     val sut = fixture.getSut(enablePerformanceV2 = true)
 
@@ -1059,6 +1059,14 @@ class AppStartMetricsTest {
     assertSame(first, metrics.pendingExtendedAppStartSpan)
   }
 
+  @Test
+  fun `extendAppStart is allowed when not launched in foreground (headless)`() {
+    val metrics = AppStartMetrics.getInstance()
+    metrics.isAppLaunchedInForeground = false
+    metrics.extendAppStart()
+    assertTrue(metrics.isExtendedAppStartPending)
+  }
+
   @Test
   fun `extendAppStart is ignored after start measurements were sent`() {
     val metrics = AppStartMetrics.getInstance()