0.16.0 Pre-Release Checks

backend/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "ripster-backend",
-  "version": "0.15.0-3",
+  "version": "0.16.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "ripster-backend",
-      "version": "0.15.0-3",
+      "version": "0.16.0",
       "dependencies": {
         "archiver": "^7.0.1",
         "cors": "^2.8.5",

backend/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ripster-backend",
-  "version": "0.15.0-3",
+  "version": "0.16.0",
   "private": true,
   "type": "commonjs",
   "scripts": {

backend/src/db/database.js

@@ -883,7 +883,13 @@ const SETTINGS_CATEGORY_MOVES = [
   { key: 'converter_movie_dir', category: 'Pfade' },
   { key: 'converter_audio_dir', category: 'Pfade' },
   { key: 'converter_output_template_video', category: 'Pfade' },
-  { key: 'converter_output_template_audio', category: 'Pfade' }
+  { key: 'converter_output_template_audio', category: 'Pfade' },
+  { key: 'server_console_log_output_enabled', category: 'Logging' },
+  { key: 'server_console_log_http_enabled', category: 'Logging' },
+  { key: 'server_console_log_debug_enabled', category: 'Logging' },
+  { key: 'server_console_log_info_enabled', category: 'Logging' },
+  { key: 'server_console_log_warn_enabled', category: 'Logging' },
+  { key: 'server_console_log_error_enabled', category: 'Logging' }
 ];
 
 async function migrateSettingsSchemaMetadata(db) {
@@ -1049,6 +1055,48 @@ async function migrateSettingsSchemaMetadata(db) {
   );
   await db.run(`INSERT OR IGNORE INTO settings_values (key, value) VALUES ('ffprobe_command', 'ffprobe')`);
 
+  await db.run(
+    `INSERT OR IGNORE INTO settings_schema (key, category, label, type, required, description, default_value, options_json, validation_json, order_index)
+     VALUES ('handbrake_pre_metadata_scan_enabled', 'Tools', 'Vorab-HandBrake-Scan vor Metadaten', 'boolean', 1, 'Wenn deaktiviert, wird der erste HandBrake-Scan vor der Metadatenauswahl übersprungen.', 'true', '[]', '{}', 221)`
+  );
+  await db.run(`INSERT OR IGNORE INTO settings_values (key, value) VALUES ('handbrake_pre_metadata_scan_enabled', 'true')`);
+
+  await db.run(
+    `INSERT OR IGNORE INTO settings_schema (key, category, label, type, required, description, default_value, options_json, validation_json, order_index)
+     VALUES ('server_console_log_output_enabled', 'Logging', 'Terminal-Ausgabe aktiv', 'boolean', 1, 'Master-Schalter für die Ausgabe der Server-Logs im Terminal (z.B. start.sh). Das Schreiben in Log-Dateien bleibt immer aktiv.', 'true', '[]', '{}', 150)`
+  );
+  await db.run(`INSERT OR IGNORE INTO settings_values (key, value) VALUES ('server_console_log_output_enabled', 'true')`);
+
+  await db.run(
+    `INSERT OR IGNORE INTO settings_schema (key, category, label, type, required, description, default_value, options_json, validation_json, order_index)
+     VALUES ('server_console_log_http_enabled', 'Logging', 'HTTP-Logs im Terminal', 'boolean', 1, 'Steuert HTTP Request-Logs im Terminal (z.B. request:start). Dateilogs bleiben unverändert.', 'true', '[]', '{}', 151)`
+  );
+  await db.run(`INSERT OR IGNORE INTO settings_values (key, value) VALUES ('server_console_log_http_enabled', 'true')`);
+
+  await db.run(
+    `INSERT OR IGNORE INTO settings_schema (key, category, label, type, required, description, default_value, options_json, validation_json, order_index)
+     VALUES ('server_console_log_debug_enabled', 'Logging', 'DEBUG im Terminal', 'boolean', 1, 'Steuert DEBUG-Meldungen in der Terminal-Ausgabe. Dateilogs bleiben unverändert.', 'true', '[]', '{}', 152)`
+  );
+  await db.run(`INSERT OR IGNORE INTO settings_values (key, value) VALUES ('server_console_log_debug_enabled', 'true')`);
+
+  await db.run(
+    `INSERT OR IGNORE INTO settings_schema (key, category, label, type, required, description, default_value, options_json, validation_json, order_index)
+     VALUES ('server_console_log_info_enabled', 'Logging', 'INFO im Terminal', 'boolean', 1, 'Steuert INFO-Meldungen in der Terminal-Ausgabe. Dateilogs bleiben unverändert.', 'true', '[]', '{}', 153)`
+  );
+  await db.run(`INSERT OR IGNORE INTO settings_values (key, value) VALUES ('server_console_log_info_enabled', 'true')`);
+
+  await db.run(
+    `INSERT OR IGNORE INTO settings_schema (key, category, label, type, required, description, default_value, options_json, validation_json, order_index)
+     VALUES ('server_console_log_warn_enabled', 'Logging', 'WARN im Terminal', 'boolean', 1, 'Steuert WARN-Meldungen in der Terminal-Ausgabe. Dateilogs bleiben unverändert.', 'true', '[]', '{}', 154)`
+  );
+  await db.run(`INSERT OR IGNORE INTO settings_values (key, value) VALUES ('server_console_log_warn_enabled', 'true')`);
+
+  await db.run(
+    `INSERT OR IGNORE INTO settings_schema (key, category, label, type, required, description, default_value, options_json, validation_json, order_index)
+     VALUES ('server_console_log_error_enabled', 'Logging', 'ERROR im Terminal', 'boolean', 1, 'Steuert ERROR-Meldungen in der Terminal-Ausgabe. Dateilogs bleiben unverändert.', 'true', '[]', '{}', 155)`
+  );
+  await db.run(`INSERT OR IGNORE INTO settings_values (key, value) VALUES ('server_console_log_error_enabled', 'true')`);
+
 
   await db.run(
     `INSERT OR IGNORE INTO settings_schema (key, category, label, type, required, description, default_value, options_json, validation_json, order_index)
@@ -1288,6 +1336,12 @@ async function migrateSettingsSchemaMetadata(db) {
   );
   await db.run(`INSERT OR IGNORE INTO settings_values (key, value) VALUES ('coverart_recovery_interval_hours', '6')`);
 
+  await db.run(
+    `INSERT OR IGNORE INTO settings_schema (key, category, label, type, required, description, default_value, options_json, validation_json, order_index)
+     VALUES ('generate_nfo_after_encode', 'Metadaten', 'NFO nach Encode erzeugen', 'boolean', 1, 'Erstellt nach erfolgreichem Encode automatisch eine .nfo-Datei neben der Ausgabedatei.', 'false', '[]', '{}', 432)`
+  );
+  await db.run(`INSERT OR IGNORE INTO settings_values (key, value) VALUES ('generate_nfo_after_encode', 'false')`);
+
   await db.run(`
     CREATE TABLE IF NOT EXISTS user_prefs (
       key TEXT PRIMARY KEY,

backend/src/index.js

@@ -16,6 +16,7 @@ const runtimeRoutes = require('./routes/runtimeRoutes');
 const converterRoutes = require('./routes/converterRoutes');
 const wsService = require('./services/websocketService');
 const pipelineService = require('./services/pipelineService');
+const settingsService = require('./services/settingsService');
 const converterScanService = require('./services/converterScanService');
 const cronService = require('./services/cronService');
 const downloadService = require('./services/downloadService');
@@ -30,6 +31,12 @@ const { getThumbnailsDir, migrateExistingThumbnails } = require('./services/thum
 async function start() {
   logger.info('backend:start:init');
   await initDatabase();
+  try {
+    const runtimeSettings = await settingsService.applyRuntimeSettings();
+    logger.info('backend:runtime-settings:applied', runtimeSettings);
+  } catch (error) {
+    logger.warn('backend:runtime-settings:apply-failed', { error: errorToMeta(error) });
+  }
   await tempCleanupService.init();
   await pipelineService.init();
   await converterScanService.startPolling();

backend/src/routes/historyRoutes.js

@@ -6,6 +6,21 @@ const logger = require('../services/logger').child('HISTORY_ROUTE');
 
 const router = express.Router();
 
+function parseSelectedJobIds(value, options = {}) {
+  const { hasExplicitValue = true } = options;
+  if (!hasExplicitValue) {
+    return null;
+  }
+  const sourceValues = Array.isArray(value)
+    ? value
+    : String(value || '')
+      .split(',');
+  return sourceValues
+    .map((entry) => Number(entry))
+    .filter((entry) => Number.isFinite(entry) && entry > 0)
+    .map((entry) => Math.trunc(entry));
+}
+
 router.get(
   '/',
   asyncHandler(async (req, res) => {
@@ -147,12 +162,31 @@ router.post(
   })
 );
 
+router.post(
+  '/:id/nfo/generate',
+  asyncHandler(async (req, res) => {
+    const id = Number(req.params.id);
+    logger.info('post:job:nfo:generate', { reqId: req.reqId, id });
+    const result = await historyService.generateJobNfo(id, {
+      mode: 'manual',
+      requireSettingDisabled: true,
+      failIfExists: true,
+      failIfOutputMissing: true
+    });
+    const job = await historyService.getJobWithLogs(id, { includeFsChecks: true });
+    res.json({ result, job });
+  })
+);
+
 router.post(
   '/:id/delete-files',
   asyncHandler(async (req, res) => {
     const id = Number(req.params.id);
     const target = String(req.body?.target || 'both');
     const includeRelated = ['1', 'true', 'yes'].includes(String(req.body?.includeRelated || 'false').toLowerCase());
+    const selectedJobIds = parseSelectedJobIds(req.body?.selectedJobIds, {
+      hasExplicitValue: Object.prototype.hasOwnProperty.call(req.body || {}, 'selectedJobIds')
+    });
     const selectedRawPaths = Array.isArray(req.body?.selectedRawPaths)
       ? req.body.selectedRawPaths
         .map((item) => String(item || '').trim())
@@ -169,12 +203,14 @@ router.post(
       id,
       target,
       includeRelated,
+      selectedJobIdCount: selectedJobIds ? selectedJobIds.length : 0,
       selectedRawPathCount: selectedRawPaths ? selectedRawPaths.length : 0,
       selectedMoviePathCount: selectedMoviePaths ? selectedMoviePaths.length : 0
     });
 
     const result = await historyService.deleteJobFiles(id, target, {
       includeRelated,
+      selectedJobIds,
       selectedRawPaths,
       selectedMoviePaths
     });
@@ -187,14 +223,18 @@ router.get(
   asyncHandler(async (req, res) => {
     const id = Number(req.params.id);
     const includeRelated = ['1', 'true', 'yes'].includes(String(req.query.includeRelated || '1').toLowerCase());
+    const selectedJobIds = parseSelectedJobIds(req.query.selectedJobIds, {
+      hasExplicitValue: Object.prototype.hasOwnProperty.call(req.query || {}, 'selectedJobIds')
+    });
 
     logger.info('get:delete-preview', {
       reqId: req.reqId,
       id,
-      includeRelated
+      includeRelated,
+      selectedJobIdCount: selectedJobIds ? selectedJobIds.length : 0
     });
 
-    const preview = await historyService.getJobDeletePreview(id, { includeRelated });
+    const preview = await historyService.getJobDeletePreview(id, { includeRelated, selectedJobIds });
     res.json({ preview });
   })
 );
@@ -205,6 +245,9 @@ router.post(
     const id = Number(req.params.id);
     const target = String(req.body?.target || 'none');
     const includeRelated = ['1', 'true', 'yes'].includes(String(req.body?.includeRelated || 'false').toLowerCase());
+    const selectedJobIds = parseSelectedJobIds(req.body?.selectedJobIds, {
+      hasExplicitValue: Object.prototype.hasOwnProperty.call(req.body || {}, 'selectedJobIds')
+    });
     const requestedResetDriveState = ['1', 'true', 'yes'].includes(String(req.body?.resetDriveState || 'false').toLowerCase());
     const preserveRawForImportJobs = ['1', 'true', 'yes'].includes(String(req.body?.preserveRawForImportJobs || 'false').toLowerCase());
     const requestedKeepDetectedDevice = req.body?.keepDetectedDevice !== undefined
@@ -226,6 +269,7 @@ router.post(
       id,
       target,
       includeRelated,
+      selectedJobIdCount: selectedJobIds ? selectedJobIds.length : 0,
       requestedResetDriveState,
       preserveRawForImportJobs,
       requestedKeepDetectedDevice,
@@ -233,10 +277,12 @@ router.post(
       selectedMoviePathCount: selectedMoviePaths ? selectedMoviePaths.length : 0
     });
 
-    const preview = await historyService.getJobDeletePreview(id, { includeRelated });
+    const preview = await historyService.getJobDeletePreview(id, { includeRelated, selectedJobIds });
     const containsOrphanRawImportJob = Boolean(
       preview?.flags?.containsOrphanRawImportJob
-      || (Array.isArray(preview?.relatedJobs) && preview.relatedJobs.some((row) => Boolean(row?.orphanRawImport)))
+      || (Array.isArray(preview?.relatedJobs) && preview.relatedJobs.some(
+        (row) => Boolean(row?.selected) && Boolean(row?.orphanRawImport)
+      ))
     );
     const resetDriveState = containsOrphanRawImportJob
       ? false
@@ -254,11 +300,13 @@ router.post(
 
     const relatedDevicePaths = Array.isArray(preview?.relatedJobs)
       ? preview.relatedJobs
+        .filter((row) => Boolean(row?.selected))
         .map((row) => String(row?.discDevice || '').trim())
         .filter(Boolean)
       : [];
     const result = await historyService.deleteJob(id, target, {
       includeRelated,
+      selectedJobIds,
       selectedRawPaths,
       selectedMoviePaths,
       preserveRawForImportJobs

backend/src/services/historyService.js

@@ -123,6 +123,187 @@ function inspectOutputFile(filePath) {
   }
 }
 
+function parseBooleanValue(value, fallback = false) {
+  if (value === null || value === undefined) {
+    return fallback;
+  }
+  if (typeof value === 'boolean') {
+    return value;
+  }
+  const normalized = String(value || '').trim().toLowerCase();
+  if (!normalized) {
+    return fallback;
+  }
+  if (['1', 'true', 'yes', 'on'].includes(normalized)) {
+    return true;
+  }
+  if (['0', 'false', 'no', 'off'].includes(normalized)) {
+    return false;
+  }
+  return fallback;
+}
+
+function resolveNfoPathFromOutputPath(outputPath) {
+  const normalizedOutputPath = String(outputPath || '').trim();
+  if (!normalizedOutputPath) {
+    return null;
+  }
+  const parsed = path.parse(normalizedOutputPath);
+  const extension = String(parsed.ext || '').trim();
+  const baseName = String(parsed.name || '').trim();
+  if (!extension || !baseName) {
+    return null;
+  }
+  return path.join(parsed.dir, `${baseName}.nfo`);
+}
+
+function inspectNfoFileStatus(nfoPath, options = {}) {
+  const includeFsChecks = options?.includeFsChecks !== false;
+  if (!nfoPath) {
+    return {
+      path: null,
+      exists: false,
+      isFile: false,
+      sizeBytes: null
+    };
+  }
+  if (!includeFsChecks) {
+    return {
+      path: nfoPath,
+      exists: null,
+      isFile: null,
+      sizeBytes: null
+    };
+  }
+  try {
+    const stat = fs.statSync(nfoPath);
+    return {
+      path: nfoPath,
+      exists: true,
+      isFile: stat.isFile(),
+      sizeBytes: stat.size
+    };
+  } catch (_error) {
+    return {
+      path: nfoPath,
+      exists: false,
+      isFile: false,
+      sizeBytes: null
+    };
+  }
+}
+
+function escapeXml(value) {
+  return String(value || '')
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;');
+}
+
+function resolveNfoMetadataFromJob(job = {}) {
+  const mkInfo = parseInfoFromValue(job?.makemkvInfo ?? job?.makemkv_info_json, {});
+  const selectedMetadata = extractSelectedMetadataFromMakemkvInfo(mkInfo);
+  const encodePlan = parseInfoFromValue(job?.encodePlan ?? job?.encode_plan_json, {});
+  const planMetadata = encodePlan?.metadata && typeof encodePlan.metadata === 'object'
+    ? encodePlan.metadata
+    : {};
+
+  const title = String(
+    job?.title
+    || selectedMetadata?.title
+    || selectedMetadata?.seriesTitle
+    || planMetadata?.title
+    || job?.detected_title
+    || ''
+  ).trim();
+  const rawYear = Number(
+    job?.year
+    ?? selectedMetadata?.year
+    ?? planMetadata?.year
+    ?? null
+  );
+  const year = Number.isFinite(rawYear) && rawYear > 0
+    ? Math.trunc(rawYear)
+    : null;
+  const imdbId = String(
+    job?.imdb_id
+    || selectedMetadata?.imdbId
+    || planMetadata?.imdbId
+    || ''
+  ).trim();
+
+  return {
+    title,
+    year,
+    imdbId
+  };
+}
+
+function buildNfoXml(metadata = {}) {
+  const title = escapeXml(metadata?.title || '');
+  const year = metadata?.year !== null && metadata?.year !== undefined
+    ? escapeXml(String(metadata.year))
+    : '';
+  const imdbId = escapeXml(metadata?.imdbId || '');
+  return [
+    '<movie>',
+    `  <title>${title}</title>`,
+    `  <year>${year}</year>`,
+    `  <imdbid>${imdbId}</imdbid>`,
+    '</movie>',
+    ''
+  ].join('\n');
+}
+
+function buildNfoStatusForJob({
+  job = {},
+  outputPath = null,
+  outputStatus = null,
+  includeFsChecks = true,
+  settings = {}
+} = {}) {
+  const normalizedOutputPath = String(outputPath || '').trim() || null;
+  const nfoPath = resolveNfoPathFromOutputPath(normalizedOutputPath);
+  const nfoStatus = inspectNfoFileStatus(nfoPath, { includeFsChecks });
+  const nfoSettingEnabled = parseBooleanValue(
+    settings?.generate_nfo_after_encode,
+    false
+  );
+  const outputExists = Boolean(outputStatus?.exists);
+  const outputIsFile = Boolean(outputStatus?.isFile);
+  const canGenerateManual = !nfoSettingEnabled
+    && Boolean(nfoPath)
+    && outputExists
+    && outputIsFile
+    && !Boolean(nfoStatus?.exists);
+
+  let reason = null;
+  if (nfoSettingEnabled) {
+    reason = 'setting_enabled';
+  } else if (!nfoPath) {
+    reason = 'output_not_file';
+  } else if (!outputExists || !outputIsFile) {
+    reason = 'output_missing';
+  } else if (Boolean(nfoStatus?.exists)) {
+    reason = 'nfo_exists';
+  } else {
+    reason = 'eligible';
+  }
+
+  return {
+    settingEnabled: nfoSettingEnabled,
+    outputPath: normalizedOutputPath,
+    nfoPath,
+    outputExists: includeFsChecks ? outputExists : null,
+    outputIsFile: includeFsChecks ? outputIsFile : null,
+    nfoExists: includeFsChecks ? Boolean(nfoStatus?.exists) : null,
+    canGenerateManual,
+    reason
+  };
+}
+
 function parseInfoFromValue(value, fallback = null) {
   if (!value) {
     return fallback;
@@ -1044,6 +1225,13 @@ function enrichJobRow(job, settings = null, options = {}) {
         ? finishedWithOutput
         : String(handbrakeInfo?.status || '').trim().toUpperCase() === 'SUCCESS')
     );
+  const nfoStatus = buildNfoStatusForJob({
+    job,
+    outputPath: resolvedPaths.effectiveOutputPath,
+    outputStatus,
+    includeFsChecks,
+    settings
+  });
 
   return {
     ...job,
@@ -1061,7 +1249,8 @@ function enrichJobRow(job, settings = null, options = {}) {
     encodeSuccess,
     rawStatus,
     outputStatus,
-    movieDirStatus
+    movieDirStatus,
+    nfoStatus
   };
 }
 
@@ -2727,6 +2916,48 @@ function parseSourceJobIdFromPlan(encodePlanRaw) {
   return sourceJobId || null;
 }
 
+function extractDiscNumberFromDeleteContext(row) {
+  const values = [
+    row?.raw_path,
+    row?.title,
+    row?.detected_title
+  ];
+  for (const value of values) {
+    const raw = String(value || '').trim();
+    if (!raw) continue;
+    const match = raw.match(/(?:^|\W)D(?:ISC)?\s*[-_ ]?(\d+)(?:\W|$)/i)
+      || raw.match(/-\s*D(\d+)\s*-\s*RAW/i);
+    const discNumber = normalizeJobIdValue(match?.[1]);
+    if (discNumber) {
+      return discNumber;
+    }
+  }
+  return null;
+}
+
+function resolveDeletePreviewRole(row) {
+  if (!row || typeof row !== 'object') {
+    return { roleKey: 'job', roleLabel: 'Job' };
+  }
+  if (isSeriesContainerRow(row) || isMultipartContainerRow(row)) {
+    return { roleKey: 'container', roleLabel: 'Container' };
+  }
+  if (isMultipartMergeRow(row)) {
+    return { roleKey: 'merge', roleLabel: 'Merge' };
+  }
+  if (isSeriesChildRow(row) || isMultipartChildRow(row)) {
+    const discNumber = extractDiscNumberFromDeleteContext(row);
+    return {
+      roleKey: 'disc',
+      roleLabel: discNumber ? `Disk ${discNumber}` : 'Disk/Child'
+    };
+  }
+  if (normalizeJobIdValue(row?.parent_job_id)) {
+    return { roleKey: 'child', roleLabel: 'Child-Job' };
+  }
+  return { roleKey: 'job', roleLabel: 'Einzeljob' };
+}
+
 function parseRetryLinkedJobIdsFromLogLines(lines = []) {
   const jobIds = new Set();
   const list = Array.isArray(lines) ? lines : [];
@@ -5104,6 +5335,124 @@ class HistoryService {
     };
   }
 
+  async generateJobNfo(jobId, options = {}) {
+    const normalizedJobId = normalizeJobIdValue(jobId);
+    if (!normalizedJobId) {
+      const error = new Error('Ungültige Job-ID.');
+      error.statusCode = 400;
+      throw error;
+    }
+
+    const mode = String(options?.mode || 'manual').trim().toLowerCase() || 'manual';
+    const requireSettingEnabled = Boolean(options?.requireSettingEnabled);
+    const requireSettingDisabled = Boolean(options?.requireSettingDisabled);
+    const failIfExists = Boolean(options?.failIfExists);
+    const failIfOutputMissing = Boolean(options?.failIfOutputMissing);
+
+    const [job, settings] = await Promise.all([
+      this.getJobById(normalizedJobId),
+      settingsService.getSettingsMap()
+    ]);
+    if (!job) {
+      const error = new Error('Job nicht gefunden.');
+      error.statusCode = 404;
+      throw error;
+    }
+
+    const enriched = enrichJobRow(job, settings, { includeFsChecks: true });
+    const nfoStatus = enriched?.nfoStatus && typeof enriched.nfoStatus === 'object'
+      ? enriched.nfoStatus
+      : buildNfoStatusForJob({
+        job: enriched,
+        outputPath: enriched?.output_path || null,
+        outputStatus: enriched?.outputStatus || null,
+        includeFsChecks: true,
+        settings
+      });
+
+    if (requireSettingEnabled && !nfoStatus.settingEnabled) {
+      return {
+        generated: false,
+        skipped: true,
+        reason: 'setting_disabled',
+        nfoStatus
+      };
+    }
+
+    if (requireSettingDisabled && nfoStatus.settingEnabled) {
+      const error = new Error('NFO-Generierung ist in den Settings aktiv. Manuelle Generierung ist nur bei deaktivierter Auto-NFO erlaubt.');
+      error.statusCode = 409;
+      throw error;
+    }
+
+    if (!nfoStatus.nfoPath) {
+      const error = new Error('Für diesen Job kann keine NFO-Datei erzeugt werden (Output ist keine Datei).');
+      error.statusCode = 409;
+      throw error;
+    }
+
+    if (!nfoStatus.outputExists || !nfoStatus.outputIsFile) {
+      if (failIfOutputMissing) {
+        const error = new Error('NFO kann nicht erzeugt werden: Output-Datei fehlt.');
+        error.statusCode = 409;
+        throw error;
+      }
+      return {
+        generated: false,
+        skipped: true,
+        reason: 'output_missing',
+        nfoStatus
+      };
+    }
+
+    if (nfoStatus.nfoExists) {
+      if (failIfExists) {
+        const error = new Error('NFO-Datei existiert bereits.');
+        error.statusCode = 409;
+        throw error;
+      }
+      return {
+        generated: false,
+        skipped: true,
+        reason: 'nfo_exists',
+        nfoStatus
+      };
+    }
+
+    const metadata = resolveNfoMetadataFromJob(enriched);
+    const xml = buildNfoXml(metadata);
+    fs.writeFileSync(nfoStatus.nfoPath, xml, 'utf8');
+
+    const refreshedNfoStatus = buildNfoStatusForJob({
+      job: enriched,
+      outputPath: enriched?.output_path || null,
+      outputStatus: enriched?.outputStatus || null,
+      includeFsChecks: true,
+      settings
+    });
+
+    await this.appendLog(
+      normalizedJobId,
+      'SYSTEM',
+      `NFO-Datei erstellt (${mode}): ${nfoStatus.nfoPath}`
+    ).catch(() => {});
+
+    logger.info('job:nfo:generated', {
+      jobId: normalizedJobId,
+      mode,
+      nfoPath: nfoStatus.nfoPath
+    });
+
+    return {
+      generated: true,
+      skipped: false,
+      mode,
+      nfoPath: nfoStatus.nfoPath,
+      metadata,
+      nfoStatus: refreshedNfoStatus
+    };
+  }
+
   async getJobArchiveDescriptor(jobId, target, options = {}) {
     const normalizedJobId = normalizeJobIdValue(jobId);
     if (!normalizedJobId) {
@@ -6649,14 +6998,7 @@ class HistoryService {
           continue;
         }
         if (!inspection.exists) {
-          upsertMoviePath({
+          // Output candidates must stay file-based only. Missing paths are not actionable.
-            path: row.path,
-            exists: false,
-            isDirectory: false,
-            isFile: true,
-            jobIds: Array.from(row.jobIds),
-            sources
-          });
           continue;
         }
         if (inspection.isDirectory) {
@@ -6710,6 +7052,11 @@ class HistoryService {
 
   async getJobDeletePreview(jobId, options = {}) {
     const includeRelated = options?.includeRelated !== false;
+    const requestedSelectedJobIds = Array.isArray(options?.selectedJobIds)
+      ? options.selectedJobIds
+        .map((item) => normalizeJobIdValue(item))
+        .filter(Boolean)
+      : null;
     const normalizedJobId = normalizeJobIdValue(jobId);
     if (!normalizedJobId) {
       const error = new Error('Ungültige Job-ID.');
@@ -6718,20 +7065,35 @@ class HistoryService {
     }
 
     const jobs = await this._resolveRelatedJobsForDeletion(normalizedJobId, { includeRelated });
+    const allJobIds = jobs.map((job) => normalizeJobIdValue(job?.id)).filter(Boolean);
+    const allJobIdSet = new Set(allJobIds);
+    const hasExplicitSelectedJobIds = Array.isArray(requestedSelectedJobIds);
+    const effectiveSelectedJobIds = includeRelated
+      ? (hasExplicitSelectedJobIds
+        ? requestedSelectedJobIds.filter((id) => allJobIdSet.has(id))
+        : allJobIds)
+      : [normalizedJobId];
+    const effectiveSelectedJobIdSet = new Set(effectiveSelectedJobIds);
+    const selectedJobs = jobs.filter((job) => effectiveSelectedJobIdSet.has(normalizeJobIdValue(job?.id)));
+
     const settings = await settingsService.getSettingsMap();
-    const relatedJobIds = jobs.map((job) => normalizeJobIdValue(job?.id)).filter(Boolean);
+    const relatedJobIds = selectedJobs.map((job) => normalizeJobIdValue(job?.id)).filter(Boolean);
-    const [lineageArtifactsByJobId, outputFoldersByJobId] = await Promise.all([
+    const [lineageArtifactsByJobId, outputFoldersByJobId] = relatedJobIds.length > 0
+      ? await Promise.all([
         this.listJobLineageArtifactsByJobIds(relatedJobIds),
         this.listJobOutputFoldersByJobIds(relatedJobIds)
-    ]);
+      ])
+      : [new Map(), new Map()];
     const preview = this._buildDeletePreviewFromJobs(
-      jobs,
+      selectedJobs,
       settings,
       lineageArtifactsByJobId,
       outputFoldersByJobId
     );
     const relatedJobs = jobs.map((job) => {
       const mkInfo = parseJsonSafe(job?.makemkv_info_json, {});
+      const roleMeta = resolveDeletePreviewRole(job);
+      const id = normalizeJobIdValue(job?.id);
       return {
         id: Number(job.id),
         parentJobId: normalizeJobIdValue(job.parent_job_id),
@@ -6739,17 +7101,23 @@ class HistoryService {
         status: String(job.status || '').trim() || null,
         discDevice: String(job.disc_device || '').trim() || null,
         isPrimary: Number(job.id) === normalizedJobId,
+        selected: Boolean(id && effectiveSelectedJobIdSet.has(id)),
+        roleKey: roleMeta.roleKey,
+        roleLabel: roleMeta.roleLabel,
         createdAt: String(job.created_at || '').trim() || null,
         orphanRawImport: isOrphanRawImportMakemkvInfo(mkInfo)
       };
     });
-    const orphanRawImportJobs = relatedJobs.filter((row) => Boolean(row?.orphanRawImport)).length;
+    const orphanRawImportJobs = relatedJobs.filter(
+      (row) => Boolean(row?.selected) && Boolean(row?.orphanRawImport)
+    ).length;
     const existingRawCandidates = preview.pathCandidates.raw.filter((row) => row.exists).length;
     const existingMovieCandidates = preview.pathCandidates.movie.filter((row) => row.exists).length;
 
     return {
       jobId: normalizedJobId,
       includeRelated,
+      selectedJobIds: effectiveSelectedJobIds,
       relatedJobs,
       pathCandidates: preview.pathCandidates,
       protectedRoots: preview.protectedRoots,
@@ -6758,6 +7126,7 @@ class HistoryService {
       },
       counts: {
         relatedJobs: relatedJobs.length,
+        selectedJobs: effectiveSelectedJobIds.length,
         orphanRawImportJobs,
         rawCandidates: preview.pathCandidates.raw.length,
         movieCandidates: preview.pathCandidates.movie.length,
@@ -6976,6 +7345,11 @@ class HistoryService {
     }
 
     const includeRelated = Boolean(options?.includeRelated);
+    const selectedJobIds = Array.isArray(options?.selectedJobIds)
+      ? options.selectedJobIds
+        .map((item) => normalizeJobIdValue(item))
+        .filter(Boolean)
+      : null;
     const selectedRawPaths = Array.isArray(options?.selectedRawPaths)
       ? options.selectedRawPaths
         .map((item) => String(item || '').trim())
@@ -6987,13 +7361,19 @@ class HistoryService {
         .filter(Boolean)
       : null;
 
-    if (includeRelated || (selectedRawPaths && selectedRawPaths.length > 0) || (selectedMoviePaths && selectedMoviePaths.length > 0)) {
+    const hasSelectedJobFilter = Array.isArray(options?.selectedJobIds);
+    if (
+      includeRelated
+      || hasSelectedJobFilter
+      || (selectedRawPaths && selectedRawPaths.length > 0)
+      || (selectedMoviePaths && selectedMoviePaths.length > 0)
+    ) {
       const normalizedJobId = normalizeJobIdValue(jobId);
-      const preview = await this.getJobDeletePreview(normalizedJobId, { includeRelated });
+      const preview = await this.getJobDeletePreview(normalizedJobId, { includeRelated, selectedJobIds });
       const summary = this._deletePathsFromPreview(preview, target, { selectedRawPaths, selectedMoviePaths });
       const relatedJobIds = Array.from(new Set(
-        (Array.isArray(preview?.relatedJobs) ? preview.relatedJobs : [])
+        (Array.isArray(preview?.selectedJobIds) ? preview.selectedJobIds : [])
-          .map((row) => normalizeJobIdValue(row?.id))
+          .map((row) => normalizeJobIdValue(row))
           .filter(Boolean)
       ));
 
@@ -7011,6 +7391,7 @@ class HistoryService {
       logger.info('job:delete-files', {
         jobId: normalizedJobId,
         includeRelated,
+        selectedJobIdCount: selectedJobIds ? selectedJobIds.length : 0,
         selectedRawPathCount: selectedRawPaths ? selectedRawPaths.length : 0,
         selectedMoviePathCount: selectedMoviePaths ? selectedMoviePaths.length : 0,
         summary
@@ -7782,6 +8163,11 @@ class HistoryService {
         .map((item) => String(item || '').trim())
         .filter(Boolean)
       : null;
+    const normalizedSelectedJobIds = Array.isArray(options?.selectedJobIds)
+      ? options.selectedJobIds
+        .map((item) => normalizeJobIdValue(item))
+        .filter(Boolean)
+      : null;
 
     const includeRelated = Boolean(options?.includeRelated);
     if (!includeRelated) {
@@ -7933,14 +8319,18 @@ class HistoryService {
     const resolved = await this.getJobByIdOrReplacement(jobId);
     const existing = resolved?.job || null;
     const normalizedJobId = normalizeJobIdValue(resolved?.resolvedJobId || jobId);
-    const preview = await this.getJobDeletePreview(normalizedJobId, { includeRelated: true });
+    const preview = await this.getJobDeletePreview(normalizedJobId, {
-    let deleteJobIds = Array.isArray(preview?.relatedJobs)
+      includeRelated: true,
-      ? preview.relatedJobs
+      selectedJobIds: normalizedSelectedJobIds
-        .map((row) => normalizeJobIdValue(row?.id))
+    });
+    let deleteJobIds = Array.isArray(preview?.selectedJobIds)
+      ? preview.selectedJobIds
+        .map((row) => normalizeJobIdValue(row))
         .filter(Boolean)
       : [];
     let rowById = new Map();
-    if (normalizedJobId && !deleteJobIds.includes(normalizedJobId)) {
+    const hasExplicitSelectedJobFilter = Array.isArray(normalizedSelectedJobIds);
+    if (!hasExplicitSelectedJobFilter && normalizedJobId && !deleteJobIds.includes(normalizedJobId)) {
       deleteJobIds = [...deleteJobIds, normalizedJobId];
     }
     if (deleteJobIds.length > 0) {

backend/src/services/logger.js

@@ -11,6 +11,23 @@ const LEVELS = {
 };
 
 const ACTIVE_LEVEL = LEVELS[String(logLevel || 'info').toLowerCase()] || LEVELS.info;
+let consoleConfig = {
+  enabled: true,
+  levels: {
+    debug: true,
+    info: true,
+    warn: true,
+    error: true
+  },
+  http: true
+};
+
+function normalizeBoolean(value, fallback = true) {
+  if (value === null || value === undefined) {
+    return fallback;
+  }
+  return Boolean(value);
+}
 
 function ensureLogDir(logDirPath) {
   try {
@@ -118,6 +135,10 @@ function emit(level, scope, message, meta = null) {
   const line = safeJson(payload);
   writeLine(line);
 
+  if (!shouldEmitToConsole(normLevel, scope)) {
+    return;
+  }
+
   const print = `[${timestamp}] [${normLevel.toUpperCase()}] [${scope}] ${message}`;
   if (normLevel === 'error') {
     console.error(print, payload.meta ? payload.meta : '');
@@ -128,6 +149,24 @@ function emit(level, scope, message, meta = null) {
   }
 }
 
+function shouldEmitToConsole(level, scope) {
+  if (!consoleConfig.enabled) {
+    return false;
+  }
+
+  const normalizedLevel = String(level || 'info').toLowerCase();
+  if (consoleConfig.levels[normalizedLevel] === false) {
+    return false;
+  }
+
+  const normalizedScope = String(scope || '').trim().toUpperCase();
+  if (normalizedScope === 'HTTP' && !consoleConfig.http) {
+    return false;
+  }
+
+  return true;
+}
+
 function child(scope) {
   return {
     debug(message, meta) {
@@ -145,7 +184,55 @@ function child(scope) {
   };
 }
 
+function setConsoleOutputEnabled(enabled) {
+  consoleConfig.enabled = Boolean(enabled);
+  return consoleConfig.enabled;
+}
+
+function isConsoleOutputEnabled() {
+  return consoleConfig.enabled;
+}
+
+function configureConsoleOutput(options = {}) {
+  const opts = options && typeof options === 'object' ? options : {};
+  if (Object.prototype.hasOwnProperty.call(opts, 'enabled')) {
+    consoleConfig.enabled = normalizeBoolean(opts.enabled, true);
+  }
+
+  if (opts.levels && typeof opts.levels === 'object') {
+    const sourceLevels = opts.levels;
+    for (const level of Object.keys(LEVELS)) {
+      if (Object.prototype.hasOwnProperty.call(sourceLevels, level)) {
+        consoleConfig.levels[level] = normalizeBoolean(sourceLevels[level], true);
+      }
+    }
+  }
+
+  if (Object.prototype.hasOwnProperty.call(opts, 'http')) {
+    consoleConfig.http = normalizeBoolean(opts.http, true);
+  }
+
+  return getConsoleOutputConfig();
+}
+
+function getConsoleOutputConfig() {
+  return {
+    enabled: Boolean(consoleConfig.enabled),
+    levels: {
+      debug: Boolean(consoleConfig.levels.debug),
+      info: Boolean(consoleConfig.levels.info),
+      warn: Boolean(consoleConfig.levels.warn),
+      error: Boolean(consoleConfig.levels.error)
+    },
+    http: Boolean(consoleConfig.http)
+  };
+}
+
 module.exports = {
   child,
-  emit
+  emit,
+  setConsoleOutputEnabled,
+  isConsoleOutputEnabled,
+  configureConsoleOutput,
+  getConsoleOutputConfig
 };

backend/src/services/settingsService.js

@@ -3,12 +3,14 @@ const os = require('os');
 const path = require('path');
 const { spawn, spawnSync } = require('child_process');
 const { getDb } = require('../db/database');
-const logger = require('./logger').child('SETTINGS');
+const loggerService = require('./logger');
+const logger = loggerService.child('SETTINGS');
 const {
   parseJson,
   normalizeValueByType,
   serializeValueByType,
-  validateSetting
+  validateSetting,
+  toBoolean
 } = require('../utils/validators');
 const { splitArgs } = require('../utils/commandLine');
 const { setLogRootDir } = require('./logPathService');
@@ -59,6 +61,20 @@ const SUBTITLE_SELECTION_KEYS_FLAG_ONLY = new Set(['--all-subtitles', '--first-s
 const SUBTITLE_FLAG_KEYS_WITH_VALUE = new Set(['--subtitle-burned', '--subtitle-default', '--subtitle-forced']);
 const TITLE_SELECTION_KEYS_WITH_VALUE = new Set(['-t', '--title']);
 const LOG_DIR_SETTING_KEY = 'log_dir';
+const SERVER_CONSOLE_LOG_OUTPUT_ENABLED_KEY = 'server_console_log_output_enabled';
+const SERVER_CONSOLE_LOG_HTTP_ENABLED_KEY = 'server_console_log_http_enabled';
+const SERVER_CONSOLE_LOG_DEBUG_ENABLED_KEY = 'server_console_log_debug_enabled';
+const SERVER_CONSOLE_LOG_INFO_ENABLED_KEY = 'server_console_log_info_enabled';
+const SERVER_CONSOLE_LOG_WARN_ENABLED_KEY = 'server_console_log_warn_enabled';
+const SERVER_CONSOLE_LOG_ERROR_ENABLED_KEY = 'server_console_log_error_enabled';
+const SERVER_CONSOLE_LOG_SETTING_KEYS = new Set([
+  SERVER_CONSOLE_LOG_OUTPUT_ENABLED_KEY,
+  SERVER_CONSOLE_LOG_HTTP_ENABLED_KEY,
+  SERVER_CONSOLE_LOG_DEBUG_ENABLED_KEY,
+  SERVER_CONSOLE_LOG_INFO_ENABLED_KEY,
+  SERVER_CONSOLE_LOG_WARN_ENABLED_KEY,
+  SERVER_CONSOLE_LOG_ERROR_ENABLED_KEY
+]);
 const MEDIA_PROFILES = ['bluray', 'dvd', 'cd', 'audiobook'];
 const PROFILED_SETTINGS = {
   raw_dir: {
@@ -168,6 +184,35 @@ function applyRuntimeLogDirSetting(rawValue) {
   }
 }
 
+function normalizeBooleanSetting(rawValue, fallback = true) {
+  const normalizedRaw = typeof rawValue === 'string' ? rawValue.trim() : rawValue;
+  if (normalizedRaw === null || normalizedRaw === undefined || normalizedRaw === '') {
+    return fallback;
+  }
+  return toBoolean(normalizedRaw);
+}
+
+function applyRuntimeServerConsoleLoggingSettingsFromMap(settingsMap = {}) {
+  const source = settingsMap && typeof settingsMap === 'object' ? settingsMap : {};
+  const enabled = normalizeBooleanSetting(source[SERVER_CONSOLE_LOG_OUTPUT_ENABLED_KEY], true);
+  const http = normalizeBooleanSetting(source[SERVER_CONSOLE_LOG_HTTP_ENABLED_KEY], true);
+  const debug = normalizeBooleanSetting(source[SERVER_CONSOLE_LOG_DEBUG_ENABLED_KEY], true);
+  const info = normalizeBooleanSetting(source[SERVER_CONSOLE_LOG_INFO_ENABLED_KEY], true);
+  const warn = normalizeBooleanSetting(source[SERVER_CONSOLE_LOG_WARN_ENABLED_KEY], true);
+  const error = normalizeBooleanSetting(source[SERVER_CONSOLE_LOG_ERROR_ENABLED_KEY], true);
+  const applied = loggerService.configureConsoleOutput({
+    enabled,
+    http,
+    levels: {
+      debug,
+      info,
+      warn,
+      error
+    }
+  });
+  return applied;
+}
+
 function isImmutableSettingKey(key) {
   return IMMUTABLE_SETTING_KEYS.has(String(key || '').trim().toLowerCase());
 }
@@ -814,6 +859,21 @@ class SettingsService {
     return { ...(snapshot?.map || {}) };
   }
 
+  applyRuntimeSettingsFromMap(settingsMap = {}) {
+    const source = settingsMap && typeof settingsMap === 'object' ? settingsMap : {};
+    const logDir = applyRuntimeLogDirSetting(source[LOG_DIR_SETTING_KEY]);
+    const consoleLogConfig = applyRuntimeServerConsoleLoggingSettingsFromMap(source);
+    return {
+      logDir,
+      serverConsoleLogConfig: consoleLogConfig
+    };
+  }
+
+  async applyRuntimeSettings() {
+    const map = await this.getSettingsMap();
+    return this.applyRuntimeSettingsFromMap(map);
+  }
+
   normalizeMediaProfile(value) {
     return normalizeMediaProfileValue(value);
   }
@@ -1014,6 +1074,10 @@ class SettingsService {
     if (String(key || '').trim().toLowerCase() === LOG_DIR_SETTING_KEY) {
       applyRuntimeLogDirSetting(result.normalized);
     }
+    if (SERVER_CONSOLE_LOG_SETTING_KEYS.has(String(key || '').trim().toLowerCase())) {
+      const map = await this.getSettingsMap({ forceRefresh: true });
+      applyRuntimeServerConsoleLoggingSettingsFromMap(map);
+    }
     this.invalidateSettingsCache([key]);
 
     return {
@@ -1107,6 +1171,13 @@ class SettingsService {
     if (logDirChange) {
       applyRuntimeLogDirSetting(logDirChange.value);
     }
+    const consoleOutputChange = normalizedEntries.find(
+      (item) => SERVER_CONSOLE_LOG_SETTING_KEYS.has(String(item?.key || '').trim().toLowerCase())
+    );
+    if (consoleOutputChange) {
+      const map = await this.getSettingsMap({ forceRefresh: true });
+      applyRuntimeServerConsoleLoggingSettingsFromMap(map);
+    }
 
     this.invalidateSettingsCache(normalizedEntries.map((item) => item.key));
     logger.info('settings:bulk-updated', { count: normalizedEntries.length });

db/schema.sql

@@ -366,6 +366,31 @@ INSERT OR IGNORE INTO settings_schema (key, category, label, type, required, des
 VALUES ('hardware_monitoring_interval_ms', 'Monitoring', 'Hardware Monitoring Intervall (ms)', 'number', 1, 'Polling-Intervall für CPU/RAM/GPU/Storage-Metriken.', '5000', '[]', '{"min":1000,"max":60000}', 140);
 INSERT OR IGNORE INTO settings_values (key, value) VALUES ('hardware_monitoring_interval_ms', '5000');
 
+-- Logging
+INSERT OR IGNORE INTO settings_schema (key, category, label, type, required, description, default_value, options_json, validation_json, order_index)
+VALUES ('server_console_log_output_enabled', 'Logging', 'Terminal-Ausgabe aktiv', 'boolean', 1, 'Master-Schalter für die Ausgabe der Server-Logs im Terminal (z.B. start.sh). Das Schreiben in Log-Dateien bleibt immer aktiv.', 'true', '[]', '{}', 150);
+INSERT OR IGNORE INTO settings_values (key, value) VALUES ('server_console_log_output_enabled', 'true');
+
+INSERT OR IGNORE INTO settings_schema (key, category, label, type, required, description, default_value, options_json, validation_json, order_index)
+VALUES ('server_console_log_http_enabled', 'Logging', 'HTTP-Logs im Terminal', 'boolean', 1, 'Steuert HTTP Request-Logs im Terminal (z.B. request:start). Dateilogs bleiben unverändert.', 'true', '[]', '{}', 151);
+INSERT OR IGNORE INTO settings_values (key, value) VALUES ('server_console_log_http_enabled', 'true');
+
+INSERT OR IGNORE INTO settings_schema (key, category, label, type, required, description, default_value, options_json, validation_json, order_index)
+VALUES ('server_console_log_debug_enabled', 'Logging', 'DEBUG im Terminal', 'boolean', 1, 'Steuert DEBUG-Meldungen in der Terminal-Ausgabe. Dateilogs bleiben unverändert.', 'true', '[]', '{}', 152);
+INSERT OR IGNORE INTO settings_values (key, value) VALUES ('server_console_log_debug_enabled', 'true');
+
+INSERT OR IGNORE INTO settings_schema (key, category, label, type, required, description, default_value, options_json, validation_json, order_index)
+VALUES ('server_console_log_info_enabled', 'Logging', 'INFO im Terminal', 'boolean', 1, 'Steuert INFO-Meldungen in der Terminal-Ausgabe. Dateilogs bleiben unverändert.', 'true', '[]', '{}', 153);
+INSERT OR IGNORE INTO settings_values (key, value) VALUES ('server_console_log_info_enabled', 'true');
+
+INSERT OR IGNORE INTO settings_schema (key, category, label, type, required, description, default_value, options_json, validation_json, order_index)
+VALUES ('server_console_log_warn_enabled', 'Logging', 'WARN im Terminal', 'boolean', 1, 'Steuert WARN-Meldungen in der Terminal-Ausgabe. Dateilogs bleiben unverändert.', 'true', '[]', '{}', 154);
+INSERT OR IGNORE INTO settings_values (key, value) VALUES ('server_console_log_warn_enabled', 'true');
+
+INSERT OR IGNORE INTO settings_schema (key, category, label, type, required, description, default_value, options_json, validation_json, order_index)
+VALUES ('server_console_log_error_enabled', 'Logging', 'ERROR im Terminal', 'boolean', 1, 'Steuert ERROR-Meldungen in der Terminal-Ausgabe. Dateilogs bleiben unverändert.', 'true', '[]', '{}', 155);
+INSERT OR IGNORE INTO settings_values (key, value) VALUES ('server_console_log_error_enabled', 'true');
+
 -- Tools
 INSERT OR IGNORE INTO settings_schema (key, category, label, type, required, description, default_value, options_json, validation_json, order_index)
 VALUES ('makemkv_command', 'Tools', 'MakeMKV Kommando', 'string', 1, 'Pfad oder Befehl für makemkvcon.', 'makemkvcon', '[]', '{"minLength":1}', 200);
@@ -391,6 +416,10 @@ INSERT OR IGNORE INTO settings_schema (key, category, label, type, required, des
 VALUES ('handbrake_restart_delete_incomplete_output', 'Tools', 'Encode-Neustart: unvollständige Ausgabe löschen', 'boolean', 1, 'Wenn aktiv, wird bei "Encode neu starten" der bisherige (nicht erfolgreiche) Output vor Start entfernt.', 'true', '[]', '{}', 220);
 INSERT OR IGNORE INTO settings_values (key, value) VALUES ('handbrake_restart_delete_incomplete_output', 'true');
 
+INSERT OR IGNORE INTO settings_schema (key, category, label, type, required, description, default_value, options_json, validation_json, order_index)
+VALUES ('handbrake_pre_metadata_scan_enabled', 'Tools', 'Vorab-HandBrake-Scan vor Metadaten', 'boolean', 1, 'Wenn deaktiviert, wird der erste HandBrake-Scan vor der Metadatenauswahl übersprungen.', 'true', '[]', '{}', 221);
+INSERT OR IGNORE INTO settings_values (key, value) VALUES ('handbrake_pre_metadata_scan_enabled', 'true');
+
 INSERT OR IGNORE INTO settings_schema (key, category, label, type, required, description, default_value, options_json, validation_json, order_index)
 VALUES ('pipeline_max_parallel_jobs', 'Tools', 'Max. parallele Film/Video Encodes', 'number', 1, 'Maximale Anzahl parallel laufender Film/Video Encode-Jobs. Gilt zusätzlich zum Gesamtlimit.', '1', '[]', '{"min":1,"max":12}', 225);
 INSERT OR IGNORE INTO settings_values (key, value) VALUES ('pipeline_max_parallel_jobs', '1');
@@ -613,6 +642,10 @@ INSERT OR IGNORE INTO settings_schema (key, category, label, type, required, des
 VALUES ('coverart_recovery_interval_hours', 'Metadaten', 'Coverart-Prüfintervall (Stunden)', 'number', 1, 'Intervall für automatische Prüfung fehlender Coverarts in Stunden.', '6', '[]', '{"min":1,"max":168}', 431);
 INSERT OR IGNORE INTO settings_values (key, value) VALUES ('coverart_recovery_interval_hours', '6');
 
+INSERT OR IGNORE INTO settings_schema (key, category, label, type, required, description, default_value, options_json, validation_json, order_index)
+VALUES ('generate_nfo_after_encode', 'Metadaten', 'NFO nach Encode erzeugen', 'boolean', 1, 'Erstellt nach erfolgreichem Encode automatisch eine .nfo-Datei neben der Ausgabedatei.', 'false', '[]', '{}', 432);
+INSERT OR IGNORE INTO settings_values (key, value) VALUES ('generate_nfo_after_encode', 'false');
+
 -- Benachrichtigungen
 INSERT OR IGNORE INTO settings_schema (key, category, label, type, required, description, default_value, options_json, validation_json, order_index)
 VALUES ('ui_expert_mode', 'Benachrichtigungen', 'Expertenmodus', 'boolean', 1, 'Schaltet erweiterte Einstellungen in der UI ein.', 'false', '[]', '{}', 495);

frontend/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "ripster-frontend",
-  "version": "0.15.0-3",
+  "version": "0.16.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "ripster-frontend",
-      "version": "0.15.0-3",
+      "version": "0.16.0",
       "dependencies": {
         "primeicons": "^7.0.0",
         "primereact": "^10.9.2",

frontend/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ripster-frontend",
-  "version": "0.15.0-3",
+  "version": "0.16.0",
   "private": true,
   "type": "module",
   "scripts": {

frontend/src/api/client.js

@@ -836,8 +836,21 @@ export const api = {
     afterMutationInvalidate(['/history']);
     return result;
   },
+  async generateJobNfo(jobId) {
+    const result = await request(`/history/${jobId}/nfo/generate`, {
+      method: 'POST'
+    });
+    afterMutationInvalidate(['/history']);
+    return result;
+  },
   async deleteJobFiles(jobId, target = 'both', options = {}) {
     const includeRelated = Boolean(options?.includeRelated);
+    const selectedJobIds = Array.isArray(options?.selectedJobIds)
+      ? options.selectedJobIds
+        .map((item) => Number(item))
+        .filter((value) => Number.isFinite(value) && value > 0)
+        .map((value) => Math.trunc(value))
+      : null;
     const selectedRawPaths = Array.isArray(options?.selectedRawPaths)
       ? options.selectedRawPaths
         .map((item) => String(item || '').trim())
@@ -853,6 +866,7 @@ export const api = {
       body: JSON.stringify({
         target,
         includeRelated,
+        ...(selectedJobIds ? { selectedJobIds } : {}),
         ...(selectedRawPaths ? { selectedRawPaths } : {}),
         ...(selectedMoviePaths ? { selectedMoviePaths } : {})
       })
@@ -862,14 +876,29 @@ export const api = {
   },
   getJobDeletePreview(jobId, options = {}) {
     const includeRelated = options?.includeRelated !== false;
+    const selectedJobIds = Array.isArray(options?.selectedJobIds)
+      ? options.selectedJobIds
+        .map((item) => Number(item))
+        .filter((value) => Number.isFinite(value) && value > 0)
+        .map((value) => Math.trunc(value))
+      : null;
     const query = new URLSearchParams();
     query.set('includeRelated', includeRelated ? '1' : '0');
+    if (selectedJobIds) {
+      query.set('selectedJobIds', selectedJobIds.join(','));
+    }
     return request(`/history/${jobId}/delete-preview?${query.toString()}`);
   },
   async deleteJobEntry(jobId, target = 'none', options = {}) {
     const includeRelated = Boolean(options?.includeRelated);
     const resetDriveState = Boolean(options?.resetDriveState);
     const preserveRawForImportJobs = Boolean(options?.preserveRawForImportJobs);
+    const selectedJobIds = Array.isArray(options?.selectedJobIds)
+      ? options.selectedJobIds
+        .map((item) => Number(item))
+        .filter((value) => Number.isFinite(value) && value > 0)
+        .map((value) => Math.trunc(value))
+      : null;
     const selectedRawPaths = Array.isArray(options?.selectedRawPaths)
       ? options.selectedRawPaths
         .map((item) => String(item || '').trim())
@@ -891,6 +920,7 @@ export const api = {
         includeRelated,
         resetDriveState,
         preserveRawForImportJobs,
+        ...(selectedJobIds ? { selectedJobIds } : {}),
         ...(hasKeepDetectedDevice ? { keepDetectedDevice } : {}),
         ...(selectedRawPaths ? { selectedRawPaths } : {}),
         ...(selectedMoviePaths ? { selectedMoviePaths } : {})

frontend/src/components/DynamicSettingsForm.jsx

@@ -28,6 +28,7 @@ const GENERAL_TOOL_KEYS = new Set([
   'mkvmerge_command',
   'ffprobe_command',
   'handbrake_restart_delete_incomplete_output',
+  'handbrake_pre_metadata_scan_enabled',
   'script_test_timeout_ms'
 ]);
 

frontend/src/components/JobDetailDialog.jsx

@@ -1060,6 +1060,7 @@ export default function JobDetailDialog({
   logLoadingMode = null,
   onAssignOmdb,
   onAssignCdMetadata,
+  onGenerateNfo,
   onAcknowledgeError,
   onResumeReady,
   onRestartEncode,
@@ -1078,6 +1079,7 @@ export default function JobDetailDialog({
   omdbAssignBusy = false,
   cdMetadataAssignBusy = false,
   acknowledgeErrorBusy = false,
+  generateNfoBusy = false,
   actionBusy = false,
   cancelBusy = false,
   reencodeBusy = false,
@@ -1088,6 +1090,8 @@ export default function JobDetailDialog({
 }) {
   const mkDone = Boolean(job?.ripSuccessful) || !job?.makemkvInfo || job?.makemkvInfo?.status === 'SUCCESS';
   const statusUpper = String(job?.status || '').trim().toUpperCase();
+  const lastStateUpper = String(job?.last_state || '').trim().toUpperCase();
+  const errorMessageLower = String(job?.error_message || '').trim().toLowerCase();
   const running = ['ANALYZING', 'RIPPING', 'MEDIAINFO_CHECK', 'ENCODING', 'CD_RIPPING', 'CD_ENCODING'].includes(statusUpper);
   const softCancelable = ['READY_TO_START', 'READY_TO_ENCODE', 'METADATA_SELECTION', 'WAITING_FOR_USER_DECISION', 'CD_METADATA_SELECTION', 'CD_READY_TO_RIP'].includes(statusUpper);
   const showCancelAction = (running || softCancelable) && typeof onCancel === 'function';
@@ -1123,6 +1127,22 @@ export default function JobDetailDialog({
   const isCd = mediaType === 'cd';
   const isAudiobook = mediaType === 'audiobook';
   const isConverter = mediaType === 'converter';
+  const retryRipRecoveryReason = (
+    errorMessageLower.includes('server-neustart')
+    || errorMessageLower.includes('rip ist unvollständig')
+    || errorMessageLower.includes('rip-validierung fehlgeschlagen')
+  );
+  const retryRipRequired = Boolean(
+    !running
+    && !isAudiobook
+    && !isConverter
+    && ['ERROR', 'CANCELLED'].includes(statusUpper)
+    && (
+      ['RIPPING', 'CD_RIPPING'].includes(lastStateUpper)
+      || retryRipRecoveryReason
+    )
+  );
+  const blockMetadataAndReviewUntilRetry = retryRipRequired;
   const converterMediaType = isConverter ? (resolveConverterMediaType(job) || 'video') : null;
   const converterMediaTypeLabel = converterMediaType === 'audio'
     ? 'Audio'
@@ -1215,6 +1235,7 @@ export default function JobDetailDialog({
     && job?.rawStatus?.isEmpty !== true
     && !running
     && mediaType !== 'audiobook'
+    && !blockMetadataAndReviewUntilRetry
     && typeof onRestartReview === 'function'
   );
   const converterPlan = isConverter && job?.encodePlan && typeof job.encodePlan === 'object'
@@ -1271,6 +1292,14 @@ export default function JobDetailDialog({
     })()
     : null;
   const canDeleteEntry = !running && typeof onDeleteEntry === 'function';
+  const nfoStatus = job?.nfoStatus && typeof job.nfoStatus === 'object'
+    ? job.nfoStatus
+    : {};
+  const canGenerateNfo = Boolean(
+    !running
+    && typeof onGenerateNfo === 'function'
+    && nfoStatus?.canGenerateManual
+  );
   const queueLocked = Boolean(isQueued && job?.id);
   const logCount = Number(job?.log_count || 0);
   const logMeta = job?.logMeta && typeof job.logMeta === 'object' ? job.logMeta : null;
@@ -1278,7 +1307,7 @@ export default function JobDetailDialog({
   const logTruncated = Boolean(logMeta?.truncated);
   const cdDetails = isCd ? resolveCdDetails(job) : null;
   const audiobookDetails = isAudiobook ? resolveAudiobookDetails(job) : null;
-  const canRetry = isCd && !running && typeof onRetry === 'function';
+  const canRetry = !running && typeof onRetry === 'function' && (isCd || retryRipRequired);
   const mediaTypeLabel = mediaType === 'bluray'
     ? (isDvdSeries ? 'Blu-ray Serie' : 'Blu-ray')
     : mediaType === 'dvd'
@@ -1516,6 +1545,7 @@ export default function JobDetailDialog({
   const resolveChildActionState = (child) => {
     const childStatusUpper = String(child?.status || '').trim().toUpperCase();
     const childLastStateUpper = String(child?.last_state || '').trim().toUpperCase();
+    const childErrorMessageLower = String(child?.error_message || '').trim().toLowerCase();
     const childRunning = ['ANALYZING', 'RIPPING', 'MEDIAINFO_CHECK', 'ENCODING', 'CD_RIPPING', 'CD_ENCODING'].includes(childStatusUpper);
     const childCanResumeReady = Boolean(
       (childStatusUpper === 'READY_TO_ENCODE' || childLastStateUpper === 'READY_TO_ENCODE')
@@ -1537,14 +1567,31 @@ export default function JobDetailDialog({
     const childHasRestartInput = Boolean(child?.encode_input_path || child?.raw_path || child?.encodePlan?.encodeInputPath);
     const childHasRaw = Boolean(child?.rawStatus?.exists || child?.raw_path || child?.encode_input_path);
     const childCanRestartEncode = Boolean(childHasConfirmedPlan && childHasRestartInput && !childRunning && childHasRaw);
+    const childRetryRipRecoveryReason = (
+      childErrorMessageLower.includes('server-neustart')
+      || childErrorMessageLower.includes('rip ist unvollständig')
+      || childErrorMessageLower.includes('rip-validierung fehlgeschlagen')
+    );
+    const childRetryRipRequired = Boolean(
+      !childRunning
+      && childMediaType !== 'audiobook'
+      && childMediaType !== 'converter'
+      && ['ERROR', 'CANCELLED'].includes(childStatusUpper)
+      && (
+        ['RIPPING', 'CD_RIPPING'].includes(childLastStateUpper)
+        || childRetryRipRecoveryReason
+      )
+    );
     const childCanRestartReview = Boolean(
       child?.rawStatus?.exists
       && child?.rawStatus?.isEmpty !== true
       && !childRunning
       && childMediaType !== 'audiobook'
+      && !childRetryRipRequired
       && typeof onRestartReview === 'function'
     );
-    const childCanAssignMetadata = !childRunning;
+    const childCanAssignMetadata = !childRunning && !childRetryRipRequired;
+    const childCanRetry = !childRunning && typeof onRetry === 'function' && (childMediaType === 'cd' || childRetryRipRequired);
     const childOutputFolders = Array.isArray(child?.outputFolders) ? child.outputFolders : [];
     const childSeriesOutputExisting = Number(child?.seriesOutputSummary?.existing || 0);
     const childHasAnyOutput = childOutputFolders.length > 0
@@ -1557,6 +1604,8 @@ export default function JobDetailDialog({
       childCanRestartEncode,
       childCanRestartReview,
       childCanAssignMetadata,
+      childCanRetry,
+      childRetryRipRequired,
       childHasRaw,
       childHasAnyOutput
     };
@@ -2544,7 +2593,24 @@ export default function JobDetailDialog({
                           </div>
                         ) : null}
 
-                        {!isCd && !isAudiobook && !isConverter && typeof onAssignOmdb === 'function' ? (
+                        {childActionState.childCanRetry ? (
+                          <div className="actions-group">
+                            <div className="actions-group-label"><i className="pi pi-refresh" /> Recovery</div>
+                            <div className="action-item">
+                              <Button
+                                label="Retry Rip"
+                                icon="pi pi-refresh"
+                                severity="warning"
+                                size="small"
+                                onClick={() => onRetry?.(child)}
+                                loading={actionBusy}
+                              />
+                              <span className="action-desc">Löscht das alte RAW und startet den Rip erneut.</span>
+                            </div>
+                          </div>
+                        ) : null}
+
+                        {!isCd && !isAudiobook && !isConverter && !childActionState.childRetryRipRequired && typeof onAssignOmdb === 'function' ? (
                           <div className="actions-group">
                             <div className="actions-group-label"><i className="pi pi-search" /> Metadaten</div>
                             <div className="action-item">
@@ -2938,7 +3004,28 @@ export default function JobDetailDialog({
                 ) : null
               )}
 
-              {!isCd && !isAudiobook && !isConverter && typeof onAssignOmdb === 'function' ? (
+              {canRetry ? (
+                <div className="actions-group">
+                  <div className="actions-group-label"><i className="pi pi-refresh" /> Recovery</div>
+                  <div className="action-item">
+                    <Button
+                      label={isCd ? 'CD-Rip neu starten' : 'Retry Rip'}
+                      icon="pi pi-refresh"
+                      severity="warning"
+                      size="small"
+                      onClick={() => onRetry?.(job)}
+                      loading={actionBusy}
+                    />
+                    <span className="action-desc">
+                      {isCd
+                        ? 'Startet den CD-Rip neu.'
+                        : 'Löscht das alte RAW und startet den Rip erneut.'}
+                    </span>
+                  </div>
+                </div>
+              ) : null}
+
+              {!isCd && !isAudiobook && !isConverter && !blockMetadataAndReviewUntilRetry && typeof onAssignOmdb === 'function' ? (
                 <div className="actions-group">
                   <div className="actions-group-label"><i className="pi pi-search" /> Metadaten</div>
                   <div className="action-item">
@@ -2957,6 +3044,25 @@ export default function JobDetailDialog({
                 </div>
               ) : null}
 
+              {canGenerateNfo ? (
+                <div className="actions-group">
+                  <div className="actions-group-label"><i className="pi pi-file" /> NFO</div>
+                  <div className="action-item">
+                    <Button
+                      label="NFO erzeugen"
+                      icon="pi pi-file-edit"
+                      severity="info"
+                      outlined
+                      size="small"
+                      onClick={() => onGenerateNfo?.(job)}
+                      loading={generateNfoBusy}
+                      disabled={actionBusy}
+                    />
+                    <span className="action-desc">Erstellt eine .nfo-Datei neben der Output-Datei (manuell aus der Historie).</span>
+                  </div>
+                </div>
+              ) : null}
+
               {typeof onDeleteFiles === 'function' ? (
                 <div className="actions-group">
                   <div className="actions-group-label"><i className="pi pi-trash" /> Dateien löschen</div>

frontend/src/components/MetadataSelectionDialog.jsx

@@ -14,6 +14,84 @@ export default function MetadataSelectionDialog({
   onSearch,
   busy
 }) {
+  const toSearchTitleCase = (value) => String(value || '')
+    .toLowerCase()
+    .replace(/\b([a-z\u00c0-\u024f])([a-z\u00c0-\u024f0-9']*)/g, (_match, first, rest) => (
+      `${first.toUpperCase()}${rest}`
+    ));
+  const stripTrailingDiscHint = (value) => {
+    let working = String(value || '').trim();
+    if (!working) {
+      return '';
+    }
+    const patterns = [
+      /\b(?:disc|disk|dvd|bd|br|cd|part|pt|vol|volume|season|staffel|episode|ep)\s*(?:\d{1,3}|[ivxlcdm]{1,8})\b$/i,
+      /\b(?:[a-z]{1,3}\d{1,4}|\d{1,4}[a-z]{1,3})\b$/i
+    ];
+    for (let i = 0; i < 4; i += 1) {
+      const before = working;
+      for (const pattern of patterns) {
+        working = working.replace(pattern, '').trim();
+      }
+      working = working.replace(/[-_.,;:]+$/g, '').trim();
+      if (working === before || !working) {
+        break;
+      }
+    }
+    return working;
+  };
+  const buildSearchVariants = (rawValue) => {
+    const raw = String(rawValue || '').trim();
+    if (!raw) {
+      return [];
+    }
+    if (/^tt\d{6,12}$/i.test(raw)) {
+      return [raw.toLowerCase()];
+    }
+    const variants = [];
+    const pushUnique = (candidate) => {
+      const normalized = String(candidate || '').replace(/\s+/g, ' ').trim();
+      if (!normalized) {
+        return;
+      }
+      if (!variants.some((entry) => entry.toLowerCase() === normalized.toLowerCase())) {
+        variants.push(normalized);
+      }
+    };
+    const separatorNormalized = raw
+      .replace(/[_]+/g, ' ')
+      .replace(/[.]+/g, ' ')
+      .replace(/\s+/g, ' ')
+      .trim();
+    const punctuationReduced = separatorNormalized
+      .replace(/[|/\\]+/g, ' ')
+      .replace(/\s+/g, ' ')
+      .trim();
+    const stripped = stripTrailingDiscHint(punctuationReduced);
+
+    pushUnique(raw);
+    pushUnique(separatorNormalized);
+    pushUnique(punctuationReduced);
+    pushUnique(toSearchTitleCase(separatorNormalized));
+    pushUnique(stripped);
+    pushUnique(toSearchTitleCase(stripped));
+
+    return variants.slice(0, 6);
+  };
+  const normalizeDetectedTitleForMetadataInput = (rawValue) => {
+    const raw = String(rawValue || '').trim();
+    if (!raw) {
+      return '';
+    }
+    const separatorNormalized = raw
+      .replace(/[_]+/g, ' ')
+      .replace(/[.]+/g, ' ')
+      .replace(/\s+/g, ' ')
+      .trim();
+    const stripped = stripTrailingDiscHint(separatorNormalized);
+    const preferred = stripped || separatorNormalized || raw;
+    return toSearchTitleCase(preferred);
+  };
   const normalizeWorkflowKind = (value) => {
     const raw = String(value || '').trim().toLowerCase();
     if (!raw) {
@@ -56,6 +134,7 @@ export default function MetadataSelectionDialog({
   const [seasonFilter, setSeasonFilter] = useState('');
   const [discValidationError, setDiscValidationError] = useState('');
   const activeSearchRequestRef = useRef(0);
+  const autoSearchDoneRef = useRef(false);
   const contextWorkflowKind = normalizeWorkflowKind(
     context?.selectedMetadata?.workflowKind
     || context?.workflowKind
@@ -97,7 +176,8 @@ export default function MetadataSelectionDialog({
     }
 
     const selectedMetadata = context?.selectedMetadata || {};
-    const defaultTitle = selectedMetadata.title || context?.detectedTitle || '';
+    const rawDefaultTitle = selectedMetadata.title || context?.detectedTitle || '';
+    const defaultTitle = normalizeDetectedTitleForMetadataInput(rawDefaultTitle) || rawDefaultTitle;
     const defaultYear = selectedMetadata.year ? String(selectedMetadata.year) : '';
     const defaultImdb = selectedMetadata.imdbId || '';
 
@@ -119,6 +199,7 @@ export default function MetadataSelectionDialog({
     setSeasonFilter('');
     setDiscValidationError('');
     setSelectedMetadataProvider(contextMetadataProvider);
+    autoSearchDoneRef.current = false;
     activeSearchRequestRef.current += 1;
   }, [visible, context]);
 
@@ -205,19 +286,30 @@ export default function MetadataSelectionDialog({
     if (!trimmedQuery || typeof onSearch !== 'function') {
       return;
     }
+    const queryVariants = buildSearchVariants(trimmedQuery);
+    if (queryVariants.length === 0) {
+      return;
+    }
     const requestId = activeSearchRequestRef.current + 1;
     activeSearchRequestRef.current = requestId;
     setHasSearchOverride(true);
     setSearchBusy(true);
     setSearchError('');
     try {
-      const results = await onSearch(trimmedQuery, {
+      let effectiveResults = [];
+      for (const candidateQuery of queryVariants) {
+        const results = await onSearch(candidateQuery, {
           metadataProvider
         });
         if (activeSearchRequestRef.current !== requestId) {
           return;
         }
-      setExtraResults(Array.isArray(results) ? results : []);
+        if (Array.isArray(results) && results.length > 0) {
+          effectiveResults = results;
+          break;
+        }
+      }
+      setExtraResults(Array.isArray(effectiveResults) ? effectiveResults : []);
     } catch (error) {
       if (activeSearchRequestRef.current !== requestId) {
         return;
@@ -230,6 +322,22 @@ export default function MetadataSelectionDialog({
     }
   };
 
+  useEffect(() => {
+    if (!visible || autoSearchDoneRef.current) {
+      return;
+    }
+    if (typeof onSearch !== 'function') {
+      autoSearchDoneRef.current = true;
+      return;
+    }
+    const trimmedQuery = String(query || '').trim();
+    if (!trimmedQuery) {
+      return;
+    }
+    autoSearchDoneRef.current = true;
+    void handleSearch();
+  }, [visible, query, metadataProvider, onSearch]);
+
   const handleSubmitError = (error, pendingPayload = null) => {
     const details = Array.isArray(error?.details) ? error.details : [];
     const duplicateDetail = details.find(

frontend/src/components/PipelineStatusCard.jsx

@@ -581,6 +581,88 @@ function hasSeriesMetadataShape(source = null) {
   );
 }
 
+function normalizeDiscWorkflowKind(value) {
+  const raw = String(value || '').trim().toLowerCase();
+  if (!raw) {
+    return null;
+  }
+  if (['series', 'tv', 'season', 'episode', 'tv_series', 'tv-season', 'tv_season'].includes(raw)) {
+    return 'series';
+  }
+  if (['film', 'movie', 'feature'].includes(raw)) {
+    return 'film';
+  }
+  return null;
+}
+
+function resolveDiscWorkflowKind({
+  mediaProfile = null,
+  selectedMetadata = null,
+  analyzeContext = null,
+  pipelineContext = null,
+  fallbackIsSeries = false
+} = {}) {
+  const normalizedMediaProfile = String(mediaProfile || '').trim().toLowerCase();
+  if (normalizedMediaProfile !== 'dvd' && normalizedMediaProfile !== 'bluray') {
+    return null;
+  }
+  const selected = selectedMetadata && typeof selectedMetadata === 'object' ? selectedMetadata : {};
+  const analyze = analyzeContext && typeof analyzeContext === 'object' ? analyzeContext : {};
+  const pipelineCtx = pipelineContext && typeof pipelineContext === 'object' ? pipelineContext : {};
+  const workflowCandidates = [
+    selected?.workflowKind,
+    selected?.kind,
+    analyze?.workflowKind,
+    pipelineCtx?.workflowKind
+  ];
+  for (const candidate of workflowCandidates) {
+    const normalized = normalizeDiscWorkflowKind(candidate);
+    if (normalized) {
+      return normalized;
+    }
+  }
+  const metadataKindCandidates = [
+    selected?.metadataKind,
+    analyze?.metadataKind
+  ];
+  for (const candidate of metadataKindCandidates) {
+    const normalized = normalizeDiscWorkflowKind(candidate);
+    if (normalized) {
+      return normalized;
+    }
+  }
+  const providerCandidates = [
+    selected?.metadataProvider,
+    analyze?.metadataProvider,
+    pipelineCtx?.metadataProvider
+  ];
+  for (const candidate of providerCandidates) {
+    const provider = String(candidate || '').trim().toLowerCase();
+    if (!provider) {
+      continue;
+    }
+    if (provider === 'tmdb' || provider === 'themoviedb') {
+      return 'series';
+    }
+    if (provider === 'omdb') {
+      return 'film';
+    }
+  }
+  return fallbackIsSeries ? 'series' : 'film';
+}
+
+function getDiscWorkflowBadgeLabel(mediaProfile, workflowKind) {
+  const normalizedMediaProfile = String(mediaProfile || '').trim().toLowerCase();
+  if (normalizedMediaProfile !== 'dvd' && normalizedMediaProfile !== 'bluray') {
+    return null;
+  }
+  const kind = normalizeDiscWorkflowKind(workflowKind) || 'film';
+  if (normalizedMediaProfile === 'bluray') {
+    return kind === 'series' ? 'Blu-ray-Serie' : 'Blu-ray-Film';
+  }
+  return kind === 'series' ? 'DVD-Serie' : 'DVD-Film';
+}
+
 function hasSeriesEpisodeAssignmentHints(titles = []) {
   const reviewTitles = Array.isArray(titles) ? titles : [];
   return reviewTitles.some((title) => {
@@ -1496,6 +1578,13 @@ export default function PipelineStatusCard({
   ).trim().toLowerCase();
   const isOrphanImport = orphanSource === 'orphan_raw_import';
   const isOrphanCancelled = isOrphanImport && (state === 'ERROR' || state === 'CANCELLED');
+  const jobStatusUpper = String(jobRow?.status || state || '').trim().toUpperCase();
+  const jobLastStateUpper = String(jobRow?.last_state || '').trim().toUpperCase();
+  const jobErrorMessageLower = String(
+    jobRow?.error_message
+    || pipeline?.context?.errorMessage
+    || ''
+  ).trim().toLowerCase();
   const ripCompleted = Boolean(
     Number(jobRow?.rip_successful || jobRow?.ripSuccessful || pipeline?.context?.ripSuccessful || 0) === 1
     || jobRow?.raw_path
@@ -1504,12 +1593,31 @@ export default function PipelineStatusCard({
     || String(jobRow?.makemkvInfo?.status || '').trim().toUpperCase() === 'SUCCESS'
   );
   const selectedMetadata = pipeline?.context?.selectedMetadata || null;
+  const analyzeContext = jobRow?.makemkvInfo?.analyzeContext && typeof jobRow.makemkvInfo.analyzeContext === 'object'
+    ? jobRow.makemkvInfo.analyzeContext
+    : null;
   const mediaInfoReview = pipeline?.context?.mediaInfoReview || null;
   const playlistAnalysis = pipeline?.context?.playlistAnalysis || null;
   const encodeInputPath = pipeline?.context?.inputPath || mediaInfoReview?.encodeInputPath || null;
   const reviewMode = String(mediaInfoReview?.mode || '').trim().toLowerCase();
   const isPreRipReview = reviewMode === 'pre_rip' || Boolean(mediaInfoReview?.preRip);
   const jobMediaProfile = resolvePipelineMediaProfile(pipeline, mediaInfoReview);
+  const retryRipRecoveryRequired = Boolean(
+    !running
+    && retryJobId
+    && typeof onRetry === 'function'
+    && !queueLocked
+    && !isOrphanCancelled
+    && !['converter', 'audiobook'].includes(String(jobMediaProfile || '').trim().toLowerCase())
+    && ['ERROR', 'CANCELLED'].includes(jobStatusUpper)
+    && (
+      ['RIPPING', 'CD_RIPPING'].includes(jobLastStateUpper)
+      || jobErrorMessageLower.includes('server-neustart')
+      || jobErrorMessageLower.includes('rip ist unvollständig')
+      || jobErrorMessageLower.includes('rip-validierung fehlgeschlagen')
+    )
+  );
+  const blockMetadataAndReviewForRipRetry = retryRipRecoveryRequired;
   const discTypeLabel = jobMediaProfile === 'bluray' ? 'Blu-ray' : 'DVD';
   const isDiscTitleSelectionRequired = Boolean(
     (jobMediaProfile === 'dvd' || jobMediaProfile === 'bluray')
@@ -2241,6 +2349,7 @@ export default function PipelineStatusCard({
   const canRestartReviewFromRaw = Boolean(
     retryJobId
     && !running
+    && !blockMetadataAndReviewForRipRetry
     && (pipeline?.context?.canRestartReviewFromRaw || pipeline?.context?.rawPath)
   );
   const allowConverterConfigEdit = showConverterConfig && allowReviewSelectionEdit && state === 'READY_TO_ENCODE';
@@ -2640,6 +2749,14 @@ export default function PipelineStatusCard({
     mediaInfoReview?.titles,
     mediaInfoReview?.seriesBatchParent
   ]);
+  const discWorkflowKind = resolveDiscWorkflowKind({
+    mediaProfile: jobMediaProfile,
+    selectedMetadata,
+    analyzeContext,
+    pipelineContext: pipeline?.context || null,
+    fallbackIsSeries: isSeriesDvdReview
+  });
+  const discWorkflowBadgeLabel = getDiscWorkflowBadgeLabel(jobMediaProfile, discWorkflowKind);
   useEffect(() => {
     let cancelled = false;
 
@@ -3551,6 +3668,7 @@ export default function PipelineStatusCard({
             {(state === 'METADATA_SELECTION' || state === 'WAITING_FOR_USER_DECISION' || isOrphanCancelled)
               && retryJobId
               && typeof onOpenMetadata === 'function'
+              && !blockMetadataAndReviewForRipRetry
               && !(jobMediaProfile === 'converter' && !selectedMetadata?.imdbId) ? (
               <Button
                 label="Metadaten öffnen"
@@ -3579,6 +3697,7 @@ export default function PipelineStatusCard({
               && retryJobId
               && typeof onReassignOmdb === 'function'
               && !isOrphanCancelled
+              && !blockMetadataAndReviewForRipRetry
               && !(jobMediaProfile === 'converter' && state === 'READY_TO_START' && !selectedMetadata?.imdbId) ? (
               <Button
                 label="Metadaten neu zuweisen"
@@ -3738,7 +3857,7 @@ export default function PipelineStatusCard({
               )
             ) : null}
 
-            {(state === 'ERROR' || state === 'CANCELLED') && retryJobId && !isOrphanCancelled && !ripCompleted && (
+            {(state === 'ERROR' || state === 'CANCELLED') && retryJobId && !isOrphanCancelled && (retryRipRecoveryRequired || !ripCompleted) && (
               <Button
                 label="Retry Rippen"
                 icon="pi pi-refresh"

frontend/src/hooks/useWebSocket.js

@@ -16,8 +16,44 @@ export function useWebSocket({ onMessage }) {
   useEffect(() => {
     let socket;
     let reconnectTimer;
+    let progressFlushTimer = null;
+    let progressFlushRaf = null;
+    let latestProgressMessage = null;
     let isUnmounted = false;
 
+    const clearProgressFlush = () => {
+      if (progressFlushRaf !== null && typeof window !== 'undefined' && typeof window.cancelAnimationFrame === 'function') {
+        window.cancelAnimationFrame(progressFlushRaf);
+      }
+      if (progressFlushTimer) {
+        clearTimeout(progressFlushTimer);
+      }
+      progressFlushRaf = null;
+      progressFlushTimer = null;
+    };
+
+    const flushProgressMessage = () => {
+      progressFlushRaf = null;
+      progressFlushTimer = null;
+      const message = latestProgressMessage;
+      latestProgressMessage = null;
+      if (!message) {
+        return;
+      }
+      onMessageRef.current?.(message);
+    };
+
+    const scheduleProgressFlush = () => {
+      if (progressFlushRaf !== null || progressFlushTimer) {
+        return;
+      }
+      if (typeof window !== 'undefined' && typeof window.requestAnimationFrame === 'function') {
+        progressFlushRaf = window.requestAnimationFrame(flushProgressMessage);
+        return;
+      }
+      progressFlushTimer = setTimeout(flushProgressMessage, 16);
+    };
+
     const connect = () => {
       if (isUnmounted) {
         return;
@@ -28,6 +64,11 @@ export function useWebSocket({ onMessage }) {
       socket.onmessage = (event) => {
         try {
           const message = JSON.parse(event.data);
+          if (message?.type === 'PIPELINE_PROGRESS') {
+            latestProgressMessage = message;
+            scheduleProgressFlush();
+            return;
+          }
           onMessageRef.current?.(message);
         } catch (error) {
           // ignore invalid json
@@ -51,6 +92,7 @@ export function useWebSocket({ onMessage }) {
 
     return () => {
       isUnmounted = true;
+      clearProgressFlush();
       if (reconnectTimer) {
         clearTimeout(reconnectTimer);
       }

frontend/src/pages/HistoryPage.jsx

@@ -546,6 +546,7 @@ export default function HistoryPage({ refreshToken = 0 }) {
   const [deleteEntryPreviewLoading, setDeleteEntryPreviewLoading] = useState(false);
   const [deleteEntryTargetBusy, setDeleteEntryTargetBusy] = useState(null);
   const [deleteEntryIncludeRelated, setDeleteEntryIncludeRelated] = useState(true);
+  const [deleteEntrySelectedJobIds, setDeleteEntrySelectedJobIds] = useState([]);
   const [deleteEntrySelectedRawPaths, setDeleteEntrySelectedRawPaths] = useState([]);
   const [deleteEntrySelectedMoviePaths, setDeleteEntrySelectedMoviePaths] = useState([]);
   const [downloadBusyTarget, setDownloadBusyTarget] = useState(null);
@@ -556,6 +557,7 @@ export default function HistoryPage({ refreshToken = 0 }) {
   const [cdMetadataDialogVisible, setCdMetadataDialogVisible] = useState(false);
   const [cdMetadataDialogContext, setCdMetadataDialogContext] = useState(null);
   const [cdMetadataAssignBusy, setCdMetadataAssignBusy] = useState(false);
+  const [generateNfoBusy, setGenerateNfoBusy] = useState(false);
   const [acknowledgeErrorBusy, setAcknowledgeErrorBusy] = useState(false);
   const [loading, setLoading] = useState(false);
   const [queuedJobIds, setQueuedJobIds] = useState([]);
@@ -1190,11 +1192,11 @@ export default function HistoryPage({ refreshToken = 0 }) {
   const handleRetry = async (row) => {
     const title = row?.title || row?.detected_title || `Job #${row?.id}`;
     const mediaType = resolveMediaType(row);
-    const actionLabel = mediaType === 'cd' ? 'CD-Rip' : 'Retry';
+    const diskLabel = mediaType === 'cd' ? 'CD' : 'Disk';
     const confirmed = await confirmModal({
-      header: `${actionLabel} neu starten`,
+      header: 'Rip neu starten',
-      message: `${actionLabel} für "${title}" neu starten?`,
+      message: `Bitte lege die korrekte ${diskLabel} für "${title}" ein.\nSoll der Rip jetzt gestartet werden?`,
-      acceptLabel: 'Neu starten',
+      acceptLabel: 'Rip starten',
       rejectLabel: 'Abbrechen'
     });
     if (!confirmed) {
@@ -1234,6 +1236,39 @@ export default function HistoryPage({ refreshToken = 0 }) {
     }
   };
 
+  const handleGenerateNfo = async (row) => {
+    const jobId = Number(row?.id || 0);
+    if (!jobId) {
+      return;
+    }
+    setGenerateNfoBusy(true);
+    try {
+      const response = await api.generateJobNfo(jobId);
+      const nfoPath = String(response?.result?.nfoPath || '').trim() || null;
+      toastRef.current?.show({
+        severity: 'success',
+        summary: 'NFO erzeugt',
+        detail: nfoPath ? `Datei erstellt: ${nfoPath}` : 'NFO-Datei wurde erstellt.',
+        life: 4000
+      });
+      if (response?.job) {
+        setSelectedJob(response.job);
+      } else {
+        await refreshDetailIfOpen(jobId);
+      }
+      await load();
+    } catch (error) {
+      toastRef.current?.show({
+        severity: 'error',
+        summary: 'NFO-Erzeugung fehlgeschlagen',
+        detail: error.message,
+        life: 4500
+      });
+    } finally {
+      setGenerateNfoBusy(false);
+    }
+  };
+
   const handleAssignOmdb = (row) => {
     const jobId = Number(row?.id || 0);
     if (!jobId) return;
@@ -1493,6 +1528,7 @@ export default function HistoryPage({ refreshToken = 0 }) {
     setDeleteEntryPreviewLoading(false);
     setDeleteEntryTargetBusy(null);
     setDeleteEntryIncludeRelated(true);
+    setDeleteEntrySelectedJobIds([]);
     setDeleteEntrySelectedRawPaths([]);
     setDeleteEntrySelectedMoviePaths([]);
   };
@@ -1509,6 +1545,7 @@ export default function HistoryPage({ refreshToken = 0 }) {
     setDeleteEntryDialogRow(row);
     setDeleteEntryPreview(null);
     setDeleteEntryIncludeRelated(includeRelated);
+    setDeleteEntrySelectedJobIds([]);
     setDeleteEntrySelectedRawPaths([]);
     setDeleteEntrySelectedMoviePaths([]);
     setDeleteEntryDialogVisible(true);
@@ -1517,7 +1554,14 @@ export default function HistoryPage({ refreshToken = 0 }) {
     try {
       const response = await api.getJobDeletePreview(jobId, { includeRelated });
       const preview = response?.preview || null;
+      const relatedJobs = Array.isArray(preview?.relatedJobs) ? preview.relatedJobs : [];
+      const selectedJobIds = Array.isArray(preview?.selectedJobIds)
+        ? preview.selectedJobIds.map((id) => normalizeJobId(id)).filter(Boolean)
+        : relatedJobs
+          .map((item) => normalizeJobId(item?.id))
+          .filter(Boolean);
       setDeleteEntryPreview(preview);
+      setDeleteEntrySelectedJobIds(selectedJobIds);
       const rawCandidates = Array.isArray(preview?.pathCandidates?.raw) ? preview.pathCandidates.raw : [];
       const defaultSelectedRawPaths = rawCandidates
         .filter((item) => Boolean(item?.exists))
@@ -1541,13 +1585,80 @@ export default function HistoryPage({ refreshToken = 0 }) {
       setDeleteEntryDialogRow(null);
       setDeleteEntryPreview(null);
       setDeleteEntryIncludeRelated(true);
+      setDeleteEntrySelectedJobIds([]);
       setDeleteEntrySelectedRawPaths([]);
+      setDeleteEntrySelectedMoviePaths([]);
     } finally {
       setDeleteEntryPreviewLoading(false);
       setDeleteEntryBusy(false);
     }
   };
 
+  const refreshDeleteEntryPreview = async (jobId, selectedJobIds) => {
+    setDeleteEntryPreviewLoading(true);
+    try {
+      const response = await api.getJobDeletePreview(jobId, {
+        includeRelated: deleteEntryIncludeRelated,
+        selectedJobIds
+      });
+      const preview = response?.preview || null;
+      const relatedJobs = Array.isArray(preview?.relatedJobs) ? preview.relatedJobs : [];
+      const nextSelectedJobIds = Array.isArray(preview?.selectedJobIds)
+        ? preview.selectedJobIds.map((id) => normalizeJobId(id)).filter(Boolean)
+        : relatedJobs
+          .map((item) => normalizeJobId(item?.id))
+          .filter(Boolean);
+      setDeleteEntryPreview(preview);
+      setDeleteEntrySelectedJobIds(nextSelectedJobIds);
+      const rawCandidates = Array.isArray(preview?.pathCandidates?.raw) ? preview.pathCandidates.raw : [];
+      const defaultSelectedRawPaths = rawCandidates
+        .filter((item) => Boolean(item?.exists))
+        .map((item) => String(item?.path || '').trim())
+        .filter(Boolean);
+      setDeleteEntrySelectedRawPaths(defaultSelectedRawPaths);
+      const movieCandidates = Array.isArray(preview?.pathCandidates?.movie) ? preview.pathCandidates.movie : [];
+      const defaultSelectedMoviePaths = movieCandidates
+        .filter((item) => Boolean(item?.exists))
+        .map((item) => String(item?.path || '').trim())
+        .filter(Boolean);
+      setDeleteEntrySelectedMoviePaths(defaultSelectedMoviePaths);
+    } catch (error) {
+      toastRef.current?.show({
+        severity: 'error',
+        summary: 'Löschvorschau fehlgeschlagen',
+        detail: error.message,
+        life: 4500
+      });
+    } finally {
+      setDeleteEntryPreviewLoading(false);
+    }
+  };
+
+  const toggleDeleteRelatedJobSelection = async (relatedJobId, checked) => {
+    const normalizedRelatedJobId = normalizeJobId(relatedJobId);
+    const dialogJobId = normalizeJobId(deleteEntryDialogRow?.id);
+    if (!normalizedRelatedJobId || !dialogJobId) {
+      return;
+    }
+    const relatedJobs = Array.isArray(deleteEntryPreview?.relatedJobs) ? deleteEntryPreview.relatedJobs : [];
+    const knownJobIds = relatedJobs
+      .map((item) => normalizeJobId(item?.id))
+      .filter(Boolean);
+    const currentSelected = new Set(
+      deleteEntrySelectedJobIds
+        .map((item) => normalizeJobId(item))
+        .filter(Boolean)
+    );
+    if (checked) {
+      currentSelected.add(normalizedRelatedJobId);
+    } else {
+      currentSelected.delete(normalizedRelatedJobId);
+    }
+    const orderedSelected = knownJobIds.filter((jobId) => currentSelected.has(jobId));
+    setDeleteEntrySelectedJobIds(orderedSelected);
+    await refreshDeleteEntryPreview(dialogJobId, orderedSelected);
+  };
+
   const confirmDeleteEntry = async (target) => {
     const normalizedTarget = String(target || '').trim().toLowerCase();
     if (!['raw', 'movie', 'both', 'none'].includes(normalizedTarget)) {
@@ -1561,6 +1672,16 @@ export default function HistoryPage({ refreshToken = 0 }) {
     if (!jobId) {
       return;
     }
+    const relatedJobs = Array.isArray(deleteEntryPreview?.relatedJobs) ? deleteEntryPreview.relatedJobs : [];
+    if (deleteEntryIncludeRelated && relatedJobs.length > 0 && deleteEntrySelectedJobIds.length === 0) {
+      toastRef.current?.show({
+        severity: 'warn',
+        summary: 'Historie-Auswahl erforderlich',
+        detail: 'Bitte mindestens einen Rip/Encode-Eintrag auswählen.',
+        life: 3500
+      });
+      return;
+    }
     if (
       (normalizedTarget === 'raw' || normalizedTarget === 'both')
       && rawDeleteSelectionEnabled
@@ -1593,6 +1714,7 @@ export default function HistoryPage({ refreshToken = 0 }) {
     try {
       const response = await api.deleteJobEntry(jobId, normalizedTarget, {
         includeRelated: deleteEntryIncludeRelated,
+        selectedJobIds: deleteEntrySelectedJobIds,
         selectedRawPaths: deleteEntrySelectedRawPaths,
         selectedMoviePaths: deleteEntrySelectedMoviePaths
       });
@@ -1630,6 +1752,88 @@ export default function HistoryPage({ refreshToken = 0 }) {
     }
   };
 
+  const confirmDeleteFilesOnly = async (target = 'both') => {
+    const normalizedTarget = String(target || '').trim().toLowerCase();
+    if (!['raw', 'movie', 'both'].includes(normalizedTarget)) {
+      return;
+    }
+    const jobId = Number(deleteEntryDialogRow?.id || 0);
+    if (!jobId) {
+      return;
+    }
+    const relatedJobs = Array.isArray(deleteEntryPreview?.relatedJobs) ? deleteEntryPreview.relatedJobs : [];
+    if (deleteEntryIncludeRelated && relatedJobs.length > 0 && deleteEntrySelectedJobIds.length === 0) {
+      toastRef.current?.show({
+        severity: 'warn',
+        summary: 'Historie-Auswahl erforderlich',
+        detail: 'Bitte mindestens einen Rip/Encode-Eintrag auswählen.',
+        life: 3500
+      });
+      return;
+    }
+    if (
+      (normalizedTarget === 'raw' || normalizedTarget === 'both')
+      && rawDeleteSelectionEnabled
+      && deleteEntrySelectedRawPaths.length === 0
+    ) {
+      toastRef.current?.show({
+        severity: 'warn',
+        summary: 'RAW-Auswahl erforderlich',
+        detail: 'Bitte mindestens einen RAW-Pfad zum Löschen auswählen.',
+        life: 3500
+      });
+      return;
+    }
+    if (
+      (normalizedTarget === 'movie' || normalizedTarget === 'both')
+      && previewMovieExisting.length > 0
+      && deleteEntrySelectedMoviePaths.length === 0
+    ) {
+      toastRef.current?.show({
+        severity: 'warn',
+        summary: `${deleteEntryOutputShortLabel}-Dateien auswählen`,
+        detail: `Bitte mindestens eine ${deleteEntryOutputShortLabel}-Datei zum Löschen auswählen.`,
+        life: 3500
+      });
+      return;
+    }
+
+    setDeleteEntryBusy(true);
+    setDeleteEntryTargetBusy(`files-${normalizedTarget}`);
+    try {
+      const response = await api.deleteJobFiles(jobId, normalizedTarget, {
+        includeRelated: deleteEntryIncludeRelated,
+        selectedJobIds: deleteEntrySelectedJobIds,
+        selectedRawPaths: deleteEntrySelectedRawPaths,
+        selectedMoviePaths: deleteEntrySelectedMoviePaths
+      });
+      const summary = response?.summary || {};
+      const rawFiles = Number(summary?.raw?.filesDeleted || 0);
+      const movieFiles = Number(summary?.movie?.filesDeleted || 0);
+      const rawDirs = Number(summary?.raw?.dirsRemoved || 0);
+      const movieDirs = Number(summary?.movie?.dirsRemoved || 0);
+      toastRef.current?.show({
+        severity: 'success',
+        summary: 'Dateien gelöscht',
+        detail: `Einträge bleiben bestehen | RAW: ${rawFiles} Dateien, ${rawDirs} Ordner | ${deleteEntryOutputShortLabel}: ${movieFiles} Dateien, ${movieDirs} Ordner`,
+        life: 5000
+      });
+
+      closeDeleteEntryDialog();
+      await load();
+    } catch (error) {
+      toastRef.current?.show({
+        severity: 'error',
+        summary: 'Datei-Löschen fehlgeschlagen',
+        detail: error.message,
+        life: 5000
+      });
+    } finally {
+      setDeleteEntryTargetBusy(null);
+      setDeleteEntryBusy(false);
+    }
+  };
+
   const toggleDeleteMoviePathSelection = (moviePath, checked) => {
     const normalizedPath = String(moviePath || '').trim();
     if (!normalizedPath) {
@@ -2251,24 +2455,36 @@ export default function HistoryPage({ refreshToken = 0 }) {
   };
 
   const previewRelatedJobs = Array.isArray(deleteEntryPreview?.relatedJobs) ? deleteEntryPreview.relatedJobs : [];
+  const previewSelectedJobIds = Array.isArray(deleteEntryPreview?.selectedJobIds)
+    ? deleteEntryPreview.selectedJobIds.map((item) => normalizeJobId(item)).filter(Boolean)
+    : previewRelatedJobs
+      .filter((item) => Boolean(item?.selected))
+      .map((item) => normalizeJobId(item?.id))
+      .filter(Boolean);
   const previewRawPaths = Array.isArray(deleteEntryPreview?.pathCandidates?.raw) ? deleteEntryPreview.pathCandidates.raw : [];
   const previewMoviePaths = Array.isArray(deleteEntryPreview?.pathCandidates?.movie) ? deleteEntryPreview.pathCandidates.movie : [];
   const deleteEntryIsMergeJob = isMultipartMergeHistoryRow(deleteEntryDialogRow);
+  const deleteEntrySupportsFilesOnly = isContainerHistoryRow(deleteEntryDialogRow);
   const previewRawExisting = previewRawPaths.filter((item) => Boolean(item?.exists));
   const previewMovieExisting = previewMoviePaths.filter((item) => Boolean(item?.exists));
-  const rawDeleteSelectionEnabled = !deleteEntryIsMergeJob && previewRawExisting.length > 2;
+  const rawDeleteSelectionEnabled = !deleteEntryIsMergeJob && previewRawExisting.length > 0;
-  const previewRawDisplay = rawDeleteSelectionEnabled
+  const previewRawDisplay = previewRawPaths;
-    ? previewRawPaths
+  const previewMovieDisplay = previewMoviePaths;
-    : (previewRawExisting.length > 0 ? previewRawExisting : previewRawPaths.slice(0, 1));
-  const previewMovieDisplay = previewMovieExisting.length > 0 ? previewMovieExisting : previewMoviePaths.slice(0, 1);
   const selectedDeleteRawPathSet = useMemo(
     () => new Set(deleteEntrySelectedRawPaths.map((item) => String(item || '').trim()).filter(Boolean)),
     [deleteEntrySelectedRawPaths]
   );
+  const selectedDeleteRelatedJobSet = useMemo(
+    () => new Set(deleteEntrySelectedJobIds.map((item) => normalizeJobId(item)).filter(Boolean)),
+    [deleteEntrySelectedJobIds]
+  );
   const selectedDeleteMoviePathSet = useMemo(
     () => new Set(deleteEntrySelectedMoviePaths.map((item) => String(item || '').trim()).filter(Boolean)),
     [deleteEntrySelectedMoviePaths]
   );
+  const relatedDeleteSelectionRequired = deleteEntryIncludeRelated
+    && previewRelatedJobs.length > 0
+    && deleteEntrySelectedJobIds.length === 0;
   const rawDeleteSelectionRequired = !deleteEntryIsMergeJob
     && rawDeleteSelectionEnabled
     && deleteEntrySelectedRawPaths.length === 0;
@@ -2357,6 +2573,7 @@ export default function HistoryPage({ refreshToken = 0 }) {
         onRetry={resolveMediaType(selectedJob) === 'converter' ? null : handleRetry}
         onAssignOmdb={handleAssignOmdb}
         onAssignCdMetadata={handleAssignCdMetadata}
+        onGenerateNfo={handleGenerateNfo}
         onAcknowledgeError={handleAcknowledgeError}
         onDeleteFiles={handleDeleteFiles}
         onDeleteEntry={handleDeleteEntry}
@@ -2371,6 +2588,7 @@ export default function HistoryPage({ refreshToken = 0 }) {
         restoreMergeBusy={actionBusy}
         omdbAssignBusy={omdbAssignBusy}
         cdMetadataAssignBusy={cdMetadataAssignBusy}
+        generateNfoBusy={generateNfoBusy}
         acknowledgeErrorBusy={acknowledgeErrorBusy}
         reencodeBusy={reencodeBusyJobId === selectedJob?.id}
         deleteEntryBusy={deleteEntryBusy}
@@ -2394,7 +2612,7 @@ export default function HistoryPage({ refreshToken = 0 }) {
         modal
       >
         <p>
-          {`Es werden ${previewRelatedJobs.length || 1} Historien-Eintrag/Einträge entfernt.`}
+          {`Es sind ${previewRelatedJobs.length || 1} Historien-Eintrag/Einträge verknüpft. Ausgewählt: ${deleteEntrySelectedJobIds.length || previewSelectedJobIds.length || 0}.`}
         </p>
         <small className="history-dv-subtle">
           {deleteEntryIsMergeJob
@@ -2418,13 +2636,29 @@ export default function HistoryPage({ refreshToken = 0 }) {
                 <ul className="history-delete-preview-list">
                   {previewRelatedJobs.map((item) => (
                     <li key={`delete-related-${item.id}`}>
-                      <strong>#{item.id}</strong> | {item.title || '-'} | {getStatusLabel(item.status)} {item.isPrimary ? '(aktuell)' : '(Alt-Eintrag)'}
+                      <label className="history-delete-preview-checkbox-row">
+                        <input
+                          type="checkbox"
+                          checked={selectedDeleteRelatedJobSet.has(normalizeJobId(item?.id))}
+                          onChange={(event) => toggleDeleteRelatedJobSelection(item.id, Boolean(event.target.checked))}
+                        />
+                        <span>
+                          <strong>#{item.id}</strong>
+                          {' '}| {item.title || '-'}
+                          {' '}| {item.roleLabel || 'Job'}
+                          {' '}| {getStatusLabel(item.status)}
+                          {' '}{item.isPrimary ? '(aktuell)' : '(verknüpft)'}
+                        </span>
+                      </label>
                     </li>
                   ))}
                 </ul>
               ) : (
                 <small className="history-dv-subtle">Keine verknüpften Alt-Einträge erkannt.</small>
               )}
+              {relatedDeleteSelectionRequired ? (
+                <small className="history-dv-subtle">Bitte mindestens einen Historien-Eintrag auswählen.</small>
+              ) : null}
             </div>
 
             {!deleteEntryIsMergeJob ? (
@@ -2517,7 +2751,7 @@ export default function HistoryPage({ refreshToken = 0 }) {
               outlined
               onClick={() => confirmDeleteEntry('movie')}
               loading={deleteEntryTargetBusy === 'movie'}
-              disabled={deleteTargetActionsDisabled || movieDeleteSelectionRequired}
+              disabled={deleteTargetActionsDisabled || movieDeleteSelectionRequired || relatedDeleteSelectionRequired}
             />
           ) : (
             <>
@@ -2528,7 +2762,7 @@ export default function HistoryPage({ refreshToken = 0 }) {
                 outlined
                 onClick={() => confirmDeleteEntry('raw')}
                 loading={deleteEntryTargetBusy === 'raw'}
-                disabled={deleteTargetActionsDisabled || rawDeleteSelectionRequired}
+                disabled={deleteTargetActionsDisabled || rawDeleteSelectionRequired || relatedDeleteSelectionRequired}
               />
               <Button
                 label={`Eintrag + nur ${deleteEntryOutputShortLabel}`}
@@ -2537,7 +2771,7 @@ export default function HistoryPage({ refreshToken = 0 }) {
                 outlined
                 onClick={() => confirmDeleteEntry('movie')}
                 loading={deleteEntryTargetBusy === 'movie'}
-                disabled={deleteTargetActionsDisabled || movieDeleteSelectionRequired}
+                disabled={deleteTargetActionsDisabled || movieDeleteSelectionRequired || relatedDeleteSelectionRequired}
               />
               <Button
                 label={`Eintrag + RAW & ${deleteEntryOutputShortLabel}`}
@@ -2545,10 +2779,21 @@ export default function HistoryPage({ refreshToken = 0 }) {
                 severity="danger"
                 onClick={() => confirmDeleteEntry('both')}
                 loading={deleteEntryTargetBusy === 'both'}
-                disabled={deleteTargetActionsDisabled || movieDeleteSelectionRequired || rawDeleteSelectionRequired}
+                disabled={deleteTargetActionsDisabled || movieDeleteSelectionRequired || rawDeleteSelectionRequired || relatedDeleteSelectionRequired}
               />
             </>
           )}
+          {deleteEntrySupportsFilesOnly ? (
+            <Button
+              label="Nur ausgewählte Dateien löschen"
+              icon="pi pi-folder-minus"
+              severity="help"
+              outlined
+              onClick={() => confirmDeleteFilesOnly('both')}
+              loading={deleteEntryTargetBusy === 'files-both'}
+              disabled={deleteTargetActionsDisabled || movieDeleteSelectionRequired || rawDeleteSelectionRequired || relatedDeleteSelectionRequired}
+            />
+          ) : null}
           <Button
             label="Nur Eintrag löschen"
             icon="pi pi-database"
@@ -2556,7 +2801,7 @@ export default function HistoryPage({ refreshToken = 0 }) {
             outlined
             onClick={() => confirmDeleteEntry('none')}
             loading={deleteEntryTargetBusy === 'none'}
-            disabled={deleteTargetActionsDisabled}
+            disabled={deleteTargetActionsDisabled || relatedDeleteSelectionRequired}
           />
           <Button
             label="Abbrechen"

frontend/src/pages/RipperPage.jsx

@@ -771,6 +771,86 @@ function mediaIndicatorMeta(job) {
   return { mediaType, src: otherIndicatorIcon, alt: 'Sonstiges Medium', title: 'Sonstiges Medium' };
 }
 
+function normalizeDiscWorkflowKind(value) {
+  const raw = String(value || '').trim().toLowerCase();
+  if (!raw) {
+    return null;
+  }
+  if (['series', 'tv', 'season', 'episode', 'tv_series', 'tv-season', 'tv_season'].includes(raw)) {
+    return 'series';
+  }
+  if (['film', 'movie', 'feature'].includes(raw)) {
+    return 'film';
+  }
+  return null;
+}
+
+function resolveDiscWorkflowKind({
+  mediaType,
+  selectedMetadata = null,
+  analyzeContext = null,
+  pipelineContext = null,
+  fallbackIsSeries = false
+} = {}) {
+  if (mediaType !== 'dvd' && mediaType !== 'bluray') {
+    return null;
+  }
+  const selected = selectedMetadata && typeof selectedMetadata === 'object' ? selectedMetadata : {};
+  const analyze = analyzeContext && typeof analyzeContext === 'object' ? analyzeContext : {};
+  const pipelineCtx = pipelineContext && typeof pipelineContext === 'object' ? pipelineContext : {};
+  const workflowCandidates = [
+    selected?.workflowKind,
+    selected?.kind,
+    analyze?.workflowKind,
+    pipelineCtx?.workflowKind
+  ];
+  for (const candidate of workflowCandidates) {
+    const normalized = normalizeDiscWorkflowKind(candidate);
+    if (normalized) {
+      return normalized;
+    }
+  }
+  const metadataKindCandidates = [
+    selected?.metadataKind,
+    analyze?.metadataKind
+  ];
+  for (const candidate of metadataKindCandidates) {
+    const normalized = normalizeDiscWorkflowKind(candidate);
+    if (normalized) {
+      return normalized;
+    }
+  }
+  const providerCandidates = [
+    selected?.metadataProvider,
+    analyze?.metadataProvider,
+    pipelineCtx?.metadataProvider
+  ];
+  for (const candidate of providerCandidates) {
+    const provider = String(candidate || '').trim().toLowerCase();
+    if (!provider) {
+      continue;
+    }
+    if (provider === 'tmdb' || provider === 'themoviedb') {
+      return 'series';
+    }
+    if (provider === 'omdb') {
+      return 'film';
+    }
+  }
+  return fallbackIsSeries ? 'series' : 'film';
+}
+
+function getDiscWorkflowBadgeLabel(mediaType, workflowKind) {
+  if (mediaType !== 'dvd' && mediaType !== 'bluray') {
+    return null;
+  }
+  const kind = normalizeDiscWorkflowKind(workflowKind) || 'film';
+  if (mediaType === 'bluray') {
+    return kind === 'series' ? 'Blu-ray-Serie' : 'Blu-ray-Film';
+  }
+  return kind === 'series' ? 'DVD-Serie' : 'DVD-Film';
+}
+
 function JobStepChecks({ backupSuccess, encodeSuccess }) {
   const hasAny = Boolean(backupSuccess || encodeSuccess);
   if (!hasAny) {
@@ -2308,6 +2388,20 @@ export default function RipperPage({
 
   const handleRetry = async (jobId) => {
     const normalizedJobId = normalizeJobId(jobId);
+    const retryJobRow = ripperJobs.find((item) => normalizeJobId(item?.id) === normalizedJobId) || null;
+    const title = retryJobRow?.title || retryJobRow?.detected_title || `Job #${normalizedJobId || jobId}`;
+    const mediaType = retryJobRow ? resolveMediaType(retryJobRow) : null;
+    const diskLabel = mediaType === 'cd' ? 'CD' : 'Disk';
+    const confirmed = await confirmModal({
+      header: 'Rip neu starten',
+      message: `Bitte lege die korrekte ${diskLabel} für "${title}" ein.\nSoll der Rip jetzt gestartet werden?`,
+      acceptLabel: 'Rip starten',
+      rejectLabel: 'Abbrechen'
+    });
+    if (!confirmed) {
+      return;
+    }
+
     if (normalizedJobId) setJobBusy(normalizedJobId, true);
     try {
       const response = await api.retryJob(jobId);
@@ -3304,7 +3398,6 @@ export default function RipperPage({
               const pipelineForJob = pipelineByJobId.get(jobId) || pipeline;
               const jobTitle = job?.title || job?.detected_title || `Job #${jobId}`;
               const mediaIndicator = mediaIndicatorMeta(job);
-              const seriesTagLabel = mediaIndicator.mediaType === 'bluray' ? 'Blu-ray Serie' : 'DVD Serie';
               const isResumable = (
                 normalizedStatus === 'READY_TO_ENCODE'
                 || (mediaIndicator.mediaType === 'audiobook' && normalizedStatus === 'READY_TO_START')
@@ -3345,6 +3438,14 @@ export default function RipperPage({
               const seriesTitleSuffix = mediaIndicator.isSeriesDvd
                 ? `${seriesSeasonLabel}${seriesDiscLabel}${seriesContainerLabel}`
                 : '';
+              const discWorkflowKind = resolveDiscWorkflowKind({
+                mediaType: mediaIndicator.mediaType,
+                selectedMetadata,
+                analyzeContext,
+                pipelineContext: pipelineForJob?.context || null,
+                fallbackIsSeries: Boolean(mediaIndicator.isSeriesVideo)
+              });
+              const discWorkflowBadgeLabel = getDiscWorkflowBadgeLabel(mediaIndicator.mediaType, discWorkflowKind);
               const jobKindRaw = String(job?.job_kind || '').trim().toLowerCase();
               const isMultipartMovie = Number(job?.is_multipart_movie || 0) === 1
                 || jobKindRaw === 'multipart_movie_child'
@@ -3478,7 +3579,7 @@ export default function RipperPage({
                         ) : null}
                         <div className="ripper-job-badges">
                           <Tag value={statusBadgeValue} severity={statusBadgeSeverity} />
-                          {mediaIndicator.isSeriesDvd ? <Tag value={seriesTagLabel} severity="secondary" /> : null}
+                          {discWorkflowBadgeLabel ? <Tag value={discWorkflowBadgeLabel} severity="secondary" /> : null}
                           {isMultipartMerge ? <Tag value="Merge Job" severity="warning" /> : null}
                           {!isMultipartMerge && isMultipartMovie ? <Tag value="Multipart Movie" severity="secondary" /> : null}
                           {isCurrentSession ? <Tag value="Aktive Session" severity="info" /> : null}
@@ -3486,7 +3587,6 @@ export default function RipperPage({
                           {normalizedStatus === 'READY_TO_ENCODE'
                             ? <Tag value={reviewConfirmed ? 'Review bestätigt' : 'Review offen'} severity={reviewConfirmed ? 'success' : 'warning'} />
                             : null}
-                          <JobStepChecks backupSuccess={Boolean(job?.backupSuccess)} encodeSuccess={Boolean(job?.encodeSuccess)} />
                         </div>
                       </div>
                       <Button
@@ -3872,7 +3972,7 @@ export default function RipperPage({
                     </div>
                     <div className="ripper-job-badges">
                       <Tag value={statusBadgeValue} severity={statusBadgeSeverity} />
-                      {mediaIndicator.isSeriesDvd ? <Tag value={seriesTagLabel} severity="secondary" /> : null}
+                      {discWorkflowBadgeLabel ? <Tag value={discWorkflowBadgeLabel} severity="secondary" /> : null}
                       {isMultipartMerge ? <Tag value="Merge Job" severity="warning" /> : null}
                       {!isMultipartMerge && isMultipartMovie ? <Tag value="Multipart Movie" severity="secondary" /> : null}
                       {isCurrentSession ? <Tag value="Aktive Session" severity="info" /> : null}

frontend/vite.config.js

@@ -1,5 +1,5 @@
 import { readFileSync } from 'node:fs';
-import { defineConfig } from 'vite';
+import { createLogger, defineConfig } from 'vite';
 import react from '@vitejs/plugin-react';
 
 const appPackage = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
@@ -24,8 +24,26 @@ if (publicOrigin) {
   };
 }
 
+const viteLogger = createLogger();
+const customLogger = {
+  ...viteLogger,
+  error(message, options) {
+    const text = String(message || '');
+    const stack = String(options?.error?.stack || '');
+    const isWsProxyMessage = text.includes('ws proxy socket error');
+    const isEpipe = text.includes('EPIPE') || stack.includes('EPIPE');
+
+    if (isWsProxyMessage && isEpipe) {
+      return;
+    }
+
+    viteLogger.error(message, options);
+  }
+};
+
 export default defineConfig({
   plugins: [react()],
+  customLogger,
   define: {
     __APP_VERSION__: JSON.stringify(appPackage.version)
   },

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "ripster",
-  "version": "0.15.0-3",
+  "version": "0.16.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "ripster",
-      "version": "0.15.0-3",
+      "version": "0.16.0",
       "devDependencies": {
         "concurrently": "^9.1.2"
       }

package.json

@@ -1,7 +1,7 @@
 {
   "name": "ripster",
   "private": true,
-  "version": "0.15.0-3",
+  "version": "0.16.0",
   "scripts": {
     "dev": "concurrently \"npm run dev --prefix backend\" \"npm run dev --prefix frontend\"",
     "dev:backend": "npm run dev --prefix backend",