chore(k1): checkpoint connection recovery work

apps/control-station/src/components/RerunViewport.tsx

@@ -292,6 +292,21 @@ export function isLiveRerunPresentationReady(
     isUsableRecordedPlaybackRange(rangeNs);
 }
 
+/**
+ * `recording_open` can arrive before Rerun has registered the live timeline.
+ * Selecting it at that point is a silent no-op, so keep retrying only until
+ * the exact live timeline is both available and active.
+ */
+export function liveTimelineNeedsSynchronization(
+  followLive: boolean,
+  activeTimeline: string | null | undefined,
+  rangeNs: { min: number; max: number } | null,
+): boolean {
+  return followLive &&
+    isUsableRecordedPlaybackRange(rangeNs) &&
+    activeTimeline !== "stream_time";
+}
+
 /**
  * Key the native receiver to its data-plane binding. Recovery authority is a
  * retry fence projected from changing supervisor snapshots; it must not tear
@@ -1435,6 +1450,7 @@ export function RerunViewport({
             let rangeNs = viewer.get_time_range(event.recording_id, timeline);
             let currentNs = viewer.get_current_time(event.recording_id, timeline);
             let playing = viewer.get_playing(event.recording_id);
+            let liveTimelineSynchronized = !followLive;
             if (!followLive && playing) {
               try {
                 viewer.set_playing(event.recording_id, false);
@@ -1496,6 +1512,17 @@ export function RerunViewport({
               if (disposed || !playbackState) return;
               try {
                 rangeNs = viewer.get_time_range(event.recording_id, timeline);
+                if (followLive && !liveTimelineSynchronized) {
+                  let activeTimeline = viewer.get_active_timeline(event.recording_id);
+                  if (liveTimelineNeedsSynchronization(followLive, activeTimeline, rangeNs)) {
+                    // The first selection above may have raced timeline
+                    // creation. Once a real range exists this retry is safe
+                    // and preserves Rerun's native live-following cursor.
+                    viewer.set_active_timeline(event.recording_id, timeline);
+                    activeTimeline = viewer.get_active_timeline(event.recording_id);
+                  }
+                  liveTimelineSynchronized = activeTimeline === timeline;
+                }
                 currentNs = viewer.get_current_time(event.recording_id, timeline);
                 playing = viewer.get_playing(event.recording_id);
               } catch {
@@ -1511,7 +1538,7 @@ export function RerunViewport({
                 setRecordingBufferProgress(recordedBuffer.bufferProgress);
               }
               const readyToRender = followLive
-                ? isLiveRerunPresentationReady(
+                ? liveTimelineSynchronized && isLiveRerunPresentationReady(
                     viewerStartResolved,
                     rangeNs,
                     liveActivitySequenceRef.current,

apps/control-station/src/workspaces/Workspaces.tsx

@@ -157,6 +157,7 @@ function SpatialWorkspace({
   const [showSegmentation, setShowSegmentation] = useState(false);
   const [showCuboids3d, setShowCuboids3d] = useState(false);
   const recordedSource = Boolean(recordedReplay) || /\.rrd(?:$|[?#])/i.test(sourceUrl);
+  const liveRerunSource = !recordedSource && /^rerun\+https?:\/\//i.test(sourceUrl.trim());
   const recordedSessionGate: RecordedAdmissionPhase = recordedSource
     ? recordedSessionAdmission?.phase ?? "loading"
     : "ready";
@@ -165,6 +166,10 @@ function SpatialWorkspace({
       isRecordedPlaybackPresentationReady(viewerStatus, playbackState));
   const streamActive = state?.sourceMode === "live" || state?.sourceMode === "replay";
   const metrics = streamActive ? state?.metrics : undefined;
+  // An explicit manual gRPC source has no Mission Core metrics producer. Its
+  // native Rerun range is therefore the only available activity proof.
+  const livePresentationActivitySequence = metrics?.publishedFrameCount ??
+    (liveRerunSource && !streamActive ? 1 : null);
   const latency = pipelineLatency(metrics);
   const frameRate = finiteMetric(metrics?.frameRateHz);
   const points = finiteMetric(metrics?.pointCount);
@@ -495,8 +500,8 @@ function SpatialWorkspace({
             <RerunViewport
               sourceUrl={sourceUrl}
               recordedArtifact={recordedSource ? recordedReplay : null}
-              followLive={!recordedReplay && streamActive}
-              liveActivitySequence={metrics?.publishedFrameCount}
+              followLive={liveRerunSource}
+              liveActivitySequence={livePresentationActivitySequence}
               liveStreamId={state?.spatialSource?.id}
               liveRecoveryAuthorityIdentity={!recordedSource && streamActive ? liveRerunRecoveryAuthorityIdentity(pointCloudSource, state?.spatialSource) : null}
               autoplayWhenReady={recordedSource}