update backlog

fix: address CodeRabbit follow-ups for PR #40
fix: stabilize local subtitle startup and pause release
2026-04-03 06:12:07 -07:00 · 2026-04-03 01:15:22 -07:00 · 2026-04-03 01:14:57 -07:00 · 2026-04-03 01:12:31 -07:00 · 2026-04-03 00:07:57 -07:00 · 2026-04-03 00:04:04 -07:00
49 changed files with 1609 additions and 177 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,8 @@

 ### Fixed
 - AniList: Stopped post-watch tracking from sending a second progress update when the current episode was already satisfied by a ready retry item in the same watch-completion pass.
+- Playback: Fixed managed local playback so duplicate startup-ready retries no longer unpause media after a later manual pause on the same file.
+- Playback: Fixed managed local subtitle auto-selection so local files reuse configured primary/secondary subtitle language priorities instead of staying on mpv's initial `sid=auto` guess.

 ## v0.10.0 (2026-03-29)

--- a/README.md
+++ b/README.md
@@ -21,6 +21,8 @@ Look up words with Yomitan, export to Anki in one key, track your immersion —

 SubMiner runs as an invisible Electron overlay on top of mpv. Subtitles render as an interactive layer. Move your cursor over any word and trigger a [Yomitan](https://github.com/yomidevs/yomitan) lookup. Press one key to snapshot the sentence, audio, and screenshot into Anki via AnkiConnect.

+First-run setup requires the mpv plugin before it can finish. On Windows, the optional `SubMiner mpv` shortcut created during setup is the recommended playback entry point because it launches `mpv` with SubMiner's defaults directly, so you do not need an `mpv.conf` profile just to use it.
+
 ## Features

 ### Dictionary Lookups
@@ -67,6 +69,8 @@ Local stats dashboard — watch time, anime library, vocabulary growth, mining t

 Browse sibling episode files and the active mpv queue in one overlay modal. Open it with `Ctrl+Alt+P` to append episodes from the current directory, jump to queued items, remove entries, or reorder the playlist without leaving playback.

+Managed local playback now reapplies your configured subtitle language priorities after mpv loads track metadata, so mixed subtitle sets can settle onto the expected primary and secondary tracks instead of staying on mpv's initial `sid=auto` guess.
+
 <br>

 ### Integrations
@@ -74,7 +78,7 @@ Browse sibling episode files and the active mpv queue in one overlay modal. Open
 <table>
  <tr>
    <td><b>YouTube</b></td>
-    <td>Auto-loaded yt-dlp subtitle tracks at startup with a manual overlay picker on demand (<code>Ctrl+Alt+C</code>)</td>
+    <td>Auto-loaded yt-dlp subtitle tracks at startup with config-driven primary/secondary language priorities and a manual overlay picker on demand (<code>Ctrl+Alt+C</code>)</td>
  </tr>
  <tr>
    <td><b>AniList</b></td>
@@ -224,7 +228,7 @@ See the [build-from-source guide](https://docs.subminer.moe/installation#from-so

 ### 2. First Launch

-Run the app. On first launch SubMiner starts in the system tray, creates a default config, and opens a setup popup to install the mpv plugin and configure Yomitan dictionaries.
+Run the app. On first launch SubMiner starts in the system tray, creates a default config, and opens a setup popup to finish config, install the mpv plugin, and configure Yomitan dictionaries.

 ### 3. Mine

--- a/Assess-and-address-PR-40-CodeRabbit-review-follow-ups.md
+++ b/Assess-and-address-PR-40-CodeRabbit-review-follow-ups.md
@@ -0,0 +1,39 @@
+---
+id: TASK-272
+title: 'Assess and address PR #40 CodeRabbit review follow-ups'
+status: Done
+assignee: []
+created_date: '2026-04-03 07:52'
+updated_date: '2026-04-03 08:04'
+labels:
+  - coderabbit
+  - review
+  - launcher
+milestone: 'PR #40'
+dependencies: []
+references:
+  - 'https://github.com/ksyasuda/SubMiner/pull/40'
+priority: medium
+---
+
+## Description
+
+<!-- SECTION:DESCRIPTION:BEGIN -->
+Implement the valid CodeRabbit findings on PR #40 and keep the Windows mpv shortcut / first-run setup flow consistent end to end.
+<!-- SECTION:DESCRIPTION:END -->
+
+## Acceptance Criteria
+<!-- AC:BEGIN -->
+- [ ] #1 Windows binary resolution does not return install directories as executable candidates
+- [ ] #2 Launch-mpv arg parsing preserves space-separated mpv option values and target separation
+- [ ] #3 Windows mpv launch args keep the final input-ipc-server and script-opts socket path in sync when custom values are supplied
+- [ ] #4 First-run setup navigation swallows stale or invalid custom-scheme actions without navigating away
+- [ ] #5 Setup messaging and footer copy reflect configReady, plugin, and dictionary gates consistently
+- [ ] #6 Regression tests cover the fixed behaviors
+<!-- AC:END -->
+
+## Final Summary
+
+<!-- SECTION:FINAL_SUMMARY:BEGIN -->
+Addressed CodeRabbit follow-ups for PR #40. Hardened launcher binary discovery on Windows and PATH resolution, fixed launch-mpv argument parsing for value-bearing flags, synced custom Windows mpv IPC socket values into script opts, and tightened first-run setup messaging/navigation to handle stale actions and blocker copy. Verified with `bun test src/main-entry-runtime.test.ts src/main/runtime/windows-mpv-launch.test.ts src/main/runtime/first-run-setup-window.test.ts launcher/mpv.test.ts`.
+<!-- SECTION:FINAL_SUMMARY:END -->
--- a/Make-Windows-mpv-shortcut-self-contained.md
+++ b/Make-Windows-mpv-shortcut-self-contained.md
@@ -0,0 +1,30 @@
+---
+id: TASK-270
+title: Make Windows mpv shortcut self-contained
+status: Done
+assignee: []
+created_date: '2026-04-02 07:13'
+updated_date: '2026-04-02 07:19'
+labels: []
+dependencies: []
+priority: medium
+---
+
+## Description
+
+<!-- SECTION:DESCRIPTION:BEGIN -->
+Remove the Windows mpv shortcut's dependency on a pre-existing mpv profile so the installer-created `SubMiner mpv` flow works out of the box without requiring the user to edit `mpv.conf`. Keep docs aligned with the new behavior and preserve the optional profile guidance for manual mpv usage.
+<!-- SECTION:DESCRIPTION:END -->
+
+## Acceptance Criteria
+<!-- AC:BEGIN -->
+- [x] #1 `SubMiner.exe --launch-mpv` launches mpv with SubMiner's required default args without requiring an mpv profile named `subminer`.
+- [x] #2 Windows shortcut/help/docs no longer describe `--launch-mpv` as depending on the SubMiner mpv profile.
+- [x] #3 Automated tests cover the Windows launch args behavior and pass after the change.
+<!-- AC:END -->
+
+## Final Summary
+
+<!-- SECTION:FINAL_SUMMARY:BEGIN -->
+Updated the Windows `--launch-mpv` path to pass SubMiner's default mpv args directly instead of requiring `--profile=subminer`. Adjusted Windows shortcut/help text to describe the self-contained defaults-based launch, and updated Windows docs to state that `mpv.conf` is not required for the shortcut path while preserving the optional profile guidance for manual mpv launches.
+<!-- SECTION:FINAL_SUMMARY:END -->
--- a/Fix-local-playback-subtitle-auto-selection-and-startup-pause-release.md
+++ b/Fix-local-playback-subtitle-auto-selection-and-startup-pause-release.md
@@ -0,0 +1,56 @@
+---
+id: TASK-271
+title: Fix local playback subtitle auto-selection and startup pause release
+status: Done
+assignee:
+  - codex
+created_date: '2026-04-03 07:47'
+updated_date: '2026-04-03 08:03'
+labels:
+  - bug
+  - playback
+  - subtitles
+dependencies: []
+---
+
+## Description
+
+<!-- SECTION:DESCRIPTION:BEGIN -->
+Investigate local-video startup on desktop playback where managed subtitle defaults can bind the wrong primary subtitle track and startup readiness retries can force playback to resume after the user manually pauses. Scope includes fixing the pause/unpause loop and making local subtitle auto-selection prefer the intended primary/secondary tracks for sentence mining sessions.
+<!-- SECTION:DESCRIPTION:END -->
+
+## Acceptance Criteria
+<!-- AC:BEGIN -->
+- [x] #1 Desktop local playback no longer forces `pause=no` after the user manually pauses during or after startup readiness handling.
+- [x] #2 Managed local subtitle startup selects the expected primary track before secondary track selection for mixed-language subtitle sets like Japanese primary plus English secondary.
+- [x] #3 Regression tests cover the pause-release bug and the local subtitle auto-selection behavior.
+- [x] #4 Internal docs are updated if runtime behavior or operator expectations change.
+<!-- AC:END -->
+
+## Implementation Plan
+
+<!-- SECTION:PLAN:BEGIN -->
+1. Add regression coverage for startup autoplay release so duplicate ready handling cannot unpause playback after the user manually pauses the same media.
+2. Add regression coverage for managed local subtitle startup selection using configured primary/secondary subtitle language preferences, with JA/EN remaining the default fallback behavior.
+3. Extract or add reusable subtitle track ranking logic that prefers configured primary and secondary subtitle languages, with stable scoring for external tracks and non-SDH labels.
+4. Update local playback startup/runtime wiring so managed subtitle defaults use explicit ranked selection instead of raw sid=auto / secondary-sid=auto while preserving config-driven language preference ordering.
+5. Run focused subtitle/playback tests, then update task notes/final summary with any behavior or docs impact.
+<!-- SECTION:PLAN:END -->
+
+## Implementation Notes
+
+<!-- SECTION:NOTES:BEGIN -->
+Implemented config-aware managed local subtitle selection runtime for local media path changes and playlist-browser local playback rearm, using `youtube.primarySubLanguages` for primary preference and `secondarySub.secondarySubLanguages` for secondary preference with JA/EN fallback defaults.
+
+Updated autoplay ready gate to ignore duplicate readiness signals for the same media so later manual pauses are not overridden by repeated tokenization-ready events.
+
+Updated config/template wording to document that the existing subtitle language preferences now drive managed subtitle auto-selection beyond YouTube-only flows.
+
+Verification: `bun test src/config/config.test.ts src/main/runtime/autoplay-ready-gate.test.ts src/main/runtime/local-subtitle-selection.test.ts src/main/runtime/playlist-browser-runtime.test.ts`; `bun run typecheck`.
+<!-- SECTION:NOTES:END -->
+
+## Final Summary
+
+<!-- SECTION:FINAL_SUMMARY:BEGIN -->
+Stopped startup readiness retries from re-unpausing the same media after a later manual pause, and added config-aware managed local subtitle selection so local playback prefers the configured primary/secondary subtitle languages instead of relying on raw mpv `sid=auto` behavior. Added regression coverage for autoplay-ready gating, local subtitle selection, playlist-browser local playback rearm, and config template wording updates.
+<!-- SECTION:FINAL_SUMMARY:END -->
--- a/changes/268-windows-mpv-shortcut-defaults.md
+++ b/changes/268-windows-mpv-shortcut-defaults.md
@@ -0,0 +1,6 @@
+type: fixed
+area: launcher
+
+- Fixed the Windows `SubMiner mpv` shortcut and `SubMiner.exe --launch-mpv` flow to launch mpv with SubMiner's required default args directly instead of requiring an `mpv.conf` profile named `subminer`.
+- Clarified the Windows install and usage docs so the shortcut path is documented as self-contained, while the optional `subminer` mpv profile remains available for manual mpv launches.
+- Hardened the first-run setup blocker copy and stale custom-scheme handling so setup messages stay aligned with config, plugin, and dictionary readiness.
--- a/changes/269-windows-mpv-shortcut-idle-overlay.md
+++ b/changes/269-windows-mpv-shortcut-idle-overlay.md
@@ -0,0 +1,5 @@
+type: fixed
+area: launcher
+
+- Fixed the Windows `SubMiner mpv` shortcut idle launch so loading a video after opening the shortcut keeps mpv in the expected SubMiner-managed session, auto-starts the overlay, and re-arms subtitle auto-selection for the newly opened file.
+- Removed the redundant `.` subtitle search path from the Windows shortcut launch args and deduped repeated subtitle source tracks in the manual sync picker so duplicate external subtitle entries no longer appear from the shortcut path.
--- a/changes/270-first-run-setup-requires-mpv-plugin.md
+++ b/changes/270-first-run-setup-requires-mpv-plugin.md
@@ -0,0 +1,5 @@
+type: changed
+area: setup
+
+- Made mpv plugin installation mandatory in the first-run setup flow, removed the skip path, and kept Finish disabled until the plugin is installed.
+- Clarified that the mpv plugin requirement applies to setup on every platform, while the optional `SubMiner mpv` shortcut remains the recommended Windows playback entry point.
--- a/changes/271-local-subtitle-auto-selection-and-pause-release.md
+++ b/changes/271-local-subtitle-auto-selection-and-pause-release.md
@@ -0,0 +1,5 @@
+type: fixed
+area: playback
+
+- Fixed managed local playback so duplicate startup-ready retries no longer unpause media after a later manual pause on the same file.
+- Fixed managed local subtitle auto-selection so local files reuse configured primary and secondary subtitle language priorities instead of staying on mpv's initial `sid=auto` guess.
--- a/config.example.jsonc
+++ b/config.example.jsonc
@@ -187,7 +187,7 @@
  // ==========================================
  // Secondary Subtitles
  // Dual subtitle track options.
-  // Used by the YouTube subtitle loading flow as secondary language preferences.
+  // Used by managed subtitle loading as secondary language preferences for local and YouTube playback.
  // Hot-reload: defaultMode updates live while SubMiner is running.
  // ==========================================
  "secondarySub": {
@@ -415,14 +415,14 @@

  // ==========================================
  // YouTube Playback Settings
-  // Defaults for SubMiner YouTube subtitle loading and languages.
+  // Defaults for managed subtitle language preferences and YouTube subtitle loading.
  // ==========================================
  "youtube": {
    "primarySubLanguages": [
      "ja",
      "jpn"
-    ] // Comma-separated primary subtitle language priority for YouTube auto-loading.
-  }, // Defaults for SubMiner YouTube subtitle loading and languages.
+    ] // Comma-separated primary subtitle language priority for managed subtitle auto-selection.
+  }, // Defaults for managed subtitle language preferences and YouTube subtitle loading.

  // ==========================================
  // Anilist
--- a/docs-site/configuration.md
+++ b/docs-site/configuration.md
@@ -448,6 +448,8 @@ See `config.example.jsonc` for detailed configuration options.
 | `autoLoadSecondarySub`  | `true`, `false`                    | Auto-detect and load matching secondary subtitle track |
 | `defaultMode`           | `"hidden"`, `"visible"`, `"hover"` | Initial display mode (default: `"hover"`)              |

+`secondarySub.secondarySubLanguages` also acts as the fallback secondary-language priority for managed startup subtitle selection on local playback and YouTube playback.
+
 **Display modes:**

 - **hidden** — Secondary subtitles not shown
@@ -1342,7 +1344,7 @@ Usage notes:

 ### YouTube Playback Settings

-Set defaults used by the `subminer` launcher for YouTube subtitle loading:
+Set defaults used by managed subtitle auto-selection and the `subminer` launcher YouTube flow:

 ```json
 {
@@ -1354,7 +1356,7 @@ Set defaults used by the `subminer` launcher for YouTube subtitle loading:

 | Option                | Values               | Description                                                                                    |
 | --------------------- | -------------------- | ---------------------------------------------------------------------------------------------- |
-| `primarySubLanguages` | string[]             | Primary subtitle language priority for YouTube auto-loading (default `["ja", "jpn"]`) |
+| `primarySubLanguages` | string[]             | Primary subtitle language priority for managed subtitle auto-selection (default `["ja", "jpn"]`) |

 Current launcher behavior:

@@ -1370,6 +1372,7 @@ Language targets are derived from subtitle config:

 - primary track: `youtube.primarySubLanguages` (falls back to `["ja","jpn"]`)
 - secondary track: `secondarySub.secondarySubLanguages` (falls back to English when empty)
+- Local playback uses the same priorities after mpv reports subtitle track metadata, so sidecar/internal mixed sets can override an incorrect initial `sid=auto` pick.
 - Tracks are resolved and loaded before mpv starts; the older launcher mode switch has been removed.

 Precedence for launcher defaults is: CLI flag > environment variable > `config.jsonc` > built-in default.
--- a/docs-site/installation.md
+++ b/docs-site/installation.md
@@ -171,7 +171,8 @@ Install `mpv` separately and ensure `mpv.exe` is on `PATH`. `ffmpeg` is still re

 ### Windows Usage Notes

- Launch `SubMiner.exe` once to let the first-run setup flow seed `%APPDATA%\\SubMiner\\config.jsonc`, offer mpv plugin installation, open bundled Yomitan settings, and optionally create `SubMiner mpv` Start Menu/Desktop shortcuts.
+- Launch `SubMiner.exe` once to let the first-run setup flow seed `%APPDATA%\\SubMiner\\config.jsonc`, require mpv plugin installation, and open bundled Yomitan settings. The optional `SubMiner mpv` Start Menu/Desktop shortcut can also be created during setup, and on Windows it is the recommended way to launch mpv playback with SubMiner defaults.
+- `SubMiner.exe --launch-mpv` and the optional `SubMiner mpv` shortcut pass SubMiner's default mpv socket/subtitle args directly and do not require an `mpv.conf` profile named `subminer`.
 - First-run mpv plugin installs pin `binary_path` to the current `SubMiner.exe` automatically. Manual plugin configs can leave `binary_path` empty unless SubMiner is installed in a non-standard location.
 - Windows plugin installs rewrite `socket_path` to `\\.\pipe\subminer-socket`; do not keep `/tmp/subminer-socket` on Windows.
 - Native window tracking is built in on Windows; no `xdotool`, `xwininfo`, or compositor-specific helper is required.
--- a/docs-site/public/config.example.jsonc
+++ b/docs-site/public/config.example.jsonc
@@ -187,7 +187,7 @@
  // ==========================================
  // Secondary Subtitles
  // Dual subtitle track options.
-  // Used by the YouTube subtitle loading flow as secondary language preferences.
+  // Used by managed subtitle loading as secondary language preferences for local and YouTube playback.
  // Hot-reload: defaultMode updates live while SubMiner is running.
  // ==========================================
  "secondarySub": {
@@ -415,14 +415,14 @@

  // ==========================================
  // YouTube Playback Settings
-  // Defaults for SubMiner YouTube subtitle loading and languages.
+  // Defaults for managed subtitle language preferences and YouTube subtitle loading.
  // ==========================================
  "youtube": {
    "primarySubLanguages": [
      "ja",
      "jpn"
-    ] // Comma-separated primary subtitle language priority for YouTube auto-loading.
-  }, // Defaults for SubMiner YouTube subtitle loading and languages.
+    ] // Comma-separated primary subtitle language priority for managed subtitle auto-selection.
+  }, // Defaults for managed subtitle language preferences and YouTube subtitle loading.

  // ==========================================
  // Anilist
--- a/docs-site/usage.md
+++ b/docs-site/usage.md
@@ -117,12 +117,15 @@ SubMiner.AppImage --help                  # Show all options

 ### Windows mpv Shortcut

-If you enabled the optional Windows shortcut during install, SubMiner creates a `SubMiner mpv` shortcut in the Start menu and/or on the desktop. It runs `SubMiner.exe --launch-mpv`, which starts `mpv.exe` with SubMiner's `subminer` profile.
+First-run setup creates the config file, then requires the mpv plugin and Yomitan dictionaries before it can finish.
+
+If you enabled the optional Windows shortcut during install, SubMiner creates a `SubMiner mpv` shortcut in the Start menu and/or on the desktop. On Windows, that shortcut is the recommended way to launch local files with SubMiner because it starts `mpv.exe` with the right defaults directly.
+After setup completes, the shortcut is the normal Windows playback entry point.

 You can use it three ways:

- Double-click `SubMiner mpv` to open `mpv` with the SubMiner profile.
- Drag a video file onto `SubMiner mpv` to launch that file with the same profile.
+- Double-click `SubMiner mpv` to open `mpv` with SubMiner's default socket/subtitle args.
+- Drag a video file onto `SubMiner mpv` to launch that file with the same defaults.
 - Run it directly from Command Prompt or PowerShell with `--launch-mpv`.

 ```powershell
@@ -130,7 +133,7 @@ You can use it three ways:
 & "C:\Program Files\SubMiner\SubMiner.exe" --launch-mpv "C:\Videos\episode 01.mkv"
 ```

-This flow requires `mpv.exe` to be on `PATH`. If it is installed elsewhere, set `SUBMINER_MPV_PATH` to the full `mpv.exe` path before launching.
+This flow requires `mpv.exe` to be on `PATH`. If it is installed elsewhere, set `SUBMINER_MPV_PATH` to the full `mpv.exe` path before launching. On Windows, `--launch-mpv` does not require an `mpv.conf` profile named `subminer`.

 ### Launcher Subcommands

@@ -157,12 +160,12 @@ SubMiner.AppImage --setup
 Setup flow:

 - config file: create the default config directory and prefer `config.jsonc`
- plugin status: install or skip the bundled mpv plugin
+- plugin status: install the bundled mpv plugin before finishing setup
 - Yomitan shortcut: open bundled Yomitan settings directly from the setup window
- dictionary check: ensure at least one bundled Yomitan dictionary is available
+- dictionary check: ensure at least one bundled Yomitan dictionary is available, unless an external Yomitan profile is configured
 - Windows: optionally create or remove `SubMiner mpv` Start Menu/Desktop shortcuts (`SubMiner.exe --launch-mpv`)
 - refresh: re-check plugin + dictionary state without restarting
- `Finish setup` stays disabled until dictionary availability is detected
+- `Finish setup` stays disabled until the config, plugin, and dictionary gates are satisfied
 - finish action writes setup completion state and suppresses future auto-open prompts

 AniList character dictionary auto-sync (optional):
@@ -189,7 +192,7 @@ Top-level launcher flags like `--jellyfin-*` are intentionally rejected.

 You can append additional MPV arguments with launcher `-a/--args`, for example `--args "--ao=alsa --volume=80"`.

-You can define a matching profile in `~/.config/mpv/mpv.conf` for consistency when launching `mpv` manually or from other tools. `subminer` launches with `--profile=subminer` by default (or override with `subminer -p <profile> ...`):
+You can define a matching profile in `~/.config/mpv/mpv.conf` for consistency when launching `mpv` manually or from other tools. The Windows `SubMiner.exe --launch-mpv` shortcut path uses equivalent args directly, but skips the extra current-directory subtitle scan to avoid duplicate sidecar detection when you drag a video onto the shortcut; the optional profile remains useful for manual mpv launches and the `subminer` wrapper defaults to `--profile=subminer` (or override with `subminer -p <profile> ...`):

 ```ini
 [subminer]
@@ -210,10 +213,6 @@ secondary-sid=auto
 secondary-sub-visibility=no
 ```

-::: warning
-`secondary-slang` is not a valid mpv option. Use `slang` with `sid=auto` / `secondary-sid=auto` to set subtitle language preferences.
-:::
-
 ### Yomitan setup

 SubMiner includes a bundled Yomitan extension for overlay word lookup. This bundled extension is separate from any Yomitan browser extension you may have installed.
@@ -238,6 +237,8 @@ Notes:
 - Secondary target languages come from `secondarySub.secondarySubLanguages` (defaults to English if unset).
 - Configure defaults in `$XDG_CONFIG_HOME/SubMiner/config.jsonc` (or `~/.config/SubMiner/config.jsonc`) under `youtube` and `secondarySub`.

+For local video files, SubMiner now uses those same config-driven language priorities after mpv finishes reporting subtitle tracks. That means mixed internal/external subtitle sets can correct an initial `sid=auto` guess and settle onto the expected primary and secondary tracks without manual cycling.
+
 ## Controller Support

 SubMiner supports gamepad/controller input for couch-friendly usage via the Chrome Gamepad API. Controller input drives the overlay while keyboard-only mode is enabled.
@@ -291,9 +292,7 @@ See [Keyboard Shortcuts](/shortcuts) for the full reference, including mining sh
 | `Alt+Shift+O` | Toggle visible overlay |
 | `Alt+Shift+Y` | Open Yomitan settings  |

-::: tip
 `Alt+Shift+Y` is fixed and not configurable. All other shortcuts can be changed under `shortcuts` in your config.
-:::

 Useful overlay-local default keybinding: `Ctrl+Alt+P` opens the playlist browser for the current video's parent directory and the live mpv queue so you can append, reorder, remove, or jump between episodes without leaving playback.

--- a/launcher/config/args-normalizer.test.ts
+++ b/launcher/config/args-normalizer.test.ts
@@ -62,6 +62,7 @@ test('createDefaultArgs normalizes configured language codes and env thread over
    assert.deepEqual(parsed.youtubeAudioLangs, ['ja', 'jpn', 'en', 'eng']);
    assert.equal(parsed.whisperThreads, 7);
    assert.equal(parsed.youtubeWhisperSourceLanguage, 'ja');
+    assert.equal(parsed.profile, '');
  } finally {
    if (originalThreads === undefined) {
      delete process.env.SUBMINER_WHISPER_THREADS;
--- a/launcher/config/args-normalizer.ts
+++ b/launcher/config/args-normalizer.ts
@@ -97,7 +97,7 @@ export function createDefaultArgs(launcherConfig: LauncherYoutubeSubgenConfig):
    backend: 'auto',
    directory: '.',
    recursive: false,
-    profile: 'subminer',
+    profile: '',
    startOverlay: false,
    whisperBin: process.env.SUBMINER_WHISPER_BIN || launcherConfig.whisperBin || '',
    whisperModel: process.env.SUBMINER_WHISPER_MODEL || launcherConfig.whisperModel || '',
--- a/launcher/mpv.test.ts
+++ b/launcher/mpv.test.ts
@@ -427,6 +427,19 @@ function withFindAppBinaryEnvSandbox(run: () => void): void {
  }
 }

+function withFindAppBinaryPlatformSandbox(
+  platform: NodeJS.Platform,
+  run: (pathModule: typeof path) => void,
+): void {
+  const originalPlatform = process.platform;
+  try {
+    Object.defineProperty(process, 'platform', { value: platform, configurable: true });
+    withFindAppBinaryEnvSandbox(() => run(platform === 'win32' ? (path.win32 as typeof path) : path));
+  } finally {
+    Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true });
+  }
+}
+
 function withAccessSyncStub(
  isExecutablePath: (filePath: string) => boolean,
  run: () => void,
@@ -447,7 +460,7 @@ function withAccessSyncStub(
  }
 }

-test('findAppBinary resolves ~/.local/bin/SubMiner.AppImage when it exists', () => {
+test('findAppBinary resolves ~/.local/bin/SubMiner.AppImage when it exists', { concurrency: false }, () => {
  const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), 'subminer-test-home-'));
  const originalHomedir = os.homedir;
  try {
@@ -455,8 +468,8 @@ test('findAppBinary resolves ~/.local/bin/SubMiner.AppImage when it exists', ()
    const appImage = path.join(baseDir, '.local/bin/SubMiner.AppImage');
    makeExecutable(appImage);

-    withFindAppBinaryEnvSandbox(() => {
-      const result = findAppBinary('/some/other/path/subminer');
+    withFindAppBinaryPlatformSandbox('linux', (pathModule) => {
+      const result = findAppBinary('/some/other/path/subminer', pathModule);
      assert.equal(result, appImage);
    });
  } finally {
@@ -465,16 +478,16 @@ test('findAppBinary resolves ~/.local/bin/SubMiner.AppImage when it exists', ()
  }
 });

-test('findAppBinary resolves /opt/SubMiner/SubMiner.AppImage when ~/.local/bin candidate does not exist', () => {
+test('findAppBinary resolves /opt/SubMiner/SubMiner.AppImage when ~/.local/bin candidate does not exist', { concurrency: false }, () => {
  const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), 'subminer-test-home-'));
  const originalHomedir = os.homedir;
  try {
    os.homedir = () => baseDir;
-    withFindAppBinaryEnvSandbox(() => {
+    withFindAppBinaryPlatformSandbox('linux', (pathModule) => {
      withAccessSyncStub(
        (filePath) => filePath === '/opt/SubMiner/SubMiner.AppImage',
        () => {
-          const result = findAppBinary('/some/other/path/subminer');
+          const result = findAppBinary('/some/other/path/subminer', pathModule);
          assert.equal(result, '/opt/SubMiner/SubMiner.AppImage');
        },
      );
@@ -485,7 +498,7 @@ test('findAppBinary resolves /opt/SubMiner/SubMiner.AppImage when ~/.local/bin c
  }
 });

-test('findAppBinary finds subminer on PATH when AppImage candidates do not exist', () => {
+test('findAppBinary finds subminer on PATH when AppImage candidates do not exist', { concurrency: false }, () => {
  const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), 'subminer-test-path-'));
  const originalHomedir = os.homedir;
  const originalPath = process.env.PATH;
@@ -497,12 +510,12 @@ test('findAppBinary finds subminer on PATH when AppImage candidates do not exist
    makeExecutable(wrapperPath);
    process.env.PATH = `${binDir}${path.delimiter}${originalPath ?? ''}`;

-    withFindAppBinaryEnvSandbox(() => {
+    withFindAppBinaryPlatformSandbox('linux', (pathModule) => {
      withAccessSyncStub(
        (filePath) => filePath === wrapperPath,
        () => {
          // selfPath must differ from wrapperPath so the self-check does not exclude it
-          const result = findAppBinary(path.join(baseDir, 'launcher', 'subminer'));
+          const result = findAppBinary(path.join(baseDir, 'launcher', 'subminer'), pathModule);
          assert.equal(result, wrapperPath);
        },
      );
@@ -513,3 +526,98 @@ test('findAppBinary finds subminer on PATH when AppImage candidates do not exist
    fs.rmSync(baseDir, { recursive: true, force: true });
  }
 });
+
+test('findAppBinary resolves Windows install paths when present', { concurrency: false }, () => {
+  const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), 'subminer-test-win-'));
+  const originalHomedir = os.homedir;
+  const originalLocalAppData = process.env.LOCALAPPDATA;
+  try {
+    os.homedir = () => baseDir;
+    process.env.LOCALAPPDATA = path.win32.join(baseDir, 'AppData', 'Local');
+    const appExe = path.win32.join(
+      baseDir,
+      'AppData',
+      'Local',
+      'Programs',
+      'SubMiner',
+      'SubMiner.exe',
+    );
+
+    withFindAppBinaryPlatformSandbox('win32', (pathModule) => {
+      withAccessSyncStub(
+        (filePath) => filePath === appExe,
+        () => {
+          const result = findAppBinary(pathModule.join(baseDir, 'launcher', 'SubMiner.exe'), pathModule);
+          assert.equal(result, appExe);
+        },
+      );
+    });
+  } finally {
+    os.homedir = originalHomedir;
+    if (originalLocalAppData === undefined) {
+      delete process.env.LOCALAPPDATA;
+    } else {
+      process.env.LOCALAPPDATA = originalLocalAppData;
+    }
+    fs.rmSync(baseDir, { recursive: true, force: true });
+  }
+});
+
+test('findAppBinary resolves SubMiner.exe on PATH on Windows', { concurrency: false }, () => {
+  const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), 'subminer-test-win-path-'));
+  const originalHomedir = os.homedir;
+  const originalPath = process.env.PATH;
+  try {
+    os.homedir = () => baseDir;
+    const binDir = path.win32.join(baseDir, 'bin');
+    const wrapperPath = path.win32.join(binDir, 'SubMiner.exe');
+    makeExecutable(wrapperPath);
+    process.env.PATH = `${binDir}${path.win32.delimiter}${originalPath ?? ''}`;
+
+    withFindAppBinaryPlatformSandbox('win32', (pathModule) => {
+      withAccessSyncStub(
+        (filePath) => filePath === wrapperPath,
+        () => {
+          const result = findAppBinary(pathModule.join(baseDir, 'launcher', 'SubMiner.exe'), pathModule);
+          assert.equal(result, wrapperPath);
+        },
+      );
+    });
+  } finally {
+    os.homedir = originalHomedir;
+    process.env.PATH = originalPath;
+    fs.rmSync(baseDir, { recursive: true, force: true });
+  }
+});
+
+test('findAppBinary resolves a Windows install directory to SubMiner.exe', { concurrency: false }, () => {
+  const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), 'subminer-test-win-dir-'));
+  const originalHomedir = os.homedir;
+  const originalSubminerBinaryPath = process.env.SUBMINER_BINARY_PATH;
+  try {
+    os.homedir = () => baseDir;
+    const installDir = path.win32.join(baseDir, 'Programs', 'SubMiner');
+    const appExe = path.win32.join(installDir, 'SubMiner.exe');
+    process.env.SUBMINER_BINARY_PATH = installDir;
+    fs.mkdirSync(installDir, { recursive: true });
+    fs.writeFileSync(appExe, '#!/bin/sh\nexit 0\n');
+    fs.chmodSync(appExe, 0o755);
+
+    const originalPlatform = process.platform;
+    try {
+      Object.defineProperty(process, 'platform', { value: 'win32', configurable: true });
+      const result = findAppBinary(path.win32.join(baseDir, 'launcher', 'SubMiner.exe'), path.win32);
+      assert.equal(result, appExe);
+    } finally {
+      Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true });
+    }
+  } finally {
+    os.homedir = originalHomedir;
+    if (originalSubminerBinaryPath === undefined) {
+      delete process.env.SUBMINER_BINARY_PATH;
+    } else {
+      process.env.SUBMINER_BINARY_PATH = originalSubminerBinaryPath;
+    }
+    fs.rmSync(baseDir, { recursive: true, force: true });
+  }
+});
--- a/launcher/mpv.ts
+++ b/launcher/mpv.ts
@@ -14,7 +14,6 @@ import {
  isExecutable,
  resolveBinaryPathCandidate,
  resolveCommandInvocation,
-  realpathMaybe,
  isYoutubeTarget,
  uniqueNormalizedLangCodes,
  sleep,
@@ -35,6 +34,8 @@ type SpawnTarget = {
  args: string[];
 };

+type PathModule = Pick<typeof path, 'join' | 'extname' | 'delimiter' | 'sep' | 'resolve'>;
+
 const DETACHED_IDLE_MPV_PID_FILE = path.join(os.tmpdir(), 'subminer-idle-mpv.pid');
 const OVERLAY_START_SOCKET_READY_TIMEOUT_MS = 900;
 const OVERLAY_START_COMMAND_SETTLE_TIMEOUT_MS = 700;
@@ -243,18 +244,49 @@ export function detectBackend(backend: Backend): Exclude<Backend, 'auto'> {
  fail('Could not detect display backend');
 }

-function resolveMacAppBinaryCandidate(candidate: string): string {
+function resolveAppBinaryCandidate(candidate: string, pathModule: PathModule = path): string {
  const direct = resolveBinaryPathCandidate(candidate);
  if (!direct) return '';

-  if (process.platform !== 'darwin') {
-    return isExecutable(direct) ? direct : '';
+  if (process.platform === 'win32') {
+    try {
+      if (fs.existsSync(direct) && fs.statSync(direct).isDirectory()) {
+        for (const candidateBinary of ['SubMiner.exe', 'subminer.exe']) {
+          const nestedCandidate = pathModule.join(direct, candidateBinary);
+          if (isExecutable(nestedCandidate)) {
+            return nestedCandidate;
+          }
+        }
+        return '';
+      }
+    } catch {
+      // ignore
    }

    if (isExecutable(direct)) {
      return direct;
    }

+    if (!pathModule.extname(direct)) {
+      for (const extension of ['.exe', '.cmd', '.bat']) {
+        const withExtension = `${direct}${extension}`;
+        if (isExecutable(withExtension)) {
+          return withExtension;
+        }
+      }
+    }
+
+    return '';
+  }
+
+  if (isExecutable(direct)) {
+    return direct;
+  }
+
+  if (process.platform !== 'darwin') {
+    return '';
+  }
+
  const appIndex = direct.indexOf('.app/');
  const appPath =
    direct.endsWith('.app') && direct.includes('.app')
@@ -265,8 +297,8 @@ function resolveMacAppBinaryCandidate(candidate: string): string {
  if (!appPath) return '';

  const candidates = [
-    path.join(appPath, 'Contents', 'MacOS', 'SubMiner'),
-    path.join(appPath, 'Contents', 'MacOS', 'subminer'),
+    pathModule.join(appPath, 'Contents', 'MacOS', 'SubMiner'),
+    pathModule.join(appPath, 'Contents', 'MacOS', 'subminer'),
  ];

  for (const candidateBinary of candidates) {
@@ -278,41 +310,78 @@ function resolveMacAppBinaryCandidate(candidate: string): string {
  return '';
 }

-export function findAppBinary(selfPath: string): string | null {
+function findCommandOnPath(candidates: string[], pathModule: PathModule = path): string {
+  const pathDirs = getPathEnv().split(pathModule.delimiter);
+  for (const candidateName of candidates) {
+    for (const dir of pathDirs) {
+      if (!dir) continue;
+
+      const directCandidate = pathModule.join(dir, candidateName);
+      if (isExecutable(directCandidate)) {
+        return directCandidate;
+      }
+
+      if (process.platform === 'win32' && !pathModule.extname(candidateName)) {
+        for (const extension of ['.exe', '.cmd', '.bat']) {
+          const extendedCandidate = pathModule.join(dir, `${candidateName}${extension}`);
+          if (isExecutable(extendedCandidate)) {
+            return extendedCandidate;
+          }
+        }
+      }
+    }
+  }
+
+  return '';
+}
+
+export function findAppBinary(selfPath: string, pathModule: PathModule = path): string | null {
  const envPaths = [process.env.SUBMINER_APPIMAGE_PATH, process.env.SUBMINER_BINARY_PATH].filter(
    (candidate): candidate is string => Boolean(candidate),
  );

  for (const envPath of envPaths) {
-    const resolved = resolveMacAppBinaryCandidate(envPath);
+    const resolved = resolveAppBinaryCandidate(envPath, pathModule);
    if (resolved) {
      return resolved;
    }
  }

  const candidates: string[] = [];
-  if (process.platform === 'darwin') {
+  if (process.platform === 'win32') {
+    const localAppData =
+      process.env.LOCALAPPDATA?.trim() ||
+      (process.env.APPDATA?.trim() || '').replace(/[\\/]Roaming$/i, `${pathModule.sep}Local`) ||
+      pathModule.join(os.homedir(), 'AppData', 'Local');
+    const programFiles = process.env.ProgramFiles?.trim() || 'C:\\Program Files';
+    const programFilesX86 = process.env['ProgramFiles(x86)']?.trim() || 'C:\\Program Files (x86)';
+    candidates.push(pathModule.join(localAppData, 'Programs', 'SubMiner', 'SubMiner.exe'));
+    candidates.push(pathModule.join(programFiles, 'SubMiner', 'SubMiner.exe'));
+    candidates.push(pathModule.join(programFilesX86, 'SubMiner', 'SubMiner.exe'));
+    candidates.push('C:\\SubMiner\\SubMiner.exe');
+  } else if (process.platform === 'darwin') {
    candidates.push('/Applications/SubMiner.app/Contents/MacOS/SubMiner');
    candidates.push('/Applications/SubMiner.app/Contents/MacOS/subminer');
-    candidates.push(path.join(os.homedir(), 'Applications/SubMiner.app/Contents/MacOS/SubMiner'));
-    candidates.push(path.join(os.homedir(), 'Applications/SubMiner.app/Contents/MacOS/subminer'));
-  }
-
-  candidates.push(path.join(os.homedir(), '.local/bin/SubMiner.AppImage'));
+    candidates.push(pathModule.join(os.homedir(), 'Applications/SubMiner.app/Contents/MacOS/SubMiner'));
+    candidates.push(pathModule.join(os.homedir(), 'Applications/SubMiner.app/Contents/MacOS/subminer'));
+  } else {
+    candidates.push(pathModule.join(os.homedir(), '.local/bin/SubMiner.AppImage'));
    candidates.push('/opt/SubMiner/SubMiner.AppImage');
+  }

  for (const candidate of candidates) {
-    if (isExecutable(candidate)) return candidate;
+    const resolved = resolveAppBinaryCandidate(candidate, pathModule);
+    if (resolved) return resolved;
  }

-  const fromPath = getPathEnv()
-    .split(path.delimiter)
-    .map((dir) => path.join(dir, 'subminer'))
-    .find((candidate) => isExecutable(candidate));
+  const fromPath = findCommandOnPath(
+    process.platform === 'win32' ? ['SubMiner', 'subminer'] : ['subminer'],
+    pathModule,
+  );

  if (fromPath) {
-    const resolvedSelf = realpathMaybe(selfPath);
-    const resolvedCandidate = realpathMaybe(fromPath);
+    const resolvedSelf = pathModule.resolve(selfPath);
+    const resolvedCandidate = pathModule.resolve(fromPath);
    if (resolvedSelf !== resolvedCandidate) return fromPath;
  }

--- a/package.json
+++ b/package.json
@@ -13,6 +13,7 @@
    "test-yomitan-parser:electron": "bun run build:yomitan && bun build scripts/test-yomitan-parser.ts --format=cjs --target=node --outfile dist/scripts/test-yomitan-parser.js --external electron && env -u ELECTRON_RUN_AS_NODE electron dist/scripts/test-yomitan-parser.js",
    "build:yomitan": "bun scripts/build-yomitan.mjs",
    "build:assets": "bun scripts/prepare-build-assets.mjs",
+    "build:launcher": "bun build ./launcher/main.ts --target=bun --packages=bundle --outfile=dist/launcher/subminer",
    "build:stats": "cd stats && bun run build",
    "dev:stats": "cd stats && bun run dev",
    "build": "bun run build:yomitan && bun run build:stats && tsc -p tsconfig.json && bun run build:renderer && bun run build:assets",
--- a/plugin/subminer/lifecycle.lua
+++ b/plugin/subminer/lifecycle.lua
@@ -29,13 +29,25 @@ function M.create(ctx)
 		return options_helper.coerce_bool(raw_auto_start, false)
 	end

+	local function rearm_managed_subtitle_defaults()
+		if not process.has_matching_mpv_ipc_socket(opts.socket_path) then
+			return false
+		end
+
+		mp.set_property_native("sub-auto", "fuzzy")
+		mp.set_property_native("sid", "auto")
+		mp.set_property_native("secondary-sid", "auto")
+		return true
+	end
+
 	local function on_file_loaded()
 		aniskip.clear_aniskip_state()
 		process.disarm_auto_play_ready_gate()
+		local has_matching_socket = rearm_managed_subtitle_defaults()

 		local should_auto_start = resolve_auto_start_enabled()
 		if should_auto_start then
-			if not process.has_matching_mpv_ipc_socket(opts.socket_path) then
+			if not has_matching_socket then
 				subminer_log(
 					"info",
 					"lifecycle",
--- a/scripts/test-plugin-start-gate.lua
+++ b/scripts/test-plugin-start-gate.lua
@@ -178,6 +178,12 @@ local function run_plugin_scenario(config)
 				value = value,
 			}
 		end
+		function mp.set_property(name, value)
+			recorded.property_sets[#recorded.property_sets + 1] = {
+				name = name,
+				value = value,
+			}
+		end
 		function mp.get_script_name()
 			return "subminer"
 		end
@@ -531,6 +537,38 @@ do
 	)
 end

+do
+	local recorded, err = run_plugin_scenario({
+		process_list = "",
+		option_overrides = {
+			binary_path = binary_path,
+			auto_start = "yes",
+			auto_start_visible_overlay = "yes",
+			auto_start_pause_until_ready = "no",
+			socket_path = "/tmp/subminer-socket",
+		},
+		input_ipc_server = "/tmp/subminer-socket",
+		media_title = "Random Movie",
+		files = {
+			[binary_path] = true,
+		},
+	})
+	assert_true(recorded ~= nil, "plugin failed to load for subtitle rearm scenario: " .. tostring(err))
+	fire_event(recorded, "file-loaded")
+	assert_true(
+		has_property_set(recorded.property_sets, "sub-auto", "fuzzy"),
+		"managed file-loaded should rearm sub-auto for idle mpv sessions"
+	)
+	assert_true(
+		has_property_set(recorded.property_sets, "sid", "auto"),
+		"managed file-loaded should rearm primary subtitle selection for idle mpv sessions"
+	)
+	assert_true(
+		has_property_set(recorded.property_sets, "secondary-sid", "auto"),
+		"managed file-loaded should rearm secondary subtitle selection for idle mpv sessions"
+	)
+end
+
 do
 	local recorded, err = run_plugin_scenario({
 		process_list = "",
@@ -1037,6 +1075,10 @@ do
 		start_call == nil,
 		"auto-start should be skipped when mpv input-ipc-server does not match configured socket_path"
 	)
+	assert_true(
+		not has_property_set(recorded.property_sets, "sid", "auto"),
+		"subtitle rearm should not run when mpv input-ipc-server does not match configured socket_path"
+	)
 	assert_true(
 		not has_property_set(recorded.property_sets, "pause", true),
 		"pause-until-ready gate should not arm when socket_path does not match"
--- a/src/cli/help.test.ts
+++ b/src/cli/help.test.ts
@@ -17,7 +17,7 @@ test('printHelp includes configured texthooker port', () => {

  assert.match(output, /--help\s+Show this help/);
  assert.match(output, /default: 7777/);
-  assert.match(output, /--launch-mpv/);
+  assert.match(output, /--launch-mpv.*Launch mpv with SubMiner defaults and exit/);
  assert.match(output, /--stats\s+Open the stats dashboard in your browser/);
  assert.doesNotMatch(output, /--refresh-known-words/);
  assert.match(output, /--setup\s+Open first-run setup window/);
--- a/src/cli/help.ts
+++ b/src/cli/help.ts
@@ -12,7 +12,7 @@ ${B}Usage:${R} subminer ${D}[command] [options]${R}
 ${B}Session${R}
  --background                   Start in tray/background mode
  --start                        Connect to mpv and launch overlay
-  --launch-mpv ${D}[targets...]${R}       Launch mpv with the SubMiner mpv profile and exit
+  --launch-mpv ${D}[targets...]${R}       Launch mpv with SubMiner defaults and exit
  --stop                         Stop the running instance
  --stats                        Open the stats dashboard in your browser
  --texthooker                   Start texthooker server only ${D}(no overlay)${R}
--- a/src/config/config.test.ts
+++ b/src/config/config.test.ts
@@ -2138,7 +2138,7 @@ test('template generator includes known keys', () => {
  );
  assert.match(
    output,
-    /"primarySubLanguages": \[\s*"ja",\s*"jpn"\s*\],? \/\/ Comma-separated primary subtitle language priority for YouTube auto-loading\./,
+    /"primarySubLanguages": \[\s*"ja",\s*"jpn"\s*\],? \/\/ Comma-separated primary subtitle language priority for managed subtitle auto-selection\./,
  );
  assert.doesNotMatch(output, /"mode": "automatic"/);
  assert.doesNotMatch(output, /"fixWithAi": false/);
--- a/src/config/definitions/options-core.ts
+++ b/src/config/definitions/options-core.ts
@@ -87,7 +87,8 @@ export function buildCoreConfigOptionRegistry(
      path: 'youtube.primarySubLanguages',
      kind: 'string',
      defaultValue: defaultConfig.youtube.primarySubLanguages.join(','),
-      description: 'Comma-separated primary subtitle language priority for YouTube auto-loading.',
+      description:
+        'Comma-separated primary subtitle language priority for managed subtitle auto-selection.',
    },
    {
      path: 'controller.enabled',
--- a/src/config/definitions/template-sections.ts
+++ b/src/config/definitions/template-sections.ts
@@ -74,7 +74,7 @@ const CORE_TEMPLATE_SECTIONS: ConfigTemplateSection[] = [
    title: 'Secondary Subtitles',
    description: [
      'Dual subtitle track options.',
-      'Used by the YouTube subtitle loading flow as secondary language preferences.',
+      'Used by managed subtitle loading as secondary language preferences for local and YouTube playback.',
    ],
    notes: ['Hot-reload: defaultMode updates live while SubMiner is running.'],
    key: 'secondarySub',
@@ -131,7 +131,7 @@ const INTEGRATION_TEMPLATE_SECTIONS: ConfigTemplateSection[] = [
  },
  {
    title: 'YouTube Playback Settings',
-    description: ['Defaults for SubMiner YouTube subtitle loading and languages.'],
+    description: ['Defaults for managed subtitle language preferences and YouTube subtitle loading.'],
    key: 'youtube',
  },
  {
--- a/src/core/services/mpv-protocol.test.ts
+++ b/src/core/services/mpv-protocol.test.ts
@@ -184,6 +184,39 @@ test('dispatchMpvProtocolMessage sets secondary subtitle track based on track li
  assert.deepEqual(state.commands, [{ command: ['set_property', 'secondary-sid', 2] }]);
 });

+test('dispatchMpvProtocolMessage prefers the already selected matching secondary track', async () => {
+  const { deps, state } = createDeps();
+
+  await dispatchMpvProtocolMessage(
+    {
+      request_id: MPV_REQUEST_ID_TRACK_LIST_SECONDARY,
+      data: [
+        {
+          type: 'sub',
+          id: 2,
+          lang: 'ja',
+          title: 'ja.srt',
+          selected: false,
+          external: true,
+          'external-filename': '/tmp/dupe.srt',
+        },
+        {
+          type: 'sub',
+          id: 3,
+          lang: 'ja',
+          title: 'ja.srt',
+          selected: true,
+          external: true,
+          'external-filename': '/tmp/dupe.srt',
+        },
+      ],
+    },
+    deps,
+  );
+
+  assert.deepEqual(state.commands, [{ command: ['set_property', 'secondary-sid', 3] }]);
+});
+
 test('dispatchMpvProtocolMessage restores secondary visibility on shutdown', async () => {
  const { deps, state } = createDeps();

--- a/src/core/services/mpv-protocol.ts
+++ b/src/core/services/mpv-protocol.ts
@@ -93,6 +93,97 @@ export interface MpvProtocolHandleMessageDeps {
  restorePreviousSecondarySubVisibility: () => void;
 }

+type SubtitleTrackCandidate = {
+  id: number;
+  lang: string;
+  title: string;
+  selected: boolean;
+  external: boolean;
+  externalFilename: string | null;
+};
+
+function normalizeSubtitleTrackCandidate(track: Record<string, unknown>): SubtitleTrackCandidate | null {
+  const id =
+    typeof track.id === 'number'
+      ? track.id
+      : typeof track.id === 'string'
+        ? Number(track.id.trim())
+        : Number.NaN;
+  if (!Number.isInteger(id)) {
+    return null;
+  }
+
+  const externalFilename =
+    typeof track['external-filename'] === 'string' && track['external-filename'].trim().length > 0
+      ? track['external-filename'].trim()
+      : typeof track.external_filename === 'string' && track.external_filename.trim().length > 0
+        ? track.external_filename.trim()
+        : null;
+
+  return {
+    id,
+    lang: String(track.lang || '').trim().toLowerCase(),
+    title: String(track.title || '').trim().toLowerCase(),
+    selected: track.selected === true,
+    external: track.external === true,
+    externalFilename,
+  };
+}
+
+function getSubtitleTrackIdentity(track: SubtitleTrackCandidate): string {
+  if (track.externalFilename) {
+    return `external:${track.externalFilename.toLowerCase()}`;
+  }
+  if (track.title.length > 0) {
+    return `title:${track.title}`;
+  }
+  return `id:${track.id}`;
+}
+
+function pickSecondarySubtitleTrackId(
+  tracks: Array<Record<string, unknown>>,
+  preferredLanguages: string[],
+): number | null {
+  const normalizedLanguages = preferredLanguages
+    .map((language) => language.trim().toLowerCase())
+    .filter((language) => language.length > 0);
+  if (normalizedLanguages.length === 0) {
+    return null;
+  }
+
+  const subtitleTracks = tracks
+    .filter((track) => track.type === 'sub')
+    .map(normalizeSubtitleTrackCandidate)
+    .filter((track): track is SubtitleTrackCandidate => track !== null);
+
+  const dedupedTracks = new Map<string, SubtitleTrackCandidate>();
+  for (const track of subtitleTracks) {
+    const identity = getSubtitleTrackIdentity(track);
+    const existing = dedupedTracks.get(identity);
+    if (!existing || (track.selected && !existing.selected)) {
+      dedupedTracks.set(identity, track);
+    }
+  }
+
+  const uniqueTracks = [...dedupedTracks.values()];
+
+  for (const language of normalizedLanguages) {
+    const selectedMatch = uniqueTracks.find(
+      (track) => track.selected && track.lang === language,
+    );
+    if (selectedMatch) {
+      return selectedMatch.id;
+    }
+
+    const match = uniqueTracks.find((track) => track.lang === language);
+    if (match) {
+      return match.id;
+    }
+  }
+
+  return null;
+}
+
 export function splitMpvMessagesFromBuffer(
  buffer: string,
  onMessage?: MpvMessageParser,
@@ -283,15 +374,11 @@ export async function dispatchMpvProtocolMessage(
      if (Array.isArray(tracks)) {
        const config = deps.getResolvedConfig();
        const languages = config.secondarySub?.secondarySubLanguages || [];
-        const subTracks = tracks.filter((track) => track.type === 'sub');
-        for (const language of languages) {
-          const match = subTracks.find((track) => track.lang === language);
-          if (match) {
+        const secondaryTrackId = pickSecondarySubtitleTrackId(tracks, languages);
+        if (secondaryTrackId !== null) {
          deps.sendCommand({
-              command: ['set_property', 'secondary-sid', match.id],
+            command: ['set_property', 'secondary-sid', secondaryTrackId],
          });
-            break;
-          }
        }
      }
    } else if (msg.request_id === MPV_REQUEST_ID_TRACK_LIST_AUDIO) {
--- a/src/core/services/subsync.test.ts
+++ b/src/core/services/subsync.test.ts
@@ -92,6 +92,52 @@ test('triggerSubsyncFromConfig opens manual picker in manual mode', async () =>
  assert.equal(inProgressState, false);
 });

+test('triggerSubsyncFromConfig dedupes repeated subtitle source tracks', async () => {
+  let payloadTrackCount = 0;
+
+  await triggerSubsyncFromConfig(
+    makeDeps({
+      getMpvClient: () => ({
+        connected: true,
+        currentAudioStreamIndex: null,
+        send: () => {},
+        requestProperty: async (name: string) => {
+          if (name === 'path') return '/tmp/video.mkv';
+          if (name === 'sid') return 1;
+          if (name === 'secondary-sid') return 2;
+          if (name === 'track-list') {
+            return [
+              { id: 1, type: 'sub', selected: true, lang: 'jpn' },
+              {
+                id: 2,
+                type: 'sub',
+                selected: true,
+                external: true,
+                lang: 'eng',
+                'external-filename': '/tmp/ref.srt',
+              },
+              {
+                id: 3,
+                type: 'sub',
+                selected: false,
+                external: true,
+                lang: 'eng',
+                'external-filename': '/tmp/ref.srt',
+              },
+            ];
+          }
+          return null;
+        },
+      }),
+      openManualPicker: (payload) => {
+        payloadTrackCount = payload.sourceTracks.length;
+      },
+    }),
+  );
+
+  assert.equal(payloadTrackCount, 1);
+});
+
 test('triggerSubsyncFromConfig reports failures to OSD', async () => {
  const osd: string[] = [];
  await triggerSubsyncFromConfig(
--- a/src/core/services/subsync.ts
+++ b/src/core/services/subsync.ts
@@ -76,6 +76,31 @@ function normalizeTrackIds(tracks: unknown[]): MpvTrack[] {
  });
 }

+function getSourceTrackIdentity(track: MpvTrack): string {
+  if (track.external && typeof track['external-filename'] === 'string' && track['external-filename'].length > 0) {
+    return `external:${track['external-filename'].toLowerCase()}`;
+  }
+  if (typeof track.id === 'number') {
+    return `id:${track.id}`;
+  }
+  if (typeof track.title === 'string' && track.title.length > 0) {
+    return `title:${track.title.toLowerCase()}`;
+  }
+  return 'unknown';
+}
+
+function dedupeSourceTracks(tracks: MpvTrack[]): MpvTrack[] {
+  const deduped = new Map<string, MpvTrack>();
+  for (const track of tracks) {
+    const identity = getSourceTrackIdentity(track);
+    const existing = deduped.get(identity);
+    if (!existing || (track.selected && !existing.selected)) {
+      deduped.set(identity, track);
+    }
+  }
+  return [...deduped.values()];
+}
+
 export interface TriggerSubsyncFromConfigDeps extends SubsyncCoreDeps {
  isSubsyncInProgress: () => boolean;
  setSubsyncInProgress: (inProgress: boolean) => void;
@@ -123,12 +148,13 @@ async function gatherSubsyncContext(client: MpvClientLike): Promise<SubsyncConte
      const filename = track['external-filename'];
      return typeof filename === 'string' && filename.length > 0;
    });
+  const uniqueSourceTracks = dedupeSourceTracks(sourceTracks);

  return {
    videoPath,
    primaryTrack,
    secondaryTrack,
-    sourceTracks,
+    sourceTracks: uniqueSourceTracks,
    audioStreamIndex: client.currentAudioStreamIndex,
  };
 }
--- a/src/main-entry-runtime.test.ts
+++ b/src/main-entry-runtime.test.ts
@@ -2,6 +2,7 @@ import assert from 'node:assert/strict';
 import test from 'node:test';
 import {
  configureEarlyAppPaths,
+  normalizeLaunchMpvExtraArgs,
  normalizeStartupArgv,
  normalizeLaunchMpvTargets,
  sanitizeHelpEnv,
@@ -70,6 +71,61 @@ test('launch-mpv entry helpers detect and normalize targets', () => {
  assert.deepEqual(normalizeLaunchMpvTargets(['SubMiner.exe', '--launch-mpv', 'C:\\a.mkv']), [
    'C:\\a.mkv',
  ]);
+  assert.deepEqual(
+    normalizeLaunchMpvExtraArgs([
+      'SubMiner.exe',
+      '--launch-mpv',
+      '--sub-file',
+      'track.srt',
+      'C:\\a.mkv',
+    ]),
+    ['--sub-file', 'track.srt'],
+  );
+  assert.deepEqual(
+    normalizeLaunchMpvTargets([
+      'SubMiner.exe',
+      '--launch-mpv',
+      '--sub-file',
+      'track.srt',
+      'C:\\a.mkv',
+    ]),
+    ['C:\\a.mkv'],
+  );
+  assert.deepEqual(
+    normalizeLaunchMpvExtraArgs([
+      'SubMiner.exe',
+      '--launch-mpv',
+      '--profile=subminer',
+      '--pause=yes',
+      'C:\\a.mkv',
+    ]),
+    ['--profile=subminer', '--pause=yes'],
+  );
+  assert.deepEqual(
+    normalizeLaunchMpvExtraArgs([
+      'SubMiner.exe',
+      '--launch-mpv',
+      '--input-ipc-server',
+      '\\\\.\\pipe\\custom-subminer-socket',
+      '--alang',
+      'ja,jpn',
+      'C:\\a.mkv',
+    ]),
+    ['--input-ipc-server', '\\\\.\\pipe\\custom-subminer-socket', '--alang', 'ja,jpn'],
+  );
+  assert.deepEqual(
+    normalizeLaunchMpvTargets([
+      'SubMiner.exe',
+      '--launch-mpv',
+      '--input-ipc-server',
+      '\\\\.\\pipe\\custom-subminer-socket',
+      '--alang',
+      'ja,jpn',
+      'C:\\a.mkv',
+      'C:\\b.mkv',
+    ]),
+    ['C:\\a.mkv', 'C:\\b.mkv'],
+  );
 });

 test('stats-daemon entry helper detects internal daemon commands', () => {
--- a/src/main-entry-runtime.ts
+++ b/src/main-entry-runtime.ts
@@ -121,7 +121,82 @@ export function shouldHandleStatsDaemonCommandAtEntry(
 }

 export function normalizeLaunchMpvTargets(argv: string[]): string[] {
-  return parseCliArgs(argv).launchMpvTargets;
+  const launchMpvIndex = argv.findIndex((arg) => arg === '--launch-mpv');
+  if (launchMpvIndex < 0) {
+    return [];
+  }
+
+  const targets: string[] = [];
+
+  let parsingTargets = false;
+  for (let i = launchMpvIndex + 1; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (!token) continue;
+
+    if (parsingTargets) {
+      targets.push(token);
+      continue;
+    }
+
+    if (token === '--') {
+      parsingTargets = true;
+      continue;
+    }
+
+    if (token.startsWith('--')) {
+      if (!token.includes('=') && i + 1 < argv.length) {
+        const value = argv[i + 1];
+        if (value && !value.startsWith('-')) {
+          i += 1;
+        }
+      }
+      continue;
+    }
+
+    if (token.startsWith('-')) {
+      continue;
+    }
+
+    parsingTargets = true;
+    targets.push(token);
+  }
+
+  return targets;
+}
+
+export function normalizeLaunchMpvExtraArgs(argv: string[]): string[] {
+  const launchMpvIndex = argv.findIndex((arg) => arg === '--launch-mpv');
+  if (launchMpvIndex < 0) {
+    return [];
+  }
+
+  const extraArgs: string[] = [];
+  for (let i = launchMpvIndex + 1; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (!token) continue;
+    if (token === '--') {
+      break;
+    }
+    if (token.startsWith('--')) {
+      extraArgs.push(token);
+      if (!token.includes('=') && i + 1 < argv.length) {
+        const value = argv[i + 1];
+        if (value && !value.startsWith('-')) {
+          extraArgs.push(value);
+          i += 1;
+        }
+      }
+      continue;
+    }
+    if (token.startsWith('-')) {
+      extraArgs.push(token);
+      continue;
+    }
+    if (!token.startsWith('-')) {
+      break;
+    }
+  }
+  return extraArgs;
 }

 export function sanitizeStartupEnv(baseEnv: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
--- a/src/main-entry.ts
+++ b/src/main-entry.ts
@@ -1,8 +1,10 @@
+import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { app, dialog } from 'electron';
 import { printHelp } from './cli/help';
 import {
  configureEarlyAppPaths,
+  normalizeLaunchMpvExtraArgs,
  normalizeLaunchMpvTargets,
  normalizeStartupArgv,
  sanitizeStartupEnv,
@@ -15,6 +17,7 @@ import {
  shouldHandleStatsDaemonCommandAtEntry,
 } from './main-entry-runtime';
 import { requestSingleInstanceLockEarly } from './main/early-single-instance';
+import { resolvePackagedFirstRunPluginAssets } from './main/runtime/first-run-setup-plugin';
 import { createWindowsMpvLaunchDeps, launchWindowsMpv } from './main/runtime/windows-mpv-launch';
 import { runStatsDaemonControlFromProcess } from './stats-daemon-entry';

@@ -32,6 +35,19 @@ function applySanitizedEnv(sanitizedEnv: NodeJS.ProcessEnv): void {
  }
 }

+function resolveBundledWindowsMpvPluginEntrypoint(): string | undefined {
+  const assets = resolvePackagedFirstRunPluginAssets({
+    dirname: __dirname,
+    appPath: app.getAppPath(),
+    resourcesPath: process.resourcesPath,
+  });
+  if (!assets) {
+    return undefined;
+  }
+
+  return path.join(assets.pluginDirSource, 'main.lua');
+}
+
 process.argv = normalizeStartupArgv(process.argv, process.env);
 applySanitizedEnv(sanitizeStartupEnv(process.env));
 configureEarlyAppPaths(app);
@@ -68,6 +84,9 @@ if (shouldHandleLaunchMpvAtEntry(process.argv, process.env)) {
          dialog.showErrorBox(title, content);
        },
      }),
+      normalizeLaunchMpvExtraArgs(process.argv),
+      process.execPath,
+      resolveBundledWindowsMpvPluginEntrypoint(),
    );
    app.exit(result.ok ? 0 : 1);
  });
--- a/src/main.ts
+++ b/src/main.ts
@@ -339,6 +339,7 @@ import { startStatsServer } from './core/services/stats-server';
 import { registerStatsOverlayToggle, destroyStatsWindow } from './core/services/stats-window.js';
 import {
  createFirstRunSetupService,
+  getFirstRunSetupCompletionMessage,
  shouldAutoOpenFirstRunSetup,
 } from './main/runtime/first-run-setup-service';
 import { createYoutubeFlowRuntime } from './main/runtime/youtube-flow';
@@ -348,6 +349,7 @@ import {
  createYoutubePrimarySubtitleNotificationRuntime,
 } from './main/runtime/youtube-primary-subtitle-notification';
 import { createAutoplayReadyGate } from './main/runtime/autoplay-ready-gate';
+import { createManagedLocalSubtitleSelectionRuntime } from './main/runtime/local-subtitle-selection';
 import {
  buildFirstRunSetupHtml,
  createMaybeFocusExistingFirstRunSetupWindowHandler,
@@ -1000,6 +1002,17 @@ const autoplayReadyGate = createAutoplayReadyGate({
  schedule: (callback, delayMs) => setTimeout(callback, delayMs),
  logDebug: (message) => logger.debug(message),
 });
+const managedLocalSubtitleSelectionRuntime = createManagedLocalSubtitleSelectionRuntime({
+  getCurrentMediaPath: () => appState.currentMediaPath,
+  getMpvClient: () => appState.mpvClient,
+  getPrimarySubtitleLanguages: () => getResolvedConfig().youtube.primarySubLanguages,
+  getSecondarySubtitleLanguages: () => getResolvedConfig().secondarySub.secondarySubLanguages,
+  sendMpvCommand: (command) => {
+    sendMpvCommandRuntime(appState.mpvClient, command);
+  },
+  schedule: (callback, delayMs) => setTimeout(callback, delayMs),
+  clearScheduled: (timer) => clearTimeout(timer),
+});
 const youtubePlaybackRuntime = createYoutubePlaybackRuntime({
  platform: process.platform,
  directPlaybackFormat: YOUTUBE_DIRECT_PLAYBACK_FORMAT,
@@ -2238,18 +2251,15 @@ const openFirstRunSetupWindowHandler = createOpenFirstRunSetupWindowHandler({
      firstRunSetupMessage = snapshot.message;
      return;
    }
-    if (submission.action === 'skip-plugin') {
-      await firstRunSetupService.skipPluginInstall();
-      firstRunSetupMessage = 'mpv plugin installation skipped.';
-      return;
-    }

    const snapshot = await firstRunSetupService.markSetupCompleted();
    if (snapshot.state.status === 'completed') {
      firstRunSetupMessage = null;
      return { closeWindow: true };
    }
-    firstRunSetupMessage = 'Install at least one Yomitan dictionary before finishing setup.';
+    firstRunSetupMessage =
+      getFirstRunSetupCompletionMessage(snapshot) ??
+      'Finish setup requires the mpv plugin and Yomitan dictionaries.';
    return;
  },
  markSetupInProgress: async () => {
@@ -3328,6 +3338,7 @@ const {
    updateCurrentMediaPath: (path) => {
      autoplayReadyGate.invalidatePendingAutoplayReadyFallbacks();
      currentMediaTokenizationGate.updateCurrentMediaPath(path);
+      managedLocalSubtitleSelectionRuntime.handleMediaPathChange(path);
      startupOsdSequencer.reset();
      subtitlePrefetchRuntime.clearScheduledSubtitlePrefetchRefresh();
      subtitlePrefetchRuntime.cancelPendingInit();
@@ -3394,6 +3405,7 @@ const {
      youtubePrimarySubtitleNotificationRuntime.handleSubtitleTrackChange(sid);
    },
    onSubtitleTrackListChange: (trackList) => {
+      managedLocalSubtitleSelectionRuntime.handleSubtitleTrackListChange(trackList);
      scheduleSubtitlePrefetchRefresh();
      youtubePrimarySubtitleNotificationRuntime.handleSubtitleTrackListChange(trackList);
    },
@@ -4135,7 +4147,10 @@ const shiftSubtitleDelayToAdjacentCueHandler = createShiftSubtitleDelayToAdjacen
  showMpvOsd: (text) => showMpvOsd(text),
 });

-const { playlistBrowserMainDeps } = createPlaylistBrowserIpcRuntime(() => appState.mpvClient);
+const { playlistBrowserMainDeps } = createPlaylistBrowserIpcRuntime(() => appState.mpvClient, {
+  getPrimarySubtitleLanguages: () => getResolvedConfig().youtube.primarySubLanguages,
+  getSecondarySubtitleLanguages: () => getResolvedConfig().secondarySub.secondarySubLanguages,
+});

 const { registerIpcRuntimeHandlers } = composeIpcRuntimeHandlers({
  mpvCommandMainDeps: {
--- a/src/main/runtime/autoplay-ready-gate.test.ts
+++ b/src/main/runtime/autoplay-ready-gate.test.ts
@@ -2,7 +2,7 @@ import assert from 'node:assert/strict';
 import test from 'node:test';
 import { createAutoplayReadyGate } from './autoplay-ready-gate';

-test('autoplay ready gate suppresses duplicate media signals unless forced while paused', async () => {
+test('autoplay ready gate suppresses duplicate media signals for the same media', async () => {
  const commands: Array<Array<string | boolean>> = [];
  const scheduled: Array<() => void> = [];

@@ -31,7 +31,6 @@ test('autoplay ready gate suppresses duplicate media signals unless forced while

  gate.maybeSignalPluginAutoplayReady({ text: '字幕', tokens: null });
  gate.maybeSignalPluginAutoplayReady({ text: '字幕', tokens: null });
-  gate.maybeSignalPluginAutoplayReady({ text: '字幕', tokens: null }, { forceWhilePaused: true });

  await new Promise((resolve) => setTimeout(resolve, 0));
  const firstScheduled = scheduled.shift();
@@ -96,3 +95,49 @@ test('autoplay ready gate retry loop does not re-signal plugin readiness', async
    true,
  );
 });
+
+test('autoplay ready gate does not unpause again after a later manual pause on the same media', async () => {
+  const commands: Array<Array<string | boolean>> = [];
+  let playbackPaused = true;
+
+  const gate = createAutoplayReadyGate({
+    isAppOwnedFlowInFlight: () => false,
+    getCurrentMediaPath: () => '/media/video.mkv',
+    getCurrentVideoPath: () => null,
+    getPlaybackPaused: () => playbackPaused,
+    getMpvClient: () =>
+      ({
+        connected: true,
+        requestProperty: async () => playbackPaused,
+        send: ({ command }: { command: Array<string | boolean> }) => {
+          commands.push(command);
+          if (command[0] === 'set_property' && command[1] === 'pause' && command[2] === false) {
+            playbackPaused = false;
+          }
+        },
+      }) as never,
+    signalPluginAutoplayReady: () => {
+      commands.push(['script-message', 'subminer-autoplay-ready']);
+    },
+    schedule: (callback) => {
+      queueMicrotask(callback);
+      return 1 as never;
+    },
+    logDebug: () => {},
+  });
+
+  gate.maybeSignalPluginAutoplayReady({ text: '字幕', tokens: null }, { forceWhilePaused: true });
+  await new Promise((resolve) => setTimeout(resolve, 0));
+
+  playbackPaused = true;
+  gate.maybeSignalPluginAutoplayReady({ text: '字幕その2', tokens: null }, { forceWhilePaused: true });
+  await new Promise((resolve) => setTimeout(resolve, 0));
+
+  assert.equal(
+    commands.filter(
+      (command) =>
+        command[0] === 'set_property' && command[1] === 'pause' && command[2] === false,
+    ).length,
+    1,
+  );
+});
--- a/src/main/runtime/autoplay-ready-gate.ts
+++ b/src/main/runtime/autoplay-ready-gate.ts
@@ -44,8 +44,6 @@ export function createAutoplayReadyGate(deps: AutoplayReadyGateDeps) {
      deps.getCurrentVideoPath()?.trim() ||
      '__unknown__';
    const duplicateMediaSignal = autoPlayReadySignalMediaPath === mediaPath;
-    const allowDuplicateWhilePaused =
-      options?.forceWhilePaused === true && deps.getPlaybackPaused() !== false;
    const releaseRetryDelayMs = 200;
    const maxReleaseAttempts = resolveAutoplayReadyMaxReleaseAttempts({
      forceWhilePaused: options?.forceWhilePaused === true,
@@ -104,20 +102,14 @@ export function createAutoplayReadyGate(deps: AutoplayReadyGateDeps) {
      })();
    };

-    if (duplicateMediaSignal && !allowDuplicateWhilePaused) {
+    if (duplicateMediaSignal) {
      return;
    }

-    if (!duplicateMediaSignal) {
    autoPlayReadySignalMediaPath = mediaPath;
    const playbackGeneration = ++autoPlayReadySignalGeneration;
    deps.signalPluginAutoplayReady();
    attemptRelease(playbackGeneration, 0);
-      return;
-    }
-
-    const playbackGeneration = ++autoPlayReadySignalGeneration;
-    attemptRelease(playbackGeneration, 0);
  };

  return {
--- a/src/main/runtime/first-run-setup-service.test.ts
+++ b/src/main/runtime/first-run-setup-service.test.ts
@@ -88,7 +88,7 @@ test('setup service auto-completes legacy installs with config and dictionaries'
    const service = createFirstRunSetupService({
      configDir,
      getYomitanDictionaryCount: async () => 2,
-      detectPluginInstalled: () => false,
+      detectPluginInstalled: () => true,
      installPlugin: async () => ({
        ok: true,
        pluginInstallStatus: 'installed',
@@ -106,17 +106,18 @@ test('setup service auto-completes legacy installs with config and dictionaries'
  });
 });

-test('setup service requires explicit finish for incomplete installs and supports plugin skip/install', async () => {
+test('setup service requires mpv plugin install before finish', async () => {
  await withTempDir(async (root) => {
    const configDir = path.join(root, 'SubMiner');
    fs.mkdirSync(configDir, { recursive: true });
    fs.writeFileSync(path.join(configDir, 'config.jsonc'), '{}');
    let dictionaryCount = 0;
+    let pluginInstalled = false;

    const service = createFirstRunSetupService({
      configDir,
      getYomitanDictionaryCount: async () => dictionaryCount,
-      detectPluginInstalled: () => false,
+      detectPluginInstalled: () => pluginInstalled,
      installPlugin: async () => ({
        ok: true,
        pluginInstallStatus: 'installed',
@@ -130,13 +131,11 @@ test('setup service requires explicit finish for incomplete installs and support
    assert.equal(initial.state.status, 'incomplete');
    assert.equal(initial.canFinish, false);

-    const skipped = await service.skipPluginInstall();
-    assert.equal(skipped.state.pluginInstallStatus, 'skipped');
-
    const installed = await service.installMpvPlugin();
    assert.equal(installed.state.pluginInstallStatus, 'installed');
    assert.equal(installed.pluginInstallPathSummary, '/tmp/mpv');

+    pluginInstalled = true;
    dictionaryCount = 1;
    const refreshed = await service.refreshStatus();
    assert.equal(refreshed.canFinish, true);
@@ -158,7 +157,7 @@ test('setup service allows completion without internal dictionaries when externa
      configDir,
      getYomitanDictionaryCount: async () => 0,
      isExternalYomitanConfigured: () => true,
-      detectPluginInstalled: () => false,
+      detectPluginInstalled: () => true,
      installPlugin: async () => ({
        ok: true,
        pluginInstallStatus: 'installed',
@@ -190,7 +189,7 @@ test('setup service does not probe internal dictionaries when external yomitan i
        throw new Error('should not probe internal dictionaries in external mode');
      },
      isExternalYomitanConfigured: () => true,
-      detectPluginInstalled: () => false,
+      detectPluginInstalled: () => true,
      installPlugin: async () => ({
        ok: true,
        pluginInstallStatus: 'installed',
@@ -218,7 +217,7 @@ test('setup service reopens when external-yomitan completion later has no extern
      configDir,
      getYomitanDictionaryCount: async () => 0,
      isExternalYomitanConfigured: () => true,
-      detectPluginInstalled: () => false,
+      detectPluginInstalled: () => true,
      installPlugin: async () => ({
        ok: true,
        pluginInstallStatus: 'installed',
@@ -235,7 +234,7 @@ test('setup service reopens when external-yomitan completion later has no extern
      configDir,
      getYomitanDictionaryCount: async () => 0,
      isExternalYomitanConfigured: () => false,
-      detectPluginInstalled: () => false,
+      detectPluginInstalled: () => true,
      installPlugin: async () => ({
        ok: true,
        pluginInstallStatus: 'installed',
@@ -252,6 +251,48 @@ test('setup service reopens when external-yomitan completion later has no extern
  });
 });

+test('setup service reopens when a completed setup no longer has the mpv plugin installed', async () => {
+  await withTempDir(async (root) => {
+    const configDir = path.join(root, 'SubMiner');
+    fs.mkdirSync(configDir, { recursive: true });
+    fs.writeFileSync(path.join(configDir, 'config.jsonc'), '{}');
+
+    const completedService = createFirstRunSetupService({
+      configDir,
+      getYomitanDictionaryCount: async () => 2,
+      detectPluginInstalled: () => true,
+      installPlugin: async () => ({
+        ok: true,
+        pluginInstallStatus: 'installed',
+        pluginInstallPathSummary: '/tmp/mpv',
+        message: 'ok',
+      }),
+      onStateChanged: () => undefined,
+    });
+
+    await completedService.ensureSetupStateInitialized();
+    await completedService.markSetupCompleted();
+
+    const service = createFirstRunSetupService({
+      configDir,
+      getYomitanDictionaryCount: async () => 2,
+      detectPluginInstalled: () => false,
+      installPlugin: async () => ({
+        ok: true,
+        pluginInstallStatus: 'installed',
+        pluginInstallPathSummary: null,
+        message: 'ok',
+      }),
+      onStateChanged: () => undefined,
+    });
+
+    const snapshot = await service.ensureSetupStateInitialized();
+    assert.equal(snapshot.state.status, 'incomplete');
+    assert.equal(snapshot.canFinish, false);
+    assert.equal(snapshot.pluginStatus, 'required');
+  });
+});
+
 test('setup service keeps completed when external-yomitan completion later has internal dictionaries available', async () => {
  await withTempDir(async (root) => {
    const configDir = path.join(root, 'SubMiner');
@@ -262,7 +303,7 @@ test('setup service keeps completed when external-yomitan completion later has i
      configDir,
      getYomitanDictionaryCount: async () => 0,
      isExternalYomitanConfigured: () => true,
-      detectPluginInstalled: () => false,
+      detectPluginInstalled: () => true,
      installPlugin: async () => ({
        ok: true,
        pluginInstallStatus: 'installed',
@@ -279,7 +320,7 @@ test('setup service keeps completed when external-yomitan completion later has i
      configDir,
      getYomitanDictionaryCount: async () => 2,
      isExternalYomitanConfigured: () => false,
-      detectPluginInstalled: () => false,
+      detectPluginInstalled: () => true,
      installPlugin: async () => ({
        ok: true,
        pluginInstallStatus: 'installed',
@@ -304,7 +345,7 @@ test('setup service marks cancelled when popup closes before completion', async
    const service = createFirstRunSetupService({
      configDir,
      getYomitanDictionaryCount: async () => 0,
-      detectPluginInstalled: () => false,
+      detectPluginInstalled: () => true,
      installPlugin: async () => ({
        ok: true,
        pluginInstallStatus: 'installed',
@@ -331,7 +372,7 @@ test('setup service reflects detected Windows mpv shortcuts before preferences a
      platform: 'win32',
      configDir,
      getYomitanDictionaryCount: async () => 0,
-      detectPluginInstalled: () => false,
+      detectPluginInstalled: () => true,
      installPlugin: async () => ({
        ok: true,
        pluginInstallStatus: 'installed',
@@ -364,7 +405,7 @@ test('setup service persists Windows mpv shortcut preferences and status with on
      platform: 'win32',
      configDir,
      getYomitanDictionaryCount: async () => 0,
-      detectPluginInstalled: () => false,
+      detectPluginInstalled: () => true,
      installPlugin: async () => ({
        ok: true,
        pluginInstallStatus: 'installed',
--- a/src/main/runtime/first-run-setup-service.ts
+++ b/src/main/runtime/first-run-setup-service.ts
@@ -27,7 +27,7 @@ export interface SetupStatusSnapshot {
  dictionaryCount: number;
  canFinish: boolean;
  externalYomitanConfigured: boolean;
-  pluginStatus: 'installed' | 'optional' | 'skipped' | 'failed';
+  pluginStatus: 'installed' | 'required' | 'failed';
  pluginInstallPathSummary: string | null;
  windowsMpvShortcuts: SetupWindowsMpvShortcutSnapshot;
  message: string | null;
@@ -48,7 +48,6 @@ export interface FirstRunSetupService {
  markSetupInProgress: () => Promise<SetupStatusSnapshot>;
  markSetupCancelled: () => Promise<SetupStatusSnapshot>;
  markSetupCompleted: () => Promise<SetupStatusSnapshot>;
-  skipPluginInstall: () => Promise<SetupStatusSnapshot>;
  installMpvPlugin: () => Promise<SetupStatusSnapshot>;
  configureWindowsMpvShortcuts: (preferences: {
    startMenuEnabled: boolean;
@@ -108,9 +107,8 @@ function getPluginStatus(
  pluginInstalled: boolean,
 ): SetupStatusSnapshot['pluginStatus'] {
  if (pluginInstalled) return 'installed';
-  if (state.pluginInstallStatus === 'skipped') return 'skipped';
  if (state.pluginInstallStatus === 'failed') return 'failed';
-  return 'optional';
+  return 'required';
 }

 function getWindowsMpvShortcutStatus(
@@ -151,6 +149,24 @@ function isYomitanSetupSatisfied(options: {
  return options.externalYomitanConfigured || options.dictionaryCount >= 1;
 }

+export function getFirstRunSetupCompletionMessage(snapshot: {
+  configReady: boolean;
+  dictionaryCount: number;
+  externalYomitanConfigured: boolean;
+  pluginStatus: SetupStatusSnapshot['pluginStatus'];
+}): string | null {
+  if (!snapshot.configReady) {
+    return 'Create or provide the config file before finishing setup.';
+  }
+  if (snapshot.pluginStatus !== 'installed') {
+    return 'Install the mpv plugin before finishing setup.';
+  }
+  if (!snapshot.externalYomitanConfigured && snapshot.dictionaryCount < 1) {
+    return 'Install at least one Yomitan dictionary before finishing setup.';
+  }
+  return null;
+}
+
 async function resolveYomitanSetupStatus(deps: {
  configFilePaths: { jsoncPath: string; jsonPath: string };
  getYomitanDictionaryCount: () => Promise<number>;
@@ -230,7 +246,9 @@ export function createFirstRunSetupService(deps: {
    return {
      configReady,
      dictionaryCount,
-      canFinish: isYomitanSetupSatisfied({
+      canFinish:
+        pluginInstalled &&
+        isYomitanSetupSatisfied({
          configReady,
          dictionaryCount,
          externalYomitanConfigured,
@@ -272,24 +290,20 @@ export function createFirstRunSetupService(deps: {
          getYomitanDictionaryCount: deps.getYomitanDictionaryCount,
          isExternalYomitanConfigured: deps.isExternalYomitanConfigured,
        });
-      const yomitanSetupSatisfied = isYomitanSetupSatisfied({
+      const pluginInstalled = await deps.detectPluginInstalled();
+      const canFinish =
+        pluginInstalled &&
+        isYomitanSetupSatisfied({
          configReady,
          dictionaryCount,
          externalYomitanConfigured,
        });
-      if (
-        isSetupCompleted(state) &&
-        !(
-          state.yomitanSetupMode === 'external' &&
-          !externalYomitanConfigured &&
-          !yomitanSetupSatisfied
-        )
-      ) {
+      if (isSetupCompleted(state) && canFinish) {
        completed = true;
        return refreshWithState(state);
      }

-      if (yomitanSetupSatisfied) {
+      if (canFinish) {
        const completedState = writeState({
          ...state,
          status: 'completed',
@@ -347,8 +361,6 @@ export function createFirstRunSetupService(deps: {
        }),
      );
    },
-    skipPluginInstall: async () =>
-      refreshWithState(writeState({ ...readState(), pluginInstallStatus: 'skipped' })),
    installMpvPlugin: async () => {
      const result = await deps.installPlugin();
      return refreshWithState(
--- a/src/main/runtime/first-run-setup-window.test.ts
+++ b/src/main/runtime/first-run-setup-window.test.ts
@@ -14,7 +14,7 @@ test('buildFirstRunSetupHtml renders macchiato setup actions and disabled finish
    dictionaryCount: 0,
    canFinish: false,
    externalYomitanConfigured: false,
-    pluginStatus: 'optional',
+    pluginStatus: 'required',
    pluginInstallPathSummary: null,
    windowsMpvShortcuts: {
      supported: false,
@@ -29,6 +29,7 @@ test('buildFirstRunSetupHtml renders macchiato setup actions and disabled finish

  assert.match(html, /SubMiner setup/);
  assert.match(html, /Install mpv plugin/);
+  assert.match(html, /Required before SubMiner setup can finish/);
  assert.match(html, /Open Yomitan Settings/);
  assert.match(html, /Finish setup/);
  assert.match(html, /disabled/);
@@ -54,6 +55,32 @@ test('buildFirstRunSetupHtml switches plugin action to reinstall when already in
  });

  assert.match(html, /Reinstall mpv plugin/);
+  assert.match(
+    html,
+    /Finish stays unlocked once the mpv plugin is installed and Yomitan reports at least one installed dictionary\./,
+  );
+});
+
+test('buildFirstRunSetupHtml explains the config blocker when setup is missing config', () => {
+  const html = buildFirstRunSetupHtml({
+    configReady: false,
+    dictionaryCount: 0,
+    canFinish: false,
+    externalYomitanConfigured: false,
+    pluginStatus: 'required',
+    pluginInstallPathSummary: null,
+    windowsMpvShortcuts: {
+      supported: false,
+      startMenuEnabled: true,
+      desktopEnabled: true,
+      startMenuInstalled: false,
+      desktopInstalled: false,
+      status: 'optional',
+    },
+    message: null,
+  });
+
+  assert.match(html, /Create or provide the config file before finishing setup\./);
 });

 test('buildFirstRunSetupHtml explains external yomitan mode and keeps finish enabled', () => {
@@ -62,7 +89,7 @@ test('buildFirstRunSetupHtml explains external yomitan mode and keeps finish ena
    dictionaryCount: 0,
    canFinish: true,
    externalYomitanConfigured: true,
-    pluginStatus: 'optional',
+    pluginStatus: 'installed',
    pluginInstallPathSummary: null,
    windowsMpvShortcuts: {
      supported: false,
@@ -76,16 +103,14 @@ test('buildFirstRunSetupHtml explains external yomitan mode and keeps finish ena
  });

  assert.match(html, /External profile configured/);
-  assert.match(
-    html,
-    /Finish stays unlocked while SubMiner is reusing an external Yomitan profile\./,
-  );
+  assert.match(html, /Finish stays unlocked while SubMiner is reusing an external Yomitan profile\./);
 });

 test('parseFirstRunSetupSubmissionUrl parses supported custom actions', () => {
  assert.deepEqual(parseFirstRunSetupSubmissionUrl('subminer://first-run-setup?action=refresh'), {
    action: 'refresh',
  });
+  assert.equal(parseFirstRunSetupSubmissionUrl('subminer://first-run-setup?action=skip-plugin'), null);
  assert.equal(parseFirstRunSetupSubmissionUrl('https://example.com'), null);
 });

@@ -121,6 +146,25 @@ test('first-run setup navigation handler prevents default and dispatches action'
  assert.deepEqual(calls, ['preventDefault', 'install-plugin']);
 });

+test('first-run setup navigation handler swallows stale custom-scheme actions', () => {
+  const calls: string[] = [];
+  const handleNavigation = createHandleFirstRunSetupNavigationHandler({
+    parseSubmissionUrl: (url) => parseFirstRunSetupSubmissionUrl(url),
+    handleAction: async (submission) => {
+      calls.push(submission.action);
+    },
+    logError: (message) => calls.push(message),
+  });
+
+  const prevented = handleNavigation({
+    url: 'subminer://first-run-setup?action=skip-plugin',
+    preventDefault: () => calls.push('preventDefault'),
+  });
+
+  assert.equal(prevented, true);
+  assert.deepEqual(calls, ['preventDefault']);
+});
+
 test('closing incomplete first-run setup quits app outside background mode', async () => {
  const calls: string[] = [];
  let closedHandler: (() => void) | undefined;
@@ -146,7 +190,7 @@ test('closing incomplete first-run setup quits app outside background mode', asy
      dictionaryCount: 0,
      canFinish: false,
      externalYomitanConfigured: false,
-      pluginStatus: 'optional',
+      pluginStatus: 'required',
      pluginInstallPathSummary: null,
      windowsMpvShortcuts: {
        supported: false,
--- a/src/main/runtime/first-run-setup-window.ts
+++ b/src/main/runtime/first-run-setup-window.ts
@@ -1,3 +1,5 @@
+import { getFirstRunSetupCompletionMessage } from './first-run-setup-service';
+
 type FocusableWindowLike = {
  focus: () => void;
 };
@@ -19,7 +21,6 @@ export type FirstRunSetupAction =
  | 'configure-windows-mpv-shortcuts'
  | 'open-yomitan-settings'
  | 'refresh'
-  | 'skip-plugin'
  | 'finish';

 export interface FirstRunSetupSubmission {
@@ -33,7 +34,7 @@ export interface FirstRunSetupHtmlModel {
  dictionaryCount: number;
  canFinish: boolean;
  externalYomitanConfigured: boolean;
-  pluginStatus: 'installed' | 'optional' | 'skipped' | 'failed';
+  pluginStatus: 'installed' | 'required' | 'failed';
  pluginInstallPathSummary: string | null;
  windowsMpvShortcuts: {
    supported: boolean;
@@ -64,18 +65,14 @@ export function buildFirstRunSetupHtml(model: FirstRunSetupHtmlModel): string {
  const pluginLabel =
    model.pluginStatus === 'installed'
      ? 'Installed'
-      : model.pluginStatus === 'skipped'
-        ? 'Skipped'
      : model.pluginStatus === 'failed'
        ? 'Failed'
-          : 'Optional';
+        : 'Required';
  const pluginTone =
    model.pluginStatus === 'installed'
      ? 'ready'
      : model.pluginStatus === 'failed'
        ? 'danger'
-        : model.pluginStatus === 'skipped'
-          ? 'muted'
        : 'warn';
  const windowsShortcutLabel =
    model.windowsMpvShortcuts.status === 'installed'
@@ -128,9 +125,14 @@ export function buildFirstRunSetupHtml(model: FirstRunSetupHtmlModel): string {
    : model.dictionaryCount >= 1
      ? 'ready'
      : 'warn';
-  const footerMessage = model.externalYomitanConfigured
+  const blockerMessage = getFirstRunSetupCompletionMessage(model);
+  const footerMessage = blockerMessage
+    ? blockerMessage
+    : model.canFinish
+      ? model.externalYomitanConfigured
        ? 'Finish stays unlocked while SubMiner is reusing an external Yomitan profile. If you later launch without yomitan.externalProfilePath, setup will require at least one internal dictionary.'
-    : 'Finish stays locked until Yomitan reports at least one installed dictionary.';
+        : 'Finish stays unlocked once the mpv plugin is installed and Yomitan reports at least one installed dictionary.'
+      : 'Finish stays locked until the mpv plugin is installed and Yomitan reports at least one installed dictionary.';

  return `<!doctype html>
 <html>
@@ -269,6 +271,7 @@ export function buildFirstRunSetupHtml(model: FirstRunSetupHtmlModel): string {
      <div>
        <strong>mpv plugin</strong>
        <div class="meta">${escapeHtml(model.pluginInstallPathSummary ?? 'Default mpv scripts location')}</div>
+        <div class="meta">Required before SubMiner setup can finish.</div>
      </div>
      ${renderStatusBadge(pluginLabel, pluginTone)}
    </div>
@@ -284,7 +287,6 @@ export function buildFirstRunSetupHtml(model: FirstRunSetupHtmlModel): string {
      <button onclick="window.location.href='subminer://first-run-setup?action=install-plugin'">${pluginActionLabel}</button>
      <button onclick="window.location.href='subminer://first-run-setup?action=open-yomitan-settings'">Open Yomitan Settings</button>
      <button class="ghost" onclick="window.location.href='subminer://first-run-setup?action=refresh'">Refresh status</button>
-      <button class="ghost" onclick="window.location.href='subminer://first-run-setup?action=skip-plugin'">Skip plugin</button>
      <button class="primary" ${model.canFinish ? '' : 'disabled'} onclick="window.location.href='subminer://first-run-setup?action=finish'">Finish setup</button>
    </div>
    <div class="message">${model.message ? escapeHtml(model.message) : ''}</div>
@@ -305,7 +307,6 @@ export function parseFirstRunSetupSubmissionUrl(rawUrl: string): FirstRunSetupSu
    action !== 'configure-windows-mpv-shortcuts' &&
    action !== 'open-yomitan-settings' &&
    action !== 'refresh' &&
-    action !== 'skip-plugin' &&
    action !== 'finish'
  ) {
    return null;
@@ -337,9 +338,17 @@ export function createHandleFirstRunSetupNavigationHandler(deps: {
  logError: (message: string, error: unknown) => void;
 }) {
  return (params: { url: string; preventDefault: () => void }): boolean => {
-    const submission = deps.parseSubmissionUrl(params.url);
-    if (!submission) return false;
+    if (!params.url.startsWith('subminer://first-run-setup')) {
+      return false;
+    }
    params.preventDefault();
+    let submission: FirstRunSetupSubmission | null;
+    try {
+      submission = deps.parseSubmissionUrl(params.url);
+    } catch {
+      return true;
+    }
+    if (!submission) return true;
    void deps.handleAction(submission).catch((error) => {
      deps.logError('Failed handling first-run setup action', error);
    });
--- a/src/main/runtime/local-subtitle-selection.test.ts
+++ b/src/main/runtime/local-subtitle-selection.test.ts
@@ -0,0 +1,77 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  createManagedLocalSubtitleSelectionRuntime,
+  resolveManagedLocalSubtitleSelection,
+} from './local-subtitle-selection';
+
+const mixedLanguageTrackList = [
+  { type: 'sub', id: 1, lang: 'pt', title: '[Infinite]', external: false, selected: true },
+  { type: 'sub', id: 2, lang: 'pt', title: '[Moshi Moshi]', external: false },
+  { type: 'sub', id: 3, lang: 'en', title: '(Vivid)', external: false },
+  { type: 'sub', id: 9, lang: 'en', title: 'English(US)', external: false },
+  { type: 'sub', id: 11, lang: 'en', title: 'en.srt', external: true },
+  { type: 'sub', id: 12, lang: 'ja', title: 'ja.srt', external: true },
+];
+
+test('resolveManagedLocalSubtitleSelection prefers default Japanese primary and English secondary tracks', () => {
+  const result = resolveManagedLocalSubtitleSelection({
+    trackList: mixedLanguageTrackList,
+    primaryLanguages: [],
+    secondaryLanguages: [],
+  });
+
+  assert.equal(result.primaryTrackId, 12);
+  assert.equal(result.secondaryTrackId, 11);
+});
+
+test('resolveManagedLocalSubtitleSelection respects configured language overrides', () => {
+  const result = resolveManagedLocalSubtitleSelection({
+    trackList: mixedLanguageTrackList,
+    primaryLanguages: ['pt'],
+    secondaryLanguages: ['ja'],
+  });
+
+  assert.equal(result.primaryTrackId, 1);
+  assert.equal(result.secondaryTrackId, 12);
+});
+
+test('managed local subtitle selection runtime applies preferred tracks once for a local media path', async () => {
+  const commands: Array<Array<string | number>> = [];
+  const scheduled: Array<() => void> = [];
+
+  const runtime = createManagedLocalSubtitleSelectionRuntime({
+    getCurrentMediaPath: () => '/videos/example.mkv',
+    getMpvClient: () =>
+      ({
+        connected: true,
+        requestProperty: async (name: string) => {
+          if (name === 'track-list') {
+            return mixedLanguageTrackList;
+          }
+          throw new Error(`Unexpected property: ${name}`);
+        },
+      }) as never,
+    getPrimarySubtitleLanguages: () => [],
+    getSecondarySubtitleLanguages: () => [],
+    sendMpvCommand: (command) => {
+      commands.push(command);
+    },
+    schedule: (callback) => {
+      scheduled.push(callback);
+      return 1 as never;
+    },
+    clearScheduled: () => {},
+  });
+
+  runtime.handleMediaPathChange('/videos/example.mkv');
+  scheduled.shift()?.();
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  runtime.handleSubtitleTrackListChange(mixedLanguageTrackList);
+
+  assert.deepEqual(commands, [
+    ['set_property', 'sid', 12],
+    ['set_property', 'secondary-sid', 11],
+  ]);
+});
--- a/src/main/runtime/local-subtitle-selection.ts
+++ b/src/main/runtime/local-subtitle-selection.ts
@@ -0,0 +1,261 @@
+import path from 'node:path';
+
+import { isRemoteMediaPath } from '../../jimaku/utils';
+import { normalizeYoutubeLangCode } from '../../core/services/youtube/labels';
+
+const DEFAULT_PRIMARY_SUBTITLE_LANGUAGES = ['ja', 'jpn'];
+const DEFAULT_SECONDARY_SUBTITLE_LANGUAGES = ['en', 'eng', 'english', 'enus', 'en-us'];
+const HEARING_IMPAIRED_PATTERN = /\b(hearing impaired|sdh|closed captions?|cc)\b/i;
+
+type SubtitleTrackLike = {
+  type?: unknown;
+  id?: unknown;
+  lang?: unknown;
+  title?: unknown;
+  external?: unknown;
+  selected?: unknown;
+};
+
+type NormalizedSubtitleTrack = {
+  id: number;
+  lang: string;
+  title: string;
+  external: boolean;
+  selected: boolean;
+};
+
+export type ManagedLocalSubtitleSelection = {
+  primaryTrackId: number | null;
+  secondaryTrackId: number | null;
+  hasPrimaryMatch: boolean;
+  hasSecondaryMatch: boolean;
+};
+
+function parseTrackId(value: unknown): number | null {
+  if (typeof value === 'number' && Number.isInteger(value)) {
+    return value;
+  }
+  if (typeof value === 'string') {
+    const parsed = Number(value.trim());
+    return Number.isInteger(parsed) ? parsed : null;
+  }
+  return null;
+}
+
+function normalizeTrack(entry: unknown): NormalizedSubtitleTrack | null {
+  if (!entry || typeof entry !== 'object') {
+    return null;
+  }
+  const track = entry as SubtitleTrackLike;
+  const id = parseTrackId(track.id);
+  if (id === null || (track.type !== undefined && track.type !== 'sub')) {
+    return null;
+  }
+  return {
+    id,
+    lang: String(track.lang || '').trim(),
+    title: String(track.title || '').trim(),
+    external: track.external === true,
+    selected: track.selected === true,
+  };
+}
+
+function normalizeLanguageList(values: string[], fallback: string[]): string[] {
+  const normalized = values
+    .map((value) => normalizeYoutubeLangCode(value))
+    .filter((value, index, items) => value.length > 0 && items.indexOf(value) === index);
+  if (normalized.length > 0) {
+    return normalized;
+  }
+  return fallback
+    .map((value) => normalizeYoutubeLangCode(value))
+    .filter((value, index, items) => value.length > 0 && items.indexOf(value) === index);
+}
+
+function resolveLanguageRank(language: string, preferredLanguages: string[]): number {
+  const normalized = normalizeYoutubeLangCode(language);
+  if (!normalized) {
+    return Number.POSITIVE_INFINITY;
+  }
+  const directIndex = preferredLanguages.indexOf(normalized);
+  if (directIndex >= 0) {
+    return directIndex;
+  }
+  const base = normalized.split('-')[0] || normalized;
+  const baseIndex = preferredLanguages.indexOf(base);
+  return baseIndex >= 0 ? baseIndex : Number.POSITIVE_INFINITY;
+}
+
+function isLikelyHearingImpaired(title: string): boolean {
+  return HEARING_IMPAIRED_PATTERN.test(title);
+}
+
+function pickBestTrackId(
+  tracks: NormalizedSubtitleTrack[],
+  preferredLanguages: string[],
+  excludeId: number | null = null,
+): { trackId: number | null; hasMatch: boolean } {
+  const ranked = tracks
+    .filter((track) => track.id !== excludeId)
+    .map((track) => ({
+      track,
+      languageRank: resolveLanguageRank(track.lang, preferredLanguages),
+    }))
+    .filter(({ languageRank }) => Number.isFinite(languageRank))
+    .sort((left, right) => {
+      if (left.languageRank !== right.languageRank) {
+        return left.languageRank - right.languageRank;
+      }
+      if (left.track.external !== right.track.external) {
+        return left.track.external ? -1 : 1;
+      }
+      if (isLikelyHearingImpaired(left.track.title) !== isLikelyHearingImpaired(right.track.title)) {
+        return isLikelyHearingImpaired(left.track.title) ? 1 : -1;
+      }
+      if (/\bdefault\b/i.test(left.track.title) !== /\bdefault\b/i.test(right.track.title)) {
+        return /\bdefault\b/i.test(left.track.title) ? -1 : 1;
+      }
+      return left.track.id - right.track.id;
+    });
+
+  return {
+    trackId: ranked[0]?.track.id ?? null,
+    hasMatch: ranked.length > 0,
+  };
+}
+
+export function resolveManagedLocalSubtitleSelection(input: {
+  trackList: unknown[] | null;
+  primaryLanguages: string[];
+  secondaryLanguages: string[];
+}): ManagedLocalSubtitleSelection {
+  const tracks = Array.isArray(input.trackList)
+    ? input.trackList.map(normalizeTrack).filter((track): track is NormalizedSubtitleTrack => track !== null)
+    : [];
+  const preferredPrimaryLanguages = normalizeLanguageList(
+    input.primaryLanguages,
+    DEFAULT_PRIMARY_SUBTITLE_LANGUAGES,
+  );
+  const preferredSecondaryLanguages = normalizeLanguageList(
+    input.secondaryLanguages,
+    DEFAULT_SECONDARY_SUBTITLE_LANGUAGES,
+  );
+
+  const primary = pickBestTrackId(tracks, preferredPrimaryLanguages);
+  const secondary = pickBestTrackId(tracks, preferredSecondaryLanguages, primary.trackId);
+
+  return {
+    primaryTrackId: primary.trackId,
+    secondaryTrackId: secondary.trackId,
+    hasPrimaryMatch: primary.hasMatch,
+    hasSecondaryMatch: secondary.hasMatch,
+  };
+}
+
+function normalizeLocalMediaPath(mediaPath: string | null | undefined): string | null {
+  if (typeof mediaPath !== 'string') {
+    return null;
+  }
+  const trimmed = mediaPath.trim();
+  if (!trimmed || isRemoteMediaPath(trimmed)) {
+    return null;
+  }
+  return path.resolve(trimmed);
+}
+
+export function createManagedLocalSubtitleSelectionRuntime(deps: {
+  getCurrentMediaPath: () => string | null;
+  getMpvClient: () =>
+    | {
+        connected?: boolean;
+        requestProperty?: (name: string) => Promise<unknown>;
+      }
+    | null;
+  getPrimarySubtitleLanguages: () => string[];
+  getSecondarySubtitleLanguages: () => string[];
+  sendMpvCommand: (command: ['set_property', 'sid' | 'secondary-sid', number]) => void;
+  schedule: (callback: () => void, delayMs: number) => ReturnType<typeof setTimeout>;
+  clearScheduled: (timer: ReturnType<typeof setTimeout>) => void;
+  delayMs?: number;
+}) {
+  const delayMs = deps.delayMs ?? 400;
+  let currentMediaPath: string | null = null;
+  let appliedMediaPath: string | null = null;
+  let pendingTimer: ReturnType<typeof setTimeout> | null = null;
+
+  const clearPendingTimer = (): void => {
+    if (!pendingTimer) {
+      return;
+    }
+    deps.clearScheduled(pendingTimer);
+    pendingTimer = null;
+  };
+
+  const maybeApplySelection = (trackList: unknown[] | null): void => {
+    if (!currentMediaPath || appliedMediaPath === currentMediaPath) {
+      return;
+    }
+    const selection = resolveManagedLocalSubtitleSelection({
+      trackList,
+      primaryLanguages: deps.getPrimarySubtitleLanguages(),
+      secondaryLanguages: deps.getSecondarySubtitleLanguages(),
+    });
+    if (!selection.hasPrimaryMatch && !selection.hasSecondaryMatch) {
+      return;
+    }
+    if (selection.primaryTrackId !== null) {
+      deps.sendMpvCommand(['set_property', 'sid', selection.primaryTrackId]);
+    }
+    if (selection.secondaryTrackId !== null) {
+      deps.sendMpvCommand(['set_property', 'secondary-sid', selection.secondaryTrackId]);
+    }
+    appliedMediaPath = currentMediaPath;
+    clearPendingTimer();
+  };
+
+  const refreshFromMpv = async (): Promise<void> => {
+    const client = deps.getMpvClient();
+    if (!client?.connected || !client.requestProperty) {
+      return;
+    }
+    const mediaPath = normalizeLocalMediaPath(deps.getCurrentMediaPath());
+    if (!mediaPath || mediaPath !== currentMediaPath) {
+      return;
+    }
+    try {
+      const trackList = await client.requestProperty('track-list');
+      maybeApplySelection(Array.isArray(trackList) ? trackList : null);
+    } catch {
+      // Skip selection when mpv track inspection fails.
+    }
+  };
+
+  const scheduleRefresh = (): void => {
+    clearPendingTimer();
+    if (!currentMediaPath || appliedMediaPath === currentMediaPath) {
+      return;
+    }
+    pendingTimer = deps.schedule(() => {
+      pendingTimer = null;
+      void refreshFromMpv();
+    }, delayMs);
+  };
+
+  return {
+    handleMediaPathChange: (mediaPath: string | null | undefined): void => {
+      const normalizedPath = normalizeLocalMediaPath(mediaPath);
+      if (normalizedPath !== currentMediaPath) {
+        appliedMediaPath = null;
+      }
+      currentMediaPath = normalizedPath;
+      if (!currentMediaPath) {
+        clearPendingTimer();
+        return;
+      }
+      scheduleRefresh();
+    },
+    handleSubtitleTrackListChange: (trackList: unknown[] | null): void => {
+      maybeApplySelection(trackList);
+    },
+  };
+}
--- a/src/main/runtime/playlist-browser-ipc.ts
+++ b/src/main/runtime/playlist-browser-ipc.ts
@@ -24,9 +24,15 @@ export type PlaylistBrowserIpcRuntime = {

 export function createPlaylistBrowserIpcRuntime(
  getMpvClient: PlaylistBrowserRuntimeDeps['getMpvClient'],
+  options?: Pick<
+    PlaylistBrowserRuntimeDeps,
+    'getPrimarySubtitleLanguages' | 'getSecondarySubtitleLanguages'
+  >,
 ): PlaylistBrowserIpcRuntime {
  const playlistBrowserRuntimeDeps: PlaylistBrowserRuntimeDeps = {
    getMpvClient,
+    getPrimarySubtitleLanguages: options?.getPrimarySubtitleLanguages,
+    getSecondarySubtitleLanguages: options?.getSecondarySubtitleLanguages,
  };

  return {
--- a/src/main/runtime/playlist-browser-runtime.test.ts
+++ b/src/main/runtime/playlist-browser-runtime.test.ts
@@ -267,6 +267,7 @@ test('playlist-browser mutation runtimes mutate queue and return refreshed snaps
  ]);
  assert.deepEqual(scheduled.map((entry) => entry.delayMs), [400]);
  scheduled[0]?.callback();
+  await new Promise((resolve) => setTimeout(resolve, 0));
  assert.deepEqual(mpvClient.getCommands().slice(-2), [
    ['set_property', 'sid', 'auto'],
    ['set_property', 'secondary-sid', 'auto'],
@@ -472,6 +473,7 @@ test('playPlaylistBrowserIndexRuntime ignores superseded local subtitle rearm ca

  scheduled[0]?.();
  scheduled[1]?.();
+  await new Promise((resolve) => setTimeout(resolve, 0));

  assert.deepEqual(
    mpvClient.getCommands().slice(-6),
@@ -485,3 +487,52 @@ test('playPlaylistBrowserIndexRuntime ignores superseded local subtitle rearm ca
    ],
  );
 });
+
+test('playlist-browser playback reapplies configured preferred subtitle tracks when track metadata is available', async (t) => {
+  const dir = createTempVideoDir(t);
+  const episode1 = path.join(dir, 'Show - S01E01.mkv');
+  const episode2 = path.join(dir, 'Show - S01E02.mkv');
+  fs.writeFileSync(episode1, '');
+  fs.writeFileSync(episode2, '');
+
+  const mpvClient = createFakeMpvClient({
+    currentVideoPath: episode1,
+    playlist: [
+      { filename: episode1, current: true, title: 'Episode 1' },
+      { filename: episode2, title: 'Episode 2' },
+    ],
+  });
+  const requestProperty = mpvClient.requestProperty.bind(mpvClient);
+  mpvClient.requestProperty = async (name: string): Promise<unknown> => {
+    if (name === 'track-list') {
+      return [
+        { type: 'sub', id: 1, lang: 'pt', title: '[Infinite]', external: false, selected: true },
+        { type: 'sub', id: 3, lang: 'en', title: 'English', external: false },
+        { type: 'sub', id: 11, lang: 'en', title: 'en.srt', external: true },
+        { type: 'sub', id: 12, lang: 'ja', title: 'ja.srt', external: true },
+      ];
+    }
+    return requestProperty(name);
+  };
+
+  const scheduled: Array<() => void> = [];
+  const deps = {
+    getMpvClient: () => mpvClient,
+    getPrimarySubtitleLanguages: () => [],
+    getSecondarySubtitleLanguages: () => [],
+    schedule: (callback: () => void) => {
+      scheduled.push(callback);
+    },
+  };
+
+  const result = await playPlaylistBrowserIndexRuntime(deps, 1);
+  assert.equal(result.ok, true);
+
+  scheduled[0]?.();
+  await new Promise((resolve) => setTimeout(resolve, 0));
+
+  assert.deepEqual(mpvClient.getCommands().slice(-2), [
+    ['set_property', 'sid', 12],
+    ['set_property', 'secondary-sid', 11],
+  ]);
+});
--- a/src/main/runtime/playlist-browser-runtime.ts
+++ b/src/main/runtime/playlist-browser-runtime.ts
@@ -8,6 +8,7 @@ import type {
 } from '../../types';
 import { isRemoteMediaPath } from '../../jimaku/utils';
 import { hasVideoExtension } from '../../shared/video-extensions';
+import { resolveManagedLocalSubtitleSelection } from './local-subtitle-selection';
 import { sortPlaylistBrowserDirectoryItems } from './playlist-browser-sort';

 type PlaylistLike = {
@@ -28,6 +29,8 @@ type MpvPlaylistBrowserClientLike = {
 export type PlaylistBrowserRuntimeDeps = {
  getMpvClient: () => MpvPlaylistBrowserClientLike | null;
  schedule?: (callback: () => void, delayMs: number) => void;
+  getPrimarySubtitleLanguages?: () => string[];
+  getSecondarySubtitleLanguages?: () => string[];
 };

 const pendingLocalSubtitleSelectionRearms = new WeakMap<MpvPlaylistBrowserClientLike, number>();
@@ -229,9 +232,20 @@ async function buildMutationResult(
  };
 }

-function rearmLocalSubtitleSelection(client: MpvPlaylistBrowserClientLike): void {
-  client.send({ command: ['set_property', 'sid', 'auto'] });
-  client.send({ command: ['set_property', 'secondary-sid', 'auto'] });
+async function rearmLocalSubtitleSelection(
+  client: MpvPlaylistBrowserClientLike,
+  deps: PlaylistBrowserRuntimeDeps,
+): Promise<void> {
+  const trackList = await readProperty(client, 'track-list');
+  const selection = resolveManagedLocalSubtitleSelection({
+    trackList: Array.isArray(trackList) ? trackList : null,
+    primaryLanguages: deps.getPrimarySubtitleLanguages?.() ?? [],
+    secondaryLanguages: deps.getSecondarySubtitleLanguages?.() ?? [],
+  });
+  client.send({ command: ['set_property', 'sid', selection.primaryTrackId ?? 'auto'] });
+  client.send({
+    command: ['set_property', 'secondary-sid', selection.secondaryTrackId ?? 'auto'],
+  });
 }

 function prepareLocalSubtitleAutoload(client: MpvPlaylistBrowserClientLike): void {
@@ -258,7 +272,7 @@ function scheduleLocalSubtitleSelectionRearm(
    if (currentPath && path.resolve(currentPath) !== expectedPath) {
      return;
    }
-    rearmLocalSubtitleSelection(client);
+    void rearmLocalSubtitleSelection(client, deps);
  }, 400);
 }

--- a/src/main/runtime/windows-mpv-launch.test.ts
+++ b/src/main/runtime/windows-mpv-launch.test.ts
@@ -40,13 +40,85 @@ test('resolveWindowsMpvPath falls back to where.exe output', () => {
  assert.equal(resolved, 'C:\\tools\\mpv.exe');
 });

-test('buildWindowsMpvLaunchArgs keeps pseudo-gui profile and targets', () => {
-  assert.deepEqual(buildWindowsMpvLaunchArgs(['C:\\a.mkv', 'C:\\b.mkv']), [
+test('buildWindowsMpvLaunchArgs uses explicit SubMiner defaults and targets', () => {
+  assert.deepEqual(
+    buildWindowsMpvLaunchArgs(
+      ['C:\\a.mkv', 'C:\\b.mkv'],
+      [],
+      'C:\\SubMiner\\SubMiner.exe',
+      'C:\\Program Files\\SubMiner\\resources\\plugin\\subminer\\main.lua',
+    ),
+    [
      '--player-operation-mode=pseudo-gui',
-    '--profile=subminer',
+      '--force-window=immediate',
+      '--script=C:\\Program Files\\SubMiner\\resources\\plugin\\subminer\\main.lua',
+      '--input-ipc-server=\\\\.\\pipe\\subminer-socket',
+      '--alang=ja,jp,jpn,japanese,en,eng,english,enus,en-us',
+      '--slang=ja,jp,jpn,japanese,en,eng,english,enus,en-us',
+      '--sub-auto=fuzzy',
+      '--sub-file-paths=subs;subtitles',
+      '--sid=auto',
+      '--secondary-sid=auto',
+      '--secondary-sub-visibility=no',
+      '--script-opts=subminer-binary_path=C:\\SubMiner\\SubMiner.exe,subminer-socket_path=\\\\.\\pipe\\subminer-socket',
      'C:\\a.mkv',
      'C:\\b.mkv',
-  ]);
+    ],
+  );
+});
+
+test('buildWindowsMpvLaunchArgs keeps shortcut-only launches in idle mode', () => {
+  assert.deepEqual(
+    buildWindowsMpvLaunchArgs(
+      [],
+      [],
+      'C:\\SubMiner\\SubMiner.exe',
+      'C:\\Program Files\\SubMiner\\resources\\plugin\\subminer\\main.lua',
+    ),
+    [
+      '--player-operation-mode=pseudo-gui',
+      '--force-window=immediate',
+      '--idle=yes',
+      '--script=C:\\Program Files\\SubMiner\\resources\\plugin\\subminer\\main.lua',
+      '--input-ipc-server=\\\\.\\pipe\\subminer-socket',
+      '--alang=ja,jp,jpn,japanese,en,eng,english,enus,en-us',
+      '--slang=ja,jp,jpn,japanese,en,eng,english,enus,en-us',
+      '--sub-auto=fuzzy',
+      '--sub-file-paths=subs;subtitles',
+      '--sid=auto',
+      '--secondary-sid=auto',
+      '--secondary-sub-visibility=no',
+      '--script-opts=subminer-binary_path=C:\\SubMiner\\SubMiner.exe,subminer-socket_path=\\\\.\\pipe\\subminer-socket',
+    ],
+  );
+});
+
+test('buildWindowsMpvLaunchArgs mirrors a custom input-ipc-server into script opts', () => {
+  assert.deepEqual(
+    buildWindowsMpvLaunchArgs(
+      ['C:\\video.mkv'],
+      ['--input-ipc-server', '\\\\.\\pipe\\custom-subminer-socket'],
+      'C:\\SubMiner\\SubMiner.exe',
+      'C:\\Program Files\\SubMiner\\resources\\plugin\\subminer\\main.lua',
+    ),
+    [
+      '--player-operation-mode=pseudo-gui',
+      '--force-window=immediate',
+      '--script=C:\\Program Files\\SubMiner\\resources\\plugin\\subminer\\main.lua',
+      '--input-ipc-server=\\\\.\\pipe\\custom-subminer-socket',
+      '--alang=ja,jp,jpn,japanese,en,eng,english,enus,en-us',
+      '--slang=ja,jp,jpn,japanese,en,eng,english,enus,en-us',
+      '--sub-auto=fuzzy',
+      '--sub-file-paths=subs;subtitles',
+      '--sid=auto',
+      '--secondary-sid=auto',
+      '--secondary-sub-visibility=no',
+      '--script-opts=subminer-binary_path=C:\\SubMiner\\SubMiner.exe,subminer-socket_path=\\\\.\\pipe\\custom-subminer-socket',
+      '--input-ipc-server',
+      '\\\\.\\pipe\\custom-subminer-socket',
+      'C:\\video.mkv',
+    ],
+  );
 });

 test('launchWindowsMpv reports missing mpv path', () => {
@@ -75,13 +147,16 @@ test('launchWindowsMpv spawns detached mpv with targets', () => {
        calls.push(args.join('|'));
      },
    }),
+    [],
+    'C:\\SubMiner\\SubMiner.exe',
+    'C:\\Program Files\\SubMiner\\resources\\plugin\\subminer\\main.lua',
  );

  assert.equal(result.ok, true);
  assert.equal(result.mpvPath, 'C:\\mpv\\mpv.exe');
  assert.deepEqual(calls, [
    'C:\\mpv\\mpv.exe',
-    '--player-operation-mode=pseudo-gui|--profile=subminer|C:\\video.mkv',
+    '--player-operation-mode=pseudo-gui|--force-window=immediate|--script=C:\\Program Files\\SubMiner\\resources\\plugin\\subminer\\main.lua|--input-ipc-server=\\\\.\\pipe\\subminer-socket|--alang=ja,jp,jpn,japanese,en,eng,english,enus,en-us|--slang=ja,jp,jpn,japanese,en,eng,english,enus,en-us|--sub-auto=fuzzy|--sub-file-paths=subs;subtitles|--sid=auto|--secondary-sid=auto|--secondary-sub-visibility=no|--script-opts=subminer-binary_path=C:\\SubMiner\\SubMiner.exe,subminer-socket_path=\\\\.\\pipe\\subminer-socket|C:\\video.mkv',
  ]);
 });

--- a/src/main/runtime/windows-mpv-launch.ts
+++ b/src/main/runtime/windows-mpv-launch.ts
@@ -33,14 +33,70 @@ export function resolveWindowsMpvPath(deps: WindowsMpvLaunchDeps): string {
  return '';
 }

-export function buildWindowsMpvLaunchArgs(targets: string[], extraArgs: string[] = []): string[] {
-  return ['--player-operation-mode=pseudo-gui', '--profile=subminer', ...extraArgs, ...targets];
+const DEFAULT_WINDOWS_MPV_SOCKET = '\\\\.\\pipe\\subminer-socket';
+
+function readExtraArgValue(extraArgs: string[], flag: string): string | undefined {
+  let value: string | undefined;
+  for (let i = 0; i < extraArgs.length; i += 1) {
+    const arg = extraArgs[i];
+    if (arg === flag) {
+      const next = extraArgs[i + 1];
+      if (next && !next.startsWith('-')) {
+        value = next;
+        i += 1;
+      }
+      continue;
+    }
+    if (arg?.startsWith(`${flag}=`)) {
+      value = arg.slice(flag.length + 1);
+    }
+  }
+  return value;
+}
+
+export function buildWindowsMpvLaunchArgs(
+  targets: string[],
+  extraArgs: string[] = [],
+  binaryPath?: string,
+  pluginEntrypointPath?: string,
+): string[] {
+  const launchIdle = targets.length === 0;
+  const inputIpcServer =
+    readExtraArgValue(extraArgs, '--input-ipc-server') ?? DEFAULT_WINDOWS_MPV_SOCKET;
+  const scriptOpts =
+    typeof binaryPath === 'string' && binaryPath.trim().length > 0
+      ? `--script-opts=subminer-binary_path=${binaryPath.trim().replace(/,/g, '\\,')},subminer-socket_path=${inputIpcServer.replace(/,/g, '\\,')}`
+      : null;
+  const scriptEntrypoint =
+    typeof pluginEntrypointPath === 'string' && pluginEntrypointPath.trim().length > 0
+      ? `--script=${pluginEntrypointPath.trim()}`
+      : null;
+
+  return [
+    '--player-operation-mode=pseudo-gui',
+    '--force-window=immediate',
+    ...(launchIdle ? ['--idle=yes'] : []),
+    ...(scriptEntrypoint ? [scriptEntrypoint] : []),
+    `--input-ipc-server=${inputIpcServer}`,
+    '--alang=ja,jp,jpn,japanese,en,eng,english,enus,en-us',
+    '--slang=ja,jp,jpn,japanese,en,eng,english,enus,en-us',
+    '--sub-auto=fuzzy',
+    '--sub-file-paths=subs;subtitles',
+    '--sid=auto',
+    '--secondary-sid=auto',
+    '--secondary-sub-visibility=no',
+    ...(scriptOpts ? [scriptOpts] : []),
+    ...extraArgs,
+    ...targets,
+  ];
 }

 export function launchWindowsMpv(
  targets: string[],
  deps: WindowsMpvLaunchDeps,
  extraArgs: string[] = [],
+  binaryPath?: string,
+  pluginEntrypointPath?: string,
 ): { ok: boolean; mpvPath: string } {
  const mpvPath = resolveWindowsMpvPath(deps);
  if (!mpvPath) {
@@ -52,7 +108,10 @@ export function launchWindowsMpv(
  }

  try {
-    deps.spawnDetached(mpvPath, buildWindowsMpvLaunchArgs(targets, extraArgs));
+    deps.spawnDetached(
+      mpvPath,
+      buildWindowsMpvLaunchArgs(targets, extraArgs, binaryPath, pluginEntrypointPath),
+    );
    return { ok: true, mpvPath };
  } catch (error) {
    const message = error instanceof Error ? error.message : String(error);
--- a/src/main/runtime/windows-mpv-shortcuts.test.ts
+++ b/src/main/runtime/windows-mpv-shortcuts.test.ts
@@ -33,7 +33,7 @@ test('buildWindowsMpvShortcutDetails targets SubMiner.exe with --launch-mpv', ()
    target: 'C:\\Apps\\SubMiner\\SubMiner.exe',
    args: '--launch-mpv',
    cwd: 'C:\\Apps\\SubMiner',
-    description: 'Launch mpv with the SubMiner profile',
+    description: 'Launch mpv with SubMiner defaults',
    icon: 'C:\\Apps\\SubMiner\\SubMiner.exe',
    iconIndex: 0,
  });
--- a/src/main/runtime/windows-mpv-shortcuts.ts
+++ b/src/main/runtime/windows-mpv-shortcuts.ts
@@ -55,7 +55,7 @@ export function buildWindowsMpvShortcutDetails(exePath: string): WindowsShortcut
    target: exePath,
    args: '--launch-mpv',
    cwd: path.win32.dirname(exePath),
-    description: 'Launch mpv with the SubMiner profile',
+    description: 'Launch mpv with SubMiner defaults',
    icon: exePath,
    iconIndex: 0,
  };
Author	SHA1	Message	Date
sudacode	aa0385904e	update backlog	2026-04-03 01:15:22 -07:00
sudacode	bf06463bb3	fix: address CodeRabbit follow-ups for PR #40	2026-04-03 01:14:57 -07:00
sudacode	61ab1b76fc	fix: stabilize local subtitle startup and pause release	2026-04-03 01:12:31 -07:00
Kyle	8a5805550f	Require mpv plugin in first-run setup	2026-04-03 00:07:57 -07:00
Kyle	78d0da03dd	Fix launcher binary discovery and defaults	2026-04-03 00:04:04 -07:00
Kyle	8b9ac99f3d	Require mpv plugin in first-run setup	2026-04-02 23:49:57 -07:00
Kyle	85e3aa4c6b	Fix Windows mpv shortcut launch and subtitle dedupe	2026-04-02 23:28:43 -07:00
sudacode	640c8acd7c	fix: make Windows mpv shortcut self-contained	2026-04-02 00:25:47 -07:00