Skip to content

Real-time network monitor + outbound firewall — see & block every connection. Privacy-first, local-first, Rust fleet agent, SIEM exports, 8 languages. / Moniteur réseau temps réel + pare-feu sortant, agent de flotte Rust, exports SIEM. 100 % local.

22.2 KB
Raw Blame
/**
 * Snitch — English UI dictionary.
 *
 * EN: Isolated locale file — one per language, so community contributors can
 *     add translations via a simple pull request (see CONTRIBUTING.md).
 *     Values may be strings or functions for interpolation: t('key', arg).
 * FR: Fichier de locale isolé — un par langue, pour que la communauté puisse
 *     ajouter des traductions par simple pull request (cf. CONTRIBUTING.md).
 *     Les valeurs sont des chaînes ou des fonctions d'interpolation.
 */
export default {  // Navigation
  nav_graph: 'Graph',
  nav_map: 'Map',

  // Status badge / Badge de statut
  status_connected: 'Live',
  status_connecting: 'Connecting…',
  status_disconnected: 'Disconnected',
  status_error: 'Error',
  lan_devices: n => `${n} device${n > 1 ? 's' : ''} LAN`,

  // Legend / Légende
  legend_alert: 'Alert',
  legend_unknown: 'Unknown',
  legend_router: 'Router',
  legend_phone: 'Phone',
  legend_pc: 'PC',
  legend_iot: 'IoT',
  legend_https: 'HTTPS',
  legend_tracking: 'Tracking',
  legend_cdn: 'CDN',
  legend_dns: 'DNS',

  // Sidebar header + stats / En-tête de barre latérale + stats
  app_name: 'SNITCH',
  tagline: "Track every hidden flow.",
  footer_credit: 'Developed by aiXis',
  stat_lan: 'LAN Devices',
  stat_ext: 'Ext. hosts',
  stat_traffic: 'Traffic',

  // Sidebar sections / Sections de la barre latérale
  section_lan: n => `LAN Devices (${n})`,
  section_ext: (n, total) => total ? `External hosts (${n}/${total})` : `External hosts (${n})`,
  section_packets: 'Recent traffic',
  packets_filter: 'Filter by app, host, protocol…',
  packets_none: 'No matching traffic in the live feed',

  // Node detail field labels / Étiquettes des champs de détail de nœud
  field_ip: 'IP',
  field_mac: 'MAC',
  field_hostname: 'Hostname',
  field_vendor: 'Vendor',
  field_type: 'Type',
  field_country: 'Country',
  field_city: 'City',
  field_org: 'Org',
  field_category: 'Category',
  field_traffic: 'Traffic',
  field_packets: 'Packets',
  processes: 'Processes',
  online: 'online',
  offline: 'offline',

  // Search / Recherche
  search_placeholder: 'Search host, IP, country…',
  cat_all: 'All',
  cat_unknown: 'Unknown',
  cat_alerted: 'Alerts',
  cat_safe: 'Safe',
  cat_tracking: 'Tracking',
  cat_cdn: 'CDN',
  cat_dns: 'DNS',
  cat_admin: 'Admin',
  cat_local: 'Local',
  cat_lan_device: 'LAN device',
  cat_other: 'Other',

  // EN: Node names + identification hints shown to the user.
  // FR: Noms de nœuds + indices d'identification affichés à l'utilisateur.
  node_local: 'This Device',
  hint_local: 'This is THIS machine — the one running Snitch. Everything it sends or receives radiates from the center of the graph.',
  unidentified: 'unidentified',
  devtype_router: 'Router',
  devtype_phone: 'Phone',
  devtype_pc: 'Computer',
  devtype_tv: 'TV',
  devtype_iot: 'IoT device',
  devtype_unknown: 'Unknown type',
  hint_unidentified: "Not identified yet — its name appears when it announces itself (DNS/mDNS) or its MAC vendor is known. If you don't recognize it, check your router's client list.",
  hint_unresolved: 'Not yet named — the domain appears when a DNS answer or TLS handshake reveals it.',
  hint_private_mac: 'Private (randomized) MAC address — iOS/Android/Windows hide the real one, so the vendor can\'t be identified. This is normal privacy behavior.',
  hint_gateway: 'This is your internet box/router — ALL your traffic physically passes through it, so seeing it communicate is normal and expected.',
  hint_lan_idle: 'Seen on your network via the neighbour table — no data exchanged. A dashed edge means "present", not "talking".',
  hint_lan_active: b => `${b} exchanged — usually automatic announcements (Bonjour/mDNS, file sharing). Watch it if the volume climbs.`,
  ext_empty: "No external connections yet — anything your machine talks to will appear here.",
  legend_edge_solid: 'solid line = traffic',
  legend_edge_dashed: 'dashed = seen, no data',
  legend_ring_safe: 'green ring = identified, safe',
  legend_ring_warn: 'amber ring = suspicious',
  legend_ring_crit: 'red ring = alert',
  legend_ring_none: 'no ring = unidentified, neutral',
  legend_perimeter: 'LAN perimeter',
  perim_lan: 'LOCAL NETWORK',

  // Alert panel / Panneau d'alertes
  alerts_title: 'Alerts',
  alerts_total: 'total',
  alerts_empty: 'No alerts yet',
  alert_NEW_HOST: 'New host',
  alert_SUSPICIOUS_PROCESS: 'Suspicious process',
  alert_SUSPICIOUS_PORT: 'Suspicious port',
  alert_BEACON: 'Beacon C2',
  alert_VOLUME_SPIKE: 'Traffic spike',
  alert_NEW_LAN_DEVICE: 'New device',
  alert_DEVICE_OFFLINE: 'Device offline',
  alert_MEDIA_EXFIL: 'Media exfiltration',
  alert_PORT_SCAN: 'Port scan',
  alert_UPLOAD_SPIKE: 'Upload spike',
  alert_WATCHLIST_HIT: 'Watchlist hit',
  // EN: Full alert messages built from backend codes + details — the backend
  //     only sends type + params, never prose.
  // FR: Messages d'alerte complets construits depuis les codes + détails du
  //     backend — le backend n'envoie que type + paramètres, jamais de prose.
  alertmsg_NEW_HOST: d => `New host contacted: ${d.host || d.ip}`,
  alertmsg_SUSPICIOUS_PROCESS: d => `Suspicious process: ${d.process} → ${d.host || d.ip}`,
  alertmsg_SUSPICIOUS_PORT: d => `Suspicious port ${d.port} (${d.reason}) → ${d.host || d.ip}`,
  alertmsg_BEACON: d => `Beacon-like regularity: ~${d.interval_s}s interval to ${d.host || d.ip}`,
  alertmsg_VOLUME_SPIKE: d => `Data spike to ${d.host || d.ip}: ${Math.round((d.bytes || 0) / 1024)} KB in ${d.window_s}s`,
  alertmsg_MEDIA_EXFIL: d => `Suspected ${d.device} exfiltration: ${d.process} → ${d.host || d.ip}`,
  alertmsg_NEW_LAN_DEVICE: d => `New device on the network: ${d.host || d.ip}`,
  alertmsg_DEVICE_OFFLINE: d => `Device went offline: ${d.host || d.ip}`,
  alertmsg_PORT_SCAN: d => `Port scan: ${d.source || d.ip} touched ${d.ports}+ ports in ${d.window_s}s`,
  alertmsg_UPLOAD_SPIKE: d => `Upload spike: ${d.process} sent ${d.mb} MB in ${d.window_s}s`,
  alertmsg_WATCHLIST_HIT: d => `Watchlist hit: ${d.match} (${d.host || d.ip}) — ${d.process || 'unknown process'}`,
  time_just_now: 'just now',
  time_seconds: n => `${n}s ago`,
  time_minutes: n => `${n}min ago`,
  time_hours: n => `${n}h ago`,

  // Privacy score / Score de confidentialité
  privacy_title: 'Privacy Score',
  privacy_critical_label: 'Critical',
  privacy_excellent_label: 'Excellent',
  privacy_risk_factors: n => `${n} risk factor${n !== 1 ? 's' : ''}`,
  privacy_more_factors: n => `+${n} more factor${n > 1 ? 's' : ''}`,
  privacy_label_excellent: 'Excellent',
  privacy_label_good: 'Good',
  privacy_label_average: 'Average',
  privacy_label_weak: 'Weak',
  privacy_label_critical: 'Critical',

  // Timeline
  timeline_packets: n => `${n.toLocaleString()} packets`,
  timeline_alerts: n => `${n} alert${n > 1 ? 's' : ''}`,
  timeline_live: 'Live',

  // Capture toggle / Bascule de capture
  capture_stop: 'Stop',
  capture_start: 'Start',
  capture_stopping: 'Stopping…',
  capture_starting: 'Starting…',
  capture_error_title: 'Capture failed — no traffic will show',
  capture_error_hint: 'Restart Snitch with capture privileges (admin on Windows — Npcap required, sudo on macOS/Linux) or press Start to retry.',

  // Port filter / Filtre de ports
  port_filter: 'Ports',
  port_all: 'All ports',
  port_placeholder: 'Add port (e.g. 443)',
  port_invalid: 'Invalid port',

  // Export
  export_btn: 'Export',
  export_graph_json: 'Graph (JSON)',
  export_graph_csv: 'Graph (CSV)',
  export_alerts_json: 'Alerts (JSON)',
  export_alerts_csv: 'Alerts (CSV)',

  // Process filter / Filtre de processus
  process_filter: 'Apps',
  process_filter_hint: 'Click to hide app from graph',
  process_none: 'No processes detected yet',
  process_clear: 'Show all apps',

  // IP whitelist / Liste blanche d'IP
  ip_whitelist: 'Trusted',
  ip_whitelist_hint: 'Trusted IPs are no longer captured or shown',
  ip_placeholder: 'Add IP (e.g. 1.1.1.1)',
  ip_invalid: 'Invalid IP address',
  ip_clear: 'Clear whitelist',
  whitelist_action: 'Mark as trusted',

  // Map / Carte
  map_you_approx: 'You (approx.)',
  map_you: 'You',
  map_located: n => `${n} located host${n !== 1 ? 's' : ''}`,
  map_no_geo: 'no geo',

  // Scoring factor labels / Libellés des facteurs de score
  score_trackers: n => `${n} tracker${n > 1 ? 's' : ''} contacted`,
  score_tracker_traffic: pct => `${pct}% traffic to trackers`,
  score_ad_networks: n => `${n} ad network${n > 1 ? 's' : ''}`,
  score_beacons: n => `${n} beacon behavior${n > 1 ? 's' : ''}`,
  score_susp_proc: n => `${n} suspicious process${n > 1 ? 'es' : ''}`,
  score_susp_ports: n => `${n} dangerous port${n > 1 ? 's' : ''}`,
  score_critical_alerts: n => `${n} critical alert${n > 1 ? 's' : ''}`,
  score_warnings: n => `${n} warnings`,
  score_https_ratio: pct => `${pct}% HTTPS traffic`,
  score_no_trackers: 'No trackers detected',

  // Settings / Réglages
  settings_title: 'Settings',
  settings_saved: 'Saved',
  close: 'Close',
  settings_language: 'Language / Langue',
  theme_toggle: 'Light / dark theme',
  settings_retention: 'History retention',
  settings_retention_hint: 'How long traffic & alert history is kept',
  settings_interface: 'Capture interface',
  settings_interface_hint: 'Which network adapter is sniffed (restart capture to apply)',
  settings_interface_auto: 'Auto (first non-loopback)',
  settings_upload: 'Upload alert threshold',
  settings_upload_hint: 'Warn when one process uploads more than this per minute',
  settings_off: 'Off',
  watchlist_title: 'Watchlist',
  watchlist_hint: 'Get alerted whenever traffic touches these IPs or domains',
  watchlist_placeholder: '203.0.113.7 or example.com',
  watchlist_add: 'Add',
  watchlist_remove: 'Remove',
  update_title: 'Updates',
  update_checking: 'Checking for updates…',
  update_available: v => `Update available: v${v} — downloading`,
  update_downloading: p => `Downloading update… ${p}%`,
  update_ready: v => `v${v} downloaded — restart to install`,
  update_none: 'Snitch is up to date',
  update_error: 'Update check failed',
  update_idle: 'No check yet',
  update_restart: 'Restart & install',
  update_check_btn: 'Check now',
  update_auto: 'Check automatically',
  update_privacy: 'Checks github.com for new releases — opt-out below; see PRIVACY.md for the other opt-in calls.',
  geo_title: 'Geolocation database',
  geo_present: dbs => `Installed: ${dbs}`,
  geo_none: 'Not installed — IPs are not geolocated',
  geo_download_btn: 'Download DB-IP Lite (free)',
  geo_consent: 'Downloads ~50 MB from db-ip.com (CC BY 4.0). Other opt-in outbound calls are listed in PRIVACY.md.',
  geo_downloading: 'Downloading…',
  geo_done: n => `Downloaded ${n} database(s)`,
  geo_failed: 'Download failed — check your connection',
  diag_title: 'Diagnostics',
  diag_hint: 'Logs and system info for bug reports',
  diag_open_logs: 'Logs',
  diag_export: 'Export',
  settings_note: 'All settings are stored locally. Snitch never sends data to third parties without your explicit opt-in.',
  nav_apps: 'Apps',
  ignore_alert: 'Ignore this alert type/host',

  // Apps view / Vue applications
  apps_empty: 'No process attributed yet',
  apps_process: 'Process',
  apps_destinations: 'Hosts',
  apps_packets: 'Packets',
  apps_volume: 'Volume',
  apps_top_dest: 'Top destinations',
  apps_history_60m: 'Last hour (bytes/min)',
  alertmsg_NEW_HOSTS: n => `${n} new host${n > 1 ? 's' : ''} contacted`,
  settings_autolaunch: 'Launch at login',
  settings_autolaunch_hint: 'Start Snitch automatically when you sign in',

  // Onboarding / Premier lancement
  onboard_title: 'Welcome to Snitch',
  onboard_sub: 'Real-time network traffic visualizer — private by design.',
  onboard_priv_title: 'Everything stays on this machine',
  onboard_priv_body: 'Traffic metadata, alerts and history are stored in a local SQLite database. No account, no cloud, no telemetry.',
  onboard_capture_title: 'What is captured',
  onboard_capture_body: 'Packet headers only: destination IPs, ports, volumes, process names, DNS names and TLS server names (SNI). Payloads are never read.',
  onboard_out_title: 'What leaves the machine',
  onboard_out_body: 'Nothing by default. The only possible outbound call is the geolocation database download, which you trigger yourself in Settings.',
  onboard_go: 'Got it',

  // Firewall & security / Pare-feu & sécurité
  fw_title: 'Firewall & Security',
  fw_lockdown: 'Lockdown mode',
  fw_lockdown_hint: 'Flag & block ALL outbound traffic (LAN stays up)',
  fw_lockdown_confirm: 'Enable lockdown? ALL outbound traffic will be flagged and blocked until you turn it off.',
  fw_lockdown_on: 'LOCKDOWN',
  fw_supported: p => `OS firewall orchestration on ${p} — best effort, needs privileges`,
  fw_unsupported: 'Native firewall not supported here — rules are visibility only',
  fw_demo: 'demo — nothing applied',
  fw_kind: 'Rule type',
  fw_value: 'Value',
  fw_kind_ip: 'IP / CIDR',
  fw_kind_domain: 'Domain',
  fw_kind_process: 'Process',
  fw_kind_port: 'Port',
  fw_ph_ip: '203.0.113.7 or 185.0.0.0/8',
  fw_ph_domain: 'evil.example',
  fw_ph_process: 'app.exe',
  fw_ph_port: 'e.g. 4444',
  fw_rules: 'Rules',
  fw_empty: 'No rules — add one to harden outbound traffic',
  fw_blocked: n => `${n} attempt${n > 1 ? 's' : ''} seen`,
  fw_applied: 'applied to OS firewall',
  fw_not_applied: 'visibility only (needs privileges)',
  fw_enable: 'Enable',
  fw_disable: 'Disable',
  fw_delete: 'Delete rule',
  audit_title: 'Security audit',
  audit_refresh: 'Refresh',
  audit_critical: 'critical',
  audit_warning: 'warnings',
  audit_risky: n => `${n} host(s) in high-risk countries`,
  audit_loading: 'Loading…',
  fw_forensics: 'Forensics export',
  block_action: 'Block',
  proc_kill: 'Kill process',
  proc_suspend: 'Suspend / resume',
  save: 'Save',
  ti_title: 'Threat intelligence (opt-in)',
  ti_hint: 'Check newly-seen hosts against a reputation provider',
  ti_none: 'Disabled',
  ti_key: 'API key',
  ti_key_ph: 'Your API key',
  ti_privacy: 'Outbound calls to the provider, only for newly-seen public hosts. Disabled by default — the key is stored locally.',
  wh_title: 'External webhook (opt-in)',
  wh_hint: 'Forward critical/warning alerts to Discord, Slack or Telegram',
  wh_url: 'Webhook URL',
  wh_url_ph: 'https://discord.com/api/webhooks/… or any endpoint',
  wh_chat: 'Chat ID',
  wh_chat_ph: 'chat_id',
  wh_privacy: 'Alert messages are POSTed to your endpoint when enabled.',
  alert_BLOCKED_ATTEMPT: 'Blocked attempt',
  alert_THREAT_HIT: 'Threat intel',
  alert_DNS_TUNNEL: 'DNS tunnel',
  alert_CLEARTEXT: 'Cleartext',
  alert_BASELINE_DEVIATION: 'Baseline deviation',
  alert_LOCKDOWN: 'Lockdown',
  alertmsg_BLOCKED_ATTEMPT: d => `Firewall rule matched: ${d.rule?.value || '?'} (${d.rule?.kind || '?'})${d.process ? ` by ${d.process}` : ''}`,
  alertmsg_THREAT_HIT: d => `Threat intel: ${d.ip} flagged ${d.verdict} (${d.provider}: ${d.detail || 'reported'})`,
  alertmsg_DNS_TUNNEL: d => `Possible DNS tunneling: oversized name queried by ${d.process}`,
  alertmsg_CLEARTEXT: d => `Unencrypted ${d.proto} connection to ${d.host || d.ip} by ${d.process}`,
  alertmsg_BASELINE_DEVIATION: d => `${d.process} contacted a new country: ${d.country}`,
  alertmsg_LOCKDOWN: () => 'Lockdown mode ENABLED — all outbound traffic blocked',
  alert_BINARY_CHANGED: 'Binary changed',
  alert_NAME_MISMATCH: 'Name mismatch',
  alert_MEM_RWX: 'RWX memory',
  alertmsg_BINARY_CHANGED: d => `Executable modified on disk: ${d.exe || d.process || '?'}`,
  alertmsg_NAME_MISMATCH: d => `Name/exe mismatch: ${d.process} → ${d.exe || '?'}`,
  alertmsg_MEM_RWX: d => `Writable-executable memory in ${d.process || `pid ${d.pid}`}: ${d.detail || ''}`,
  alert_why: 'Why?',
  fw_action: 'Action',
  fw_action_block: 'Block',
  fw_action_sinkhole: 'Sinkhole',
  iw_title: 'Integrity watch',
  iw_hint: 'Hash executables of networked processes, flag name/exe mismatches and (Linux) RWX memory regions.',
  iw_privacy: 'All checks are read-only local inspection — nothing is modified or sent.',
  alertmsg_MODULE_SUSPECT: d => `Suspicious module path in ${d.process || 'process'}: ${(d.modules || []).join(', ')}`,
  alertmsg_MODULE_CHANGED: d => `Loaded-module integrity changed in ${d.process || 'process'}`,
  alertmsg_MINING_STRATUM: d => `Cryptomining protocol (${d.marker || 'stratum'}) from ${d.process || `pid ${d.pid}`}`,
  alertmsg_MINING_SUSPECT: d => `Mining behaviour: ${d.process || `pid ${d.pid}`} — ${d.detail || 'pool port + sustained CPU'}`,
  alertmsg_SINKHOLE_HIT: d => `Sinkholed connection attempted: ${d.host || d.ip || '?'}`,
  alertmsg_INJECT_SUSPECT: d => `Injected-module suspicion in pid ${d.pid}: ${(d.paths || []).join(', ')}`,
  fw_action_throttle: 'Throttle',
  fw_rate: 'Rate (kbit/s)',
  fw_rate_hint: 'Egress rate limit in kbit/s (Linux tc)',
  ioc_title: 'Community IOC pack',
  ioc_export: 'Export pack',
  ioc_hint: 'Shares indicators as a noised Bloom filter — raw values never leave the file. Import checks are probabilistic.',
  ioc_import_ph: 'Paste a received IOC pack (JSON)…',
  ioc_check: 'Check',
  ioc_hints: n => `${n} destination(s) match the pack (probabilistic)`,
  ioc_clean: 'No match',
  ioc_bad: 'Invalid pack',
  di_inspect: 'Deep inspect (Frida)',
  di_result: 'Suspicious module paths:',
  di_clean: 'No suspicious module path — clean, or no connect() captured.',
  di_failed: 'Deep inspection failed (frida not installed or insufficient rights)',
  ebpf_title: 'eBPF connect probe',
  ebpf_hint: 'Linux only — attributes packets from very short-lived processes that the socket table misses. Needs python3-bcc + root.',
  ebpf_privacy: 'Kernel events stay local — attribution only, nothing is logged or sent.',
  slm_title: 'Local LLM enrichment',
  slm_hint: 'Optional: enriches alert explanations with an Ollama-compatible model. Loopback only — remote endpoints are rejected.',
  slm_endpoint: 'Endpoint',
  slm_model: 'Model',
  slm_privacy: 'Runs only when enabled; alert metadata goes to your local model, never off-machine.',
  slm_mode_ollama: 'Ollama server',
  slm_mode_embedded: 'Embedded GGUF',
  slm_model_path: 'Model file (.gguf)',
  fw_profiles: 'Profiles',
  fw_profiles_hint: 'One-tap policy bundles — expanded into ordinary rules.',
  fw_profile_permissive: 'Permissive',
  fw_profile_balanced: 'Balanced',
  fw_profile_strict: 'Strict',
  fw_pcap_empty: 'No frames captured yet — the ring holds recent traffic only',
  fw_pcap_hint: 'Download recent raw frames as .pcap — bounded ring buffer, Wireshark-ready',
  bl_title: 'Blocklist import',
  bl_hint: 'Turn a hosts file or domain list into firewall rules (max 500).',
  bl_source: 'Source',
  bl_src_file: 'File',
  bl_src_url: 'URL',
  bl_import: 'Import',
  bl_url_confirm: 'Fetching this URL makes Snitch emit an OUTBOUND request — one of the few it can ever send. Continue?',
  bl_result: (a, s) => `${a} rules added · ${s} already present`,
  bl_truncated: 'list truncated at the cap',
  bl_remote: 'remote fetch performed',
  ar_title: 'Custom alert rules',
  ar_hint: 'Raise CUSTOM_RULE alerts on your own matches — or \'alert + block\' to auto-firewall matched hosts.',
  ar_name_ph: 'Rule name (optional)',
  ar_field: 'Field',
  ar_op: 'Operator',
  ar_value_ph: 'Value',
  ar_sev: 'Severity',
  ar_hits: n => `${n} hits`,
  sev_info: 'info',
  sev_warning: 'warning',
  sev_critical: 'critical',
  pair_title: 'Remote pairing (LAN)',
  pair_hint: 'Let other devices on your LAN reach this API — token still required.',
  pair_lan_ips: ips => `Reachable at: ${ips}`,
  pair_port: p => `port ${p}`,
  pair_restart: 'Applies at next backend restart — a live socket cannot be rebound.',
  pair_privacy: 'Loopback-only by default; enabling exposes the API to your LAN with token auth still enforced.',
  sb_title: 'Network-denial sandbox',
  sb_hint: 'Run a binary with zero network egress — observe behaviour without exposure.',
  sb_path: 'Executable path',
  sb_run: 'Detonate',
  sb_done: code => `Ran in sandbox — exit ${code}`,
  sb_failed: 'Sandbox unavailable on this platform',
  alertmsg_CUSTOM_RULE: d => `Custom rule matched: ${d.rule?.name || 'unnamed rule'}`,
  alert_TLS_CERT: 'TLS certificate',
  alert_HIGH_ENTROPY: 'High entropy',
  alert_ICMP_TUNNEL: 'ICMP tunnel',
  alert_ML_ANOMALY: 'ML anomaly',
  alert_ASK_VERDICT: 'Verdict needed',
  alertmsg_TLS_CERT: d => `TLS cert anomaly for ${d.host || d.ip}: ${(d.reasons || []).join(', ')} (issuer ${d.issuer || '?'})`,
  alertmsg_HIGH_ENTROPY: d => `High-entropy payload on cleartext channel ${d.process || '?'} → ${d.ip}:${d.port} (${d.entropy} bits/byte)`,
  alertmsg_ICMP_TUNNEL: d => `Possible ICMP tunnelling: repeated fat echo payloads with ${d.ip}`,
  alertmsg_ML_ANOMALY: d => `ML flow anomaly: ${d.process || '?'} → ${d.ip} (score ${d.score})`,
  alertmsg_ASK_VERDICT: d => `Verdict needed: ${d.process || 'a process'} → ${d.remote_ip}:${d.remote_port}/${d.proto} (auto-decision in ${d.timeout_s}s)`,
  alertmsg_DGA_SUSPECT: d => `DGA-looking domain ${d.label || d.name} (${(d.reasons || []).join(', ')})`,
  alertmsg_PROTO_MISMATCH: d => `Protocol mismatch: ${d.reason} — ${d.process || '?'} → ${d.ip}:${d.port}`,
  alert_act_block: 'Block IP',
  alert_act_kill: 'Kill',
  alert_act_suspend: 'Suspend',
  alert_act_allow: 'Allow',
  alert_act_deny: 'Deny',
  alert_act_allow_perm: 'Allow always',
  alert_act_deny_perm: 'Deny always',
  ar_action: 'Action',
  ar_action_alert: 'Alert only',
  ar_action_block: 'Alert + block',

  sl_title: 'Syslog output',
  sl_hint: 'Forward warning/critical alerts to a syslog collector (RFC 3164, UDP or tcp://). Opt-in — nothing is sent until an address is set.',
  sl_ph: 'host:port or tcp://host:port',
  ask_title: 'Ask-on-connect',
  ask_hint: 'Hold new outbound flows until you allow/deny — the Little Snitch-style prompt. Linux + NFQUEUE + root required.',
  ask_timeout: 'Timeout',
  ask_failopen: 'Fail-open (allow on timeout — less safe)',
  ask_unavailable: 'Ask mode unavailable on this system',
  ask_not_running: 'Ask mode is enabled but not running — check backend logs',
  gs_title: 'IOC peer sync',
  gs_hint: 'Push salted-Merkle proof packs to explicitly paired Snitch instances every 5 min — hash commitments only, never raw indicators.',
  gs_peers_ph: 'host:port, comma-separated',
  gs_privacy: 'Opt-in fleet sharing — packs leave only for the peers you list here.',
  ks_title: 'Volume kill-switch',
  ks_hint: 'Auto-block the remote IP (real firewall rule) when an upload spike fires — off by default',
}