diff --git a/.changes/parental-lock-external-players.md b/.changes/parental-lock-external-players.md
new file mode 100644
index 0000000000..18d9aa515a
--- /dev/null
+++ b/.changes/parental-lock-external-players.md
@@ -0,0 +1,6 @@
+---
+type: fix
+area: parental-lock
+---
+
+Locking the app again now closes an MPV or VLC window opened while it was unlocked from a source with locked categories, also after the window reloads. Films in MPV, VLC and Embedded MPV no longer lock half way. A stream that stops playing no longer keeps the screen awake and the app unlocked.
diff --git a/apps/electron-backend-e2e/src/parental-lock-external-player.e2e.ts b/apps/electron-backend-e2e/src/parental-lock-external-player.e2e.ts
new file mode 100644
index 0000000000..69c3dc26a2
--- /dev/null
+++ b/apps/electron-backend-e2e/src/parental-lock-external-player.e2e.ts
@@ -0,0 +1,202 @@
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import type { Page } from '@playwright/test';
+import {
+    addXtreamPortal,
+    closeElectronApp,
+    expect,
+    launchElectronApp,
+    openSettings,
+    openSettingsSection,
+    openWorkspaceSection,
+    test,
+    waitForXtreamWorkspaceReady,
+} from './electron-test-fixtures';
+import { reloadFromMainProcess } from './renderer-reload.support';
+
+const PIN = '2468';
+const PID_KEY = '__parentalLockPlayerPids';
+
+function stopPlayer(pid: number): void {
+    try {
+        process.kill(pid);
+    } catch {
+        // Already gone.
+    }
+}
+
+function playerIsAlive(pid: number): boolean {
+    try {
+        process.kill(pid, 0);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+async function launchPlayer(
+    app: Awaited<ReturnType<typeof launchElectronApp>>,
+    playerPath: string,
+    title: string
+): Promise<number> {
+    const before = await app.electronApp.evaluate(
+        (_, key) => (Reflect.get(globalThis, key) as number[]).length,
+        PID_KEY
+    );
+    await app.mainWindow.evaluate(
+        async ({ playerPath, title }) => {
+            await window.electron.setMpvPlayerPath(playerPath);
+            await window.electron.openInMpv(
+                'https://streams.example.test/synthetic.ts',
+                title,
+                '',
+                ''
+            );
+        },
+        { playerPath, title }
+    );
+    await expect
+        .poll(() =>
+            app.electronApp.evaluate(
+                (_, key) => (Reflect.get(globalThis, key) as number[]).length,
+                PID_KEY
+            )
+        )
+        .toBe(before + 1);
+    return app.electronApp.evaluate(
+        (_, key) => (Reflect.get(globalThis, key) as number[]).at(-1) ?? 0,
+        PID_KEY
+    );
+}
+
+async function enterPin(page: Page): Promise<void> {
+    await page.getByTestId('parental-lock-pin').fill(PIN);
+    await page.getByTestId('parental-lock-pin-submit').click();
+}
+
+/**
+ * A relock closes an MPV session opened while unlocked from a source with
+ * a locked category, and leaves one opened while locked; a renderer reload
+ * closes one the unlocked page left running. The native process boundary is
+ * replaced by a quiet, long-lived child; CI installs no MPV.
+ */
+test('@electron @parental @playback relock and reload close an MPV session opened while unlocked', async ({
+    dataDir,
+}) => {
+    test.setTimeout(120_000);
+    const directory = mkdtempSync(join(tmpdir(), 'iptvnator-lock-player-'));
+    const playerPath = join(directory, 'synthetic-mpv');
+    const app = await launchElectronApp(dataDir);
+    const pids: number[] = [];
+    try {
+        const page = app.mainWindow;
+        await app.electronApp.evaluate(
+            (_, { playerPath, nodePath, key }) => {
+                const childProcess = process.getBuiltinModule('child_process');
+                const spawn = childProcess.spawn;
+                Reflect.set(globalThis, key, []);
+                childProcess.spawn = ((command, ...args) => {
+                    if (command !== playerPath)
+                        return Reflect.apply(spawn, childProcess, [
+                            command,
+                            ...args,
+                        ]);
+                    const child = spawn(
+                        nodePath,
+                        ['-e', 'setInterval(() => {}, 1000)'],
+                        { stdio: ['ignore', 'pipe', 'pipe'], detached: false }
+                    );
+                    (Reflect.get(globalThis, key) as number[]).push(
+                        child.pid as number
+                    );
+                    return child;
+                }) as typeof spawn;
+            },
+            { playerPath, nodePath: process.execPath, key: PID_KEY }
+        );
+        await page.evaluate(() =>
+            window.electron.updateSettings({ mpvReuseInstance: true })
+        );
+
+        // Enabling the lock leaves this session unlocked.
+        await openSettings(page);
+        await openSettingsSection(page, 'parental');
+        const toggle = page.locator(
+            '[data-test-id="parental-lock-enabled"] button[role="switch"]'
+        );
+        await toggle.click();
+        await page.getByTestId('parental-lock-pin').fill(PIN);
+        await page.getByTestId('parental-lock-pin-confirm').fill(PIN);
+        await page.getByTestId('parental-lock-pin-submit').click();
+        await expect(toggle).toHaveAttribute('aria-checked', 'true');
+
+        await addXtreamPortal(page, { name: 'Synthetic Lock Portal' });
+        await waitForXtreamWorkspaceReady(page);
+        await openWorkspaceSection(page, 'Live TV');
+        await page.getByTestId('context-manage-categories').click();
+        const dialog = page.locator('app-category-management-dialog');
+        await dialog
+            .locator('[data-test-id^="category-lock-"]')
+            .first()
+            .click();
+        await dialog.getByRole('button', { name: 'Save', exact: true }).click();
+        await expect(dialog).toBeHidden();
+        await expect(page).toHaveURL(/\/workspace\/xtreams\/[^/]+\/live/);
+
+        // Opened while unlocked, from a source with a locked category.
+        const unlockedPid = await launchPlayer(
+            app,
+            playerPath,
+            'Synthetic unlocked launch'
+        );
+        pids.push(unlockedPid);
+        expect(playerIsAlive(unlockedPid)).toBe(true);
+
+        const lockButton = page.getByTestId('header-parental-lock');
+        await lockButton.click();
+        await expect(lockButton).toHaveClass(/is-active/);
+        await expect.poll(() => playerIsAlive(unlockedPid)).toBe(false);
+
+        // Opened while locked: it came from the filtered catalog and must
+        // survive an unlock and the next relock.
+        const lockedPid = await launchPlayer(
+            app,
+            playerPath,
+            'Synthetic locked launch'
+        );
+        pids.push(lockedPid);
+        await lockButton.click();
+        await enterPin(page);
+        await expect(lockButton).not.toHaveClass(/is-active/);
+        await lockButton.click();
+        await expect(lockButton).toHaveClass(/is-active/);
+        // Nothing to wait for when the session is rightly left alone: give
+        // a wrong close (sent at once on relock) time to land.
+        // eslint-disable-next-line playwright/no-wait-for-timeout
+        await page.waitForTimeout(3_000);
+        expect(playerIsAlive(lockedPid)).toBe(true);
+        stopPlayer(lockedPid);
+
+        // A reload forgets what the page saw; the new page starts locked and
+        // closes a player still running from the unlocked page.
+        await lockButton.click();
+        await enterPin(page);
+        await expect(lockButton).not.toHaveClass(/is-active/);
+        const reloadedPid = await launchPlayer(
+            app,
+            playerPath,
+            'Synthetic launch before a reload'
+        );
+        pids.push(reloadedPid);
+        await reloadFromMainProcess(app);
+        await expect(page.getByTestId('header-parental-lock')).toHaveClass(
+            /is-active/
+        );
+        await expect.poll(() => playerIsAlive(reloadedPid)).toBe(false);
+    } finally {
+        pids.forEach(stopPlayer);
+        await closeElectronApp(app);
+        rmSync(directory, { recursive: true, force: true });
+    }
+});
diff --git a/apps/electron-backend/src/app/api/main.preload.ts b/apps/electron-backend/src/app/api/main.preload.ts
index 4e1a177caa..b4b120a6be 100644
--- a/apps/electron-backend/src/app/api/main.preload.ts
+++ b/apps/electron-backend/src/app/api/main.preload.ts
@@ -631,6 +631,8 @@ const electronApi: ElectronBridgeApi = {
             sessionId,
             ...(exact ? [true] : [])
         ),
+    listExternalPlayerSessions: (): Promise<ExternalPlayerSession[]> =>
+        ipcRenderer.invoke('LIST_EXTERNAL_PLAYER_SESSIONS'),
     getEmbeddedMpvSupport: (): Promise<EmbeddedMpvSupport> =>
         ipcRenderer.invoke('EMBEDDED_MPV_SUPPORT'),
     prepareEmbeddedMpv: (): Promise<EmbeddedMpvSupport> =>
diff --git a/apps/electron-backend/src/app/events/external-player-session-registry.spec.ts b/apps/electron-backend/src/app/events/external-player-session-registry.spec.ts
index d0dcccde09..6c70baaa25 100644
--- a/apps/electron-backend/src/app/events/external-player-session-registry.spec.ts
+++ b/apps/electron-backend/src/app/events/external-player-session-registry.spec.ts
@@ -55,6 +55,27 @@ describe('ExternalPlayerSessionRegistry', () => {
         );
     });
 
+    it('lists the sessions whose player may still run', () => {
+        const begin = (title: string) =>
+            registry.beginSession({
+                player: 'mpv',
+                title,
+                streamUrl: 'https://streams.example.test/one.m3u8',
+            });
+        const launching = begin('Launching');
+        const opened = begin('Opened');
+        const closed = begin('Closed');
+        const failed = begin('Failed');
+        registry.markOpened(opened.id);
+        registry.markClosed(closed.id);
+        registry.markError(failed.id, 'synthetic failure');
+
+        expect(registry.listOpenSessions().map(({ id }) => id)).toEqual([
+            launching.id,
+            opened.id,
+        ]);
+    });
+
     it('keeps close capability and closes the session explicitly', async () => {
         const session = registry.beginSession({
             player: 'vlc',
diff --git a/apps/electron-backend/src/app/events/external-player-session-registry.ts b/apps/electron-backend/src/app/events/external-player-session-registry.ts
index b143d9457c..0a5cf3d6e6 100644
--- a/apps/electron-backend/src/app/events/external-player-session-registry.ts
+++ b/apps/electron-backend/src/app/events/external-player-session-registry.ts
@@ -96,6 +96,13 @@ export class ExternalPlayerSessionRegistry {
         return this.sessions.get(id)?.snapshot ?? null;
     }
 
+    /** Every session whose player may still be running. */
+    listOpenSessions(): ExternalPlayerSession[] {
+        return [...this.sessions.values()]
+            .map(({ snapshot }) => snapshot)
+            .filter(isRestorableSession);
+    }
+
     isNewerLaunch(id: string | null, session: ExternalPlayerSession): boolean {
         const order = id ? this.getSession(id)?.launchOrder : undefined;
         return (order ?? 0) > (session.launchOrder ?? 0);
diff --git a/apps/electron-backend/src/app/events/player.events.ts b/apps/electron-backend/src/app/events/player.events.ts
index bb52f8734c..fbfb2b606e 100644
--- a/apps/electron-backend/src/app/events/player.events.ts
+++ b/apps/electron-backend/src/app/events/player.events.ts
@@ -1,6 +1,7 @@
 import { ipcMain } from 'electron';
 import {
     CLOSE_EXTERNAL_PLAYER_SESSION,
+    LIST_EXTERNAL_PLAYER_SESSIONS,
     type ExternalPlayerName,
     PLAYBACK_SET_KEEP_AWAKE,
     PlayerContentInfo,
@@ -188,6 +189,10 @@ ipcMain.handle(
     }
 );
 
+ipcMain.handle(LIST_EXTERNAL_PLAYER_SESSIONS, () =>
+    externalPlayerSessions.listOpenSessions()
+);
+
 ipcMain.handle(PLAYBACK_SET_KEEP_AWAKE, (event, active: boolean) => {
     setPlaybackKeepAwake(event.sender, active === true);
 });
diff --git a/apps/web/src/app/services/parental-lock-enforcement.service.spec.ts b/apps/web/src/app/services/parental-lock-enforcement.service.spec.ts
index 8549df0fee..1eec1c784e 100644
--- a/apps/web/src/app/services/parental-lock-enforcement.service.spec.ts
+++ b/apps/web/src/app/services/parental-lock-enforcement.service.spec.ts
@@ -9,6 +9,7 @@ import {
 } from '@iptvnator/portal/xtream/data-access';
 import { ParentalLockService } from '@iptvnator/services';
 import { ParentalLockEnforcementService } from './parental-lock-enforcement.service';
+import { ParentalLockExternalSessions } from './parental-lock-external-sessions';
 import { PlaybackKeepAwakeService } from './playback-keep-awake.service';
 
 interface Applier {
@@ -546,18 +547,40 @@ describe('ParentalLockEnforcementService apply serialization', () => {
 });
 
 describe('ParentalLockEnforcementService busy probe', () => {
-    it('counts playing audio (the radio player) as activity', () => {
-        let probe: (() => boolean) | undefined;
+    let probe: (() => boolean) | undefined;
+    let version: ReturnType<typeof signal<number>>;
+    let active: ReturnType<typeof signal<boolean>>;
+    let externalSessions: {
+        start: jest.Mock;
+        isBusy: jest.Mock;
+        onLockChange: jest.Mock;
+    };
+
+    beforeEach(() => {
+        probe = undefined;
+        version = signal(0);
+        active = signal(false);
+        externalSessions = {
+            start: jest.fn(),
+            isBusy: jest.fn(() => false),
+            onLockChange: jest.fn(),
+        };
         TestBed.resetTestingModule();
         TestBed.configureTestingModule({
             providers: [
                 {
                     provide: ParentalLockService,
                     useValue: {
-                        version: signal(0),
+                        version,
+                        active,
+                        isM3uGroupLocked: () => false,
                         registerBusyProbe: (fn: () => boolean) => (probe = fn),
                     },
                 },
+                {
+                    provide: ParentalLockExternalSessions,
+                    useValue: externalSessions,
+                },
                 { provide: XtreamStore, useValue: {} },
                 { provide: XTREAM_DATA_SOURCE, useValue: {} },
                 { provide: StalkerStore, useValue: {} },
@@ -574,6 +597,26 @@ describe('ParentalLockEnforcementService busy probe', () => {
         });
         const service = TestBed.inject(ParentalLockEnforcementService);
         TestBed.runInInjectionContext(() => service.start());
+        TestBed.flushEffects();
+    });
+
+    it('counts players outside the page (Embedded MPV, MPV/VLC films)', () => {
+        expect(externalSessions.start).toHaveBeenCalled();
+        expect(probe?.()).toBe(false);
+
+        externalSessions.isBusy.mockReturnValue(true);
+        expect(probe?.()).toBe(true);
+    });
+
+    it('hands a relock to the external session closer', () => {
+        active.set(true);
+        version.set(1);
+        TestBed.flushEffects();
+
+        expect(externalSessions.onLockChange).toHaveBeenCalledTimes(1);
+    });
+
+    it('counts playing audio (the radio player) as activity', () => {
         expect(probe?.()).toBe(false);
 
         const audio = document.createElement('audio');
diff --git a/apps/web/src/app/services/parental-lock-enforcement.service.ts b/apps/web/src/app/services/parental-lock-enforcement.service.ts
index 16a0927559..1b78d8ebd6 100644
--- a/apps/web/src/app/services/parental-lock-enforcement.service.ts
+++ b/apps/web/src/app/services/parental-lock-enforcement.service.ts
@@ -14,6 +14,7 @@ import {
 } from '@iptvnator/portal/xtream/data-access';
 import { ParentalLockService } from '@iptvnator/services';
 import { toParentalLockXtreamCategoryType } from '@iptvnator/shared/interfaces';
+import { ParentalLockExternalSessions } from './parental-lock-external-sessions';
 import { PlaybackKeepAwakeService } from './playback-keep-awake.service';
 
 const XTREAM_ROUTE =
@@ -37,6 +38,7 @@ export class ParentalLockEnforcementService {
     private readonly router = inject(Router);
     private readonly store = inject(Store);
     private readonly keepAwake = inject(PlaybackKeepAwakeService);
+    private readonly externalSessions = inject(ParentalLockExternalSessions);
     private readonly activeChannel = this.store.selectSignal(selectActive);
     private started = false;
     private lastVersion = -1;
@@ -50,10 +52,15 @@ export class ParentalLockEnforcementService {
         }
         this.started = true;
         // Playback counts as activity: video through the keep-awake
-        // tracker, and audio (the radio player) read directly, since the
-        // keep-awake service deliberately ignores <audio>.
+        // tracker, audio (the radio player) read directly, since the
+        // keep-awake service deliberately ignores <audio>, and the players
+        // that render outside the page (Embedded MPV, MPV/VLC films).
+        this.externalSessions.start();
         this.parentalLock.registerBusyProbe(
-            () => this.keepAwake.hasPlayingVideo() || hasPlayingAudio()
+            () =>
+                this.keepAwake.hasPlayingVideo() ||
+                hasPlayingAudio() ||
+                this.externalSessions.isBusy()
         );
         // The Stalker step is loaded as soon as a Stalker route opens, so a
         // relock there can run it synchronously instead of awaiting a chunk.
@@ -94,6 +101,7 @@ export class ParentalLockEnforcementService {
                 if (this.parentalLock.active()) {
                     this.failClosedNow();
                 }
+                this.externalSessions.onLockChange();
                 this.scheduleApply();
             });
         });
diff --git a/apps/web/src/app/services/parental-lock-external-sessions.spec.ts b/apps/web/src/app/services/parental-lock-external-sessions.spec.ts
new file mode 100644
index 0000000000..de3de0316e
--- /dev/null
+++ b/apps/web/src/app/services/parental-lock-external-sessions.spec.ts
@@ -0,0 +1,464 @@
+import { signal } from '@angular/core';
+import { TestBed } from '@angular/core/testing';
+import { Router } from '@angular/router';
+import {
+    ParentalLockLockStore,
+    ParentalLockService,
+    ParentalLockSessionOwners,
+} from '@iptvnator/services';
+import type {
+    EmbeddedMpvSession,
+    ExternalPlayerSession,
+    PlaybackPositionData,
+} from '@iptvnator/shared/interfaces';
+import { ExternalPlaybackService } from './external-playback.service';
+import {
+    EXTERNAL_PROGRESS_WINDOW_MS,
+    ParentalLockExternalSessions,
+} from './parental-lock-external-sessions';
+
+type Listener<T> = (value: T) => void;
+
+const flush = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+function session(
+    overrides: Partial<ExternalPlayerSession> = {}
+): ExternalPlayerSession {
+    return {
+        id: 'session-1',
+        player: 'mpv',
+        status: 'playing',
+        title: 'Synthetic Film',
+        streamUrl: 'http://stream.example/film.mkv',
+        startedAt: new Date(15_000).toISOString(),
+        updatedAt: new Date(15_000).toISOString(),
+        canClose: true,
+        ...overrides,
+    };
+}
+
+describe('ParentalLockExternalSessions', () => {
+    let clock: number;
+    let active: ReturnType<typeof signal<boolean>>;
+    let hasLocks: jest.Mock;
+    let withholdsEverything: ReturnType<typeof signal<boolean>>;
+    let activeSession: ReturnType<typeof signal<ExternalPlayerSession | null>>;
+    let dismissActiveSession: jest.Mock;
+    let restoreDismissedSession: jest.Mock;
+    let closeExternalPlayerSession: jest.Mock;
+    let router: { url: string };
+    let emitSession: Listener<ExternalPlayerSession>;
+    let emitPosition: Listener<PlaybackPositionData>;
+    let emitEmbedded: Listener<EmbeddedMpvSession>;
+    let listed: ExternalPlayerSession[];
+    let service: ParentalLockExternalSessions;
+
+    /** Lock now: the enforcement calls `onLockChange` on the new version. */
+    const relock = () => {
+        active.set(true);
+        service.onLockChange();
+    };
+
+    beforeEach(() => {
+        clock = 10_000;
+        active = signal(false);
+        hasLocks = jest.fn(() => true);
+        withholdsEverything = signal(false);
+        activeSession = signal<ExternalPlayerSession | null>(null);
+        dismissActiveSession = jest.fn();
+        restoreDismissedSession = jest.fn();
+        closeExternalPlayerSession = jest.fn(
+            async (id: string): Promise<ExternalPlayerSession | null> =>
+                session({ id, status: 'closed', canClose: false })
+        );
+        router = { url: '/workspace/playlists/m3u-1/all' };
+        listed = [];
+        (window as { electron?: unknown }).electron = {
+            closeExternalPlayerSession,
+            listExternalPlayerSessions: async () => listed,
+            onExternalPlayerSessionUpdate: (
+                callback: Listener<ExternalPlayerSession>
+            ) => (emitSession = callback),
+            onPlaybackPositionUpdate: (
+                callback: Listener<PlaybackPositionData>
+            ) => (emitPosition = callback),
+            onEmbeddedMpvSessionUpdate: (
+                callback: Listener<EmbeddedMpvSession>
+            ) => (emitEmbedded = callback),
+        };
+        TestBed.configureTestingModule({
+            providers: [
+                {
+                    provide: ParentalLockService,
+                    useValue: { active, withholdsEverything },
+                },
+                { provide: ParentalLockLockStore, useValue: { hasLocks } },
+                {
+                    provide: ExternalPlaybackService,
+                    useValue: {
+                        activeSession,
+                        dismissActiveSession,
+                        restoreDismissedSession,
+                    },
+                },
+                { provide: Router, useValue: router },
+            ],
+        });
+        service = TestBed.inject(ParentalLockExternalSessions);
+        service.now = () => clock;
+        service.start();
+    });
+
+    afterEach(() => {
+        delete (window as { electron?: unknown }).electron;
+        TestBed.resetTestingModule();
+    });
+
+    describe('relock', () => {
+        it('closes a session started while unlocked and hides it from the dock', async () => {
+            const started = session();
+            emitSession(started);
+            activeSession.set(started);
+
+            relock();
+            await flush();
+
+            expect(hasLocks).toHaveBeenCalledWith('m3u-1');
+            expect(dismissActiveSession).toHaveBeenCalled();
+            expect(closeExternalPlayerSession).toHaveBeenCalledWith(
+                'session-1',
+                true
+            );
+        });
+
+        it('judges a session by its own source over the route', () => {
+            router.url = '/workspace/dashboard';
+            emitSession(
+                session({
+                    contentInfo: {
+                        playlistId: 'xtream-1',
+                        contentXtreamId: 7,
+                        contentType: 'vod',
+                    },
+                })
+            );
+
+            relock();
+
+            expect(hasLocks).toHaveBeenCalledWith('xtream-1');
+        });
+
+        it('treats a launch from outside a source route as any source', () => {
+            router.url = '/workspace/favorites';
+            emitSession(session());
+
+            relock();
+
+            expect(hasLocks).toHaveBeenCalledWith(null);
+            expect(closeExternalPlayerSession).toHaveBeenCalled();
+        });
+
+        it('keeps a session whose source has no locked category', () => {
+            hasLocks.mockReturnValue(false);
+            emitSession(session());
+
+            relock();
+
+            expect(closeExternalPlayerSession).not.toHaveBeenCalled();
+            expect(dismissActiveSession).not.toHaveBeenCalled();
+        });
+
+        it('closes any such session while the lock store is unreadable', () => {
+            hasLocks.mockReturnValue(false);
+            withholdsEverything.set(true);
+            emitSession(session());
+
+            relock();
+
+            expect(closeExternalPlayerSession).toHaveBeenCalled();
+        });
+
+        it('keeps a session launched while locked (from the filtered catalog)', () => {
+            relock();
+            clock += 1_000;
+            emitSession(
+                session({ startedAt: new Date(clock).toISOString() })
+            );
+            relock();
+
+            expect(closeExternalPlayerSession).not.toHaveBeenCalled();
+        });
+
+        it('closes a launch that raced the relock', () => {
+            relock();
+            // Started before the relock, first reported after it.
+            emitSession(session({ startedAt: new Date(clock - 1).toISOString() }));
+
+            expect(closeExternalPlayerSession).toHaveBeenCalledWith(
+                'session-1',
+                true
+            );
+        });
+
+        it('closes a locked-time session switched in place while unlocked', () => {
+            relock();
+            clock += 1_000;
+            const startedAt = new Date(clock).toISOString();
+            emitSession(session({ startedAt }));
+            active.set(false);
+            emitSession(
+                session({
+                    startedAt,
+                    streamUrl: 'http://stream.example/other.mkv',
+                })
+            );
+
+            relock();
+
+            expect(closeExternalPlayerSession).toHaveBeenCalledTimes(1);
+        });
+
+        it('keeps a locked-time session that only reports status while unlocked', () => {
+            relock();
+            clock += 1_000;
+            const startedAt = new Date(clock).toISOString();
+            emitSession(session({ startedAt, status: 'opened' }));
+            active.set(false);
+            emitSession(session({ startedAt, status: 'playing' }));
+
+            relock();
+
+            expect(closeExternalPlayerSession).not.toHaveBeenCalled();
+        });
+
+        it('leaves a session its owner enforces', () => {
+            TestBed.inject(ParentalLockSessionOwners).claim(
+                (candidate) => candidate.id === 'session-1'
+            );
+            emitSession(session());
+
+            relock();
+
+            expect(closeExternalPlayerSession).not.toHaveBeenCalled();
+        });
+
+        it('retries a close that failed', async () => {
+            jest.useFakeTimers();
+            try {
+                closeExternalPlayerSession.mockRejectedValueOnce(
+                    new Error('synthetic close failure')
+                );
+                emitSession(session());
+
+                relock();
+                await Promise.resolve();
+                await Promise.resolve();
+                expect(closeExternalPlayerSession).toHaveBeenCalledTimes(1);
+
+                jest.advanceTimersByTime(1_000);
+                expect(closeExternalPlayerSession).toHaveBeenCalledTimes(2);
+            } finally {
+                jest.useRealTimers();
+            }
+        });
+
+        it('closes a launch again once it can be closed', async () => {
+            const launching = session({ status: 'launching' });
+            closeExternalPlayerSession.mockResolvedValueOnce(launching);
+            emitSession(launching);
+
+            relock();
+            await flush();
+            expect(closeExternalPlayerSession).toHaveBeenCalledTimes(1);
+
+            emitSession(session());
+            await flush();
+            expect(closeExternalPlayerSession).toHaveBeenCalledTimes(2);
+        });
+
+        it('only hides a session that cannot be closed', () => {
+            const stuck = session({ canClose: false });
+            emitSession(stuck);
+            activeSession.set(stuck);
+
+            relock();
+
+            expect(dismissActiveSession).toHaveBeenCalled();
+            expect(closeExternalPlayerSession).not.toHaveBeenCalled();
+        });
+
+        it('never closes while unlocked', () => {
+            emitSession(session());
+
+            expect(closeExternalPlayerSession).not.toHaveBeenCalled();
+        });
+
+        it('shows a hidden session again when unlocked before it could be closed', () => {
+            const stuck = session({ canClose: false });
+            emitSession(stuck);
+            activeSession.set(stuck);
+            relock();
+            expect(restoreDismissedSession).not.toHaveBeenCalled();
+
+            active.set(false);
+            service.onLockChange();
+
+            expect(restoreDismissedSession).toHaveBeenCalledWith('session-1');
+        });
+
+        it.each(['returns the session open', 'fails'] as const)(
+            'shows a hidden session again when unlocked while its close %s',
+            async (outcome) => {
+                const started = session();
+                let settle: () => void = () => undefined;
+                closeExternalPlayerSession.mockImplementationOnce(
+                    () =>
+                        new Promise((resolve, reject) => {
+                            settle = () =>
+                                outcome === 'fails'
+                                    ? reject(new Error('synthetic failure'))
+                                    : resolve(started);
+                        })
+                );
+                emitSession(started);
+                activeSession.set(started);
+                relock();
+
+                active.set(false);
+                service.onLockChange();
+                expect(restoreDismissedSession).not.toHaveBeenCalled();
+
+                settle();
+                await flush();
+                expect(restoreDismissedSession).toHaveBeenCalledWith(
+                    'session-1'
+                );
+            }
+        );
+
+        describe('sessions still running from before the page loaded', () => {
+            const earlier = () =>
+                session({ startedAt: new Date(5_000).toISOString() });
+
+            /** A reloaded page: a fresh service, started while locked. */
+            const reloadedPage = () => {
+                active.set(true);
+                const page = TestBed.runInInjectionContext(
+                    () => new ParentalLockExternalSessions()
+                );
+                page.now = () => clock;
+                page.start();
+                return page;
+            };
+
+            it('closes one the main process lists, judged as any source', async () => {
+                listed = [earlier()];
+                reloadedPage();
+                await flush();
+
+                expect(hasLocks).toHaveBeenCalledWith(null);
+                expect(closeExternalPlayerSession).toHaveBeenCalledWith(
+                    'session-1',
+                    true
+                );
+            });
+
+            it('closes one first reported by an update after the reload', () => {
+                reloadedPage();
+                emitSession(earlier());
+
+                expect(hasLocks).toHaveBeenCalledWith(null);
+                expect(closeExternalPlayerSession).toHaveBeenCalled();
+            });
+
+            it('keeps one when no source has a locked category', async () => {
+                hasLocks.mockReturnValue(false);
+                listed = [earlier()];
+                reloadedPage();
+                await flush();
+
+                expect(closeExternalPlayerSession).not.toHaveBeenCalled();
+            });
+        });
+
+        it('forgets a closed session', () => {
+            emitSession(session());
+            emitSession(session({ status: 'closed', canClose: false }));
+
+            relock();
+
+            expect(closeExternalPlayerSession).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('busy probe for the idle relock', () => {
+        const film = () =>
+            session({
+                contentInfo: {
+                    playlistId: 'xtream-1',
+                    contentXtreamId: 7,
+                    contentType: 'vod',
+                },
+            });
+        const position = (positionSeconds: number): PlaybackPositionData => ({
+            sessionId: 'session-1',
+            playlistId: 'xtream-1',
+            contentXtreamId: 7,
+            contentType: 'vod',
+            positionSeconds,
+        });
+
+        it('counts an MPV/VLC film while its position moves', () => {
+            emitSession(film());
+            expect(service.isBusy()).toBe(false);
+
+            emitPosition(position(100));
+            expect(service.isBusy()).toBe(true);
+
+            clock += 5_000;
+            emitPosition(position(105));
+            clock += EXTERNAL_PROGRESS_WINDOW_MS;
+            expect(service.isBusy()).toBe(true);
+        });
+
+        it('stops counting a paused film', () => {
+            emitSession(film());
+            emitPosition(position(100));
+            clock += 5_000;
+            emitPosition(position(100));
+            clock += EXTERNAL_PROGRESS_WINDOW_MS - 4_000;
+
+            expect(service.isBusy()).toBe(false);
+        });
+
+        it('stops counting a film whose player closed', () => {
+            emitSession(film());
+            emitPosition(position(100));
+            emitSession({ ...film(), status: 'closed', canClose: false });
+
+            expect(service.isBusy()).toBe(false);
+        });
+
+        it('does not count live MPV/VLC, which cannot report a pause', () => {
+            emitSession(session());
+            emitPosition(position(100));
+
+            expect(service.isBusy()).toBe(false);
+        });
+
+        it('counts Embedded MPV while any session plays', () => {
+            const embedded = (
+                id: string,
+                status: EmbeddedMpvSession['status']
+            ) => ({ id, status }) as EmbeddedMpvSession;
+
+            emitEmbedded(embedded('a', 'playing'));
+            emitEmbedded(embedded('b', 'playing'));
+            emitEmbedded(embedded('a', 'paused'));
+            expect(service.isBusy()).toBe(true);
+
+            emitEmbedded(embedded('b', 'closed'));
+            expect(service.isBusy()).toBe(false);
+        });
+    });
+});
diff --git a/apps/web/src/app/services/parental-lock-external-sessions.ts b/apps/web/src/app/services/parental-lock-external-sessions.ts
new file mode 100644
index 0000000000..dbed90d5de
--- /dev/null
+++ b/apps/web/src/app/services/parental-lock-external-sessions.ts
@@ -0,0 +1,267 @@
+import { inject, Injectable } from '@angular/core';
+import { Router } from '@angular/router';
+import {
+    ParentalLockLockStore,
+    ParentalLockService,
+    ParentalLockSessionOwners,
+} from '@iptvnator/services';
+import type {
+    EmbeddedMpvSession,
+    ExternalPlayerSession,
+    PlaybackPositionData,
+} from '@iptvnator/shared/interfaces';
+import { ExternalPlaybackService } from './external-playback.service';
+
+/** A source route; a launch from it plays that source's content. */
+const SOURCE_ROUTE = /^\/workspace\/(?:playlists|xtreams|stalker)\/([^/?#]+)/;
+
+/**
+ * MPV/VLC report a film's position every 5 s. A position that moved within
+ * this window means the film is playing; a paused one stops moving.
+ */
+export const EXTERNAL_PROGRESS_WINDOW_MS = 15_000;
+
+const CLOSE_RETRY_MS = 1_000;
+
+type Tracked = {
+    session: ExternalPlayerSession;
+    /** Its media was opened while unlocked: may show withheld content. */
+    tainted: boolean;
+    /** The session's source; `null` when it cannot be told. */
+    sourceId: string | null;
+    closing: boolean;
+    /** Dismissed from the dock by the relock. */
+    hidden?: boolean;
+    retry?: ReturnType<typeof setTimeout>;
+    position?: number;
+    progressAt?: number;
+};
+
+function isOpen(session: ExternalPlayerSession): boolean {
+    return (
+        session.status !== 'closed' &&
+        (session.status !== 'error' || session.canClose)
+    );
+}
+
+/**
+ * The parental lock for players that render outside the page.
+ *
+ * Relock: an MPV/VLC session carries no category, so a session started (or
+ * switched) while unlocked is closed when its source has any locked
+ * category — any source has, when the source is unknown — or the lock store
+ * is unreadable. A session launched while locked came from the filtered
+ * catalog and keeps playing. Features that know the category claim their
+ * sessions through `ParentalLockSessionOwners` and close only withheld ones.
+ *
+ * Idle relock: Embedded MPV counts as busy while `playing`, an MPV/VLC film
+ * or episode while its reported position moves. Live MPV/VLC cannot report a
+ * pause, so it does not hold the lock open.
+ */
+@Injectable({ providedIn: 'root' })
+export class ParentalLockExternalSessions {
+    private readonly lock = inject(ParentalLockService);
+    private readonly locks = inject(ParentalLockLockStore);
+    private readonly owners = inject(ParentalLockSessionOwners);
+    private readonly playback = inject(ExternalPlaybackService);
+    private readonly router = inject(Router);
+    private readonly sessions = new Map<string, Tracked>();
+    private readonly embeddedPlaying = new Set<string>();
+    private lockedAt = Number.NEGATIVE_INFINITY;
+    private pageStartedAt = Number.NEGATIVE_INFINITY;
+    private started = false;
+
+    /** The clock; a field so specs can substitute it. */
+    now = (): number => Date.now();
+
+    start(): void {
+        if (this.started) {
+            return;
+        }
+        this.started = true;
+        // A page starts locked (or with the feature off), and a session it
+        // did not see open — still running across a reload or a crashed
+        // renderer — has an unknown history: treated as opened unlocked.
+        this.pageStartedAt = this.lockedAt = this.now();
+        const bridge = window.electron;
+        bridge?.onExternalPlayerSessionUpdate?.((session) =>
+            this.observe(session)
+        );
+        bridge?.onPlaybackPositionUpdate?.((position) =>
+            this.observePosition(position)
+        );
+        bridge?.onEmbeddedMpvSessionUpdate?.((session) =>
+            this.observeEmbedded(session)
+        );
+        void bridge
+            ?.listExternalPlayerSessions?.()
+            .then((sessions) =>
+                sessions.forEach((session) => {
+                    if (!this.sessions.has(session.id)) this.observe(session);
+                })
+            )
+            .catch(() => undefined);
+    }
+
+    /** Called on every lock version change: closes on relock, shows on unlock. */
+    onLockChange(): void {
+        if (this.lock.active()) {
+            this.lockedAt = this.now();
+        }
+        for (const entry of [...this.sessions.values()]) {
+            this.enforce(entry);
+        }
+    }
+
+    isBusy(): boolean {
+        if (this.embeddedPlaying.size > 0) {
+            return true;
+        }
+        const now = this.now();
+        return [...this.sessions.values()].some(
+            ({ session, progressAt }) =>
+                !!session.contentInfo &&
+                (session.status === 'opened' || session.status === 'playing') &&
+                progressAt !== undefined &&
+                now - progressAt <= EXTERNAL_PROGRESS_WINDOW_MS
+        );
+    }
+
+    private observe(session: ExternalPlayerSession): void {
+        const current = this.sessions.get(session.id);
+        if (!isOpen(session)) {
+            clearTimeout(current?.retry);
+            this.sessions.delete(session.id);
+            return;
+        }
+        const entry: Tracked = current ?? {
+            session,
+            tainted: false,
+            // The route at a reload is not the one the launch was made from.
+            sourceId:
+                Date.parse(session.startedAt) < this.pageStartedAt
+                    ? null
+                    : this.routeSourceId(),
+            closing: false,
+        };
+        // New media while unlocked: a launch, or an in-place switch of a
+        // reused player (status reports alone do not count). A session first
+        // seen after a relock it started before raced that relock.
+        const unlockedMedia =
+            !this.lock.active() &&
+            (!current || current.session.streamUrl !== session.streamUrl);
+        if (
+            unlockedMedia ||
+            (!current && Date.parse(session.startedAt) <= this.lockedAt)
+        ) {
+            entry.tainted = true;
+        }
+        entry.session = session;
+        entry.sourceId = session.contentInfo?.playlistId ?? entry.sourceId;
+        this.sessions.set(session.id, entry);
+        this.enforce(entry);
+    }
+
+    private observePosition(position: PlaybackPositionData): void {
+        const entry = position.sessionId
+            ? this.sessions.get(position.sessionId)
+            : undefined;
+        if (!entry || entry.position === position.positionSeconds) {
+            return;
+        }
+        entry.position = position.positionSeconds;
+        entry.progressAt = this.now();
+    }
+
+    private observeEmbedded(session: EmbeddedMpvSession): void {
+        if (session.status === 'playing') {
+            this.embeddedPlaying.add(session.id);
+        } else {
+            this.embeddedPlaying.delete(session.id);
+        }
+    }
+
+    private needsClose(entry: Tracked): boolean {
+        return (
+            this.lock.active() &&
+            entry.tainted &&
+            !this.owners.isOwned(entry.session) &&
+            // Unreadable locks withhold every category; otherwise any
+            // locked category of the source (of any, when unknown) counts.
+            (this.lock.withholdsEverything() ||
+                this.locks.hasLocks(entry.sourceId))
+        );
+    }
+
+    private enforce(entry: Tracked): void {
+        const { session } = entry;
+        if (this.sessions.get(session.id) !== entry) {
+            return;
+        }
+        if (!this.needsClose(entry)) {
+            clearTimeout(entry.retry);
+            entry.retry = undefined;
+            // Unlocked before it could be closed: show it in the dock again.
+            if (entry.hidden && !entry.closing) {
+                entry.hidden = false;
+                this.playback.restoreDismissedSession(session.id);
+            }
+            return;
+        }
+        if (this.playback.activeSession()?.id === session.id) {
+            entry.hidden = true;
+            this.playback.dismissActiveSession();
+        }
+        const bridge = window.electron;
+        if (
+            !session.canClose ||
+            !bridge?.closeExternalPlayerSession ||
+            entry.closing ||
+            entry.retry
+        ) {
+            return;
+        }
+        entry.closing = true;
+        bridge.closeExternalPlayerSession(session.id, true).then(
+            (result) => {
+                entry.closing = false;
+                if (result && isOpen(result)) {
+                    // The launch has no closer yet; its next update runs the
+                    // close again. Recheck now when an update already
+                    // arrived or the app was unlocked meanwhile.
+                    if (entry.session !== session || !this.needsClose(entry)) {
+                        this.enforce(entry);
+                    }
+                    return;
+                }
+                this.observe(
+                    result ?? {
+                        ...session,
+                        status: 'closed',
+                        canClose: false,
+                        closedByRequest: true,
+                    }
+                );
+            },
+            () => {
+                entry.closing = false;
+                if (this.sessions.get(session.id) !== entry) {
+                    return;
+                }
+                if (!this.needsClose(entry)) {
+                    this.enforce(entry);
+                    return;
+                }
+                entry.retry = setTimeout(() => {
+                    entry.retry = undefined;
+                    this.enforce(entry);
+                }, CLOSE_RETRY_MS);
+            }
+        );
+    }
+
+    private routeSourceId(): string | null {
+        const match = SOURCE_ROUTE.exec(this.router.url ?? '');
+        return match ? decodeURIComponent(match[1]) : null;
+    }
+}
diff --git a/apps/web/src/app/services/playback-keep-awake.service.spec.ts b/apps/web/src/app/services/playback-keep-awake.service.spec.ts
index 5a62246cde..e62948c381 100644
--- a/apps/web/src/app/services/playback-keep-awake.service.spec.ts
+++ b/apps/web/src/app/services/playback-keep-awake.service.spec.ts
@@ -1,4 +1,7 @@
-import { PlaybackKeepAwakeService } from './playback-keep-awake.service';
+import {
+    PLAYBACK_STALL_RELEASE_MS,
+    PlaybackKeepAwakeService,
+} from './playback-keep-awake.service';
 
 type ElectronWindow = {
     electron?: Pick<typeof window.electron, 'setPlaybackKeepAwake'>;
@@ -87,6 +90,93 @@ describe('PlaybackKeepAwakeService', () => {
             second.remove();
         });
 
+        describe('a stream that stops advancing', () => {
+            let currentTime: number;
+
+            beforeEach(() => {
+                jest.useFakeTimers();
+                currentTime = 10;
+                Object.defineProperty(video, 'currentTime', {
+                    configurable: true,
+                    get: () => currentTime,
+                });
+            });
+
+            afterEach(() => {
+                jest.useRealTimers();
+            });
+
+            it.each(['waiting', 'stalled'] as const)(
+                'releases after %s without progress and holds again on playing',
+                (eventType) => {
+                    video.dispatchEvent(new Event('playing'));
+                    video.dispatchEvent(new Event(eventType));
+                    jest.advanceTimersByTime(PLAYBACK_STALL_RELEASE_MS - 1);
+                    expect(setPlaybackKeepAwake).toHaveBeenLastCalledWith(true);
+
+                    jest.advanceTimersByTime(1);
+                    expect(setPlaybackKeepAwake).toHaveBeenLastCalledWith(
+                        false
+                    );
+                    expect(service.hasPlayingVideo()).toBe(false);
+
+                    video.dispatchEvent(new Event('playing'));
+                    expect(setPlaybackKeepAwake).toHaveBeenLastCalledWith(true);
+                    expect(setPlaybackKeepAwake).toHaveBeenCalledTimes(3);
+                }
+            );
+
+            it('keeps the lock when the video plays on from its buffer', () => {
+                video.dispatchEvent(new Event('playing'));
+                video.dispatchEvent(new Event('stalled'));
+                currentTime = 40;
+                jest.advanceTimersByTime(PLAYBACK_STALL_RELEASE_MS);
+                expect(setPlaybackKeepAwake).toHaveBeenCalledTimes(1);
+                expect(service.hasPlayingVideo()).toBe(true);
+            });
+
+            it('releases a video that advanced a little and froze without another event', () => {
+                video.dispatchEvent(new Event('playing'));
+                video.dispatchEvent(new Event('waiting'));
+                currentTime = 11;
+                jest.advanceTimersByTime(PLAYBACK_STALL_RELEASE_MS);
+                expect(service.hasPlayingVideo()).toBe(true);
+
+                jest.advanceTimersByTime(PLAYBACK_STALL_RELEASE_MS);
+                expect(service.hasPlayingVideo()).toBe(false);
+            });
+
+            it('stops checking once playing reports the video resumed', () => {
+                video.dispatchEvent(new Event('playing'));
+                video.dispatchEvent(new Event('waiting'));
+                video.dispatchEvent(new Event('playing'));
+                jest.advanceTimersByTime(PLAYBACK_STALL_RELEASE_MS * 2);
+                expect(service.hasPlayingVideo()).toBe(true);
+            });
+
+            it('restarts the check when a recovered video stalls again', () => {
+                video.dispatchEvent(new Event('playing'));
+                video.dispatchEvent(new Event('waiting'));
+                jest.advanceTimersByTime(5_000);
+                currentTime = 15;
+                video.dispatchEvent(new Event('waiting'));
+                jest.advanceTimersByTime(PLAYBACK_STALL_RELEASE_MS - 5_000);
+                expect(service.hasPlayingVideo()).toBe(true);
+
+                jest.advanceTimersByTime(5_000);
+                expect(service.hasPlayingVideo()).toBe(false);
+            });
+
+            it('does not let repeated stall events postpone the release', () => {
+                video.dispatchEvent(new Event('playing'));
+                video.dispatchEvent(new Event('waiting'));
+                jest.advanceTimersByTime(PLAYBACK_STALL_RELEASE_MS / 2);
+                video.dispatchEvent(new Event('stalled'));
+                jest.advanceTimersByTime(PLAYBACK_STALL_RELEASE_MS / 2);
+                expect(service.hasPlayingVideo()).toBe(false);
+            });
+        });
+
         it('does not react to repeated playing events of a tracked video', () => {
             video.dispatchEvent(new Event('playing'));
             video.dispatchEvent(new Event('playing'));
diff --git a/apps/web/src/app/services/playback-keep-awake.service.ts b/apps/web/src/app/services/playback-keep-awake.service.ts
index eb2f512b79..27962d99f9 100644
--- a/apps/web/src/app/services/playback-keep-awake.service.ts
+++ b/apps/web/src/app/services/playback-keep-awake.service.ts
@@ -16,6 +16,17 @@ type WakeLockNavigator = Navigator & {
 /** Events on a tracked video that mean it is no longer playing. */
 const RELEASE_EVENTS = ['pause', 'ended', 'emptied', 'error'] as const;
 
+/** Events on a tracked video that mean it may have stopped advancing. */
+const STALL_EVENTS = ['waiting', 'stalled'] as const;
+
+/**
+ * A tracked video that has not advanced this long after `waiting` or
+ * `stalled` is released: a stream that dies after starting (starved MSE,
+ * a dropped live source) never fires `pause` or `ended`. Its next `playing`
+ * tracks it again.
+ */
+export const PLAYBACK_STALL_RELEASE_MS = 60_000;
+
 /**
  * Keeps the display awake while any built-in web player (HTML5/hls.js,
  * Video.js, ArtPlayer) is playing video (issue #1095).
@@ -50,6 +61,10 @@ export class PlaybackKeepAwakeService {
     private started = false;
     private readonly playingVideos = new Set<HTMLVideoElement>();
     private readonly releaseCleanups = new Map<HTMLVideoElement, () => void>();
+    private readonly stallChecks = new Map<
+        HTMLVideoElement,
+        { handle: ReturnType<typeof setTimeout>; time: number }
+    >();
 
     private lastSentToBridge: boolean | null = null;
     private wakeLock: WakeLockSentinelLike | null = null;
@@ -127,17 +142,58 @@ export class PlaybackKeepAwakeService {
         }
         this.playingVideos.add(video);
         const onRelease = () => this.untrackVideo(video);
+        const onStall = () => this.scheduleStallCheck(video);
+        const onResume = () => this.clearStallCheck(video);
         for (const type of RELEASE_EVENTS) {
             video.addEventListener(type, onRelease);
         }
+        for (const type of STALL_EVENTS) {
+            video.addEventListener(type, onStall);
+        }
+        video.addEventListener('playing', onResume);
         this.releaseCleanups.set(video, () => {
+            video.removeEventListener('playing', onResume);
             for (const type of RELEASE_EVENTS) {
                 video.removeEventListener(type, onRelease);
             }
+            for (const type of STALL_EVENTS) {
+                video.removeEventListener(type, onStall);
+            }
         });
         this.sync();
     }
 
+    /**
+     * Judged by progress, not by the event: `stalled` also fires while the
+     * buffer still plays. A pending check restarts only when the video moved
+     * since it was taken (a recovery followed by a new stall), so repeated
+     * stall events on a frozen video cannot postpone the release. A video
+     * that moved is checked again until `playing` reports it resumed: it may
+     * advance a little and freeze without another event.
+     */
+    private scheduleStallCheck(video: HTMLVideoElement): void {
+        const pending = this.stallChecks.get(video);
+        if (pending && pending.time === video.currentTime) {
+            return;
+        }
+        clearTimeout(pending?.handle);
+        const time = video.currentTime;
+        const handle = setTimeout(() => {
+            this.stallChecks.delete(video);
+            if (video.currentTime === time) {
+                this.untrackVideo(video);
+            } else {
+                this.scheduleStallCheck(video);
+            }
+        }, PLAYBACK_STALL_RELEASE_MS);
+        this.stallChecks.set(video, { handle, time });
+    }
+
+    private clearStallCheck(video: HTMLVideoElement): void {
+        clearTimeout(this.stallChecks.get(video)?.handle);
+        this.stallChecks.delete(video);
+    }
+
     private untrackVideo(video: HTMLVideoElement): void {
         if (!this.playingVideos.delete(video)) {
             return;
@@ -145,6 +201,7 @@ export class PlaybackKeepAwakeService {
         const cleanup = this.releaseCleanups.get(video);
         this.releaseCleanups.delete(video);
         cleanup?.();
+        this.clearStallCheck(video);
         this.sync();
     }
 
diff --git a/docs/architecture/parental-lock.md b/docs/architecture/parental-lock.md
index ff04565bdd..1a24f5145b 100644
--- a/docs/architecture/parental-lock.md
+++ b/docs/architecture/parental-lock.md
@@ -31,7 +31,9 @@ follow in a second PR.
   player counts as interaction, so a film never locks half way — video
   through the keep-awake tracker, and audio (the radio player) read from
   the playing `<audio>` elements, since the keep-awake service ignores
-  them.
+  them. Players outside the page count too (see "External players"): an
+  Embedded MPV session while `playing`, an MPV/VLC film or episode while
+  its reported position moves.
 - This is a child lock, not a security boundary: the PIN hash and the lock
   store sit in user-readable app data. The UI says so. There is no PIN
   recovery; resetting the app data is the way out.
@@ -582,6 +584,51 @@ opinion" and restore leaves the target's locks alone; present replaces them
 (`replacePlaylistLocks`, which also re-stamps the Xtream index). The PIN is
 never exported.
 
+## External players
+
+MPV/VLC play in their own process, and the session the main process
+reports carries no category. `ParentalLockExternalSessions`
+(`apps/web/src/app/services/parental-lock-external-sessions.ts`), started
+by the enforcement service, tracks every session from
+`onExternalPlayerSessionUpdate`:
+
+- **Relock.** A session whose media was opened while unlocked — a launch,
+  or an in-place switch of a reused player (a changed stream URL; status
+  reports do not count) — is closed on relock when its source may hold
+  withheld content: the lock store is unreadable, or the source has a
+  locked category (any source has, when the source cannot be told). The
+  source is the session's `contentInfo.playlistId`, otherwise the source
+  route the launch was made from; a launch from a global page (dashboard,
+  favorites, search) has none. A session first reported after a relock it
+  started before raced that relock and counts as opened while unlocked. A
+  session opened while locked came from the filtered catalog and keeps
+  playing. Closing uses `closeExternalPlayerSession(id, true)` and hides
+  the session from the dock first; a launch without a closer yet is closed
+  on its next update, a rejected close is retried every second, and a
+  session that cannot be closed (`canClose: false`) is only hidden — shown
+  again if the session is unlocked before it closes.
+- **Reload.** A page starts locked (or with the feature off) and knows
+  nothing of earlier sessions. On start it reads the sessions still open
+  in the main process (`listExternalPlayerSessions`); a session that
+  started before the page — listed, or first reported by a later update —
+  has an unknown history and counts as opened while unlocked, with an
+  unknown source. A player left running by a reloaded or crashed page is
+  therefore closed under the same rule.
+- **Owners.** A feature that knows the category of its sessions claims them
+  through `ParentalLockSessionOwners` (`libs/services`) and closes only
+  those in a withheld category. Xtream Live does:
+  `XtreamExternalLiveSessions` keeps the playing channel's category and
+  closes a session of a withheld one, so an unlocked channel keeps
+  playing.
+- **Idle relock.** Embedded MPV counts as busy while any session is
+  `playing` (two with multiview). An MPV/VLC film or episode counts while
+  its position, reported every 5 s, moved within the last 15 s, so a pause
+  lets the timer run. A session that reports no position does not count,
+  like live MPV/VLC: those players cannot report a pause, and an open,
+  paused window must not keep the app unlocked indefinitely. Positions
+  need `contentInfo` and, for MPV, the IPC socket, so this also covers M3U
+  films (no `contentInfo`) and Flatpak MPV (no socket bridge).
+
 ## Not yet covered (phase 2)
 
 Favorites, recently viewed, playback positions / Continue Watching, the
@@ -603,6 +650,7 @@ predicate is `ParentalLockService.is*Locked`.
   persisted lock set, its unreadable state and the SQLite re-stamp),
   `apps/web/src/app/services/parental-lock-prompt.service.ts`,
   `parental-lock-enforcement.service.ts`,
+  `parental-lock-external-sessions.ts` (MPV/VLC and Embedded MPV),
   `apps/web/src/app/settings/settings-parental-section.component.*` and `settings-parental-lock.facade.ts` (rows anchored and indexed for settings search),
   `libs/ui/components/src/lib/parental-lock-pin-dialog/`,
   `libs/portal/stalker/feature/src/lib/stalker-category-lock-dialog/`.
diff --git a/docs/architecture/player-controls-contract.md b/docs/architecture/player-controls-contract.md
index dcfc9583c3..23e343330c 100644
--- a/docs/architecture/player-controls-contract.md
+++ b/docs/architecture/player-controls-contract.md
@@ -1953,6 +1953,12 @@ capture listeners because media events do not bubble. Release listeners also
 attach to the tracked element: Chromium's pause after DOM removal never reaches
 the document. A playing video holds a display-sleep lock only while the document
 is visible or that video is in picture-in-picture, which survives minimization.
+A tracked video that fires `waiting` or `stalled` and then does not advance for
+60 seconds is released too (`PLAYBACK_STALL_RELEASE_MS`): a stream that dies
+after starting fires neither `pause` nor `ended`. It is judged by `currentTime`,
+since `stalled` also fires while the buffer still plays; a video that moved is
+checked again until `playing` reports it resumed. After a release the next
+`playing` tracks the video again.
 In Electron this relies on the main window keeping Chromium background
 throttling on: with `backgroundThrottling: false` a minimized window keeps
 reporting `visible`, so the gate would never release the display.
diff --git a/libs/portal/xtream/feature/src/lib/live-stream-layout/xtream-external-live-sessions.service.spec.ts b/libs/portal/xtream/feature/src/lib/live-stream-layout/xtream-external-live-sessions.service.spec.ts
index 97c2c5cbf0..40c4a8981b 100644
--- a/libs/portal/xtream/feature/src/lib/live-stream-layout/xtream-external-live-sessions.service.spec.ts
+++ b/libs/portal/xtream/feature/src/lib/live-stream-layout/xtream-external-live-sessions.service.spec.ts
@@ -1,7 +1,10 @@
 import { signal } from '@angular/core';
 import { TestBed } from '@angular/core/testing';
 import { PORTAL_EXTERNAL_PLAYBACK } from '@iptvnator/portal/shared/util';
-import { ParentalLockService } from '@iptvnator/services';
+import {
+    ParentalLockService,
+    ParentalLockSessionOwners,
+} from '@iptvnator/services';
 import type { ExternalPlayerSession } from '@iptvnator/shared/interfaces';
 import { XtreamExternalLiveSessions } from './xtream-external-live-sessions.service';
 
@@ -150,6 +153,23 @@ describe('XtreamExternalLiveSessions', () => {
         expect(closeSession).not.toHaveBeenCalled();
     });
 
+    it('claims its launches from the app-wide relock closer', () => {
+        const owners = TestBed.inject(ParentalLockSessionOwners);
+        const { finish, launchId } = guard.begin(original);
+        const launching = {
+            ...session('owned', oldUrl, 'launching'),
+            launchId,
+        };
+        expect(owners.isOwned(launching)).toBe(true);
+
+        finish({ ...launching, status: 'opened', canClose: true });
+        expect(owners.isOwned(session('owned', oldUrl, 'opened'))).toBe(true);
+        expect(owners.isOwned(session('other', newUrl, 'opened'))).toBe(false);
+
+        receive(session('owned', oldUrl, 'closed'));
+        expect(owners.isOwned(session('owned', oldUrl, 'opened'))).toBe(false);
+    });
+
     it('does not restore the old category when a launch response arrives after a copy switch', () => {
         const { finish, launchId } = guard.begin(original);
         const opened = { ...session('old', oldUrl, 'opened'), launchId };
diff --git a/libs/portal/xtream/feature/src/lib/live-stream-layout/xtream-external-live-sessions.service.ts b/libs/portal/xtream/feature/src/lib/live-stream-layout/xtream-external-live-sessions.service.ts
index 24213cc2e9..e311f85991 100644
--- a/libs/portal/xtream/feature/src/lib/live-stream-layout/xtream-external-live-sessions.service.ts
+++ b/libs/portal/xtream/feature/src/lib/live-stream-layout/xtream-external-live-sessions.service.ts
@@ -10,8 +10,10 @@ import {
     isLiveExternalPlayerSession,
     PORTAL_EXTERNAL_PLAYBACK,
 } from '@iptvnator/portal/shared/util';
-import { ParentalLockService } from '@iptvnator/services';
-import type { XtreamPlaylistData } from '@iptvnator/portal/xtream/data-access';
+import {
+    ParentalLockService,
+    ParentalLockSessionOwners,
+} from '@iptvnator/services';
 import type {
     EpgProgram,
     ExternalPlayerSession,
@@ -28,35 +30,13 @@ import {
     type GuideLaunchOutcome,
     type XtreamOwnedLaunch as Launch,
 } from './xtream-native-handoff';
+import { sameXtreamLiveOwner, type XtreamLiveOwner } from './xtream-live-owner';
 
-export type XtreamLiveOwner = Pick<
-    XtreamPlaylistData,
-    'serverUrl' | 'username' | 'password'
-> & {
-    playlistId: string;
-};
-
-export function captureXtreamLiveOwner(
-    playlist?: XtreamPlaylistData | null
-): XtreamLiveOwner | undefined {
-    if (!playlist?.id) return undefined;
-    const { id: playlistId, serverUrl, username, password } = playlist;
-    return { playlistId, serverUrl, username, password };
-}
-
-export function sameXtreamLiveOwner(
-    left: XtreamLiveOwner | undefined,
-    right: XtreamLiveOwner | undefined
-): boolean {
-    return (
-        !!left &&
-        !!right &&
-        left.playlistId === right.playlistId &&
-        left.serverUrl === right.serverUrl &&
-        left.username === right.username &&
-        left.password === right.password
-    );
-}
+export {
+    captureXtreamLiveOwner,
+    sameXtreamLiveOwner,
+    type XtreamLiveOwner,
+} from './xtream-live-owner';
 
 export interface XtreamLiveSource extends XtreamLiveOwner {
     categoryId: number | null | 'unknown';
@@ -118,7 +98,15 @@ export class XtreamExternalLiveSessions {
         const unsubscribe = window.electron?.onExternalPlayerSessionUpdate?.(
             (session) => this.update(session)
         );
+        // Relock closes only sessions of a withheld category (enforce), so
+        // the app-wide closer for uncategorized sessions leaves these alone.
+        const release = inject(ParentalLockSessionOwners).claim(
+            (session) =>
+                this.sessions.has(session.id) ||
+                (!!session.launchId && this.pending.has(session.launchId))
+        );
         this.destroyRef.onDestroy(() => {
+            release();
             unsubscribe?.();
             this.sessions.forEach((entry) => clearTimeout(entry.retry));
         });
diff --git a/libs/portal/xtream/feature/src/lib/live-stream-layout/xtream-live-owner.ts b/libs/portal/xtream/feature/src/lib/live-stream-layout/xtream-live-owner.ts
new file mode 100644
index 0000000000..712b8b2795
--- /dev/null
+++ b/libs/portal/xtream/feature/src/lib/live-stream-layout/xtream-live-owner.ts
@@ -0,0 +1,30 @@
+import type { XtreamPlaylistData } from '@iptvnator/portal/xtream/data-access';
+
+export type XtreamLiveOwner = Pick<
+    XtreamPlaylistData,
+    'serverUrl' | 'username' | 'password'
+> & {
+    playlistId: string;
+};
+
+export function captureXtreamLiveOwner(
+    playlist?: XtreamPlaylistData | null
+): XtreamLiveOwner | undefined {
+    if (!playlist?.id) return undefined;
+    const { id: playlistId, serverUrl, username, password } = playlist;
+    return { playlistId, serverUrl, username, password };
+}
+
+export function sameXtreamLiveOwner(
+    left: XtreamLiveOwner | undefined,
+    right: XtreamLiveOwner | undefined
+): boolean {
+    return (
+        !!left &&
+        !!right &&
+        left.playlistId === right.playlistId &&
+        left.serverUrl === right.serverUrl &&
+        left.username === right.username &&
+        left.password === right.password
+    );
+}
diff --git a/libs/services/src/lib/parental-lock/index.ts b/libs/services/src/lib/parental-lock/index.ts
index 00b264892b..e706f802dc 100644
--- a/libs/services/src/lib/parental-lock/index.ts
+++ b/libs/services/src/lib/parental-lock/index.ts
@@ -1,5 +1,6 @@
 export * from './parental-lock-idle-timer';
 export * from './parental-lock-prompt.token';
+export * from './parental-lock-session-owners';
 export * from './parental-lock-lock-store.service';
 export * from './parental-lock-playlist-cleanup';
 export * from './parental-lock-storage';
diff --git a/libs/services/src/lib/parental-lock/parental-lock-lock-store.service.spec.ts b/libs/services/src/lib/parental-lock/parental-lock-lock-store.service.spec.ts
index afde973dfb..0400a031e2 100644
--- a/libs/services/src/lib/parental-lock/parental-lock-lock-store.service.spec.ts
+++ b/libs/services/src/lib/parental-lock/parental-lock-lock-store.service.spec.ts
@@ -107,6 +107,30 @@ describe('ParentalLockLockStore', () => {
         expect(store.readable()).toBe(true);
     });
 
+    it('tells which sources have a locked category', async () => {
+        storage.readLocks.mockResolvedValueOnce({
+            ...stored,
+            'pl-2': { xtream: [], stalker: [], m3u: [] },
+            'pl-3': { xtream: [], stalker: [], m3u: ['Synthetic Group'] },
+        });
+        await store.load();
+
+        expect(store.hasLocks('pl-1')).toBe(true);
+        expect(store.hasLocks('pl-2')).toBe(false);
+        expect(store.hasLocks('pl-3')).toBe(true);
+        expect(store.hasLocks('pl-4')).toBe(false);
+        expect(store.hasLocks(null)).toBe(true);
+    });
+
+    it('reports no locked source when every entry is empty', async () => {
+        storage.readLocks.mockResolvedValueOnce({
+            'pl-2': { xtream: [], stalker: [], m3u: [] },
+        });
+        await store.load();
+
+        expect(store.hasLocks(null)).toBe(false);
+    });
+
     it('re-derives the SQLite index from the store on load', async () => {
         await store.load();
         // ensureReadable awaits the reconcile that load() started.
diff --git a/libs/services/src/lib/parental-lock/parental-lock-lock-store.service.ts b/libs/services/src/lib/parental-lock/parental-lock-lock-store.service.ts
index 76c210bf8e..87a866739a 100644
--- a/libs/services/src/lib/parental-lock/parental-lock-lock-store.service.ts
+++ b/libs/services/src/lib/parental-lock/parental-lock-lock-store.service.ts
@@ -208,6 +208,20 @@ export class ParentalLockLockStore {
         return this.locks()[playlistId]?.m3u ?? [];
     }
 
+    /** Whether the source (any source when `null`) has a locked category. */
+    hasLocks(playlistId: string | null): boolean {
+        const store = this.locks();
+        const entries =
+            playlistId === null ? Object.values(store) : [store[playlistId]];
+        return entries.some(
+            (locks) =>
+                !!locks &&
+                (locks.xtream.length > 0 ||
+                    locks.stalker.length > 0 ||
+                    locks.m3u.length > 0)
+        );
+    }
+
     /**
      * Every mutation re-reads a store that failed to read BEFORE building
      * the edit: `locksFor` on the empty fail-closed store would otherwise
diff --git a/libs/services/src/lib/parental-lock/parental-lock-session-owners.ts b/libs/services/src/lib/parental-lock/parental-lock-session-owners.ts
new file mode 100644
index 0000000000..ec84c01624
--- /dev/null
+++ b/libs/services/src/lib/parental-lock/parental-lock-session-owners.ts
@@ -0,0 +1,28 @@
+import { Injectable } from '@angular/core';
+import type { ExternalPlayerSession } from '@iptvnator/shared/interfaces';
+
+/**
+ * External player sessions whose parental lock a feature enforces itself.
+ *
+ * The app-wide relock closes MPV/VLC sessions it cannot judge (their
+ * category is not on the session). A feature that knows the category of the
+ * sessions it launched — Xtream Live keeps the playing channel's category —
+ * claims them here, so the generic closer leaves them to the owner, which
+ * closes only those in a now-withheld category.
+ */
+@Injectable({ providedIn: 'root' })
+export class ParentalLockSessionOwners {
+    private readonly owners = new Set<
+        (session: ExternalPlayerSession) => boolean
+    >();
+
+    /** Registers an ownership test. Returns the unregister function. */
+    claim(owns: (session: ExternalPlayerSession) => boolean): () => void {
+        this.owners.add(owns);
+        return () => this.owners.delete(owns);
+    }
+
+    isOwned(session: ExternalPlayerSession): boolean {
+        return [...this.owners].some((owns) => owns(session));
+    }
+}
diff --git a/libs/shared/interfaces/src/lib/electron-api.interface.ts b/libs/shared/interfaces/src/lib/electron-api.interface.ts
index 9bbfecdff1..b6a7b1ce46 100644
--- a/libs/shared/interfaces/src/lib/electron-api.interface.ts
+++ b/libs/shared/interfaces/src/lib/electron-api.interface.ts
@@ -1398,6 +1398,8 @@ export interface ElectronBridgeApi {
         sessionId: string,
         exact?: boolean
     ) => Promise<ExternalPlayerSession | null>;
+    /** Sessions still open in the main process, e.g. after a page reload. */
+    listExternalPlayerSessions?: () => Promise<ExternalPlayerSession[]>;
     getEmbeddedMpvSupport: () => Promise<EmbeddedMpvSupport>;
     prepareEmbeddedMpv?: () => Promise<EmbeddedMpvSupport>;
     createEmbeddedMpvSession: (
diff --git a/libs/shared/interfaces/src/lib/ipc-commands.ts b/libs/shared/interfaces/src/lib/ipc-commands.ts
index 08a4f715d5..3c929f56cb 100644
--- a/libs/shared/interfaces/src/lib/ipc-commands.ts
+++ b/libs/shared/interfaces/src/lib/ipc-commands.ts
@@ -63,6 +63,7 @@ export const OPEN_VLC_PLAYER = 'OPEN_VLC_PLAYER';
 export const SET_VLC_PLAYER_PATH = 'SET_VLC_PLAYER_PATH';
 export const SET_VLC_REUSE_INSTANCE = 'SET_VLC_REUSE_INSTANCE';
 export const CLOSE_EXTERNAL_PLAYER_SESSION = 'CLOSE_EXTERNAL_PLAYER_SESSION';
+export const LIST_EXTERNAL_PLAYER_SESSIONS = 'LIST_EXTERNAL_PLAYER_SESSIONS';
 export const EXTERNAL_PLAYER_SESSION_UPDATE = 'EXTERNAL_PLAYER_SESSION_UPDATE';
 export const EMBEDDED_MPV_SUPPORT = 'EMBEDDED_MPV_SUPPORT';
 export const EMBEDDED_MPV_CREATE_SESSION = 'EMBEDDED_MPV_CREATE_SESSION';