novac 2.2.0 → 2.2.2

package/kits/libos/kitdef.js

@@ -0,0 +1,3135 @@
+'use strict';
+
+// ============================================================
+//  kitos.js  —  Full OS Integration Kit for Nova
+//  20 categories of native OS interaction, all cross-platform.
+//  Platforms: Linux, macOS, Windows, Android (Termux)
+//
+//  import "kitos"
+//
+//  Categories exported as namespaced objects:
+//    Notify, TTS, Dialog, Menu, Keyboard, Mouse, Screen,
+//    Audio, Camera, Power, Brightness, Wifi, Bluetooth,
+//    Volume, Trash, Open, Autostart, A11y, IdleTime,
+//    Sensors, Location, Vibrate
+//
+//  module.exports = { kitdef: { Notify, TTS, Dialog, ... } }
+// ============================================================
+
+'use strict';
+
+const { execSync, spawnSync, exec, spawn } = require('child_process');
+const os   = require('os');
+const fs   = require('fs');
+const path = require('path');
+
+// ── Platform detection ────────────────────────────────────────────────────────
+
+const PLATFORM = (() => {
+  const p = os.platform();
+  if (p === 'darwin') return 'macos';
+  if (p === 'win32')  return 'windows';
+  if (p === 'linux') {
+    // Termux detection: $PREFIX points into /data/data/com.termux
+    if (process.env.PREFIX && process.env.PREFIX.includes('com.termux')) return 'android';
+    return 'linux';
+  }
+  return p;
+})();
+
+const IS_MACOS   = PLATFORM === 'macos';
+const IS_WINDOWS = PLATFORM === 'windows';
+const IS_LINUX   = PLATFORM === 'linux';
+const IS_ANDROID = PLATFORM === 'android';
+
+// ── Internal helpers ──────────────────────────────────────────────────────────
+
+/**
+ * Run a command synchronously, return { code, stdout, stderr }.
+ * Never throws.
+ */
+function _run(cmd, opts = {}) {
+  try {
+    const stdout = execSync(cmd, {
+      encoding: 'utf8',
+      timeout: opts.timeout ?? 15_000,
+      env: { ...process.env, ...opts.env },
+      stdio: ['ignore', 'pipe', 'pipe'],
+      ...(opts.cwd ? { cwd: opts.cwd } : {}),
+    }).trimEnd();
+    return { code: 0, stdout, stderr: '' };
+  } catch (e) {
+    return {
+      code:   e.status ?? 1,
+      stdout: (e.stdout ?? '').trimEnd(),
+      stderr: (e.stderr ?? '').trimEnd(),
+    };
+  }
+}
+
+/** Run and return stdout string only ('' on failure). */
+function _out(cmd, opts = {}) { return _run(cmd, opts).stdout; }
+
+/** Spawn and return { code, stdout, stderr }. Never throws. */
+function _spawn(bin, args = [], opts = {}) {
+  const r = spawnSync(bin, args, {
+    encoding: 'utf8',
+    timeout: opts.timeout ?? 15_000,
+    env: { ...process.env, ...opts.env },
+    ...(opts.cwd ? { cwd: opts.cwd } : {}),
+  });
+  return {
+    code:   r.status ?? 1,
+    stdout: (r.stdout ?? '').trimEnd(),
+    stderr: (r.stderr ?? '').trimEnd(),
+  };
+}
+
+/** Escape a string for use inside an AppleScript string literal. */
+function _escAS(s) { return String(s).replace(/\\/g, '\\\\').replace(/"/g, '\\"'); }
+
+/** Escape a string for safe insertion into a shell command. */
+function _esc(s)   { return `'${String(s).replace(/'/g, "'\\''")}'`; }
+
+/** Run an AppleScript string. Returns stdout. */
+function _osascript(script) {
+  return _spawn('osascript', ['-e', script]).stdout;
+}
+
+/** Run a PowerShell command string. Returns stdout. */
+function _pwsh(code) {
+  return _spawn('powershell', ['-NoProfile', '-NonInteractive', '-Command', code]).stdout;
+}
+
+/** Detect which Linux dialog tool is available. */
+function _linuxDialog() {
+  for (const t of ['zenity', 'yad', 'kdialog', 'qarma']) {
+    if (_run(`which ${t}`).code === 0) return t;
+  }
+  return null;
+}
+
+/** Which Linux notification tool is available. */
+function _linuxNotify() {
+  if (_run('which notify-send').code === 0) return 'notify-send';
+  if (_run('which dunstify').code  === 0) return 'dunstify';
+  return null;
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
+//  1. NOTIFY — Desktop Notifications
+// ══════════════════════════════════════════════════════════════════════════════
+
+const Notify = {
+  /**
+   * Send a desktop notification.
+   * @param {string} title
+   * @param {string} [body='']
+   * @param {object} [opts]
+   * @param {'low'|'normal'|'critical'} [opts.urgency='normal']  Linux only
+   * @param {number} [opts.timeout]  ms (Linux), ignored elsewhere
+   * @param {string} [opts.icon]     icon name or path (Linux)
+   * @param {string} [opts.sound]    sound name (macOS)
+   * @param {string} [opts.subtitle] (macOS)
+   * @param {string} [opts.id]       notification id (Linux)
+   */
+  send(title, body = '', opts = {}) {
+    title = String(title); body = String(body);
+
+    if (IS_MACOS) {
+      const t   = _escAS(title);
+      const b   = _escAS(body);
+      const sub = opts.subtitle ? `with subtitle "${_escAS(opts.subtitle)}"` : '';
+      const snd = opts.sound    ? `sound name "${_escAS(opts.sound)}"` : '';
+      _osascript(
+        `display notification "${b}" with title "${t}" ${sub} ${snd}`
+      );
+      return true;
+    }
+
+    if (IS_WINDOWS) {
+      // PowerShell toast via BurntToast-free method (WinRT)
+      const t = title.replace(/'/g, "''"), b2 = body.replace(/'/g, "''");
+      _pwsh(`
+        [Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null
+        [Windows.Data.Xml.Dom.XmlDocument, Windows.Data.Xml.Dom.XmlDocument, ContentType = WindowsRuntime] | Out-Null
+        $xml = [Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent([Windows.UI.Notifications.ToastTemplateType]::ToastText02)
+        $xml.GetElementsByTagName('text')[0].AppendChild($xml.CreateTextNode('${t}')) | Out-Null
+        $xml.GetElementsByTagName('text')[1].AppendChild($xml.CreateTextNode('${b2}')) | Out-Null
+        $toast = [Windows.UI.Notifications.ToastNotification]::new($xml)
+        [Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('Nova').Show($toast)
+      `);
+      return true;
+    }
+
+    if (IS_ANDROID) {
+      const args = ['termux-notification', '--title', title, '--content', body];
+      if (opts.id)      args.push('--id', String(opts.id));
+      if (opts.icon)    args.push('--icon', opts.icon);
+      _spawn(args[0], args.slice(1));
+      return true;
+    }
+
+    // Linux
+    const tool = _linuxNotify();
+    if (!tool) return false;
+    const args = [title, body];
+    if (opts.urgency) args.unshift('--urgency=' + opts.urgency);
+    if (opts.timeout) args.unshift('--expire-time=' + opts.timeout);
+    if (opts.icon)    args.unshift('--icon=' + opts.icon);
+    if (opts.id)      args.unshift('--replace-id=' + opts.id);
+    _spawn(tool, args);
+    return true;
+  },
+
+  /** Remove a notification by id (Linux / Android only). */
+  remove(id) {
+    if (IS_ANDROID) { _spawn('termux-notification-remove', [String(id)]); return; }
+    if (IS_LINUX)   { _run(`notify-send --close=${id}`); }
+  },
+
+  /** List active notifications (Android only). */
+  list() {
+    if (IS_ANDROID) return JSON.parse(_out('termux-notification-list') || '[]');
+    return [];
+  },
+
+  platform: PLATFORM,
+};
+
+// ══════════════════════════════════════════════════════════════════════════════
+//  2. TTS — Text-to-Speech
+// ══════════════════════════════════════════════════════════════════════════════
+
+const TTS = {
+  /**
+   * Speak text aloud (synchronous by default).
+   * @param {string} text
+   * @param {object} [opts]
+   * @param {string} [opts.voice]   voice name
+   * @param {number} [opts.rate]    words-per-minute or rate (platform-specific)
+   * @param {number} [opts.pitch]   pitch adjustment (Linux espeak)
+   * @param {boolean} [opts.async]  if true, don't wait
+   */
+  speak(text, opts = {}) {
+    text = String(text);
+
+    if (IS_MACOS) {
+      const args = [text];
+      if (opts.voice) args.push('-v', opts.voice);
+      if (opts.rate)  args.push('-r', String(opts.rate));
+      opts.async ? spawn('say', args, { detached: true, stdio: 'ignore' }).unref()
+                 : _spawn('say', args);
+      return;
+    }
+
+    if (IS_WINDOWS) {
+      const rate  = opts.rate  ? `$s.Rate=${opts.rate};`  : '';
+      const voice = opts.voice ? `$s.SelectVoice('${opts.voice.replace(/'/g, "''")}');` : '';
+      const cmd   = `Add-Type -AssemblyName System.speech; $s=New-Object System.Speech.Synthesis.SpeechSynthesizer; ${voice}${rate}$s.Speak('${text.replace(/'/g, "''")}')`;
+      opts.async ? spawn('powershell', ['-NoProfile', '-Command', cmd], { detached: true, stdio: 'ignore' }).unref()
+                 : _pwsh(cmd);
+      return;
+    }
+
+    if (IS_ANDROID) {
+      const args = ['termux-tts-speak'];
+      if (opts.rate)  args.push('-r', String(opts.rate));
+      if (opts.pitch) args.push('-p', String(opts.pitch));
+      if (opts.voice) args.push('-l', opts.voice);
+      args.push(text);
+      opts.async ? spawn(args[0], args.slice(1), { detached: true, stdio: 'ignore' }).unref()
+                 : _spawn(args[0], args.slice(1));
+      return;
+    }
+
+    // Linux — try espeak, espeak-ng, festival, spd-say
+    if (_run('which espeak-ng').code === 0) {
+      const args = [text];
+      if (opts.voice) args.push('-v', opts.voice);
+      if (opts.rate)  args.push('-s', String(opts.rate));
+      if (opts.pitch) args.push('-p', String(opts.pitch));
+      opts.async ? spawn('espeak-ng', args, { detached: true, stdio: 'ignore' }).unref()
+                 : _spawn('espeak-ng', args);
+    } else if (_run('which espeak').code === 0) {
+      const args = [text];
+      if (opts.voice) args.push('-v', opts.voice);
+      if (opts.rate)  args.push('-s', String(opts.rate));
+      opts.async ? spawn('espeak', args, { detached: true, stdio: 'ignore' }).unref()
+                 : _spawn('espeak', args);
+    } else if (_run('which spd-say').code === 0) {
+      _spawn('spd-say', [text]);
+    } else if (_run('which festival').code === 0) {
+      const r = spawnSync('festival', ['--pipe'], { input: `(SayText "${text.replace(/"/g, '\\"')}")`, encoding: 'utf8' });
+    }
+  },
+
+  /** List available voices. */
+  voices() {
+    if (IS_MACOS) {
+      return _out('say -v ?').split('\n')
+        .filter(Boolean)
+        .map(l => { const m = l.match(/^(\S+)\s+(\S+)/); return m ? { name: m[1], lang: m[2] } : null; })
+        .filter(Boolean);
+    }
+    if (IS_WINDOWS) {
+      return _pwsh('Add-Type -AssemblyName System.speech; (New-Object System.Speech.Synthesis.SpeechSynthesizer).GetInstalledVoices() | ForEach-Object { $_.VoiceInfo.Name }')
+        .split('\n').map(s => s.trim()).filter(Boolean).map(n => ({ name: n }));
+    }
+    if (IS_ANDROID) {
+      return []; // Termux TTS uses Android TTS engine
+    }
+    // espeak-ng
+    return _out('espeak-ng --voices').split('\n').slice(1)
+      .filter(Boolean)
+      .map(l => { const p = l.trim().split(/\s+/); return { name: p[4], lang: p[1] }; });
+  },
+
+  /** Stop any ongoing speech (best-effort). */
+  stop() {
+    if (IS_MACOS)   _run('killall say 2>/dev/null');
+    if (IS_WINDOWS) _pwsh('Add-Type -AssemblyName System.speech; (New-Object System.Speech.Synthesis.SpeechSynthesizer).SpeakAsyncCancelAll()');
+    if (IS_ANDROID) _spawn('termux-tts-stop');
+    if (IS_LINUX)   _run('killall espeak espeak-ng spd-say 2>/dev/null');
+  },
+};
+
+// ══════════════════════════════════════════════════════════════════════════════
+//  3. DIALOG — Native OS Dialogs
+// ══════════════════════════════════════════════════════════════════════════════
+
+const Dialog = {
+  /**
+   * Show an alert dialog.
+   * @param {string} message
+   * @param {string} [title='Alert']
+   */
+  alert(message, title = 'Alert') {
+    message = String(message); title = String(title);
+    if (IS_MACOS) {
+      _osascript(`display alert "${_escAS(title)}" message "${_escAS(message)}"`);
+    } else if (IS_WINDOWS) {
+      _pwsh(`[System.Windows.Forms.MessageBox]::Show('${message.replace(/'/g, "''")}', '${title.replace(/'/g, "''")}') | Out-Null`);
+    } else if (IS_ANDROID) {
+      _spawn('termux-dialog', ['confirm', '-t', title, '-i', message]);
+    } else {
+      const t = _linuxDialog();
+      if (t === 'zenity') _spawn('zenity', ['--info', `--title=${title}`, `--text=${message}`]);
+      else if (t === 'kdialog') _spawn('kdialog', ['--msgbox', message, '--title', title]);
+      else if (t === 'yad') _spawn('yad', ['--info', `--title=${title}`, `--text=${message}`]);
+    }
+  },
+
+  /**
+   * Show a confirm (yes/no) dialog.
+   * @returns {boolean}
+   */
+  confirm(message, title = 'Confirm') {
+    message = String(message); title = String(title);
+    if (IS_MACOS) {
+      const r = _osascript(`display alert "${_escAS(title)}" message "${_escAS(message)}" buttons {"Cancel","OK"} default button "OK"`);
+      return r.includes('OK');
+    }
+    if (IS_WINDOWS) {
+      const r = _pwsh(`[System.Windows.Forms.MessageBox]::Show('${message.replace(/'/g, "''")}', '${title.replace(/'/g, "''")}', 'YesNo')`);
+      return r.trim() === 'Yes';
+    }
+    if (IS_ANDROID) {
+      const r = _spawn('termux-dialog', ['confirm', '-t', title, '-i', message]);
+      try { return JSON.parse(r.stdout).text === 'yes'; } catch { return false; }
+    }
+    const t = _linuxDialog();
+    if (t === 'zenity')  return _spawn('zenity',  ['--question', `--title=${title}`, `--text=${message}`]).code === 0;
+    if (t === 'kdialog') return _spawn('kdialog', ['--yesno', message, '--title', title]).code === 0;
+    if (t === 'yad')     return _spawn('yad',     ['--question', `--title=${title}`, `--text=${message}`]).code === 0;
+    return false;
+  },
+
+  /**
+   * Show a text prompt dialog.
+   * @param {string} message
+   * @param {string} [defaultValue='']
+   * @returns {string|null}  null if cancelled
+   */
+  prompt(message, defaultValue = '', title = 'Input') {
+    message = String(message); defaultValue = String(defaultValue);
+    if (IS_MACOS) {
+      const r = _osascript(
+        `set result to display dialog "${_escAS(message)}" default answer "${_escAS(defaultValue)}" with title "${_escAS(title)}" buttons {"Cancel","OK"} default button "OK"\n` +
+        `return text returned of result`
+      );
+      return r || null;
+    }
+    if (IS_WINDOWS) {
+      const r = _pwsh(
+        `Add-Type -AssemblyName Microsoft.VisualBasic; ` +
+        `[Microsoft.VisualBasic.Interaction]::InputBox('${message.replace(/'/g, "''")}', '${title.replace(/'/g, "''")}', '${defaultValue.replace(/'/g, "''")}')`
+      );
+      return r.trim() === '' ? null : r.trim();
+    }
+    if (IS_ANDROID) {
+      const r = _spawn('termux-dialog', ['text', '-t', title, '-i', message, '--hint', defaultValue]);
+      try { const j = JSON.parse(r.stdout); return j.text ?? null; } catch { return null; }
+    }
+    const t = _linuxDialog();
+    if (t === 'zenity') {
+      const r = _spawn('zenity', ['--entry', `--title=${title}`, `--text=${message}`, `--entry-text=${defaultValue}`]);
+      return r.code === 0 ? r.stdout.trim() : null;
+    }
+    if (t === 'kdialog') {
+      const r = _spawn('kdialog', ['--inputbox', message, defaultValue, '--title', title]);
+      return r.code === 0 ? r.stdout.trim() : null;
+    }
+    if (t === 'yad') {
+      const r = _spawn('yad', ['--entry', `--title=${title}`, `--text=${message}`, `--entry-text=${defaultValue}`]);
+      return r.code === 0 ? r.stdout.trim() : null;
+    }
+    return null;
+  },
+
+  /**
+   * Show a native file picker dialog.
+   * @param {object} [opts]
+   * @param {boolean} [opts.multiple=false]
+   * @param {string}  [opts.initialDir]
+   * @param {string}  [opts.filter]  e.g. '*.txt'
+   * @param {string}  [opts.title]
+   * @returns {string|string[]|null}
+   */
+  filePicker(opts = {}) {
+    const title  = opts.title      ?? 'Select File';
+    const initDir= opts.initialDir ?? os.homedir();
+    const multi  = opts.multiple   ?? false;
+
+    if (IS_MACOS) {
+      const multiClause = multi ? 'with multiple selections allowed' : '';
+      const r = _osascript(
+        `set f to choose file with prompt "${_escAS(title)}" default location "${_escAS(initDir)}" ${multiClause}\n` +
+        `POSIX path of f`
+      );
+      if (!r) return null;
+      return multi ? r.split('\n').filter(Boolean) : r.trim();
+    }
+    if (IS_WINDOWS) {
+      const code = `
+        Add-Type -AssemblyName System.Windows.Forms
+        $d = New-Object System.Windows.Forms.OpenFileDialog
+        $d.Title = '${title.replace(/'/g, "''")}'; $d.InitialDirectory = '${initDir.replace(/'/g, "''")}'
+        ${multi ? "$d.Multiselect = $true" : ''}
+        if ($d.ShowDialog() -eq 'OK') { $d.FileNames -join [char]10 } else { '' }
+      `;
+      const r = _pwsh(code).trim();
+      if (!r) return null;
+      const files = r.split('\n').map(s => s.trim()).filter(Boolean);
+      return multi ? files : files[0];
+    }
+    if (IS_ANDROID) {
+      const r = _spawn('termux-storage-get', ['/tmp/kitos_file_pick.tmp']);
+      return r.code === 0 ? '/tmp/kitos_file_pick.tmp' : null;
+    }
+    const t = _linuxDialog();
+    if (t === 'zenity') {
+      const args = ['--file-selection', `--title=${title}`, `--filename=${initDir}/`];
+      if (multi) args.push('--multiple', '--separator=\n');
+      const r = _spawn('zenity', args);
+      if (r.code !== 0) return null;
+      const files = r.stdout.split('\n').filter(Boolean);
+      return multi ? files : files[0];
+    }
+    if (t === 'kdialog') {
+      const r = _spawn('kdialog', ['--getopenfilename', initDir, opts.filter ?? '*', '--title', title]);
+      return r.code === 0 ? r.stdout.trim() : null;
+    }
+    return null;
+  },
+
+  /**
+   * Show a folder/directory picker.
+   * @returns {string|null}
+   */
+  folderPicker(opts = {}) {
+    const title  = opts.title ?? 'Select Folder';
+    const initDir= opts.initialDir ?? os.homedir();
+
+    if (IS_MACOS) {
+      const r = _osascript(`POSIX path of (choose folder with prompt "${_escAS(title)}" default location "${_escAS(initDir)}")`);
+      return r ? r.trim() : null;
+    }
+    if (IS_WINDOWS) {
+      const r = _pwsh(`
+        Add-Type -AssemblyName System.Windows.Forms
+        $d = New-Object System.Windows.Forms.FolderBrowserDialog
+        $d.Description = '${title.replace(/'/g, "''")}'; $d.SelectedPath = '${initDir.replace(/'/g, "''")}'
+        if ($d.ShowDialog() -eq 'OK') { $d.SelectedPath } else { '' }
+      `).trim();
+      return r || null;
+    }
+    const t = _linuxDialog();
+    if (t === 'zenity') {
+      const r = _spawn('zenity', ['--file-selection', '--directory', `--title=${title}`, `--filename=${initDir}/`]);
+      return r.code === 0 ? r.stdout.trim() : null;
+    }
+    if (t === 'kdialog') {
+      const r = _spawn('kdialog', ['--getexistingdirectory', initDir, '--title', title]);
+      return r.code === 0 ? r.stdout.trim() : null;
+    }
+    return null;
+  },
+
+  /**
+   * Show a color picker dialog.
+   * @returns {{ hex: string, r: number, g: number, b: number }|null}
+   */
+  colorPicker(opts = {}) {
+    const initial = opts.color ?? '#ffffff';
+    if (IS_MACOS) {
+      // AppleScript doesn't have a native color picker, use choose color
+      const r = _osascript(`set c to choose color default color {65535, 65535, 65535}\nreturn c`);
+      // Returns e.g. "{65535, 32768, 0}"
+      const m = r.match(/(\d+),\s*(\d+),\s*(\d+)/);
+      if (!m) return null;
+      const [rv, gv, bv] = [Math.round(+m[1]/257), Math.round(+m[2]/257), Math.round(+m[3]/257)];
+      const hex = '#' + [rv, gv, bv].map(v => v.toString(16).padStart(2,'0')).join('');
+      return { hex, r: rv, g: gv, b: bv };
+    }
+    if (IS_WINDOWS) {
+      const r = _pwsh(`
+        Add-Type -AssemblyName System.Windows.Forms
+        $d = New-Object System.Windows.Forms.ColorDialog
+        if ($d.ShowDialog() -eq 'OK') { "$($d.Color.R) $($d.Color.G) $($d.Color.B)" } else { '' }
+      `).trim();
+      if (!r) return null;
+      const [rv, gv, bv] = r.split(' ').map(Number);
+      const hex = '#' + [rv, gv, bv].map(v => v.toString(16).padStart(2,'0')).join('');
+      return { hex, r: rv, g: gv, b: bv };
+    }
+    const t = _linuxDialog();
+    if (t === 'zenity') {
+      const r = _spawn('zenity', ['--color-selection', `--color=${initial}`]);
+      if (r.code !== 0) return null;
+      const s = r.stdout.trim(); // "rgb(r,g,b)" or "#RRGGBB"
+      const m = s.match(/rgb\((\d+),\s*(\d+),\s*(\d+)\)/) ?? s.match(/#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})/i);
+      if (!m) return null;
+      const [rv, gv, bv] = s.startsWith('rgb') ? [+m[1], +m[2], +m[3]] : [parseInt(m[1],16), parseInt(m[2],16), parseInt(m[3],16)];
+      const hex = '#' + [rv, gv, bv].map(v => v.toString(16).padStart(2,'0')).join('');
+      return { hex, r: rv, g: gv, b: bv };
+    }
+    if (t === 'kdialog') {
+      const r = _spawn('kdialog', ['--getcolor', '--default', initial]);
+      if (r.code !== 0) return null;
+      const hex = r.stdout.trim();
+      const rv = parseInt(hex.slice(1,3),16), gv = parseInt(hex.slice(3,5),16), bv = parseInt(hex.slice(5,7),16);
+      return { hex, r: rv, g: gv, b: bv };
+    }
+    return null;
+  },
+
+  /**
+   * Show a date picker dialog.
+   * @returns {string|null}  ISO date string 'YYYY-MM-DD'
+   */
+  datePicker(opts = {}) {
+    const title = opts.title ?? 'Select Date';
+    if (IS_ANDROID) {
+      const r = _spawn('termux-dialog', ['datepicker', '-t', title]);
+      try { const j = JSON.parse(r.stdout); return j.text ?? null; } catch { return null; }
+    }
+    const t = _linuxDialog();
+    if (t === 'yad') {
+      const r = _spawn('yad', ['--calendar', `--title=${title}`, '--date-format=%Y-%m-%d']);
+      return r.code === 0 ? r.stdout.trim() : null;
+    }
+    if (t === 'zenity') {
+      const r = _spawn('zenity', ['--calendar', `--title=${title}`, '--date-format=%Y-%m-%d']);
+      return r.code === 0 ? r.stdout.trim() : null;
+    }
+    if (IS_MACOS) {
+      // Fallback: prompt
+      return Dialog.prompt('Enter date (YYYY-MM-DD)', new Date().toISOString().slice(0,10), title);
+    }
+    if (IS_WINDOWS) {
+      return Dialog.prompt('Enter date (YYYY-MM-DD)', new Date().toISOString().slice(0,10), title);
+    }
+    return null;
+  },
+
+  /**
+   * Show a list selection dialog.
+   * @param {string[]} items
+   * @param {object} [opts]
+   * @param {boolean} [opts.multiple=false]
+   * @returns {string|string[]|null}
+   */
+  selectList(items, opts = {}) {
+    const title  = opts.title    ?? 'Select';
+    const prompt = opts.prompt   ?? 'Choose an item:';
+    const multi  = opts.multiple ?? false;
+
+    if (IS_MACOS) {
+      const list = items.map(i => `"${_escAS(i)}"`).join(', ');
+      const r = _osascript(
+        `choose from list {${list}} with title "${_escAS(title)}" with prompt "${_escAS(prompt)}"` +
+        (multi ? ' with multiple selections allowed' : '')
+      );
+      if (!r || r === 'false') return null;
+      const selected = r.split(', ');
+      return multi ? selected : selected[0];
+    }
+    if (IS_WINDOWS) {
+      const list = items.map(i => `'${i.replace(/'/g, "''")}'`).join(',');
+      const r = _pwsh(`
+        Add-Type -AssemblyName System.Windows.Forms
+        $f = New-Object System.Windows.Forms.Form; $f.Text = '${title.replace(/'/g, "''")}'; $f.Width = 400; $f.Height = 500; $f.StartPosition = 'CenterScreen'
+        $lb = New-Object System.Windows.Forms.ListBox; $lb.Dock = 'Fill'; $lb.SelectionMode = '${multi ? 'MultiSimple' : 'One'}'
+        @(${list}) | ForEach-Object { $lb.Items.Add($_) | Out-Null }
+        $ok = New-Object System.Windows.Forms.Button; $ok.Text = 'OK'; $ok.DialogResult = 'OK'; $ok.Dock = 'Bottom'
+        $f.Controls.AddRange(@($lb, $ok)); $f.AcceptButton = $ok
+        if ($f.ShowDialog() -eq 'OK') { $lb.SelectedItems -join '\\n' } else { '' }
+      `).trim();
+      if (!r) return null;
+      const selected = r.split('\\n').filter(Boolean);
+      return multi ? selected : selected[0];
+    }
+    if (IS_ANDROID) {
+      const r = _spawn('termux-dialog', ['radio', '-t', title, '-v', items.join(',')]);
+      try { const j = JSON.parse(r.stdout); return j.text ?? null; } catch { return null; }
+    }
+    const t = _linuxDialog();
+    if (t === 'zenity') {
+      const colArgs = items.flatMap(i => [multi ? 'TRUE' : 'FALSE', i]);
+      const r = _spawn('zenity', ['--list', `--title=${title}`, `--text=${prompt}`,
+        '--column=Select', '--column=Item', '--checklist', ...colArgs]);
+      if (r.code !== 0) return null;
+      const sel = r.stdout.trim().split('|').filter(Boolean);
+      return multi ? sel : sel[0] ?? null;
+    }
+    if (t === 'kdialog') {
+      const itemArgs = items.flatMap(i => [i, i, 'off']);
+      const r = _spawn('kdialog', [multi ? '--checklist' : '--menu', prompt, '--title', title, ...itemArgs]);
+      if (r.code !== 0) return null;
+      const sel = r.stdout.trim().split('\n').filter(Boolean);
+      return multi ? sel : sel[0] ?? null;
+    }
+    return null;
+  },
+
+  /** Show a progress bar (returns a handle with .update(n, text) and .close()). */
+  progress(title = 'Loading...', total = 100) {
+    if (IS_MACOS) {
+      // Display a progress bar via AppleScript (display dialog workaround)
+      let current = 0;
+      const close = () => {};
+      const update = (n, text) => { current = n; };
+      return { update, close, get value() { return current; } };
+    }
+    if (IS_LINUX || IS_ANDROID) {
+      const t = _linuxDialog();
+      if (t === 'zenity') {
+        const child = spawn('zenity', ['--progress', `--title=${title}`, '--percentage=0', '--auto-close'], { stdio: ['pipe', 'ignore', 'ignore'] });
+        return {
+          update(n, text = '') { child.stdin.write(`${Math.round(n)}\\n# ${text}\\n`); },
+          close() { child.stdin.end(); child.kill(); },
+        };
+      }
+    }
+    return { update() {}, close() {} };
+  },
+};
+
+// ══════════════════════════════════════════════════════════════════════════════
+//  4. MENU — System Tray / Menu Bar / Context Menu
+// ══════════════════════════════════════════════════════════════════════════════
+
+const Menu = {
+  /**
+   * Show a context/popup menu and return selected item.
+   * On platforms without native menus, falls back to Dialog.selectList.
+   * @param {string[]} items
+   * @param {object} [opts]
+   * @returns {string|null}
+   */
+  context(items, opts = {}) {
+    const title = opts.title ?? 'Menu';
+    if (IS_MACOS) {
+      const list  = items.map(i => `"${_escAS(i)}"`).join(', ');
+      const r = _osascript(`choose from list {${list}} with title "${_escAS(title)}"`);
+      return (!r || r === 'false') ? null : r.trim();
+    }
+    if (IS_LINUX) {
+      const t = _linuxDialog();
+      if (t === 'zenity') {
+        const args = ['--list', `--title=${title}`, '--column=Item', ...items];
+        const r = _spawn('zenity', args);
+        return r.code === 0 ? r.stdout.trim() : null;
+      }
+      if (t === 'yad') {
+        const args = ['--list', `--title=${title}`, '--column=Item', ...items, '--no-headers'];
+        const r = _spawn('yad', args);
+        return r.code === 0 ? r.stdout.trim().replace(/\|$/, '') : null;
+      }
+    }
+    return Dialog.selectList(items, opts);
+  },
+
+  /**
+   * Spawn a persistent system tray icon (Linux only via yad --notification).
+   * Returns a handle with .update(tooltip) and .destroy().
+   */
+  tray(icon, tooltip = '', menuItems = []) {
+    if (IS_LINUX && _run('which yad').code === 0) {
+      const menu  = menuItems.map(m => `${m.label}!${m.cmd ?? 'echo ' + m.label}`).join('!');
+      const args  = ['--notification', `--image=${icon}`, `--text=${tooltip}`];
+      if (menu) args.push(`--menu=${menu}`);
+      const child = spawn('yad', args, { detached: true, stdio: 'ignore' });
+      child.unref();
+      return {
+        update(tip) { /* yad --notification doesn't support live update easily */ },
+        destroy() { child.kill(); },
+      };
+    }
+    if (IS_MACOS) {
+      // BitBar/xbar style — can only open/write to plugin directory
+      return { update() {}, destroy() {} };
+    }
+    return { update() {}, destroy() {} };
+  },
+};
+
+// ══════════════════════════════════════════════════════════════════════════════
+//  5. KEYBOARD — Simulate Keystrokes / Hotkeys
+// ══════════════════════════════════════════════════════════════════════════════
+
+const Keyboard = {
+  /**
+   * Type a string of text.
+   * @param {string} text
+   */
+  type(text) {
+    text = String(text);
+    if (IS_MACOS) {
+      _osascript(`tell application "System Events" to keystroke "${_escAS(text)}"`);
+    } else if (IS_WINDOWS) {
+      _pwsh(`
+        Add-Type -AssemblyName System.Windows.Forms
+        [System.Windows.Forms.SendKeys]::SendWait('${text.replace(/[+^%~(){}]/g, '{$&}').replace(/'/g, "''")}')
+      `);
+    } else if (IS_LINUX) {
+      if (_run('which xdotool').code === 0) _spawn('xdotool', ['type', '--clearmodifiers', text]);
+    } else if (IS_ANDROID) {
+      _spawn('termux-clipboard-set', [text]);
+      // Cannot type directly without accessibility service
+    }
+  },
+
+  /**
+   * Press a key or key combination.
+   * @param {string} key  e.g. 'Return', 'ctrl+c', 'cmd+shift+4', 'F5', 'Escape'
+   */
+  press(key) {
+    key = String(key);
+    if (IS_MACOS) {
+      // Map common names to AppleScript key codes / keystroke format
+      const AS_KEYS = { Return: 'return', Escape: 'escape', Delete: 'delete', Tab: 'tab', Space: 'space',
+        F1:'f1',F2:'f2',F3:'f3',F4:'f4',F5:'f5',F6:'f6',F7:'f7',F8:'f8',F9:'f9',F10:'f10',F11:'f11',F12:'f12' };
+      const parts = key.toLowerCase().split('+');
+      const main  = parts[parts.length - 1];
+      const mods  = parts.slice(0, -1);
+      const modStr = mods.map(m => ({
+        ctrl: 'control down', cmd: 'command down', shift: 'shift down', alt: 'option down', option: 'option down',
+      }[m] ?? '')).filter(Boolean).join(', ');
+      const asKey = AS_KEYS[parts[parts.length - 1]] ?? main;
+      _osascript(`tell application "System Events" to keystroke "${asKey}" using {${modStr}}`);
+    } else if (IS_WINDOWS) {
+      const WIN_KEYS = { ctrl: '^', shift: '+', alt: '%', Return: '~', Escape: '{ESC}', Tab: '{TAB}',
+        Delete: '{DELETE}', BackSpace: '{BACKSPACE}', Up: '{UP}', Down: '{DOWN}', Left: '{LEFT}', Right: '{RIGHT}' };
+      let combo = key;
+      for (const [k, v] of Object.entries(WIN_KEYS)) combo = combo.replace(new RegExp(k, 'gi'), v);
+      _pwsh(`Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('${combo.replace(/'/g, "''")}')`);
+    } else if (IS_LINUX) {
+      if (_run('which xdotool').code === 0) _spawn('xdotool', ['key', '--clearmodifiers', key.replace(/cmd/gi, 'super')]);
+    }
+  },
+
+  /**
+   * Hold a key down, run fn, then release (macOS / Linux xdotool).
+   * @param {string} key
+   * @param {Function} fn
+   */
+  hold(key, fn) {
+    if (IS_LINUX && _run('which xdotool').code === 0) {
+      _spawn('xdotool', ['keydown', key]);
+      try { fn(); } finally { _spawn('xdotool', ['keyup', key]); }
+    } else {
+      fn();
+    }
+  },
+
+  /** Get the clipboard text content. */
+  getClipboard() {
+    if (IS_MACOS)   return _out('pbpaste');
+    if (IS_WINDOWS) return _pwsh('Get-Clipboard').trim();
+    if (IS_ANDROID) return _out('termux-clipboard-get');
+    if (IS_LINUX) {
+      if (_run('which xclip').code  === 0) return _out('xclip -selection clipboard -o');
+      if (_run('which xsel').code   === 0) return _out('xsel --clipboard --output');
+      if (_run('which wl-paste').code === 0) return _out('wl-paste');
+    }
+    return '';
+  },
+
+  /** Set clipboard text content. */
+  setClipboard(text) {
+    text = String(text);
+    if (IS_MACOS)   { const r = spawnSync('pbcopy', [], { input: text, encoding: 'utf8' }); return; }
+    if (IS_WINDOWS) { _pwsh(`Set-Clipboard '${text.replace(/'/g, "''")}'`); return; }
+    if (IS_ANDROID) { _spawn('termux-clipboard-set', [text]); return; }
+    if (IS_LINUX) {
+      if (_run('which xclip').code  === 0) { spawnSync('xclip', ['-selection', 'clipboard'], { input: text, encoding: 'utf8' }); return; }
+      if (_run('which xsel').code   === 0) { spawnSync('xsel', ['--clipboard', '--input'], { input: text, encoding: 'utf8' }); return; }
+      if (_run('which wl-copy').code === 0) { spawnSync('wl-copy', [], { input: text, encoding: 'utf8' }); }
+    }
+  },
+};
+
+// ══════════════════════════════════════════════════════════════════════════════
+//  6. MOUSE — Cursor Control
+// ══════════════════════════════════════════════════════════════════════════════
+
+const Mouse = {
+  /**
+   * Move the cursor to absolute screen coordinates.
+   * @param {number} x
+   * @param {number} y
+   */
+  move(x, y) {
+    x = Math.round(x); y = Math.round(y);
+    if (IS_MACOS)   _spawn('cliclick', [`m:${x},${y}`]);
+    else if (IS_WINDOWS) _pwsh(`Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.Cursor]::Position = New-Object System.Drawing.Point(${x}, ${y})`);
+    else if (IS_LINUX && _run('which xdotool').code === 0) _spawn('xdotool', ['mousemove', String(x), String(y)]);
+  },
+
+  /**
+   * Click at current position or given coordinates.
+   * @param {number} [x]
+   * @param {number} [y]
+   * @param {'left'|'right'|'middle'} [button='left']
+   */
+  click(x, y, button = 'left') {
+    const btn = { left: 1, middle: 2, right: 3 };
+    if (x !== undefined) Mouse.move(x, y);
+    if (IS_MACOS) {
+      const action = { left: 'c', right: 'rc', middle: 'mc' }[button] ?? 'c';
+      if (x !== undefined) _spawn('cliclick', [`${action}:${Math.round(x)},${Math.round(y)}`]);
+      else _spawn('cliclick', [action]);
+    } else if (IS_WINDOWS) {
+      const btnNum = btn[button] ?? 1;
+      _pwsh(`
+        Add-Type -AssemblyName System.Windows.Forms
+        $pos = [System.Windows.Forms.Cursor]::Position
+        Add-Type @'
+        using System; using System.Runtime.InteropServices;
+        public class Mouse { [DllImport("user32.dll")] public static extern void mouse_event(int f, int x, int y, int d, int e); }
+'@
+        [Mouse]::mouse_event(${btnNum === 1 ? 2 : btnNum === 2 ? 8 : 32}, 0, 0, 0, 0)
+        [Mouse]::mouse_event(${btnNum === 1 ? 4 : btnNum === 2 ? 16 : 64}, 0, 0, 0, 0)
+      `);
+    } else if (IS_LINUX && _run('which xdotool').code === 0) {
+      _spawn('xdotool', ['click', String(btn[button] ?? 1)]);
+    }
+  },
+
+  /** Double-click. */
+  doubleClick(x, y) {
+    if (IS_MACOS) {
+      if (x !== undefined) _spawn('cliclick', [`dc:${Math.round(x)},${Math.round(y)}`]);
+      else _spawn('cliclick', ['dc']);
+    } else {
+      Mouse.click(x, y); Mouse.click(x, y);
+    }
+  },
+
+  /** Right-click. */
+  rightClick(x, y) { Mouse.click(x, y, 'right'); },
+
+  /** Scroll up or down. */
+  scroll(direction = 'down', amount = 3) {
+    if (IS_MACOS) _spawn('cliclick', [`kd:${direction === 'down' ? 'page-down' : 'page-up'}`]);
+    else if (IS_LINUX && _run('which xdotool').code === 0) {
+      const btn = direction === 'down' ? 5 : 4;
+      for (let i = 0; i < amount; i++) _spawn('xdotool', ['click', String(btn)]);
+    }
+  },
+
+  /** Get current cursor position. */
+  position() {
+    if (IS_MACOS) {
+      const r = _osascript('tell application "System Events" to return position of mouse cursor');
+      const m = r.match(/(\d+),\s*(\d+)/);
+      return m ? { x: +m[1], y: +m[2] } : { x: 0, y: 0 };
+    }
+    if (IS_WINDOWS) {
+      const r = _pwsh(`$p=[System.Windows.Forms.Cursor]::Position; "$($p.X),$($p.Y)"`).trim();
+      const [x, y] = r.split(',').map(Number);
+      return { x, y };
+    }
+    if (IS_LINUX && _run('which xdotool').code === 0) {
+      const r = _out('xdotool getmouselocation --shell');
+      const m = r.match(/X=(\d+)\s+Y=(\d+)/);
+      return m ? { x: +m[1], y: +m[2] } : { x: 0, y: 0 };
+    }
+    return { x: 0, y: 0 };
+  },
+
+  /** Drag from (x1,y1) to (x2,y2). */
+  drag(x1, y1, x2, y2) {
+    if (IS_LINUX && _run('which xdotool').code === 0) {
+      _spawn('xdotool', ['mousemove', String(x1), String(y1)]);
+      _spawn('xdotool', ['mousedown', '1']);
+      _spawn('xdotool', ['mousemove', String(x2), String(y2)]);
+      _spawn('xdotool', ['mouseup', '1']);
+    } else if (IS_MACOS) {
+      _spawn('cliclick', [`dd:${x1},${y1}`, `du:${x2},${y2}`]);
+    }
+  },
+};
+
+// ══════════════════════════════════════════════════════════════════════════════
+//  7. SCREEN — Screenshots / Display Info
+// ══════════════════════════════════════════════════════════════════════════════
+
+const Screen = {
+  /**
+   * Take a screenshot.
+   * @param {string} [outputPath]  destination file (PNG)
+   * @param {object} [opts]
+   * @param {object} [opts.region]  { x, y, w, h }
+   * @returns {string}  path to screenshot file
+   */
+  screenshot(outputPath, opts = {}) {
+    outputPath = outputPath ?? path.join(os.tmpdir(), `kitos_screenshot_${Date.now()}.png`);
+
+    if (IS_MACOS) {
+      const args = ['-x']; // silent
+      if (opts.region) {
+        const { x, y, w, h } = opts.region;
+        args.push('-R', `${x},${y},${w},${h}`);
+      }
+      args.push(outputPath);
+      _spawn('screencapture', args);
+    } else if (IS_WINDOWS) {
+      _pwsh(`
+        Add-Type -AssemblyName System.Windows.Forms
+        Add-Type -AssemblyName System.Drawing
+        $bounds = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds
+        ${opts.region ? `$bounds = New-Object System.Drawing.Rectangle(${opts.region.x},${opts.region.y},${opts.region.w},${opts.region.h})` : ''}
+        $bmp = New-Object System.Drawing.Bitmap($bounds.Width, $bounds.Height)
+        $g = [System.Drawing.Graphics]::FromImage($bmp)
+        $g.CopyFromScreen($bounds.Location, [System.Drawing.Point]::Empty, $bounds.Size)
+        $bmp.Save('${outputPath.replace(/'/g, "''")}')
+        $g.Dispose(); $bmp.Dispose()
+      `);
+    } else if (IS_ANDROID) {
+      _spawn('termux-screenshot', ['-f', outputPath]);
+    } else if (IS_LINUX) {
+      if (_run('which scrot').code === 0) {
+        const args = [outputPath];
+        if (opts.region) {
+          const { x, y, w, h } = opts.region;
+          args.unshift(`-a`, `${x},${y},${w},${h}`);
+        }
+        _spawn('scrot', args);
+      } else if (_run('which gnome-screenshot').code === 0) {
+        _spawn('gnome-screenshot', ['-f', outputPath]);
+      } else if (_run('which import').code === 0) { // ImageMagick
+        _spawn('import', ['-window', 'root', outputPath]);
+      } else if (_run('which spectacle').code === 0) {
+        _spawn('spectacle', ['-n', '-o', outputPath]);
+      }
+    }
+    return outputPath;
+  },
+
+  /**
+   * Get all monitor/display info.
+   * @returns {Array<{ id, width, height, x, y, primary, dpi }>}
+   */
+  monitors() {
+    if (IS_MACOS) {
+      const r = _out('system_profiler SPDisplaysDataType');
+      // Parse resolution lines: e.g. "Resolution: 2560 x 1440"
+      const monitors = [];
+      const lines = r.split('\n');
+      let current = null;
+      for (const line of lines) {
+        if (line.match(/\s+Resolution:\s+(\d+) x (\d+)/)) {
+          const m = line.match(/(\d+) x (\d+)/);
+          if (m) monitors.push({ width: +m[1], height: +m[2], x: 0, y: 0, primary: monitors.length === 0 });
+        }
+      }
+      return monitors.length ? monitors : [{ width: 1920, height: 1080, x: 0, y: 0, primary: true }];
+    }
+    if (IS_WINDOWS) {
+      const r = _pwsh(`Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.Screen]::AllScreens | ForEach-Object { "$($_.Bounds.X),$($_.Bounds.Y),$($_.Bounds.Width),$($_.Bounds.Height),$($_.Primary)" }`);
+      return r.trim().split('\n').filter(Boolean).map((line, i) => {
+        const [x, y, w, h, primary] = line.trim().split(',');
+        return { id: i, x: +x, y: +y, width: +w, height: +h, primary: primary === 'True' };
+      });
+    }
+    if (IS_ANDROID) {
+      const r = _out('termux-display-info 2>/dev/null');
+      try { return [JSON.parse(r)]; } catch { return [{ width: 1080, height: 1920, primary: true }]; }
+    }
+    if (IS_LINUX) {
+      const r = _out('xrandr 2>/dev/null');
+      const monitors = [];
+      for (const m of r.matchAll(/(\S+) connected(?: primary)? (\d+)x(\d+)\+(\d+)\+(\d+)/g)) {
+        monitors.push({ id: m[1], width: +m[2], height: +m[3], x: +m[4], y: +m[5], primary: r.includes(`${m[1]} connected primary`) });
+      }
+      return monitors.length ? monitors : [{ width: 1920, height: 1080, primary: true }];
+    }
+    return [];
+  },
+
+  /** Get primary screen dimensions. */
+  size() {
+    const m = Screen.monitors().find(m => m.primary) ?? Screen.monitors()[0];
+    return m ? { width: m.width, height: m.height } : { width: 0, height: 0 };
+  },
+
+  /**
+   * Get the pixel color at screen coordinates.
+   * @returns {{ r: number, g: number, b: number, hex: string }|null}
+   */
+  pixelColor(x, y) {
+    if (IS_MACOS) {
+      // Use screencapture + sips to read one pixel
+      const tmp = path.join(os.tmpdir(), 'kitos_px.png');
+      _spawn('screencapture', ['-x', '-R', `${x},${y},1,1`, tmp]);
+      const r = _out(`sips -g all ${tmp} 2>/dev/null`);
+      fs.unlinkSync(tmp);
+      // Parse pixel data (hex) from sips
+      const m = r.match(/pixelColor: ([0-9a-f]+)/i);
+      if (!m) return null;
+      const hex = '#' + m[1].slice(0, 6);
+      return { r: parseInt(hex.slice(1,3),16), g: parseInt(hex.slice(3,5),16), b: parseInt(hex.slice(5,7),16), hex };
+    }
+    if (IS_LINUX && _run('which import').code === 0) {
+      const r = _out(`import -window root -crop 1x1+${x}+${y} txt:- 2>/dev/null`);
+      const m = r.match(/#([0-9A-F]{6})/i);
+      if (!m) return null;
+      const hex = '#' + m[1];
+      return { r: parseInt(hex.slice(1,3),16), g: parseInt(hex.slice(3,5),16), b: parseInt(hex.slice(5,7),16), hex };
+    }
+    return null;
+  },
+
+  /** Get DPI of primary monitor. */
+  dpi() {
+    if (IS_MACOS) {
+      const r = _out('system_profiler SPDisplaysDataType');
+      const m = r.match(/(\d+) dpi/i);
+      return m ? +m[1] : 96;
+    }
+    if (IS_LINUX) {
+      const r = _out('xdpyinfo 2>/dev/null');
+      const m = r.match(/(\d+)x(\d+) dots per inch/);
+      return m ? +m[1] : 96;
+    }
+    return 96;
+  },
+};
+
+// ══════════════════════════════════════════════════════════════════════════════
+//  8. AUDIO — Sound Playback / Beep / Volume
+// ══════════════════════════════════════════════════════════════════════════════
+
+const Audio = {
+  /**
+   * Play a sound file.
+   * @param {string} filePath
+   * @param {object} [opts]
+   * @param {boolean} [opts.async]
+   * @param {number}  [opts.volume]  0.0–1.0
+   */
+  play(filePath, opts = {}) {
+    filePath = path.resolve(filePath);
+    if (IS_MACOS) {
+      const args = [filePath];
+      if (opts.volume !== undefined) args.push('--volume', String(Math.round(opts.volume * 100)));
+      opts.async ? spawn('afplay', args, { detached: true, stdio: 'ignore' }).unref()
+                 : _spawn('afplay', args);
+    } else if (IS_WINDOWS) {
+      const cmd = `(New-Object Media.SoundPlayer '${filePath.replace(/'/g, "''")}').PlaySync()`;
+      opts.async ? spawn('powershell', ['-NoProfile', '-Command', cmd], { detached: true, stdio: 'ignore' }).unref()
+                 : _pwsh(cmd);
+    } else if (IS_ANDROID) {
+      _spawn('termux-media-player', ['play', filePath]);
+    } else if (IS_LINUX) {
+      for (const player of ['paplay', 'aplay', 'mpg123', 'ffplay', 'mplayer', 'cvlc']) {
+        if (_run(`which ${player}`).code === 0) {
+          const args = player === 'ffplay' ? ['-nodisp', '-autoexit', filePath]
+                     : player === 'cvlc'   ? ['--play-and-exit', filePath]
+                     : [filePath];
+          opts.async ? spawn(player, args, { detached: true, stdio: 'ignore' }).unref()
+                     : _spawn(player, args);
+          return;
+        }
+      }
+    }
+  },
+
+  /** Play a system beep / bell sound. */
+  beep(count = 1) {
+    for (let i = 0; i < count; i++) {
+      if (IS_MACOS)   _osascript('beep');
+      else if (IS_WINDOWS) _pwsh('[Console]::Beep(800, 200)');
+      else if (IS_ANDROID) _spawn('termux-vibrate', ['-d', '100']);
+      else { process.stdout.write('\x07'); }
+    }
+  },
+
+  /**
+   * Get system volume (0–100).
+   * @returns {number}
+   */
+  getVolume() {
+    if (IS_MACOS) {
+      const r = _out('osascript -e "output volume of (get volume settings)"');
+      return parseInt(r) || 0;
+    }
+    if (IS_WINDOWS) {
+      const r = _pwsh(`(Get-AudioDevice -Playback).Volume`);
+      return Math.round(parseFloat(r) * 100) || 0;
+    }
+    if (IS_ANDROID) {
+      try { return JSON.parse(_out('termux-volume')).find(v => v.stream === 'music')?.volume ?? 50; } catch { return 50; }
+    }
+    if (IS_LINUX) {
+      const r = _out('amixer sget Master 2>/dev/null || pactl get-sink-volume @DEFAULT_SINK@ 2>/dev/null');
+      const m = r.match(/(\d+)%/);
+      return m ? +m[1] : 0;
+    }
+    return 0;
+  },
+
+  /**
+   * Set system volume.
+   * @param {number} level  0–100
+   */
+  setVolume(level) {
+    level = Math.max(0, Math.min(100, Math.round(level)));
+    if (IS_MACOS) {
+      _osascript(`set volume output volume ${level}`);
+    } else if (IS_WINDOWS) {
+      _pwsh(`$obj = New-Object -ComObject WScript.Shell; for($i=0;$i -lt 50;$i++){$obj.SendKeys([char]174)}; for($i=0;$i -lt [math]::Round(${level}/2);$i++){$obj.SendKeys([char]175)}`);
+    } else if (IS_ANDROID) {
+      _spawn('termux-volume', ['music', String(level)]);
+    } else if (IS_LINUX) {
+      if (_run('which pactl').code === 0) _spawn('pactl', ['set-sink-volume', '@DEFAULT_SINK@', `${level}%`]);
+      else _spawn('amixer', ['sset', 'Master', `${level}%`]);
+    }
+  },
+
+  /** Get mute state. */
+  isMuted() {
+    if (IS_MACOS) return _out('osascript -e "output muted of (get volume settings)"').trim() === 'true';
+    if (IS_LINUX) {
+      const r = _out('amixer sget Master 2>/dev/null');
+      return r.includes('[off]');
+    }
+    return false;
+  },
+
+  /** Mute audio. */
+  mute() {
+    if (IS_MACOS) _osascript('set volume with output muted');
+    else if (IS_WINDOWS) _pwsh('(New-Object -ComObject WScript.Shell).SendKeys([char]173)');
+    else if (IS_LINUX) {
+      if (_run('which pactl').code === 0) _spawn('pactl', ['set-sink-mute', '@DEFAULT_SINK@', '1']);
+      else _spawn('amixer', ['sset', 'Master', 'mute']);
+    }
+  },
+
+  /** Unmute audio. */
+  unmute() {
+    if (IS_MACOS) _osascript('set volume without output muted');
+    else if (IS_WINDOWS) _pwsh('(New-Object -ComObject WScript.Shell).SendKeys([char]173)');
+    else if (IS_LINUX) {
+      if (_run('which pactl').code === 0) _spawn('pactl', ['set-sink-mute', '@DEFAULT_SINK@', '0']);
+      else _spawn('amixer', ['sset', 'Master', 'unmute']);
+    }
+  },
+
+  /** Toggle mute. */
+  toggleMute() { Audio.isMuted() ? Audio.unmute() : Audio.mute(); },
+
+  /** List audio output devices. */
+  devices() {
+    if (IS_MACOS) {
+      return _out('system_profiler SPAudioDataType').split('\n')
+        .filter(l => l.match(/^\s{6}\S/))
+        .map(l => l.trim());
+    }
+    if (IS_LINUX && _run('which pactl').code === 0) {
+      return _out('pactl list sinks short').split('\n').filter(Boolean).map(l => {
+        const p = l.trim().split('\t');
+        return { id: p[0], name: p[1], driver: p[2], state: p[4] };
+      });
+    }
+    if (IS_ANDROID) {
+      try { return JSON.parse(_out('termux-volume')); } catch { return []; }
+    }
+    return [];
+  },
+
+  /** Stop media playback (Android). */
+  stop() {
+    if (IS_ANDROID) _spawn('termux-media-player', ['stop']);
+    if (IS_MACOS)   _run('killall afplay 2>/dev/null');
+  },
+};
+
+// ══════════════════════════════════════════════════════════════════════════════
+//  9. CAMERA — Webcam / Photo Capture
+// ══════════════════════════════════════════════════════════════════════════════
+
+const Camera = {
+  /**
+   * Capture a photo from the default camera.
+   * @param {string} [outputPath]
+   * @param {object} [opts]
+   * @param {string} [opts.device]  camera device (Linux)
+   * @returns {string}  path to captured image
+   */
+  capture(outputPath, opts = {}) {
+    outputPath = outputPath ?? path.join(os.tmpdir(), `kitos_cam_${Date.now()}.jpg`);
+    if (IS_ANDROID) {
+      _spawn('termux-camera-photo', [outputPath]);
+      return outputPath;
+    }
+    if (IS_MACOS) {
+      // imagesnap (brew install imagesnap)
+      if (_run('which imagesnap').code === 0) {
+        _spawn('imagesnap', ['-q', outputPath]);
+        return outputPath;
+      }
+    }
+    if (IS_LINUX) {
+      const device = opts.device ?? '/dev/video0';
+      if (_run('which ffmpeg').code === 0) {
+        _spawn('ffmpeg', ['-y', '-f', 'v4l2', '-i', device, '-frames:v', '1', outputPath]);
+        return outputPath;
+      }
+      if (_run('which fswebcam').code === 0) {
+        _spawn('fswebcam', ['-d', device, '-r', '1280x720', '--no-banner', outputPath]);
+        return outputPath;
+      }
+    }
+    return outputPath;
+  },
+
+  /**
+   * Capture video.
+   * @param {string} outputPath
+   * @param {number} [duration=5]  seconds
+   * @param {object} [opts]
+   * @returns {string}  path to video file
+   */
+  captureVideo(outputPath, duration = 5, opts = {}) {
+    outputPath = outputPath ?? path.join(os.tmpdir(), `kitos_vid_${Date.now()}.mp4`);
+    if (IS_ANDROID) {
+      _spawn('termux-camera-video', [outputPath]);
+      return outputPath;
+    }
+    if (IS_LINUX && _run('which ffmpeg').code === 0) {
+      const device = opts.device ?? '/dev/video0';
+      _spawn('ffmpeg', ['-y', '-f', 'v4l2', '-i', device, '-t', String(duration), outputPath]);
+    }
+    return outputPath;
+  },
+
+  /**
+   * List available camera devices.
+   * @returns {string[]}
+   */
+  devices() {
+    if (IS_ANDROID) {
+      try { return JSON.parse(_out('termux-camera-info') || '[]'); } catch { return []; }
+    }
+    if (IS_MACOS && _run('which imagesnap').code === 0) {
+      return _out('imagesnap -l').split('\n').filter(l => l.startsWith('[') || l.match(/^\s+\S/)).map(l => l.trim()).filter(Boolean);
+    }
+    if (IS_LINUX) {
+      const devices = [];
+      for (let i = 0; i < 8; i++) {
+        if (fs.existsSync(`/dev/video${i}`)) devices.push(`/dev/video${i}`);
+      }
+      return devices;
+    }
+    return [];
+  },
+};
+
+// ══════════════════════════════════════════════════════════════════════════════
+//  10. POWER — Battery / Sleep / Shutdown
+// ══════════════════════════════════════════════════════════════════════════════
+
+const Power = {
+  /**
+   * Get battery information.
+   * @returns {{ level: number, charging: boolean, full: boolean, timeRemaining: number|null }|null}
+   */
+  battery() {
+    if (IS_MACOS) {
+      const r = _out('pmset -g batt');
+      const levelM = r.match(/(\d+)%/);
+      const chargeM = r.match(/AC Power/) ?? r.match(/charging/i);
+      const timeM   = r.match(/(\d+):(\d+) remaining/);
+      return {
+        level: levelM ? +levelM[1] : null,
+        charging: !!chargeM,
+        full: r.includes('fully charged'),
+        timeRemaining: timeM ? +timeM[1] * 60 + +timeM[2] : null,
+      };
+    }
+    if (IS_WINDOWS) {
+      const r = _pwsh(`(Get-WmiObject Win32_Battery) | Select-Object EstimatedChargeRemaining, BatteryStatus | ConvertTo-Csv -NoTypeInformation`);
+      const lines = r.trim().split('\n');
+      if (lines.length < 2) return null;
+      const [level, status] = lines[1].replace(/"/g, '').split(',').map(s => s.trim());
+      return { level: +level, charging: status === '2', full: status === '1', timeRemaining: null };
+    }
+    if (IS_ANDROID) {
+      try { return JSON.parse(_out('termux-battery-status')); } catch { return null; }
+    }
+    if (IS_LINUX) {
+      const battDir = '/sys/class/power_supply';
+      if (!fs.existsSync(battDir)) return null;
+      const batts = fs.readdirSync(battDir).filter(d => d.startsWith('BAT'));
+      if (!batts.length) return null;
+      const batt = path.join(battDir, batts[0]);
+      const read = (f) => { try { return fs.readFileSync(path.join(batt, f), 'utf8').trim(); } catch { return null; } };
+      const cap    = read('capacity');
+      const status = read('status');
+      return {
+        level: cap ? +cap : null,
+        charging: status === 'Charging',
+        full: status === 'Full',
+        timeRemaining: null,
+      };
+    }
+    return null;
+  },
+
+  /** Put the system to sleep. */
+  sleep() {
+    if (IS_MACOS)   _run('pmset sleepnow');
+    else if (IS_WINDOWS) _pwsh('Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.Application]::SetSuspendState("Suspend",$false,$false)');
+    else if (IS_LINUX)   _run('systemctl suspend');
+    else if (IS_ANDROID) _spawn('termux-toast', ['Sleep not supported on Android']);
+  },
+
+  /** Shut down the system. */
+  shutdown(delay = 0) {
+    if (IS_MACOS)   _run(`shutdown -h +${delay}`);
+    else if (IS_WINDOWS) _run(`shutdown /s /t ${delay * 60}`);
+    else if (IS_LINUX)   _run(`shutdown -h +${delay}`);
+  },
+
+  /** Restart the system. */
+  restart(delay = 0) {
+    if (IS_MACOS)   _run(`shutdown -r +${delay}`);
+    else if (IS_WINDOWS) _run(`shutdown /r /t ${delay * 60}`);
+    else if (IS_LINUX)   _run(`shutdown -r +${delay}`);
+  },
+
+  /** Lock the screen. */
+  lock() {
+    if (IS_MACOS) {
+      _run('/System/Library/CoreServices/"Menu Extras"/User.menu/Contents/Resources/CGSession -suspend 2>/dev/null || pmset displaysleepnow');
+    } else if (IS_WINDOWS) {
+      _run('rundll32.exe user32.dll,LockWorkStation');
+    } else if (IS_ANDROID) {
+      _spawn('termux-toast', ['Screen lock not directly supported']);
+    } else if (IS_LINUX) {
+      const lockers = ['gnome-screensaver-command -l', 'xdg-screensaver lock', 'loginctl lock-session', 'xscreensaver-command -lock', 'i3lock'];
+      for (const cmd of lockers) { if (_run(cmd).code === 0) break; }
+    }
+  },
+
+  /** Prevent the system from sleeping (returns a stopper function). */
+  preventSleep(reason = 'Nova process') {
+    let child;
+    if (IS_MACOS) {
+      child = spawn('caffeinate', ['-d', '-i'], { detached: true, stdio: 'ignore' });
+      child.unref();
+    } else if (IS_WINDOWS) {
+      child = spawn('powershell', ['-NoProfile', '-Command',
+        `while ($true) { (New-Object -ComObject WScript.Shell).SendKeys([char]0); Start-Sleep -Seconds 60 }`
+      ], { detached: true, stdio: 'ignore' });
+      child.unref();
+    } else if (IS_LINUX) {
+      if (_run('which systemd-inhibit').code === 0) {
+        child = spawn('systemd-inhibit', ['--what=sleep:idle', '--why=' + reason, 'sleep', 'infinity'], { detached: true, stdio: 'ignore' });
+        child.unref();
+      } else if (_run('which caffeine').code === 0) {
+        child = spawn('caffeine', [], { detached: true, stdio: 'ignore' });
+        child.unref();
+      }
+    } else if (IS_ANDROID) {
+      _spawn('termux-wake-lock');
+    }
+    return () => {
+      if (child) { try { child.kill(); } catch {} }
+      if (IS_ANDROID) _spawn('termux-wake-unlock');
+    };
+  },
+
+  /** Cancel a scheduled shutdown. */
+  cancelShutdown() {
+    if (IS_MACOS || IS_LINUX) _run('shutdown -c 2>/dev/null');
+    else if (IS_WINDOWS) _run('shutdown /a');
+  },
+};
+
+// ══════════════════════════════════════════════════════════════════════════════
+//  11. BRIGHTNESS — Display Brightness
+// ══════════════════════════════════════════════════════════════════════════════
+
+const Brightness = {
+  /**
+   * Get display brightness (0–100).
+   * @param {number} [monitor=0]  monitor index
+   * @returns {number}
+   */
+  get(monitor = 0) {
+    if (IS_MACOS && _run('which brightness').code === 0) {
+      const r = _out('brightness -l');
+      const m = r.match(/display \d+: brightness ([\d.]+)/);
+      return m ? Math.round(parseFloat(m[1]) * 100) : 100;
+    }
+    if (IS_WINDOWS) {
+      const r = _pwsh('(Get-WmiObject -Namespace root/WMI -Class WmiMonitorBrightness).CurrentBrightness');
+      return parseInt(r) || 100;
+    }
+    if (IS_ANDROID) {
+      try { return JSON.parse(_out('termux-brightness'))?.brightness ?? 100; } catch { return 100; }
+    }
+    if (IS_LINUX) {
+      // Try /sys/class/backlight
+      const bl = '/sys/class/backlight';
+      if (fs.existsSync(bl)) {
+        const devices = fs.readdirSync(bl);
+        if (devices.length > 0) {
+          const dev = path.join(bl, devices[monitor] ?? devices[0]);
+          const cur = +fs.readFileSync(path.join(dev, 'brightness'), 'utf8').trim();
+          const max = +fs.readFileSync(path.join(dev, 'max_brightness'), 'utf8').trim();
+          return Math.round((cur / max) * 100);
+        }
+      }
+      if (_run('which xrandr').code === 0) {
+        const r = _out('xrandr --verbose 2>/dev/null');
+        const m = r.match(/Brightness: ([\d.]+)/);
+        return m ? Math.round(parseFloat(m[1]) * 100) : 100;
+      }
+    }
+    return 100;
+  },
+
+  /**
+   * Set display brightness.
+   * @param {number} level  0–100
+   * @param {number} [monitor=0]
+   */
+  set(level, monitor = 0) {
+    level = Math.max(0, Math.min(100, Math.round(level)));
+    if (IS_MACOS && _run('which brightness').code === 0) {
+      _spawn('brightness', [String(level / 100)]);
+    } else if (IS_WINDOWS) {
+      _pwsh(`(Get-WmiObject -Namespace root/WMI -Class WmiMonitorBrightnessMethods).WmiSetBrightness(1, ${level})`);
+    } else if (IS_ANDROID) {
+      _spawn('termux-brightness', [String(Math.round(level * 2.55))]);
+    } else if (IS_LINUX) {
+      const bl = '/sys/class/backlight';
+      if (fs.existsSync(bl)) {
+        const devices = fs.readdirSync(bl);
+        if (devices.length > 0) {
+          const dev = path.join(bl, devices[monitor] ?? devices[0]);
+          const max = +fs.readFileSync(path.join(dev, 'max_brightness'), 'utf8').trim();
+          const val = Math.round((level / 100) * max);
+          try { fs.writeFileSync(path.join(dev, 'brightness'), String(val)); return; } catch {}
+        }
+      }
+      if (_run('which xrandr').code === 0) {
+        const r = _out('xrandr --listactivemonitors 2>/dev/null');
+        const m = r.match(/\d+:\s+\S+\s+(\S+)/g);
+        const displayName = m ? m[monitor ?? 0]?.split(/\s+/).pop() : null;
+        if (displayName) _spawn('xrandr', ['--output', displayName, '--brightness', String(level / 100)]);
+      }
+    }
+  },
+};
+
+// ══════════════════════════════════════════════════════════════════════════════
+//  12. WIFI — Wireless Network
+// ══════════════════════════════════════════════════════════════════════════════
+
+const Wifi = {
+  /**
+   * Get current SSID.
+   * @returns {string|null}
+   */
+  currentSSID() {
+    if (IS_MACOS) {
+      return _out('/System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/airport -I 2>/dev/null').match(/\s+SSID: (.+)/)?.[1]?.trim() ?? null;
+    }
+    if (IS_WINDOWS) {
+      return _out('netsh wlan show interfaces').match(/\s+SSID\s+:\s+(.+)/)?.[1]?.trim() ?? null;
+    }
+    if (IS_ANDROID) {
+      try { return JSON.parse(_out('termux-wifi-connectioninfo'))?.ssid ?? null; } catch { return null; }
+    }
+    if (IS_LINUX) {
+      return (_out('iwgetid -r 2>/dev/null').trim() ||
+             _out('nmcli -t -f active,ssid dev wifi 2>/dev/null').split('\n').find(l => l.startsWith('yes:'))?.split(':')[1]) ?? null;
+    }
+    return null;
+  },
+
+  /**
+   * Get detailed connection info.
+   * @returns {object|null}
+   */
+  connectionInfo() {
+    if (IS_ANDROID) {
+      try { return JSON.parse(_out('termux-wifi-connectioninfo')); } catch { return null; }
+    }
+    if (IS_MACOS) {
+      const r = _out('/System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/airport -I 2>/dev/null');
+      const info = {};
+      for (const m of r.matchAll(/\s+(\S+): (.+)/g)) info[m[1].trim()] = m[2].trim();
+      return info;
+    }
+    if (IS_LINUX) {
+      return { ssid: Wifi.currentSSID(), signal: Wifi.signalStrength() };
+    }
+    return null;
+  },
+
+  /**
+   * Scan for available WiFi networks.
+   * @returns {Array<{ ssid, signal, security, channel }>}
+   */
+  scan() {
+    if (IS_ANDROID) {
+      try { return JSON.parse(_out('termux-wifi-scaninfo') || '[]'); } catch { return []; }
+    }
+    if (IS_MACOS) {
+      const r = _out('/System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/airport -s 2>/dev/null');
+      return r.split('\n').slice(1).filter(Boolean).map(l => {
+        const parts = l.trim().split(/\s+/);
+        return { ssid: parts[0], bssid: parts[1], signal: +parts[2], channel: +parts[3], security: parts.slice(5).join(' ') };
+      });
+    }
+    if (IS_LINUX) {
+      const r = _out('nmcli -t -f SSID,SIGNAL,SECURITY,CHAN dev wifi list 2>/dev/null');
+      return r.split('\n').filter(Boolean).map(l => {
+        const [ssid, signal, security, channel] = l.split(':');
+        return { ssid, signal: +signal, security, channel: +channel };
+      });
+    }
+    if (IS_WINDOWS) {
+      const r = _out('netsh wlan show networks mode=bssid');
+      const networks = [];
+      let current = {};
+      for (const line of r.split('\n')) {
+        const m = line.match(/\s+SSID\s+\d+\s+:\s+(.+)/);  if (m) current = { ssid: m[1].trim() };
+        const s = line.match(/\s+Signal\s+:\s+(\d+)%/);    if (s) current.signal = +s[1];
+        const a = line.match(/\s+Authentication\s+:\s+(.+)/); if (a) { current.security = a[1].trim(); networks.push(current); }
+      }
+      return networks;
+    }
+    return [];
+  },
+
+  /**
+   * Get signal strength in dBm or percent.
+   * @returns {number|null}
+   */
+  signalStrength() {
+    if (IS_ANDROID) {
+      try { return JSON.parse(_out('termux-wifi-connectioninfo'))?.rssi ?? null; } catch { return null; }
+    }
+    if (IS_LINUX) {
+      const r = _out('iwconfig 2>/dev/null');
+      const m = r.match(/Signal level=([\-\d]+) dBm/);
+      return m ? +m[1] : null;
+    }
+    return null;
+  },
+
+  /** Enable WiFi (Android + Linux nmcli). */
+  enable() {
+    if (IS_ANDROID) _spawn('termux-wifi-enable', ['true']);
+    else if (IS_LINUX && _run('which nmcli').code === 0) _spawn('nmcli', ['radio', 'wifi', 'on']);
+    else if (IS_WINDOWS) _run('netsh interface set interface Wi-Fi admin=enabled');
+  },
+
+  /** Disable WiFi. */
+  disable() {
+    if (IS_ANDROID) _spawn('termux-wifi-enable', ['false']);
+    else if (IS_LINUX && _run('which nmcli').code === 0) _spawn('nmcli', ['radio', 'wifi', 'off']);
+    else if (IS_WINDOWS) _run('netsh interface set interface Wi-Fi admin=disabled');
+  },
+};
+
+// ══════════════════════════════════════════════════════════════════════════════
+//  13. BLUETOOTH — Bluetooth Control
+// ══════════════════════════════════════════════════════════════════════════════
+
+const Bluetooth = {
+  /**
+   * Toggle Bluetooth on/off.
+   * @param {boolean} on
+   */
+  setEnabled(on) {
+    if (IS_MACOS)   _run(`blueutil --power ${on ? 1 : 0} 2>/dev/null || echo "install blueutil: brew install blueutil"`);
+    else if (IS_WINDOWS) _pwsh(`Add-Type -AssemblyName System.Runtime.WindowsRuntime; [Windows.Devices.Radios.Radio,Windows.Devices.Radios, ContentType=WindowsRuntime] | Out-Null`);
+    else if (IS_ANDROID) _spawn('termux-bluetooth-scan', on ? ['-le'] : []);
+    else if (IS_LINUX) _run(`rfkill ${on ? 'unblock' : 'block'} bluetooth 2>/dev/null`);
+  },
+
+  /** Is Bluetooth enabled? */
+  isEnabled() {
+    if (IS_MACOS) return _out('blueutil --power 2>/dev/null').trim() === '1';
+    if (IS_LINUX) return _out('rfkill list bluetooth 2>/dev/null').includes('Soft blocked: no');
+    if (IS_ANDROID) { try { return JSON.parse(_out('termux-bluetooth-info 2>/dev/null') || '{}').enabled ?? false; } catch { return false; } }
+    return false;
+  },
+
+  /**
+   * List paired devices.
+   * @returns {Array<{ id, name, connected, paired }>}
+   */
+  pairedDevices() {
+    if (IS_MACOS) {
+      const r = _out('system_profiler SPBluetoothDataType 2>/dev/null');
+      const devices = [];
+      for (const m of r.matchAll(/(\S[\w\s]+):\s*\n\s+Address: ([\w:]+)/g)) {
+        devices.push({ name: m[1].trim(), id: m[2], paired: true, connected: r.includes(`${m[1].trim()}`) });
+      }
+      return devices;
+    }
+    if (IS_LINUX && _run('which bluetoothctl').code === 0) {
+      const r = _out('bluetoothctl devices');
+      return r.split('\n').filter(Boolean).map(l => {
+        const m = l.match(/Device ([\w:]+) (.+)/);
+        return m ? { id: m[1], name: m[2], paired: true } : null;
+      }).filter(Boolean);
+    }
+    if (IS_ANDROID) {
+      try { return JSON.parse(_out('termux-bluetooth-paired-devices 2>/dev/null') || '[]'); } catch { return []; }
+    }
+    return [];
+  },
+
+  /** Scan for nearby Bluetooth devices (Linux bluetoothctl). */
+  scan(durationMs = 5000) {
+    if (IS_LINUX && _run('which bluetoothctl').code === 0) {
+      _run(`bluetoothctl scan on & sleep ${Math.round(durationMs/1000)} && bluetoothctl scan off`);
+      return Bluetooth.pairedDevices();
+    }
+    if (IS_ANDROID) {
+      try { return JSON.parse(_out('termux-bluetooth-scan -d 5000 2>/dev/null') || '[]'); } catch { return []; }
+    }
+    return [];
+  },
+
+  /**
+   * Connect to a device by MAC address.
+   * @param {string} address  e.g. 'AA:BB:CC:DD:EE:FF'
+   */
+  connect(address) {
+    if (IS_LINUX && _run('which bluetoothctl').code === 0) {
+      _run(`bluetoothctl connect ${address}`);
+    } else if (IS_ANDROID) {
+      _spawn('termux-bluetooth-connect', [address]);
+    }
+  },
+
+  /** Disconnect from a device. */
+  disconnect(address) {
+    if (IS_LINUX && _run('which bluetoothctl').code === 0) {
+      _run(`bluetoothctl disconnect ${address}`);
+    }
+  },
+};
+
+// ══════════════════════════════════════════════════════════════════════════════
+//  14. VOLUME — Fine-grained audio volume control
+// ══════════════════════════════════════════════════════════════════════════════
+
+const Volume = {
+  /** Get volume for a specific stream type (Android: music, ring, alarm, notification). */
+  getStream(stream = 'music') {
+    if (IS_ANDROID) {
+      try {
+        const vols = JSON.parse(_out('termux-volume'));
+        const s    = vols.find(v => v.stream === stream);
+        return s ? s.volume : null;
+      } catch { return null; }
+    }
+    return Audio.getVolume();
+  },
+
+  /** Set volume for a specific stream type. */
+  setStream(stream, level) {
+    if (IS_ANDROID) { _spawn('termux-volume', [stream, String(level)]); return; }
+    Audio.setVolume(level);
+  },
+
+  /** Get microphone input level (0–100). */
+  getMicLevel() {
+    if (IS_LINUX && _run('which amixer').code === 0) {
+      const r = _out('amixer sget Capture 2>/dev/null || amixer sget "Mic" 2>/dev/null');
+      const m = r.match(/(\d+)%/);
+      return m ? +m[1] : null;
+    }
+    if (IS_MACOS) {
+      const r = _out('osascript -e "input volume of (get volume settings)"').trim();
+      return parseInt(r) ?? null;
+    }
+    if (IS_WINDOWS) {
+      return parseInt(_pwsh(`[math]::Round((Get-AudioDevice -Microphone).Volume * 100)`) ?? '0');
+    }
+    return null;
+  },
+
+  /** Set microphone input level (0–100). */
+  setMicLevel(level) {
+    level = Math.max(0, Math.min(100, Math.round(level)));
+    if (IS_MACOS) _osascript(`set volume input volume ${level}`);
+    else if (IS_LINUX && _run('which amixer').code === 0) {
+      _spawn('amixer', ['sset', 'Capture', `${level}%`]);
+    } else if (IS_WINDOWS) {
+      _pwsh(`(Get-AudioDevice -Microphone).Volume = ${level / 100}`);
+    }
+  },
+
+  /** List output devices. */
+  outputDevices() { return Audio.devices(); },
+
+  /** Switch default audio output device (Linux PulseAudio). */
+  switchOutput(sinkName) {
+    if (IS_LINUX && _run('which pactl').code === 0) {
+      _spawn('pactl', ['set-default-sink', sinkName]);
+    }
+  },
+
+  // All basic ops delegate to Audio
+  get: () => Audio.getVolume(),
+  set: (l) => Audio.setVolume(l),
+  mute: () => Audio.mute(),
+  unmute: () => Audio.unmute(),
+  toggle: () => Audio.toggleMute(),
+  isMuted: () => Audio.isMuted(),
+};
+
+// ══════════════════════════════════════════════════════════════════════════════
+//  15. TRASH — Send Files to Trash
+// ══════════════════════════════════════════════════════════════════════════════
+
+const Trash = {
+  /**
+   * Move a file or directory to the system trash.
+   * @param {string} filePath
+   * @returns {boolean}
+   */
+  send(filePath) {
+    filePath = path.resolve(filePath);
+    if (IS_MACOS) {
+      const r = _osascript(`tell application "Finder" to delete POSIX file "${_escAS(filePath)}"`);
+      return !r.includes('error');
+    }
+    if (IS_WINDOWS) {
+      const r = _pwsh(`
+        Add-Type -AssemblyName Microsoft.VisualBasic
+        [Microsoft.VisualBasic.FileIO.FileSystem]::DeleteFile('${filePath.replace(/'/g, "''")}', 'OnlyErrorDialogs', 'SendToRecycleBin')
+      `);
+      return r.trim() === '';
+    }
+    if (IS_ANDROID) {
+      // Termux has no trash; move to ~/_trash
+      const trashDir = path.join(os.homedir(), '_trash');
+      fs.mkdirSync(trashDir, { recursive: true });
+      fs.renameSync(filePath, path.join(trashDir, path.basename(filePath) + '.' + Date.now()));
+      return true;
+    }
+    if (IS_LINUX) {
+      // Try trash-cli
+      if (_run('which trash-put').code === 0) return _spawn('trash-put', [filePath]).code === 0;
+      if (_run('which gio').code     === 0) return _spawn('gio', ['trash', filePath]).code === 0;
+      // XDG Trash spec fallback
+      const trashDir = path.join(os.homedir(), '.local', 'share', 'Trash');
+      const files    = path.join(trashDir, 'files');
+      const info     = path.join(trashDir, 'info');
+      fs.mkdirSync(files, { recursive: true });
+      fs.mkdirSync(info,  { recursive: true });
+      const name = path.basename(filePath);
+      const dest = path.join(files, name);
+      fs.renameSync(filePath, dest);
+      const trashInfo = `[Trash Info]\nPath=${filePath}\nDeletionDate=${new Date().toISOString().replace(/\..+/, '')}\n`;
+      fs.writeFileSync(path.join(info, name + '.trashinfo'), trashInfo, 'utf8');
+      return true;
+    }
+    return false;
+  },
+
+  /**
+   * List items in the trash.
+   * @returns {Array<{ name, path, date }>}
+   */
+  list() {
+    if (IS_MACOS) {
+      const trashPath = path.join(os.homedir(), '.Trash');
+      return fs.readdirSync(trashPath).map(f => ({ name: f, path: path.join(trashPath, f) }));
+    }
+    if (IS_LINUX) {
+      if (_run('which trash-list').code === 0) {
+        return _out('trash-list').split('\n').filter(Boolean).map(l => {
+          const m = l.match(/^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}) (.+)/);
+          return m ? { date: m[1], path: m[2], name: path.basename(m[2]) } : null;
+        }).filter(Boolean);
+      }
+      const infoDir = path.join(os.homedir(), '.local', 'share', 'Trash', 'info');
+      if (!fs.existsSync(infoDir)) return [];
+      return fs.readdirSync(infoDir).map(f => ({ name: f.replace('.trashinfo', '') }));
+    }
+    if (IS_WINDOWS) {
+      const r = _pwsh(`(New-Object -ComObject Shell.Application).NameSpace(10).Items() | ForEach-Object { $_.Path }`);
+      return r.split('\n').filter(Boolean).map(p => ({ name: path.basename(p.trim()), path: p.trim() }));
+    }
+    if (IS_ANDROID) {
+      const td = path.join(os.homedir(), '_trash');
+      if (!fs.existsSync(td)) return [];
+      return fs.readdirSync(td).map(f => ({ name: f, path: path.join(td, f) }));
+    }
+    return [];
+  },
+
+  /** Empty the trash. */
+  empty() {
+    if (IS_MACOS) {
+      _osascript('tell application "Finder" to empty trash');
+    } else if (IS_LINUX) {
+      if (_run('which trash-empty').code === 0) _run('trash-empty');
+      else {
+        const td = path.join(os.homedir(), '.local', 'share', 'Trash');
+        _run(`rm -rf "${td}/files/"* "${td}/info/"* 2>/dev/null`);
+      }
+    } else if (IS_WINDOWS) {
+      _pwsh('(New-Object -ComObject Shell.Application).NameSpace(10).Items() | ForEach-Object { Remove-Item $_.Path -Recurse -Force }');
+    } else if (IS_ANDROID) {
+      const td = path.join(os.homedir(), '_trash');
+      _run(`rm -rf ${_esc(td)}/* 2>/dev/null`);
+    }
+  },
+};
+
+// ══════════════════════════════════════════════════════════════════════════════
+//  16. OPEN — Open Files / URLs / Apps
+// ══════════════════════════════════════════════════════════════════════════════
+
+const Open = {
+  /**
+   * Open a file, URL, or application with the system default handler.
+   * @param {string} target  file path, URL, or app name
+   * @param {object} [opts]
+   * @param {string} [opts.app]  specific app to open with
+   * @param {boolean} [opts.reveal]  reveal in file manager instead of opening
+   */
+  open(target, opts = {}) {
+    target = String(target);
+    if (opts.reveal) return Open.reveal(target);
+
+    if (IS_MACOS) {
+      const args = [target];
+      if (opts.app) args.unshift('-a', opts.app);
+      spawn('open', args, { detached: true, stdio: 'ignore' }).unref();
+    } else if (IS_WINDOWS) {
+      if (opts.app) spawn('cmd', ['/c', 'start', '', opts.app, target], { detached: true, stdio: 'ignore' }).unref();
+      else          spawn('cmd', ['/c', 'start', '', target], { detached: true, stdio: 'ignore' }).unref();
+    } else if (IS_ANDROID) {
+      _spawn('termux-open', [target]);
+    } else if (IS_LINUX) {
+      const opener = _run('which xdg-open').code === 0 ? 'xdg-open'
+                   : _run('which gio').code     === 0 ? 'gio'
+                   : _run('which mimeopen').code === 0 ? 'mimeopen'
+                   : null;
+      if (opener) spawn(opener, opener === 'gio' ? ['open', target] : [target], { detached: true, stdio: 'ignore' }).unref();
+    }
+  },
+
+  /** Open a URL in the default browser. */
+  url(url) { Open.open(url); },
+
+  /** Open a file with its default application. */
+  file(filePath) { Open.open(path.resolve(filePath)); },
+
+  /**
+   * Reveal a file in Finder / Explorer / Nautilus / Files.
+   * @param {string} filePath
+   */
+  reveal(filePath) {
+    filePath = path.resolve(filePath);
+    if (IS_MACOS) {
+      _osascript(`tell application "Finder" to reveal POSIX file "${_escAS(filePath)}"\ntell application "Finder" to activate`);
+    } else if (IS_WINDOWS) {
+      _run(`explorer /select,"${filePath.replace(/"/g, '\\"')}"`);
+    } else if (IS_LINUX) {
+      const parent = path.dirname(filePath);
+      if (_run('which nautilus').code === 0) spawn('nautilus', ['--select', filePath], { detached: true, stdio: 'ignore' }).unref();
+      else if (_run('which dolphin').code === 0) spawn('dolphin', ['--select', filePath], { detached: true, stdio: 'ignore' }).unref();
+      else if (_run('which thunar').code === 0) spawn('thunar', [parent], { detached: true, stdio: 'ignore' }).unref();
+      else spawn('xdg-open', [parent], { detached: true, stdio: 'ignore' }).unref();
+    }
+  },
+
+  /** Open a terminal window (optionally with a command). */
+  terminal(cmd, opts = {}) {
+    if (IS_MACOS) {
+      if (cmd) _osascript(`tell application "Terminal" to do script "${_escAS(cmd)}"\ntell application "Terminal" to activate`);
+      else      _osascript('tell application "Terminal" to activate');
+    } else if (IS_WINDOWS) {
+      if (cmd) spawn('cmd', ['/c', 'start', 'cmd', '/k', cmd], { detached: true, stdio: 'ignore' }).unref();
+      else      spawn('cmd', ['/c', 'start', 'cmd'], { detached: true, stdio: 'ignore' }).unref();
+    } else if (IS_LINUX) {
+      const terms = ['gnome-terminal', 'konsole', 'xterm', 'xfce4-terminal', 'lxterminal', 'alacritty', 'kitty'];
+      for (const t of terms) {
+        if (_run(`which ${t}`).code === 0) {
+          const args = cmd ? (t === 'gnome-terminal' ? ['--', 'bash', '-c', cmd] : ['-e', cmd]) : [];
+          spawn(t, args, { detached: true, stdio: 'ignore' }).unref();
+          return;
+        }
+      }
+    }
+  },
+};
+
+// ══════════════════════════════════════════════════════════════════════════════
+//  17. AUTOSTART — Startup Items
+// ══════════════════════════════════════════════════════════════════════════════
+
+const Autostart = {
+  /**
+   * Add a startup item.
+   * @param {string} name    identifier / display name
+   * @param {string} command command to run (full path recommended)
+   * @param {object} [opts]
+   * @param {boolean} [opts.hidden]  (macOS Login Item)
+   */
+  add(name, command, opts = {}) {
+    name = String(name); command = String(command);
+    if (IS_MACOS) {
+      // Create a LaunchAgent plist in ~/Library/LaunchAgents
+      const plistPath = path.join(os.homedir(), 'Library', 'LaunchAgents', `com.nova.${name}.plist`);
+      const args = command.split(' ');
+      const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+  <key>Label</key><string>com.nova.${name}</string>
+  <key>ProgramArguments</key><array>${args.map(a => `<string>${a}</string>`).join('')}</array>
+  <key>RunAtLoad</key><true/>
+  ${opts.hidden ? '<key>LSUIElement</key><true/>' : ''}
+</dict></plist>`;
+      fs.writeFileSync(plistPath, plist, 'utf8');
+      _run(`launchctl load "${plistPath}" 2>/dev/null`);
+      return true;
+    }
+    if (IS_WINDOWS) {
+      _run(`reg add "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" /v "${name}" /t REG_SZ /d "${command.replace(/"/g, '\\"')}" /f`);
+      return true;
+    }
+    if (IS_ANDROID) {
+      // Termux:Boot
+      const bootDir = path.join(os.homedir(), '.termux', 'boot');
+      fs.mkdirSync(bootDir, { recursive: true });
+      const scriptPath = path.join(bootDir, `${name}.sh`);
+      fs.writeFileSync(scriptPath, `#!/data/data/com.termux/files/usr/bin/bash\n${command}\n`, 'utf8');
+      fs.chmodSync(scriptPath, 0o755);
+      return true;
+    }
+    if (IS_LINUX) {
+      const autostartDir = path.join(os.homedir(), '.config', 'autostart');
+      fs.mkdirSync(autostartDir, { recursive: true });
+      const desktop = `[Desktop Entry]\nType=Application\nName=${name}\nExec=${command}\nX-GNOME-Autostart-enabled=true\nHidden=false\n`;
+      fs.writeFileSync(path.join(autostartDir, `${name}.desktop`), desktop, 'utf8');
+      return true;
+    }
+    return false;
+  },
+
+  /**
+   * Remove a startup item.
+   * @param {string} name
+   */
+  remove(name) {
+    name = String(name);
+    if (IS_MACOS) {
+      const plistPath = path.join(os.homedir(), 'Library', 'LaunchAgents', `com.nova.${name}.plist`);
+      if (fs.existsSync(plistPath)) {
+        _run(`launchctl unload "${plistPath}" 2>/dev/null`);
+        fs.unlinkSync(plistPath);
+        return true;
+      }
+      return false;
+    }
+    if (IS_WINDOWS) {
+      _run(`reg delete "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" /v "${name}" /f 2>nul`);
+      return true;
+    }
+    if (IS_ANDROID) {
+      const scriptPath = path.join(os.homedir(), '.termux', 'boot', `${name}.sh`);
+      if (fs.existsSync(scriptPath)) { fs.unlinkSync(scriptPath); return true; }
+      return false;
+    }
+    if (IS_LINUX) {
+      const desktop = path.join(os.homedir(), '.config', 'autostart', `${name}.desktop`);
+      if (fs.existsSync(desktop)) { fs.unlinkSync(desktop); return true; }
+      return false;
+    }
+    return false;
+  },
+
+  /**
+   * List all startup items added via kitos.
+   * @returns {Array<{ name, command, enabled }>}
+   */
+  list() {
+    if (IS_MACOS) {
+      const dir = path.join(os.homedir(), 'Library', 'LaunchAgents');
+      if (!fs.existsSync(dir)) return [];
+      return fs.readdirSync(dir).filter(f => f.startsWith('com.nova.') && f.endsWith('.plist')).map(f => ({ name: f.replace(/^com\.nova\./, '').replace(/\.plist$/, ''), file: path.join(dir, f) }));
+    }
+    if (IS_LINUX || IS_ANDROID) {
+      const dir = IS_ANDROID
+        ? path.join(os.homedir(), '.termux', 'boot')
+        : path.join(os.homedir(), '.config', 'autostart');
+      if (!fs.existsSync(dir)) return [];
+      return fs.readdirSync(dir).map(f => ({ name: f.replace(/\.(desktop|sh)$/, ''), file: path.join(dir, f) }));
+    }
+    if (IS_WINDOWS) {
+      const r = _run('reg query "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run"').stdout;
+      return r.split('\n').filter(l => l.trim() && !l.includes('HKEY')).map(l => {
+        const m = l.trim().match(/^(\S+)\s+REG_SZ\s+(.+)/);
+        return m ? { name: m[1], command: m[2] } : null;
+      }).filter(Boolean);
+    }
+    return [];
+  },
+
+  /** Enable/disable a startup item (Linux .desktop files). */
+  setEnabled(name, enabled) {
+    if (IS_LINUX) {
+      const desktop = path.join(os.homedir(), '.config', 'autostart', `${name}.desktop`);
+      if (!fs.existsSync(desktop)) return false;
+      let content = fs.readFileSync(desktop, 'utf8');
+      content = content.replace(/X-GNOME-Autostart-enabled=\w+/, `X-GNOME-Autostart-enabled=${enabled ? 'true' : 'false'}`);
+      content = content.replace(/Hidden=\w+/, `Hidden=${enabled ? 'false' : 'true'}`);
+      fs.writeFileSync(desktop, content, 'utf8');
+      return true;
+    }
+    return false;
+  },
+};
+
+// ══════════════════════════════════════════════════════════════════════════════
+//  18. A11Y — Accessibility
+// ══════════════════════════════════════════════════════════════════════════════
+
+const A11y = {
+  /**
+   * Announce a message via the screen reader.
+   * @param {string} message
+   * @param {boolean} [interrupt=false]
+   */
+  announce(message, interrupt = false) {
+    message = String(message);
+    if (IS_MACOS) {
+      _osascript(`tell application "VoiceOver" to output "${_escAS(message)}"`);
+    } else if (IS_LINUX) {
+      // AT-SPI / spd-say
+      if (_run('which spd-say').code === 0) {
+        _spawn('spd-say', interrupt ? ['-C', message] : [message]);
+      } else if (_run('which espeakup').code === 0) {
+        _spawn('espeakup', ['--device', 'default', message]);
+      }
+    } else if (IS_WINDOWS) {
+      _pwsh(`Add-Type -AssemblyName System.speech; $s = New-Object System.Speech.Synthesis.SpeechSynthesizer; $s.Speak('${message.replace(/'/g, "''")}'); $s.Dispose()`);
+    } else if (IS_ANDROID) {
+      TTS.speak(message);
+    }
+  },
+
+  /**
+   * Get focused element info (best-effort via platform tools).
+   * @returns {object|null}
+   */
+  focusedElement() {
+    if (IS_LINUX && _run('which xdotool').code === 0) {
+      const winId = _out('xdotool getactivewindow 2>/dev/null').trim();
+      const name  = _out(`xdotool getwindowname ${winId} 2>/dev/null`).trim();
+      const pid   = _out(`xdotool getwindowpid ${winId} 2>/dev/null`).trim();
+      return { windowId: winId, title: name, pid: +pid };
+    }
+    if (IS_MACOS) {
+      const r = _osascript(
+        'tell application "System Events" to return {name, description} of first UI element whose focused is true of (first process whose frontmost is true)'
+      );
+      return { raw: r };
+    }
+    return null;
+  },
+
+  /**
+   * Get the active window title.
+   * @returns {string|null}
+   */
+  activeWindowTitle() {
+    if (IS_MACOS) {
+      return _osascript('tell application "System Events" to return name of first process whose frontmost is true').trim() || null;
+    }
+    if (IS_LINUX && _run('which xdotool').code === 0) {
+      return _out('xdotool getactivewindow getwindowname 2>/dev/null').trim() || null;
+    }
+    if (IS_WINDOWS) {
+      return _pwsh('(Get-Process | Where-Object {$_.MainWindowTitle -ne ""} | Where-Object {$_.MainWindowHandle -ne 0} | Sort-Object CPU -desc | Select-Object -First 1).MainWindowTitle').trim() || null;
+    }
+    return null;
+  },
+
+  /**
+   * List running application windows.
+   * @returns {Array<{ pid, name, title }>}
+   */
+  windows() {
+    if (IS_LINUX && _run('which wmctrl').code === 0) {
+      return _out('wmctrl -l -p').split('\n').filter(Boolean).map(l => {
+        const [id, desktop, pid, host, ...title] = l.trim().split(/\s+/);
+        return { id, desktop, pid: +pid, host, title: title.join(' ') };
+      });
+    }
+    if (IS_MACOS) {
+      const r = _osascript('tell application "System Events" to return {name, unix id} of every process whose background only is false');
+      return r ? [{ raw: r }] : [];
+    }
+    if (IS_WINDOWS) {
+      return _pwsh('Get-Process | Where-Object {$_.MainWindowTitle -ne ""} | ForEach-Object { "$($_.Id)|$($_.ProcessName)|$($_.MainWindowTitle)" }')
+        .split('\n').filter(Boolean).map(l => {
+          const [pid, name, title] = l.split('|');
+          return { pid: +pid, name, title };
+        });
+    }
+    return [];
+  },
+};
+
+// ══════════════════════════════════════════════════════════════════════════════
+//  19. IDLETIME — User Idle Detection
+// ══════════════════════════════════════════════════════════════════════════════
+
+const IdleTime = {
+  /**
+   * Get the number of milliseconds the user has been idle.
+   * @returns {number}
+   */
+  get() {
+    if (IS_MACOS) {
+      const r = _out('ioreg -c IOHIDSystem 2>/dev/null | awk \'/HIDIdleTime/{print $NF; exit}\'');
+      // Value in nanoseconds
+      return r ? Math.round(+r / 1_000_000) : 0;
+    }
+    if (IS_LINUX) {
+      if (_run('which xprintidle').code === 0) {
+        return +(_out('xprintidle').trim()) || 0;
+      }
+      if (_run('which xssstate').code === 0) {
+        return +(_out('xssstate -i').trim()) || 0;
+      }
+      // Read /proc/uptime and last input from xinput or loginctl
+      return 0;
+    }
+    if (IS_WINDOWS) {
+      const r = _pwsh(`
+        Add-Type @'
+        using System; using System.Runtime.InteropServices;
+        public class Idle {
+          [DllImport("user32.dll")] static extern bool GetLastInputInfo(ref LASTINPUTINFO p);
+          [StructLayout(LayoutKind.Sequential)] struct LASTINPUTINFO { public uint cbSize; public int dwTime; }
+          public static int IdleMs() {
+            var l = new LASTINPUTINFO(); l.cbSize = (uint)System.Runtime.InteropServices.Marshal.SizeOf(l);
+            GetLastInputInfo(ref l); return Environment.TickCount - l.dwTime;
+          }
+        }
+'@
+        [Idle]::IdleMs()
+      `).trim();
+      return +r || 0;
+    }
+    if (IS_ANDROID) {
+      // No direct API; return 0
+      return 0;
+    }
+    return 0;
+  },
+
+  /**
+   * Is the user idle for more than a given threshold?
+   * @param {number} thresholdMs
+   * @returns {boolean}
+   */
+  isIdle(thresholdMs) { return IdleTime.get() >= thresholdMs; },
+
+  /**
+   * Get last input timestamp.
+   * @returns {Date}
+   */
+  lastInputAt() { return new Date(Date.now() - IdleTime.get()); },
+
+  /**
+   * Watch idle state, calling onIdle when idle for thresholdMs, onActive when active again.
+   * @param {number} thresholdMs
+   * @param {Function} onIdle
+   * @param {Function} [onActive]
+   * @param {number} [pollMs=5000]
+   * @returns {{ stop: Function }}
+   */
+  watch(thresholdMs, onIdle, onActive, pollMs = 5000) {
+    let wasIdle = false;
+    const timer = setInterval(() => {
+      const idle = IdleTime.isIdle(thresholdMs);
+      if (idle && !wasIdle) { wasIdle = true; onIdle(); }
+      else if (!idle && wasIdle) { wasIdle = false; if (onActive) onActive(); }
+    }, pollMs);
+    return { stop: () => clearInterval(timer) };
+  },
+};
+
+// ══════════════════════════════════════════════════════════════════════════════
+//  20. SENSORS — Hardware Sensors (CPU temp, fan, GPU)
+// ══════════════════════════════════════════════════════════════════════════════
+
+const Sensors = {
+  /**
+   * Get CPU temperature in Celsius.
+   * @returns {number|null}
+   */
+  cpuTemp() {
+    if (IS_MACOS) {
+      // iStats (gem install iStats) or osx-cpu-temp
+      if (_run('which istats').code === 0) {
+        const r = _out('istats cpu temp --value-only 2>/dev/null');
+        return parseFloat(r) || null;
+      }
+      if (_run('which osx-cpu-temp').code === 0) {
+        return parseFloat(_out('osx-cpu-temp')) || null;
+      }
+      // Try powermetrics (requires sudo)
+      return null;
+    }
+    if (IS_LINUX) {
+      // /sys/class/thermal
+      const thermal = '/sys/class/thermal';
+      if (fs.existsSync(thermal)) {
+        const zones = fs.readdirSync(thermal).filter(d => d.startsWith('thermal_zone'));
+        for (const zone of zones) {
+          const type = _out(`cat /sys/class/thermal/${zone}/type 2>/dev/null`).trim();
+          if (!type.includes('cpu') && !type.includes('x86') && !type.includes('acpi')) continue;
+          const temp = _out(`cat /sys/class/thermal/${zone}/temp 2>/dev/null`).trim();
+          if (temp) return +temp / 1000;
+        }
+        // Fallback: first zone
+        if (zones.length > 0) {
+          const temp = _out(`cat /sys/class/thermal/${zones[0]}/temp 2>/dev/null`).trim();
+          if (temp) return +temp / 1000;
+        }
+      }
+      // lm-sensors
+      if (_run('which sensors').code === 0) {
+        const r = _out('sensors 2>/dev/null');
+        const m = r.match(/Core 0:\s+\+?([\d.]+)°C/);
+        return m ? parseFloat(m[1]) : null;
+      }
+    }
+    if (IS_WINDOWS) {
+      const r = _pwsh('(Get-WmiObject -Namespace root/wmi -Class MSAcpi_ThermalZoneTemperature).CurrentTemperature');
+      return r ? Math.round((+r.trim() - 2732) / 10) : null;
+    }
+    if (IS_ANDROID) {
+      const paths = ['/sys/class/thermal/thermal_zone0/temp', '/sys/devices/virtual/thermal/thermal_zone0/temp'];
+      for (const p of paths) {
+        if (fs.existsSync(p)) {
+          const raw = +fs.readFileSync(p, 'utf8').trim();
+          return raw > 1000 ? raw / 1000 : raw;
+        }
+      }
+    }
+    return null;
+  },
+
+  /**
+   * Get all available temperatures.
+   * @returns {Array<{ name, temp, high, critical }>}
+   */
+  temperatures() {
+    if (IS_LINUX && _run('which sensors').code === 0) {
+      const r = _out('sensors -j 2>/dev/null');
+      try {
+        const data = JSON.parse(r);
+        const result = [];
+        for (const [chip, sensors] of Object.entries(data)) {
+          for (const [sensor, values] of Object.entries(sensors)) {
+            if (typeof values !== 'object') continue;
+            const temp = Object.values(values).find(v => String(v).match(/\d+\.\d+/) && typeof v === 'number');
+            if (temp) result.push({ chip, sensor, temp });
+          }
+        }
+        return result;
+      } catch {}
+    }
+    if (IS_ANDROID) {
+      const base = '/sys/class/thermal';
+      if (!fs.existsSync(base)) return [];
+      return fs.readdirSync(base).filter(d => d.startsWith('thermal_zone')).map(zone => {
+        const type = _out(`cat ${base}/${zone}/type 2>/dev/null`).trim();
+        const temp = _out(`cat ${base}/${zone}/temp 2>/dev/null`).trim();
+        return temp ? { name: type || zone, temp: +temp > 1000 ? +temp/1000 : +temp } : null;
+      }).filter(Boolean);
+    }
+    const cpu = Sensors.cpuTemp();
+    return cpu !== null ? [{ name: 'CPU', temp: cpu }] : [];
+  },
+
+  /**
+   * Get GPU temperature in Celsius.
+   * @returns {number|null}
+   */
+  gpuTemp() {
+    if (IS_LINUX) {
+      // NVIDIA
+      if (_run('which nvidia-smi').code === 0) {
+        const r = _out('nvidia-smi --query-gpu=temperature.gpu --format=csv,noheader,nounits 2>/dev/null');
+        return r ? +r.trim() : null;
+      }
+      // AMD via sensors
+      if (_run('which sensors').code === 0) {
+        const r = _out('sensors 2>/dev/null');
+        const m = r.match(/edge:\s+\+?([\d.]+)°C/);
+        return m ? parseFloat(m[1]) : null;
+      }
+    }
+    if (IS_WINDOWS) {
+      const r = _pwsh('(Get-WmiObject -Namespace root/OpenHardwareMonitor -Class Sensor | Where-Object {$_.SensorType -eq "Temperature" -and $_.Name -like "*GPU*"} | Select-Object -First 1).Value');
+      return r ? parseFloat(r) : null;
+    }
+    return null;
+  },
+
+  /**
+   * Get CPU fan speed(s) in RPM.
+   * @returns {number|null}
+   */
+  fanSpeed() {
+    if (IS_MACOS && _run('which istats').code === 0) {
+      const r = _out('istats fan speed --value-only 2>/dev/null');
+      return parseFloat(r) || null;
+    }
+    if (IS_LINUX && _run('which sensors').code === 0) {
+      const r = _out('sensors 2>/dev/null');
+      const m = r.match(/fan\d+:\s+([\d]+) RPM/i);
+      return m ? +m[1] : null;
+    }
+    if (IS_WINDOWS) {
+      const r = _pwsh('(Get-WmiObject Win32_Fan).DesiredSpeed');
+      return r ? +r.trim() : null;
+    }
+    return null;
+  },
+
+  /**
+   * Get all sensor readings.
+   * @returns {object}
+   */
+  all() {
+    return {
+      cpuTemp:  Sensors.cpuTemp(),
+      gpuTemp:  Sensors.gpuTemp(),
+      fanSpeed: Sensors.fanSpeed(),
+      temps:    Sensors.temperatures(),
+    };
+  },
+};
+
+// ══════════════════════════════════════════════════════════════════════════════
+//  21. LOCATION — GPS / IP Geolocation
+// ══════════════════════════════════════════════════════════════════════════════
+
+const Location = {
+  /**
+   * Get current location.
+   * Falls back from GPS → CoreLocation → IP-based.
+   * @param {object} [opts]
+   * @param {boolean} [opts.ipFallback=true]
+   * @returns {Promise<{ lat, lon, accuracy, source }>}
+   */
+  async get(opts = {}) {
+    const ipFallback = opts.ipFallback !== false;
+
+    if (IS_ANDROID) {
+      try {
+        const r = _out('termux-location -r once -p gps 2>/dev/null');
+        const j = JSON.parse(r);
+        if (j.latitude !== undefined) return { lat: j.latitude, lon: j.longitude, accuracy: j.accuracy, altitude: j.altitude, source: 'gps' };
+      } catch {}
+      // Network fallback
+      try {
+        const r = _out('termux-location -r once -p network 2>/dev/null');
+        const j = JSON.parse(r);
+        if (j.latitude !== undefined) return { lat: j.latitude, lon: j.longitude, accuracy: j.accuracy, source: 'network' };
+      } catch {}
+    }
+
+    if (IS_MACOS && _run('which CoreLocationCLI').code === 0) {
+      try {
+        const r = _out('CoreLocationCLI -format "%latitude,%longitude" 2>/dev/null');
+        const [lat, lon] = r.split(',').map(Number);
+        if (!isNaN(lat)) return { lat, lon, accuracy: null, source: 'corelocation' };
+      } catch {}
+    }
+
+    if (ipFallback) return Location.ipLocation();
+    return null;
+  },
+
+  /**
+   * Get location via IP geolocation API.
+   * @returns {Promise<{ lat, lon, city, country, ip, source }>}
+   */
+  async ipLocation() {
+    const http  = require('http');
+    const https = require('https');
+    return new Promise((resolve) => {
+      const req = https.get('https://ipapi.co/json/', { timeout: 5000 }, (res) => {
+        let data = '';
+        res.on('data', c => data += c);
+        res.on('end', () => {
+          try {
+            const j = JSON.parse(data);
+            resolve({ lat: j.latitude, lon: j.longitude, city: j.city, country: j.country_name, ip: j.ip, source: 'ip' });
+          } catch { resolve(null); }
+        });
+      });
+      req.on('error', () => {
+        // Fallback: ip-api.com (HTTP)
+        const r2 = http.get('http://ip-api.com/json/', { timeout: 5000 }, (res) => {
+          let data = '';
+          res.on('data', c => data += c);
+          res.on('end', () => {
+            try {
+              const j = JSON.parse(data);
+              resolve({ lat: j.lat, lon: j.lon, city: j.city, country: j.country, ip: j.query, source: 'ip' });
+            } catch { resolve(null); }
+          });
+        });
+        r2.on('error', () => resolve(null));
+      });
+    });
+  },
+
+  /**
+   * Calculate distance between two coordinates in km (Haversine).
+   * @param {number} lat1
+   * @param {number} lon1
+   * @param {number} lat2
+   * @param {number} lon2
+   * @returns {number}
+   */
+  distance(lat1, lon1, lat2, lon2) {
+    const R = 6371;
+    const dLat = (lat2 - lat1) * Math.PI / 180;
+    const dLon = (lon2 - lon1) * Math.PI / 180;
+    const a = Math.sin(dLat/2)**2 + Math.cos(lat1*Math.PI/180) * Math.cos(lat2*Math.PI/180) * Math.sin(dLon/2)**2;
+    return R * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
+  },
+};
+
+// ══════════════════════════════════════════════════════════════════════════════
+//  22. VIBRATE — Haptic Feedback
+// ══════════════════════════════════════════════════════════════════════════════
+
+const Vibrate = {
+  /**
+   * Vibrate the device.
+   * @param {number} [durationMs=500]
+   * @param {object} [opts]
+   * @param {number} [opts.force=1.0]  0.0–1.0 intensity (Android only)
+   */
+  vibrate(durationMs = 500, opts = {}) {
+    durationMs = Math.max(1, Math.round(durationMs));
+    if (IS_ANDROID) {
+      const args = ['termux-vibrate', '-d', String(durationMs)];
+      if (opts.force !== undefined) args.push('-f');
+      _spawn(args[0], args.slice(1));
+    } else if (IS_LINUX) {
+      // Some Linux devices support vibration via /sys/class/leds
+      const vibPath = '/sys/class/leds/vibrator';
+      if (fs.existsSync(vibPath)) {
+        try {
+          fs.writeFileSync(path.join(vibPath, 'brightness'), '255');
+          setTimeout(() => { try { fs.writeFileSync(path.join(vibPath, 'brightness'), '0'); } catch {} }, durationMs);
+        } catch {}
+      }
+      // Fallback: beep (at least give audio feedback)
+      else Audio.beep(1);
+    } else {
+      // macOS / Windows: audio bell as fallback
+      Audio.beep(1);
+    }
+  },
+
+  /**
+   * Vibrate a pattern.
+   * @param {number[]} pattern  alternating on/off durations in ms e.g. [100, 200, 100]
+   */
+  pattern(pattern) {
+    if (IS_ANDROID) {
+      // Termux doesn't support pattern directly; simulate with delays
+      let delay = 0;
+      for (let i = 0; i < pattern.length; i++) {
+        if (i % 2 === 0) {
+          setTimeout(() => Vibrate.vibrate(pattern[i]), delay);
+        }
+        delay += pattern[i];
+      }
+    } else {
+      for (let i = 0; i < pattern.length; i += 2) {
+        if (i < pattern.length) setTimeout(() => Vibrate.vibrate(pattern[i]), i * 500);
+      }
+    }
+  },
+
+  /** Check if vibration is supported. */
+  isSupported() {
+    if (IS_ANDROID) return _run('which termux-vibrate').code === 0;
+    if (IS_LINUX)   return fs.existsSync('/sys/class/leds/vibrator');
+    return false;
+  },
+};
+
+// ══════════════════════════════════════════════════════════════════════════════
+//  KITX11 — Low-level X11 window management (Linux only)
+// ══════════════════════════════════════════════════════════════════════════════
+
+const X11 = {
+  /**
+   * Is X11 available?
+   * @returns {boolean}
+   */
+  isAvailable() {
+    return (IS_LINUX || IS_ANDROID) &&
+      (!!process.env.DISPLAY || !!process.env.WAYLAND_DISPLAY) &&
+      _run('which xdotool').code === 0;
+  },
+
+  // ── Window management ─────────────────────────────────────────────────────
+
+  /**
+   * List all open windows.
+   * @returns {Array<{ id, pid, title, desktop, x, y, w, h }>}
+   */
+  listWindows() {
+    const wmctrl = _run('which wmctrl').code === 0;
+    const xdotool = _run('which xdotool').code === 0;
+    if (wmctrl) {
+      return _out('wmctrl -l -G -p').split('\n').filter(Boolean).map(l => {
+        const [id, desktop, pid, x, y, w, h, ...title] = l.trim().split(/\s+/);
+        return { id, desktop: +desktop, pid: +pid, x: +x, y: +y, w: +w, h: +h, title: title.join(' ') };
+      });
+    }
+    if (xdotool) {
+      const ids = _out('xdotool search --onlyvisible --name "" 2>/dev/null').split('\n').filter(Boolean);
+      return ids.map(id => {
+        const title = _out(`xdotool getwindowname ${id} 2>/dev/null`).trim();
+        const pid   = _out(`xdotool getwindowpid ${id} 2>/dev/null`).trim();
+        return { id, pid: +pid, title };
+      });
+    }
+    return [];
+  },
+
+  /**
+   * Get the active (focused) window ID.
+   * @returns {string|null}
+   */
+  activeWindow() {
+    if (_run('which xdotool').code === 0) return _out('xdotool getactivewindow 2>/dev/null').trim() || null;
+    if (_run('which wmctrl').code  === 0) return _out('wmctrl -d').match(/\* (\w+)/)?.[1] ?? null;
+    return null;
+  },
+
+  /**
+   * Focus a window by its ID.
+   * @param {string} windowId
+   */
+  focusWindow(windowId) {
+    if (_run('which xdotool').code === 0) _spawn('xdotool', ['windowactivate', '--sync', String(windowId)]);
+    else if (_run('which wmctrl').code === 0) _spawn('wmctrl', ['-ia', String(windowId)]);
+  },
+
+  /**
+   * Find windows by title pattern.
+   * @param {string} pattern  regex or substring
+   * @returns {string[]}  window IDs
+   */
+  findByTitle(pattern) {
+    if (_run('which xdotool').code === 0) {
+      return _out(`xdotool search --name "${pattern.replace(/"/g, '\\"')}" 2>/dev/null`).split('\n').filter(Boolean);
+    }
+    if (_run('which wmctrl').code === 0) {
+      return _out('wmctrl -l').split('\n').filter(l => l.toLowerCase().includes(pattern.toLowerCase()))
+        .map(l => l.trim().split(/\s+/)[0]);
+    }
+    return [];
+  },
+
+  /**
+   * Find windows by PID.
+   * @param {number} pid
+   * @returns {string[]}  window IDs
+   */
+  findByPID(pid) {
+    if (_run('which xdotool').code === 0) {
+      return _out(`xdotool search --pid ${pid} 2>/dev/null`).split('\n').filter(Boolean);
+    }
+    return [];
+  },
+
+  /**
+   * Close a window gracefully.
+   * @param {string} windowId
+   */
+  closeWindow(windowId) {
+    if (_run('which wmctrl').code  === 0) _spawn('wmctrl', ['-ic', String(windowId)]);
+    else if (_run('which xdotool').code === 0) _spawn('xdotool', ['windowclose', String(windowId)]);
+  },
+
+  /**
+   * Kill a window (force close).
+   * @param {string} windowId
+   */
+  killWindow(windowId) {
+    if (_run('which xdotool').code === 0) _spawn('xdotool', ['windowkill', String(windowId)]);
+    else _spawn('xkill', []);
+  },
+
+  /**
+   * Move a window to given coordinates.
+   * @param {string} windowId
+   * @param {number} x
+   * @param {number} y
+   */
+  moveWindow(windowId, x, y) {
+    if (_run('which wmctrl').code === 0) {
+      _spawn('wmctrl', ['-ir', String(windowId), '-e', `0,${x},${y},-1,-1`]);
+    } else if (_run('which xdotool').code === 0) {
+      _spawn('xdotool', ['windowmove', String(windowId), String(x), String(y)]);
+    }
+  },
+
+  /**
+   * Resize a window.
+   * @param {string} windowId
+   * @param {number} w
+   * @param {number} h
+   */
+  resizeWindow(windowId, w, h) {
+    if (_run('which wmctrl').code === 0) {
+      _spawn('wmctrl', ['-ir', String(windowId), '-e', `0,-1,-1,${w},${h}`]);
+    } else if (_run('which xdotool').code === 0) {
+      _spawn('xdotool', ['windowsize', String(windowId), String(w), String(h)]);
+    }
+  },
+
+  /**
+   * Move and resize in one call.
+   * @param {string} windowId
+   * @param {number} x
+   * @param {number} y
+   * @param {number} w
+   * @param {number} h
+   */
+  setGeometry(windowId, x, y, w, h) {
+    if (_run('which wmctrl').code === 0) {
+      _spawn('wmctrl', ['-ir', String(windowId), '-e', `0,${x},${y},${w},${h}`]);
+    } else if (_run('which xdotool').code === 0) {
+      _spawn('xdotool', ['windowmove', String(windowId), String(x), String(y)]);
+      _spawn('xdotool', ['windowsize', String(windowId), String(w), String(h)]);
+    }
+  },
+
+  /**
+   * Get window geometry.
+   * @param {string} windowId
+   * @returns {{ x, y, w, h }|null}
+   */
+  getGeometry(windowId) {
+    if (_run('which xdotool').code === 0) {
+      const geo = _out(`xdotool getwindowgeometry ${windowId} 2>/dev/null`);
+      const pos = geo.match(/Position: (\d+),(\d+)/);
+      const siz = geo.match(/Geometry: (\d+)x(\d+)/);
+      if (pos && siz) return { x: +pos[1], y: +pos[2], w: +siz[1], h: +siz[2] };
+    }
+    if (_run('which wmctrl').code === 0) {
+      const r = _out(`wmctrl -l -G | grep ${windowId}`);
+      const p = r.trim().split(/\s+/);
+      if (p.length >= 8) return { x: +p[3], y: +p[4], w: +p[5], h: +p[6] };
+    }
+    return null;
+  },
+
+  /**
+   * Maximize a window.
+   * @param {string} windowId
+   */
+  maximize(windowId) {
+    if (_run('which wmctrl').code === 0) {
+      _spawn('wmctrl', ['-ir', String(windowId), '-b', 'add,maximized_vert,maximized_horz']);
+    } else if (_run('which xdotool').code === 0) {
+      _spawn('xdotool', ['windowmove', String(windowId), '0', '0']);
+      const s = Screen.size();
+      _spawn('xdotool', ['windowsize', String(windowId), String(s.width), String(s.height)]);
+    }
+  },
+
+  /**
+   * Minimize a window.
+   * @param {string} windowId
+   */
+  minimize(windowId) {
+    if (_run('which xdotool').code === 0) _spawn('xdotool', ['windowminimize', String(windowId)]);
+    else if (_run('which wmctrl').code === 0) _spawn('wmctrl', ['-ir', String(windowId), '-b', 'add,hidden']);
+  },
+
+  /**
+   * Restore/unminimize a window.
+   * @param {string} windowId
+   */
+  restore(windowId) {
+    if (_run('which wmctrl').code === 0) _spawn('wmctrl', ['-ir', String(windowId), '-b', 'remove,maximized_vert,maximized_horz,hidden']);
+    else if (_run('which xdotool').code === 0) _spawn('xdotool', ['windowactivate', String(windowId)]);
+  },
+
+  /**
+   * Always-on-top (raise above all windows).
+   * @param {string} windowId
+   * @param {boolean} [on=true]
+   */
+  alwaysOnTop(windowId, on = true) {
+    if (_run('which wmctrl').code === 0) {
+      _spawn('wmctrl', ['-ir', String(windowId), '-b', `${on ? 'add' : 'remove'},above`]);
+    }
+  },
+
+  /**
+   * Set window opacity (0.0–1.0). Requires a compositor.
+   * @param {string} windowId
+   * @param {number} opacity
+   */
+  setOpacity(windowId, opacity) {
+    opacity = Math.max(0, Math.min(1, opacity));
+    const value = Math.round(opacity * 0xFFFFFFFF);
+    if (_run('which xprop').code === 0) {
+      _spawn('xprop', ['-id', String(windowId), '-f', '_NET_WM_WINDOW_OPACITY', '32c', '-set', '_NET_WM_WINDOW_OPACITY', String(value)]);
+    }
+  },
+
+  /**
+   * Get window class / application name.
+   * @param {string} windowId
+   * @returns {{ class: string, name: string }|null}
+   */
+  getClass(windowId) {
+    if (_run('which xprop').code === 0) {
+      const r = _out(`xprop -id ${windowId} WM_CLASS 2>/dev/null`);
+      const m = r.match(/WM_CLASS.*= "([^"]+)", "([^"]+)"/);
+      return m ? { class: m[1], name: m[2] } : null;
+    }
+    return null;
+  },
+
+  // ── Virtual Desktops / Workspaces ─────────────────────────────────────────
+
+  /**
+   * Get current desktop/workspace number.
+   * @returns {number}
+   */
+  currentDesktop() {
+    if (_run('which wmctrl').code === 0) {
+      const r = _out('wmctrl -d');
+      const m = r.match(/^(\d+)\s+\*/m);
+      return m ? +m[1] : 0;
+    }
+    if (_run('which xdotool').code === 0) {
+      return +(_out('xdotool get_desktop 2>/dev/null').trim()) || 0;
+    }
+    return 0;
+  },
+
+  /**
+   * Switch to a desktop by number.
+   * @param {number} n  0-indexed
+   */
+  switchDesktop(n) {
+    if (_run('which wmctrl').code === 0) _spawn('wmctrl', ['-s', String(n)]);
+    else if (_run('which xdotool').code === 0) _spawn('xdotool', ['set_desktop', String(n)]);
+  },
+
+  /**
+   * Move window to a desktop.
+   * @param {string} windowId
+   * @param {number} desktop  0-indexed
+   */
+  moveToDesktop(windowId, desktop) {
+    if (_run('which wmctrl').code === 0) _spawn('wmctrl', ['-ir', String(windowId), '-t', String(desktop)]);
+    else if (_run('which xdotool').code === 0) _spawn('xdotool', ['set_desktop_for_window', String(windowId), String(desktop)]);
+  },
+
+  /**
+   * List all virtual desktops.
+   * @returns {Array<{ id, name, active }>}
+   */
+  listDesktops() {
+    if (_run('which wmctrl').code === 0) {
+      return _out('wmctrl -d').split('\n').filter(Boolean).map(l => {
+        const parts = l.trim().split(/\s+/);
+        return { id: +parts[0], active: parts[1] === '*', name: parts.slice(-1)[0] };
+      });
+    }
+    return [];
+  },
+
+  // ── X11 Properties ────────────────────────────────────────────────────────
+
+  /**
+   * Get an X11 property from a window.
+   * @param {string} windowId
+   * @param {string} property  e.g. '_NET_WM_STATE', 'WM_NAME'
+   * @returns {string}
+   */
+  getProperty(windowId, property) {
+    if (_run('which xprop').code === 0) {
+      return _out(`xprop -id ${windowId} ${property} 2>/dev/null`);
+    }
+    return '';
+  },
+
+  /**
+   * Set an X11 string property on a window.
+   * @param {string} windowId
+   * @param {string} property
+   * @param {string} value
+   */
+  setProperty(windowId, property, value) {
+    if (_run('which xprop').code === 0) {
+      _spawn('xprop', ['-id', String(windowId), '-f', property, '8s', '-set', property, value]);
+    }
+  },
+
+  /**
+   * Send an X11 ClientMessage event to a window.
+   * @param {string} windowId
+   * @param {string} msgType   e.g. '_NET_CLOSE_WINDOW'
+   * @param {number[]} data    up to 5 longs
+   */
+  sendClientMessage(windowId, msgType, data = [0,0,0,0,0]) {
+    if (_run('which xdotool').code === 0) {
+      _spawn('xdotool', ['windowactivate', String(windowId)]);
+    }
+    // Use xdotool or direct Xlib via xdpyinfo — best effort
+  },
+
+  // ── Screen / Display ──────────────────────────────────────────────────────
+
+  /**
+   * Get info about connected X11 outputs (monitors).
+   * @returns {Array<{ name, connected, primary, resolution, position, hz }>}
+   */
+  outputs() {
+    const r = _out('xrandr 2>/dev/null');
+    const outputs = [];
+    for (const line of r.split('\n')) {
+      const m = line.match(/^(\S+)\s+(connected|disconnected)(?: primary)?\s*(?:(\d+)x(\d+)\+(\d+)\+(\d+))?/);
+      if (m) {
+        outputs.push({
+          name: m[1], connected: m[2] === 'connected', primary: line.includes('primary'),
+          resolution: m[3] ? `${m[3]}x${m[4]}` : null,
+          position: m[5] ? { x: +m[5], y: +m[6] } : null,
+        });
+      }
+    }
+    return outputs;
+  },
+
+  /**
+   * Set display resolution for an output.
+   * @param {string} outputName  e.g. 'HDMI-1'
+   * @param {string} resolution  e.g. '1920x1080'
+   * @param {string} [rate]      e.g. '60'
+   */
+  setResolution(outputName, resolution, rate) {
+    const args = ['--output', outputName, '--mode', resolution];
+    if (rate) args.push('--rate', rate);
+    _spawn('xrandr', args);
+  },
+
+  /**
+   * Turn an output on or off.
+   * @param {string} outputName
+   * @param {boolean} on
+   */
+  setOutputEnabled(outputName, on) {
+    _spawn('xrandr', ['--output', outputName, on ? '--auto' : '--off']);
+  },
+
+  /**
+   * Set display rotation.
+   * @param {string} outputName
+   * @param {'normal'|'left'|'right'|'inverted'} rotation
+   */
+  setRotation(outputName, rotation) {
+    _spawn('xrandr', ['--output', outputName, '--rotate', rotation]);
+  },
+
+  // ── Input / XDG ──────────────────────────────────────────────────────────
+
+  /**
+   * List X11 input devices.
+   * @returns {Array<{ id, name, type }>}
+   */
+  listInputDevices() {
+    if (_run('which xinput').code === 0) {
+      return _out('xinput list --short').split('\n').filter(Boolean).map(l => {
+        const m = l.match(/^\s+(.+?)\s+id=(\d+)\s+\[(.+?)\]/);
+        return m ? { name: m[1].trim(), id: +m[2], type: m[3].trim() } : null;
+      }).filter(Boolean);
+    }
+    return [];
+  },
+
+  /**
+   * Enable or disable an input device (e.g. touchpad).
+   * @param {number} deviceId
+   * @param {boolean} enabled
+   */
+  setInputEnabled(deviceId, enabled) {
+    if (_run('which xinput').code === 0) {
+      _spawn('xinput', [enabled ? 'enable' : 'disable', String(deviceId)]);
+    }
+  },
+
+  /**
+   * Set mouse pointer speed/acceleration.
+   * @param {number} speed  -1.0 to 1.0 (libinput) or acceleration factor
+   */
+  setPointerSpeed(speed) {
+    if (_run('which xinput').code === 0) {
+      // Try libinput
+      const devices = X11.listInputDevices().filter(d => d.type.includes('pointer'));
+      for (const d of devices) {
+        _spawn('xinput', ['set-prop', String(d.id), 'libinput Accel Speed', String(speed)]);
+      }
+    }
+  },
+
+  // ── Clipboard (X11) ───────────────────────────────────────────────────────
+
+  /** Get X11 clipboard content (CLIPBOARD selection). */
+  getClipboard() { return Keyboard.getClipboard(); },
+
+  /** Get X11 primary selection (middle-click paste). */
+  getPrimary() {
+    if (_run('which xsel').code  === 0) return _out('xsel --primary --output');
+    if (_run('which xclip').code === 0) return _out('xclip -selection primary -o');
+    return '';
+  },
+
+  /** Set X11 primary selection. */
+  setPrimary(text) {
+    if (_run('which xsel').code  === 0) spawnSync('xsel', ['--primary', '--input'], { input: text, encoding: 'utf8' });
+    else if (_run('which xclip').code === 0) spawnSync('xclip', ['-selection', 'primary'], { input: text, encoding: 'utf8' });
+  },
+
+  // ── Compositor / Effects ──────────────────────────────────────────────────
+
+  /**
+   * Is a compositor running?
+   * @returns {boolean}
+   */
+  hasCompositor() {
+    if (_run('which xprop').code === 0) {
+      return _out('xprop -root _NET_WM_CM_S0 2>/dev/null').trim() !== '';
+    }
+    return false;
+  },
+
+  /**
+   * Get the X11 display name.
+   * @returns {string}
+   */
+  display() { return process.env.DISPLAY ?? ':0'; },
+
+  /**
+   * Get screen DPI via xdpyinfo.
+   * @returns {{ x: number, y: number }|null}
+   */
+  dpi() {
+    const r = _out('xdpyinfo 2>/dev/null');
+    const m = r.match(/resolution:\s+(\d+)x(\d+) dots per inch/);
+    return m ? { x: +m[1], y: +m[2] } : null;
+  },
+
+  /**
+   * Bell / ring terminal bell via X11.
+   */
+  bell() { _run('xbell 2>/dev/null || xdotool key XF86AudioPlay 2>/dev/null'); },
+
+  // ── xdg-open / MIME ───────────────────────────────────────────────────────
+
+  /**
+   * Get default app for a MIME type.
+   * @param {string} mimeType  e.g. 'text/html'
+   * @returns {string|null}
+   */
+  defaultApp(mimeType) {
+    if (_run('which xdg-mime').code === 0) {
+      return _out(`xdg-mime query default ${mimeType}`).trim() || null;
+    }
+    return null;
+  },
+
+  /**
+   * Set default app for a MIME type.
+   * @param {string} mimeType
+   * @param {string} desktopFile  e.g. 'firefox.desktop'
+   */
+  setDefaultApp(mimeType, desktopFile) {
+    if (_run('which xdg-mime').code === 0) {
+      _spawn('xdg-mime', ['default', desktopFile, mimeType]);
+    }
+  },
+
+  /**
+   * Query MIME type of a file.
+   * @param {string} filePath
+   * @returns {string|null}
+   */
+  mimeType(filePath) {
+    if (_run('which xdg-mime').code === 0) {
+      return _out(`xdg-mime query filetype ${_esc(filePath)}`).trim() || null;
+    }
+    if (_run('which file').code === 0) {
+      return _out(`file --mime-type -b ${_esc(filePath)}`).trim() || null;
+    }
+    return null;
+  },
+};
+
+// ══════════════════════════════════════════════════════════════════════════════
+//  PLATFORM CONSTANT
+// ══════════════════════════════════════════════════════════════════════════════
+
+const KITOS_PLATFORM = PLATFORM;
+
+// ══════════════════════════════════════════════════════════════════════════════
+//  EXPORTS
+// ══════════════════════════════════════════════════════════════════════════════
+
+module.exports = {
+  kitdef: {
+    // ── 1. Notifications ─────────────────────────────
+    Notify,
+
+    // ── 2. Text-to-Speech ────────────────────────────
+    TTS,
+
+    // ── 3. Native Dialogs ────────────────────────────
+    Dialog,
+
+    // ── 4. System Menu / Tray ────────────────────────
+    Menu,
+
+    // ── 5. Keyboard Simulation ───────────────────────
+    Keyboard,
+
+    // ── 6. Mouse Control ─────────────────────────────
+    Mouse,
+
+    // ── 7. Screen / Screenshots ──────────────────────
+    Screen,
+
+    // ── 8. Audio Playback ────────────────────────────
+    Audio,
+
+    // ── 9. Camera ────────────────────────────────────
+    Camera,
+
+    // ── 10. Power / Battery ──────────────────────────
+    Power,
+
+    // ── 11. Display Brightness ───────────────────────
+    Brightness,
+
+    // ── 12. WiFi ─────────────────────────────────────
+    Wifi,
+
+    // ── 13. Bluetooth ────────────────────────────────
+    Bluetooth,
+
+    // ── 14. Volume (fine-grained) ────────────────────
+    Volume,
+
+    // ── 15. Trash / Recycle ──────────────────────────
+    Trash,
+
+    // ── 16. Open / Reveal ────────────────────────────
+    Open,
+
+    // ── 17. Autostart ────────────────────────────────
+    Autostart,
+
+    // ── 18. Accessibility ────────────────────────────
+    A11y,
+
+    // ── 19. Idle Time ────────────────────────────────
+    IdleTime,
+
+    // ── 20. Hardware Sensors ─────────────────────────
+    Sensors,
+
+    // ── 21. Location ─────────────────────────────────
+    Location,
+
+    // ── 22. Haptic Vibration ─────────────────────────
+    Vibrate,
+
+    // ── 23. X11 Window Manager ───────────────────────
+    X11,
+
+    // ── Platform info ─────────────────────────────────
+    platform: KITOS_PLATFORM,
+    IS_MACOS,
+    IS_WINDOWS,
+    IS_LINUX,
+    IS_ANDROID,
+  }
+};