onbuzz 5.4.1 → 5.4.4

package/src/services/eventLoopMonitor.js

@@ -0,0 +1,102 @@
+/**
+ * Event-loop delay monitor.
+ *
+ * The whole backend runs on one event loop, so the honest measure of "are
+ * routes competing for processing time?" is how long the loop is *blocked*
+ * between ticks. Node's perf_hooks.monitorEventLoopDelay gives exactly that as
+ * a histogram (in nanoseconds); we surface a ms snapshot via /api/system so the
+ * Monitor App can show it — turning "I think something blocks" into "here's the
+ * p99 lag under real load," which is what should drive any heavier offloading
+ * work (worker threads, etc.).
+ */
+
+import { monitorEventLoopDelay, createHistogram } from 'perf_hooks';
+
+const NS_PER_MS = 1e6;
+const round2 = (v) => Math.round((v + Number.EPSILON) * 100) / 100;
+const nsToMs = (v) => (Number.isFinite(v) ? round2(v / NS_PER_MS) : 0);
+const usToMs = (v) => (Number.isFinite(Number(v)) ? round2(Number(v) / 1000) : 0);
+
+export class EventLoopMonitor {
+  /** @param {{ resolution?: number, stallMs?: number }} [opts] */
+  constructor({ resolution = 20, stallMs = 100 } = {}) {
+    this.histogram = monitorEventLoopDelay({ resolution });
+    this.stallMs = stallMs;
+    this.started = false;
+    // Named phase timers (e.g. 'agentProcessing') so we can see WHICH work eats
+    // the loop, not just that it's blocked. Values recorded in microseconds.
+    this.phases = new Map(); // name -> perf_hooks Histogram
+  }
+
+  /**
+   * Record a phase duration (ms). Cheap enough to call on every agent turn.
+   * @param {string} name
+   * @param {number} ms
+   */
+  recordPhase(name, ms) {
+    if (!name || !Number.isFinite(ms) || ms < 0) return;
+    let h = this.phases.get(name);
+    if (!h) { h = createHistogram(); this.phases.set(name, h); }
+    h.record(Math.max(1, Math.round(ms * 1000))); // µs, min 1 (record() needs ≥1)
+  }
+
+  start() {
+    if (!this.started) {
+      this.histogram.enable();
+      this.started = true;
+    }
+    return this;
+  }
+
+  stop() {
+    if (this.started) {
+      this.histogram.disable();
+      this.started = false;
+    }
+    return this;
+  }
+
+  reset() {
+    this.histogram.reset();
+    for (const h of this.phases.values()) h.reset();
+    return this;
+  }
+
+  /**
+   * Snapshot of loop delay, in milliseconds. `stalling` flags when p99 lag is
+   * high enough that routes are visibly competing.
+   * @returns {{ meanMs:number, p50Ms:number, p99Ms:number, maxMs:number, stalling:boolean, started:boolean }}
+   */
+  snapshot() {
+    const h = this.histogram;
+    const p99 = nsToMs(h.percentile(99));
+    const phases = {};
+    for (const [name, ph] of this.phases) {
+      const count = Number(ph.count) || 0;
+      if (count === 0) continue;
+      phases[name] = {
+        p50Ms: usToMs(ph.percentile(50)),
+        p99Ms: usToMs(ph.percentile(99)),
+        maxMs: usToMs(ph.max),
+        count,
+      };
+    }
+    return {
+      meanMs: nsToMs(h.mean),
+      p50Ms: nsToMs(h.percentile(50)),
+      p99Ms: p99,
+      maxMs: nsToMs(h.max),
+      stalling: p99 > this.stallMs,
+      started: this.started,
+      phases,
+    };
+  }
+}
+
+let instance = null;
+export function getEventLoopMonitor(opts) {
+  if (!instance) instance = new EventLoopMonitor(opts);
+  return instance;
+}
+
+export default getEventLoopMonitor;

package/src/services/scheduleService.js

@@ -12,8 +12,14 @@
 
 import { promises as fs } from 'fs';
 import path from 'path';
-import { execSync } from 'child_process';
+import { exec, spawn } from 'child_process';
+import { promisify } from 'util';
 import { getUserDataDir } from '../utilities/userDataDir.js';
+
+// Async exec so OS-scheduler sync (crontab / schtasks / `which`) never blocks
+// the event loop — a schedule create/update must not stall other routes or the
+// agent tick while a subprocess runs.
+const execAsync = promisify(exec);
 import { resolveModuleFilename } from '../utilities/esmCjsPath.js';
 
 // ========================
@@ -207,6 +213,11 @@ class ScheduleService {
     this.catchUpGraceMs = 24 * 60 * 60 * 1000;
     this.checkTimer = null;
 
+    // Serializes OS-scheduler sync so concurrent create/update/delete can't race
+    // the crontab read-modify-write (execSync used to serialize this for free by
+    // blocking; async exec doesn't, so we serialize explicitly).
+    this._osSyncQueue = Promise.resolve();
+
     // Dependencies (injected)
     this.agentPool = null;
     this.messageProcessor = null;
@@ -565,7 +576,22 @@ class ScheduleService {
     const projectDir = this.orchestrator?.config?.project?.directory || process.cwd();
     try {
       const agent = await stateManager.importArchivedAgent(agentId, projectDir, this.agentPool);
-      if (agent) this.logger.info('Schedule restored target agent from disk on fire', { agentId });
+      if (agent) {
+        this.logger.info('Schedule restored target agent from disk on fire', { agentId });
+        // The agent just materialized in the pool. Tell the UI so it appears in
+        // the agent list immediately — the frontend refreshes its list on
+        // 'agent-imported'. Without this, a schedule-loaded agent (e.g. a missed
+        // task triggered manually) is invisible until a full page reload.
+        this._broadcast('agent-imported', {
+          agent: {
+            id: agent.id,
+            name: agent.name,
+            status: agent.status,
+            capabilities: agent.capabilities,
+            model: agent.currentModel || agent.preferredModel,
+          },
+        });
+      }
       return agent || (await this.agentPool.getAgent(agentId));
     } catch (err) {
       this.logger.warn('Schedule could not restore target agent from disk', { agentId, error: err.message });
@@ -692,14 +718,48 @@ class ScheduleService {
   // so schedules fire even when Loxia is shut down.
   // ========================
 
+  /**
+   * Run an OS-sync task after any previous one completes, so the crontab
+   * read-modify-write (and schtasks delete+create) can't interleave. Keeps the
+   * chain alive even if a task rejects.
+   * @private
+   */
+  _runSerialized(fn) {
+    const run = this._osSyncQueue.then(() => fn());
+    this._osSyncQueue = run.then(() => {}, () => {});
+    return run;
+  }
+
+  /**
+   * Async equivalent of execSync-with-stdin: spawn a command, write `input` to
+   * its stdin, resolve on clean exit. Needed for `crontab -`, which reads the
+   * new crontab from stdin.
+   * @private
+   */
+  _execWithInput(cmd, args, input) {
+    return new Promise((resolve, reject) => {
+      const child = spawn(cmd, args, { stdio: ['pipe', 'pipe', 'pipe'] });
+      let stderr = '';
+      child.stderr.on('data', (d) => { stderr += d.toString(); });
+      child.on('error', reject);
+      child.on('close', (code) => {
+        if (code === 0) resolve();
+        else reject(new Error(`${cmd} exited ${code}: ${stderr.trim()}`));
+      });
+      child.stdin.write(input);
+      child.stdin.end();
+    });
+  }
+
   /**
    * Find the loxia CLI binary path
    */
-  _findLoxiaBin() {
+  async _findLoxiaBin() {
     try {
       // Check if installed globally
       const which = process.platform === 'win32' ? 'where loxia' : 'which loxia';
-      return execSync(which, { encoding: 'utf-8' }).trim().split('\n')[0];
+      const { stdout } = await execAsync(which, { encoding: 'utf-8' });
+      return stdout.trim().split('\n')[0];
     } catch {
       // Fallback to local bin
       const __dirname = path.dirname(resolveModuleFilename(import.meta.url));
@@ -718,27 +778,29 @@ class ScheduleService {
       return;
     }
 
-    try {
-      const loxiaBin = this._findLoxiaBin();
-      const command = resolveTriggerCommand({
-        scheduleId: schedule.id,
-        isElectron: !!process.versions?.electron,
-        execPath: process.execPath,
-        loxiaBin,
-      });
+    return this._runSerialized(async () => {
+      try {
+        const loxiaBin = await this._findLoxiaBin();
+        const command = resolveTriggerCommand({
+          scheduleId: schedule.id,
+          isElectron: !!process.versions?.electron,
+          execPath: process.execPath,
+          loxiaBin,
+        });
 
-      if (process.platform === 'win32') {
-        await this._syncToWindows(schedule, command);
-      } else {
-        await this._syncToCrontab(schedule, command);
+        if (process.platform === 'win32') {
+          await this._syncToWindows(schedule, command);
+        } else {
+          await this._syncToCrontab(schedule, command);
+        }
+      } catch (err) {
+        // Non-fatal — internal scheduler still works as fallback
+        this.logger.warn('Failed to sync schedule to OS scheduler', {
+          id: schedule.id,
+          error: err.message
+        });
       }
-    } catch (err) {
-      // Non-fatal — internal scheduler still works as fallback
-      this.logger.warn('Failed to sync schedule to OS scheduler', {
-        id: schedule.id,
-        error: err.message
-      });
-    }
+    });
   }
 
   /**
@@ -746,18 +808,20 @@ class ScheduleService {
    * Called after delete or disable.
    */
   async _removeFromOS(scheduleId) {
-    try {
-      if (process.platform === 'win32') {
-        this._removeFromWindows(scheduleId);
-      } else {
-        this._removeFromCrontab(scheduleId);
+    return this._runSerialized(async () => {
+      try {
+        if (process.platform === 'win32') {
+          await this._removeFromWindows(scheduleId);
+        } else {
+          await this._removeFromCrontab(scheduleId);
+        }
+      } catch (err) {
+        this.logger.warn('Failed to remove schedule from OS scheduler', {
+          id: scheduleId,
+          error: err.message
+        });
       }
-    } catch (err) {
-      this.logger.warn('Failed to remove schedule from OS scheduler', {
-        id: scheduleId,
-        error: err.message
-      });
-    }
+    });
   }
 
   /**
@@ -772,13 +836,13 @@ class ScheduleService {
 
   // --- Linux/macOS: crontab ---
 
-  _syncToCrontab(schedule, command) {
+  async _syncToCrontab(schedule, command) {
     const tag = `# loxia-schedule:${schedule.id}`;
 
     // Read current crontab
     let existing = '';
     try {
-      existing = execSync('crontab -l 2>/dev/null', { encoding: 'utf-8' });
+      existing = (await execAsync('crontab -l 2>/dev/null', { encoding: 'utf-8' })).stdout;
     } catch {
       // No crontab yet
     }
@@ -791,32 +855,32 @@ class ScheduleService {
 
     // Write back
     const newCrontab = lines.filter(l => l.trim() !== '').join('\n') + '\n';
-    execSync('crontab -', { input: newCrontab, encoding: 'utf-8' });
+    await this._execWithInput('crontab', ['-'], newCrontab);
 
     this.logger.info('Synced schedule to crontab', { id: schedule.id, cron: schedule.cronExpression });
   }
 
-  _removeFromCrontab(scheduleId) {
+  async _removeFromCrontab(scheduleId) {
     let existing;
     try {
-      existing = execSync('crontab -l 2>/dev/null', { encoding: 'utf-8' });
+      existing = (await execAsync('crontab -l 2>/dev/null', { encoding: 'utf-8' })).stdout;
     } catch {
       return; // No crontab
     }
 
     const lines = existing.split('\n').filter(l => !l.includes(`loxia-schedule:${scheduleId}`));
     const newCrontab = lines.filter(l => l.trim() !== '').join('\n') + '\n';
-    execSync('crontab -', { input: newCrontab, encoding: 'utf-8' });
+    await this._execWithInput('crontab', ['-'], newCrontab);
   }
 
   // --- Windows: schtasks ---
 
-  _syncToWindows(schedule, command) {
+  async _syncToWindows(schedule, command) {
     const taskName = `LoxiaSchedule_${schedule.id}`;
 
     // Remove existing task if any
     try {
-      execSync(`schtasks /Delete /TN "${taskName}" /F 2>nul`, { encoding: 'utf-8' });
+      await execAsync(`schtasks /Delete /TN "${taskName}" /F 2>nul`, { encoding: 'utf-8' });
     } catch {
       // Task may not exist
     }
@@ -832,7 +896,7 @@ class ScheduleService {
       return;
     }
 
-    execSync(
+    await execAsync(
       buildSchtasksCreateCommand(taskName, command, scArgs),
       { encoding: 'utf-8' }
     );
@@ -840,10 +904,10 @@ class ScheduleService {
     this.logger.info('Synced schedule to Windows Task Scheduler', { id: schedule.id, taskName });
   }
 
-  _removeFromWindows(scheduleId) {
+  async _removeFromWindows(scheduleId) {
     const taskName = `LoxiaSchedule_${scheduleId}`;
     try {
-      execSync(`schtasks /Delete /TN "${taskName}" /F 2>nul`, { encoding: 'utf-8' });
+      await execAsync(`schtasks /Delete /TN "${taskName}" /F 2>nul`, { encoding: 'utf-8' });
     } catch {
       // Task may not exist
     }

package/src/tools/__tests__/webTool.e2e.test.js

@@ -46,8 +46,15 @@ beforeAll(async () => {
 }, 30000);
 
 afterAll(async () => {
-  try { await wt.cleanup?.(); } catch { /* swallow */ }
-}, 15000);
+  // Browser shutdown is best-effort and must NEVER fail the suite. The old
+  // try/catch swallowed cleanup ERRORS but not a hook TIMEOUT — under CPU
+  // load (e.g. another test suite running concurrently) Puppeteer teardown
+  // occasionally took >15s and the whole suite reported failed with zero
+  // failing tests. Race cleanup against a soft deadline: if the browser is
+  // slow to die, move on and let Jest's force-exit reap the process.
+  const softDeadline = new Promise((r) => setTimeout(r, 20000).unref?.());
+  try { await Promise.race([wt.cleanup?.(), softDeadline]); } catch { /* swallow */ }
+}, 45000);
 
 // ─── HTTP Status Detection ──────────────────────────────────────────────────
 

package/src/tools/webTool.js

@@ -144,6 +144,7 @@ import { BROWSER_CONFIG, KNOWN_SITES } from '../utilities/stealthConstants.js';
 
 // Credential vault for secure authentication
 import { getCredentialVault } from '../services/credentialVault.js';
+import { canonicalizeSiteId } from '../utilities/siteIdCanonical.js';
 
 /**
  * Actions that simulate genuine human input (and therefore warrant a human-like
@@ -1709,7 +1710,9 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
       };
     }
 
-    const normalizedSiteId = siteId.toLowerCase().trim();
+    // Canonicalize so the agent's identifier (a slug, a domain, or a full URL)
+    // resolves to the SAME vault key the user saved under in Settings.
+    const normalizedSiteId = canonicalizeSiteId(siteId);
 
     this.logger?.info('[WebTool] Authentication requested', {
       siteId: normalizedSiteId,

package/src/utilities/__tests__/siteIdCanonical.test.js

@@ -0,0 +1,92 @@
+import { describe, test, expect } from '@jest/globals';
+import { canonicalizeSiteId } from '../siteIdCanonical.js';
+
+// A small custom known-sites map to exercise slug/domain aliasing deterministically.
+const KNOWN = {
+  linkedin: { name: 'LinkedIn', loginUrl: 'https://www.linkedin.com/login' },
+  github: { name: 'GitHub', loginUrl: 'https://github.com/login' },
+  bad: { name: 'Bad', loginUrl: 'not a url' }, // malformed loginUrl → skipped in domain map
+};
+
+describe('canonicalizeSiteId', () => {
+  test('empty / nullish → ""', () => {
+    expect(canonicalizeSiteId(null, KNOWN)).toBe('');
+    expect(canonicalizeSiteId(undefined, KNOWN)).toBe('');
+    expect(canonicalizeSiteId('', KNOWN)).toBe('');
+    expect(canonicalizeSiteId('   ', KNOWN)).toBe('');
+  });
+
+  test('a known slug stays the slug', () => {
+    expect(canonicalizeSiteId('linkedin', KNOWN)).toBe('linkedin');
+    expect(canonicalizeSiteId('  LinkedIn  ', KNOWN)).toBe('linkedin');
+  });
+
+  test('a known site\'s domain maps to its slug', () => {
+    expect(canonicalizeSiteId('linkedin.com', KNOWN)).toBe('linkedin');
+    expect(canonicalizeSiteId('www.linkedin.com', KNOWN)).toBe('linkedin');
+    expect(canonicalizeSiteId('GitHub.com', KNOWN)).toBe('github');
+  });
+
+  test('a full URL for a known site maps to its slug', () => {
+    expect(canonicalizeSiteId('https://www.linkedin.com/login', KNOWN)).toBe('linkedin');
+    expect(canonicalizeSiteId('http://linkedin.com/', KNOWN)).toBe('linkedin');
+    expect(canonicalizeSiteId('https://www.linkedin.com:443/feed', KNOWN)).toBe('linkedin');
+  });
+
+  test('the whole point: every form of the same site converges', () => {
+    const forms = ['linkedin', 'LinkedIn', 'linkedin.com', 'www.linkedin.com', 'https://www.linkedin.com/login'];
+    const canon = forms.map(f => canonicalizeSiteId(f, KNOWN));
+    expect(new Set(canon).size).toBe(1);
+    expect(canon[0]).toBe('linkedin');
+  });
+
+  test('unknown domain → normalized host (www + port stripped)', () => {
+    expect(canonicalizeSiteId('www.example.com', KNOWN)).toBe('example.com');
+    expect(canonicalizeSiteId('https://example.com/path?q=1', KNOWN)).toBe('example.com');
+    expect(canonicalizeSiteId('example.com:8080', KNOWN)).toBe('example.com');
+  });
+
+  test('unknown bare token stays as-is (lowercased/trimmed)', () => {
+    expect(canonicalizeSiteId('  MyCustomSite  ', KNOWN)).toBe('mycustomsite');
+  });
+
+  test('an unparseable URL-ish string drops the path portion gracefully', () => {
+    expect(canonicalizeSiteId('ht!tp://%%%/foo', KNOWN)).toBe('ht!tp:');
+  });
+
+  test('malformed known-site loginUrl is skipped (no crash)', () => {
+    // 'bad' has an unparseable loginUrl; its slug still resolves directly.
+    expect(canonicalizeSiteId('bad', KNOWN)).toBe('bad');
+  });
+
+  test('defaults to the real KNOWN_SITES when no map passed (and caches)', () => {
+    // linkedin is a real known site → should resolve from its domain.
+    expect(canonicalizeSiteId('www.linkedin.com')).toBe('linkedin');
+    expect(canonicalizeSiteId('github.com')).toBe('github'); // 2nd call hits the cached map
+  });
+
+  test('a path-bearing string without a protocol is treated as a URL', () => {
+    expect(canonicalizeSiteId('example.com/login', KNOWN)).toBe('example.com');
+    expect(canonicalizeSiteId('foo/bar', KNOWN)).toBe('foo');
+  });
+
+  test('a value that strips to empty → ""', () => {
+    expect(canonicalizeSiteId(':8080', KNOWN)).toBe('');
+    expect(canonicalizeSiteId('www.', KNOWN)).toBe('');
+  });
+
+  test('known-sites entries with null/blank loginUrl are skipped without crashing', () => {
+    const known = {
+      ok: { name: 'Ok', loginUrl: 'https://ok.example/login' },
+      nullEntry: null,
+      noUrl: { name: 'NoUrl' },
+      blankHost: { name: 'Blank', loginUrl: 'file:///x' }, // parses, hostname === ''
+    };
+    expect(canonicalizeSiteId('ok.example', known)).toBe('ok');
+    expect(canonicalizeSiteId('whatever.com', known)).toBe('whatever.com'); // no match, no crash
+  });
+
+  test('tolerates a null known map (defensive default)', () => {
+    expect(canonicalizeSiteId('foo', null)).toBe('foo');
+  });
+});

package/src/utilities/constants.js

@@ -740,10 +740,27 @@ const SCHEDULER_CONFIG = {
 
   // Recovery delays (milliseconds)
   API_KEY_ERROR_DELAY_MS: 5 * 60 * 1000, // 5 minutes for API key issues
-  RATE_LIMIT_DELAY_MS: 2 * 60 * 1000, // 2 minutes for rate limiting
+  // Rate limits are minute-window (RPM/TPM) — a 60s cooldown self-heals the
+  // common case. Repeated strikes escalate (see RATE_LIMIT_ESCALATION_*).
+  RATE_LIMIT_DELAY_MS: 60 * 1000, // 1 minute quiet cooldown per strike
+  // Provider overload (529/capacity) is NOT a minute-window reset — capacity
+  // problems genuinely last longer, so it keeps the old 2-minute lane.
+  PROVIDER_OVERLOAD_DELAY_MS: 2 * 60 * 1000,
   NETWORK_ERROR_DELAY_MS: 30 * 1000, // 30 seconds for network issues
   UNKNOWN_ERROR_DELAY_MS: 60 * 1000, // 1 minute for unknown errors
 
+  // Rate-limit escalation ladder. Strikes are counted PER MODEL (the limit is
+  // per provider+model, shared by every agent using it) and decay when no new
+  // strike lands within the window. Strikes 1..N-1: quiet 60s cooldowns.
+  // Strike N: broadcast model_error (switch-model modal) + longer delay.
+  RATE_LIMIT_ESCALATION_STRIKES: 3,       // modal after 2 failed cooldowns
+  RATE_LIMIT_ESCALATED_DELAY_MS: 2 * 60 * 1000,
+  RATE_LIMIT_STRIKE_WINDOW_MS: 10 * 60 * 1000,
+  // When one agent hits the limit on model M, other agents on M are cooled
+  // down too — staggered so they don't all wake at once and re-stampede the
+  // freshly reset minute-window.
+  MODEL_COOLDOWN_STAGGER_MS: 15 * 1000,
+
   // Recent message threshold for inter-agent tracking
   RECENT_MESSAGE_THRESHOLD_MS: 10 * 60 * 1000, // 10 minutes
 

package/src/utilities/siteIdCanonical.js

@@ -0,0 +1,79 @@
+/**
+ * Canonicalize a website credential identifier so BOTH entry points — the user
+ * saving in Settings and the agent asking webTool to authenticate — resolve to
+ * the SAME vault key.
+ *
+ * Before this, each side just did `toLowerCase().trim()`, so a credential saved
+ * as "https://www.linkedin.com/login" (or "LinkedIn", or "linkedin.com") would
+ * never be found when the agent looked up "linkedin" — the vault re-prompted
+ * even though the user had already saved it.
+ *
+ * Rules (all applied after lower-casing + trimming):
+ *   - a URL or path-bearing string → reduce to its hostname
+ *   - strip a leading "www." and any :port
+ *   - if the result is a known-site slug (e.g. "linkedin") → keep it
+ *   - if the result is a known site's domain (e.g. "linkedin.com") → map it to
+ *     that site's slug ("linkedin")
+ *   - otherwise keep the normalized host/token (e.g. "example.com", "myslug")
+ *
+ * Pure + dependency-light so it's trivially testable and safe to call on every
+ * hop.
+ */
+
+import { KNOWN_SITES } from './stealthConstants.js';
+
+/** Build a { host-without-www → slug } map from KNOWN_SITES login URLs. */
+function buildDomainToSlug(known) {
+  const map = {};
+  for (const [slug, cfg] of Object.entries(known || {})) {
+    if (!cfg || !cfg.loginUrl) continue;
+    try {
+      const host = new URL(cfg.loginUrl).hostname.toLowerCase().replace(/^www\./, '');
+      if (host) map[host] = slug;
+    } catch {
+      /* skip malformed loginUrl */
+    }
+  }
+  return map;
+}
+
+let _cachedMap = null;
+function domainToSlug(known) {
+  if (known === KNOWN_SITES) {
+    if (!_cachedMap) _cachedMap = buildDomainToSlug(known);
+    return _cachedMap;
+  }
+  return buildDomainToSlug(known); // custom map (tests) — don't cache
+}
+
+/**
+ * @param {string} input - a slug, domain, or URL
+ * @param {object} [known] - known-sites map (defaults to KNOWN_SITES)
+ * @returns {string} canonical vault key ('' for empty input)
+ */
+export function canonicalizeSiteId(input, known = KNOWN_SITES) {
+  if (input == null) return '';
+  let s = String(input).trim().toLowerCase();
+  if (!s) return '';
+
+  // URL or path-bearing → reduce to hostname.
+  if (s.includes('://') || s.includes('/')) {
+    try {
+      s = new URL(s.includes('://') ? s : `https://${s}`).hostname;
+    } catch {
+      s = s.split('/')[0]; // not parseable — drop the path portion
+    }
+  }
+
+  s = s.replace(/^www\./, '').replace(/:\d+$/, ''); // strip www + :port
+  if (!s) return '';
+
+  // Direct known-site slug?
+  if (Object.prototype.hasOwnProperty.call(known || {}, s)) return s;
+
+  // Known site by domain (e.g. "linkedin.com" → "linkedin")?
+  const slug = domainToSlug(known)[s];
+  return slug || s;
+}
+
+export default canonicalizeSiteId;

package/web-ui/build/index.html

@@ -6,8 +6,8 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Loxia Autopilot One</title>
     <meta name="description" content="AI Agents System - No-code/vibe-code/companion-coder platform" />
-    <script type="module" crossorigin src="/static/index-Z3yzqwSM.js"></script>
-    <link rel="stylesheet" crossorigin href="/static/index-DLkEZgsP.css">
+    <script type="module" crossorigin src="/static/index-D5ugcmb5.js"></script>
+    <link rel="stylesheet" crossorigin href="/static/index-CCCr_d0f.css">
   </head>
   <body>
     <div id="root"></div>

package/web-ui/build/static/1c-Chd__H0X.js

@@ -0,0 +1,2 @@
+import{g as f}from"./index-D5ugcmb5.js";import{r as s}from"./index-BgQv5-Hn.js";function i(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const c=Object.getOwnPropertyDescriptor(e,r);c&&Object.defineProperty(t,r,c.get?c:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var a=s();const p=f(a),l=i({__proto__:null,default:p},[a]);export{l as _};
+//# sourceMappingURL=1c-Chd__H0X.js.map

package/web-ui/build/static/1c-Chd__H0X.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"1c-Chd__H0X.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/abap-z3xpIMD6.js

@@ -0,0 +1,2 @@
+import{g as s,r as f}from"./index-D5ugcmb5.js";function c(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const a=Object.getOwnPropertyDescriptor(e,r);a&&Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var p=f();const i=s(p),b=c({__proto__:null,default:i},[p]);export{b as a};
+//# sourceMappingURL=abap-z3xpIMD6.js.map

package/web-ui/build/static/abap-z3xpIMD6.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abap-z3xpIMD6.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/abnf-Cxa5i-Ka.js

@@ -0,0 +1,2 @@
+import{g as s,a as c}from"./index-D5ugcmb5.js";function i(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const a=Object.getOwnPropertyDescriptor(e,r);a&&Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var f=c();const p=s(f),b=i({__proto__:null,default:p},[f]);export{b as a};
+//# sourceMappingURL=abnf-Cxa5i-Ka.js.map

package/web-ui/build/static/abnf-Cxa5i-Ka.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abnf-Cxa5i-Ka.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/abnf-DfTJvpMA.js

@@ -0,0 +1,2 @@
+import{g as s}from"./index-D5ugcmb5.js";import{a as i}from"./index-BgQv5-Hn.js";function c(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const a=Object.getOwnPropertyDescriptor(e,r);a&&Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var f=i();const p=s(f),g=c({__proto__:null,default:p},[f]);export{g as a};
+//# sourceMappingURL=abnf-DfTJvpMA.js.map

package/web-ui/build/static/abnf-DfTJvpMA.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abnf-DfTJvpMA.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/accesslog-H0NR0TsC.js

@@ -0,0 +1,2 @@
+import{g as n}from"./index-D5ugcmb5.js";import{b as f}from"./index-BgQv5-Hn.js";function g(t,c){for(var o=0;o<c.length;o++){const e=c[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const s=Object.getOwnPropertyDescriptor(e,r);s&&Object.defineProperty(t,r,s.get?s:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var a=f();const l=n(a),u=g({__proto__:null,default:l},[a]);export{u as a};
+//# sourceMappingURL=accesslog-H0NR0TsC.js.map

package/web-ui/build/static/accesslog-H0NR0TsC.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"accesslog-H0NR0TsC.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/actionscript-CfplIEUr.js

@@ -0,0 +1,2 @@
+import{g as a,b as s}from"./index-D5ugcmb5.js";function p(r,i){for(var o=0;o<i.length;o++){const t=i[o];if(typeof t!="string"&&!Array.isArray(t)){for(const e in t)if(e!=="default"&&!(e in r)){const c=Object.getOwnPropertyDescriptor(t,e);c&&Object.defineProperty(r,e,c.get?c:{enumerable:!0,get:()=>t[e]})}}}return Object.freeze(Object.defineProperty(r,Symbol.toStringTag,{value:"Module"}))}var n=s();const f=a(n),g=p({__proto__:null,default:f},[n]);export{g as a};
+//# sourceMappingURL=actionscript-CfplIEUr.js.map

package/web-ui/build/static/actionscript-CfplIEUr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"actionscript-CfplIEUr.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}