@shawnowen/comet-mcp 2.3.1 → 2.4.1

package/extension/session-logic.js

@@ -0,0 +1,2383 @@
+// session-logic.js — Extracted pure logic functions (Spec 036)
+// Dual-format: ESM exports for Node.js tests, globalThis for Chrome extension
+// Wrapped in IIFE to avoid polluting global scope (individual function names
+// must not leak, or background.js/sidepanel.js delegate consts will collide).
+
+(function () {
+  const DEFAULT_DOMAIN_DISPLAY_MAP = {
+    "github.com": "GitHub",
+    "docs.google.com": "Google Docs",
+    "sheets.google.com": "Google Sheets",
+    "drive.google.com": "Google Drive",
+    "mail.google.com": "Gmail",
+    "app.asana.com": "Asana",
+    "linear.app": "Linear",
+    "slack.com": "Slack",
+    "notion.so": "Notion",
+    "figma.com": "Figma",
+    "app.shortwave.com": "Shortwave",
+  };
+
+  const EQUANAUT_PROVIDER_LABELS = {
+    gateway: "Equabot Gateway",
+    anthropic: "Anthropic",
+    openai: "OpenAI",
+    "openai-codex": "OpenAI Codex",
+    google: "Google Gemini",
+    xai: "xAI",
+    deepseek: "DeepSeek",
+    perplexity: "Perplexity",
+    ollama: "Local Ollama",
+    "ollama-cloud": "Ollama Cloud",
+    local: "Local Ollama",
+  };
+
+  const EQUANAUT_PROVIDER_ORDER = [
+    "gateway",
+    "anthropic",
+    "openai",
+    "openai-codex",
+    "google",
+    "xai",
+    "deepseek",
+    "perplexity",
+    "ollama-cloud",
+    "ollama",
+    "local",
+  ];
+
+  const EQUANAUT_PROVIDER_GLYPHS = {
+    gateway: "EQ",
+    anthropic: "AI",
+    openai: "OA",
+    "openai-codex": "CX",
+    google: "G",
+    xai: "xAI",
+    deepseek: "DS",
+    perplexity: "PX",
+    ollama: "OL",
+    "ollama-cloud": "OC",
+    local: "OL",
+  };
+
+  const EQUANAUT_MODEL_CAPABILITIES = {
+    fast: "Fast",
+    vision: "Vision",
+    reasoning: "Reasoning",
+    tools: "Tools",
+    image: "Image",
+    pdf: "PDF",
+  };
+
+  const EQUANAUT_MODEL_CAPABILITY_ORDER = ["fast", "vision", "reasoning", "tools", "image", "pdf"];
+
+  const EQUANAUT_COMMAND_CENTER_FALLBACK_MODELS = [
+    {
+      id: "gateway:default",
+      name: "Equabot Gateway (Default)",
+      provider: "gateway",
+      type: "cloud",
+      status: "unknown",
+      source: "command-center-fallback",
+      details: "Uses the Equa account gateway primary model",
+      isDefault: true,
+    },
+    {
+      id: "gateway:anthropic/claude-opus-4-5",
+      name: "Claude Opus 4.5",
+      provider: "anthropic",
+      type: "cloud",
+      status: "unknown",
+      source: "command-center-fallback",
+      contextLength: 200000,
+    },
+    {
+      id: "gateway:anthropic/claude-sonnet-4-20250514",
+      name: "Claude Sonnet 4",
+      provider: "anthropic",
+      type: "cloud",
+      status: "unknown",
+      source: "command-center-fallback",
+      contextLength: 200000,
+    },
+    {
+      id: "gateway:openai/gpt-5.2",
+      name: "GPT-5.2 (OpenAI)",
+      provider: "openai",
+      type: "cloud",
+      status: "unknown",
+      source: "command-center-fallback",
+    },
+    {
+      id: "gateway:google/gemini-3-pro-preview",
+      name: "Gemini 3.1 Pro (Google)",
+      provider: "google",
+      type: "cloud",
+      status: "unknown",
+      source: "command-center-fallback",
+    },
+    {
+      id: "gateway:google/gemini-2.5-pro",
+      name: "Gemini 2.5 Pro",
+      provider: "google",
+      type: "cloud",
+      status: "unknown",
+      source: "command-center-fallback",
+    },
+    {
+      id: "gateway:xai/grok-3",
+      name: "Grok 3",
+      provider: "xai",
+      type: "cloud",
+      status: "unknown",
+      source: "command-center-fallback",
+    },
+    {
+      id: "gateway:deepseek/deepseek-chat",
+      name: "DeepSeek Chat",
+      provider: "deepseek",
+      type: "cloud",
+      status: "unknown",
+      source: "command-center-fallback",
+    },
+    {
+      id: "deepseek-coder-v2:latest",
+      name: "deepseek-coder-v2:latest",
+      provider: "ollama",
+      type: "local",
+      status: "unknown",
+      source: "command-center-fallback",
+      details: "Command Center standalone fallback",
+    },
+    {
+      id: "qwen2.5:72b",
+      name: "qwen2.5:72b",
+      provider: "ollama",
+      type: "local",
+      status: "unknown",
+      source: "command-center-fallback",
+      details: "Command Center standalone fallback",
+    },
+    {
+      id: "llama3.3:70b",
+      name: "llama3.3:70b",
+      provider: "ollama",
+      type: "local",
+      status: "unknown",
+      source: "command-center-fallback",
+      details: "Command Center standalone fallback",
+    },
+  ];
+
+  function normalizeProviderKey(provider) {
+    return String(provider || "")
+      .trim()
+      .toLowerCase();
+  }
+
+  function providerLabel(provider) {
+    const key = normalizeProviderKey(provider);
+    return EQUANAUT_PROVIDER_LABELS[key] || (provider ? String(provider) : "Other");
+  }
+
+  function getEquanautProviderGlyph(provider) {
+    const key = normalizeProviderKey(provider);
+    if (EQUANAUT_PROVIDER_GLYPHS[key]) return EQUANAUT_PROVIDER_GLYPHS[key];
+    const label = providerLabel(key);
+    const letters = label.match(/[A-Za-z0-9]/g) || [];
+    return (letters[0] || "?").toUpperCase() + (letters[1] || "").toUpperCase();
+  }
+
+  function getEquanautProviderFilterKey(model) {
+    if (!model) return "gateway";
+    if (model.location === "local") return "ollama";
+    if (model.location === "cloud" && model.provider === "ollama") return "ollama-cloud";
+    return (
+      normalizeProviderKey(model.provider || inferEquanautProviderFromId(model.id)) || "gateway"
+    );
+  }
+
+  function getEquanautModelSearchText(model) {
+    const capabilities = Array.isArray(model?.capabilities)
+      ? model.capabilities
+      : getEquanautModelCapabilities(model);
+    return [
+      model?.id,
+      model?.sourceId,
+      model?.name,
+      model?.provider,
+      model?.providerLabel,
+      model?.location,
+      model?.route,
+      model?.meta,
+      model?.details,
+      model?.source,
+      model?.costTier || getEquanautModelCostTier(model),
+      ...capabilities,
+      ...capabilities.map((capability) => EQUANAUT_MODEL_CAPABILITIES[capability]),
+    ]
+      .filter(Boolean)
+      .join(" ")
+      .toLowerCase();
+  }
+
+  function getEquanautModelCostTier(model) {
+    const text = [
+      model?.id,
+      model?.name,
+      model?.provider,
+      model?.providerLabel,
+      model?.location,
+      model?.meta,
+      model?.details,
+    ]
+      .filter(Boolean)
+      .join(" ")
+      .toLowerCase();
+
+    if (model?.location === "local") return "$";
+    if (/(flash|fast|mini|nano|haiku|instant|cheap|low cost|gpt-oss)/i.test(text)) return "$";
+    if (/(opus|gpt-5|gpt5|grok|frontier|pro preview|3\.1 pro|4\.5)/i.test(text)) return "$$$";
+    if (/(sonnet|pro|default|gateway|claude|gemini|openai|anthropic)/i.test(text)) return "$$";
+    return "$$";
+  }
+
+  function getEquanautModelCapabilities(model) {
+    const text = [
+      model?.id,
+      model?.name,
+      model?.provider,
+      model?.providerLabel,
+      model?.location,
+      model?.route,
+      model?.meta,
+      model?.details,
+      model?.source,
+    ]
+      .filter(Boolean)
+      .join(" ")
+      .toLowerCase();
+    const caps = new Set();
+    const contextLength = Number(model?.contextLength) || 0;
+
+    if (/(flash|fast|mini|nano|haiku|instant|gpt-oss|qwen|llama|local|ollama)/.test(text)) {
+      caps.add("fast");
+    }
+    if (/(vision|visual|image|multimodal|gemini|gpt-4o|gpt-image|claude-3)/.test(text)) {
+      caps.add("vision");
+    }
+    if (
+      /(reason|thinking|opus|sonnet|pro|gpt-5|gpt5|gpt-oss|grok|deepseek|qwen|glm|claude)/.test(
+        text
+      ) ||
+      contextLength >= 64000
+    ) {
+      caps.add("reasoning");
+    }
+    if (/(tool|function|gateway|command center|equabot|comet|mcp)/.test(text)) {
+      caps.add("tools");
+    }
+    if (/(image|imagen|dall|nano banana|gemini)/.test(text)) {
+      caps.add("image");
+    }
+    if (
+      /(pdf|document|long context|claude|gemini|gpt-5|gpt5|gpt-4|opus|sonnet)/.test(text) ||
+      contextLength >= 128000
+    ) {
+      caps.add("pdf");
+    }
+
+    if (model?.route === "command-center") caps.add("tools");
+
+    return EQUANAUT_MODEL_CAPABILITY_ORDER.filter((capability) => caps.has(capability));
+  }
+
+  function getEquanautCapabilityLabel(capability) {
+    return EQUANAUT_MODEL_CAPABILITIES[capability] || String(capability || "");
+  }
+
+  function filterEquanautModels(models, opts) {
+    const options = opts || {};
+    const routingMode = options.routingMode || "auto";
+    const provider = normalizeProviderKey(options.provider || "all") || "all";
+    const capability = String(options.capability || "all")
+      .trim()
+      .toLowerCase();
+    const query = String(options.query || "")
+      .trim()
+      .toLowerCase();
+
+    return (models || []).filter((model) => {
+      if (!isEquanautModelAllowedForRouting(model, routingMode)) return false;
+      if (provider !== "all" && getEquanautProviderFilterKey(model) !== provider) return false;
+      if (
+        capability &&
+        capability !== "all" &&
+        !getEquanautModelCapabilities(model).includes(capability)
+      ) {
+        return false;
+      }
+      if (query && !getEquanautModelSearchText(model).includes(query)) return false;
+      return true;
+    });
+  }
+
+  function normalizeGatewayModelPath(provider, modelId) {
+    const id = String(modelId || "").trim();
+    if (!id) return "";
+    if (id === "default" || id.includes("/")) return id;
+    const key = normalizeProviderKey(provider);
+    return key ? `${key}/${id}` : id;
+  }
+
+  function formatEquanautContextLength(value) {
+    const n = Number(value);
+    if (!Number.isFinite(n) || n <= 0) return "";
+    if (n >= 1000000) return `${(n / 1000000).toFixed(n % 1000000 === 0 ? 0 : 1)}M ctx`;
+    if (n >= 1000) return `${Math.round(n / 1000)}k ctx`;
+    return `${n} ctx`;
+  }
+
+  function inferEquanautProviderFromId(id) {
+    const raw = String(id || "").replace(/^gateway:/, "");
+    if (raw.includes("/")) return raw.split("/")[0];
+    if (/^claude-|^sonnet-|^opus-/i.test(raw)) return "anthropic";
+    if (/^gpt-|^o[0-9]/i.test(raw)) return "openai";
+    if (/^gemini-/i.test(raw)) return "google";
+    if (/^grok-/i.test(raw)) return "xai";
+    if (/^deepseek/i.test(raw)) return raw.includes(":") ? "ollama" : "deepseek";
+    return raw.includes(":") ? "ollama" : "gateway";
+  }
+
+  function normalizeEquanautModelEntry(entry, opts) {
+    if (!entry || typeof entry !== "object") return null;
+    const options = opts || {};
+    const source = String(options.source || entry.source || "").trim() || "unknown";
+    const rawId = String(entry.id || entry.model || entry.name || "").trim();
+    if (!rawId || rawId === "ollama:offline") return null;
+
+    const rawProvider = normalizeProviderKey(entry.provider || entry.providerKey);
+    const rawType = String(entry.type || "")
+      .trim()
+      .toLowerCase();
+    const status =
+      String(entry.status || "")
+        .trim()
+        .toLowerCase() || "unknown";
+
+    let id = rawId;
+    let provider = rawProvider || inferEquanautProviderFromId(rawId);
+    let location = rawType === "local" ? "local" : "";
+    let route = "standalone";
+
+    if (id.startsWith("ollama:")) {
+      id = id.slice("ollama:".length);
+      provider = "ollama";
+      location = "local";
+    } else if (id.startsWith("gateway:")) {
+      provider = inferEquanautProviderFromId(id) || provider;
+      location = "gateway";
+      route = "command-center";
+    } else if (source === "ollama" && rawType === "cloud") {
+      provider = "ollama";
+      location = "cloud";
+    } else if (
+      source === "gateway-rpc" &&
+      provider &&
+      provider !== "ollama" &&
+      provider !== "local"
+    ) {
+      id = `gateway:${normalizeGatewayModelPath(provider, id)}`;
+      location = "gateway";
+      route = "command-center";
+    } else if (rawType === "cloud") {
+      location = "gateway";
+      route = "command-center";
+    } else if (!location) {
+      location = provider === "ollama" || id.includes(":") ? "local" : "gateway";
+      if (location === "gateway") route = "command-center";
+    }
+
+    if (location === "gateway") route = "command-center";
+    if (provider === "local") provider = "ollama";
+
+    const contextLength =
+      Number(entry.contextLength || entry.contextWindow || entry.contextTokens) || undefined;
+    const contextMeta = formatEquanautContextLength(contextLength);
+    const statusMeta = status && status !== "available" && status !== "unknown" ? status : "";
+    const detailMeta =
+      typeof entry.details === "string" && entry.details.trim() ? entry.details.trim() : "";
+    const sizeMeta =
+      typeof entry.sizeGb === "number" && entry.sizeGb > 0 ? `${entry.sizeGb}GB` : "";
+    const meta = [contextMeta, sizeMeta, detailMeta, statusMeta].filter(Boolean).join(" - ");
+
+    const normalized = {
+      id,
+      name: String(entry.name || id).trim() || id,
+      provider,
+      providerLabel: providerLabel(provider),
+      type: location === "local" ? "local" : "chat",
+      location,
+      route,
+      contextLength,
+      status,
+      enabled: entry.enabled !== false && status !== "offline",
+      isDefault: Boolean(entry.isDefault),
+      source,
+      sourceId: rawId,
+      meta,
+    };
+    normalized.providerKey = getEquanautProviderFilterKey(normalized);
+    normalized.providerGlyph = getEquanautProviderGlyph(normalized.providerKey);
+    normalized.costTier = getEquanautModelCostTier(normalized);
+    normalized.capabilities = getEquanautModelCapabilities(normalized);
+    return normalized;
+  }
+
+  function normalizeEquanautOllamaModel(entry) {
+    const id = String(entry?.name || entry?.model || "").trim();
+    if (!id) return null;
+    const isCloud = /:cloud$/.test(id) || (entry.size === 0 && !entry?.details?.family);
+    const family = entry?.details?.family || id.split(":")[0] || id;
+    const params = entry?.details?.parameter_size || "";
+    const sizeGb = entry.size ? (entry.size / 1024 ** 3).toFixed(1) + "GB" : "";
+    return normalizeEquanautModelEntry(
+      {
+        id,
+        name: id,
+        provider: isCloud ? "ollama" : family,
+        type: isCloud ? "cloud" : "local",
+        status: "available",
+        details: [params, sizeGb].filter(Boolean).join(" - ") || (isCloud ? "Ollama Cloud" : ""),
+        source: "ollama",
+      },
+      { source: "ollama" }
+    );
+  }
+
+  function modelsFromEquanautGatewayConfig(raw, opts) {
+    const config = raw && typeof raw === "object" ? raw : {};
+    const source = opts?.source || "gateway-config";
+    const models = [];
+    const primaryModel =
+      typeof config.primaryModel === "string" && config.primaryModel.trim()
+        ? config.primaryModel.trim()
+        : typeof config.primary === "string" && config.primary.trim()
+          ? config.primary.trim()
+          : "default";
+    models.push(
+      normalizeEquanautModelEntry(
+        {
+          id: primaryModel === "default" ? "gateway:default" : `gateway:${primaryModel}`,
+          name: primaryModel === "default" ? "Equabot Gateway (Default)" : primaryModel,
+          provider: inferEquanautProviderFromId(primaryModel),
+          type: "cloud",
+          status: "available",
+          source,
+          isDefault: true,
+          details: "Gateway primary model",
+        },
+        { source }
+      )
+    );
+
+    const providers = Array.isArray(config.providers)
+      ? config.providers
+      : config.providers && typeof config.providers === "object"
+        ? Object.entries(config.providers).map(([key, value]) =>
+            typeof value === "object" && value
+              ? { key, ...value }
+              : { key, models: Array.isArray(value) ? value : [] }
+          )
+        : [];
+    for (const provider of providers) {
+      const key = normalizeProviderKey(provider?.key || provider?.provider || provider?.id);
+      if (!key) continue;
+      const providerModels = Array.isArray(provider.models)
+        ? provider.models
+        : provider.models && typeof provider.models === "object"
+          ? Object.values(provider.models)
+          : [];
+      for (const model of providerModels) {
+        const modelId =
+          typeof model === "string"
+            ? model.trim()
+            : typeof model?.id === "string"
+              ? model.id.trim()
+              : "";
+        if (!modelId) continue;
+        const modelName =
+          typeof model === "object" && typeof model.name === "string" && model.name.trim()
+            ? model.name.trim()
+            : modelId;
+        models.push(
+          normalizeEquanautModelEntry(
+            {
+              id: `gateway:${normalizeGatewayModelPath(key, modelId)}`,
+              name: modelName,
+              provider: key,
+              type: "cloud",
+              status: "available",
+              source,
+              details: `Routes through Equabot Gateway via ${key}`,
+            },
+            { source }
+          )
+        );
+      }
+    }
+    return models.filter(Boolean);
+  }
+
+  function normalizeEquanautModelCatalog(raw, opts) {
+    if (!raw) return [];
+    const options = opts || {};
+    if (Array.isArray(raw)) {
+      return raw.map((entry) => normalizeEquanautModelEntry(entry, options)).filter(Boolean);
+    }
+    if (typeof raw !== "object") return [];
+    if (Array.isArray(raw.models) || Array.isArray(raw.items)) {
+      return (raw.models || raw.items)
+        .map((entry) => normalizeEquanautModelEntry(entry, options))
+        .filter(Boolean);
+    }
+    if (Array.isArray(raw.providers) || (raw.providers && typeof raw.providers === "object")) {
+      return modelsFromEquanautGatewayConfig(raw, options);
+    }
+    return [];
+  }
+
+  function sortEquanautModelCatalog(models) {
+    return [...(models || [])].sort((a, b) => {
+      const ai = EQUANAUT_PROVIDER_ORDER.indexOf(a.provider);
+      const bi = EQUANAUT_PROVIDER_ORDER.indexOf(b.provider);
+      const ar = ai === -1 ? 999 : ai;
+      const br = bi === -1 ? 999 : bi;
+      if (ar !== br) return ar - br;
+      const al = a.location === "local" ? 1 : 0;
+      const bl = b.location === "local" ? 1 : 0;
+      if (al !== bl) return al - bl;
+      return String(a.name || a.id).localeCompare(String(b.name || b.id));
+    });
+  }
+
+  function mergeEquanautModelCatalogs() {
+    const merged = new Map();
+    const lists = Array.from(arguments).flat().filter(Boolean);
+    for (const entry of lists) {
+      const normalized =
+        entry && entry.id && entry.location
+          ? entry
+          : normalizeEquanautModelEntry(entry, { source: "merge" });
+      if (!normalized) continue;
+      if (!merged.has(normalized.id)) {
+        merged.set(normalized.id, normalized);
+        continue;
+      }
+      const prior = merged.get(normalized.id);
+      merged.set(normalized.id, {
+        ...prior,
+        ...normalized,
+        meta: normalized.meta || prior.meta,
+        enabled: prior.enabled || normalized.enabled,
+        isDefault: prior.isDefault || normalized.isDefault,
+      });
+    }
+    return sortEquanautModelCatalog(Array.from(merged.values()));
+  }
+
+  function groupEquanautModelCatalog(models) {
+    const groups = [];
+    const byKey = new Map();
+    for (const model of sortEquanautModelCatalog(models || [])) {
+      const key =
+        model.location === "local"
+          ? "ollama"
+          : model.location === "cloud"
+            ? "ollama-cloud"
+            : model.provider || "gateway";
+      if (!byKey.has(key)) {
+        const group = { key, label: providerLabel(key), entries: [] };
+        byKey.set(key, group);
+        groups.push(group);
+      }
+      byKey.get(key).entries.push(model);
+    }
+    return groups;
+  }
+
+  function getEquanautCommandCenterFallbackModels() {
+    return EQUANAUT_COMMAND_CENTER_FALLBACK_MODELS.map((entry) =>
+      normalizeEquanautModelEntry(entry, { source: "command-center-fallback" })
+    ).filter(Boolean);
+  }
+
+  function getEquanautModelBadge(model) {
+    if (model?.location === "local") return { label: "Local", className: "local" };
+    if (model?.route === "command-center") return { label: "Gateway", className: "gateway" };
+    return { label: "Cloud", className: "cloud" };
+  }
+
+  function getEquanautModelDisplayName(modelOrId) {
+    const raw =
+      typeof modelOrId === "object" && modelOrId
+        ? modelOrId.name || modelOrId.id || modelOrId.sourceId
+        : modelOrId;
+    const value = String(raw || "").trim();
+    if (!value) return "Choose model";
+    if (value === "gateway:default" || /^equabot gateway \(default\)$/i.test(value)) {
+      return "Gateway Default";
+    }
+    const withoutGateway = value.replace(/^gateway:/, "");
+    const withoutProvider = withoutGateway.includes("/")
+      ? withoutGateway.split("/").slice(1).join("/")
+      : withoutGateway;
+    const compact = withoutProvider
+      .replace(/\s+\((openai|google|anthropic|xai|ollama|deepseek|perplexity)\)$/i, "")
+      .trim();
+    return compact || value;
+  }
+
+  function isEquanautModelConfigured(model) {
+    if (!model || typeof model !== "object") return false;
+    const status = String(model.status || "")
+      .trim()
+      .toLowerCase();
+    return model.enabled !== false && status === "available";
+  }
+
+  function getEquanautModelSettingsUrl(modelOrId, reason) {
+    const id =
+      typeof modelOrId === "object" && modelOrId
+        ? modelOrId.id || modelOrId.sourceId || modelOrId.name
+        : modelOrId;
+    const url = new URL("https://app.equa.cc/equabotz/settings");
+    url.searchParams.set("section", "models");
+    if (id) url.searchParams.set("model", String(id));
+    if (reason) url.searchParams.set("reason", String(reason));
+    url.searchParams.set("source", "browser-extension");
+    return url.toString();
+  }
+
+  function isEquanautCommandCenterModel(modelId) {
+    return String(modelId || "").startsWith("gateway:");
+  }
+
+  function resolveEquanautOllamaModelId(modelId) {
+    const id = String(modelId || "").trim();
+    if (!id || isEquanautCommandCenterModel(id)) return null;
+    return id.startsWith("ollama:") ? id.slice("ollama:".length) : id;
+  }
+
+  function normalizeEquanautRoutingMode(mode) {
+    const value = String(mode || "")
+      .trim()
+      .toLowerCase();
+    return value === "local" || value === "cloud-only" ? value : "auto";
+  }
+
+  function isEquanautModelAllowedForRouting(model, routingMode) {
+    const mode = normalizeEquanautRoutingMode(routingMode);
+    if (!model || model.enabled === false) return false;
+    if (mode === "local") return model.location === "local";
+    if (mode === "cloud-only") return model.route === "command-center";
+    return true;
+  }
+
+  function pickEquanautModelForRoutingMode(models, currentId, routingMode, fallbackId) {
+    const mode = normalizeEquanautRoutingMode(routingMode);
+    const list = Array.isArray(models) ? models : [];
+    const current = list.find((model) => model.id === currentId);
+    if (isEquanautModelAllowedForRouting(current, mode)) return current.id;
+
+    const preferredDefault = list.find(
+      (model) => model.isDefault && isEquanautModelAllowedForRouting(model, mode)
+    );
+    if (preferredDefault) return preferredDefault.id;
+
+    const available = list.find(
+      (model) => model.status === "available" && isEquanautModelAllowedForRouting(model, mode)
+    );
+    if (available) return available.id;
+
+    const anyAllowed = list.find((model) => isEquanautModelAllowedForRouting(model, mode));
+    if (anyAllowed) return anyAllowed.id;
+
+    const fallback = String(fallbackId || "").trim();
+    if (mode === "cloud-only")
+      return fallback.startsWith("gateway:") ? fallback : "gateway:default";
+    if (mode === "local") return fallback && !fallback.startsWith("gateway:") ? fallback : "";
+    return fallback || "gateway:default";
+  }
+
+  function timeAgo(ts, now) {
+    if (now === undefined) now = Date.now();
+    const seconds = Math.floor((now - ts) / 1000);
+    if (seconds < 60) return "just now";
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60) return `${minutes} min ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24) return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+  }
+
+  function fsFuzzyMatch(query, text) {
+    const lower = text.toLowerCase();
+    const q = query.toLowerCase();
+    if (lower.includes(q)) return true;
+    let qi = 0;
+    for (let i = 0; i < lower.length && qi < q.length; i++) {
+      if (lower[i] === q[qi]) qi++;
+    }
+    return qi === q.length;
+  }
+
+  function fsFormatEventDescription(event) {
+    const title = event.title || event.groupTitle || "";
+    switch (event.type) {
+      case "group_created":
+        return "Created group" + (title ? ': "' + title + '"' : "");
+      case "group_archived":
+        return "Archived" + (title ? ': "' + title + '"' : "");
+      case "group_restored":
+        return "Restored" + (title ? ': "' + title + '"' : "");
+      case "group_deleted":
+        return "Deleted" + (title ? ': "' + title + '"' : "");
+      case "save_and_close":
+        return (
+          "Saved & closed " +
+          (event.tabCount || "?") +
+          " tabs in " +
+          (event.groupCount || "?") +
+          " groups"
+        );
+      case "lifecycle_start":
+        return "Agent started: " + (event.agentId || "unknown");
+      case "lifecycle_complete":
+        return "Agent completed: " + (event.agentId || "unknown");
+      case "lifecycle_abort":
+        return "Agent aborted: " + (event.agentId || "unknown");
+      case "tab_deleted":
+        return "Removed tab from " + (title || "group");
+      case "bulk_action":
+        return (event.action || "Bulk action") + " on " + (event.count || "?") + " items";
+      default:
+        return event.type || "Unknown action";
+    }
+  }
+
+  function fsApplyFilters(groups, query, filterMode, hideArchived) {
+    let filtered = groups;
+
+    if (filterMode === "named") {
+      filtered = filtered.filter(
+        (g) => g.title && g.title !== "Untitled" && g.title !== "Ungrouped Tabs"
+      );
+    } else if (filterMode === "folders") {
+      filtered = filtered.filter((g) => g.folderId);
+    }
+
+    if (hideArchived) {
+      filtered = filtered.filter((g) => g.status !== "archived");
+    }
+
+    if (query) {
+      filtered = filtered.filter((g) => {
+        const tabs = g.urls || g.tabs || [];
+        return (
+          (g.title || "").toLowerCase().includes(query) ||
+          tabs.some(
+            (t) =>
+              (t.title || "").toLowerCase().includes(query) ||
+              (t.url || "").toLowerCase().includes(query)
+          )
+        );
+      });
+    }
+
+    return filtered;
+  }
+
+  // Extended filter engine for the full-screen filter bar
+  function fsApplyAdvancedFilters(groups, opts) {
+    let filtered = groups;
+
+    // Sidebar filter mode (legacy compat)
+    if (opts.filterMode === "named") {
+      filtered = filtered.filter(
+        (g) => g.title && g.title !== "Untitled" && g.title !== "Ungrouped Tabs"
+      );
+    } else if (opts.filterMode === "folders") {
+      filtered = filtered.filter((g) => g.folderId);
+    }
+
+    // Status filter
+    if (opts.status && opts.status !== "all") {
+      filtered = filtered.filter((g) => (g.status || "archived") === opts.status);
+    }
+
+    // Color filter (array of active colors)
+    if (opts.colors && opts.colors.length > 0) {
+      filtered = filtered.filter((g) => opts.colors.includes(g.color || "grey"));
+    }
+
+    // Starred only
+    if (opts.starred) {
+      filtered = filtered.filter((g) => g.starred);
+    }
+
+    // Locked only
+    if (opts.locked) {
+      filtered = filtered.filter((g) =>
+        opts.lockedSet ? opts.lockedSet.has(g.taskThreadId || g.id) : g.locked
+      );
+    }
+
+    // Stale only (>7 days old)
+    if (opts.stale) {
+      const staleThreshold = 7 * 24 * 60 * 60 * 1000;
+      const now = Date.now();
+      filtered = filtered.filter((g) => {
+        const ts = g.archivedAt || g.closedAt;
+        return ts && now - new Date(ts).getTime() > staleThreshold;
+      });
+    }
+
+    // Tab count range
+    if (opts.minTabs > 0) {
+      filtered = filtered.filter((g) => (g.urls || g.tabs || []).length >= opts.minTabs);
+    }
+    if (opts.maxTabs > 0 && opts.maxTabs < Infinity) {
+      filtered = filtered.filter((g) => (g.urls || g.tabs || []).length <= opts.maxTabs);
+    }
+
+    // Text search (title + description + tab titles + tab URLs + tab descriptions)
+    if (opts.query) {
+      const q = opts.query.toLowerCase();
+      filtered = filtered.filter((g) => {
+        const tabs = g.urls || g.tabs || [];
+        return (
+          (g.title || "").toLowerCase().includes(q) ||
+          normalizeEntityDescription(g).toLowerCase().includes(q) ||
+          tabs.some(
+            (t) =>
+              (t.title || "").toLowerCase().includes(q) ||
+              (t.url || "").toLowerCase().includes(q) ||
+              normalizeEntityDescription(t).toLowerCase().includes(q)
+          )
+        );
+      });
+    }
+
+    return filtered;
+  }
+
+  // Sort groups by various criteria
+  function fsSortGroups(groups, sortBy) {
+    const sorted = [...groups];
+    switch (sortBy) {
+      case "newest":
+        sorted.sort((a, b) => {
+          const ta = new Date(a.archivedAt || a.closedAt || 0).getTime();
+          const tb = new Date(b.archivedAt || b.closedAt || 0).getTime();
+          return tb - ta;
+        });
+        break;
+      case "oldest":
+        sorted.sort((a, b) => {
+          const ta = new Date(a.archivedAt || a.closedAt || 0).getTime();
+          const tb = new Date(b.archivedAt || b.closedAt || 0).getTime();
+          return ta - tb;
+        });
+        break;
+      case "az":
+        sorted.sort((a, b) => (a.title || "Untitled").localeCompare(b.title || "Untitled"));
+        break;
+      case "za":
+        sorted.sort((a, b) => (b.title || "Untitled").localeCompare(a.title || "Untitled"));
+        break;
+      case "most-tabs":
+        sorted.sort((a, b) => (b.urls || b.tabs || []).length - (a.urls || a.tabs || []).length);
+        break;
+      case "fewest-tabs":
+        sorted.sort((a, b) => (a.urls || a.tabs || []).length - (b.urls || b.tabs || []).length);
+        break;
+      default:
+        break;
+    }
+    return sorted;
+  }
+
+  // Group groups into sections by a property
+  function fsGroupBy(groups, groupByKey) {
+    if (!groupByKey || groupByKey === "none") {
+      return [{ key: null, label: null, groups: groups }];
+    }
+
+    const sections = new Map();
+
+    for (const group of groups) {
+      let sectionKey, sectionLabel;
+
+      switch (groupByKey) {
+        case "color": {
+          sectionKey = group.color || "grey";
+          sectionLabel = sectionKey.charAt(0).toUpperCase() + sectionKey.slice(1);
+          break;
+        }
+        case "status": {
+          sectionKey = group.status || "archived";
+          const statusLabels = { pending: "Pending", done: "Done", archived: "Archived" };
+          sectionLabel = statusLabels[sectionKey] || sectionKey;
+          break;
+        }
+        case "date": {
+          const ts = new Date(group.archivedAt || group.closedAt || 0).getTime();
+          const now = Date.now();
+          const dayMs = 24 * 60 * 60 * 1000;
+          const age = now - ts;
+          if (age < dayMs) {
+            sectionKey = "today";
+            sectionLabel = "Today";
+          } else if (age < 7 * dayMs) {
+            sectionKey = "this-week";
+            sectionLabel = "This Week";
+          } else if (age < 30 * dayMs) {
+            sectionKey = "this-month";
+            sectionLabel = "This Month";
+          } else {
+            sectionKey = "older";
+            sectionLabel = "Older";
+          }
+          break;
+        }
+        case "size": {
+          const tabCount = (group.urls || group.tabs || []).length;
+          if (tabCount === 0) {
+            sectionKey = "empty";
+            sectionLabel = "Empty";
+          } else if (tabCount <= 3) {
+            sectionKey = "small";
+            sectionLabel = "Small (1-3 tabs)";
+          } else if (tabCount <= 10) {
+            sectionKey = "medium";
+            sectionLabel = "Medium (4-10 tabs)";
+          } else {
+            sectionKey = "large";
+            sectionLabel = "Large (10+ tabs)";
+          }
+          break;
+        }
+        default:
+          sectionKey = "other";
+          sectionLabel = "Other";
+      }
+
+      if (!sections.has(sectionKey)) {
+        sections.set(sectionKey, { key: sectionKey, label: sectionLabel, groups: [] });
+      }
+      sections.get(sectionKey).groups.push(group);
+    }
+
+    return Array.from(sections.values());
+  }
+
+  function fsResolveSelectedTabs(selectedSet, cachedGroups) {
+    const result = [];
+    for (const key of selectedSet) {
+      const lastDash = key.lastIndexOf("-");
+      if (lastDash === -1) continue;
+      const groupId = key.slice(0, lastDash);
+      const idx = parseInt(key.slice(lastDash + 1));
+      const group = cachedGroups.find((g) => (g.taskThreadId || g.id) === groupId);
+      if (!group) continue;
+      const tabs = group.urls || group.tabs || [];
+      if (idx >= 0 && idx < tabs.length) {
+        result.push({ groupId, tabIdx: idx, tab: tabs[idx] });
+      }
+    }
+    return result;
+  }
+
+  function getDomainDisplayName(url, domainMap) {
+    if (domainMap === undefined) domainMap = DEFAULT_DOMAIN_DISPLAY_MAP;
+    try {
+      const hostname = new URL(url).hostname.replace(/^www\./, "");
+      return domainMap[hostname] || hostname;
+    } catch {
+      return "Other";
+    }
+  }
+
+  const DEFAULT_SAFETY_REMINDER_HOST_ALLOWLIST = Object.freeze([
+    "localhost",
+    "127.0.0.1",
+    "*.equa.test",
+    "*.up.railway.app",
+    "staging.equa.cc",
+    "*.staging.equa.cc",
+    "*.preview.equa.cc",
+    "*.dev.equa.cc",
+  ]);
+
+  const EQUANAUT_COMMAND_LIBRARY_GROUPS = Object.freeze([
+    {
+      plugin: "Comet",
+      pluginId: "comet",
+      source: "skill",
+      category: "browser_control",
+      rootPath: "/Users/shawnowen/.agents/skills",
+      order: 10,
+      requiredTools: ["comet_connect"],
+      keywords: ["browser", "comet", "agent", "sidecar"],
+      template:
+        "Use this Comet browser skill only after comet_connect establishes the owned tab group and top-display window proof.",
+      commands: [
+        {
+          id: "comet-agent",
+          title: "Comet agent",
+          description:
+            "Load the comet-agent browser orchestration skill and route browser work through Comet-Bridge.",
+          requiredTools: ["comet_connect", "comet_ask", "comet_screenshot", "comet_read_page"],
+          aliases: ["browser-agent", "comet-browser-agent"],
+          keywords: ["browser", "orchestrator", "agent", "sidecar", "skills"],
+          template:
+            "Use the comet-agent skill. Start with comet_connect, verify top-display windowed full-display placement, then use the owned tab group only.",
+        },
+        "comet-assistant",
+        "comet-auto",
+        "comet-browse",
+        { id: "comet-connect", title: "comet_connect", aliases: ["connect", "browser-connect"] },
+        "comet-delegate",
+        {
+          id: "comet-ask",
+          skillName: "comet-agent",
+          title: "comet_ask",
+          requiredTools: ["comet_connect", "comet_ask"],
+          aliases: ["ask", "browser-ask"],
+        },
+        "comet-interact",
+        "comet-keepalive",
+        "comet-labs",
+        "comet-monitor",
+        "comet-network",
+        "comet-pdf",
+        "comet-read",
+        {
+          id: "comet-read-page",
+          skillName: "comet-read",
+          title: "comet_read_page",
+          requiredTools: ["comet_connect", "comet_read_page"],
+          aliases: ["read-page", "browser-read"],
+        },
+        "comet-research",
+        "comet-scrape",
+        {
+          id: "comet-screenshot",
+          title: "comet_screenshot",
+          requiredTools: ["comet_connect", "comet_screenshot"],
+          aliases: ["screenshot", "browser-screenshot"],
+        },
+        "comet-search",
+        "comet-session",
+        "comet-shortcuts",
+        "comet-skill-inventory",
+        "comet-workspace",
+      ],
+    },
+    {
+      plugin: "Spequa",
+      pluginId: "spequa",
+      source: "plugin",
+      category: "spequa",
+      rootPath: "/Users/shawnowen/.codex/plugins/cache/equa-local/spequa/0.9.2/skills",
+      prefix: "spequa:",
+      order: 200,
+      keywords: ["spequa", "sdd", "spec", "pipeline"],
+      template:
+        "Route to the Spequa command skill and follow its source prompt under /Users/shawnowen/dev/equa/tools/spequa/.codex/prompts/.",
+      commands: [
+        { id: "spequa", fullId: "spequa", aliases: ["spequa:spequa"] },
+        "0-pipeline",
+        "1-constitution",
+        "2-problems",
+        "3-spequafy",
+        "3.0-diagnose",
+        "3.1-analyze-domain",
+        "4-clarify",
+        "4.1-expert-decision",
+        "5-plan",
+        "5.1-research",
+        "6-tasks",
+        "6.1-taskstoissues",
+        "7-checklist",
+        "8-analyze",
+        "9-test",
+        "10-implement",
+        "11-docs",
+        "12-score-docs",
+        "13-code-review",
+        "14-create-pull-request",
+        "14.1-pr-checks",
+        "15-comet-review",
+        "15.1-comet-pr-review",
+        "16-close",
+      ],
+    },
+    {
+      plugin: "Equa Web Test Skills",
+      pluginId: "equa-web-test-skills",
+      source: "skill",
+      category: "qa",
+      rootPath: "/Users/shawnowen/.agents/skills",
+      order: 500,
+      keywords: ["equa", "qa", "test", "smoke", "browser"],
+      template:
+        "Route to the requested Equa QA skill and preserve the repo-specific browser validation contract.",
+      commands: [
+        "auth-flow-qa",
+        "dataroom-document-checklist",
+        "e2e-auth",
+        "e2e-captable",
+        "e2e-full",
+        "e2e-org",
+        "e2e-smoke",
+        "equa-orchestrator-qa",
+        "equa-start-dev",
+        "equa-web-test-skills",
+        "mattermost-messaging-qa",
+        "pr-review-browser-qa",
+      ],
+    },
+    {
+      plugin: "Knowledge Base",
+      pluginId: "knowledge-base",
+      source: "skill",
+      category: "knowledge",
+      rootPath: "/Users/shawnowen/.agents/skills",
+      order: 650,
+      keywords: ["kb", "knowledge", "entity", "search"],
+      template:
+        "Route to the Knowledge Base skill and use the user's arguments as the lookup query.",
+      commands: [
+        "kb-ask",
+        "kb-entity",
+        "kb-index",
+        "kb-search",
+        "task-threads",
+        "task-blocker-analysis",
+      ],
+    },
+    {
+      plugin: "Local Agents",
+      pluginId: "local-agents",
+      source: "skill",
+      category: "local_agent",
+      rootPath: "/Users/shawnowen/.agents/skills",
+      order: 760,
+      keywords: ["local", "agent", "handoff", "llm"],
+      template:
+        "Route to the requested local agent skill and keep the invocation as structured sidecar context.",
+      commands: [
+        "cursor-agent-handoff",
+        "email-thread-research",
+        "gitguardian-remediate",
+        "linear-tasks",
+        "local-analysis",
+        "local-code",
+        "local-creative",
+        "local-llm",
+        "mattermost-infra-deploy",
+        "source-command-handoff-cursor-agent",
+        "switch-model",
+      ],
+    },
+    {
+      plugin: "QuickBooks Ops",
+      pluginId: "qbo",
+      source: "skill",
+      category: "finance",
+      rootPath: "/Users/shawnowen/.agents/skills",
+      order: 850,
+      keywords: ["qbo", "quickbooks", "accounting", "finance"],
+      template: "Route to the requested QBO skill and preserve accounting workflow context.",
+      commands: [
+        "qbo-accounting",
+        "qbo-ar-review",
+        "qbo-bank-fetch",
+        "qbo-bill-email",
+        "qbo-bill-open",
+        "qbo-journal-entry",
+        "qbo-month-close",
+        "qbo-pay-bill",
+        "qbo-reconcile",
+        "qbo-report",
+        "qbo-tax-prep",
+        "qbo-vendor-reconcile",
+      ],
+    },
+    {
+      plugin: "Prescription Refill SOP",
+      pluginId: "prescription-refill",
+      source: "skill",
+      category: "personal_ops",
+      rootPath: "/Users/shawnowen/.agents/skills/prescription-refill-skills",
+      order: 970,
+      keywords: ["prescription", "refill", "mychart", "costco"],
+      template:
+        "Route to the requested prescription refill SOP skill and preserve health workflow context.",
+      commands: [
+        "costco-pharmacy-phone-call",
+        "log-refill-event-to-workbook",
+        "monitor-shortwave-refill-emails",
+        "prescription-refill-sop-orchestrator",
+        "submit-mychart-refill-request",
+        "update-refill-tracker-doc",
+        "verify-mychart-refill-approval",
+      ],
+    },
+    {
+      plugin: "SVF Operations",
+      pluginId: "svf",
+      source: "skill",
+      category: "property_ops",
+      rootPath: "/Users/shawnowen/.codex/skills",
+      order: 1080,
+      keywords: ["svf", "property", "documents", "sales"],
+      template: "Route to the requested Sugarloaf Valley Farms skill.",
+      commands: [
+        "svf-chain-of-title",
+        "svf-document-intake",
+        "svf-north-lots-sales-ops",
+        "svf-property-manager",
+        "svf-task-thread-orchestrator",
+      ],
+    },
+    {
+      plugin: "Codex Local Skills",
+      pluginId: "codex-local",
+      source: "skill",
+      category: "codex",
+      rootPath: "/Users/shawnowen/.codex/skills",
+      order: 1160,
+      keywords: ["codex", "local", "screen", "migration"],
+      template: "Route to the requested local Codex skill.",
+      commands: ["chronicle", "migrate-to-codex"],
+    },
+    {
+      plugin: "Browser Use",
+      pluginId: "browser-use",
+      source: "plugin",
+      category: "browser",
+      rootPath:
+        "/Users/shawnowen/.codex/plugins/cache/openai-bundled/browser-use/0.1.0-alpha2/skills",
+      prefix: "browser-use:",
+      order: 1240,
+      keywords: ["browser", "in-app", "openai"],
+      template:
+        "Route to the Browser Use plugin skill when the in-app browser is explicitly requested.",
+      commands: ["browser"],
+    },
+    {
+      plugin: "Computer Use",
+      pluginId: "computer-use",
+      source: "plugin",
+      category: "desktop",
+      rootPath: "/Users/shawnowen/.codex/plugins/cache/openai-bundled/computer-use/1.0.780/skills",
+      prefix: "computer-use:",
+      order: 1260,
+      keywords: ["computer", "desktop", "macos"],
+      template: "Route to the Computer Use plugin skill for desktop-level evidence or UI control.",
+      commands: ["computer-use"],
+    },
+    {
+      plugin: "Figma",
+      pluginId: "figma",
+      source: "plugin",
+      category: "design",
+      rootPath: "/Users/shawnowen/.codex/plugins/cache/openai-curated/figma/63976030/skills",
+      prefix: "figma:",
+      order: 1300,
+      keywords: ["figma", "design", "figjam"],
+      template: "Route to the requested Figma skill and follow its prerequisite instructions.",
+      commands: [
+        { id: "figma-code-connect", skillName: "figma-code-connect-components" },
+        "figma-create-design-system-rules",
+        "figma-create-new-file",
+        "figma-generate-design",
+        "figma-generate-library",
+        "figma-implement-design",
+        "figma-use",
+      ],
+    },
+    {
+      plugin: "GitHub",
+      pluginId: "github",
+      source: "plugin",
+      category: "devops",
+      rootPath: "/Users/shawnowen/.codex/plugins/cache/openai-curated/github/63976030/skills",
+      prefix: "github:",
+      order: 1410,
+      keywords: ["github", "pr", "issue", "ci"],
+      template: "Route to the requested GitHub skill and preserve repository context.",
+      commands: ["github", "gh-address-comments", "gh-fix-ci", "yeet"],
+    },
+    {
+      plugin: "Gmail",
+      pluginId: "gmail",
+      source: "plugin",
+      category: "workspace",
+      rootPath: "/Users/shawnowen/.codex/plugins/cache/openai-curated/gmail/63976030/skills",
+      prefix: "gmail:",
+      order: 1480,
+      keywords: ["gmail", "email", "inbox"],
+      template: "Route to the requested Gmail skill with the user's mailbox context.",
+      commands: ["gmail", "gmail-inbox-triage"],
+    },
+    {
+      plugin: "Google Calendar",
+      pluginId: "google-calendar",
+      source: "plugin",
+      category: "workspace",
+      rootPath:
+        "/Users/shawnowen/.codex/plugins/cache/openai-curated/google-calendar/63976030/skills",
+      prefix: "google-calendar:",
+      order: 1520,
+      keywords: ["google", "calendar", "schedule"],
+      template: "Route to the requested Google Calendar skill.",
+      commands: [
+        "google-calendar",
+        "google-calendar-daily-brief",
+        "google-calendar-free-up-time",
+        "google-calendar-group-scheduler",
+        "google-calendar-meeting-prep",
+      ],
+    },
+    {
+      plugin: "Google Drive",
+      pluginId: "google-drive",
+      source: "plugin",
+      category: "workspace",
+      rootPath: "/Users/shawnowen/.codex/plugins/cache/openai-curated/google-drive/63976030/skills",
+      prefix: "google-drive:",
+      order: 1580,
+      keywords: ["google", "drive", "docs", "sheets", "slides"],
+      template: "Route to the requested Google Drive skill.",
+      commands: [
+        "google-drive",
+        "google-docs",
+        "google-drive-comments",
+        "google-sheets",
+        "google-slides",
+      ],
+    },
+    {
+      plugin: "Linear",
+      pluginId: "linear",
+      source: "plugin",
+      category: "planning",
+      rootPath: "/Users/shawnowen/.codex/plugins/cache/openai-curated/linear/63976030/skills",
+      prefix: "linear:",
+      order: 1640,
+      keywords: ["linear", "issues", "projects"],
+      template: "Route to the Linear skill with issue or project context.",
+      commands: ["linear"],
+    },
+    {
+      plugin: "OpenAI Developers",
+      pluginId: "openai-developers",
+      source: "plugin",
+      category: "developer",
+      rootPath:
+        "/Users/shawnowen/.codex/plugins/cache/openai-curated/openai-developers/63976030/skills",
+      prefix: "openai-developers:",
+      order: 1690,
+      keywords: ["openai", "api", "agents", "chatgpt"],
+      template: "Route to the requested OpenAI Developers skill.",
+      commands: [
+        "agents-sdk",
+        "build-chatgpt-app",
+        "chatgpt-app-submission",
+        "openai-api-troubleshooting",
+        "openai-platform-api-key",
+      ],
+    },
+    {
+      plugin: "Documents",
+      pluginId: "documents",
+      source: "plugin",
+      category: "document",
+      rootPath:
+        "/Users/shawnowen/.codex/plugins/cache/openai-primary-runtime/documents/26.506.11943/skills",
+      prefix: "documents:",
+      order: 1760,
+      keywords: ["documents", "docx"],
+      template: "Route to the Documents runtime skill.",
+      commands: ["documents"],
+    },
+    {
+      plugin: "Presentations",
+      pluginId: "presentations",
+      source: "plugin",
+      category: "document",
+      rootPath:
+        "/Users/shawnowen/.codex/plugins/cache/openai-primary-runtime/presentations/26.506.11943/skills",
+      prefix: "presentations:",
+      order: 1780,
+      keywords: ["presentations", "slides", "pptx"],
+      template: "Route to the Presentations runtime skill.",
+      commands: ["presentations"],
+    },
+    {
+      plugin: "Spreadsheets",
+      pluginId: "spreadsheets",
+      source: "plugin",
+      category: "document",
+      rootPath:
+        "/Users/shawnowen/.codex/plugins/cache/openai-primary-runtime/spreadsheets/26.506.11943/skills",
+      prefix: "spreadsheets:",
+      order: 1800,
+      keywords: ["spreadsheets", "sheets", "xlsx"],
+      template: "Route to the Spreadsheets runtime skill.",
+      commands: ["spreadsheets"],
+    },
+    {
+      plugin: "Superpowers",
+      pluginId: "superpowers",
+      source: "plugin",
+      category: "workflow",
+      rootPath:
+        "/Users/shawnowen/.codex/plugins/cache/claude-plugins-official/superpowers/5.1.0/skills",
+      prefix: "superpowers:",
+      order: 1850,
+      keywords: ["superpowers", "workflow", "planning", "tdd"],
+      template: "Route to the requested Superpowers workflow skill.",
+      commands: [
+        "brainstorming",
+        "dispatching-parallel-agents",
+        "executing-plans",
+        "finishing-a-development-branch",
+        "receiving-code-review",
+        "requesting-code-review",
+        "subagent-driven-development",
+        "systematic-debugging",
+        "test-driven-development",
+        "using-git-worktrees",
+        "using-superpowers",
+        "verification-before-completion",
+        "writing-plans",
+        "writing-skills",
+      ],
+    },
+    {
+      plugin: "Security",
+      pluginId: "codex-security",
+      source: "plugin",
+      category: "security",
+      rootPath:
+        "/Users/shawnowen/.codex/plugins/cache/openai-curated/codex-security/63976030/skills",
+      prefix: "codex-security:",
+      order: 2020,
+      keywords: ["security", "threat", "scan"],
+      template: "Route to the requested Codex Security skill.",
+      commands: [
+        "attack-path-analysis",
+        "finding-discovery",
+        "fix-finding",
+        "security-scan",
+        "threat-model",
+        "validation",
+      ],
+    },
+    {
+      plugin: "CodeRabbit",
+      pluginId: "coderabbit",
+      source: "plugin",
+      category: "code_review",
+      rootPath: "/Users/shawnowen/.codex/plugins/cache/openai-curated/coderabbit/63976030/skills",
+      prefix: "coderabbit:",
+      order: 2120,
+      keywords: ["coderabbit", "review"],
+      template: "Route to the CodeRabbit review skill.",
+      commands: ["coderabbit-review"],
+    },
+    {
+      plugin: "Frontend Design",
+      pluginId: "frontend-design",
+      source: "plugin",
+      category: "design",
+      rootPath:
+        "/Users/shawnowen/.codex/plugins/cache/claude-plugins-official/frontend-design/local/skills",
+      prefix: "frontend-design:",
+      order: 2180,
+      keywords: ["frontend", "design", "ui"],
+      template: "Route to the Frontend Design skill.",
+      commands: ["frontend-design"],
+    },
+    {
+      plugin: "Hookify",
+      pluginId: "hookify",
+      source: "plugin",
+      category: "writing",
+      rootPath:
+        "/Users/shawnowen/.codex/plugins/cache/claude-plugins-official/hookify/local/skills",
+      prefix: "hookify:",
+      order: 2220,
+      keywords: ["hookify", "writing", "rules"],
+      template: "Route to the Hookify writing-rules skill.",
+      commands: [{ id: "writing-hookify-rules", skillName: "writing-rules" }],
+    },
+    {
+      plugin: "Skill Creator",
+      pluginId: "skill-creator",
+      source: "plugin",
+      category: "developer",
+      rootPath:
+        "/Users/shawnowen/.codex/plugins/cache/claude-plugins-official/skill-creator/local/skills",
+      prefix: "skill-creator:",
+      order: 2260,
+      keywords: ["skill", "creator"],
+      template: "Route to the Skill Creator skill.",
+      commands: ["skill-creator"],
+    },
+  ]);
+
+  const EQUANAUT_PLUGIN_LIBRARY_GROUPS = Object.freeze([
+    ["comet", "Comet Browser Skills", "local", "browser_control"],
+    ["spequa", "Spequa", "plugin", "spequa"],
+    ["equa-web-test-skills", "Equa Web Test Skills", "local", "qa"],
+    ["knowledge-base", "Knowledge Base", "local", "knowledge"],
+    ["local-agents", "Local Agents", "local", "local_agent"],
+    ["qbo", "QuickBooks Ops", "local", "finance"],
+    ["prescription-refill", "Prescription Refill SOP", "local", "personal_ops"],
+    ["svf", "SVF Operations", "local", "property_ops"],
+    ["codex-local", "Codex Local Skills", "local", "codex"],
+    ["browser-use", "Browser Use", "plugin", "browser"],
+    ["computer-use", "Computer Use", "plugin", "desktop"],
+    ["figma", "Figma", "plugin", "design"],
+    ["github", "GitHub", "plugin", "devops"],
+    ["gmail", "Gmail", "plugin", "workspace"],
+    ["google-calendar", "Google Calendar", "plugin", "workspace"],
+    ["google-drive", "Google Drive", "plugin", "workspace"],
+    ["linear", "Linear", "plugin", "planning"],
+    ["openai-developers", "OpenAI Developers", "plugin", "developer"],
+    ["documents", "Documents", "plugin", "document"],
+    ["presentations", "Presentations", "plugin", "document"],
+    ["spreadsheets", "Spreadsheets", "plugin", "document"],
+    ["superpowers", "Superpowers", "plugin", "workflow"],
+    ["codex-security", "Codex Security", "plugin", "security"],
+    ["coderabbit", "CodeRabbit", "plugin", "code_review"],
+    ["frontend-design", "Frontend Design", "plugin", "design"],
+    ["hookify", "Hookify", "plugin", "writing"],
+    ["skill-creator", "Skill Creator", "plugin", "developer"],
+  ]);
+
+  function humanizeSlashCommandTitle(value) {
+    const tail = String(value || "")
+      .split(":")
+      .pop()
+      .replace(/^spequa$/, "spequa")
+      .replace(/[._-]+/g, " ")
+      .trim();
+    return tail ? tail.replace(/\b\w/g, (letter) => letter.toUpperCase()) : "Command";
+  }
+
+  function slashSkillPath(rootPath, skillName) {
+    if (!rootPath || !skillName) return null;
+    return `${rootPath}/${skillName}/SKILL.md`;
+  }
+
+  function expandCommandLibraryGroup(group, groupIndex) {
+    const commands = Array.isArray(group.commands) ? group.commands : [];
+    const prefix = group.prefix || "";
+    return commands.map((entry, index) => {
+      const item = typeof entry === "string" ? { id: entry } : entry || {};
+      const skillName = item.skillName || item.skill || item.id;
+      const id = item.fullId || `${prefix}${item.id}`;
+      const requiredTools = normalizeSlashCommandArray(item.requiredTools || group.requiredTools);
+      const keywords = [
+        ...normalizeSlashCommandArray(group.keywords),
+        ...normalizeSlashCommandArray(item.keywords),
+      ];
+      return {
+        id,
+        order: Number(group.order || groupIndex * 1000) + index,
+        title: item.title || humanizeSlashCommandTitle(id),
+        description:
+          item.description ||
+          `Load ${id} from the ${group.plugin} ${group.source === "plugin" ? "plugin" : "skill library"}.`,
+        source: item.source || group.source || "skill",
+        plugin: group.plugin,
+        pluginId: group.pluginId,
+        category: item.category || group.category || "general",
+        skillName,
+        skillPath:
+          item.skillPath || slashSkillPath(group.rootPath, item.skillPathSegment || skillName),
+        requiredTools,
+        aliases: normalizeSlashCommandArray(item.aliases),
+        keywords,
+        template:
+          item.template ||
+          group.template ||
+          `Route to ${id} and include the user's arguments as structured command context.`,
+      };
+    });
+  }
+
+  function buildDefaultEquanautSlashCommands() {
+    return EQUANAUT_COMMAND_LIBRARY_GROUPS.flatMap(expandCommandLibraryGroup);
+  }
+
+  function pluginCommandCount(pluginId) {
+    return buildDefaultEquanautSlashCommands().filter((command) => command.pluginId === pluginId)
+      .length;
+  }
+
+  const DEFAULT_EQUANAUT_SLASH_COMMANDS = Object.freeze(buildDefaultEquanautSlashCommands());
+  const DEFAULT_EQUANAUT_PLUGIN_LIBRARY = Object.freeze(
+    EQUANAUT_PLUGIN_LIBRARY_GROUPS.map(([id, name, source, category], index) => ({
+      id,
+      name,
+      title: name,
+      source,
+      sourceFamily: "plugin",
+      category,
+      status: "installed",
+      installed: true,
+      commandCount: pluginCommandCount(id),
+      readOnly: true,
+      allowedOperations: ["inspect", "search", "invoke_slash_command"],
+      order: (index + 1) * 10,
+    }))
+  );
+
+  function normalizeHostname(url) {
+    try {
+      return new URL(url).hostname.replace(/^www\./, "").toLowerCase();
+    } catch {
+      return "";
+    }
+  }
+
+  function hostMatchesPattern(hostname, pattern) {
+    const normalizedPattern = String(pattern || "")
+      .trim()
+      .replace(/^www\./, "")
+      .toLowerCase();
+    if (!hostname || !normalizedPattern) return false;
+    if (normalizedPattern.startsWith("*.")) {
+      const suffix = normalizedPattern.slice(2);
+      return hostname === suffix || hostname.endsWith(`.${suffix}`);
+    }
+    return hostname === normalizedPattern;
+  }
+
+  function isSafetyReminderAllowlisted(url, allowlist) {
+    const hostname = normalizeHostname(url);
+    const patterns = Array.isArray(allowlist) ? allowlist : DEFAULT_SAFETY_REMINDER_HOST_ALLOWLIST;
+    return patterns.some((pattern) => hostMatchesPattern(hostname, pattern));
+  }
+
+  function shouldInjectSafetyReminder(url, allowlist) {
+    return !isSafetyReminderAllowlisted(url, allowlist);
+  }
+
+  function normalizeSlashCommandId(value) {
+    return String(value || "")
+      .trim()
+      .replace(/^\/+/, "")
+      .toLowerCase();
+  }
+
+  function normalizeSlashCommandArray(value) {
+    return Array.isArray(value)
+      ? value.map((item) => String(item || "").trim()).filter(Boolean)
+      : [];
+  }
+
+  function normalizeEquanautSlashCommand(record, index) {
+    const input = record || {};
+    const id = normalizeSlashCommandId(
+      input.id || input.name || input.title || `command-${index + 1}`
+    );
+    const title = String(input.title || input.name || `/${id}`).replace(/^\/+/, "");
+    const requiredTools = normalizeSlashCommandArray(input.requiredTools || input.tools);
+    const aliases = normalizeSlashCommandArray(input.aliases);
+    const keywords = normalizeSlashCommandArray(input.keywords);
+    return {
+      id,
+      name: `/${id}`,
+      order: Number.isFinite(Number(input.order)) ? Number(input.order) : index + 1,
+      title,
+      description: String(input.description || "").trim(),
+      sourceFamily: "slash_command",
+      source: input.source || "skill",
+      plugin: input.plugin || "Comet",
+      category: input.category || "general",
+      skillName: input.skillName || input.skill || null,
+      skillPath: input.skillPath || null,
+      requiredTools,
+      aliases,
+      keywords,
+      template: String(input.template || "").trim(),
+      status: input.installed === false ? "unavailable" : "installed",
+      installed: input.installed !== false,
+      readOnly: true,
+      allowedOperations: ["inspect", "search", "invoke_slash_command"],
+    };
+  }
+
+  function normalizeEquanautPlugin(record, index) {
+    const input = record || {};
+    const id = normalizeSlashCommandId(
+      input.id || input.name || input.title || `plugin-${index + 1}`
+    );
+    return {
+      id,
+      name: String(input.name || input.title || id).trim() || id,
+      title: String(input.title || input.name || id).trim() || id,
+      sourceFamily: "plugin",
+      source: input.source || "plugin",
+      category: input.category || "general",
+      status: input.installed === false ? "unavailable" : input.status || "installed",
+      installed: input.installed !== false,
+      commandCount: Number.isFinite(Number(input.commandCount)) ? Number(input.commandCount) : 0,
+      version: input.version || null,
+      rootPath: input.rootPath || null,
+      readOnly: true,
+      allowedOperations: ["inspect", "search", "invoke_slash_command"],
+      order: Number.isFinite(Number(input.order)) ? Number(input.order) : index + 1,
+    };
+  }
+
+  function buildEquanautSlashCommandCatalog(input) {
+    const records = Array.isArray(input)
+      ? input
+      : Array.isArray(input?.commands)
+        ? input.commands
+        : DEFAULT_EQUANAUT_SLASH_COMMANDS;
+    return records
+      .map((record, index) => normalizeEquanautSlashCommand(record, index))
+      .filter((record) => record.id)
+      .sort((a, b) => a.order - b.order || a.id.localeCompare(b.id));
+  }
+
+  function buildEquanautPluginCatalog(input) {
+    const records = Array.isArray(input)
+      ? input
+      : Array.isArray(input?.plugins)
+        ? input.plugins
+        : DEFAULT_EQUANAUT_PLUGIN_LIBRARY;
+    return records
+      .map((record, index) => normalizeEquanautPlugin(record, index))
+      .filter((record) => record.id)
+      .sort((a, b) => a.order - b.order || a.id.localeCompare(b.id));
+  }
+
+  function filterEquanautPlugins(catalog, query) {
+    const plugins = buildEquanautPluginCatalog(catalog);
+    const normalizedQuery = normalizeSlashCommandId(query);
+    if (!normalizedQuery) return plugins;
+    return plugins.filter((plugin) => {
+      const haystack = [
+        plugin.id,
+        plugin.name,
+        plugin.title,
+        plugin.source,
+        plugin.category,
+        plugin.status,
+        plugin.rootPath,
+      ]
+        .filter(Boolean)
+        .join(" ")
+        .toLowerCase();
+      return haystack.includes(normalizedQuery);
+    });
+  }
+
+  function filterEquanautSlashCommands(catalog, query) {
+    const commands = buildEquanautSlashCommandCatalog(catalog);
+    const normalizedQuery = normalizeSlashCommandId(query);
+    if (!normalizedQuery) return commands;
+    return commands.filter((command) => {
+      const haystack = [
+        command.id,
+        command.name,
+        command.title,
+        command.description,
+        command.source,
+        command.plugin,
+        command.category,
+        command.skillName,
+        command.skillPath,
+        ...command.requiredTools,
+        ...command.aliases,
+        ...command.keywords,
+      ]
+        .filter(Boolean)
+        .join(" ")
+        .toLowerCase();
+      return haystack.includes(normalizedQuery);
+    });
+  }
+
+  function parseEquanautSlashCommandInvocation(text) {
+    const raw = String(text || "").trim();
+    const match = raw.match(/^\/([A-Za-z0-9][A-Za-z0-9:_-]*)(?:\s+([\s\S]*))?$/);
+    if (!match) return null;
+    const commandId = normalizeSlashCommandId(match[1]);
+    return {
+      raw,
+      commandId,
+      commandText: `/${commandId}`,
+      args: String(match[2] || "").trim(),
+      hasArgs: Boolean(match[2] && String(match[2]).trim()),
+    };
+  }
+
+  function resolveEquanautSlashCommand(invocation, catalog) {
+    const commandId = normalizeSlashCommandId(
+      typeof invocation === "string" ? invocation : invocation?.commandId
+    );
+    if (!commandId) return null;
+    const commands = buildEquanautSlashCommandCatalog(catalog);
+    return (
+      commands.find((command) => {
+        if (command.id === commandId) return true;
+        if (normalizeSlashCommandId(command.title) === commandId) return true;
+        return command.aliases.some((alias) => normalizeSlashCommandId(alias) === commandId);
+      }) || null
+    );
+  }
+
+  function normalizeBindingWindowSnapshot(snapshot) {
+    const windows = Array.isArray(snapshot?.windows) ? snapshot.windows : [];
+    const map = new Map();
+    for (const windowInfo of windows) {
+      if (windowInfo?.windowId === undefined || windowInfo?.windowId === null) continue;
+      map.set(String(windowInfo.windowId), {
+        windowId: Number(windowInfo.windowId),
+        binding: windowInfo.binding || null,
+        bindingStatus: windowInfo.bindingStatus || windowInfo.binding?.status || "unbound",
+      });
+    }
+    return map;
+  }
+
+  function formatBindingStatusLabel(windowInfo) {
+    const status = String(windowInfo?.bindingStatus || windowInfo?.binding?.status || "unbound");
+    const labels = {
+      active: "Bound",
+      completed: "Complete",
+      stale: "Stale",
+      reaped: "Reaped",
+      conflict: "Conflict",
+      unbound: "Unbound",
+    };
+    return labels[status] || status;
+  }
+
+  function getBindingStatusClass(windowInfo) {
+    const status = String(windowInfo?.bindingStatus || windowInfo?.binding?.status || "unbound")
+      .toLowerCase()
+      .replace(/[^a-z0-9_-]/g, "");
+    return `binding-status-${status || "unbound"}`;
+  }
+
+  function escapeHtml(str) {
+    return String(str)
+      .replace(/&/g, "&amp;")
+      .replace(/</g, "&lt;")
+      .replace(/>/g, "&gt;")
+      .replace(/"/g, "&quot;")
+      .replace(/'/g, "&#039;");
+  }
+
+  function groupAndSortForDeletion(selectedTabs) {
+    const byGroup = new Map();
+    for (const s of selectedTabs) {
+      if (!byGroup.has(s.groupId)) byGroup.set(s.groupId, []);
+      byGroup.get(s.groupId).push(s.tabIdx);
+    }
+    for (const [, indices] of byGroup) {
+      indices.sort((a, b) => b - a);
+    }
+    return byGroup;
+  }
+
+  const SUPPORTED_ROUTER_INTENTS = Object.freeze([
+    "inspect",
+    "search",
+    "open",
+    "restore",
+    "archive",
+    "rename",
+    "mark_pending",
+    "mark_done",
+    "dispatch_to_fleet",
+    "get_fleet_status",
+    "open_orchestrator_url",
+    "invoke_slash_command",
+  ]);
+
+  const READ_ONLY_ROUTER_INTENTS = new Set(["inspect", "search", "get_fleet_status"]);
+
+  function isCapabilityUsable(capability) {
+    return !!(
+      capability &&
+      capability.reachable === true &&
+      capability.fresh !== false &&
+      capability.connected !== false &&
+      capability.usable !== false
+    );
+  }
+
+  function selectEquanautRouterRoute(capabilities) {
+    const caps = capabilities || {};
+    if (isCapabilityUsable(caps.equaGateway)) {
+      return { route: "gateway", degraded: false };
+    }
+    if (isCapabilityUsable(caps.equaApi)) {
+      return {
+        route: "equa_api_enriched",
+        degraded: true,
+        degradedReason: "gateway unavailable; using Equa API context enrichment",
+      };
+    }
+    if (isCapabilityUsable(caps.cometBridgeAsk)) {
+      return {
+        route: "comet_bridge",
+        degraded: true,
+        degradedReason: "gateway and Equa API unavailable; using Comet bridge",
+      };
+    }
+    if (isCapabilityUsable(caps.localModel)) {
+      return {
+        route: "local_model",
+        degraded: true,
+        degradedReason: "gateway, Equa API, and Comet bridge unavailable; using local model",
+      };
+    }
+    return {
+      route: "unavailable",
+      degraded: true,
+      degradedReason: "no router backend is reachable",
+    };
+  }
+
+  function stringOrNull(value) {
+    if (value === undefined || value === null || value === "") return null;
+    return String(value);
+  }
+
+  function hasOwn(record, key) {
+    return !!record && Object.prototype.hasOwnProperty.call(record, key);
+  }
+
+  function normalizeEntityDescription(record) {
+    if (!record || typeof record !== "object") return "";
+    if (hasOwn(record, "description")) return String(record.description ?? "");
+    if (hasOwn(record, "note")) return String(record.note ?? "");
+    if (hasOwn(record, "notes")) {
+      const notes = record.notes;
+      if (Array.isArray(notes)) return notes.map((note) => String(note ?? "")).join("\n");
+      return String(notes ?? "");
+    }
+    return "";
+  }
+
+  function normalizeCatalogTabs(record) {
+    const tabs = Array.isArray(record?.tabs)
+      ? record.tabs
+      : Array.isArray(record?.urls)
+        ? record.urls
+        : [];
+    return tabs.map((tab, index) => {
+      const description = normalizeEntityDescription(tab);
+      return {
+        id: stringOrNull(
+          tab.id || tab.tabId || `${record.taskThreadId || record.id || "tab"}-${index + 1}`
+        ),
+        title: String(tab.title || tab.url || "Untitled"),
+        url: stringOrNull(tab.url),
+        active: !!tab.active,
+        description,
+        inheritedDescription: description
+          ? ""
+          : String(tab.inheritedDescription || record?.description || ""),
+      };
+    });
+  }
+
+  function catalogTitle(record) {
+    return (
+      record.title ||
+      record.sessionName ||
+      record.taskGoal ||
+      record.displayName ||
+      record.name ||
+      record.label ||
+      record.url ||
+      "Untitled"
+    );
+  }
+
+  function catalogStatus(record, fallback) {
+    return record.status || record.taskStatus || record.state || fallback || "unknown";
+  }
+
+  function normalizeCatalogRecord(record, sourceFamily, index) {
+    const source = sourceFamily || "unknown";
+    const nativeId =
+      record.taskThreadId ||
+      record.sessionKey ||
+      record.id ||
+      record.sessionId ||
+      record.tabGroupId ||
+      record.groupId ||
+      record.windowId ||
+      `${source}-${index + 1}`;
+    return {
+      id: String(nativeId),
+      sourceFamily: source,
+      title: String(catalogTitle(record)).trim() || "Untitled",
+      description: normalizeEntityDescription(record),
+      agentInstructions: String(
+        record.agentInstructions || record.equanautInstructions || ""
+      ).trim(),
+      status: catalogStatus(record, source === "archived" ? "archived" : null),
+      windowId: stringOrNull(record.windowId),
+      taskThreadId: stringOrNull(record.taskThreadId || record.threadId),
+      agentId: stringOrNull(record.agentId),
+      orchestratorUrl: stringOrNull(record.orchestratorUrl || record.perplexityUrl),
+      tabs: normalizeCatalogTabs(record),
+      lastActivityAt:
+        record.lastActivityAt ||
+        record.lastActivity ||
+        record.updatedAt ||
+        record.archivedAt ||
+        record.closedAt ||
+        null,
+      allowedOperations: ["inspect", "search"],
+      readOnly: true,
+    };
+  }
+
+  function normalizeFleetRecord(record, index) {
+    const base = normalizeCatalogRecord(record, "fleet", index);
+    return {
+      ...base,
+      status: catalogStatus(record, "unknown"),
+      agentType: record.agentType || record.type || null,
+      allowedOperations: ["inspect", "search", "get_fleet_status", "dispatch_to_fleet"],
+      readOnly: true,
+    };
+  }
+
+  function buildGlobalContextCatalog(input) {
+    const data = input || {};
+    const now = data.now || new Date().toISOString();
+    const liveSessions = (data.liveSessions || []).map((r, i) =>
+      normalizeCatalogRecord(r, "live", i)
+    );
+    const archivedSessions = (data.archivedSessions || []).map((r, i) =>
+      normalizeCatalogRecord(r, "archived", i)
+    );
+    const recentlyClosed = (data.recentlyClosed || []).map((r, i) =>
+      normalizeCatalogRecord(r, "recent", i)
+    );
+    const unifiedThreads = (data.unifiedThreads || []).map((r, i) =>
+      normalizeCatalogRecord(r, "unified", i)
+    );
+    const fleetMembers = (data.fleetMembers || []).map((r, i) => normalizeFleetRecord(r, i));
+    const gatewayTools = (data.gatewayTools || []).map((r, i) =>
+      normalizeCatalogRecord(r, "gateway", i)
+    );
+    const slashCommands = Array.isArray(data.slashCommands)
+      ? buildEquanautSlashCommandCatalog(data.slashCommands)
+      : buildEquanautSlashCommandCatalog();
+    const plugins = Array.isArray(data.plugins)
+      ? buildEquanautPluginCatalog(data.plugins)
+      : buildEquanautPluginCatalog();
+
+    return {
+      liveSessions,
+      archivedSessions,
+      recentlyClosed,
+      unifiedThreads,
+      fleetMembers,
+      gatewayTools,
+      slashCommands,
+      plugins,
+      freshness: {
+        liveSessionsAt: data.liveSessionsAt || now,
+        catalogAt: data.catalogAt || now,
+        staleSources: Array.isArray(data.staleSources) ? data.staleSources : [],
+      },
+    };
+  }
+
+  function countGlobalContextCatalog(catalog) {
+    const c = catalog || {};
+    return {
+      live: (c.liveSessions || []).length,
+      archived: (c.archivedSessions || []).length,
+      recent: (c.recentlyClosed || []).length,
+      unified: (c.unifiedThreads || []).length,
+      fleet: (c.fleetMembers || []).length,
+      gatewayTools: (c.gatewayTools || []).length,
+      slashCommands: (c.slashCommands || []).length,
+      plugins: (c.plugins || []).length,
+    };
+  }
+
+  function buildAgentContextEnvelope(input) {
+    const data = input || {};
+    const submittedAt = data.submittedAt || new Date().toISOString();
+    const globalCatalog = data.globalCatalog || buildGlobalContextCatalog({ now: submittedAt });
+    const capabilities = data.capabilities || {};
+    const activeWindowScope = data.activeWindowScope || {
+      windowId: "unknown",
+      groups: [],
+      ungroupedTabs: [],
+      mutationPolicy: {},
+    };
+    const catalogCounts = countGlobalContextCatalog(globalCatalog);
+    const scopedGroupCount = Array.isArray(activeWindowScope.groups)
+      ? activeWindowScope.groups.length
+      : 0;
+    const scopedTabCount =
+      (activeWindowScope.groups || []).reduce((sum, group) => {
+        return sum + (Array.isArray(group.tabs) ? group.tabs.length : group.tabCount || 0);
+      }, 0) +
+      (Array.isArray(activeWindowScope.ungroupedTabs) ? activeWindowScope.ungroupedTabs.length : 0);
+
+    return {
+      schemaVersion: data.schemaVersion || "1.0",
+      submittedAt,
+      userText: String(data.userText || ""),
+      activeWindowScope,
+      globalCatalog,
+      capabilities,
+      allowedIntents: data.allowedIntents || Array.from(SUPPORTED_ROUTER_INTENTS),
+      slashCommand: data.slashCommand || null,
+      attachments: data.attachments || [],
+      telemetry: {
+        ...(data.telemetry || {}),
+        activeWindowId: activeWindowScope.windowId || "unknown",
+        scopedGroupCount,
+        scopedTabCount,
+        catalogCounts,
+        slashCommandId: data.slashCommand?.commandId || data.slashCommand?.command?.id || null,
+      },
+    };
+  }
+
+  function denyRouterIntent(intent, code, message, activeWindowScope) {
+    return {
+      intent,
+      scope: "denied",
+      mutation: !READ_ONLY_ROUTER_INTENTS.has(intent),
+      requiresConfirmation: false,
+      preview: message,
+      denial: { code, message },
+      audit: {
+        requestedBy: "sidepanel",
+        activeWindowId: activeWindowScope?.windowId || "unknown",
+        createdAt: new Date().toISOString(),
+      },
+      allowed: false,
+    };
+  }
+
+  function validateRouterIntent(input) {
+    const data = input || {};
+    const intent = String(data.intent || "");
+    const target = data.target || {};
+    const activeWindowScope = data.activeWindowScope || {};
+    const activeWindowId = activeWindowScope.windowId ? String(activeWindowScope.windowId) : "";
+
+    if (!SUPPORTED_ROUTER_INTENTS.includes(intent)) {
+      return denyRouterIntent(
+        intent || "unknown",
+        "UNSUPPORTED_INTENT",
+        `Unsupported router intent: ${intent || "unknown"}`,
+        activeWindowScope
+      );
+    }
+
+    const mutation = !READ_ONLY_ROUTER_INTENTS.has(intent);
+    if (!mutation) {
+      return {
+        intent,
+        target,
+        scope: "global_read_only",
+        mutation: false,
+        requiresConfirmation: false,
+        preview: `Read-only ${intent} for ${target.title || target.id || "router context"}`,
+        audit: {
+          requestedBy: "sidepanel",
+          activeWindowId: activeWindowId || "unknown",
+          createdAt: new Date().toISOString(),
+        },
+        allowed: true,
+      };
+    }
+
+    if (activeWindowScope.profileOwner === "human" || target.profileOwner === "human") {
+      return denyRouterIntent(
+        intent,
+        "HUMAN_PROFILE_DENIED",
+        "Normal agents cannot mutate human-owned browser profile or window state.",
+        activeWindowScope
+      );
+    }
+
+    if (target.displayRole === "primary_user" || target.displayRole === "bottom_user") {
+      return denyRouterIntent(
+        intent,
+        "BOTTOM_DISPLAY_MUTATION_DENIED",
+        "Normal agents cannot mutate bottom-display user browser windows.",
+        activeWindowScope
+      );
+    }
+
+    const targetWindowId = target.windowId ? String(target.windowId) : "";
+    const allowOtherWindow =
+      activeWindowScope.mutationPolicy && activeWindowScope.mutationPolicy.allowOtherWindowMutation;
+    if (
+      targetWindowId &&
+      activeWindowId &&
+      targetWindowId !== activeWindowId &&
+      !allowOtherWindow
+    ) {
+      return denyRouterIntent(
+        intent,
+        "OTHER_WINDOW_MUTATION_DENIED",
+        "Normal sidepanel requests may mutate only the active sidepanel window. Open or rebind the target first.",
+        activeWindowScope
+      );
+    }
+
+    if (
+      ["open", "restore", "open_orchestrator_url"].includes(intent) &&
+      activeWindowScope.displayRole &&
+      activeWindowScope.displayRole !== "top_agents"
+    ) {
+      return denyRouterIntent(
+        intent,
+        "TOP_DISPLAY_REQUIRED",
+        "Open and restore actions must use the top-display agent workspace.",
+        activeWindowScope
+      );
+    }
+
+    if (intent === "dispatch_to_fleet") {
+      const status = String(target.status || "").toLowerCase();
+      if (!["active", "running", "idle", "online"].includes(status)) {
+        return denyRouterIntent(
+          intent,
+          "FLEET_TARGET_UNAVAILABLE",
+          "Dispatch requires a live or reachable fleet target.",
+          activeWindowScope
+        );
+      }
+    }
+
+    return {
+      intent,
+      target,
+      scope: intent === "dispatch_to_fleet" ? "fleet" : "active_window",
+      mutation: true,
+      requiresConfirmation: !!data.requiresConfirmation,
+      preview: data.preview || `${intent} ${target.title || target.id || "target"}`,
+      audit: {
+        requestedBy: "sidepanel",
+        activeWindowId: activeWindowId || "unknown",
+        reason: data.reason || "user_request",
+        createdAt: new Date().toISOString(),
+      },
+      allowed: true,
+    };
+  }
+
+  const SessionLogic = {
+    timeAgo,
+    fsFuzzyMatch,
+    fsFormatEventDescription,
+    fsApplyFilters,
+    fsApplyAdvancedFilters,
+    fsSortGroups,
+    fsGroupBy,
+    fsResolveSelectedTabs,
+    getDomainDisplayName,
+    DEFAULT_SAFETY_REMINDER_HOST_ALLOWLIST,
+    DEFAULT_EQUANAUT_SLASH_COMMANDS,
+    DEFAULT_EQUANAUT_PLUGIN_LIBRARY,
+    isSafetyReminderAllowlisted,
+    shouldInjectSafetyReminder,
+    normalizeEquanautModelEntry,
+    normalizeEquanautModelCatalog,
+    normalizeEquanautOllamaModel,
+    modelsFromEquanautGatewayConfig,
+    mergeEquanautModelCatalogs,
+    groupEquanautModelCatalog,
+    getEquanautCommandCenterFallbackModels,
+    getEquanautModelBadge,
+    getEquanautProviderGlyph,
+    getEquanautProviderFilterKey,
+    getEquanautModelCostTier,
+    getEquanautModelCapabilities,
+    getEquanautCapabilityLabel,
+    filterEquanautModels,
+    getEquanautModelDisplayName,
+    isEquanautModelConfigured,
+    getEquanautModelSettingsUrl,
+    EQUANAUT_MODEL_CAPABILITIES,
+    EQUANAUT_MODEL_CAPABILITY_ORDER,
+    isEquanautCommandCenterModel,
+    resolveEquanautOllamaModelId,
+    normalizeEquanautRoutingMode,
+    isEquanautModelAllowedForRouting,
+    pickEquanautModelForRoutingMode,
+    normalizeSlashCommandId,
+    normalizeEquanautSlashCommand,
+    normalizeEquanautPlugin,
+    buildEquanautSlashCommandCatalog,
+    buildEquanautPluginCatalog,
+    filterEquanautSlashCommands,
+    filterEquanautPlugins,
+    parseEquanautSlashCommandInvocation,
+    resolveEquanautSlashCommand,
+    normalizeBindingWindowSnapshot,
+    formatBindingStatusLabel,
+    getBindingStatusClass,
+    escapeHtml,
+    groupAndSortForDeletion,
+    SUPPORTED_ROUTER_INTENTS,
+    selectEquanautRouterRoute,
+    normalizeEntityDescription,
+    normalizeCatalogRecord,
+    buildGlobalContextCatalog,
+    countGlobalContextCatalog,
+    buildAgentContextEnvelope,
+    validateRouterIntent,
+    DEFAULT_DOMAIN_DISPLAY_MAP,
+  };
+
+  // Browser: register on globalThis
+  if (typeof globalThis !== "undefined") {
+    globalThis.SessionLogic = SessionLogic;
+    // sidepanel.js calls timeAgo() unqualified at 9 sites — keep that contract
+    // intact even though the IIFE otherwise hides individual names. Without
+    // this, fsRenderGroups throws "timeAgo is not defined" on the first card
+    // and the middle column of session-manager.html renders nothing.
+    globalThis.timeAgo = timeAgo;
+  }
+
+  // Node.js CJS: export for test require()
+  if (typeof module !== "undefined" && module.exports) {
+    module.exports = SessionLogic;
+  }
+})();