Add "keep only German audio" post-extract step for .DL. files

- New video-processor.ts: ffmpeg/ffprobe remux that keeps only the German
  audio track (by language tag, with safe fallbacks) and strips the ".DL."
  marker from the filename
- Runs after extraction in both the deferred and hybrid post-process paths,
  inside the per-package file-op chain; abortable, disk-space checked,
  mtime-preserving, atomic temp->replace so the original is never lost
- System ffmpeg via PATH / RD_FFMPEG_BIN; toggle + track-mode select in settings

src/main/constants.ts

@@ -72,6 +72,8 @@ export function defaultSettings(): AppSettings {
     packageName: "",
     autoExtract: true,
     autoRename4sf4sj: false,
+    keepGermanAudioOnly: false,
+    germanAudioMode: "tag",
     extractDir: path.join(baseDir, "_entpackt"),
     collectMkvToLibrary: false,
     mkvLibraryDir: path.join(baseDir, "_mkv"),

src/main/download-manager.ts

@@ -54,6 +54,7 @@ import { AllDebridWebUnrestrictor, BestDebridWebUnrestrictor, DebridService, Meg
 import { cleanupArchives, clearExtractResumeState, collectArchiveCleanupTargets, detectArchiveSignature, extractPackageArchives, findArchiveCandidates, hasAnyFilesRecursive, removeEmptyDirectoryTree, resetExtractorCachesForPasswordChange, type ExtractArchiveFailureInfo } from "./extractor";
 import { validateFileAgainstManifest } from "./integrity";
 import { classifyDiskError } from "./fs-error";
+import { processVideoFile, stripDualLangMarker, hasDualLangMarker, isRemuxableVideoFile, type GermanAudioMode, type VideoProcessResult } from "./video-processor";
 import { logger } from "./logger";
 import { getRecentRotationEvents, runWithRotationItemSink, setRotationEventListener } from "./account-rotation-log";
 import type { RotationEvent } from "../shared/types";
@@ -2040,7 +2041,7 @@ export class DownloadManager extends EventEmitter {
   private logRenameProcess(
     pkg: PackageEntry,
     level: "INFO" | "WARN" | "ERROR",
-    stage: "auto-rename" | "mkv-move",
+    stage: "auto-rename" | "mkv-move" | "audio-strip",
     message: string,
     fields?: Record<string, unknown>,
     item?: DownloadItem | null,
@@ -3892,6 +3893,128 @@ export class DownloadManager extends EventEmitter {
     );
   }
 
+  private async keepGermanAudioOnly(
+    extractDir: string,
+    pkg?: PackageEntry,
+    shouldAbort?: () => boolean,
+    signal?: AbortSignal
+  ): Promise<number> {
+    if (!pkg) {
+      return this.keepGermanAudioOnlyImpl(extractDir, undefined, shouldAbort, signal);
+    }
+    return this.chainPackageFileOp(pkg.id, () =>
+      this.keepGermanAudioOnlyImpl(extractDir, pkg, shouldAbort, signal)
+    );
+  }
+
+  // Post-extract step: for ".DL." (Dual-Language) MKV/MP4 files, keep only the
+  // German audio track and strip the ".DL." marker from the filename. Operates
+  // only inside pkg.extractDir, before MKV-collect. Best-effort per file; an
+  // error never fails the package. Original is never lost (see video-processor).
+  private async keepGermanAudioOnlyImpl(
+    extractDir: string,
+    pkg?: PackageEntry,
+    shouldAbort?: () => boolean,
+    signal?: AbortSignal
+  ): Promise<number> {
+    if (!this.settings.keepGermanAudioOnly) {
+      return 0;
+    }
+    const mkvLibraryDir = String(this.settings.mkvLibraryDir || "").trim();
+    if (mkvLibraryDir && (isPathInsideDir(mkvLibraryDir, extractDir) || isPathInsideDir(extractDir, mkvLibraryDir))) {
+      logger.warn(`Tonspur-Bereinigung ABGEBROCHEN: extractDir=${extractDir} ueberlappt mit mkvLibraryDir=${mkvLibraryDir}`);
+      return 0;
+    }
+
+    const videoFiles = await this.collectVideoFiles(extractDir);
+    const sampleTokenRe = /(^|[._\-\s])sample([._\-\s]|$)/i;
+    const targets = videoFiles.filter((p) => {
+      const name = path.basename(p);
+      if (!isRemuxableVideoFile(name) || !hasDualLangMarker(name)) {
+        return false;
+      }
+      if (sampleTokenRe.test(name) || ["sample", "samples"].includes(path.basename(path.dirname(p)).toLowerCase())) {
+        return false;
+      }
+      return true;
+    });
+    if (targets.length === 0) {
+      return 0;
+    }
+    if (pkg) {
+      this.logRenameProcess(pkg, "INFO", "audio-strip", "Tonspur-Bereinigung gestartet", { extractDir, candidates: targets.length });
+    }
+
+    const mode: GermanAudioMode = this.settings.germanAudioMode === "first" ? "first" : "tag";
+    let processed = 0;
+    for (const sourcePath of targets) {
+      if (shouldAbort?.() || signal?.aborted) {
+        return processed;
+      }
+      const sourceName = path.basename(sourcePath);
+      let result: VideoProcessResult;
+      try {
+        result = await processVideoFile(sourcePath, { mode, cpuPriority: this.settings.extractCpuPriority, signal });
+      } catch (error) {
+        result = { action: "error", reason: "exception", error: compactErrorText(error) };
+      }
+      if (result.action === "aborted") {
+        return processed;
+      }
+      if (result.action === "skipped-no-tool") {
+        logger.warn("Tonspur-Bereinigung: ffmpeg/ffprobe nicht gefunden — Schritt uebersprungen (PATH oder RD_FFMPEG_BIN setzen)");
+        if (pkg) {
+          this.logRenameProcess(pkg, "WARN", "audio-strip", "Tonspur-Bereinigung uebersprungen: ffmpeg/ffprobe fehlt", { sourceName });
+        }
+        return processed;
+      }
+      if (pkg) {
+        const level = result.action === "error" ? "WARN" : "INFO";
+        const resolved = this.inferItemForMediaLog(pkg, sourcePath, sourceName);
+        this.logRenameProcess(pkg, level, "audio-strip", `Tonspur: ${result.action} (${result.reason})`, {
+          sourceName,
+          keptTrack: result.keptTrackIndex,
+          audioTracks: result.totalAudioTracks,
+          ...(result.error ? { error: result.error } : {})
+        }, resolved.item, resolved.matchedBy);
+      }
+      if (result.action === "remuxed") {
+        processed += 1;
+      }
+      // Only strip ".DL." once the file is confirmed German-only (remuxed) or
+      // already single-track. Skips/errors leave the file fully untouched so the
+      // unprocessed state stays visible.
+      if (result.action === "remuxed" || result.action === "kept-single") {
+        await this.stripDualLangFromFileName(sourcePath, pkg);
+      }
+    }
+    return processed;
+  }
+
+  private async stripDualLangFromFileName(sourcePath: string, pkg?: PackageEntry): Promise<void> {
+    const dir = path.dirname(sourcePath);
+    const name = path.basename(sourcePath);
+    const newName = stripDualLangMarker(name);
+    if (newName === name) {
+      return;
+    }
+    const targetPath = path.join(dir, newName);
+    if (pathKey(targetPath) !== pathKey(sourcePath) && await this.existsAsync(targetPath)) {
+      logger.warn(`.DL.-Strip uebersprungen (Ziel existiert): ${newName}`);
+      return;
+    }
+    try {
+      await this.renamePathWithExdevFallback(sourcePath, targetPath, { label: "audio-strip" });
+      await this.renameCompanionFiles(sourcePath, targetPath, pkg);
+      if (pkg) {
+        const resolved = this.inferItemForMediaLog(pkg, targetPath, path.basename(targetPath));
+        this.logRenameProcess(pkg, "INFO", "audio-strip", ".DL. aus Dateiname entfernt", { sourcePath, targetPath }, resolved.item, resolved.matchedBy);
+      }
+    } catch (error) {
+      logger.warn(`.DL.-Strip fehlgeschlagen (${name}): ${compactErrorText(error)}`);
+    }
+  }
+
   private async autoRenameExtractedVideoFilesImpl(
     extractDir: string,
     pkg?: PackageEntry,
@@ -4511,7 +4634,12 @@ export class DownloadManager extends EventEmitter {
     if (!cleanBase) {
       return null;
     }
-    const cleanFileName = `${cleanBase}${sourceExt}`;
+    // Safety net: collect derives names from folder tokens that may still carry
+    // ".DL.". When German-audio-only is on, never reintroduce the marker the
+    // audio step already stripped from the file.
+    const cleanFileName = this.settings.keepGermanAudioOnly
+      ? stripDualLangMarker(`${cleanBase}${sourceExt}`)
+      : `${cleanBase}${sourceExt}`;
     if (cleanFileName.toLowerCase() === path.basename(sourcePath).toLowerCase()) {
       return null;
     }
@@ -7076,6 +7204,7 @@ export class DownloadManager extends EventEmitter {
       return false;
     }
     return this.settings.autoRename4sf4sj
+      || this.settings.keepGermanAudioOnly
       || this.settings.collectMkvToLibrary
       || this.settings.removeLinkFilesAfterExtract
       || this.settings.removeSamplesAfterExtract
@@ -10942,6 +11071,7 @@ export class DownloadManager extends EventEmitter {
           try {
             await this.chainPackageFileOp(pkg.id, async () => {
               await this.autoRenameExtractedVideoFilesImpl(pkg.extractDir, pkg, hybridShouldAbort);
+              await this.keepGermanAudioOnlyImpl(pkg.extractDir, pkg, hybridShouldAbort, hybridController.signal);
               await this.collectMkvFilesToLibrary(packageId, pkg, hybridShouldAbort, true);
             });
           } catch (err) {
@@ -11612,6 +11742,12 @@ export class DownloadManager extends EventEmitter {
         });
         throwIfAborted();
         await this.autoRenameExtractedVideoFiles(pkg.extractDir, pkg, shouldAbort, true);
+        if (this.settings.keepGermanAudioOnly) {
+          pkg.postProcessLabel = "Tonspur...";
+          this.emitState();
+          throwIfAborted();
+          await this.keepGermanAudioOnly(pkg.extractDir, pkg, shouldAbort, deferredController.signal);
+        }
       }
 
       if ((extractedCount > 0 || alreadyMarkedExtracted) && failed === 0 && this.settings.cleanupMode !== "none") {

src/main/storage.ts

@@ -421,6 +421,8 @@ export function normalizeSettings(settings: AppSettings): AppSettings {
     packageName: asText(settings.packageName),
     autoExtract: Boolean(settings.autoExtract),
     autoRename4sf4sj: Boolean(settings.autoRename4sf4sj),
+    keepGermanAudioOnly: Boolean(settings.keepGermanAudioOnly),
+    germanAudioMode: settings.germanAudioMode === "first" ? "first" : "tag",
     extractDir: normalizeAbsoluteDir(settings.extractDir, defaults.extractDir),
     collectMkvToLibrary: Boolean(settings.collectMkvToLibrary),
     mkvLibraryDir: normalizeAbsoluteDir(settings.mkvLibraryDir, defaults.mkvLibraryDir),

src/main/video-processor.ts

@@ -0,0 +1,445 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawn } from "node:child_process";
+
+// Removes only-German audio handling for "Dual Language" (.DL.) scene releases.
+// Mirrors the user's ffmpeg script but adds: language-tag detection (with safe
+// fallbacks), disk-space pre-check, atomic temp->replace, mtime preservation,
+// abort-into-child, and "never destroy the only usable audio" safety.
+//
+// The ffmpeg/ffprobe-specific logic lives here so it is mockable in isolation;
+// the per-package iteration + filename/.DL. rename + logging stays in
+// download-manager.ts (its existing domain).
+
+export type GermanAudioMode = "tag" | "first";
+
+export interface ProbedAudioStream {
+  language: string;
+  title: string;
+}
+
+export type AudioTrackDecision =
+  | { action: "remux"; audioRelIndex: number; reason: string }
+  | { action: "single"; audioRelIndex: 0; reason: string }
+  | { action: "skip"; reason: string };
+
+export type VideoProcessAction =
+  | "remuxed"
+  | "kept-single"
+  | "skipped-no-german"
+  | "skipped-no-audio"
+  | "skipped-no-space"
+  | "skipped-no-tool"
+  | "error"
+  | "aborted";
+
+export interface VideoProcessResult {
+  action: VideoProcessAction;
+  reason: string;
+  keptTrackIndex?: number;
+  totalAudioTracks?: number;
+  error?: string;
+}
+
+export interface ProcessVideoOptions {
+  mode: GermanAudioMode;
+  cpuPriority?: string;
+  signal?: AbortSignal;
+}
+
+// Injection seam so the irreversible file-mutating body (temp -> replace ->
+// utimes -> rm-on-failure) can be exercised in tests with a fake ffmpeg/ffprobe
+// runner, without spawning real processes. Production passes nothing.
+export interface ProcessVideoDeps {
+  resolveTooling?: () => Promise<{ ffmpeg: string; ffprobe: string } | null>;
+  runProcess?: typeof runVideoProcess;
+}
+
+const VIDEO_REMUX_EXTENSIONS = new Set([".mkv", ".mp4"]);
+const PROBE_TIMEOUT_MS = 60_000;
+const STDOUT_CAP = 2 * 1024 * 1024;
+const STDERR_CAP = 64 * 1024;
+
+// ---------------------------------------------------------------------------
+// Pure helpers (no fs / no process) — unit-tested in isolation.
+// ---------------------------------------------------------------------------
+
+// "X.German.DL.720p.mkv" -> "X.German.720p.mkv"; "X.DL.mkv" -> "X.mkv".
+export function stripDualLangMarker(fileName: string): string {
+  const ext = path.extname(fileName);
+  const base = ext ? fileName.slice(0, -ext.length) : fileName;
+  const stripped = base.replace(/\.DL\./gi, ".").replace(/\.DL$/i, "");
+  return stripped + ext;
+}
+
+export function hasDualLangMarker(fileName: string): boolean {
+  return stripDualLangMarker(fileName) !== fileName;
+}
+
+export function isRemuxableVideoFile(fileName: string): boolean {
+  return VIDEO_REMUX_EXTENSIONS.has(path.extname(fileName).toLowerCase());
+}
+
+function isGermanStream(stream: ProbedAudioStream): boolean {
+  const lang = (stream.language || "").toLowerCase().trim();
+  if (["ger", "deu", "de", "german", "deutsch"].includes(lang)) {
+    return true;
+  }
+  const title = (stream.title || "").toLowerCase();
+  return /\b(german|deutsch|ger|deu)\b/.test(title);
+}
+
+// Decide which audio track to keep. Safety invariant: only ever choose to remux
+// (which destroys the original) when we are confident; otherwise skip untouched.
+export function pickAudioTrack(streams: ProbedAudioStream[], mode: GermanAudioMode): AudioTrackDecision {
+  const total = streams.length;
+  if (total === 0) {
+    return { action: "skip", reason: "no-audio" };
+  }
+  if (mode === "first") {
+    return total === 1
+      ? { action: "single", audioRelIndex: 0, reason: "single-audio" }
+      : { action: "remux", audioRelIndex: 0, reason: "first-audio" };
+  }
+  // tag mode
+  const germanPos = streams.findIndex(isGermanStream);
+  if (germanPos >= 0) {
+    return total === 1
+      ? { action: "single", audioRelIndex: 0, reason: "single-german" }
+      : { action: "remux", audioRelIndex: germanPos, reason: "german-tag" };
+  }
+  const anyTagged = streams.some((s) => (s.language || "").trim().length > 0);
+  if (!anyTagged) {
+    // No language metadata at all -> fall back to the script's behavior.
+    return total === 1
+      ? { action: "single", audioRelIndex: 0, reason: "single-untagged" }
+      : { action: "remux", audioRelIndex: 0, reason: "fallback-first-untagged" };
+  }
+  // Tagged, but no German track -> never guess-delete the only usable audio.
+  return { action: "skip", reason: "no-german-track" };
+}
+
+export function parseFfprobeAudioStreams(jsonText: string): ProbedAudioStream[] {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(jsonText);
+  } catch {
+    return [];
+  }
+  const streams = (parsed as { streams?: unknown }).streams;
+  if (!Array.isArray(streams)) {
+    return [];
+  }
+  return streams.map((raw) => {
+    const tags = (raw && typeof raw === "object" ? (raw as { tags?: unknown }).tags : undefined) as
+      | { language?: unknown; title?: unknown }
+      | undefined;
+    return {
+      language: typeof tags?.language === "string" ? tags.language : "",
+      title: typeof tags?.title === "string" ? tags.title : ""
+    };
+  });
+}
+
+export function buildFfprobeArgs(input: string): string[] {
+  return [
+    "-v", "error",
+    "-select_streams", "a",
+    "-show_entries", "stream=index:stream_tags=language,title",
+    "-of", "json",
+    input
+  ];
+}
+
+export function buildFfmpegRemuxArgs(opts: { input: string; output: string; audioRelIndex: number; keepSubs?: boolean }): string[] {
+  const args = ["-i", opts.input, "-map", "0:v:0", "-map", `0:a:${opts.audioRelIndex}`];
+  if (opts.keepSubs) {
+    // Optional (not enabled by current settings): keep German subtitle tracks only.
+    args.push("-map", "0:s:m:language:ger?", "-map", "0:s:m:language:deu?");
+  }
+  // Stream-copy and keep metadata (so the kept track's language tag survives;
+  // unlike the original script's -map_metadata -1 which dropped it).
+  args.push("-c", "copy", "-disposition:a:0", "default", "-y", opts.output);
+  return args;
+}
+
+// Stream-copy remux is disk-bound; generous budget scaled by size, clamped.
+export function computeRemuxTimeoutMs(bytes: number): number {
+  const perBytes = Math.ceil((Number(bytes) || 0) / (10 * 1024 * 1024)) * 1000;
+  return Math.max(120_000, Math.min(60 * 60 * 1000, 120_000 + perBytes));
+}
+
+// ---------------------------------------------------------------------------
+// Tooling discovery (system PATH + RD_FFMPEG_BIN/RD_FFPROBE_BIN env override).
+// Lazy probe + cache, mirroring the extractor's 7z/Java resolution convention.
+// ---------------------------------------------------------------------------
+
+interface VideoTooling {
+  ffmpeg: string;
+  ffprobe: string;
+}
+
+let cachedTooling: VideoTooling | null | undefined;
+let cachedToolingNullSince = 0;
+const TOOLING_NULL_TTL_MS = 5 * 60 * 1000;
+
+function ffmpegCandidate(): string {
+  return String(process.env.RD_FFMPEG_BIN || "").trim() || "ffmpeg";
+}
+
+function ffprobeCandidate(): string {
+  return String(process.env.RD_FFPROBE_BIN || "").trim() || "ffprobe";
+}
+
+async function probeVersion(command: string): Promise<boolean> {
+  const result = await runVideoProcess(command, ["-version"], { timeoutMs: 10_000 });
+  return result.ok && !result.missing;
+}
+
+export async function resolveVideoTooling(): Promise<VideoTooling | null> {
+  if (cachedTooling) {
+    return cachedTooling;
+  }
+  if (cachedTooling === null && Date.now() - cachedToolingNullSince < TOOLING_NULL_TTL_MS) {
+    return null;
+  }
+  const ffmpeg = ffmpegCandidate();
+  const ffprobe = ffprobeCandidate();
+  const [ffmpegOk, ffprobeOk] = await Promise.all([probeVersion(ffmpeg), probeVersion(ffprobe)]);
+  if (ffmpegOk && ffprobeOk) {
+    cachedTooling = { ffmpeg, ffprobe };
+    return cachedTooling;
+  }
+  cachedTooling = null;
+  cachedToolingNullSince = Date.now();
+  return null;
+}
+
+export function resetVideoToolingCache(): void {
+  cachedTooling = undefined;
+  cachedToolingNullSince = 0;
+}
+
+// ---------------------------------------------------------------------------
+// Process spawning (ffmpeg/ffprobe). ffmpeg/ffprobe exit conventions: 0 = ok,
+// anything else = real failure (NOT 7-Zip's "exit 1 = warning" semantics).
+// ---------------------------------------------------------------------------
+
+export interface VideoSpawnResult {
+  ok: boolean;
+  aborted: boolean;
+  timedOut: boolean;
+  missing: boolean;
+  exitCode: number | null;
+  stdout: string;
+  stderr: string;
+}
+
+function appendCapped(buffer: string, text: string, cap: number): string {
+  const next = buffer + text;
+  return next.length > cap ? next.slice(next.length - cap) : next;
+}
+
+function applyChildPriority(pid: number | undefined, cpuPriority?: string): void {
+  if (process.platform !== "win32") {
+    return;
+  }
+  const numeric = Number(pid || 0);
+  if (!Number.isFinite(numeric) || numeric <= 0) {
+    return;
+  }
+  try {
+    const level = cpuPriority === "high" ? os.constants.priority.PRIORITY_NORMAL : os.constants.priority.PRIORITY_BELOW_NORMAL;
+    os.setPriority(numeric, level);
+  } catch {
+  }
+}
+
+function killChildTree(child: { pid?: number; kill: () => void }): void {
+  const pid = Number(child.pid || 0);
+  if (process.platform === "win32" && Number.isFinite(pid) && pid > 0) {
+    try {
+      const killer = spawn("taskkill", ["/PID", String(pid), "/T", "/F"], { windowsHide: true, stdio: "ignore" });
+      killer.on("error", () => { try { child.kill(); } catch {} });
+      return;
+    } catch {
+    }
+  }
+  try {
+    child.kill();
+  } catch {
+  }
+}
+
+export function runVideoProcess(
+  command: string,
+  args: string[],
+  opts: { signal?: AbortSignal; timeoutMs?: number; cpuPriority?: string } = {}
+): Promise<VideoSpawnResult> {
+  const { signal, timeoutMs, cpuPriority } = opts;
+  if (signal?.aborted) {
+    return Promise.resolve({ ok: false, aborted: true, timedOut: false, missing: false, exitCode: null, stdout: "", stderr: "" });
+  }
+  return new Promise((resolve) => {
+    let settled = false;
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let aborted = false;
+    let timeoutId: NodeJS.Timeout | null = null;
+
+    const child = spawn(command, args, { windowsHide: true });
+    applyChildPriority(child.pid, cpuPriority);
+
+    const onAbort = (): void => {
+      aborted = true;
+      killChildTree(child);
+    };
+
+    const finish = (result: VideoSpawnResult): void => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      if (signal) {
+        signal.removeEventListener("abort", onAbort);
+      }
+      resolve(result);
+    };
+
+    if (timeoutMs && timeoutMs > 0) {
+      timeoutId = setTimeout(() => {
+        timedOut = true;
+        killChildTree(child);
+        finish({ ok: false, aborted: false, timedOut: true, missing: false, exitCode: null, stdout, stderr });
+      }, timeoutMs);
+    }
+    if (signal) {
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+
+    child.stdout?.on("data", (chunk) => { stdout = appendCapped(stdout, String(chunk || ""), STDOUT_CAP); });
+    child.stderr?.on("data", (chunk) => { stderr = appendCapped(stderr, String(chunk || ""), STDERR_CAP); });
+
+    child.on("error", (error) => {
+      const text = String(error || "");
+      finish({ ok: false, aborted: false, timedOut: false, missing: text.toLowerCase().includes("enoent"), exitCode: null, stdout, stderr: stderr || text });
+    });
+
+    child.on("close", (code) => {
+      if (aborted) {
+        finish({ ok: false, aborted: true, timedOut: false, missing: false, exitCode: code, stdout, stderr });
+        return;
+      }
+      if (timedOut) {
+        finish({ ok: false, aborted: false, timedOut: true, missing: false, exitCode: code, stdout, stderr });
+        return;
+      }
+      finish({ ok: code === 0, aborted: false, timedOut: false, missing: false, exitCode: code, stdout, stderr });
+    });
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Per-file orchestration: probe -> decide -> (disk check) -> remux -> atomic
+// replace -> preserve mtime. Operates IN PLACE (same filename); the .DL. rename
+// + companion handling + logging is done by the caller (download-manager).
+// ---------------------------------------------------------------------------
+
+async function getFreeSpaceBytes(dir: string): Promise<number | null> {
+  try {
+    const stat = await fs.promises.statfs(dir);
+    return Number(stat.bavail) * Number(stat.bsize);
+  } catch {
+    return null;
+  }
+}
+
+export async function processVideoFile(filePath: string, opts: ProcessVideoOptions, deps: ProcessVideoDeps = {}): Promise<VideoProcessResult> {
+  const resolveTool = deps.resolveTooling || resolveVideoTooling;
+  const run = deps.runProcess || runVideoProcess;
+  if (opts.signal?.aborted) {
+    return { action: "aborted", reason: "aborted" };
+  }
+  const tooling = await resolveTool();
+  if (!tooling) {
+    return { action: "skipped-no-tool", reason: "ffmpeg/ffprobe nicht gefunden (PATH oder RD_FFMPEG_BIN)" };
+  }
+
+  const probe = await run(tooling.ffprobe, buildFfprobeArgs(filePath), { signal: opts.signal, timeoutMs: PROBE_TIMEOUT_MS });
+  if (probe.aborted) {
+    return { action: "aborted", reason: "aborted" };
+  }
+  if (!probe.ok) {
+    return { action: "error", reason: "ffprobe fehlgeschlagen", error: probe.stderr || `exit ${String(probe.exitCode)}` };
+  }
+
+  const streams = parseFfprobeAudioStreams(probe.stdout);
+  const decision = pickAudioTrack(streams, opts.mode);
+  if (decision.action === "skip") {
+    return {
+      action: decision.reason === "no-german-track" ? "skipped-no-german" : "skipped-no-audio",
+      reason: decision.reason,
+      totalAudioTracks: streams.length
+    };
+  }
+  if (decision.action === "single") {
+    return { action: "kept-single", reason: decision.reason, totalAudioTracks: streams.length, keptTrackIndex: 0 };
+  }
+
+  // remux path
+  let originalStat: fs.Stats;
+  try {
+    originalStat = await fs.promises.stat(filePath);
+  } catch (error) {
+    return { action: "error", reason: "stat fehlgeschlagen", error: String(error) };
+  }
+  const free = await getFreeSpaceBytes(path.dirname(filePath));
+  if (free !== null && free < Math.ceil(originalStat.size * 1.05)) {
+    return { action: "skipped-no-space", reason: "zu wenig freier Speicher fuer Remux", totalAudioTracks: streams.length };
+  }
+
+  const ext = path.extname(filePath);
+  const tempPath = `${filePath}.gertmp${ext}`;
+  await fs.promises.rm(tempPath, { force: true }).catch(() => {});
+
+  const remux = await run(
+    tooling.ffmpeg,
+    buildFfmpegRemuxArgs({ input: filePath, output: tempPath, audioRelIndex: decision.audioRelIndex, keepSubs: false }),
+    { signal: opts.signal, timeoutMs: computeRemuxTimeoutMs(originalStat.size), cpuPriority: opts.cpuPriority }
+  );
+  if (remux.aborted) {
+    await fs.promises.rm(tempPath, { force: true }).catch(() => {});
+    return { action: "aborted", reason: "aborted" };
+  }
+  if (!remux.ok) {
+    await fs.promises.rm(tempPath, { force: true }).catch(() => {});
+    return { action: "error", reason: "ffmpeg remux fehlgeschlagen", error: remux.stderr || `exit ${String(remux.exitCode)}`, totalAudioTracks: streams.length };
+  }
+
+  const tempStat = await fs.promises.stat(tempPath).catch(() => null);
+  if (!tempStat || tempStat.size <= 0) {
+    await fs.promises.rm(tempPath, { force: true }).catch(() => {});
+    return { action: "error", reason: "Remux ergab leere Datei", totalAudioTracks: streams.length };
+  }
+
+  try {
+    // libuv rename replaces an existing destination on Windows; fall back if not.
+    await fs.promises.rename(tempPath, filePath).catch(async () => {
+      await fs.promises.rm(filePath, { force: true });
+      await fs.promises.rename(tempPath, filePath);
+    });
+    // Preserve original mtime so freshness gates (hybrid collect) don't skip it.
+    await fs.promises.utimes(filePath, originalStat.atime, originalStat.mtime).catch(() => {});
+  } catch (error) {
+    await fs.promises.rm(tempPath, { force: true }).catch(() => {});
+    return { action: "error", reason: "Ersetzen der Datei fehlgeschlagen", error: String(error), totalAudioTracks: streams.length };
+  }
+
+  return { action: "remuxed", reason: decision.reason, keptTrackIndex: decision.audioRelIndex, totalAudioTracks: streams.length };
+}

src/renderer/App.tsx

@@ -844,7 +844,7 @@ const emptySnapshot = (): UiSnapshot => ({
     archivePasswordList: "",
     rememberToken: true, providerOrder: [], providerPrimary: "realdebrid", providerSecondary: "none",
     providerTertiary: "none", autoProviderFallback: true, outputDir: "", packageName: "",
-    autoExtract: true, autoRename4sf4sj: false, extractDir: "", createExtractSubfolder: true, hybridExtract: true,
+    autoExtract: true, autoRename4sf4sj: false, keepGermanAudioOnly: false, germanAudioMode: "tag", extractDir: "", createExtractSubfolder: true, hybridExtract: true,
     collectMkvToLibrary: false, mkvLibraryDir: "",
     cleanupMode: "none", extractConflictMode: "overwrite", removeLinkFilesAfterExtract: false,
     removeSamplesAfterExtract: false, enableIntegrityCheck: true, autoResumeOnStart: true,
@@ -5372,6 +5372,11 @@ export function App(): ReactElement {
                     <label className="toggle-line"><input type="checkbox" checked={settingsDraft.autoSkipExtracted} onChange={(e) => setBool("autoSkipExtracted", e.target.checked)} /> Bereits Entpacktes beim Start überspringen</label>
                     <label className="toggle-line"><input type="checkbox" checked={settingsDraft.hideExtractedItems} onChange={(e) => setBool("hideExtractedItems", e.target.checked)} /> Entpackte Items in Paketliste ausblenden</label>
                     <label className="toggle-line"><input type="checkbox" checked={settingsDraft.autoRename4sf4sj} onChange={(e) => setBool("autoRename4sf4sj", e.target.checked)} /> Auto-Rename (Beta)</label>
+                    <label className="toggle-line"><input type="checkbox" checked={settingsDraft.keepGermanAudioOnly} onChange={(e) => setBool("keepGermanAudioOnly", e.target.checked)} /> Nur deutsche Tonspur behalten (.DL.-Dateien, braucht ffmpeg)</label>
+                    <div><label>Tonspur-Auswahl</label><select value={settingsDraft.germanAudioMode} disabled={!settingsDraft.keepGermanAudioOnly} onChange={(e) => setText("germanAudioMode", e.target.value)}>
+                      <option value="tag">Deutsche Spur per Sprach-Tag (empfohlen)</option>
+                      <option value="first">Immer erste Tonspur (wie Script)</option>
+                    </select></div>
                     <label className="toggle-line"><input type="checkbox" checked={settingsDraft.createExtractSubfolder} onChange={(e) => setBool("createExtractSubfolder", e.target.checked)} /> Entpackte Dateien in Paket-Unterordner speichern</label>
                     <label className="toggle-line"><input type="checkbox" checked={settingsDraft.hybridExtract} onChange={(e) => setBool("hybridExtract", e.target.checked)} /> Hybrid-Extract</label>
                     <label className="toggle-line"><input type="checkbox" checked={settingsDraft.autoExtractWhenStopped} onChange={(e) => setBool("autoExtractWhenStopped", e.target.checked)} /> Entpacken auch ohne laufende Session (bei Stopp / Programmstart)</label>

src/shared/types.ts

@@ -97,6 +97,8 @@ export interface AppSettings {
   packageName: string;
   autoExtract: boolean;
   autoRename4sf4sj: boolean;
+  keepGermanAudioOnly: boolean;
+  germanAudioMode: "tag" | "first";
   extractDir: string;
   collectMkvToLibrary: boolean;
   mkvLibraryDir: string;