diff --git a/app/components-react/highlighter/ImportStream.tsx b/app/components-react/highlighter/ImportStream.tsx
index 10bf49d3cced..db341cea3339 100644
--- a/app/components-react/highlighter/ImportStream.tsx
+++ b/app/components-react/highlighter/ImportStream.tsx
@@ -3,10 +3,15 @@ import { Services } from 'components-react/service-provider';
 import { ListInput, TextInput } from 'components-react/shared/inputs';
 import Form from 'components-react/shared/inputs/Form';
 import * as remote from '@electron/remote';
-import { SUPPORTED_FILE_TYPES } from 'services/highlighter/constants';
+import {
+  HIGHLIGHTER_APP_NAME,
+  REPLAY_APP_NAME,
+  SUPPORTED_FILE_TYPES,
+} from 'services/highlighter/constants';
 import { EGame } from 'services/highlighter/models/ai-highlighter.models';
 import {
   IStreamInfoForAiHighlighter,
+  TInstalledHighlighterApp,
   TOpenedFrom,
 } from 'services/highlighter/models/highlighter.models';
 import { $t } from 'services/i18n';
@@ -35,7 +40,7 @@ export function ImportStreamModal({
   streamInfo?: IStreamInfoForAiHighlighter;
 }) {
   const { HighlighterService, UsageStatisticsService, IncrementalRolloutService } = Services;
-  const [replayInstalled, setReplayInstalled] = useState<boolean | null>(null);
+  const [installedApp, setInstalledApp] = useState<TInstalledHighlighterApp | null>(null);
   const [showingInstallFlow, setShowingInstallFlow] = useState(false);
   const [pendingImport, setPendingImport] = useState<{
     game: EGame;
@@ -44,8 +49,8 @@ export function ImportStreamModal({
   } | null>(null);
 
   useEffect(() => {
-    HighlighterService.isStreamlabsReplayInstalled().then(installed => {
-      setReplayInstalled(installed);
+    HighlighterService.actions.return.getInstalledHighlighterApp().then(app => {
+      setInstalledApp(app);
     });
   }, []);
 
@@ -147,15 +152,20 @@ export function ImportStreamModal({
         return;
       }
 
-      // If Replay isn't installed yet, defer the import: stash the details, kick off the
-      // install, and replay it via onInstallComplete. This keeps every entry point (Go-live
-      // and the Highlighter page) on the same flow — game + title first, install second,
-      // then Replay opens directly on the import screen with the game and video.
-      const isInstalled = await HighlighterService.isStreamlabsReplayInstalled();
-      if (!isInstalled) {
+      // With neither app installed, hand the import to the installer instead of deeplinking it:
+      // the video and game go into the install origin marker, and Replay picks them up on its
+      // first launch. This keeps every entry point (Go-live and the Highlighter page) on the
+      // same flow — game + title first, install second, then Replay opens directly on the import
+      // screen with the game and video. pendingImport is only kept so a retry writes the same
+      // marker and so onInstallComplete can close this modal.
+      //
+      // With either app installed the import is deeplinked, and the service picks the protocol —
+      // a Highlighter user is sent to Highlighter, where their data still lives.
+      const app = await HighlighterService.actions.return.getInstalledHighlighterApp();
+      if (app === 'none') {
         setPendingImport({ game, filePath: filePath[0], streamId: id });
         setShowingInstallFlow(true);
-        HighlighterService.installStreamlabsReplay();
+        HighlighterService.actions.installStreamlabsReplay({ videoPath: filePath[0], game });
         return;
       }
 
@@ -183,23 +193,32 @@ export function ImportStreamModal({
     return (
       <MigrationNotice
         variant="modal"
+        installOriginMetadata={
+          pendingImport
+            ? { videoPath: pendingImport.filePath, game: pendingImport.game }
+            : undefined
+        }
         onCancel={() => {
           setShowingInstallFlow(false);
           closeModal(true);
         }}
         onInstallComplete={() => {
-          setReplayInstalled(true);
+          setInstalledApp('replay');
           setShowingInstallFlow(false);
 
-          // If there's a pending import, execute it now
+          // Deliberately no import deeplink here. The install origin marker already carried the
+          // video and game, and Replay acts on it when the installer launches it, so sending the
+          // link as well would open the same import a second time. Only the tracking the
+          // deeplink would have recorded is kept.
           if (pendingImport) {
-            HighlighterService.actions.openReplayImport(
-              pendingImport.filePath,
-              pendingImport.game,
+            UsageStatisticsService.recordAnalyticsEvent('AIHighlighter', {
+              type: 'ReplayImport',
               openedFrom,
-              pendingImport.streamId,
-              inputValue,
-            );
+              streamId: pendingImport.streamId,
+              game: pendingImport.game,
+              // Separates marker hand-offs from deeplinked imports in the ReplayImport numbers
+              via: 'install-marker',
+            });
             setPendingImport(null);
             closeModal(false);
           }
@@ -211,7 +230,7 @@ export function ImportStreamModal({
   // Show the install UI only once the user has committed to importing (game + title
   // selected, then startImport triggers the install). Applies to every entry point so
   // the import form is always shown first, never the install flow.
-  if (migrationEnabled && replayInstalled === false && showingInstallFlow) {
+  if (migrationEnabled && installedApp === 'none' && showingInstallFlow) {
     return (
       <HypeWrapper gameConfig={gameConfig} isAnimating={false} artwork={artwork}>
         {renderMigrationNotice()}
@@ -365,11 +384,16 @@ export function ImportStreamModal({
         </Button>
       </div>
       <div className={styles.explainerTextWrapper}>
-        {replayInstalled ? (
-          <p className={styles.explainerText}> Continuing will open Streamlabs Highlighter</p>
-        ) : (
-          <p className={styles.explainerText}> Continuing will install Streamlabs Highlighter</p>
-        )}
+        <p className={styles.explainerText}>
+          {' '}
+          {installedApp === 'replay' &&
+            $t('Continuing will open %{appName}', { appName: REPLAY_APP_NAME })}
+          {installedApp === 'highlighter' &&
+            $t('Continuing will open %{appName}', { appName: HIGHLIGHTER_APP_NAME })}
+          {installedApp !== 'replay' &&
+            installedApp !== 'highlighter' &&
+            $t('Continuing will install %{appName}', { appName: REPLAY_APP_NAME })}
+        </p>
       </div>
     </HypeWrapper>
   );
diff --git a/app/components-react/highlighter/SettingsView.tsx b/app/components-react/highlighter/SettingsView.tsx
index 6e0d22645f35..d3b45699528d 100644
--- a/app/components-react/highlighter/SettingsView.tsx
+++ b/app/components-react/highlighter/SettingsView.tsx
@@ -38,7 +38,7 @@ export default function SettingsView({
     EAvailableFeatures.highlighterMigration,
   );
 
-  const [isReplayInstalled, setIsReplayInstalled] = useState(false);
+  const [isReplayInstalled, setIsReplayInstalled] = useState<boolean | null>(null);
 
   useEffect(() => {
     if (!migrationEnabled) return;
@@ -56,7 +56,8 @@ export default function SettingsView({
     outputDisplay: StreamingService.views.outputDisplay,
   }));
 
-  const isInstalled = migrationEnabled ? isReplayInstalled : v.highlighterVersion !== '';
+  const installationCheckComplete = !migrationEnabled || isReplayInstalled !== null;
+  const isInstalled = migrationEnabled ? isReplayInstalled === true : v.highlighterVersion !== '';
 
   const disableAIHighlighter =
     (v.isVerticalRecording || v.isVerticalReplayBuffer) && v.outputDisplay === 'vertical';
@@ -197,6 +198,8 @@ export default function SettingsView({
     toggleUseAiHighlighter();
   }
 
+  if (!installationCheckComplete) return <div className={styles.settingsViewRoot} />;
+
   return (
     <div className={styles.settingsViewRoot}>
       <div style={{ display: 'flex', padding: 20 }}>
diff --git a/app/components-react/highlighter/migration/MigrationNotice.m.less b/app/components-react/highlighter/migration/MigrationNotice.m.less
index 3d78b6e8f563..fdc3b0757f65 100644
--- a/app/components-react/highlighter/migration/MigrationNotice.m.less
+++ b/app/components-react/highlighter/migration/MigrationNotice.m.less
@@ -168,6 +168,24 @@
 // Feature Carousel
 // =================================================================================================
 
+.app-detection {
+  width: 100%;
+  opacity: 0;
+  // Keeps the hidden carousel out of the tab order while app detection is pending — opacity and
+  // pointer-events alone leave the install CTA keyboard-focusable.
+  visibility: hidden;
+  pointer-events: none;
+  // Hold the visibility flip until the fade-out finishes; instant on the way in.
+  transition: opacity 160ms ease, visibility 0s linear 160ms;
+}
+
+.app-detection-ready {
+  opacity: 1;
+  visibility: visible;
+  pointer-events: auto;
+  transition: opacity 160ms ease, visibility 0s;
+}
+
 .carousel-wrapper {
   display: flex;
   background-color: var(--dark-background);
diff --git a/app/components-react/highlighter/migration/MigrationNotice.tsx b/app/components-react/highlighter/migration/MigrationNotice.tsx
index 654bef52fa6e..95e9d706ec1e 100644
--- a/app/components-react/highlighter/migration/MigrationNotice.tsx
+++ b/app/components-react/highlighter/migration/MigrationNotice.tsx
@@ -3,12 +3,15 @@ import { Services } from 'components-react/service-provider';
 import ModalInstallationFlow from './ModalInstallationFlow';
 import PageInstallationFlow from './PageInstallationFlow';
 import { EAvailableFeatures } from 'services/incremental-rollout';
+import { IReplayInstallOriginMetadata } from 'services/highlighter/models/highlighter.models';
 
 interface IMigrationNoticeProps {
   variant?: 'page' | 'modal';
   onShowAllClips?: () => void;
   onCancel?: () => void;
   onInstallComplete?: () => void;
+  /** Hand-off data for the install origin marker, used when the user retries a failed install. */
+  installOriginMetadata?: IReplayInstallOriginMetadata;
 }
 
 export default function MigrationNotice(props: IMigrationNoticeProps) {
@@ -37,7 +40,11 @@ export default function MigrationNotice(props: IMigrationNoticeProps) {
 
   if (variant === 'modal') {
     return (
-      <ModalInstallationFlow onCancel={handleCancel} onInstallComplete={props.onInstallComplete} />
+      <ModalInstallationFlow
+        onCancel={handleCancel}
+        onInstallComplete={props.onInstallComplete}
+        installOriginMetadata={props.installOriginMetadata}
+      />
     );
   }
 
diff --git a/app/components-react/highlighter/migration/ModalInstallationFlow.tsx b/app/components-react/highlighter/migration/ModalInstallationFlow.tsx
index 3bb302d97f37..0e5d4729e2d9 100644
--- a/app/components-react/highlighter/migration/ModalInstallationFlow.tsx
+++ b/app/components-react/highlighter/migration/ModalInstallationFlow.tsx
@@ -2,28 +2,35 @@ import React, { useEffect } from 'react';
 import { Button } from 'antd';
 import cx from 'classnames';
 import styles from './MigrationNotice.m.less';
-import { REPLAY_APP_NAME } from 'services/highlighter/constants';
+import { HIGHLIGHTER_APP_NAME, REPLAY_APP_NAME } from 'services/highlighter/constants';
 import { $t } from 'services/i18n';
 import Translate from 'components-react/shared/Translate';
 import SectionHeader from './SectionHeader';
 import { useInstallState, getStatusText } from './useInstallState';
+import { IReplayInstallOriginMetadata } from 'services/highlighter/models/highlighter.models';
 
 interface IModalInstallationFlowProps {
   onCancel: () => void;
   onInstallComplete?: () => void;
+  /** Hand-off data for the install origin marker, so a retry writes the same marker as the first
+   * attempt. */
+  installOriginMetadata?: IReplayInstallOriginMetadata;
 }
 
 export default function ModalInstallationFlow(props: IModalInstallationFlowProps) {
   const {
     step,
     progress,
+    installedApp,
     isInstalled,
     isInstalling,
     isRecorderRunning,
     handleOpenOrInstall,
     handleRetry,
     handleCancel,
-  } = useInstallState();
+  } = useInstallState(props.installOriginMetadata);
+
+  const appName = installedApp === 'highlighter' ? HIGHLIGHTER_APP_NAME : REPLAY_APP_NAME;
 
   useEffect(() => {
     if (step === 'done' && props.onInstallComplete) {
@@ -57,14 +64,11 @@ export default function ModalInstallationFlow(props: IModalInstallationFlowProps
 
     return (
       <div className={styles.migrationNoticeModal}>
-        <SectionHeader
-          title={$t('%{appName} is required', { appName: REPLAY_APP_NAME })}
-          onClose={props.onCancel}
-        />
+        <SectionHeader title={$t('%{appName} is required', { appName })} onClose={props.onCancel} />
         <p className={styles.subtitle}>
-          {$t('Install %{appName} to import and detect game highlights.', {
-            appName: REPLAY_APP_NAME,
-          })}
+          {installedApp === 'highlighter'
+            ? $t('Open %{appName} to import and detect game highlights.', { appName })
+            : $t('Install %{appName} to import and detect game highlights.', { appName })}
         </p>
         <div className={styles.actions}>
           <Button
@@ -72,9 +76,11 @@ export default function ModalInstallationFlow(props: IModalInstallationFlowProps
             onClick={() => handleOpenOrInstall('modal')}
             style={{ width: '100%' }}
           >
-            {isInstalled
-              ? $t('Open %{appName}', { appName: REPLAY_APP_NAME })
-              : $t('Install %{appName}', { appName: REPLAY_APP_NAME })}
+            {installedApp === 'replay' && $t('Open %{appName}', { appName: REPLAY_APP_NAME })}
+            {installedApp === 'highlighter' &&
+              $t('Open %{appName}', { appName: HIGHLIGHTER_APP_NAME })}
+            {(installedApp === 'none' || installedApp === null) &&
+              $t('Install %{appName}', { appName: REPLAY_APP_NAME })}
           </Button>
         </div>
       </div>
diff --git a/app/components-react/highlighter/migration/PageInstallationFlow.tsx b/app/components-react/highlighter/migration/PageInstallationFlow.tsx
index baa583140163..d5f48a69545a 100644
--- a/app/components-react/highlighter/migration/PageInstallationFlow.tsx
+++ b/app/components-react/highlighter/migration/PageInstallationFlow.tsx
@@ -1,13 +1,16 @@
 import React from 'react';
 import { Button } from 'antd';
 import cx from 'classnames';
-import { REPLAY_APP_NAME } from 'services/highlighter/constants';
+import { HIGHLIGHTER_APP_NAME, REPLAY_APP_NAME } from 'services/highlighter/constants';
 import { $t } from 'services/i18n';
 import Utils from 'services/utils';
 import styles from './MigrationNotice.m.less';
 import FeatureCarousel, { CAROUSEL_FEATURES } from './FeatureCarousel';
 import { useInstallState, getStatusText } from './useInstallState';
-import { EReplayInstallStep } from 'services/highlighter/models/highlighter.models';
+import {
+  EReplayInstallStep,
+  TInstalledHighlighterApp,
+} from 'services/highlighter/models/highlighter.models';
 
 interface IPageInstallationFlowProps {
   onCancel: () => void;
@@ -18,12 +21,14 @@ export default function PageInstallationFlow(props: IPageInstallationFlowProps)
   const {
     step,
     progress,
-    isInstalled,
+    installedApp,
     handleOpenOrInstall,
     handleRetry,
     handleCancel,
   } = useInstallState();
 
+  const appName = installedApp === 'highlighter' ? HIGHLIGHTER_APP_NAME : REPLAY_APP_NAME;
+
   function onCancel() {
     handleCancel();
     props.onCancel();
@@ -32,12 +37,17 @@ export default function PageInstallationFlow(props: IPageInstallationFlowProps)
   const isStaging = Utils.getHighlighterEnvironment() !== 'production';
 
   return (
-    <>
+    <div
+      className={cx(styles.appDetection, {
+        [styles.appDetectionReady]: installedApp !== null,
+      })}
+      aria-hidden={installedApp === null}
+    >
       <FeatureCarousel
-        title={REPLAY_APP_NAME}
+        title={appName}
         description={$t(
           'Turn your streams into TikTok and YouTube videos with the click of a button.',
-          { appName: REPLAY_APP_NAME },
+          { appName },
         )}
         features={CAROUSEL_FEATURES}
       >
@@ -48,7 +58,7 @@ export default function PageInstallationFlow(props: IPageInstallationFlowProps)
           <PageInstallCta
             step={step}
             progress={progress}
-            isInstalled={isInstalled ?? false}
+            installedApp={installedApp ?? 'none'}
             onOpenOrInstall={() => handleOpenOrInstall('page')}
             onRetry={handleRetry}
             onCancel={onCancel}
@@ -71,7 +81,7 @@ export default function PageInstallationFlow(props: IPageInstallationFlowProps)
           )}
         </div>
       </FeatureCarousel>
-    </>
+    </div>
   );
 }
 
@@ -80,7 +90,7 @@ export default function PageInstallationFlow(props: IPageInstallationFlowProps)
 interface IPageInstallCtaProps {
   step: EReplayInstallStep;
   progress: number;
-  isInstalled: boolean;
+  installedApp: TInstalledHighlighterApp;
   onOpenOrInstall: () => void;
   onShowAllClips: () => void;
   onRetry: () => void;
@@ -90,7 +100,7 @@ interface IPageInstallCtaProps {
 function PageInstallCta({
   step,
   progress,
-  isInstalled,
+  installedApp,
   onOpenOrInstall,
   onShowAllClips,
   onRetry,
@@ -98,12 +108,16 @@ function PageInstallCta({
 }: IPageInstallCtaProps) {
   const isInstalling = step === 'downloading' || step === 'installing' || step === 'verifying';
 
-  // Idle — CTA button (install or open depending on whether Replay is already installed)
+  // Nothing to open yet — the only state where the CTA is an install and the handwritten
+  // annotations teasing it make sense.
+  const nothingInstalled = installedApp === 'none';
+
+  // Idle — CTA button: open whichever app the user has, or install Replay when they have neither
   if (step === 'idle') {
     return (
       <div style={{ display: 'flex', gap: 8 }}>
         <div style={{ position: 'relative' }}>
-          {!isInstalled && (
+          {nothingInstalled && (
             <div style={{ position: 'absolute', left: 63, top: -32 }}>
               <svg
                 width="25"
@@ -147,10 +161,11 @@ function PageInstallCta({
             type="primary"
             onClick={onOpenOrInstall}
           >
-            {isInstalled
-              ? $t('Open %{appName}', { appName: REPLAY_APP_NAME })
-              : $t('Install %{appName}', { appName: REPLAY_APP_NAME })}
-            {!isInstalled && (
+            {installedApp === 'replay' && $t('Open %{appName}', { appName: REPLAY_APP_NAME })}
+            {installedApp === 'highlighter' &&
+              $t('Open %{appName}', { appName: HIGHLIGHTER_APP_NAME })}
+            {nothingInstalled && $t('Install %{appName}', { appName: REPLAY_APP_NAME })}
+            {nothingInstalled && (
               <div
                 style={{
                   position: 'absolute',
@@ -194,7 +209,7 @@ function PageInstallCta({
             )}
           </Button>
         </div>
-        {isInstalled && (
+        {!nothingInstalled && (
           <Button
             size="large"
             style={{ width: 'max-content' }}
@@ -219,10 +234,9 @@ function PageInstallCta({
           <div className={styles.progressBarRow}>
             <div className={styles.progressTrack}>
               <div
-                className={cx(
-                  styles.progressFill,
-                  step !== 'downloading' && styles.progressFillPulse,
-                )}
+                className={cx(styles.progressFill, {
+                  [styles.progressFillPulse]: step !== 'downloading',
+                })}
                 style={{ width: step === 'downloading' ? `${progress}%` : '100%' }}
               />
             </div>
diff --git a/app/components-react/highlighter/migration/useInstallState.ts b/app/components-react/highlighter/migration/useInstallState.ts
index 580b04d9e4e0..a405ff212614 100644
--- a/app/components-react/highlighter/migration/useInstallState.ts
+++ b/app/components-react/highlighter/migration/useInstallState.ts
@@ -1,16 +1,28 @@
 import { useEffect, useState } from 'react';
 import { Services } from 'components-react/service-provider';
 import { useVuex } from 'components-react/hooks';
-import { EReplayInstallStep } from 'services/highlighter/models/highlighter.models';
+import {
+  EReplayInstallStep,
+  IReplayInstallOriginMetadata,
+  TInstalledHighlighterApp,
+} from 'services/highlighter/models/highlighter.models';
 import { REPLAY_APP_NAME } from 'services/highlighter/constants';
 import { $t } from 'services/i18n';
 
-export function useInstallState() {
+/**
+ * @param installOriginMetadata - Hand-off data for the install origin marker, passed on again when
+ * the user retries a failed install so the retry writes the same marker as the first attempt.
+ */
+export function useInstallState(installOriginMetadata?: IReplayInstallOriginMetadata) {
   const { HighlighterService } = Services;
 
-  const [isInstalled, setIsInstalled] = useState<boolean | null>(null);
+  const [installedApp, setInstalledApp] = useState<TInstalledHighlighterApp | null>(null);
   const [isRecorderRunning, setIsRecorderRunning] = useState(false);
 
+  // Kept as the Replay-installed boolean the existing conditionals were written against. A
+  // Highlighter user has an app but not this one, so they are deliberately not "installed" here.
+  const isInstalled = installedApp === null ? null : installedApp === 'replay';
+
   const { step, progress, error } = useVuex(() => ({
     step: HighlighterService.state.replayInstall.step as EReplayInstallStep,
     progress: HighlighterService.state.replayInstall.progress as number,
@@ -20,16 +32,17 @@ export function useInstallState() {
   const isInstalling = step === 'downloading' || step === 'installing' || step === 'verifying';
 
   useEffect(() => {
-    HighlighterService.actions.return.isStreamlabsReplayInstalled().then(installed => {
-      setIsInstalled(installed);
-      if (installed) {
+    HighlighterService.actions.return.getInstalledHighlighterApp().then(app => {
+      setInstalledApp(app);
+      // The recorder belongs to Replay, so there is nothing to look for in the other two states.
+      if (app === 'replay') {
         HighlighterService.actions.return.isStreamlabsRecorderRunning().then(setIsRecorderRunning);
       }
     });
   }, []);
 
   useEffect(() => {
-    if (step === 'done') setIsInstalled(true);
+    if (step === 'done') setInstalledApp('replay');
   }, [step]);
 
   function handleOpenOrInstall(source: 'page' | 'modal') {
@@ -37,7 +50,7 @@ export function useInstallState() {
   }
 
   function handleRetry() {
-    HighlighterService.actions.installStreamlabsReplay();
+    HighlighterService.actions.installStreamlabsReplay(installOriginMetadata);
   }
 
   function handleCancel() {
@@ -48,6 +61,7 @@ export function useInstallState() {
     step,
     progress,
     error,
+    installedApp,
     isInstalled,
     isInstalling,
     isRecorderRunning,
diff --git a/app/components-react/pages/Highlighter.tsx b/app/components-react/pages/Highlighter.tsx
index bcb427830a80..da5b9daf0e36 100644
--- a/app/components-react/pages/Highlighter.tsx
+++ b/app/components-react/pages/Highlighter.tsx
@@ -34,7 +34,7 @@ export default function Highlighter(props: { params?: { view: string } }) {
   } else if (clipsAmount > 0) {
     initialViewState = { view: EHighlighterView.CLIPS, id: undefined };
   } else {
-    initialViewState = { view: EHighlighterView.SETTINGS };
+    initialViewState = { view: EHighlighterView.STREAM };
   }
 
   useEffect(() => {
diff --git a/app/i18n/en-US/highlighter.json b/app/i18n/en-US/highlighter.json
index 8e60affd5198..1e2b88eed576 100644
--- a/app/i18n/en-US/highlighter.json
+++ b/app/i18n/en-US/highlighter.json
@@ -183,7 +183,10 @@
   "Install %{appName} to import and detect game highlights.": "Install %{appName} to import and detect game highlights.",
   "Open %{appName}": "Open %{appName}",
   "Install %{appName}": "Install %{appName}",
+  "Open %{appName} to import and detect game highlights.": "Open %{appName} to import and detect game highlights.",
   "%{appName} has been installed and is now running.": "%{appName} has been installed and is now running.",
+  "Continuing will open %{appName}": "Continuing will open %{appName}",
+  "Continuing will install %{appName}": "Continuing will install %{appName}",
   "Installing Highlighter": "Installing Highlighter",
   "Installation interrupted": "Installation interrupted",
   "It seems the installation didn't finish.": "It seems the installation didn't finish.",
diff --git a/app/services/highlighter/constants.ts b/app/services/highlighter/constants.ts
index 8d4d7bb6792f..267b5cc5dd22 100644
--- a/app/services/highlighter/constants.ts
+++ b/app/services/highlighter/constants.ts
@@ -32,12 +32,30 @@ export const AI_HIGHLIGHTER_BUILDS_URL_STAGING =
 export const AI_HIGHLIGHTER_BUILDS_URL_PRODUCTION =
   'https://cdn-highlighter-builds.streamlabs.com/production/manifest_win_x86_64.json';
 
-export const HIGHLIGHTER_SETUP_URL_STAGING =
-  'https://cdn-highlighter-desktop.streamlabs.com/streamlabs-highlighter/staging/win32/x64/Streamlabs%20Highlighter-Setup.exe';
-
-export const HIGHLIGHTER_SETUP_URL_PRODUCTION =
-  'https://cdn-highlighter-desktop.streamlabs.com/streamlabs-highlighter/production/win32/x64/Streamlabs%20Highlighter-Setup.exe';
-
-export const REPLAY_PROTOCOL = 'streamlabs-highlighter';
-export const REPLAY_APP_NAME = 'Streamlabs Highlighter';
-export const REPLAY_SETUP_EXE_NAME = 'Streamlabs Highlighter-Setup.exe';
+export const REPLAY_SETUP_URL_STAGING =
+  'https://cdn-highlighter-desktop.streamlabs.com/replay/staging/win32/x64/G+HUB+Replay-Setup.exe';
+
+export const REPLAY_SETUP_URL_PRODUCTION =
+  'https://cdn-highlighter-desktop.streamlabs.com/replay/production/win32/x64/G+HUB+Replay-Setup.exe';
+
+export const REPLAY_PROTOCOL = 'ghub-replay';
+export const REPLAY_APP_NAME = 'Replay';
+export const REPLAY_SETUP_EXE_NAME = 'G HUB Replay-Setup.exe';
+
+// The standalone app Replay replaces. Users who still have it keep their data by migrating from
+// inside it — Highlighter merges and installs Replay itself — so Desktop hands them over instead
+// of installing Replay behind its back. This protocol is what REPLAY_PROTOCOL held before the
+// rename, and it is all we have to detect the legacy app with.
+export const HIGHLIGHTER_PROTOCOL = 'streamlabs-highlighter';
+export const HIGHLIGHTER_APP_NAME = 'Streamlabs Highlighter';
+
+// Origin slug Replay attributes an install to when Streamlabs Desktop installed it.
+export const REPLAY_INSTALL_ORIGIN = 'sl_desktop';
+
+// The install origin marker is a hand-off file, so it lives in the current user's temp directory
+// (%TEMP%\GHUB_Replay\install-origin.json) rather than in either app's data directory. It has to
+// work before Replay is installed at all, and Replay deletes it as soon as it has been read.
+// Deliberately not derived from REPLAY_APP_NAME: this directory name is a contract with Replay and
+// does not follow the app rename.
+export const REPLAY_INSTALL_ORIGIN_DIR_NAME = 'GHUB_Replay';
+export const REPLAY_INSTALL_ORIGIN_FILE_NAME = 'install-origin.json';
diff --git a/app/services/highlighter/index.ts b/app/services/highlighter/index.ts
index 6c6d5ce6fe62..5e3379a2389f 100644
--- a/app/services/highlighter/index.ts
+++ b/app/services/highlighter/index.ts
@@ -15,10 +15,14 @@ import os from 'os';
 import {
   SCRUB_SPRITE_DIRECTORY,
   SUPPORTED_FILE_TYPES,
-  HIGHLIGHTER_SETUP_URL_STAGING,
-  HIGHLIGHTER_SETUP_URL_PRODUCTION,
+  REPLAY_SETUP_URL_STAGING,
+  REPLAY_SETUP_URL_PRODUCTION,
   REPLAY_PROTOCOL,
+  HIGHLIGHTER_PROTOCOL,
   REPLAY_SETUP_EXE_NAME,
+  REPLAY_INSTALL_ORIGIN,
+  REPLAY_INSTALL_ORIGIN_DIR_NAME,
+  REPLAY_INSTALL_ORIGIN_FILE_NAME,
 } from './constants';
 import { pmap } from 'util/pmap';
 import { RenderingClip } from './rendering/rendering-clip';
@@ -55,7 +59,9 @@ import {
   EHighlighterView,
   ITempRecordingInfo,
   IReplayInstallState,
+  IReplayInstallOriginMetadata,
   EReplayInstallStep,
+  TInstalledHighlighterApp,
   TOpenedFrom,
 } from './models/highlighter.models';
 import {
@@ -340,10 +346,11 @@ export class HighlighterService extends PersistentStatefulService<IHighlighterSt
   // =================================================================================================
 
   /**
-   * Checks if Streamlabs Replay is installed by verifying the Windows deeplink protocol registration
-   * @returns Promise<boolean> - true if the ${REPLAY_PROTOCOL} protocol is registered, false otherwise
+   * Checks whether an app is installed by looking up its deeplink protocol handler in the Windows
+   * Registry. Registering the protocol is the only trace either app leaves that we can rely on.
+   * @returns Promise<boolean> - true if the protocol is registered to an executable
    */
-  async isStreamlabsReplayInstalled(): Promise<boolean> {
+  private async isProtocolRegistered(protocol: string): Promise<boolean> {
     // Only check on Windows
     if (getOS() !== OS.Windows) {
       return false;
@@ -352,7 +359,7 @@ export class HighlighterService extends PersistentStatefulService<IHighlighterSt
     try {
       // Query the Windows Registry for the protocol handler command
       const { stdout, stderr } = await execAsync(
-        `reg query "HKEY_CLASSES_ROOT\\${REPLAY_PROTOCOL}\\shell\\open\\command" /ve`,
+        `reg query "HKEY_CLASSES_ROOT\\${protocol}\\shell\\open\\command" /ve`,
         {
           timeout: 5000,
         },
@@ -373,6 +380,39 @@ export class HighlighterService extends PersistentStatefulService<IHighlighterSt
     }
   }
 
+  /**
+   * Checks if Streamlabs Replay is installed by verifying the Windows deeplink protocol registration
+   * @returns Promise<boolean> - true if the ${REPLAY_PROTOCOL} protocol is registered, false otherwise
+   */
+  async isStreamlabsReplayInstalled(): Promise<boolean> {
+    return this.isProtocolRegistered(REPLAY_PROTOCOL);
+  }
+
+  /**
+   * Checks if the standalone Streamlabs Highlighter app — the one Replay replaces — is installed.
+   * @returns Promise<boolean> - true if the ${HIGHLIGHTER_PROTOCOL} protocol is registered
+   */
+  async isStreamlabsHighlighterInstalled(): Promise<boolean> {
+    return this.isProtocolRegistered(HIGHLIGHTER_PROTOCOL);
+  }
+
+  /**
+   * Single source of truth for which app Desktop should talk to.
+   *
+   * Replay wins whenever it exists, so a user who has both is never sent backwards. Highlighter
+   * only answers when Replay is absent, and that user is handed to Highlighter rather than having
+   * Replay installed underneath them: Highlighter is where the data merge happens, and it installs
+   * Replay at the end of it.
+   *
+   * The Highlighter lookup is skipped entirely once Replay is found — that is the common case and
+   * it should not pay for a second registry query.
+   */
+  async getInstalledHighlighterApp(): Promise<TInstalledHighlighterApp> {
+    if (await this.isStreamlabsReplayInstalled()) return 'replay';
+    if (await this.isStreamlabsHighlighterInstalled()) return 'highlighter';
+    return 'none';
+  }
+
   /**
    * Checks if the StreamlabsRecorder.exe process is currently running
    * @returns Promise<boolean> - true if process is running, false otherwise
@@ -403,9 +443,9 @@ export class HighlighterService extends PersistentStatefulService<IHighlighterSt
 
   private getReplaySetupUrl(): string {
     if (Utils.getHighlighterEnvironment() === 'production') {
-      return HIGHLIGHTER_SETUP_URL_PRODUCTION;
+      return REPLAY_SETUP_URL_PRODUCTION;
     }
-    return HIGHLIGHTER_SETUP_URL_STAGING;
+    return REPLAY_SETUP_URL_STAGING;
   }
 
   /**
@@ -507,14 +547,150 @@ export class HighlighterService extends PersistentStatefulService<IHighlighterSt
     }
   }
 
+  /**
+   * Dev-only escape hatch for testing the install flow against a locally built Replay installer
+   * instead of the CDN one. Set HIGHLIGHTER_LOCAL_SETUP_PATH to the setup exe before launching, e.g.
+   *
+   *   set "HIGHLIGHTER_LOCAL_SETUP_PATH=C:\path\to\Streamlabs Highlighter-0.0.16 Setup.exe"
+   *
+   * Read from remote.process.env at runtime (via Utils.env), so it takes effect on the next
+   * `yarn start` with no rebuild — unlike HIGHLIGHTER_ENV, which webpack bakes in at compile time.
+   *
+   * Gated on dev mode: a local build is not signed by Logitech, so this path skips the Authenticode
+   * check, and that check must stay unconditional in shipped builds.
+   *
+   * Throws if the path is set but missing, rather than silently falling back to the CDN download —
+   * a typo should be visible, not quietly ignored.
+   */
+  private async getLocalReplaySetupPath(): Promise<string | null> {
+    if (!Utils.isDevMode()) return null;
+
+    const configuredPath = Utils.env.HIGHLIGHTER_LOCAL_SETUP_PATH?.trim();
+    if (!configuredPath) return null;
+
+    // Tolerate a value pasted with surrounding quotes, which is easy to do for a path with spaces
+    const setupPath = path.resolve(configuredPath.replace(/^"(.*)"$/, '$1'));
+
+    if (!(await fs.pathExists(setupPath))) {
+      throw new Error(
+        `HIGHLIGHTER_LOCAL_SETUP_PATH is set but no installer exists at "${setupPath}".`,
+      );
+    }
+
+    return setupPath;
+  }
+
+  /**
+   * Where Replay looks for the install origin marker, given who we are running as.
+   *
+   * Replay reads exactly one location: the current user's temp directory. A parent writing under a
+   * different identity gets a different %TEMP% — SYSTEM and services land in C:\Windows\TEMP or a
+   * profile under the Windows directory — and the marker would sit somewhere Replay never reads.
+   * Those identities are recognised by their profile: SYSTEM sits in
+   * C:\Windows\system32\config\systemprofile and the service accounts in C:\Windows\ServiceProfiles,
+   * both under %SystemRoot%. Elevation alone is fine: "run as administrator" from the user's own
+   * account keeps the profile.
+   *
+   * Deliberately does not require temp to sit under the home directory. %TEMP% is an ordinary
+   * per-user environment variable, and redirecting it to another drive or an enterprise-managed
+   * path is a supported configuration — Replay, running as the same user, resolves the same
+   * redirected path, so the hand-off still works.
+   *
+   * Throws rather than returning a path we know Replay will not read.
+   */
+  private getReplayInstallOriginMarkerPath(): string {
+    const isInside = (child: string, parent: string) => {
+      const relativePath = path.relative(parent, child);
+      return (
+        relativePath !== '' && !relativePath.startsWith('..') && !path.isAbsolute(relativePath)
+      );
+    };
+
+    const temp = remote.app.getPath('temp');
+    const home = remote.app.getPath('home');
+    const systemRoot = remote.process.env.SystemRoot ?? 'C:\\Windows';
+
+    if (isInside(home, systemRoot)) {
+      throw new Error(`"${temp}" is not the desktop user's temp directory`);
+    }
+
+    return path.join(temp, REPLAY_INSTALL_ORIGIN_DIR_NAME, REPLAY_INSTALL_ORIGIN_FILE_NAME);
+  }
+
+  /**
+   * Writes the marker Streamlabs Replay reads on first run to attribute the install to
+   * Streamlabs Desktop.
+   *
+   * Must run before the installer is executed: Squirrel's Setup.exe launches Replay at the end of
+   * the install, so Replay can resolve its origin while our exec call is still pending.
+   *
+   * When the install was triggered from the import dialog, the marker also carries what the user
+   * picked there, under `metadata`: the recording and its game. Those are the exact values Desktop
+   * would otherwise pass via the `import` deeplink once the install finishes, so Replay can see it
+   * coming — the marker is the hand-off for that single import, not a second unrelated one.
+   *
+   * Best-effort by design. Attribution is never worth failing an install over, so every error is
+   * swallowed and only reported to Sentry.
+   */
+  private async writeReplayInstallOriginMarker(
+    metadata?: IReplayInstallOriginMetadata,
+  ): Promise<void> {
+    try {
+      const markerPath = this.getReplayInstallOriginMarkerPath();
+
+      const videoPath = metadata?.videoPath?.trim();
+      const game = metadata?.game;
+
+      // Only carry entries we actually have: an absent key is easier for Replay to reason about
+      // than one holding an empty value.
+      const markerMetadata = {
+        ...(videoPath ? { videoPath } : {}),
+        ...(game ? { game } : {}),
+      };
+      const hasMetadata = Object.keys(markerMetadata).length > 0;
+
+      // outputJson creates the containing directory if it does not exist yet.
+      // `metadata` itself is omitted when there is nothing to hand over, so Replay never has to
+      // tell an empty object apart from a missing one.
+      await fs.outputJson(markerPath, {
+        version: 1,
+        origin: REPLAY_INSTALL_ORIGIN,
+        createdAt: new Date().toISOString(),
+        ...(hasMetadata ? { metadata: markerMetadata } : {}),
+      });
+
+      // Replay logs the path it looked at on every launch until the origin settles. Two paths that
+      // do not match is the whole diagnosis, so log ours and the identity that wrote it.
+      console.log(
+        `Wrote Streamlabs Replay install origin marker to "${markerPath}" as "${
+          os.userInfo().username
+        }"${hasMetadata ? ` with ${JSON.stringify(markerMetadata)}` : ''}`,
+      );
+    } catch (error: unknown) {
+      Sentry.withScope(scope => {
+        scope.setTag('feature', 'highlighter');
+        scope.setTag('replayInstallPhase', 'write-install-origin');
+        console.error('Failed to write Streamlabs Replay install origin marker:', error);
+        // Captured explicitly on top of the console line: a silently lost marker costs the user
+        // their import hand-off, so it is worth a real exception event — with a stack and grouped
+        // by what actually failed — rather than only the message event the console patch sends.
+        Sentry.captureException(error);
+      });
+    }
+  }
+
   /**
    * Downloads and installs Streamlabs Replay.
    * Fakes progress increments during the download/install phases,
    * verifies the deeplink registry after install, and auto-launches the app.
+   *
+   * @param originMetadata - Optional hand-off data for the install origin marker: the video and
+   * game the import dialog wants Replay to open with. Passing it here is what replaces the import
+   * deeplink — Replay reads the marker on its first launch, so nothing is sent afterwards.
    */
   private replayInstallAbortController: AbortController | null = null;
 
-  async installStreamlabsReplay(): Promise<boolean> {
+  async installStreamlabsReplay(originMetadata?: IReplayInstallOriginMetadata): Promise<boolean> {
     if (getOS() !== OS.Windows) {
       Sentry.withScope(scope => {
         scope.setTag('feature', 'highlighter');
@@ -551,17 +727,28 @@ export class HighlighterService extends PersistentStatefulService<IHighlighterSt
       // --- Downloading phase ---
       this.SET_REPLAY_INSTALL({ step: 'downloading', progress: 0, error: null });
 
-      const setupUrl = this.getReplaySetupUrl();
+      // Dev only. When set, this is a locally built installer we neither downloaded nor own,
+      // so the download, the signature check and the cleanup below are all skipped for it.
+      const localSetupPath = await this.getLocalReplaySetupPath();
+      let setupPath: string;
+
+      if (localSetupPath) {
+        console.info('Installing Streamlabs Replay from local build:', localSetupPath);
+        setupPath = localSetupPath;
+        this.setReplayDownloadProgress(94);
+      } else {
+        const setupUrl = this.getReplaySetupUrl();
 
-      // Download the setup exe to temp directory
-      const tempDir = os.tmpdir();
-      const setupPath = path.join(tempDir, REPLAY_SETUP_EXE_NAME);
+        // Download the setup exe to temp directory
+        const tempDir = os.tmpdir();
+        setupPath = path.join(tempDir, REPLAY_SETUP_EXE_NAME);
 
-      await downloadFile(setupUrl, setupPath, (progress: IDownloadProgress) => {
-        // Map download progress to 0-94%
-        const downloadPercent = progress.percent * 94;
-        this.setReplayDownloadProgress(downloadPercent);
-      });
+        await downloadFile(setupUrl, setupPath, (progress: IDownloadProgress) => {
+          // Map download progress to 0-94%
+          const downloadPercent = progress.percent * 94;
+          this.setReplayDownloadProgress(downloadPercent);
+        });
+      }
 
       clearProgress();
 
@@ -573,8 +760,18 @@ export class HighlighterService extends PersistentStatefulService<IHighlighterSt
         return false;
       }
 
-      // Verify the Authenticode signature before execution
-      await this.verifyAuthenticodeSignature(setupPath);
+      if (localSetupPath) {
+        // A local build is not signed by Logitech, so the check would always fail here
+        console.warn('Skipping installer signature verification for local Streamlabs Replay build');
+      } else {
+        // Verify the Authenticode signature before execution
+        await this.verifyAuthenticodeSignature(setupPath);
+      }
+
+      // Attribute this install to Streamlabs Desktop before the installer runs, and hand over
+      // whatever we already know about what comes next (the video and game to import).
+      // Best-effort: this never throws and never blocks the install.
+      await this.writeReplayInstallOriginMarker(originMetadata);
 
       // --- Installing phase ---
       this.SET_REPLAY_INSTALL({ step: 'installing', progress: 94 });
@@ -636,11 +833,13 @@ export class HighlighterService extends PersistentStatefulService<IHighlighterSt
         });
       }
 
-      // Clean up setup file
-      try {
-        await fs.remove(setupPath);
-      } catch {
-        // Non-critical cleanup
+      // Clean up setup file. Never for a local build — that is the developer's own artifact.
+      if (!localSetupPath) {
+        try {
+          await fs.remove(setupPath);
+        } catch {
+          // Non-critical cleanup
+        }
       }
 
       // Track installation finished successfully
@@ -701,71 +900,101 @@ export class HighlighterService extends PersistentStatefulService<IHighlighterSt
   }
 
   /**
-   * Opens Streamlabs Replay or starts installation if not installed
-   * @param source - Where the action was initiated from ('page' or 'modal')
-   * @returns Promise<boolean> - true if Replay was opened, false if installation was started
+   * Launches an app through its deeplink protocol, falling back to the bare scheme.
+   * @returns Promise<boolean> - false when neither form could be opened, which in practice means
+   * the protocol is registered but the app itself is gone.
    */
-  async openReplay(source: 'page' | 'modal'): Promise<boolean> {
-    const isInstalled = await this.isStreamlabsReplayInstalled();
-
-    if (isInstalled) {
-      // Track opening Replay
-      this.usageStatisticsService.recordAnalyticsEvent('AIHighlighter', {
-        type: 'ReplayOpen',
-        source,
+  private async openProtocol(protocol: string): Promise<boolean> {
+    try {
+      await remote.shell.openExternal(`${protocol}://open`);
+      return true;
+    } catch (error: unknown) {
+      Sentry.withScope(scope => {
+        scope.setTag('feature', 'highlighter');
+        console.error(`Failed to open "${protocol}":`, error);
       });
-
-      // Open Streamlabs Replay via deeplink
       try {
-        await remote.shell.openExternal(`${REPLAY_PROTOCOL}://open`);
+        await remote.shell.openExternal(`${protocol}:`);
         return true;
-      } catch (error: unknown) {
+      } catch (fallbackError: unknown) {
         Sentry.withScope(scope => {
           scope.setTag('feature', 'highlighter');
-          console.error('Failed to open Streamlabs Replay:', error);
+          console.error(`Failed to open "${protocol}" with fallback:`, fallbackError);
         });
-        try {
-          await remote.shell.openExternal(`${REPLAY_PROTOCOL}:`);
-          return true;
-        } catch (fallbackError: unknown) {
-          Sentry.withScope(scope => {
-            scope.setTag('feature', 'highlighter');
-            console.error('Failed to open Streamlabs Replay with fallback:', fallbackError);
-          });
-          // Protocol is registered but app is missing — start installation
-          this.installStreamlabsReplay();
-          return false;
-        }
+        return false;
       }
-    } else {
-      // Track installation click
+    }
+  }
+
+  /**
+   * Opens whichever app the user should land in, installing Replay when there is none.
+   *
+   * - Replay installed -> open Replay (whether or not Highlighter is also still around).
+   * - Only Highlighter installed -> open Highlighter. It owns the data merge and installs Replay
+   *   at the end of it, so Desktop must not install Replay behind its back.
+   * - Neither -> install Replay.
+   *
+   * A protocol that is registered but will not launch means the app was removed without
+   * unregistering, so it falls through to the install.
+   *
+   * @param source - Where the action was initiated from ('page' or 'modal')
+   * @returns Promise<boolean> - true if an app was opened, false if installation was started
+   */
+  async openReplay(source: 'page' | 'modal'): Promise<boolean> {
+    const app = await this.getInstalledHighlighterApp();
+
+    if (app === 'replay') {
       this.usageStatisticsService.recordAnalyticsEvent('AIHighlighter', {
-        type: 'ReplayInstallationClick',
+        type: 'ReplayOpen',
         source,
       });
-
-      // Start installation flow for Streamlabs Replay (don't await so UI can update)
-      this.installStreamlabsReplay();
-      return false;
+      if (await this.openProtocol(REPLAY_PROTOCOL)) return true;
+    } else if (app === 'highlighter') {
+      this.usageStatisticsService.recordAnalyticsEvent('AIHighlighter', {
+        type: 'HighlighterAppOpen',
+        source,
+      });
+      if (await this.openProtocol(HIGHLIGHTER_PROTOCOL)) return true;
     }
+
+    // Track installation click
+    this.usageStatisticsService.recordAnalyticsEvent('AIHighlighter', {
+      type: 'ReplayInstallationClick',
+      source,
+    });
+
+    // Start installation flow for Streamlabs Replay (don't await so UI can update)
+    this.installStreamlabsReplay();
+    return false;
   }
 
   /**
-   * Opens Streamlabs Replay with an import deeplink
+   * Opens the installed app with an import deeplink.
+   *
+   * Both apps take the same `import` route and the same params, so the only thing that varies is
+   * the protocol. A Highlighter user is deeplinked into Highlighter rather than Replay: the import
+   * lands in the app that still holds their data.
+   *
+   * Callers gate on {@link getInstalledHighlighterApp} first — with nothing installed there is no
+   * app to deeplink into, and that path runs the installer instead.
+   *
    * @param videoPath - Path to the video file to import
    * @param game - The game type for the video
    * @param openedFrom - Where the import was initiated from
    * @param streamId - Optional stream ID for tracking
    * @param title - Optional title for the recording
    */
-  openReplayImport(
+  async openReplayImport(
     videoPath: string,
     game: string,
     openedFrom: TOpenedFrom,
     streamId?: string,
     title?: string,
-  ): void {
-    let deeplink = `${REPLAY_PROTOCOL}://import?path=${encodeURIComponent(
+  ): Promise<void> {
+    const app = await this.getInstalledHighlighterApp();
+    const protocol = app === 'highlighter' ? HIGHLIGHTER_PROTOCOL : REPLAY_PROTOCOL;
+
+    let deeplink = `${protocol}://import?path=${encodeURIComponent(
       videoPath,
     )}&game=${encodeURIComponent(game)}`;
 
@@ -775,8 +1004,10 @@ export class HighlighterService extends PersistentStatefulService<IHighlighterSt
 
     remote.shell.openExternal(deeplink);
 
+    // Tracked as a separate event rather than a flag on ReplayImport so a migration-era Highlighter
+    // import never inflates the Replay import numbers.
     this.usageStatisticsService.recordAnalyticsEvent('AIHighlighter', {
-      type: 'ReplayImport',
+      type: app === 'highlighter' ? 'HighlighterAppImport' : 'ReplayImport',
       openedFrom,
       streamId,
       game,
@@ -1376,23 +1607,13 @@ export class HighlighterService extends PersistentStatefulService<IHighlighterSt
           }
 
           if (this.getClips(this.views.clips, streamId).length === 0) {
-            if (streamId) {
-              this.navigationService.actions.navigate(
-                'Highlighter',
-                {
-                  view: EHighlighterView.STREAM,
-                },
-                EMenuItemKey.Highlighter,
-              );
-            } else {
-              this.navigationService.actions.navigate(
-                'Highlighter',
-                {
-                  view: EHighlighterView.SETTINGS,
-                },
-                EMenuItemKey.Highlighter,
-              );
-            }
+            this.navigationService.actions.navigate(
+              'Highlighter',
+              {
+                view: EHighlighterView.STREAM,
+              },
+              EMenuItemKey.Highlighter,
+            );
           }
         } catch (error: unknown) {
           console.error('Error deleting clip or folder:', error);
@@ -1810,7 +2031,10 @@ export class HighlighterService extends PersistentStatefulService<IHighlighterSt
     );
 
     if (migrationEnabled) {
-      await this.installStreamlabsReplay();
+      // Routes through openReplay rather than installing directly, so a user who still has the
+      // standalone Highlighter app is sent there to migrate instead of getting Replay installed
+      // underneath them.
+      await this.openReplay('page');
     } else {
       this.usageStatisticsService.recordAnalyticsEvent('AIHighlighter', {
         type: 'Installation',
diff --git a/app/services/highlighter/models/highlighter.models.ts b/app/services/highlighter/models/highlighter.models.ts
index 245ae89168c7..0c21e0b889b2 100644
--- a/app/services/highlighter/models/highlighter.models.ts
+++ b/app/services/highlighter/models/highlighter.models.ts
@@ -51,6 +51,32 @@ export interface IReplayInstallState {
   error: string | null;
 }
 
+/**
+ * Which of the two apps Desktop should talk to.
+ *
+ * Replay replaces the standalone Highlighter app, but Highlighter users migrate from inside
+ * Highlighter so they keep their data — it merges and installs Replay itself. So a user who only
+ * has Highlighter gets sent there rather than having Replay installed underneath them, and Replay
+ * wins as soon as it exists.
+ */
+export type TInstalledHighlighterApp = 'replay' | 'highlighter' | 'none';
+
+/**
+ * Extra hand-off data written into the install origin marker Replay reads on first run.
+ *
+ * Everything here is optional and best-effort: it describes what Desktop is about to ask Replay
+ * to do once the install finishes, so Replay launch the onboarding with more context.
+ */
+export interface IReplayInstallOriginMetadata {
+  /**
+   * Absolute path of the recording the user picked in the import dialog — the same path Desktop
+   * sends via the `import` deeplink.
+   */
+  videoPath?: string;
+  /** Game the user picked for that recording */
+  game?: EGame;
+}
+
 // CLIP
 export interface INewClipData {
   path: string;
diff --git a/app/services/utils.ts b/app/services/utils.ts
index c54c734089e3..b5776d535aff 100644
--- a/app/services/utils.ts
+++ b/app/services/utils.ts
@@ -26,6 +26,9 @@ export interface IEnv {
   SLD_GUEST_CAM_HASH: string;
   CI: boolean;
   HIGHLIGHTER_ENV: 'production' | 'staging' | 'local';
+  // Dev only: absolute path to a locally built Streamlabs Replay installer. When set, the Replay
+  // install flow runs that exe instead of downloading one from the CDN.
+  HIGHLIGHTER_LOCAL_SETUP_PATH?: string;
   PRODUCT_UPDATES: boolean;
   AVATAR_ENV?: 'production' | 'staging' | 'local';
 }