@agenticmail/enterprise 0.5.311 → 0.5.313

package/dist/cli-verify-VKBNIEAX.js

@@ -0,0 +1,149 @@
+import {
+  DomainLock
+} from "./chunk-UPU23ZRG.js";
+import "./chunk-KFQGP6VL.js";
+
+// src/domain-lock/cli-verify.ts
+function getFlag(args, name) {
+  const idx = args.indexOf(name);
+  if (idx !== -1 && args[idx + 1]) return args[idx + 1];
+  return void 0;
+}
+function hasFlag(args, name) {
+  return args.includes(name);
+}
+function detectDbType(url) {
+  const u = url.toLowerCase().trim();
+  if (u.startsWith("postgres") || u.startsWith("pg:")) return "postgres";
+  if (u.startsWith("mysql")) return "mysql";
+  if (u.startsWith("mongodb")) return "mongodb";
+  if (u.startsWith("libsql") || u.includes(".turso.io")) return "turso";
+  if (u.endsWith(".db") || u.endsWith(".sqlite") || u.endsWith(".sqlite3") || u.startsWith("file:")) return "sqlite";
+  return "postgres";
+}
+async function runVerifyDomain(args) {
+  const { default: chalk } = await import("chalk");
+  const { default: ora } = await import("ora");
+  console.log("");
+  console.log(chalk.bold("  AgenticMail Enterprise \u2014 Domain Verification"));
+  console.log("");
+  let domain = getFlag(args, "--domain");
+  let dnsChallenge;
+  let db = null;
+  let dbConnected = false;
+  const envDbUrl = process.env.DATABASE_URL;
+  if (envDbUrl) {
+    const dbType = detectDbType(envDbUrl);
+    const spinner = ora(`Connecting to database (${dbType})...`).start();
+    try {
+      const { createAdapter } = await import("./factory-TBGUYM5X.js");
+      db = await createAdapter({ type: dbType, connectionString: envDbUrl });
+      await db.migrate();
+      const settings = await db.getSettings();
+      if (!domain && settings?.domain) domain = settings.domain;
+      if (settings?.domainDnsChallenge) dnsChallenge = settings.domainDnsChallenge;
+      dbConnected = true;
+      spinner.succeed(`Connected to ${dbType} database` + (domain ? ` (domain: ${domain})` : ""));
+    } catch (err) {
+      spinner.warn(`Could not connect via DATABASE_URL: ${err.message}`);
+      db = null;
+    }
+  }
+  if (!dbConnected) {
+    const dbPath = getFlag(args, "--db");
+    const dbType = getFlag(args, "--db-type") || "sqlite";
+    if (dbPath) {
+      const spinner = ora(`Connecting to ${dbType} database...`).start();
+      try {
+        const { createAdapter } = await import("./factory-TBGUYM5X.js");
+        db = await createAdapter({ type: dbType, connectionString: dbPath });
+        await db.migrate();
+        const settings = await db.getSettings();
+        if (!domain && settings?.domain) domain = settings.domain;
+        if (settings?.domainDnsChallenge) dnsChallenge = settings.domainDnsChallenge;
+        dbConnected = true;
+        spinner.succeed(`Connected to ${dbType} database`);
+      } catch {
+        spinner.warn("Could not read local database");
+      }
+    }
+  }
+  if (!domain) {
+    const { default: inquirer } = await import("inquirer");
+    const answer = await inquirer.prompt([{
+      type: "input",
+      name: "domain",
+      message: "Domain to verify:",
+      suffix: chalk.dim("  (e.g. agents.yourcompany.com)"),
+      validate: (v) => v.includes(".") || "Enter a valid domain",
+      filter: (v) => v.trim().toLowerCase()
+    }]);
+    domain = answer.domain;
+  }
+  const lock = new DomainLock();
+  const maxAttempts = hasFlag(args, "--poll") ? 5 : 1;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const spinner = ora(
+      maxAttempts > 1 ? `Checking DNS verification (attempt ${attempt}/${maxAttempts})...` : "Checking DNS verification..."
+    ).start();
+    try {
+      const result = await lock.checkVerification(domain);
+      if (!result.success) {
+        spinner.fail("Verification check failed");
+        console.log("");
+        console.error(chalk.red(`  ${result.error}`));
+        console.log("");
+        if (db) await db.disconnect();
+        process.exit(1);
+      }
+      if (result.verified) {
+        spinner.succeed("Domain verified!");
+        if (dbConnected && db) {
+          try {
+            await db.updateSettings({
+              domainStatus: "verified",
+              domainVerifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+            });
+            console.log(chalk.dim("  Database updated with verified status."));
+          } catch {
+          }
+        }
+        console.log("");
+        console.log(chalk.green.bold(`  \u2713 ${domain} is verified and protected.`));
+        console.log(chalk.dim("  Your deployment domain is locked. No other instance can claim it."));
+        console.log(chalk.dim("  The system now operates 100% offline \u2014 no outbound calls are made."));
+        console.log("");
+        if (db) await db.disconnect();
+        return;
+      }
+    } catch (err) {
+      spinner.warn(`Check failed: ${err.message}`);
+    }
+    if (attempt < maxAttempts) {
+      const waitSpinner = ora(`DNS record not found yet. Retrying in 10 seconds...`).start();
+      await new Promise((r) => setTimeout(r, 1e4));
+      waitSpinner.stop();
+    }
+  }
+  console.log("");
+  console.log(chalk.yellow("  DNS record not detected yet."));
+  console.log("");
+  console.log(chalk.bold("  Make sure this TXT record exists at your DNS provider:"));
+  console.log("");
+  console.log(`  ${chalk.bold("Host:")}   ${chalk.cyan(`_agenticmail-verify.${domain}`)}`);
+  console.log(`  ${chalk.bold("Type:")}   ${chalk.cyan("TXT")}`);
+  if (dnsChallenge) {
+    console.log(`  ${chalk.bold("Value:")}  ${chalk.cyan(dnsChallenge)}`);
+  } else {
+    console.log(`  ${chalk.bold("Value:")}  ${chalk.dim("(check your dashboard or setup output)")}`);
+  }
+  console.log("");
+  console.log(chalk.dim("  DNS propagation can take up to 48 hours."));
+  console.log(chalk.dim("  Run with --poll to retry automatically:"));
+  console.log(chalk.dim(`    npx @agenticmail/enterprise verify-domain --domain ${domain} --poll`));
+  console.log("");
+  if (db) await db.disconnect();
+}
+export {
+  runVerifyDomain
+};

package/dist/cli.js

@@ -14,10 +14,10 @@ switch (command) {
     import("./cli-submit-skill-SNGAHVB7.js").then((m) => m.runSubmitSkill(args.slice(1))).catch(fatal);
     break;
   case "recover":
-    import("./cli-recover-44SVHH3K.js").then((m) => m.runRecover(args.slice(1))).catch(fatal);
+    import("./cli-recover-T32NABFA.js").then((m) => m.runRecover(args.slice(1))).catch(fatal);
     break;
   case "verify-domain":
-    import("./cli-verify-NGRIHB3J.js").then((m) => m.runVerifyDomain(args.slice(1))).catch(fatal);
+    import("./cli-verify-CZIITRED.js").then((m) => m.runVerifyDomain(args.slice(1))).catch(fatal);
     break;
   case "reset-password":
     import("./cli-reset-password-SO5Y6MW7.js").then((m) => m.runResetPassword(args.slice(1))).catch(fatal);
@@ -57,14 +57,14 @@ Skill Development:
     break;
   case "serve":
   case "start":
-    import("./cli-serve-COFEVLTD.js").then((m) => m.runServe(args.slice(1))).catch(fatal);
+    import("./cli-serve-Y534FCRV.js").then((m) => m.runServe(args.slice(1))).catch(fatal);
     break;
   case "agent":
-    import("./cli-agent-EV7RDHZ4.js").then((m) => m.runAgent(args.slice(1))).catch(fatal);
+    import("./cli-agent-5WV3EEPW.js").then((m) => m.runAgent(args.slice(1))).catch(fatal);
     break;
   case "setup":
   default:
-    import("./setup-VF4ZBLQQ.js").then((m) => m.runSetupWizard()).catch(fatal);
+    import("./setup-N3ODDSQE.js").then((m) => m.runSetupWizard()).catch(fatal);
     break;
 }
 function fatal(err) {

package/dist/dashboard/app.js

@@ -163,6 +163,12 @@ function App() {
     if (document.cookie.match(/em_session|em_csrf/)) {
       authCall('/me').then(async d => {
         setUser(d.user || d);
+        // If user is org-bound, lock org context immediately
+        var u = d.user || d;
+        if (u.clientOrgId) {
+          setSelectedOrgId(u.clientOrgId);
+          localStorage.setItem('em_client_org_id', u.clientOrgId);
+        }
         // Init transport encryption BEFORE setting authed — ensures all subsequent
         // API calls from child components are encrypted
         try {
@@ -202,9 +208,10 @@ function App() {
     apiCall('/settings').then(d => { const s = d.settings || d || {}; if (s.primaryColor) applyBrandColor(s.primaryColor); if (s.orgId) setOrgId(s.orgId); }).catch(() => {});
     apiCall('/me/permissions').then(d => {
       if (d && d.permissions) setPermissions(d.permissions);
-      // If user is assigned to a client org, auto-set org context
+      // If user is assigned to a client org, auto-set org context and lock switcher
       if (d && d.clientOrgId) {
         localStorage.setItem('em_client_org_id', d.clientOrgId);
+        setSelectedOrgId(d.clientOrgId);
       } else {
         localStorage.removeItem('em_client_org_id');
       }
@@ -230,10 +237,15 @@ function App() {
         if (d.user.permissions) setPermissions(d.user.permissions);
         if (d.user.clientOrgId) {
           localStorage.setItem('em_client_org_id', d.user.clientOrgId);
+          // Auto-select the client org so all pages filter by it
+          onOrgChange(d.user.clientOrgId, null);
           apiCall('/organizations/' + d.user.clientOrgId).then(function(o) {
-            if (o && o.name) setImpersonating(function(prev) { return prev ? Object.assign({}, prev, { user: Object.assign({}, prev.user, { clientOrgName: o.name }) }) : prev; });
+            if (o && o.name) {
+              setImpersonating(function(prev) { return prev ? Object.assign({}, prev, { user: Object.assign({}, prev.user, { clientOrgName: o.name }) }) : prev; });
+              onOrgChange(d.user.clientOrgId, o);
+            }
           }).catch(function() {});
-        } else localStorage.removeItem('em_client_org_id');
+        } else { localStorage.removeItem('em_client_org_id'); onOrgChange('', null); }
         toast('Now viewing as ' + d.user.name, 'info');
         setPage('dashboard');
       }
@@ -248,6 +260,7 @@ function App() {
       return null;
     });
     localStorage.removeItem('em_client_org_id');
+    onOrgChange('', null); // Reset org selection back to platform org
     authCall('/me').then(d => { setUser(d.user || d); }).catch(() => {});
     apiCall('/me/permissions').then(d => { if (d && d.permissions) setPermissions(d.permissions); }).catch(() => {});
     toast('Stopped impersonation', 'success');

package/dist/dashboard/components/org-switcher.js

@@ -136,7 +136,11 @@ export function OrgContextSwitcher(props) {
  */
 export function useOrgContext() {
   var app = useApp();
-  var selectedOrgId = app.selectedOrgId || '';
+  var user = app.user || {};
+  var userClientOrgId = user.clientOrgId || null;
+  var isLocked = !!userClientOrgId && user.role !== 'owner' && user.role !== 'admin';
+  // If user is org-bound (locked), always use their clientOrgId regardless of selectedOrgId
+  var selectedOrgId = isLocked ? userClientOrgId : (app.selectedOrgId || '');
   var selectedOrg = app.selectedOrg || null;
   var onOrgChange = app.onOrgChange || function() {};
 

package/dist/dashboard/org-switcher.js

@@ -0,0 +1,156 @@
+import { h, useState, useEffect, useCallback, useRef, Fragment, apiCall, useApp } from './utils.js';
+import { I } from './icons.js';
+
+// ─── Global org cache (shared across all switcher instances) ────────
+var _orgCache = { orgs: null, loading: false, listeners: [], lastFetch: 0 };
+var ORG_CACHE_TTL = 5 * 60 * 1000; // 5 minutes
+
+function getOrgsFromCache(forceRefresh) {
+  var now = Date.now();
+  // Return cached if fresh
+  if (!forceRefresh && _orgCache.orgs && (now - _orgCache.lastFetch) < ORG_CACHE_TTL) {
+    return Promise.resolve(_orgCache.orgs);
+  }
+  // Already loading — wait for it
+  if (_orgCache.loading) {
+    return new Promise(function(resolve) {
+      _orgCache.listeners.push(resolve);
+    });
+  }
+  // Fetch
+  _orgCache.loading = true;
+  return apiCall('/organizations').then(function(d) {
+    var list = d.organizations || [];
+    _orgCache.orgs = list;
+    _orgCache.lastFetch = Date.now();
+    _orgCache.loading = false;
+    // Notify waiters
+    var listeners = _orgCache.listeners;
+    _orgCache.listeners = [];
+    listeners.forEach(function(fn) { fn(list); });
+    return list;
+  }).catch(function() {
+    _orgCache.loading = false;
+    _orgCache.orgs = _orgCache.orgs || [];
+    var listeners = _orgCache.listeners;
+    _orgCache.listeners = [];
+    listeners.forEach(function(fn) { fn(_orgCache.orgs || []); });
+    return _orgCache.orgs || [];
+  });
+}
+
+/** Invalidate org cache (call after creating/deleting orgs) */
+export function invalidateOrgCache() {
+  _orgCache.orgs = null;
+  _orgCache.lastFetch = 0;
+}
+
+/**
+ * OrgContextSwitcher — Global org context picker for multi-tenant pages.
+ *
+ * If the current user has a clientOrgId, the switcher is LOCKED to that org
+ * (they can only see their org's data). Owners/admins can switch freely.
+ *
+ * Uses a global cache so /organizations is only fetched once across all pages.
+ */
+export function OrgContextSwitcher(props) {
+  var onOrgChange = props.onOrgChange;
+  var selectedOrgId = props.selectedOrgId || '';
+  var showLabel = props.showLabel !== false;
+  var style = props.style || {};
+
+  var app = useApp();
+  var user = app.user || {};
+  var userOrgId = user.clientOrgId || null;
+  var isLocked = !!userOrgId && user.role !== 'owner' && user.role !== 'admin';
+
+  var _orgs = useState(_orgCache.orgs || []);
+  var orgs = _orgs[0]; var setOrgs = _orgs[1];
+  var _loaded = useState(!!_orgCache.orgs);
+  var loaded = _loaded[0]; var setLoaded = _loaded[1];
+
+  useEffect(function() {
+    // If already cached, use immediately (no API call)
+    if (_orgCache.orgs && (Date.now() - _orgCache.lastFetch) < ORG_CACHE_TTL) {
+      setOrgs(_orgCache.orgs);
+      setLoaded(true);
+      return;
+    }
+    getOrgsFromCache(false).then(function(list) {
+      setOrgs(list);
+      setLoaded(true);
+    });
+  }, []);
+
+  // Don't render if no client orgs and user isn't org-bound
+  if (loaded && orgs.length === 0 && !userOrgId) return null;
+  if (!loaded) return null;
+
+  var effectiveId = isLocked ? userOrgId : selectedOrgId;
+  var selectedOrg = orgs.find(function(o) { return o.id === effectiveId; });
+
+  return h('div', {
+    style: Object.assign({
+      display: 'flex', alignItems: 'center', gap: 10, padding: '8px 14px',
+      background: 'var(--bg-tertiary)', border: '1px solid var(--border)',
+      borderRadius: 'var(--radius, 8px)',
+      marginBottom: 16, fontSize: 13
+    }, style)
+  },
+    showLabel && h('span', { style: { color: 'var(--text-muted)', fontWeight: 600, whiteSpace: 'nowrap' } }, I.building(), ' Viewing:'),
+    isLocked
+      ? h('div', { style: { fontWeight: 600, fontSize: 13, color: 'var(--text)', display: 'flex', alignItems: 'center', gap: 6 } },
+          selectedOrg ? selectedOrg.name : 'Your Organization',
+          h('span', { className: 'badge badge-neutral', style: { fontSize: 10 } }, 'Locked')
+        )
+      : h('select', {
+          value: selectedOrgId,
+          onChange: function(e) {
+            var id = e.target.value;
+            var org = orgs.find(function(o) { return o.id === id; });
+            onOrgChange(id, org || null);
+          },
+          style: {
+            padding: '6px 10px', borderRadius: 6, border: '1px solid var(--border)',
+            background: 'var(--bg-card)', color: 'var(--text)', fontSize: 13,
+            cursor: 'pointer', fontWeight: 600, flex: 1, maxWidth: 300
+          }
+        },
+        h('option', { value: '' }, 'My Organization'),
+        orgs.filter(function(o) { return o.is_active !== false; }).map(function(o) {
+          return h('option', { key: o.id, value: o.id }, o.name + (o.billing_rate_per_agent > 0 ? ' (' + (o.currency || 'USD') + ' ' + parseFloat(o.billing_rate_per_agent).toFixed(0) + '/agent)' : ''));
+        })
+      ),
+    selectedOrg && h('span', { style: { fontSize: 11, color: 'var(--text-muted)' } },
+      selectedOrg.contact_name ? selectedOrg.contact_name : '',
+      selectedOrg.contact_email ? ' \u2022 ' + selectedOrg.contact_email : ''
+    ),
+    // Impersonation banner
+    app.impersonating && h('span', { className: 'badge badge-warning', style: { fontSize: 10, marginLeft: 'auto' } }, 'Impersonating: ' + (user.name || user.email))
+  );
+}
+
+/**
+ * useOrgContext — Hook that provides org switching state.
+ * Auto-selects the user's client org if they are org-bound.
+ */
+export function useOrgContext() {
+  var app = useApp();
+  var user = app.user || {};
+  var userClientOrgId = user.clientOrgId || null;
+  var isLocked = !!userClientOrgId && user.role !== 'owner' && user.role !== 'admin';
+  // If user is org-bound (locked), always use their clientOrgId regardless of selectedOrgId
+  var selectedOrgId = isLocked ? userClientOrgId : (app.selectedOrgId || '');
+  var selectedOrg = app.selectedOrg || null;
+  var onOrgChange = app.onOrgChange || function() {};
+
+  // Stable Switcher reference
+  var Switcher = useCallback(function(extraProps) {
+    return h(OrgContextSwitcher, Object.assign({
+      selectedOrgId: selectedOrgId,
+      onOrgChange: onOrgChange
+    }, extraProps || {}));
+  }, [selectedOrgId, onOrgChange]);
+
+  return { selectedOrgId: selectedOrgId, selectedOrg: selectedOrg, onOrgChange: onOrgChange, Switcher: Switcher };
+}

package/dist/dashboard/pages/login.js

@@ -382,6 +382,118 @@ export function OnboardingWizard({ onComplete }) {
 
   var set = function(k, v) { setForm(function(f) { return Object.assign({}, f, { [k]: v }); }); };
 
+  // ─── Smart DB URL Analysis & Auto-Optimization ─────
+
+  var analyzeDbUrl = function(url) {
+    if (!url) return null;
+    try {
+      var u = new URL(url);
+      var port = u.port || '5432';
+      var host = u.hostname || '';
+      var info = {
+        host: host, port: port, provider: null, isPooler: false, poolerMode: null,
+        directUrl: null, optimizedUrl: null, warnings: [], tips: [], autoFixed: []
+      };
+
+      // ── Supabase Detection ──────────────────────────
+      if (host.includes('.supabase.co') || host.includes('pooler.supabase.com')) {
+        info.provider = 'supabase';
+        var projectRef = u.username.replace('postgres.', '');
+
+        if (host.includes('pooler.supabase.com')) {
+          info.isPooler = true;
+          info.poolerMode = port === '6543' ? 'transaction' : port === '5432' ? 'session' : 'unknown';
+
+          // Build direct URL: db.{ref}.supabase.co:5432
+          var directU = new URL(url);
+          directU.hostname = 'db.' + projectRef + '.supabase.co';
+          directU.port = '5432';
+          directU.searchParams.delete('pgbouncer');
+          info.directUrl = directU.toString();
+
+          if (port === '5432') {
+            // Auto-fix: switch from session mode (5432) to transaction mode (6543)
+            var fixedU = new URL(url);
+            fixedU.port = '6543';
+            fixedU.searchParams.set('pgbouncer', 'true');
+            info.optimizedUrl = fixedU.toString();
+            info.autoFixed.push('Switched from session mode (port 5432) to transaction mode (port 6543) — higher connection limits and better for multi-process setups.');
+            info.autoFixed.push('Added ?pgbouncer=true for proper connection pooling.');
+          } else if (port === '6543') {
+            // Already on transaction mode — ensure pgbouncer param is set
+            if (!u.searchParams.get('pgbouncer')) {
+              var optU = new URL(url);
+              optU.searchParams.set('pgbouncer', 'true');
+              info.optimizedUrl = optU.toString();
+              info.autoFixed.push('Added ?pgbouncer=true parameter for proper PgBouncer transaction mode handling.');
+            }
+            info.tips.push('Transaction mode pooler detected — optimal for production.');
+          }
+          info.tips.push('Direct URL auto-generated for migrations (bypasses pooler for DDL operations).');
+
+        } else if (host.startsWith('db.') || host.includes('.supabase.co')) {
+          // Direct connection — build pooler URL for them
+          info.directUrl = url;
+          var region = host.match(/db\.([^.]+)\.supabase\.co/)?.[1] || projectRef;
+          // Try to detect region from hostname pattern
+          var poolerU = new URL(url);
+          // Supabase pooler format: aws-0-{region}.pooler.supabase.com
+          poolerU.hostname = 'aws-0-us-east-1.pooler.supabase.com'; // default, user may need to adjust
+          poolerU.port = '6543';
+          poolerU.username = 'postgres.' + region;
+          poolerU.searchParams.set('pgbouncer', 'true');
+          info.warnings.push('Direct connection detected. For production with multiple agents, use the Supabase connection pooler.');
+          info.tips.push('Go to Supabase Dashboard > Settings > Database > Connection string > URI, and select "Transaction mode" to get the correct pooler URL.');
+        }
+      }
+      // ── Neon Detection ──────────────────────────────
+      else if (host.includes('.neon.tech')) {
+        info.provider = 'neon';
+        info.isPooler = host.includes('-pooler');
+        if (!info.isPooler) {
+          // Auto-fix: add -pooler to hostname
+          var neonFixedU = new URL(url);
+          var parts = neonFixedU.hostname.split('.');
+          if (parts[0] && !parts[0].endsWith('-pooler')) {
+            parts[0] = parts[0] + '-pooler';
+            neonFixedU.hostname = parts.join('.');
+            info.optimizedUrl = neonFixedU.toString();
+            info.autoFixed.push('Added connection pooler endpoint (-pooler) for better connection handling.');
+          }
+          // Direct URL is the original
+          info.directUrl = url;
+          info.tips.push('Direct URL saved for migrations.');
+        } else {
+          // Already pooled — generate direct URL
+          var neonDirectU = new URL(url);
+          var neonParts = neonDirectU.hostname.split('.');
+          if (neonParts[0]) {
+            neonParts[0] = neonParts[0].replace(/-pooler$/, '');
+            neonDirectU.hostname = neonParts.join('.');
+          }
+          info.directUrl = neonDirectU.toString();
+          info.tips.push('Neon pooler detected — optimal for production. Direct URL auto-generated for migrations.');
+        }
+      }
+      // ── Generic Postgres ────────────────────────────
+      else {
+        info.provider = 'postgres';
+        // Check for common PgBouncer indicators
+        if (port === '6432' || port === '6543' || u.searchParams.get('pgbouncer') === 'true') {
+          info.isPooler = true;
+          info.poolerMode = 'transaction';
+          info.tips.push('PgBouncer detected. Connection pooling will be configured automatically.');
+        }
+      }
+
+      return info;
+    } catch { return null; }
+  };
+
+  var dbUrlInfo = useMemo(function() {
+    return analyzeDbUrl(form.dbConnectionString);
+  }, [form.dbConnectionString]);
+
   // ─── DB Config Builder ──────────────────────────────
 
   var buildDbConfig = function() {
@@ -389,7 +501,17 @@ export function OnboardingWizard({ onComplete }) {
     if (t === 'sqlite') return { type: 'sqlite' };
     if (t === 'turso') return { type: 'turso', connectionString: form.dbConnectionString, authToken: form.dbAuthToken };
     if (t === 'dynamodb') return { type: 'dynamodb', region: form.dbRegion, accessKeyId: form.dbAccessKey, secretAccessKey: form.dbSecretKey };
-    return { type: t, connectionString: form.dbConnectionString };
+    // Use optimized URL if available (auto-fixed pooler mode, pgbouncer param, etc.)
+    var connStr = (dbUrlInfo && dbUrlInfo.optimizedUrl) ? dbUrlInfo.optimizedUrl : form.dbConnectionString;
+    var config = { type: t, connectionString: connStr };
+    // Auto-attach smart DB metadata for Postgres-family databases
+    if (dbUrlInfo) {
+      config.poolerDetected = dbUrlInfo.isPooler || !!dbUrlInfo.optimizedUrl;
+      config.poolerMode = dbUrlInfo.poolerMode || (dbUrlInfo.optimizedUrl ? 'transaction' : null);
+      config.directUrl = dbUrlInfo.directUrl;
+      config.provider = dbUrlInfo.provider;
+    }
+    return config;
   };
 
   // ─── Actions ────────────────────────────────────────
@@ -528,9 +650,43 @@ export function OnboardingWizard({ onComplete }) {
       );
     }
     // Connection string types: postgres, mysql, mongodb, supabase, neon, planetscale, cockroachdb
-    return h('div', { className: 'form-group' },
-      h('label', { className: 'form-label' }, 'Connection String'),
-      h('input', { className: 'input', value: form.dbConnectionString, onChange: function(e) { set('dbConnectionString', e.target.value); }, placeholder: currentDbType ? currentDbType.placeholder : '' })
+    var urlHints = dbUrlInfo && form.dbConnectionString.length > 10;
+    return h(Fragment, null,
+      h('div', { className: 'form-group' },
+        h('label', { className: 'form-label' }, 'Connection String'),
+        h('input', { className: 'input', value: form.dbConnectionString, onChange: function(e) { set('dbConnectionString', e.target.value); }, placeholder: currentDbType ? currentDbType.placeholder : '' })
+      ),
+      // Smart URL analysis hints
+      urlHints && h('div', { style: { margin: '-8px 0 12px', fontSize: 12, lineHeight: 1.6 } },
+        dbUrlInfo.provider && dbUrlInfo.provider !== 'postgres' && h('div', { style: { color: 'var(--accent)', fontWeight: 500, marginBottom: 4 } },
+          dbUrlInfo.provider === 'supabase' ? '\uD83D\uDFE2 Supabase' : dbUrlInfo.provider === 'neon' ? '\uD83D\uDFE2 Neon' : dbUrlInfo.provider,
+          ' detected',
+          dbUrlInfo.isPooler || dbUrlInfo.optimizedUrl ? ' \u2014 connection will be auto-optimized' : ' (direct connection)'
+        ),
+        // Auto-fix notifications (green — things we fixed for them)
+        dbUrlInfo.autoFixed && dbUrlInfo.autoFixed.map(function(f, i) {
+          return h('div', { key: 'f' + i, style: { color: '#10b981', padding: '4px 8px', background: 'rgba(16,185,129,0.08)', borderRadius: 6, marginBottom: 4 } },
+            '\u2728 Auto-configured: ', f
+          );
+        }),
+        // Warnings (yellow — things they need to act on)
+        dbUrlInfo.warnings.map(function(w, i) {
+          return h('div', { key: 'w' + i, style: { color: 'var(--warning, #f59e0b)', padding: '4px 8px', background: 'rgba(245,158,11,0.1)', borderRadius: 6, marginBottom: 4 } },
+            '\u26A0\uFE0F ', w
+          );
+        }),
+        // Tips (informational)
+        dbUrlInfo.tips.map(function(t, i) {
+          return h('div', { key: 't' + i, style: { color: 'var(--text-secondary)', padding: '2px 0' } },
+            '\u2714\uFE0F ', t
+          );
+        }),
+        // Summary of what will be sent
+        (dbUrlInfo.directUrl || dbUrlInfo.optimizedUrl) && h('div', { style: { color: 'var(--text-secondary)', padding: '6px 8px', background: 'var(--bg-secondary)', borderRadius: 6, marginTop: 4, fontSize: 11 } },
+          dbUrlInfo.optimizedUrl && h('div', null, '\uD83D\uDD17 Pooler URL: ', h('code', { style: { fontSize: 10 } }, dbUrlInfo.optimizedUrl.substring(0, 60) + '...')),
+          dbUrlInfo.directUrl && h('div', null, '\uD83D\uDD17 Direct URL (migrations): ', h('code', { style: { fontSize: 10 } }, dbUrlInfo.directUrl.substring(0, 60) + '...'))
+        )
+      )
     );
   };
 

package/dist/dashboard/pages/task-pipeline.js

@@ -231,6 +231,7 @@ var ACTIVITY_TYPE_COLORS = {
   created: '#6366f1', assigned: '#991b1b', started: '#06b6d4', in_progress: '#06b6d4',
   completed: '#15803d', failed: '#ef4444', cancelled: '#6b7394', delegated: '#a855f7',
   compaction: '#8b5cf6', error: '#ef4444',
+  crash: '#dc2626', recovery: '#f59e0b', note: '#3b82f6',
 };
 
 function ActivityLog(props) {
@@ -1084,7 +1085,6 @@ export function AgentTaskPipeline(props) {
   }
 
   return h(Fragment, null,
-    h(orgCtx.Switcher),
     active.length > 0 && h('div', { style: { marginBottom: 12 } },
       h('div', { style: { fontSize: 11, fontWeight: 600, color: STATUS_COLORS.in_progress, marginBottom: 6, display: 'flex', alignItems: 'center', gap: 4 } },
         h('div', { style: { width: 6, height: 6, borderRadius: '50%', background: STATUS_COLORS.in_progress, animation: 'flowPulse 2s infinite' } }),

package/dist/factory-3IWXVE37.js

@@ -0,0 +1,9 @@
+import {
+  createAdapter,
+  getSupportedDatabases
+} from "./chunk-D3KFSWLK.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  createAdapter,
+  getSupportedDatabases
+};

package/dist/factory-5M6PTMLC.js

@@ -0,0 +1,11 @@
+import {
+  createAdapter,
+  getSupportedDatabases,
+  smartDbConfig
+} from "./chunk-BSVWPG6I.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  createAdapter,
+  getSupportedDatabases,
+  smartDbConfig
+};

package/dist/factory-CSSHN7GE.js

@@ -0,0 +1,11 @@
+import {
+  createAdapter,
+  getSupportedDatabases,
+  smartDbConfig
+} from "./chunk-MQKIWAHQ.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  createAdapter,
+  getSupportedDatabases,
+  smartDbConfig
+};

package/dist/factory-JFWXTAWK.js

@@ -0,0 +1,11 @@
+import {
+  createAdapter,
+  getSupportedDatabases,
+  smartDbConfig
+} from "./chunk-MJGGW6MC.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  createAdapter,
+  getSupportedDatabases,
+  smartDbConfig
+};

package/dist/factory-TBGUYM5X.js

@@ -0,0 +1,9 @@
+import {
+  createAdapter,
+  getSupportedDatabases
+} from "./chunk-NGA7BBPF.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  createAdapter,
+  getSupportedDatabases
+};