diff --git a/ui/sidebar/sidebar.css b/ui/sidebar/sidebar.css
index 798b294..1d4d266 100644
--- a/ui/sidebar/sidebar.css
+++ b/ui/sidebar/sidebar.css
@@ -1,42 +1,169 @@
 :root {
-    /* Chrome UI Color Palette - 更中性的灰色调 */
-    --tf-primary: #1a73e8;
-    --tf-primary-hover: #1557b0;
-    --tf-primary-light: #e8f0fe;
+    /* 主色调 - 更现代的蓝色调 */
+    --tf-primary: #4285f4;
+    --tf-primary-hover: #3367d6;
+    --tf-primary-light: rgba(66, 133, 244, 0.12);
+    --tf-primary-focus: rgba(66, 133, 244, 0.25);
+    
+    /* 辅助色 */
+    --tf-success: #34a853;
+    --tf-warning: #fbbc04;
+    --tf-danger: #ea4335;
+    
+    /* 浅色模式背景 */
     --tf-bg-primary: #ffffff;
-    --tf-bg-secondary: #f8f9fa;
-    --tf-bg-hover: #f1f3f4;
-    --tf-bg-active: #e8eaed;
-    --tf-text-primary: #202124;
-    --tf-text-secondary: #5f6368;
-    --tf-text-muted: #9aa0a6;
-    --tf-border: #dadce0;
-    --tf-border-light: #e8eaed;
-    --tf-focus-ring: rgba(26, 115, 232, 0.4);
-
-    /* 更锐利的圆角，与Chrome一致 */
+    --tf-bg-secondary: #f8fafc;
+    --tf-bg-tertiary: #f1f5f9;
+    --tf-bg-hover: #eef2f6;
+    --tf-bg-active: #e2e8f0;
+    --tf-bg-overlay: rgba(0, 0, 0, 0.05);
+    
+    /* 浅色模式文字 */
+    --tf-text-primary: #1e293b;
+    --tf-text-secondary: #475569;
+    --tf-text-muted: #94a3b8;
+    --tf-text-inverse: #ffffff;
+    
+    /* 浅色模式边框 */
+    --tf-border: #e2e8f0;
+    --tf-border-light: #f1f5f9;
+    --tf-border-dark: #cbd5e1;
+    
+    /* 焦点状态 */
+    --tf-focus-ring: rgba(66, 133, 244, 0.3);
+    --tf-focus-ring-width: 2px;
+    
+    /* 圆角 */
     --tf-radius: 4px;
-    --tf-radius-lg: 6px;
-
-    /* 更紧凑的字体系统 */
+    --tf-radius-md: 6px;
+    --tf-radius-lg: 8px;
+    --tf-radius-xl: 12px;
+    
+    /* 字体系统 */
     --tf-font-size-xs: 11px;
     --tf-font-size-sm: 12px;
     --tf-font-size-md: 13px;
     --tf-font-size-lg: 14px;
-
-    /* 更紧凑的间距，提高信息密度 */
+    --tf-font-size-xl: 16px;
+    
+    /* 间距系统 */
     --tf-spacing-xs: 2px;
     --tf-spacing-sm: 4px;
     --tf-spacing-md: 8px;
     --tf-spacing-lg: 12px;
     --tf-spacing-xl: 16px;
-
-    /* 轻微的投影，只在必要时使用 */
-    --tf-shadow: 0 1px 2px rgba(0, 0, 0, 0.1);
-    --tf-shadow-lg: 0 2px 4px rgba(0, 0, 0, 0.15);
-
-    /* 更快的过渡 */
+    --tf-spacing-2xl: 20px;
+    
+    /* 阴影系统 - 更细腻的层次 */
+    --tf-shadow-xs: 0 1px 2px rgba(0, 0, 0, 0.04);
+    --tf-shadow-sm: 0 1px 3px rgba(0, 0, 0, 0.06), 0 1px 2px rgba(0, 0, 0, 0.03);
+    --tf-shadow-md: 0 4px 6px -1px rgba(0, 0, 0, 0.08), 0 2px 4px -1px rgba(0, 0, 0, 0.04);
+    --tf-shadow-lg: 0 10px 15px -3px rgba(0, 0, 0, 0.08), 0 4px 6px -2px rgba(0, 0, 0, 0.04);
+    --tf-shadow-xl: 0 20px 25px -5px rgba(0, 0, 0, 0.08), 0 10px 10px -5px rgba(0, 0, 0, 0.04);
+    
+    /* 毛玻璃效果 */
+    --tf-blur-sm: blur(4px);
+    --tf-blur-md: blur(8px);
+    --tf-blur-lg: blur(12px);
+    --tf-bg-glass: rgba(255, 255, 255, 0.8);
+    --tf-bg-glass-hover: rgba(255, 255, 255, 0.9);
+    
+    /* 过渡动画 */
+    --tf-transition-fast: all 0.1s ease;
     --tf-transition: all 0.15s ease;
+    --tf-transition-slow: all 0.25s ease;
+    --tf-transition-bounce: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+    
+    /* 动画曲线 */
+    --tf-ease-in-out: cubic-bezier(0.4, 0, 0.2, 1);
+    --tf-ease-out: cubic-bezier(0.0, 0, 0.2, 1);
+    --tf-ease-in: cubic-bezier(0.4, 0, 1, 1);
+}
+
+/* 深色模式变量 */
+@media (prefers-color-scheme: dark) {
+    :root {
+        /* 主色调 - 深色模式下更柔和 */
+        --tf-primary: #60a5fa;
+        --tf-primary-hover: #3b82f6;
+        --tf-primary-light: rgba(96, 165, 250, 0.15);
+        --tf-primary-focus: rgba(96, 165, 250, 0.3);
+        
+        /* 深色模式背景 */
+        --tf-bg-primary: #1e1e2e;
+        --tf-bg-secondary: #252536;
+        --tf-bg-tertiary: #2d2d3f;
+        --tf-bg-hover: #313244;
+        --tf-bg-active: #45475a;
+        --tf-bg-overlay: rgba(255, 255, 255, 0.03);
+        
+        /* 深色模式文字 */
+        --tf-text-primary: #cdd6f4;
+        --tf-text-secondary: #a6adc8;
+        --tf-text-muted: #6c7086;
+        --tf-text-inverse: #1e1e2e;
+        
+        /* 深色模式边框 */
+        --tf-border: #313244;
+        --tf-border-light: #45475a;
+        --tf-border-dark: #585b70;
+        
+        /* 焦点状态 */
+        --tf-focus-ring: rgba(96, 165, 250, 0.4);
+        
+        /* 深色模式阴影 - 更有氛围感 */
+        --tf-shadow-xs: 0 1px 2px rgba(0, 0, 0, 0.2);
+        --tf-shadow-sm: 0 1px 3px rgba(0, 0, 0, 0.3), 0 1px 2px rgba(0, 0, 0, 0.15);
+        --tf-shadow-md: 0 4px 6px -1px rgba(0, 0, 0, 0.4), 0 2px 4px -1px rgba(0, 0, 0, 0.2);
+        --tf-shadow-lg: 0 10px 15px -3px rgba(0, 0, 0, 0.4), 0 4px 6px -2px rgba(0, 0, 0, 0.2);
+        --tf-shadow-xl: 0 20px 25px -5px rgba(0, 0, 0, 0.5), 0 10px 10px -5px rgba(0, 0, 0, 0.25);
+        
+        /* 深色模式毛玻璃效果 */
+        --tf-bg-glass: rgba(30, 30, 46, 0.85);
+        --tf-bg-glass-hover: rgba(30, 30, 46, 0.95);
+    }
+}
+
+/* 手动深色模式类 */
+.tf-dark-mode {
+    /* 主色调 - 深色模式下更柔和 */
+    --tf-primary: #60a5fa;
+    --tf-primary-hover: #3b82f6;
+    --tf-primary-light: rgba(96, 165, 250, 0.15);
+    --tf-primary-focus: rgba(96, 165, 250, 0.3);
+    
+    /* 深色模式背景 */
+    --tf-bg-primary: #1e1e2e;
+    --tf-bg-secondary: #252536;
+    --tf-bg-tertiary: #2d2d3f;
+    --tf-bg-hover: #313244;
+    --tf-bg-active: #45475a;
+    --tf-bg-overlay: rgba(255, 255, 255, 0.03);
+    
+    /* 深色模式文字 */
+    --tf-text-primary: #cdd6f4;
+    --tf-text-secondary: #a6adc8;
+    --tf-text-muted: #6c7086;
+    --tf-text-inverse: #1e1e2e;
+    
+    /* 深色模式边框 */
+    --tf-border: #313244;
+    --tf-border-light: #45475a;
+    --tf-border-dark: #585b70;
+    
+    /* 焦点状态 */
+    --tf-focus-ring: rgba(96, 165, 250, 0.4);
+    
+    /* 深色模式阴影 */
+    --tf-shadow-xs: 0 1px 2px rgba(0, 0, 0, 0.2);
+    --tf-shadow-sm: 0 1px 3px rgba(0, 0, 0, 0.3), 0 1px 2px rgba(0, 0, 0, 0.15);
+    --tf-shadow-md: 0 4px 6px -1px rgba(0, 0, 0, 0.4), 0 2px 4px -1px rgba(0, 0, 0, 0.2);
+    --tf-shadow-lg: 0 10px 15px -3px rgba(0, 0, 0, 0.4), 0 4px 6px -2px rgba(0, 0, 0, 0.2);
+    --tf-shadow-xl: 0 20px 25px -5px rgba(0, 0, 0, 0.5), 0 10px 10px -5px rgba(0, 0, 0, 0.25);
+    
+    /* 深色模式毛玻璃效果 */
+    --tf-bg-glass: rgba(30, 30, 46, 0.85);
+    --tf-bg-glass-hover: rgba(30, 30, 46, 0.95);
 }
 
 .tf-hidden {
@@ -219,7 +346,213 @@ body {
     font-size: 14px;
 }
 
-/* Group Selector - Chrome标签栏风格 */
+/* 搜索清除按钮 */
+.tf-search-clear {
+    position: absolute;
+    right: 4px;
+    padding: 4px;
+    color: var(--tf-text-muted);
+    background: transparent;
+    border: none;
+    cursor: pointer;
+    border-radius: var(--tf-radius);
+    opacity: 0;
+    transition: var(--tf-transition);
+}
+
+.tf-search-box:hover .tf-search-clear,
+.tf-search-box:focus-within .tf-search-clear {
+    opacity: 1;
+}
+
+.tf-search-clear:hover {
+    color: var(--tf-text-secondary);
+    background: var(--tf-bg-hover);
+}
+
+/* 搜索建议下拉框 */
+.tf-search-suggestions {
+    position: absolute;
+    top: 100%;
+    left: var(--tf-spacing-md);
+    right: var(--tf-spacing-md);
+    margin-top: 2px;
+    background: var(--tf-bg-primary);
+    border: 1px solid var(--tf-border);
+    border-radius: var(--tf-radius-lg);
+    box-shadow: var(--tf-shadow-lg);
+    z-index: 1000;
+    max-height: 300px;
+    overflow-y: auto;
+    animation: tf-fade-in 0.15s ease;
+}
+
+@keyframes tf-fade-in {
+    from {
+        opacity: 0;
+        transform: translateY(-4px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+.tf-search-suggestions-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: var(--tf-spacing-sm) var(--tf-spacing-md);
+    border-bottom: 1px solid var(--tf-border-light);
+}
+
+.tf-search-suggestions-title {
+    font-size: var(--tf-font-size-xs);
+    color: var(--tf-text-muted);
+    font-weight: 500;
+    text-transform: uppercase;
+    letter-spacing: 0.3px;
+}
+
+.tf-btn-xs {
+    font-size: var(--tf-font-size-xs);
+    padding: 2px 6px;
+    color: var(--tf-primary);
+    background: transparent;
+    border: none;
+    cursor: pointer;
+    border-radius: var(--tf-radius);
+}
+
+.tf-btn-xs:hover {
+    background: var(--tf-primary-light);
+}
+
+.tf-search-suggestions-list {
+    padding: var(--tf-spacing-xs) 0;
+}
+
+.tf-search-suggestion-item {
+    display: flex;
+    align-items: center;
+    gap: var(--tf-spacing-md);
+    padding: var(--tf-spacing-sm) var(--tf-spacing-md);
+    cursor: pointer;
+    transition: var(--tf-transition);
+}
+
+.tf-search-suggestion-item:hover,
+.tf-search-suggestion-item.tf-suggestion-active {
+    background: var(--tf-bg-hover);
+}
+
+.tf-search-suggestion-item.tf-suggestion-active {
+    background: var(--tf-primary-light);
+}
+
+.tf-suggestion-icon {
+    font-size: 14px;
+    flex-shrink: 0;
+    width: 20px;
+    text-align: center;
+}
+
+.tf-suggestion-text {
+    flex: 1;
+    font-size: var(--tf-font-size-sm);
+    color: var(--tf-text-primary);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.tf-suggestion-highlight {
+    color: var(--tf-primary);
+    font-weight: 500;
+}
+
+.tf-suggestion-type {
+    font-size: var(--tf-font-size-xs);
+    color: var(--tf-text-muted);
+    background: var(--tf-bg-secondary);
+    padding: 2px 6px;
+    border-radius: var(--tf-radius);
+    flex-shrink: 0;
+}
+
+.tf-suggestion-meta {
+    font-size: var(--tf-font-size-xs);
+    color: var(--tf-text-muted);
+    flex-shrink: 0;
+}
+
+/* 搜索结果统计 */
+.tf-search-stats {
+    padding: var(--tf-spacing-sm) var(--tf-spacing-md);
+    background: var(--tf-bg-secondary);
+    border-bottom: 1px solid var(--tf-border-light);
+}
+
+.tf-search-results-count {
+    font-size: var(--tf-font-size-xs);
+    color: var(--tf-text-secondary);
+}
+
+/* 空状态优化 */
+.tf-empty-state {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    padding: var(--tf-spacing-xl) var(--tf-spacing-md);
+    text-align: center;
+}
+
+.tf-empty-icon {
+    font-size: 40px;
+    margin-bottom: var(--tf-spacing-md);
+}
+
+.tf-empty-title {
+    font-size: var(--tf-font-size-md);
+    font-weight: 500;
+    color: var(--tf-text-primary);
+    margin-bottom: var(--tf-spacing-sm);
+}
+
+.tf-empty-subtitle {
+    font-size: var(--tf-font-size-sm);
+    color: var(--tf-text-secondary);
+    margin-bottom: var(--tf-spacing-md);
+}
+
+.tf-empty-tips {
+    font-size: var(--tf-font-size-xs);
+    color: var(--tf-text-muted);
+}
+
+.tf-empty-tips p {
+    margin-bottom: var(--tf-spacing-sm);
+    font-weight: 500;
+}
+
+.tf-empty-tips ul {
+    list-style: none;
+    padding: 0;
+}
+
+.tf-empty-tips li {
+    padding: 2px 0;
+}
+
+/* 搜索高亮 */
+.tf-search-highlight {
+    background: var(--tf-primary-light);
+    color: var(--tf-primary);
+    font-weight: 500;
+    padding: 0 2px;
+    border-radius: 2px;
+}
 .tf-group-selector {
     display: flex;
     border-bottom: 1px solid var(--tf-border-light);
@@ -577,6 +910,111 @@ tab-item {
     color: var(--tf-text-muted);
 }
 
+/* 批量操作工具栏 */
+.tf-batch-actions {
+    display: flex;
+    align-items: center;
+    gap: var(--tf-spacing-sm);
+    flex: 1;
+    min-width: 0;
+    overflow-x: auto;
+}
+
+.tf-batch-actions .tf-btn {
+    flex-shrink: 0;
+}
+
+/* 全选按钮特殊样式 */
+.tf-btn-partial {
+    position: relative;
+}
+
+.tf-btn-partial::after {
+    content: '';
+    position: absolute;
+    bottom: 0;
+    left: 50%;
+    transform: translateX(-50%);
+    width: 40%;
+    height: 2px;
+    background: var(--tf-primary);
+}
+
+/* 当前窗口高亮 */
+.tf-window-current {
+    background: var(--tf-primary-light) !important;
+    border-left: 3px solid var(--tf-primary) !important;
+}
+
+/* 选择模式下的标签页样式 */
+.tf-tab.selected {
+    background: var(--tf-primary-light);
+    border-left: 3px solid var(--tf-primary);
+}
+
+.tf-tab.selected::before {
+    display: none;
+}
+
+/* 选择模式指示器 */
+.tf-selection-indicator {
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    background: var(--tf-primary);
+    color: var(--tf-text-inverse);
+    padding: 4px 8px;
+    font-size: var(--tf-font-size-xs);
+    text-align: center;
+    z-index: 1000;
+    animation: tf-slideInDown 0.2s var(--tf-ease-out);
+}
+
+/* 批量操作按钮禁用状态 */
+.tf-btn:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+    pointer-events: none;
+}
+
+.tf-btn:disabled:hover {
+    transform: none;
+    box-shadow: none;
+}
+
+/* 右键菜单快捷键样式 */
+.tf-menu-shortcut {
+    margin-left: auto;
+    font-size: 11px;
+    color: var(--tf-text-muted);
+    opacity: 0.7;
+}
+
+.tf-menu-item:hover .tf-menu-shortcut {
+    opacity: 0.9;
+}
+
+/* 选择模式下的分组选择 */
+.tf-group-select-all {
+    display: flex;
+    align-items: center;
+    gap: var(--tf-spacing-sm);
+    padding: var(--tf-spacing-sm) var(--tf-spacing-md);
+    background: var(--tf-bg-secondary);
+    border-bottom: 1px solid var(--tf-border-light);
+    font-size: var(--tf-font-size-xs);
+    color: var(--tf-text-secondary);
+}
+
+.tf-group-select-all input[type="checkbox"] {
+    width: 14px;
+    height: 14px;
+    margin: 0;
+    accent-color: var(--tf-primary);
+    cursor: pointer;
+}
+
 /* Context Menu - Chrome风格 */
 .tf-context-menu {
     position: fixed;
@@ -1097,3 +1535,587 @@ tab-item {
         border-left-width: 4px;
     }
 }
+
+/* ========== 增强的 UI 效果 ========== */
+
+/* 毛玻璃效果 */
+.tf-glass {
+    background: var(--tf-bg-glass);
+    backdrop-filter: var(--tf-blur-md);
+    -webkit-backdrop-filter: var(--tf-blur-md);
+    border: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.tf-glass-dark {
+    background: var(--tf-bg-glass);
+    backdrop-filter: var(--tf-blur-md);
+    -webkit-backdrop-filter: var(--tf-blur-md);
+    border: 1px solid rgba(0, 0, 0, 0.1);
+}
+
+/* 上下文菜单毛玻璃效果 */
+.tf-context-menu {
+    background: var(--tf-bg-glass);
+    backdrop-filter: var(--tf-blur-md);
+    -webkit-backdrop-filter: var(--tf-blur-md);
+    box-shadow: var(--tf-shadow-lg);
+}
+
+/* 模态框毛玻璃效果 */
+.tf-modal-backdrop {
+    background: rgba(0, 0, 0, 0.4);
+    backdrop-filter: var(--tf-blur-sm);
+    -webkit-backdrop-filter: var(--tf-blur-sm);
+}
+
+.tf-modal-panel {
+    background: var(--tf-bg-glass);
+    backdrop-filter: var(--tf-blur-md);
+    -webkit-backdrop-filter: var(--tf-blur-md);
+    box-shadow: var(--tf-shadow-xl);
+}
+
+/* 加载遮罩毛玻璃效果 */
+.tf-loading {
+    background: rgba(255, 255, 255, 0.8);
+    backdrop-filter: var(--tf-blur-sm);
+    -webkit-backdrop-filter: var(--tf-blur-sm);
+}
+
+/* 搜索建议下拉框毛玻璃效果 */
+.tf-search-suggestions {
+    background: var(--tf-bg-glass);
+    backdrop-filter: var(--tf-blur-md);
+    -webkit-backdrop-filter: var(--tf-blur-md);
+    box-shadow: var(--tf-shadow-lg);
+}
+
+/* ========== 增强的动画效果 ========== */
+
+/* 淡入淡出动画 */
+@keyframes tf-fadeIn {
+    from {
+        opacity: 0;
+        transform: translateY(-4px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+@keyframes tf-fadeOut {
+    from {
+        opacity: 1;
+        transform: translateY(0);
+    }
+    to {
+        opacity: 0;
+        transform: translateY(-4px);
+    }
+}
+
+/* 缩放动画 */
+@keyframes tf-scaleIn {
+    from {
+        opacity: 0;
+        transform: scale(0.95);
+    }
+    to {
+        opacity: 1;
+        transform: scale(1);
+    }
+}
+
+@keyframes tf-scaleOut {
+    from {
+        opacity: 1;
+        transform: scale(1);
+    }
+    to {
+        opacity: 0;
+        transform: scale(0.95);
+    }
+}
+
+/* 滑入滑出动画 */
+@keyframes tf-slideInLeft {
+    from {
+        opacity: 0;
+        transform: translateX(-20px);
+    }
+    to {
+        opacity: 1;
+        transform: translateX(0);
+    }
+}
+
+@keyframes tf-slideInRight {
+    from {
+        opacity: 0;
+        transform: translateX(20px);
+    }
+    to {
+        opacity: 1;
+        transform: translateX(0);
+    }
+}
+
+@keyframes tf-slideInUp {
+    from {
+        opacity: 0;
+        transform: translateY(20px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+@keyframes tf-slideInDown {
+    from {
+        opacity: 0;
+        transform: translateY(-20px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+/* 脉冲动画 */
+@keyframes tf-pulse {
+    0%, 100% {
+        opacity: 1;
+    }
+    50% {
+        opacity: 0.5;
+    }
+}
+
+/* 闪烁动画 */
+@keyframes tf-shimmer {
+    0% {
+        background-position: -200% 0;
+    }
+    100% {
+        background-position: 200% 0;
+    }
+}
+
+/* 弹跳动画 */
+@keyframes tf-bounce {
+    0%, 20%, 53%, 80%, 100% {
+        transform: translateY(0);
+    }
+    40%, 43% {
+        transform: translateY(-4px);
+    }
+    70% {
+        transform: translateY(-2px);
+    }
+    90% {
+        transform: translateY(-1px);
+    }
+}
+
+/* 晃动动画 */
+@keyframes tf-shake {
+    0%, 100% {
+        transform: translateX(0);
+    }
+    10%, 30%, 50%, 70%, 90% {
+        transform: translateX(-2px);
+    }
+    20%, 40%, 60%, 80% {
+        transform: translateX(2px);
+    }
+}
+
+/* ========== 增强的按钮反馈效果 ========== */
+
+/* 按钮基础样式优化 */
+.tf-btn {
+    position: relative;
+    overflow: hidden;
+    transition: var(--tf-transition-bounce);
+}
+
+.tf-btn::after {
+    content: '';
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    width: 0;
+    height: 0;
+    background: rgba(255, 255, 255, 0.3);
+    border-radius: 50%;
+    transform: translate(-50%, -50%);
+    transition: width 0.3s, height 0.3s;
+}
+
+.tf-btn:hover::after {
+    width: 200%;
+    height: 200%;
+}
+
+.tf-btn:active {
+    transform: scale(0.97);
+}
+
+.tf-btn:active::after {
+    background: rgba(255, 255, 255, 0.2);
+    transition: width 0s, height 0s;
+}
+
+/* 主按钮增强 */
+.tf-btn-primary {
+    background: linear-gradient(135deg, var(--tf-primary) 0%, var(--tf-primary-hover) 100%);
+    box-shadow: 0 1px 3px rgba(66, 133, 244, 0.3);
+    transition: all 0.2s var(--tf-ease-out);
+}
+
+.tf-btn-primary:hover {
+    transform: translateY(-1px);
+    box-shadow: 0 4px 8px rgba(66, 133, 244, 0.4);
+}
+
+.tf-btn-primary:active {
+    transform: translateY(0) scale(0.98);
+    box-shadow: 0 1px 2px rgba(66, 133, 244, 0.3);
+}
+
+/* 次按钮增强 */
+.tf-btn-secondary {
+    background: var(--tf-bg-secondary);
+    border: 1px solid var(--tf-border);
+}
+
+.tf-btn-secondary:hover {
+    background: var(--tf-bg-hover);
+    border-color: var(--tf-border-dark);
+}
+
+/* 图标按钮增强 */
+.tf-btn-icon {
+    border-radius: var(--tf-radius-md);
+}
+
+.tf-btn-icon:hover {
+    background: var(--tf-bg-hover);
+}
+
+.tf-btn-icon:active {
+    background: var(--tf-bg-active);
+}
+
+/* ========== 标签页和分组动画效果 ========== */
+
+/* 标签项悬停效果 */
+.tf-tab {
+    transition: var(--tf-transition);
+}
+
+.tf-tab:hover {
+    background: var(--tf-bg-hover);
+}
+
+.tf-tab::before {
+    content: '';
+    position: absolute;
+    left: 0;
+    top: 0;
+    bottom: 0;
+    width: 0;
+    background: var(--tf-primary);
+    transition: width 0.15s var(--tf-ease-out);
+}
+
+.tf-tab.active::before {
+    width: 3px;
+}
+
+.tf-tab:hover::before {
+    width: 2px;
+}
+
+/* 分组标题悬停效果 */
+.tf-group-header {
+    transition: var(--tf-transition);
+}
+
+.tf-group-header:hover {
+    background: var(--tf-bg-hover);
+}
+
+/* 分组折叠动画 */
+.tf-group-content {
+    transition: max-height 0.3s var(--tf-ease-in-out), opacity 0.3s var(--tf-ease-in-out);
+    max-height: 2000px;
+    opacity: 1;
+    overflow: hidden;
+}
+
+.tf-group.collapsed .tf-group-content {
+    max-height: 0;
+    opacity: 0;
+}
+
+/* 分组展开/折叠图标动画 */
+.tf-group-toggle {
+    transition: transform 0.3s var(--tf-ease-in-out);
+}
+
+.tf-group.collapsed .tf-group-toggle {
+    transform: rotate(-90deg);
+}
+
+/* ========== 搜索输入框增强效果 ========== */
+
+.tf-search-box {
+    transition: var(--tf-transition);
+}
+
+.tf-search-box:focus-within {
+    transform: scale(1.01);
+}
+
+.tf-search-input {
+    transition: var(--tf-transition);
+}
+
+.tf-search-input:focus {
+    box-shadow: 0 0 0 3px var(--tf-primary-focus);
+}
+
+/* ========== 滚动条美化 ========== */
+
+/* WebKit 浏览器 */
+.tf-group-container::-webkit-scrollbar,
+.tf-folder-tree::-webkit-scrollbar,
+.tf-create-group-tab-list::-webkit-scrollbar,
+.tf-search-suggestions::-webkit-scrollbar {
+    width: 6px;
+}
+
+.tf-group-container::-webkit-scrollbar-track,
+.tf-folder-tree::-webkit-scrollbar-track,
+.tf-create-group-tab-list::-webkit-scrollbar-track,
+.tf-search-suggestions::-webkit-scrollbar-track {
+    background: transparent;
+}
+
+.tf-group-container::-webkit-scrollbar-thumb,
+.tf-folder-tree::-webkit-scrollbar-thumb,
+.tf-create-group-tab-list::-webkit-scrollbar-thumb,
+.tf-search-suggestions::-webkit-scrollbar-thumb {
+    background: var(--tf-border);
+    border-radius: 3px;
+}
+
+.tf-group-container::-webkit-scrollbar-thumb:hover,
+.tf-folder-tree::-webkit-scrollbar-thumb:hover,
+.tf-create-group-tab-list::-webkit-scrollbar-thumb:hover,
+.tf-search-suggestions::-webkit-scrollbar-thumb:hover {
+    background: var(--tf-border-dark);
+}
+
+/* ========== 焦点状态增强 ========== */
+
+.tf-btn:focus-visible,
+.tf-group-btn:focus-visible,
+.tf-search-input:focus-visible,
+.tf-tab-action-btn:focus-visible,
+.tf-menu-item:focus-visible {
+    outline: 2px solid var(--tf-primary);
+    outline-offset: 2px;
+}
+
+/* ========== 深色模式特定优化 ========== */
+
+@media (prefers-color-scheme: dark) {
+    /* 深色模式下的毛玻璃效果调整 */
+    .tf-glass {
+        background: rgba(30, 30, 46, 0.85);
+        border: 1px solid rgba(255, 255, 255, 0.05);
+    }
+    
+    .tf-context-menu {
+        background: rgba(37, 37, 54, 0.95);
+        border: 1px solid rgba(255, 255, 255, 0.08);
+    }
+    
+    .tf-modal-panel {
+        background: rgba(37, 37, 54, 0.95);
+        border: 1px solid rgba(255, 255, 255, 0.08);
+    }
+    
+    .tf-modal-backdrop {
+        background: rgba(0, 0, 0, 0.6);
+    }
+    
+    .tf-search-suggestions {
+        background: rgba(37, 37, 54, 0.95);
+        border: 1px solid rgba(255, 255, 255, 0.08);
+    }
+    
+    .tf-loading {
+        background: rgba(30, 30, 46, 0.9);
+    }
+    
+    /* 深色模式下的滚动条 */
+    .tf-group-container::-webkit-scrollbar-thumb,
+    .tf-folder-tree::-webkit-scrollbar-thumb,
+    .tf-create-group-tab-list::-webkit-scrollbar-thumb,
+    .tf-search-suggestions::-webkit-scrollbar-thumb {
+        background: rgba(255, 255, 255, 0.1);
+    }
+    
+    .tf-group-container::-webkit-scrollbar-thumb:hover,
+    .tf-folder-tree::-webkit-scrollbar-thumb:hover,
+    .tf-create-group-tab-list::-webkit-scrollbar-thumb:hover,
+    .tf-search-suggestions::-webkit-scrollbar-thumb:hover {
+        background: rgba(255, 255, 255, 0.15);
+    }
+    
+    /* 深色模式下的主按钮渐变 */
+    .tf-btn-primary {
+        background: linear-gradient(135deg, #3b82f6 0%, #2563eb 100%);
+    }
+    
+    /* 深色模式下的阴影 */
+    .tf-modal-panel,
+    .tf-context-menu,
+    .tf-search-suggestions {
+        box-shadow: 0 8px 32px rgba(0, 0, 0, 0.4);
+    }
+}
+
+/* 手动深色模式类 */
+.tf-dark-mode .tf-glass {
+    background: rgba(30, 30, 46, 0.85);
+    border: 1px solid rgba(255, 255, 255, 0.05);
+}
+
+.tf-dark-mode .tf-context-menu {
+    background: rgba(37, 37, 54, 0.95);
+    border: 1px solid rgba(255, 255, 255, 0.08);
+}
+
+.tf-dark-mode .tf-modal-panel {
+    background: rgba(37, 37, 54, 0.95);
+    border: 1px solid rgba(255, 255, 255, 0.08);
+}
+
+.tf-dark-mode .tf-modal-backdrop {
+    background: rgba(0, 0, 0, 0.6);
+}
+
+.tf-dark-mode .tf-search-suggestions {
+    background: rgba(37, 37, 54, 0.95);
+    border: 1px solid rgba(255, 255, 255, 0.08);
+}
+
+.tf-dark-mode .tf-loading {
+    background: rgba(30, 30, 46, 0.9);
+}
+
+.tf-dark-mode .tf-btn-primary {
+    background: linear-gradient(135deg, #3b82f6 0%, #2563eb 100%);
+}
+
+/* ========== 主题切换动画 ========== */
+
+/* 平滑主题过渡 */
+* {
+    transition: background-color 0.3s var(--tf-ease-in-out),
+                border-color 0.3s var(--tf-ease-in-out),
+                color 0.3s var(--tf-ease-in-out),
+                box-shadow 0.3s var(--tf-ease-in-out);
+}
+
+/* 排除不需要过渡的属性 */
+.tf-loading-spinner,
+.tf-tab,
+.tf-group-header {
+    transition: background-color 0.15s var(--tf-ease-out),
+                border-color 0.15s var(--tf-ease-out),
+                color 0.15s var(--tf-ease-out),
+                transform 0.15s var(--tf-ease-out),
+                box-shadow 0.15s var(--tf-ease-out);
+}
+
+/* ========== 骨架屏加载效果 ========== */
+
+.tf-skeleton {
+    background: linear-gradient(
+        90deg,
+        var(--tf-bg-secondary) 25%,
+        var(--tf-bg-tertiary) 37%,
+        var(--tf-bg-secondary) 63%
+    );
+    background-size: 400% 100%;
+    animation: tf-shimmer 1.4s ease-in-out infinite;
+}
+
+/* ========== 空状态增强 ========== */
+
+.tf-empty-state {
+    animation: tf-fadeIn 0.3s var(--tf-ease-out);
+}
+
+.tf-empty-icon {
+    animation: tf-bounce 2s infinite;
+}
+
+/* ========== Toast 通知增强 ========== */
+
+.tf-toast {
+    background: linear-gradient(135deg, #323232 0%, #1a1a1a 100%);
+    box-shadow: var(--tf-shadow-lg);
+}
+
+.tf-toast.success {
+    background: linear-gradient(135deg, #15803d 0%, #166534 100%);
+}
+
+.tf-toast.error {
+    background: linear-gradient(135deg, #dc2626 0%, #b91c1c 100%);
+}
+
+.tf-toast.warning {
+    background: linear-gradient(135deg, #d97706 0%, #b45309 100%);
+    color: #fff;
+}
+
+.tf-toast.info {
+    background: linear-gradient(135deg, #2563eb 0%, #1d4ed8 100%);
+}
+
+/* ========== 选中状态增强 ========== */
+
+.tf-tab.selected {
+    background: var(--tf-primary-light);
+    border-left: 3px solid var(--tf-primary);
+}
+
+.tf-tab.selected::before {
+    display: none;
+}
+
+/* ========== 禁用状态 ========== */
+
+.tf-btn:disabled,
+.tf-group-btn:disabled,
+.tf-tab-action-btn:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+    pointer-events: none;
+}
+
+.tf-btn:disabled:hover,
+.tf-group-btn:disabled:hover,
+.tf-tab-action-btn:disabled:hover {
+    transform: none;
+    box-shadow: none;
+}
diff --git a/ui/sidebar/sidebar.html b/ui/sidebar/sidebar.html
index d7ad20b..97ad829 100644
--- a/ui/sidebar/sidebar.html
+++ b/ui/sidebar/sidebar.html
@@ -44,7 +44,21 @@ <h1>SuperTab</h1>
                         <path d="M21 21l-4.35-4.35"/>
                     </svg>
                 </span>
-                <input type="text" id="search-input" placeholder="搜索标签页" class="tf-search-input">
+                <input type="text" id="search-input" placeholder="搜索标签页 (支持: 标题/备注/URL/域名)" class="tf-search-input" autocomplete="off">
+                <button id="search-clear-btn" class="tf-btn tf-btn-icon tf-search-clear tf-hidden" type="button" aria-label="清除搜索">
+                    <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                        <line x1="18" y1="6" x2="6" y2="18"/>
+                        <line x1="6" y1="6" x2="18" y2="18"/>
+                    </svg>
+                </button>
+            </div>
+            <!-- 搜索建议和历史记录 -->
+            <div id="search-suggestions" class="tf-search-suggestions tf-hidden">
+                <div class="tf-search-suggestions-header">
+                    <span class="tf-search-suggestions-title">搜索建议</span>
+                    <button id="clear-history-btn" class="tf-btn tf-btn-xs tf-hidden" type="button">清除历史</button>
+                </div>
+                <div id="search-suggestions-list" class="tf-search-suggestions-list"></div>
             </div>
         </div>
 
@@ -86,12 +100,43 @@ <h1>SuperTab</h1>
         <!-- 底部操作栏 -->
         <footer class="tf-footer">
             <div class="tf-footer-actions">
-                <button id="batch-favorite-btn" class="tf-btn tf-btn-secondary tf-hidden" title="转收藏选中的标签页">
-                    <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
-                        <path d="M19 21l-7-5-7 5V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2z"></path>
-                    </svg>
-                    <span>转收藏选中 (0)</span>
-                </button>
+                <div id="batch-actions" class="tf-batch-actions tf-hidden">
+                    <button id="batch-select-all-btn" class="tf-btn tf-btn-secondary" title="全选/取消全选">
+                        <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <path d="M9 11l3 3L22 4"/>
+                            <path d="M21 12v7a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h11"/>
+                        </svg>
+                        <span>全选</span>
+                    </button>
+                    <button id="batch-close-btn" class="tf-btn tf-btn-secondary" title="关闭选中的标签页">
+                        <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <line x1="18" y1="6" x2="6" y2="18"/>
+                            <line x1="6" y1="6" x2="18" y2="18"/>
+                        </svg>
+                        <span>关闭</span>
+                    </button>
+                    <button id="batch-sleep-btn" class="tf-btn tf-btn-secondary" title="休眠选中的标签页">
+                        <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <path d="M17 18a5 5 0 0 0-10 0"/>
+                            <path d="M12 14V2"/>
+                            <path d="M4.93 10.93A17 17 0 0 1 12 9a17 17 0 0 1 7.07 1.93"/>
+                        </svg>
+                        <span>休眠</span>
+                    </button>
+                    <button id="batch-move-btn" class="tf-btn tf-btn-secondary" title="移动选中的标签页">
+                        <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <path d="M8 5v14M19 12H5"/>
+                            <polyline points="12 19 19 12 12 5"/>
+                        </svg>
+                        <span>移动</span>
+                    </button>
+                    <button id="batch-favorite-btn" class="tf-btn tf-btn-secondary" title="转收藏选中的标签页">
+                        <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <path d="M19 21l-7-5-7 5V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2z"></path>
+                        </svg>
+                        <span>收藏</span>
+                    </button>
+                </div>
                 <button id="create-group-btn" class="tf-btn tf-btn-primary">
                     <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
                         <line x1="12" y1="5" x2="12" y2="19"/>
@@ -184,6 +229,7 @@ <h2 id="create-group-modal-title">新建自定义分组</h2>
     </div>
 
     <!-- Import custom elements -->
+    <script src="../../utils/tab-search-engine.js"></script>
     <script src="../components/group-item.js"></script>
     <script src="../components/tab-item.js"></script>
     <script src="sidebar.js"></script>
diff --git a/ui/sidebar/sidebar.js b/ui/sidebar/sidebar.js
index c78b68f..24f8a86 100644
--- a/ui/sidebar/sidebar.js
+++ b/ui/sidebar/sidebar.js
@@ -25,6 +25,10 @@ class SuperTabSidebar {
     this.contextMenuContext = null;
     this.createGroupTabFilterQuery = '';
     this.createGroupSelectedTabUuids = new Set();
+    // 搜索增强
+    this.searchEngine = null;
+    this.searchResults = [];
+    this.isSearching = false;
 
     this.initializeElements();
     this.setupEventListeners();
@@ -69,7 +73,18 @@ class SuperTabSidebar {
       createGroupTabSearchInput: document.getElementById('create-group-tab-search-input'),
       createGroupSelectAllCheckbox: document.getElementById('create-group-select-all-checkbox'),
       createGroupSelectionSummary: document.getElementById('create-group-selection-summary'),
-      createGroupTabList: document.getElementById('create-group-tab-list')
+      createGroupTabList: document.getElementById('create-group-tab-list'),
+      // 搜索增强元素
+      searchClearBtn: document.getElementById('search-clear-btn'),
+      searchSuggestions: document.getElementById('search-suggestions'),
+      searchSuggestionsList: document.getElementById('search-suggestions-list'),
+      clearHistoryBtn: document.getElementById('clear-history-btn'),
+      // 批量操作增强元素
+      batchActions: document.getElementById('batch-actions'),
+      batchSelectAllBtn: document.getElementById('batch-select-all-btn'),
+      batchCloseBtn: document.getElementById('batch-close-btn'),
+      batchSleepBtn: document.getElementById('batch-sleep-btn'),
+      batchMoveBtn: document.getElementById('batch-move-btn')
     };
 
     // Create context menu if it doesn't exist
@@ -84,10 +99,40 @@ class SuperTabSidebar {
   }
 
   setupEventListeners() {
-    // Search functionality
+    // Search functionality - 增强版
     this.elements.searchInput.addEventListener('input', (e) => {
       this.searchQuery = e.target.value;
-      this.filterTabs();
+      this.handleSearchInput(this.searchQuery);
+    });
+
+    this.elements.searchInput.addEventListener('focus', () => {
+      this.showSearchSuggestions();
+    });
+
+    this.elements.searchInput.addEventListener('keydown', (e) => {
+      this.handleSearchKeyDown(e);
+    });
+
+    // 搜索清除按钮
+    if (this.elements.searchClearBtn) {
+      this.elements.searchClearBtn.addEventListener('click', () => {
+        this.clearSearch();
+      });
+    }
+
+    // 清除历史按钮
+    if (this.elements.clearHistoryBtn) {
+      this.elements.clearHistoryBtn.addEventListener('click', () => {
+        this.clearSearchHistory();
+      });
+    }
+
+    // 点击外部关闭搜索建议
+    document.addEventListener('click', (e) => {
+      const searchContainer = document.querySelector('.tf-search-container');
+      if (searchContainer && !searchContainer.contains(e.target)) {
+        this.hideSearchSuggestions();
+      }
     });
 
     // Group switching
@@ -119,6 +164,31 @@ class SuperTabSidebar {
       this.bookmarkSelectedTabs();
     });
 
+    // 批量操作增强按钮
+    if (this.elements.batchSelectAllBtn) {
+      this.elements.batchSelectAllBtn.addEventListener('click', () => {
+        this.toggleSelectAll();
+      });
+    }
+
+    if (this.elements.batchCloseBtn) {
+      this.elements.batchCloseBtn.addEventListener('click', () => {
+        this.closeSelectedTabs();
+      });
+    }
+
+    if (this.elements.batchSleepBtn) {
+      this.elements.batchSleepBtn.addEventListener('click', () => {
+        this.sleepSelectedTabs();
+      });
+    }
+
+    if (this.elements.batchMoveBtn) {
+      this.elements.batchMoveBtn.addEventListener('click', () => {
+        this.showMoveTabsDialog();
+      });
+    }
+
     // Global event listeners
     document.addEventListener('click', (e) => {
       if (!this.contextMenu.contains(e.target)) {
@@ -755,12 +825,39 @@ class SuperTabSidebar {
           this.showNoteDialog(tabUuid);
         }
         break;
+      case 'set-alias':
+        if (tabUuid) {
+          this.showAliasDialog(tabUuid, tabData);
+        }
+        break;
       case 'move-to-group':
         await this.showMoveToGroupDialog(tabUuid);
         break;
       case 'copy-url':
         await this.copyTabUrl(tabData?.url || '');
         break;
+      case 'copy-title':
+        await this.copyTabTitle(tabData?.title || '');
+        break;
+      case 'pin':
+        await this.toggleTabPin(tabId, tabUuid);
+        break;
+      case 'mute':
+        await this.toggleTabMute(tabId, tabUuid);
+        break;
+      case 'discard':
+        await this.discardTab(tabId, tabUuid);
+        break;
+      case 'close-others':
+        if (tabUuid) {
+          await this.closeOtherTabs(tabUuid);
+        }
+        break;
+      case 'close-to-right':
+        if (tabUuid) {
+          await this.closeTabsToRight(tabUuid);
+        }
+        break;
       case 'close':
         if (Number.isInteger(tabId)) {
           await this.closeTab(tabId);
@@ -779,6 +876,18 @@ class SuperTabSidebar {
       case 'collapse-all':
         this.setAllGroupCollapsed(true);
         break;
+      case 'select-all-tabs':
+        await this.selectAllTabsInGroup(groupData);
+        break;
+      case 'close-group-tabs':
+        await this.closeAllTabsInGroup(groupData);
+        break;
+      case 'sleep-group-tabs':
+        await this.sleepAllTabsInGroup(groupData);
+        break;
+      case 'rename-group':
+        await this.renameGroup(groupData);
+        break;
       case 'delete':
         await this.deleteGroupFromContextMenu(groupData);
         break;
@@ -787,12 +896,318 @@ class SuperTabSidebar {
     }
   }
 
-  setAllGroupCollapsed(collapsed) {
-    this.groups = (this.groups || []).map(group => ({
-      ...group,
-      collapsed
-    }));
+  // ========== 新增快捷操作方法 ==========
+
+  async copyTabTitle(title) {
+    const text = typeof title === 'string' ? title.trim() : '';
+    if (!text) {
+      this.showToast('标题为空，无法复制', 'error');
+      return;
+    }
+
+    try {
+      if (navigator.clipboard?.writeText) {
+        await navigator.clipboard.writeText(text);
+      } else {
+        const textArea = document.createElement('textarea');
+        textArea.value = text;
+        document.body.appendChild(textArea);
+        textArea.select();
+        document.execCommand('copy');
+        document.body.removeChild(textArea);
+      }
+      this.showToast('标题已复制', 'success');
+    } catch (error) {
+      console.error('Failed to copy tab title:', error);
+      this.showToast('复制标题失败', 'error');
+    }
+  }
+
+  showAliasDialog(tabUuid, tabData) {
+    if (!tabUuid) return;
+    
+    const currentAlias = tabData?.alias || '';
+    const newAlias = prompt(
+      `请输入标签页别名（留空则清除别名）：`,
+      currentAlias
+    );
+    
+    if (newAlias === null) return;
+    
+    this.setTabAlias(tabUuid, newAlias.trim());
+  }
+
+  async setTabAlias(tabUuid, alias) {
+    try {
+      const response = await chrome.runtime.sendMessage({
+        action: 'setTabAlias',
+        data: {
+          tabUuid,
+          alias
+        }
+      });
+      
+      if (response?.success) {
+        if (alias && alias.trim()) {
+          this.showToast(`已设置别名: ${alias}`, 'success');
+        } else {
+          this.showToast('已清除别名', 'success');
+        }
+        await this.loadData();
+      } else {
+        throw new Error(response?.error || '设置别名失败');
+      }
+    } catch (error) {
+      console.error('Failed to set alias:', error);
+      this.showToast('设置别名失败', 'error');
+    }
+  }
+
+  async toggleTabPin(tabId, tabUuid) {
+    if (!Number.isInteger(tabId)) {
+      this.showToast('无法固定此标签页', 'error');
+      return;
+    }
+
+    try {
+      // 使用 Chrome API 获取当前标签页的固定状态
+      const currentTab = await chrome.tabs.get(tabId);
+      const newPinnedState = !currentTab.pinned;
+      
+      await chrome.tabs.update(tabId, { pinned: newPinnedState });
+      
+      // 更新存储中的标签页数据
+      await chrome.runtime.sendMessage({
+        action: 'updateTabPinned',
+        data: {
+          tabUuid,
+          pinned: newPinnedState
+        }
+      });
+      
+      this.showToast(
+        newPinnedState ? '标签页已固定' : '标签页已取消固定',
+        'success'
+      );
+      await this.loadData();
+    } catch (error) {
+      console.error('Failed to toggle pin:', error);
+      this.showToast('操作失败', 'error');
+    }
+  }
+
+  async toggleTabMute(tabId, tabUuid) {
+    if (!Number.isInteger(tabId)) {
+      this.showToast('无法操作此标签页', 'error');
+      return;
+    }
+
+    try {
+      const currentTab = await chrome.tabs.get(tabId);
+      const newMutedState = !currentTab.mutedInfo?.muted;
+      
+      await chrome.tabs.update(tabId, { muted: newMutedState });
+      
+      this.showToast(
+        newMutedState ? '标签页已静音' : '标签页已取消静音',
+        'success'
+      );
+      await this.loadData();
+    } catch (error) {
+      console.error('Failed to toggle mute:', error);
+      this.showToast('操作失败', 'error');
+    }
+  }
+
+  async discardTab(tabId, tabUuid) {
+    if (!Number.isInteger(tabId)) {
+      this.showToast('无法休眠此标签页', 'error');
+      return;
+    }
+
+    try {
+      // 检查是否是当前活动标签页
+      const currentTab = await chrome.tabs.get(tabId);
+      
+      if (currentTab.active) {
+        this.showToast('无法休眠当前活动标签页', 'info');
+        return;
+      }
+      
+      // 使用 discard API 休眠标签页
+      if (chrome.tabs.discard) {
+        await chrome.tabs.discard(tabId);
+      }
+      
+      // 更新存储中的标签页状态
+      await chrome.runtime.sendMessage({
+        action: 'updateTabDiscarded',
+        data: {
+          tabUuid,
+          discarded: true
+        }
+      });
+      
+      this.showToast('标签页已休眠，内存已释放', 'success');
+      await this.loadData();
+    } catch (error) {
+      console.error('Failed to discard tab:', error);
+      this.showToast('休眠失败', 'error');
+    }
+  }
+
+  async selectAllTabsInGroup(groupData) {
+    if (!groupData) return;
+    
+    const groupTabs = groupData.tabs || [];
+    
+    if (groupTabs.length === 0) {
+      this.showToast('该分组中没有标签页', 'info');
+      return;
+    }
+    
+    // 进入选择模式
+    if (!this.selectionMode) {
+      this.selectionMode = true;
+    }
+    
+    // 选中该分组的所有标签页
+    groupTabs.forEach(tab => {
+      if (tab && tab.uuid) {
+        this.selectedTabUuids.add(tab.uuid);
+      }
+    });
+    
     this.renderGroups();
+    this.updateSelectionUI();
+    this.showToast(`已选中 ${groupTabs.length} 个标签页`, 'success');
+  }
+
+  async closeAllTabsInGroup(groupData) {
+    if (!groupData) return;
+    
+    const groupTabs = groupData.tabs || [];
+    const tabCount = groupTabs.length;
+    
+    if (tabCount === 0) {
+      this.showToast('该分组中没有标签页', 'info');
+      return;
+    }
+    
+    const confirmed = confirm(`确定要关闭分组 "${groupData.name || '未命名分组'}" 中的 ${tabCount} 个标签页吗？`);
+    if (!confirmed) return;
+    
+    try {
+      const chromeTabIds = [];
+      const tabUuids = [];
+      
+      groupTabs.forEach(tab => {
+        if (Number.isInteger(tab.id)) {
+          chromeTabIds.push(tab.id);
+        }
+        if (tab.uuid) {
+          tabUuids.push(tab.uuid);
+        }
+      });
+      
+      // 使用 Chrome API 关闭标签页
+      if (chromeTabIds.length > 0 && chrome.tabs) {
+        await chrome.tabs.remove(chromeTabIds);
+      }
+      
+      // 通知 background
+      await chrome.runtime.sendMessage({
+        action: 'closeTabs',
+        data: {
+          tabUuids,
+          includePinned: false
+        }
+      });
+      
+      this.showToast(`已关闭 ${tabCount} 个标签页`, 'success');
+      await this.loadData();
+    } catch (error) {
+      console.error('Failed to close group tabs:', error);
+      this.showToast('关闭标签页失败', 'error');
+    }
+  }
+
+  async sleepAllTabsInGroup(groupData) {
+    if (!groupData) return;
+    
+    const groupTabs = groupData.tabs || [];
+    const tabCount = groupTabs.length;
+    
+    if (tabCount === 0) {
+      this.showToast('该分组中没有标签页', 'info');
+      return;
+    }
+    
+    const confirmed = confirm(`确定要休眠分组 "${groupData.name || '未命名分组'}" 中的 ${tabCount} 个标签页吗？`);
+    if (!confirmed) return;
+    
+    try {
+      let sleptCount = 0;
+      const activeTabId = this.getCurrentActiveTabId();
+      
+      for (const tab of groupTabs) {
+        if (tab.id === activeTabId) {
+          continue; // 跳过当前活动标签页
+        }
+        
+        try {
+          if (Number.isInteger(tab.id) && chrome.tabs && chrome.tabs.discard) {
+            await chrome.tabs.discard(tab.id);
+            sleptCount++;
+          }
+        } catch (e) {
+          console.warn('Failed to discard tab:', e);
+        }
+      }
+      
+      this.showToast(`已休眠 ${sleptCount} 个标签页，释放内存`, 'success');
+      await this.loadData();
+    } catch (error) {
+      console.error('Failed to sleep group tabs:', error);
+      this.showToast('休眠标签页失败', 'error');
+    }
+  }
+
+  async renameGroup(groupData) {
+    if (!groupData || !groupData.id) return;
+    
+    const currentName = groupData.name || '';
+    const newName = prompt(
+      `请输入新的分组名称：`,
+      currentName
+    );
+    
+    if (newName === null || !newName.trim()) {
+      if (newName !== null) {
+        this.showToast('分组名称不能为空', 'error');
+      }
+      return;
+    }
+    
+    try {
+      const response = await chrome.runtime.sendMessage({
+        action: 'renameGroup',
+        data: {
+          groupId: groupData.id,
+          newName: newName.trim()
+        }
+      });
+      
+      if (response?.success) {
+        this.showToast(`分组已重命名为: ${newName.trim()}`, 'success');
+        await this.loadData();
+      } else {
+        throw new Error(response?.error || '重命名失败');
+      }
+    } catch (error) {
+      console.error('Failed to rename group:', error);
+      this.showToast('重命名失败', 'error');
+    }
   }
 
   async deleteGroupFromContextMenu(groupData) {
@@ -891,6 +1306,10 @@ class SuperTabSidebar {
 
   getContextMenuHTML(context) {
     if (context.type === 'tab') {
+      const tab = context.data || {};
+      const hasNote = tab.note && tab.note.trim();
+      const hasAlias = tab.alias && tab.alias.trim();
+      
       return `
         <div class="tf-menu-item" data-action="activate">
           <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
@@ -899,19 +1318,29 @@ class SuperTabSidebar {
             <line x1="8" y1="12" x2="16" y2="12"/>
           </svg>
           <span>切换到标签页</span>
+          <span class="tf-menu-shortcut">Enter</span>
         </div>
+        <div class="tf-menu-divider"></div>
         <div class="tf-menu-item" data-action="add-note">
           <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
             <path d="M11 4H4a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7"/>
             <path d="M18.5 2.5a2.121 2.121 0 0 1 3 3L12 15l-4 1 1-4 9.5-9.5z"/>
           </svg>
-          <span>添加备注</span>
+          <span>${hasNote ? '编辑备注' : '添加备注'}</span>
+        </div>
+        <div class="tf-menu-item" data-action="set-alias">
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+            <path d="M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2"/>
+            <rect x="8" y="2" width="8" height="4" rx="1" ry="1"/>
+          </svg>
+          <span>${hasAlias ? '编辑别名' : '设置别名'}</span>
         </div>
         <div class="tf-menu-item" data-action="move-to-group">
           <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
             <path d="M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z"/>
           </svg>
           <span>移动到分组</span>
+          <span class="tf-menu-shortcut">M</span>
         </div>
         <div class="tf-menu-item" data-action="copy-url">
           <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
@@ -919,14 +1348,65 @@ class SuperTabSidebar {
             <path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"/>
           </svg>
           <span>复制链接</span>
+          <span class="tf-menu-shortcut">C</span>
+        </div>
+        <div class="tf-menu-item" data-action="copy-title">
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+            <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/>
+            <polyline points="14 2 14 8 20 8"/>
+          </svg>
+          <span>复制标题</span>
+        </div>
+        <div class="tf-menu-divider"></div>
+        <div class="tf-menu-item" data-action="pin">
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+            <line x1="12" y1="17" x2="12" y2="22"/>
+            <path d="M5 17h14v-5a7 7 0 0 0-14 0v5z"/>
+            <path d="M15.13 6.29l-3.13-3.13-3.13 3.13a4 4 0 0 0 0 5.66"/>
+          </svg>
+          <span>${tab.pinned ? '取消固定' : '固定标签页'}</span>
+          <span class="tf-menu-shortcut">P</span>
+        </div>
+        <div class="tf-menu-item" data-action="mute">
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+            <polygon points="11 5 6 9 2 9 2 15 6 15 11 19 11 5"/>
+            <line x1="15.54" y1="8.46" x2="19.07" y2="12"/>
+            <line x1="19.07" y1="8.46" x2="15.54" y2="12"/>
+          </svg>
+          <span>${tab.muted ? '取消静音' : '静音标签页'}</span>
+        </div>
+        <div class="tf-menu-item" data-action="discard">
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+            <path d="M17 18a5 5 0 0 0-10 0"/>
+            <path d="M12 14V2"/>
+            <path d="M4.93 10.93A17 17 0 0 1 12 9a17 17 0 0 1 7.07 1.93"/>
+          </svg>
+          <span>休眠标签页</span>
         </div>
         <div class="tf-menu-divider"></div>
+        <div class="tf-menu-item" data-action="close-others">
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+            <line x1="18" y1="6" x2="6" y2="18"/>
+            <line x1="6" y1="6" x2="18" y2="18"/>
+            <rect x="3" y="3" width="18" height="18" rx="2" ry="2" stroke-dasharray="4 4"/>
+          </svg>
+          <span>关闭其他标签页</span>
+        </div>
+        <div class="tf-menu-item" data-action="close-to-right">
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+            <line x1="13" y1="6" x2="18" y2="18"/>
+            <line x1="18" y1="6" x2="13" y2="18"/>
+            <line x1="12" y1="4" x2="12" y2="20"/>
+          </svg>
+          <span>关闭右侧标签页</span>
+        </div>
         <div class="tf-menu-item danger" data-action="close">
           <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
             <polyline points="3 6 5 6 21 6"/>
             <path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"/>
           </svg>
           <span>关闭标签页</span>
+          <span class="tf-menu-shortcut">Del</span>
         </div>
       `;
     } else if (context.type === 'group') {
@@ -950,6 +1430,36 @@ class SuperTabSidebar {
           <span>折叠所有</span>
         </div>
         <div class="tf-menu-divider"></div>
+        <div class="tf-menu-item" data-action="select-all-tabs">
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+            <path d="M9 11l3 3L22 4"/>
+            <path d="M21 12v7a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h11"/>
+          </svg>
+          <span>选中所有标签页</span>
+        </div>
+        <div class="tf-menu-item" data-action="close-group-tabs">
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+            <polyline points="3 6 5 6 21 6"/>
+            <path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"/>
+          </svg>
+          <span>关闭分组内标签页</span>
+        </div>
+        <div class="tf-menu-item" data-action="sleep-group-tabs">
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+            <path d="M17 18a5 5 0 0 0-10 0"/>
+            <path d="M12 14V2"/>
+            <path d="M4.93 10.93A17 17 0 0 1 12 9a17 17 0 0 1 7.07 1.93"/>
+          </svg>
+          <span>休眠分组内标签页</span>
+        </div>
+        <div class="tf-menu-divider"></div>
+        <div class="tf-menu-item" data-action="rename-group">
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+            <path d="M11 4H4a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7"/>
+            <path d="M18.5 2.5a2.121 2.121 0 0 1 3 3L12 15l-4 1 1-4 9.5-9.5z"/>
+          </svg>
+          <span>重命名分组</span>
+        </div>
         <div class="tf-menu-item danger" data-action="delete">
           <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
             <polyline points="3 6 5 6 21 6"/>
@@ -965,12 +1475,51 @@ class SuperTabSidebar {
 
   filterTabs() {
     const query = this.searchQuery.toLowerCase().trim();
+    
+    // 初始化搜索引擎（如果尚未初始化）
+    if (!this.searchEngine && typeof TabSearchEngine !== 'undefined') {
+      this.searchEngine = new TabSearchEngine({
+        debounceDelay: 150,
+        maxHistoryItems: 20
+      });
+    }
+    
     if (!query) {
+      this.hideSearchSuggestions();
+      this.updateSearchClearButton(false);
       this.renderGroups();
       return;
     }
+    
+    this.updateSearchClearButton(true);
+    
+    // 使用增强的搜索引擎（如果可用）
+    if (this.searchEngine) {
+      this.performEnhancedSearch(query);
+    } else {
+      // 降级到原有搜索方式
+      this.performLegacySearch(query);
+    }
+  }
+
+  performEnhancedSearch(query) {
+    // 获取所有标签页
+    const allTabs = this.getAllTabs();
+    
+    // 执行增强搜索
+    this.searchResults = this.searchEngine.search(allTabs, query, {
+      searchFields: ['title', 'alias', 'url', 'note', 'domain'],
+      sortBy: 'relevance'
+    });
+    
+    // 按分组重新组织结果
+    const filteredGroups = this.organizeResultsByGroups(this.searchResults);
+    
+    // 渲染过滤结果
+    this.renderFilteredResults(filteredGroups);
+  }
 
-    // Filter groups based on search query
+  performLegacySearch(query) {
     const filteredGroups = this.groups.map(group => ({
       ...group,
       tabs: group.tabs ? group.tabs.filter(tab =>
@@ -980,15 +1529,79 @@ class SuperTabSidebar {
         (tab.note && tab.note.toLowerCase().includes(query))
       ) : []
     })).filter(group => group.tabs.length > 0);
+    
+    this.renderFilteredResults(filteredGroups);
+  }
 
-    // Render filtered results
+  getAllTabs() {
+    const tabs = [];
+    for (const group of this.groups) {
+      if (group.tabs && Array.isArray(group.tabs)) {
+        tabs.push(...group.tabs);
+      }
+    }
+    return tabs;
+  }
+
+  organizeResultsByGroups(searchResults) {
+    if (!searchResults || searchResults.length === 0) {
+      return [];
+    }
+    
+    const groupMap = new Map();
+    
+    for (const result of searchResults) {
+      const tab = result.tab;
+      const groupId = tab.groupId || 'unknown';
+      
+      if (!groupMap.has(groupId)) {
+        // 查找原始分组信息
+        const originalGroup = this.groups.find(g => g.id === groupId);
+        groupMap.set(groupId, {
+          id: groupId,
+          name: originalGroup ? originalGroup.name : (groupId.startsWith('domain_') ? this.getDomainGroupName(groupId) : '其他'),
+          type: originalGroup ? originalGroup.type : 'search',
+          tabs: []
+        });
+      }
+      
+      const group = groupMap.get(groupId);
+      group.tabs.push(tab);
+    }
+    
+    return Array.from(groupMap.values());
+  }
+
+  getDomainGroupName(groupId) {
+    if (!groupId) return '其他';
+    const parts = groupId.split('domain_');
+    return parts.length > 1 ? parts[1] : '其他';
+  }
+
+  renderFilteredResults(filteredGroups) {
     const container = this.elements[`${this.currentGroup}Groups`];
+    if (!container) return;
+    
     container.innerHTML = '';
 
     if (filteredGroups.length === 0) {
-      container.innerHTML = '<div class="tf-empty-state">🔍 未找到匹配的标签页</div>';
+      container.innerHTML = this.getSearchEmptyState();
       return;
     }
+    
+    // 显示搜索结果统计
+    const totalResults = filteredGroups.reduce((sum, g) => sum + (g.tabs ? g.tabs.length : 0), 0);
+    const statsHtml = `
+      <div class="tf-search-stats">
+        <span class="tf-search-results-count">
+          🔍 找到 ${totalResults} 个匹配的标签页
+        </span>
+      </div>
+    `;
+    
+    const statsContainer = document.createElement('div');
+    statsContainer.innerHTML = statsHtml;
+    container.appendChild(statsContainer);
 
     filteredGroups.forEach(group => {
       const groupElement = document.createElement('group-item');
@@ -1000,6 +1613,356 @@ class SuperTabSidebar {
     });
   }
 
+  getSearchEmptyState() {
+    const query = this.searchQuery || '';
+    return `
+      <div class="tf-empty-state">
+        <div class="tf-empty-icon">🔍</div>
+        <div class="tf-empty-title">未找到匹配的标签页</div>
+        <div class="tf-empty-subtitle">没有包含 "${this.escapeHtml(query)}" 的标签页</div>
+        <div class="tf-empty-tips">
+          <p>💡 提示：</p>
+          <ul>
+            <li>尝试使用更短的关键词</li>
+            <li>使用引号进行精确匹配，如 "GitHub"</li>
+            <li>使用 field:value 限定字段，如 title:GitHub</li>
+          </ul>
+        </div>
+      </div>
+    `;
+  }
+
+  escapeHtml(text) {
+    if (!text) return '';
+    const div = document.createElement('div');
+    div.textContent = text;
+    return div.innerHTML;
+  }
+
+  // ========== 搜索增强方法 ==========
+
+  handleSearchInput(query) {
+    this.searchQuery = query;
+    
+    // 更新清除按钮状态
+    this.updateSearchClearButton(query && query.length > 0);
+    
+    // 如果有输入内容，显示搜索建议
+    if (query && query.length > 0) {
+      this.showSearchSuggestions();
+    }
+    
+    // 执行过滤（防抖处理）
+    if (this.searchEngine) {
+      this.searchEngine.debouncedSearch(
+        (results, q) => this.onSearchComplete(results, q),
+        this.getAllTabs(),
+        query
+      );
+    } else {
+      this.filterTabs();
+    }
+  }
+
+  onSearchComplete(results, query) {
+    // 只有当查询仍然匹配时才更新结果
+    if (query === this.searchQuery) {
+      this.searchResults = results;
+      this.filterTabs();
+    }
+  }
+
+  updateSearchClearButton(show) {
+    if (!this.elements.searchClearBtn) return;
+    
+    if (show) {
+      this.elements.searchClearBtn.classList.remove('tf-hidden');
+    } else {
+      this.elements.searchClearBtn.classList.add('tf-hidden');
+    }
+  }
+
+  clearSearch() {
+    this.searchQuery = '';
+    if (this.elements.searchInput) {
+      this.elements.searchInput.value = '';
+    }
+    this.hideSearchSuggestions();
+    this.updateSearchClearButton(false);
+    this.searchResults = [];
+    this.renderGroups();
+    
+    if (this.elements.searchInput) {
+      this.elements.searchInput.focus();
+    }
+  }
+
+  showSearchSuggestions() {
+    if (!this.elements.searchSuggestions || !this.elements.searchSuggestionsList) return;
+    
+    // 初始化搜索引擎
+    if (!this.searchEngine && typeof TabSearchEngine !== 'undefined') {
+      this.searchEngine = new TabSearchEngine({
+        debounceDelay: 150,
+        maxHistoryItems: 20
+      });
+    }
+    
+    if (!this.searchEngine) {
+      return;
+    }
+    
+    // 获取建议
+    const suggestions = this.searchEngine.getSearchSuggestions(
+      this.searchQuery || '',
+      this.getAllTabs()
+    );
+    
+    if (suggestions.length === 0 && (!this.searchQuery || this.searchQuery.trim() === '')) {
+      // 如果没有输入，显示历史记录
+      const history = this.searchEngine.getSearchHistory(8);
+      if (history.length > 0) {
+        this.renderSearchHistory(history);
+        this.elements.searchSuggestions.classList.remove('tf-hidden');
+      } else {
+        this.hideSearchSuggestions();
+      }
+      return;
+    }
+    
+    if (suggestions.length === 0) {
+      this.hideSearchSuggestions();
+      return;
+    }
+    
+    this.renderSearchSuggestions(suggestions);
+    this.elements.searchSuggestions.classList.remove('tf-hidden');
+  }
+
+  renderSearchHistory(history) {
+    if (!this.elements.searchSuggestionsList) return;
+    
+    // 显示清除历史按钮
+    if (this.elements.clearHistoryBtn && history.length > 0) {
+      this.elements.clearHistoryBtn.classList.remove('tf-hidden');
+    }
+    
+    this.elements.searchSuggestionsList.innerHTML = history.map((item, index) => `
+      <div class="tf-search-suggestion-item" 
+           data-index="${index}" 
+           data-query="${this.escapeHtml(item.query)}"
+           data-type="history">
+        <span class="tf-suggestion-icon">🕐</span>
+        <span class="tf-suggestion-text">${this.escapeHtml(item.query)}</span>
+        <span class="tf-suggestion-meta">${this.formatTimestamp(item.timestamp)}</span>
+      </div>
+    `).join('');
+    
+    this.bindSuggestionEvents();
+  }
+
+  renderSearchSuggestions(suggestions) {
+    if (!this.elements.searchSuggestionsList) return;
+    
+    // 隐藏清除历史按钮（当有输入时）
+    if (this.elements.clearHistoryBtn) {
+      this.elements.clearHistoryBtn.classList.add('tf-hidden');
+    }
+    
+    this.elements.searchSuggestionsList.innerHTML = suggestions.map((suggestion, index) => {
+      const icon = this.getSuggestionIcon(suggestion.type);
+      const label = this.highlightSuggestionText(suggestion.label, this.searchQuery);
+      
+      return `
+        <div class="tf-search-suggestion-item" 
+             data-index="${index}" 
+             data-query="${this.escapeHtml(suggestion.query)}"
+             data-type="${suggestion.type}">
+          <span class="tf-suggestion-icon">${icon}</span>
+          <span class="tf-suggestion-text">${label}</span>
+          <span class="tf-suggestion-type">${this.getSuggestionTypeLabel(suggestion.type)}</span>
+        </div>
+      `;
+    }).join('');
+    
+    this.bindSuggestionEvents();
+  }
+
+  getSuggestionIcon(type) {
+    const icons = {
+      'history': '🕐',
+      'title': '📄',
+      'domain': '🌐',
+      'note': '📝',
+      'url': '🔗'
+    };
+    return icons[type] || '🔍';
+  }
+
+  getSuggestionTypeLabel(type) {
+    const labels = {
+      'history': '历史',
+      'title': '标题',
+      'domain': '域名',
+      'note': '备注',
+      'url': 'URL'
+    };
+    return labels[type] || '搜索';
+  }
+
+  highlightSuggestionText(text, query) {
+    if (!query || query.trim() === '') {
+      return this.escapeHtml(text);
+    }
+    
+    const lowerText = text.toLowerCase();
+    const lowerQuery = query.toLowerCase();
+    
+    const index = lowerText.indexOf(lowerQuery);
+    if (index === -1) {
+      return this.escapeHtml(text);
+    }
+    
+    const before = text.substring(0, index);
+    const match = text.substring(index, index + query.length);
+    const after = text.substring(index + query.length);
+    
+    return `${this.escapeHtml(before)}<span class="tf-suggestion-highlight">${this.escapeHtml(match)}</span>${this.escapeHtml(after)}`;
+  }
+
+  formatTimestamp(timestamp) {
+    const now = Date.now();
+    const diff = now - timestamp;
+    
+    const minutes = Math.floor(diff / 60000);
+    const hours = Math.floor(diff / 3600000);
+    const days = Math.floor(diff / 86400000);
+    
+    if (minutes < 1) return '刚刚';
+    if (minutes < 60) return `${minutes}分钟前`;
+    if (hours < 24) return `${hours}小时前`;
+    if (days < 7) return `${days}天前`;
+    
+    const date = new Date(timestamp);
+    return `${date.getMonth() + 1}/${date.getDate()}`;
+  }
+
+  bindSuggestionEvents() {
+    if (!this.elements.searchSuggestionsList) return;
+    
+    const items = this.elements.searchSuggestionsList.querySelectorAll('.tf-search-suggestion-item');
+    items.forEach(item => {
+      item.addEventListener('click', () => {
+        const query = item.dataset.query;
+        if (query) {
+          this.applySuggestion(query);
+        }
+      });
+      
+      item.addEventListener('mouseenter', () => {
+        items.forEach(i => i.classList.remove('tf-suggestion-active'));
+        item.classList.add('tf-suggestion-active');
+      });
+    });
+  }
+
+  applySuggestion(query) {
+    if (!query) return;
+    
+    this.searchQuery = query;
+    if (this.elements.searchInput) {
+      this.elements.searchInput.value = query;
+    }
+    
+    this.hideSearchSuggestions();
+    this.filterTabs();
+  }
+
+  hideSearchSuggestions() {
+    if (this.elements.searchSuggestions) {
+      this.elements.searchSuggestions.classList.add('tf-hidden');
+    }
+  }
+
+  handleSearchKeyDown(e) {
+    const suggestionsList = this.elements.searchSuggestionsList;
+    const suggestions = suggestionsList ? 
+      suggestionsList.querySelectorAll('.tf-search-suggestion-item') : [];
+    
+    if (!suggestions || suggestions.length === 0) {
+      if (e.key === 'Escape') {
+        this.clearSearch();
+      }
+      return;
+    }
+    
+    let activeIndex = -1;
+    suggestions.forEach((item, index) => {
+      if (item.classList.contains('tf-suggestion-active')) {
+        activeIndex = index;
+      }
+    });
+    
+    switch (e.key) {
+      case 'ArrowDown':
+        e.preventDefault();
+        suggestions.forEach(item => item.classList.remove('tf-suggestion-active'));
+        if (activeIndex < suggestions.length - 1) {
+          suggestions[activeIndex + 1].classList.add('tf-suggestion-active');
+        } else {
+          suggestions[0].classList.add('tf-suggestion-active');
+        }
+        break;
+        
+      case 'ArrowUp':
+        e.preventDefault();
+        suggestions.forEach(item => item.classList.remove('tf-suggestion-active'));
+        if (activeIndex > 0) {
+          suggestions[activeIndex - 1].classList.add('tf-suggestion-active');
+        } else {
+          suggestions[suggestions.length - 1].classList.add('tf-suggestion-active');
+        }
+        break;
+        
+      case 'Enter':
+        e.preventDefault();
+        const activeItem = suggestionsList.querySelector('.tf-suggestion-active');
+        if (activeItem && activeItem.dataset.query) {
+          this.applySuggestion(activeItem.dataset.query);
+        } else {
+          // 如果没有选中的建议，直接使用当前输入
+          this.hideSearchSuggestions();
+          this.filterTabs();
+        }
+        break;
+        
+      case 'Escape':
+        e.preventDefault();
+        if (this.searchQuery && this.searchQuery.length > 0) {
+          this.hideSearchSuggestions();
+        } else {
+          this.clearSearch();
+        }
+        break;
+        
+      case 'Tab':
+        // Tab 键选择当前高亮的建议
+        const highlightedItem = suggestionsList.querySelector('.tf-suggestion-active');
+        if (highlightedItem && highlightedItem.dataset.query) {
+          e.preventDefault();
+          this.applySuggestion(highlightedItem.dataset.query);
+        }
+        break;
+    }
+  }
+
+  clearSearchHistory() {
+    if (this.searchEngine) {
+      this.searchEngine.clearSearchHistory();
+    }
+    this.hideSearchSuggestions();
+  }
+
   updateStats() {
     this.elements.tabCount.textContent = `${this.tabs.length} 个标签页`;
     this.elements.groupCount.textContent = `${this.groups.length} 个分组`;
@@ -1264,10 +2227,476 @@ class SuperTabSidebar {
 
   updateSelectionUI() {
     const selectedCount = this.selectedTabUuids.size;
+    const totalTabs = this.getAllTabs().length;
+    const allSelected = totalTabs > 0 && selectedCount === totalTabs;
+    const someSelected = selectedCount > 0 && selectedCount < totalTabs;
+    
     this.elements.selectModeBtn.classList.toggle('active', this.selectionMode);
-    this.elements.batchFavoriteBtn.classList.toggle('tf-hidden', !this.selectionMode);
-    this.elements.batchFavoriteBtn.disabled = selectedCount === 0;
-    this.elements.batchFavoriteBtn.querySelector('span').textContent = `转收藏选中 (${selectedCount})`;
+    
+    // 更新批量操作按钮显示
+    if (this.elements.batchActions) {
+      this.elements.batchActions.classList.toggle('tf-hidden', !this.selectionMode);
+    }
+    
+    // 更新全选按钮状态
+    if (this.elements.batchSelectAllBtn) {
+      const btnSpan = this.elements.batchSelectAllBtn.querySelector('span');
+      if (btnSpan) {
+        if (allSelected) {
+          btnSpan.textContent = '取消全选';
+          this.elements.batchSelectAllBtn.classList.add('active');
+        } else {
+          btnSpan.textContent = '全选';
+          this.elements.batchSelectAllBtn.classList.remove('active');
+        }
+      }
+      
+      // 添加部分选中状态
+      if (someSelected) {
+        this.elements.batchSelectAllBtn.classList.add('partial');
+      } else {
+        this.elements.batchSelectAllBtn.classList.remove('partial');
+      }
+    }
+    
+    // 更新按钮禁用状态和计数
+    const buttonsToUpdate = [
+      { element: this.elements.batchCloseBtn, label: '关闭' },
+      { element: this.elements.batchSleepBtn, label: '休眠' },
+      { element: this.elements.batchMoveBtn, label: '移动' },
+      { element: this.elements.batchFavoriteBtn, label: '收藏' }
+    ];
+    
+    buttonsToUpdate.forEach(({ element, label }) => {
+      if (element) {
+        element.disabled = selectedCount === 0;
+        const span = element.querySelector('span');
+        if (span) {
+          span.textContent = selectedCount > 0 ? `${label} (${selectedCount})` : label;
+        }
+      }
+    });
+  }
+
+  // ========== 批量操作增强方法 ==========
+
+  toggleSelectAll() {
+    const allTabs = this.getAllTabs();
+    const totalTabs = allTabs.length;
+    const selectedCount = this.selectedTabUuids.size;
+    const allSelected = totalTabs > 0 && selectedCount === totalTabs;
+    
+    if (allSelected) {
+      // 取消全选
+      this.selectedTabUuids.clear();
+    } else {
+      // 全选
+      allTabs.forEach(tab => {
+        if (tab && tab.uuid) {
+          this.selectedTabUuids.add(tab.uuid);
+        }
+      });
+    }
+    
+    this.renderGroups();
+    this.updateSelectionUI();
+  }
+
+  async closeSelectedTabs() {
+    const tabUuids = Array.from(this.selectedTabUuids);
+    if (tabUuids.length === 0) {
+      this.showToast('请先勾选标签页', 'info');
+      return;
+    }
+    
+    const selectedTabs = this.getAllTabs().filter(tab => tabUuids.includes(tab.uuid));
+    const normalTabs = selectedTabs.filter(tab => !tab.pinned);
+    const pinnedTabs = selectedTabs.filter(tab => tab.pinned);
+    
+    // 如果有固定标签页，询问用户
+    if (pinnedTabs.length > 0) {
+      const confirmed = confirm(`您选中了 ${pinnedTabs.length} 个固定标签页，确定要关闭它们吗？\n\n将同时关闭 ${normalTabs.length} 个普通标签页。`);
+      if (!confirmed) {
+        return;
+      }
+    }
+    
+    try {
+      // 获取选中标签页的 Chrome tab ID
+      const chromeTabIds = [];
+      selectedTabs.forEach(tab => {
+        if (tab.chromeTabId !== undefined && tab.chromeTabId !== null) {
+          chromeTabIds.push(tab.chromeTabId);
+        }
+      });
+      
+      // 如果有 Chrome tab ID，直接使用 Chrome API 关闭
+      if (chromeTabIds.length > 0 && typeof chrome !== 'undefined' && chrome.tabs) {
+        await chrome.tabs.remove(chromeTabIds);
+      }
+      
+      // 通过 background 关闭标签页（包含固定标签页）
+      const response = await chrome.runtime.sendMessage({
+        action: 'closeTabs',
+        data: {
+          tabUuids: tabUuids,
+          includePinned: pinnedTabs.length > 0
+        }
+      });
+      
+      if (response?.success) {
+        const closedCount = response.closedCount || tabUuids.length;
+        this.showToast(`已关闭 ${closedCount} 个标签页`, 'success');
+        
+        // 清除选中状态
+        this.selectedTabUuids.clear();
+        
+        // 刷新数据
+        await this.loadData();
+        this.updateSelectionUI();
+      } else {
+        throw new Error(response?.error || '关闭标签页失败');
+      }
+    } catch (error) {
+      console.error('Failed to close tabs:', error);
+      this.showToast('关闭标签页失败', 'error');
+    }
+  }
+
+  async sleepSelectedTabs() {
+    const tabUuids = Array.from(this.selectedTabUuids);
+    if (tabUuids.length === 0) {
+      this.showToast('请先勾选标签页', 'info');
+      return;
+    }
+    
+    const selectedTabs = this.getAllTabs().filter(tab => tabUuids.includes(tab.uuid));
+    const activeTabId = this.getCurrentActiveTabId();
+    
+    // 过滤掉当前活动标签页（不能休眠当前活动标签页）
+    const tabsToSleep = selectedTabs.filter(tab => 
+      tab.chromeTabId !== activeTabId
+    );
+    
+    if (tabsToSleep.length === 0) {
+      this.showToast('无法休眠当前活动标签页', 'info');
+      return;
+    }
+    
+    try {
+      // 构建 tabIds 列表
+      const chromeTabIds = [];
+      tabsToSleep.forEach(tab => {
+        if (tab.chromeTabId !== undefined && tab.chromeTabId !== null) {
+          chromeTabIds.push(tab.chromeTabId);
+        }
+      });
+      
+      // 使用 Chrome API 休眠标签页（如果可用）
+      if (chromeTabIds.length > 0 && typeof chrome !== 'undefined' && chrome.tabs) {
+        // 使用 discard API 释放标签页内存
+        for (const tabId of chromeTabIds) {
+          try {
+            if (chrome.tabs.discard) {
+              await chrome.tabs.discard(tabId);
+            }
+          } catch (e) {
+            console.warn('Failed to discard tab:', e);
+          }
+        }
+      }
+      
+      // 标记标签页为休眠状态
+      const response = await chrome.runtime.sendMessage({
+        action: 'sleepTabs',
+        data: {
+          tabUuids: tabsToSleep.map(t => t.uuid)
+        }
+      });
+      
+      if (response?.success) {
+        const sleptCount = response.sleptCount || tabsToSleep.length;
+        this.showToast(`已休眠 ${sleptCount} 个标签页，释放内存`, 'success');
+        
+        // 清除选中状态
+        this.selectedTabUuids.clear();
+        
+        // 刷新数据
+        await this.loadData();
+        this.updateSelectionUI();
+      } else {
+        throw new Error(response?.error || '休眠标签页失败');
+      }
+    } catch (error) {
+      console.error('Failed to sleep tabs:', error);
+      this.showToast('休眠标签页失败', 'error');
+    }
+  }
+
+  getCurrentActiveTabId() {
+    // 获取所有标签页中当前活动的标签页
+    const allTabs = this.getAllTabs();
+    const activeTabs = allTabs.filter(tab => tab.active);
+    return activeTabs.length > 0 ? activeTabs[0].chromeTabId : null;
+  }
+
+  async showMoveTabsDialog() {
+    const tabUuids = Array.from(this.selectedTabUuids);
+    if (tabUuids.length === 0) {
+      this.showToast('请先勾选标签页', 'info');
+      return;
+    }
+    
+    try {
+      // 获取所有窗口信息
+      const response = await chrome.runtime.sendMessage({
+        action: 'listWindows'
+      });
+      
+      if (!response?.success) {
+        throw new Error(response?.error || '无法获取窗口列表');
+      }
+      
+      const windows = Array.isArray(response.data) ? response.data : [];
+      
+      if (windows.length <= 1) {
+        this.showToast('只有一个窗口，无法移动标签页', 'info');
+        return;
+      }
+      
+      // 显示窗口选择对话框
+      const targetWindow = await this.showWindowSelectionDialog(windows, tabUuids.length);
+      
+      if (targetWindow) {
+        await this.moveSelectedTabsToWindow(tabUuids, targetWindow.id);
+      }
+    } catch (error) {
+      console.error('Failed to show move dialog:', error);
+      this.showToast('移动标签页失败', 'error');
+    }
+  }
+
+  async showWindowSelectionDialog(windows, tabCount) {
+    return new Promise((resolve) => {
+      // 构建窗口选项
+      let windowListHtml = windows.map((win, index) => {
+        const tabCountInWindow = win.tabCount || 0;
+        const isCurrentWindow = win.focused;
+        const windowType = win.type === 'normal' ? '普通窗口' : win.type;
+        const activeIndicator = isCurrentWindow ? ' (当前)' : '';
+        
+        return `
+          <div class="tf-window-option ${isCurrentWindow ? 'tf-window-current' : ''}" 
+               data-window-id="${win.id}"
+               style="padding: 12px; border-bottom: 1px solid var(--tf-border-light); cursor: pointer;">
+            <div style="font-weight: 500; color: var(--tf-text-primary);">
+              窗口 ${index + 1}${activeIndicator}
+            </div>
+            <div style="font-size: 12px; color: var(--tf-text-muted); margin-top: 4px;">
+              ${tabCountInWindow} 个标签页 · ${windowType}
+            </div>
+          </div>
+        `;
+      }).join('');
+      
+      // 创建对话框
+      const dialogHtml = `
+        <div id="move-tabs-dialog" class="tf-modal" style="z-index: 10050;">
+          <div class="tf-modal-backdrop" data-action="close-move-dialog"></div>
+          <div class="tf-modal-panel" style="max-height: 400px;">
+            <div class="tf-modal-header">
+              <h2>移动 ${tabCount} 个标签页到</h2>
+              <button id="move-dialog-close-btn" class="tf-btn tf-btn-icon" type="button">
+                <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                  <line x1="18" y1="6" x2="6" y2="18"/>
+                  <line x1="6" y1="6" x2="18" y2="18"/>
+                </svg>
+              </button>
+            </div>
+            <div class="tf-modal-body" style="padding: 0; overflow-y: auto;">
+              ${windowListHtml}
+            </div>
+            <div class="tf-modal-footer" style="justify-content: flex-end;">
+              <button id="move-dialog-cancel-btn" class="tf-btn tf-btn-secondary" type="button">取消</button>
+            </div>
+          </div>
+        </div>
+      `;
+      
+      // 插入到文档
+      const tempDiv = document.createElement('div');
+      tempDiv.innerHTML = dialogHtml;
+      const dialog = tempDiv.firstElementChild;
+      document.body.appendChild(dialog);
+      
+      // 绑定事件
+      const closeDialog = () => {
+        dialog.remove();
+        resolve(null);
+      };
+      
+      const selectWindow = (windowId) => {
+        const targetWindow = windows.find(w => w.id === parseInt(windowId));
+        dialog.remove();
+        resolve(targetWindow);
+      };
+      
+      // 点击窗口选项
+      const windowOptions = dialog.querySelectorAll('.tf-window-option');
+      windowOptions.forEach(option => {
+        option.addEventListener('click', () => {
+          selectWindow(option.dataset.windowId);
+        });
+        
+        option.addEventListener('mouseenter', () => {
+          option.style.background = 'var(--tf-bg-hover)';
+        });
+        
+        option.addEventListener('mouseleave', () => {
+          option.style.background = '';
+        });
+      });
+      
+      // 关闭按钮
+      const closeBtn = dialog.querySelector('#move-dialog-close-btn');
+      const cancelBtn = dialog.querySelector('#move-dialog-cancel-btn');
+      const backdrop = dialog.querySelector('[data-action="close-move-dialog"]');
+      
+      if (closeBtn) closeBtn.addEventListener('click', closeDialog);
+      if (cancelBtn) cancelBtn.addEventListener('click', closeDialog);
+      if (backdrop) backdrop.addEventListener('click', closeDialog);
+      
+      // ESC 键关闭
+      const handleKeyDown = (e) => {
+        if (e.key === 'Escape') {
+          document.removeEventListener('keydown', handleKeyDown);
+          closeDialog();
+        }
+      };
+      document.addEventListener('keydown', handleKeyDown);
+    });
+  }
+
+  async moveSelectedTabsToWindow(tabUuids, targetWindowId) {
+    try {
+      const selectedTabs = this.getAllTabs().filter(tab => tabUuids.includes(tab.uuid));
+      const chromeTabIds = [];
+      
+      selectedTabs.forEach(tab => {
+        if (tab.chromeTabId !== undefined && tab.chromeTabId !== null) {
+          chromeTabIds.push(tab.chromeTabId);
+        }
+      });
+      
+      if (chromeTabIds.length === 0) {
+        throw new Error('没有可移动的标签页');
+      }
+      
+      // 使用 Chrome API 移动标签页
+      if (typeof chrome !== 'undefined' && chrome.tabs) {
+        await chrome.tabs.move(chromeTabIds, {
+          windowId: targetWindowId,
+          index: -1 // 添加到窗口末尾
+        });
+      }
+      
+      // 通知 background 更新状态
+      await chrome.runtime.sendMessage({
+        action: 'moveTabsToWindow',
+        data: {
+          tabUuids: tabUuids,
+          targetWindowId: targetWindowId
+        }
+      });
+      
+      this.showToast(`已移动 ${chromeTabIds.length} 个标签页`, 'success');
+      
+      // 清除选中状态
+      this.selectedTabUuids.clear();
+      
+      // 刷新数据
+      await this.loadData();
+      this.updateSelectionUI();
+      
+    } catch (error) {
+      console.error('Failed to move tabs:', error);
+      this.showToast('移动标签页失败: ' + error.message, 'error');
+    }
+  }
+
+  // 批量关闭其他标签页（右键菜单使用）
+  async closeOtherTabs(currentTabUuid) {
+    try {
+      const confirmed = confirm('确定要关闭除此标签页以外的所有标签页吗？');
+      if (!confirmed) return;
+      
+      const allTabs = this.getAllTabs();
+      const tabsToClose = allTabs.filter(tab => 
+        tab.uuid !== currentTabUuid && !tab.pinned
+      );
+      
+      if (tabsToClose.length === 0) {
+        this.showToast('没有需要关闭的标签页', 'info');
+        return;
+      }
+      
+      const response = await chrome.runtime.sendMessage({
+        action: 'closeTabs',
+        data: {
+          tabUuids: tabsToClose.map(t => t.uuid),
+          includePinned: false
+        }
+      });
+      
+      if (response?.success) {
+        const closedCount = response.closedCount || tabsToClose.length;
+        this.showToast(`已关闭 ${closedCount} 个标签页`, 'success');
+        await this.loadData();
+      }
+    } catch (error) {
+      console.error('Failed to close other tabs:', error);
+      this.showToast('关闭标签页失败', 'error');
+    }
+  }
+
+  // 批量关闭右侧标签页（右键菜单使用）
+  async closeTabsToRight(currentTabUuid) {
+    try {
+      const confirmed = confirm('确定要关闭此标签页右侧的所有标签页吗？');
+      if (!confirmed) return;
+      
+      const allTabs = this.getAllTabs();
+      const currentIndex = allTabs.findIndex(tab => tab.uuid === currentTabUuid);
+      
+      if (currentIndex === -1) {
+        this.showToast('无法找到当前标签页', 'error');
+        return;
+      }
+      
+      const tabsToClose = allTabs.slice(currentIndex + 1).filter(tab => !tab.pinned);
+      
+      if (tabsToClose.length === 0) {
+        this.showToast('右侧没有需要关闭的标签页', 'info');
+        return;
+      }
+      
+      const response = await chrome.runtime.sendMessage({
+        action: 'closeTabs',
+        data: {
+          tabUuids: tabsToClose.map(t => t.uuid),
+          includePinned: false
+        }
+      });
+      
+      if (response?.success) {
+        const closedCount = response.closedCount || tabsToClose.length;
+        this.showToast(`已关闭 ${closedCount} 个标签页`, 'success');
+        await this.loadData();
+      }
+    } catch (error) {
+      console.error('Failed to close tabs to right:', error);
+      this.showToast('关闭标签页失败', 'error');
+    }
   }
 
   async bookmarkSelectedTabs() {
diff --git a/utils/grouping-engine.js b/utils/grouping-engine.js
index 1f29f8a..402fce3 100644
--- a/utils/grouping-engine.js
+++ b/utils/grouping-engine.js
@@ -4,34 +4,231 @@ class GroupingEngine {
   constructor() {
     this.domainGroups = new Map();
     this.dateGroups = new Map();
+    
+    // Common domain patterns for smart grouping
+    this.domainPatterns = {
+      'google.com': ['google.com', 'google.co.uk', 'google.co.jp', 'google.fr', 'google.de'],
+      'github.com': ['github.com', 'gist.github.com', 'pages.github.com'],
+      'amazon.com': ['amazon.com', 'amazon.co.uk', 'amazon.co.jp', 'amazon.fr', 'amazon.de'],
+      'microsoft.com': ['microsoft.com', 'office.com', 'onedrive.com', 'outlook.com', 'azure.com'],
+      'apple.com': ['apple.com', 'icloud.com', 'itunes.com', 'appstore.com'],
+      'alibaba.com': ['alibaba.com', 'taobao.com', 'tmall.com', 'aliexpress.com'],
+      'tencent.com': ['qq.com', 'weixin.qq.com', 'tencent.com', 'wechat.com'],
+      'baidu.com': ['baidu.com', 'tieba.baidu.com', 'zhidao.baidu.com', 'map.baidu.com'],
+      'bilibili.com': ['bilibili.com', 'bilibili.tv', 'bilibili.net'],
+      'jd.com': ['jd.com', 'jd.hk', 'jd.co.jp'],
+      'netflix.com': ['netflix.com', 'netflix.net'],
+      'youtube.com': ['youtube.com', 'youtu.be'],
+      'twitter.com': ['twitter.com', 'x.com'],
+      'reddit.com': ['reddit.com', 'redd.it'],
+      'stackoverflow.com': ['stackoverflow.com', 'stackexchange.com'],
+      'wikipedia.org': ['wikipedia.org', 'wikimedia.org', 'wikidata.org']
+    };
+    
+    // Domain category mapping for smarter grouping
+    this.domainCategories = {
+      'work': ['linkedin.com', 'indeed.com', 'glassdoor.com', 'upwork.com', 'fiverr.com'],
+      'social': ['facebook.com', 'instagram.com', 'twitter.com', 'x.com', 'reddit.com', 'pinterest.com', 'tiktok.com', 'snapchat.com', 'weibo.com', 'zhihu.com', 'douban.com'],
+      'shopping': ['amazon.com', 'ebay.com', 'walmart.com', 'target.com', 'alibaba.com', 'taobao.com', 'tmall.com', 'jd.com', 'pinduoduo.com', 'suning.com'],
+      'learning': ['coursera.org', 'udemy.com', 'edx.org', 'khanacademy.org', 'pluralsight.com', 'lynda.com', 'codecademy.com', 'freecodecamp.org'],
+      'news': ['bbc.com', 'cnn.com', 'nytimes.com', 'theguardian.com', 'washingtonpost.com', 'reuters.com', 'bloomberg.com', 'wsj.com', 'ft.com', 'qq.com/news', 'sina.com.cn', 'sohu.com', '163.com/news'],
+      'finance': ['bankofamerica.com', 'chase.com', 'wellsfargo.com', 'citibank.com', 'hsbc.com', 'icbc.com.cn', 'ccb.com', 'boc.cn', 'abcchina.com', 'psbc.com', 'citics.com'],
+      'entertainment': ['netflix.com', 'hbo.com', 'disneyplus.com', 'hulu.com', 'primevideo.com', 'bilibili.com', 'youku.com', 'iqiyi.com', 'tencentvideo.com', 'spotify.com', 'music.163.com', 'qqmusic.com', 'kuwo.cn', 'kugou.com'],
+      'search': ['google.com', 'bing.com', 'yahoo.com', 'baidu.com', 'sogou.com', 'so.com', 'duckduckgo.com'],
+      'tools': ['slack.com', 'notion.so', 'trello.com', 'asana.com', 'jira.com', 'dropbox.com', 'box.com', 'evernote.com', 'onedrive.com', 'icloud.com', 'docs.google.com', 'sheets.google.com', 'slides.google.com', 'office.com'],
+      'coding': ['github.com', 'gitlab.com', 'bitbucket.org', 'stackoverflow.com', 'codepen.io', 'jsfiddle.net', 'repl.it', 'codewars.com', 'leetcode.com', 'hackerrank.com', 'hackerearth.com', 'topcoder.com', 'codesignal.com']
+    };
+  }
+
+  // Extract base domain (e.g., 'github.com' from 'gist.github.com')
+  extractBaseDomain(hostname) {
+    if (!hostname) return null;
+    
+    const parts = hostname.split('.');
+    if (parts.length <= 2) return hostname;
+    
+    // Check for common country code TLDs
+    const countryTLDs = ['cn', 'jp', 'uk', 'fr', 'de', 'es', 'it', 'br', 'au', 'ca', 'in', 'ru', 'kr', 'tw', 'hk', 'sg', 'my', 'th', 'vn', 'id', 'ph', 'mx', 'ar', 'co', 'pe', 'cl', 'ec', 'uy', 'za', 'ng', 'eg', 'sa', 'ae', 'il', 'tr', 'pl', 'nl', 'se', 'no', 'fi', 'dk', 'pt', 'gr', 'ro', 'bg', 'hu', 'cz', 'sk', 'at', 'ch', 'be', 'lu', 'ie'];
+    
+    // Check for second-level domains like .co.uk, .co.jp, .com.cn
+    if (parts.length >= 3) {
+      const lastTwo = parts.slice(-2).join('.');
+      const lastThree = parts.slice(-3).join('.');
+      
+      // Handle .co.uk, .co.jp etc.
+      if (parts[parts.length - 2] === 'co' && countryTLDs.includes(parts[parts.length - 1])) {
+        return lastThree;
+      }
+      
+      // Handle .com.cn, .net.cn etc.
+      if (['com', 'net', 'org', 'gov', 'edu', 'ac'].includes(parts[parts.length - 2]) && countryTLDs.includes(parts[parts.length - 1])) {
+        return lastThree;
+      }
+    }
+    
+    // Default: return last two parts
+    return parts.slice(-2).join('.');
   }
 
-  // Group tabs by domain
-  groupByDomain(tabs) {
+  // Get domain category for smarter grouping
+  getDomainCategory(domain) {
+    if (!domain) return null;
+    
+    const baseDomain = this.extractBaseDomain(domain);
+    if (!baseDomain) return null;
+    
+    for (const [category, domains] of Object.entries(this.domainCategories)) {
+      for (const pattern of domains) {
+        if (baseDomain === pattern || baseDomain.endsWith(`.${pattern}`) || pattern.endsWith(`.${baseDomain}`)) {
+          return category;
+        }
+      }
+    }
+    
+    return null;
+  }
+
+  // Check if domains are related (same company/service)
+  areDomainsRelated(domain1, domain2) {
+    if (!domain1 || !domain2) return false;
+    if (domain1 === domain2) return true;
+    
+    const base1 = this.extractBaseDomain(domain1);
+    const base2 = this.extractBaseDomain(domain2);
+    
+    if (base1 === base2) return true;
+    
+    // Check domain patterns
+    for (const [mainDomain, relatedDomains] of Object.entries(this.domainPatterns)) {
+      const hasDomain1 = relatedDomains.some(d => domain1.includes(d) || base1 === d);
+      const hasDomain2 = relatedDomains.some(d => domain2.includes(d) || base2 === d);
+      if (hasDomain1 && hasDomain2) return true;
+    }
+    
+    return false;
+  }
+
+  // Group tabs by domain (enhanced version)
+  groupByDomain(tabs, options = {}) {
+    const { 
+      smartGrouping = true, 
+      groupByCategory = false,
+      includeSubdomains = true 
+    } = options;
+    
     const groups = new Map();
+    const categoryGroups = new Map();
 
     for (const tab of tabs) {
       const domain = this.extractDomain(tab.url);
       if (!domain) continue;
+      
+      let groupKey = domain;
+      let groupName = domain;
+      
+      if (smartGrouping) {
+        const baseDomain = this.extractBaseDomain(domain);
+        if (baseDomain && includeSubdomains) {
+          groupKey = baseDomain;
+          
+          // Check if domain has a common pattern with special name
+          for (const [mainDomain, relatedDomains] of Object.entries(this.domainPatterns)) {
+            if (relatedDomains.some(d => domain.includes(d) || baseDomain === d)) {
+              groupKey = mainDomain;
+              groupName = mainDomain;
+              break;
+            }
+          }
+        }
+      }
+      
+      // If grouping by category
+      if (groupByCategory) {
+        const category = this.getDomainCategory(domain);
+        if (category) {
+          if (!categoryGroups.has(category)) {
+            categoryGroups.set(category, {
+              id: `category_${category}`,
+              name: this.getCategoryDisplayName(category),
+              type: 'category',
+              tabs: [],
+              collapsed: true,
+              createdAt: Date.now(),
+              icon: this.getCategoryIcon(category)
+            });
+          }
+          categoryGroups.get(category).tabs.push(tab);
+          continue;
+        }
+      }
 
-      if (!groups.has(domain)) {
-        groups.set(domain, {
-          id: `domain_${this.sanitizeId(domain)}`,
-          name: domain,
+      if (!groups.has(groupKey)) {
+        groups.set(groupKey, {
+          id: `domain_${this.sanitizeId(groupKey)}`,
+          name: groupName,
           type: 'domain',
           tabs: [],
           collapsed: true,
           createdAt: Date.now(),
-          icon: this.getDomainIcon(domain)
+          icon: this.getDomainIcon(groupKey)
         });
       }
 
-      groups.get(domain).tabs.push(tab);
+      groups.get(groupKey).tabs.push(tab);
+    }
+    
+    // Combine regular groups with category groups if using category grouping
+    let resultGroups = [];
+    if (groupByCategory) {
+      resultGroups = Array.from(categoryGroups.values());
+      // Add remaining domain groups that don't fit into any category
+      resultGroups = resultGroups.concat(Array.from(groups.values()));
+    } else {
+      resultGroups = Array.from(groups.values());
     }
 
-    // Convert to array and sort by tab count (descending)
-    return Array.from(groups.values())
-      .sort((a, b) => b.tabs.length - a.tabs.length);
+    // Sort by tab count (descending), then alphabetically
+    return resultGroups
+      .sort((a, b) => {
+        if (b.tabs.length !== a.tabs.length) {
+          return b.tabs.length - a.tabs.length;
+        }
+        return a.name.localeCompare(b.name);
+      });
+  }
+
+  // Get category display name
+  getCategoryDisplayName(category) {
+    const categoryNames = {
+      'work': '工作',
+      'social': '社交',
+      'shopping': '购物',
+      'learning': '学习',
+      'news': '新闻',
+      'finance': '金融',
+      'entertainment': '娱乐',
+      'search': '搜索',
+      'tools': '工具',
+      'coding': '编程'
+    };
+    return categoryNames[category] || category;
+  }
+
+  // Get category icon
+  getCategoryIcon(category) {
+    const categoryIcons = {
+      'work': '💼',
+      'social': '👥',
+      'shopping': '🛍️',
+      'learning': '📚',
+      'news': '📰',
+      'finance': '💰',
+      'entertainment': '🎬',
+      'search': '🔍',
+      'tools': '🔧',
+      'coding': '💻'
+    };
+    return categoryIcons[category] || '🌐';
   }
 
   // Group tabs by date/time
@@ -164,45 +361,144 @@ class GroupingEngine {
     }
   }
 
-  getTimeGroup(timestamp) {
+  // Get time of day label (morning, afternoon, evening, night)
+  getTimeOfDayLabel(hour) {
+    if (hour >= 5 && hour < 9) return '清晨';
+    if (hour >= 9 && hour < 12) return '上午';
+    if (hour >= 12 && hour < 14) return '中午';
+    if (hour >= 14 && hour < 18) return '下午';
+    if (hour >= 18 && hour < 22) return '晚上';
+    return '深夜';
+  }
+
+  // Check if a date is a weekend
+  isWeekend(date) {
+    const day = date.getDay();
+    return day === 0 || day === 6;
+  }
+
+  // Get week number of the year
+  getWeekNumber(date) {
+    const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+    const dayNum = d.getUTCDay() || 7;
+    d.setUTCDate(d.getUTCDate() + 4 - dayNum);
+    const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+    return Math.ceil((((d - yearStart) / 86400000) + 1) / 7);
+  }
+
+  // Enhanced getTimeGroup with more granular options
+  getTimeGroup(timestamp, options = {}) {
+    const { 
+      includeTimeOfDay = true, 
+      separateWeekends = false,
+      useChineseLabels = true
+    } = options;
+    
     const date = new Date(timestamp);
     const now = new Date();
     const diffMs = now.getTime() - date.getTime();
     const diffHours = diffMs / (1000 * 60 * 60);
     const diffDays = diffMs / (1000 * 60 * 60 * 24);
 
-    // Today - group by hour
+    // Today - more granular grouping with time of day
     if (diffHours < 24 && this.isSameDay(date, now)) {
       const hour = date.getHours();
-      const timeSlot = Math.floor(hour / 4) * 4; // 4-hour slots
-      return {
-        key: `today_${timeSlot}`,
-        label: `Today ${timeSlot}:00-${timeSlot + 4}:00`,
-        timeSlot: `today_${timeSlot}`
-      };
+      
+      if (includeTimeOfDay) {
+        const timeOfDay = this.getTimeOfDayLabel(hour);
+        const timeSlot = hour;
+        return {
+          key: `today_${timeOfDay}`,
+          label: useChineseLabels ? `今天 ${timeOfDay}` : `Today ${timeOfDay}`,
+          timeSlot: `today_${timeOfDay}`,
+          isToday: true,
+          timeOfDay
+        };
+      } else {
+        // Original 4-hour slots
+        const timeSlot = Math.floor(hour / 4) * 4;
+        return {
+          key: `today_${timeSlot}`,
+          label: useChineseLabels ? `今天 ${timeSlot}:00-${timeSlot + 4}:00` : `Today ${timeSlot}:00-${timeSlot + 4}:00`,
+          timeSlot: `today_${timeSlot}`,
+          isToday: true
+        };
+      }
     }
 
     // Yesterday
     const yesterday = new Date(now);
     yesterday.setDate(yesterday.getDate() - 1);
     if (diffDays < 2 && this.isSameDay(date, yesterday)) {
+      const hour = date.getHours();
+      const timeOfDay = includeTimeOfDay ? this.getTimeOfDayLabel(hour) : '';
+      
+      if (separateWeekends && this.isWeekend(yesterday)) {
+        return {
+          key: 'yesterday_weekend',
+          label: useChineseLabels ? '昨天（周末）' : 'Yesterday (Weekend)',
+          timeSlot: 'yesterday_weekend',
+          isYesterday: true,
+          isWeekend: true
+        };
+      }
+      
       return {
         key: 'yesterday',
-        label: 'Yesterday',
-        timeSlot: 'yesterday'
+        label: useChineseLabels ? (timeOfDay ? `昨天 ${timeOfDay}` : '昨天') : (timeOfDay ? `Yesterday ${timeOfDay}` : 'Yesterday'),
+        timeSlot: 'yesterday',
+        isYesterday: true
       };
     }
 
-    // This week
+    // This week - with weekday/weekend separation
     const weekAgo = new Date(now);
     weekAgo.setDate(weekAgo.getDate() - 7);
     if (diffDays < 7 && date >= weekAgo) {
-      const dayNames = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
-      const dayName = dayNames[date.getDay()];
+      const dayNamesEn = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+      const dayNamesCn = ['周日', '周一', '周二', '周三', '周四', '周五', '周六'];
+      const dayNameEn = dayNamesEn[date.getDay()];
+      const dayNameCn = dayNamesCn[date.getDay()];
+      const isWeekend = this.isWeekend(date);
+      
+      if (separateWeekends) {
+        if (isWeekend) {
+          return {
+            key: 'this_week_weekend',
+            label: useChineseLabels ? '本周周末' : 'This Weekend',
+            timeSlot: 'this_week_weekend',
+            isWeekend: true,
+            isThisWeek: true
+          };
+        } else {
+          return {
+            key: `this_week_${dayNameEn.toLowerCase()}`,
+            label: useChineseLabels ? `本周${dayNameCn}` : `This ${dayNameEn}`,
+            timeSlot: `this_week_${dayNameEn.toLowerCase()}`,
+            isThisWeek: true,
+            isWeekend: false
+          };
+        }
+      }
+      
+      return {
+        key: `this_week_${dayNameEn.toLowerCase()}`,
+        label: useChineseLabels ? dayNameCn : dayNameEn,
+        timeSlot: `this_week_${dayNameEn.toLowerCase()}`,
+        isThisWeek: true
+      };
+    }
+
+    // Last week
+    const twoWeeksAgo = new Date(now);
+    twoWeeksAgo.setDate(twoWeeksAgo.getDate() - 14);
+    if (diffDays < 14 && date >= twoWeeksAgo) {
+      const weekNum = this.getWeekNumber(date);
       return {
-        key: `this_week_${dayName.toLowerCase()}`,
-        label: dayName,
-        timeSlot: `this_week_${dayName.toLowerCase()}`
+        key: `last_week_${weekNum}`,
+        label: useChineseLabels ? '上周' : 'Last Week',
+        timeSlot: 'last_week',
+        isLastWeek: true
       };
     }
 
@@ -210,29 +506,140 @@ class GroupingEngine {
     if (diffDays < 30 && date.getMonth() === now.getMonth() && date.getFullYear() === now.getFullYear()) {
       return {
         key: 'this_month',
-        label: 'This Month',
-        timeSlot: 'this_month'
+        label: useChineseLabels ? '本月' : 'This Month',
+        timeSlot: 'this_month',
+        isThisMonth: true
       };
     }
 
-    // Older - group by month
+    // Last month
+    const lastMonth = new Date(now);
+    lastMonth.setMonth(lastMonth.getMonth() - 1);
+    if (date.getMonth() === lastMonth.getMonth() && date.getFullYear() === lastMonth.getFullYear()) {
+      return {
+        key: 'last_month',
+        label: useChineseLabels ? '上月' : 'Last Month',
+        timeSlot: 'last_month',
+        isLastMonth: true
+      };
+    }
+
+    // Older - group by month with year
     const month = date.getMonth() + 1;
     const year = date.getFullYear();
-    const monthNames = ['', 'January', 'February', 'March', 'April', 'May', 'June',
+    const monthNamesEn = ['', 'January', 'February', 'March', 'April', 'May', 'June',
                        'July', 'August', 'September', 'October', 'November', 'December'];
+    const monthNamesCn = ['', '一月', '二月', '三月', '四月', '五月', '六月',
+                       '七月', '八月', '九月', '十月', '十一月', '十二月'];
+
+    // Check if it's this year
+    if (year === now.getFullYear()) {
+      return {
+        key: `older_${year}_${month}`,
+        label: useChineseLabels ? `${monthNamesCn[month]}` : `${monthNamesEn[month]}`,
+        timeSlot: `older_${year}_${month}`,
+        year,
+        month
+      };
+    }
 
     return {
       key: `older_${year}_${month}`,
-      label: `${monthNames[month]} ${year}`,
-      timeSlot: `older_${year}_${month}`
+      label: useChineseLabels ? `${year}年${monthNamesCn[month]}` : `${monthNamesEn[month]} ${year}`,
+      timeSlot: `older_${year}_${month}`,
+      year,
+      month
     };
   }
 
+  // Group tabs by date with enhanced options
+  groupByDate(tabs, options = {}) {
+    const { 
+      includeTimeOfDay = true, 
+      separateWeekends = false,
+      useChineseLabels = true
+    } = options;
+    
+    const groups = new Map();
+
+    for (const tab of tabs) {
+      const timeGroup = this.getTimeGroup(tab.openedAt || Date.now(), {
+        includeTimeOfDay,
+        separateWeekends,
+        useChineseLabels
+      });
+
+      if (!groups.has(timeGroup.key)) {
+        groups.set(timeGroup.key, {
+          id: `date_${timeGroup.key}`,
+          name: timeGroup.label,
+          type: 'date',
+          tabs: [],
+          collapsed: true,
+          createdAt: Date.now(),
+          timeSlot: timeGroup.timeSlot,
+          ...timeGroup
+        });
+      }
+
+      groups.get(timeGroup.key).tabs.push(tab);
+    }
+
+    // Convert to array and sort by time (most recent first)
+    return Array.from(groups.values())
+      .sort((a, b) => {
+        const timeA = this.getTimeValue(a.timeSlot);
+        const timeB = this.getTimeValue(b.timeSlot);
+        return timeB - timeA;
+      });
+  }
+
+  // Group tabs by work week (Monday-Friday vs weekend)
+  groupByWorkWeek(tabs) {
+    const groups = new Map();
+    
+    for (const tab of tabs) {
+      const date = new Date(tab.openedAt || Date.now());
+      const isWeekend = this.isWeekend(date);
+      const weekNum = this.getWeekNumber(date);
+      const year = date.getFullYear();
+      
+      const groupKey = isWeekend 
+        ? `weekend_${year}_${weekNum}` 
+        : `workweek_${year}_${weekNum}`;
+      
+      if (!groups.has(groupKey)) {
+        groups.set(groupKey, {
+          id: `week_${groupKey}`,
+          name: isWeekend ? `第${weekNum}周 周末` : `第${weekNum}周 工作日`,
+          type: 'workweek',
+          tabs: [],
+          collapsed: true,
+          createdAt: Date.now(),
+          isWeekend,
+          weekNum,
+          year
+        });
+      }
+      
+      groups.get(groupKey).tabs.push(tab);
+    }
+    
+    return Array.from(groups.values())
+      .sort((a, b) => {
+        if (b.year !== a.year) return b.year - a.year;
+        if (b.weekNum !== a.weekNum) return b.weekNum - a.weekNum;
+        return a.isWeekend ? 1 : -1; // Work days come before weekend
+      });
+  }
+
   getTimeValue(timeSlot) {
     if (timeSlot.startsWith('today_')) return Date.now();
-    if (timeSlot === 'yesterday') return Date.now() - (24 * 60 * 60 * 1000);
+    if (timeSlot === 'yesterday' || timeSlot === 'yesterday_weekend') return Date.now() - (24 * 60 * 60 * 1000);
     if (timeSlot.startsWith('this_week_')) return Date.now() - (3 * 24 * 60 * 60 * 1000);
+    if (timeSlot === 'last_week') return Date.now() - (10 * 24 * 60 * 60 * 1000);
     if (timeSlot === 'this_month') return Date.now() - (15 * 24 * 60 * 60 * 1000);
+    if (timeSlot === 'last_month') return Date.now() - (45 * 24 * 60 * 60 * 1000);
     return Date.now() - (90 * 24 * 60 * 60 * 1000); // Default to 3 months ago
   }
 
diff --git a/utils/rule-engine.js b/utils/rule-engine.js
index 4ccbe92..03cb382 100644
--- a/utils/rule-engine.js
+++ b/utils/rule-engine.js
@@ -7,11 +7,62 @@
  * - 域名提取
  * - 规则优先级排序
  * - 匹配规则查找
+ * - 支持多种匹配条件和组合逻辑
  */
 
 class RuleEngine {
   constructor() {
     console.log('🔧 RuleEngine initialized');
+    
+    // 支持的字段类型
+    this.supportedFields = {
+      'title': {
+        label: '标题',
+        operators: ['contains', 'equals', 'startsWith', 'endsWith', 'regex', 'notContains', 'notEquals']
+      },
+      'url': {
+        label: 'URL',
+        operators: ['contains', 'equals', 'startsWith', 'endsWith', 'regex', 'notContains', 'notEquals']
+      },
+      'domain': {
+        label: '域名',
+        operators: ['contains', 'equals', 'startsWith', 'endsWith', 'regex', 'notContains', 'notEquals']
+      },
+      'path': {
+        label: '路径',
+        operators: ['contains', 'equals', 'startsWith', 'endsWith', 'regex', 'notContains', 'notEquals']
+      },
+      'note': {
+        label: '备注',
+        operators: ['contains', 'equals', 'regex', 'notContains', 'notEquals']
+      },
+      'alias': {
+        label: '别名',
+        operators: ['contains', 'equals', 'startsWith', 'endsWith', 'regex', 'notContains', 'notEquals']
+      },
+      'openedAt': {
+        label: '打开时间',
+        operators: ['before', 'after', 'between', 'today', 'yesterday', 'thisWeek', 'thisMonth']
+      },
+      'lastAccessed': {
+        label: '最后访问时间',
+        operators: ['before', 'after', 'between', 'today', 'yesterday', 'thisWeek', 'thisMonth']
+      },
+      'visitCount': {
+        label: '访问次数',
+        operators: ['greaterThan', 'lessThan', 'equals', 'between', 'notEquals']
+      },
+      'pinned': {
+        label: '固定标签',
+        operators: ['equals', 'notEquals']
+      }
+    };
+    
+    // 逻辑操作符
+    this.logicOperators = {
+      'AND': '全部满足',
+      'OR': '满足任一'
+    };
   }
 
   /**
@@ -21,19 +72,27 @@ class RuleEngine {
    * @returns {boolean} 是否匹配
    */
   matchesRule(tab, rule) {
-    // 检查规则是否启用且包含条件
     if (!rule.enabled || !rule.conditions || rule.conditions.length === 0) {
       return false;
     }
 
-    // 所有条件都必须匹配（AND逻辑）
-    for (const condition of rule.conditions) {
-      if (!this.matchesCondition(tab, condition)) {
-        return false;
+    const logicOperator = rule.logicOperator || 'AND';
+    
+    if (logicOperator === 'AND') {
+      for (const condition of rule.conditions) {
+        if (!this.matchesCondition(tab, condition)) {
+          return false;
+        }
       }
+      return true;
+    } else {
+      for (const condition of rule.conditions) {
+        if (this.matchesCondition(tab, condition)) {
+          return true;
+        }
+      }
+      return false;
     }
-
-    return true;
   }
 
   /**
@@ -48,8 +107,35 @@ class RuleEngine {
     }
 
     const fieldValue = this.getFieldValue(tab, condition.field);
-    if (!fieldValue) return false;
+    const operator = typeof condition.operator === 'string' && condition.operator.trim()
+      ? condition.operator
+      : 'contains';
 
+    // 时间相关操作符
+    if (['before', 'after', 'between', 'today', 'yesterday', 'thisWeek', 'thisMonth'].includes(operator)) {
+      return this.matchTimeCondition(fieldValue, operator, condition);
+    }
+
+    // 数字相关操作符
+    if (['greaterThan', 'lessThan', 'between'].includes(operator)) {
+      return this.matchNumberCondition(fieldValue, operator, condition);
+    }
+
+    // 布尔值操作符
+    if (condition.field === 'pinned') {
+      return this.matchBooleanCondition(fieldValue, operator, condition);
+    }
+
+    // 字符串相关操作符
+    return this.matchStringCondition(fieldValue, operator, condition);
+  }
+
+  /**
+   * 匹配字符串条件
+   */
+  matchStringCondition(fieldValue, operator, condition) {
+    if (!fieldValue) return false;
+    
     const rawExpectedValue = typeof condition.value === 'string'
       ? condition.value
       : (typeof condition.keyword === 'string' ? condition.keyword : '');
@@ -58,9 +144,6 @@ class RuleEngine {
       return false;
     }
 
-    const operator = typeof condition.operator === 'string' && condition.operator.trim()
-      ? condition.operator
-      : 'contains';
     const caseSensitive = Boolean(condition.caseSensitive);
 
     if (operator === 'regex') {
@@ -79,8 +162,12 @@ class RuleEngine {
     switch (operator) {
       case 'contains':
         return searchValue.includes(testValue);
+      case 'notContains':
+        return !searchValue.includes(testValue);
       case 'equals':
         return searchValue === testValue;
+      case 'notEquals':
+        return searchValue !== testValue;
       case 'startsWith':
         return searchValue.startsWith(testValue);
       case 'endsWith':
@@ -90,11 +177,104 @@ class RuleEngine {
     }
   }
 
+  /**
+   * 匹配时间条件
+   */
+  matchTimeCondition(fieldValue, operator, condition) {
+    const fieldTime = Number(fieldValue);
+    if (!Number.isFinite(fieldTime)) return false;
+    
+    const now = Date.now();
+    const today = new Date();
+    today.setHours(0, 0, 0, 0);
+    const todayStart = today.getTime();
+    const todayEnd = todayStart + 24 * 60 * 60 * 1000;
+    
+    const yesterday = new Date(today);
+    yesterday.setDate(yesterday.getDate() - 1);
+    const yesterdayStart = yesterday.getTime();
+    
+    const weekStart = new Date(today);
+    weekStart.setDate(weekStart.getDate() - weekStart.getDay());
+    const weekStartTime = weekStart.getTime();
+    
+    const monthStart = new Date(today.getFullYear(), today.getMonth(), 1);
+    const monthStartTime = monthStart.getTime();
+
+    switch (operator) {
+      case 'today':
+        return fieldTime >= todayStart && fieldTime < todayEnd;
+      case 'yesterday':
+        return fieldTime >= yesterdayStart && fieldTime < todayStart;
+      case 'thisWeek':
+        return fieldTime >= weekStartTime && fieldTime < todayEnd;
+      case 'thisMonth':
+        return fieldTime >= monthStartTime && fieldTime < todayEnd;
+      case 'before':
+        const beforeTime = Number(condition.value);
+        return Number.isFinite(beforeTime) && fieldTime < beforeTime;
+      case 'after':
+        const afterTime = Number(condition.value);
+        return Number.isFinite(afterTime) && fieldTime > afterTime;
+      case 'between':
+        const startTime = Number(condition.startValue);
+        const endTime = Number(condition.endValue);
+        return Number.isFinite(startTime) && Number.isFinite(endTime) && 
+               fieldTime >= startTime && fieldTime <= endTime;
+      default:
+        return false;
+    }
+  }
+
+  /**
+   * 匹配数字条件
+   */
+  matchNumberCondition(fieldValue, operator, condition) {
+    const fieldNum = Number(fieldValue);
+    if (!Number.isFinite(fieldNum)) return false;
+    
+    const conditionValue = Number(condition.value);
+    const conditionStartValue = Number(condition.startValue);
+    const conditionEndValue = Number(condition.endValue);
+
+    switch (operator) {
+      case 'greaterThan':
+        return Number.isFinite(conditionValue) && fieldNum > conditionValue;
+      case 'lessThan':
+        return Number.isFinite(conditionValue) && fieldNum < conditionValue;
+      case 'equals':
+        return Number.isFinite(conditionValue) && fieldNum === conditionValue;
+      case 'notEquals':
+        return Number.isFinite(conditionValue) && fieldNum !== conditionValue;
+      case 'between':
+        return Number.isFinite(conditionStartValue) && Number.isFinite(conditionEndValue) &&
+               fieldNum >= conditionStartValue && fieldNum <= conditionEndValue;
+      default:
+        return false;
+    }
+  }
+
+  /**
+   * 匹配布尔值条件
+   */
+  matchBooleanCondition(fieldValue, operator, condition) {
+    const fieldBool = Boolean(fieldValue);
+    const conditionValue = condition.value === 'true' || condition.value === true;
+    
+    if (operator === 'equals') {
+      return fieldBool === conditionValue;
+    } else if (operator === 'notEquals') {
+      return fieldBool !== conditionValue;
+    }
+    
+    return false;
+  }
+
   /**
    * 获取标签页指定字段的值
    * @param {Object} tab - 标签页对象
-   * @param {string} field - 字段名 ('title' | 'url' | 'domain')
-   * @returns {string} 字段值
+   * @param {string} field - 字段名
+   * @returns {*} 字段值
    */
   getFieldValue(tab, field) {
     switch (field) {
@@ -111,6 +291,18 @@ class RuleEngine {
         } catch (error) {
           return '';
         }
+      case 'note':
+        return tab.note || '';
+      case 'alias':
+        return tab.alias || '';
+      case 'openedAt':
+        return tab.openedAt || 0;
+      case 'lastAccessed':
+        return tab.lastAccessed || 0;
+      case 'visitCount':
+        return tab.visitCount || 0;
+      case 'pinned':
+        return tab.pinned || false;
       default:
         return '';
     }
@@ -150,6 +342,25 @@ class RuleEngine {
     return null;
   }
 
+  /**
+   * 查找所有匹配的规则
+   * @param {Object} tab - 标签页对象
+   * @param {Array} rules - 规则数组
+   * @returns {Array} 匹配的规则数组
+   */
+  findAllMatchingRules(tab, rules) {
+    const sortedRules = this.sortRulesByPriority(rules);
+    const matchingRules = [];
+
+    for (const rule of sortedRules) {
+      if (this.matchesRule(tab, rule)) {
+        matchingRules.push(rule);
+      }
+    }
+
+    return matchingRules;
+  }
+
   /**
    * 按优先级排序规则（数字越小优先级越高）
    * @param {Array} rules - 规则数组
@@ -162,6 +373,84 @@ class RuleEngine {
       return priorityA - priorityB;
     });
   }
+
+  /**
+   * 验证规则格式是否正确
+   * @param {Object} rule - 规则对象
+   * @returns {Object} 验证结果 { valid: boolean, errors: string[] }
+   */
+  validateRule(rule) {
+    const errors = [];
+    
+    if (!rule || typeof rule !== 'object') {
+      return { valid: false, errors: ['规则格式无效'] };
+    }
+    
+    if (!rule.name || typeof rule.name !== 'string' || rule.name.trim() === '') {
+      errors.push('规则名称不能为空');
+    }
+    
+    if (!rule.conditions || !Array.isArray(rule.conditions)) {
+      errors.push('规则必须包含条件数组');
+    } else if (rule.conditions.length === 0) {
+      errors.push('规则至少需要一个条件');
+    } else {
+      rule.conditions.forEach((condition, index) => {
+        if (!condition.field) {
+          errors.push(`条件 ${index + 1}: 缺少字段`);
+        } else if (!this.supportedFields[condition.field]) {
+          errors.push(`条件 ${index + 1}: 不支持的字段 "${condition.field}"`);
+        }
+        
+        if (!condition.operator) {
+          errors.push(`条件 ${index + 1}: 缺少操作符`);
+        } else if (condition.field && this.supportedFields[condition.field]) {
+          const validOperators = this.supportedFields[condition.field].operators;
+          if (!validOperators.includes(condition.operator)) {
+            errors.push(`条件 ${index + 1}: 操作符 "${condition.operator}" 不支持字段 "${condition.field}"`);
+          }
+        }
+      });
+    }
+    
+    if (rule.logicOperator && !['AND', 'OR'].includes(rule.logicOperator)) {
+      errors.push('逻辑操作符必须是 "AND" 或 "OR"');
+    }
+    
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+
+  /**
+   * 获取支持的字段列表
+   * @returns {Array} 字段信息数组
+   */
+  getSupportedFields() {
+    return Object.entries(this.supportedFields).map(([field, info]) => ({
+      field,
+      label: info.label,
+      operators: info.operators
+    }));
+  }
+
+  /**
+   * 获取支持的操作符列表
+   * @param {string} field - 字段名（可选）
+   * @returns {Object|Array} 操作符信息
+   */
+  getSupportedOperators(field) {
+    if (field && this.supportedFields[field]) {
+      return this.supportedFields[field].operators;
+    }
+    return {
+      string: ['contains', 'equals', 'startsWith', 'endsWith', 'regex', 'notContains', 'notEquals'],
+      time: ['before', 'after', 'between', 'today', 'yesterday', 'thisWeek', 'thisMonth'],
+      number: ['greaterThan', 'lessThan', 'equals', 'between', 'notEquals'],
+      boolean: ['equals', 'notEquals']
+    };
+  }
 }
 
 // 导出模块
diff --git a/utils/tab-search-engine.js b/utils/tab-search-engine.js
new file mode 100644
index 0000000..16315b5
--- /dev/null
+++ b/utils/tab-search-engine.js
@@ -0,0 +1,653 @@
+/**
+ * TabSearchEngine - 增强的标签页搜索引擎
+ * 
+ * 功能特性：
+ * - 实时搜索防抖
+ * - 多维度搜索（标题、备注、URL、域名、别名、打开时间、访问次数）
+ * - 高级搜索语法（引号精确匹配、排除词、字段限定）
+ * - 搜索历史记录
+ * - 搜索结果排序（相关度、时间、访问次数）
+ * - 搜索结果高亮
+ */
+
+class TabSearchEngine {
+  constructor(options = {}) {
+    this.options = {
+      debounceDelay: options.debounceDelay || 150,
+      maxHistoryItems: options.maxHistoryItems || 20,
+      defaultSearchFields: options.defaultSearchFields || ['title', 'alias', 'url', 'note', 'domain'],
+      highlightClass: options.highlightClass || 'tf-search-highlight',
+      ...options
+    };
+    
+    this.searchHistory = [];
+    this.debounceTimer = null;
+    this.lastQuery = '';
+    this.currentResults = [];
+    
+    // 高级搜索语法标记
+    this.syntaxTokens = {
+      exactMatch: /"([^"]+)"/g,
+      exclude: /-(\S+)/g,
+      fieldLimit: /(\w+):/g
+    };
+    
+    // 字段权重配置（用于相关度排序）
+    this.fieldWeights = {
+      title: 10,
+      alias: 9,
+      note: 8,
+      domain: 7,
+      url: 5,
+      path: 3
+    };
+    
+    // 可搜索字段映射
+    this.searchableFields = {
+      title: { label: '标题', weight: 10 },
+      alias: { label: '别名', weight: 9 },
+      note: { label: '备注', weight: 8 },
+      domain: { label: '域名', weight: 7 },
+      url: { label: 'URL', weight: 5 },
+      path: { label: '路径', weight: 3 }
+    };
+    
+    // 从存储加载搜索历史
+    this.loadSearchHistory();
+  }
+
+  /**
+   * 解析搜索查询
+   * @param {string} query - 原始搜索查询
+   * @returns {Object} 解析后的查询对象
+   */
+  parseQuery(query) {
+    if (!query || typeof query !== 'string') {
+      return {
+        terms: [],
+        exactTerms: [],
+        excludeTerms: [],
+        fieldLimits: {},
+        rawQuery: ''
+      };
+    }
+    
+    const trimmedQuery = query.trim();
+    let remainingQuery = trimmedQuery;
+    
+    // 提取精确匹配项（带引号的内容）
+    const exactTerms = [];
+    let exactMatch;
+    while ((exactMatch = this.syntaxTokens.exactMatch.exec(trimmedQuery)) !== null) {
+      exactTerms.push(exactMatch[1].toLowerCase());
+      remainingQuery = remainingQuery.replace(exactMatch[0], '');
+    }
+    
+    // 提取排除项（以-开头的词）
+    const excludeTerms = [];
+    let excludeMatch;
+    while ((excludeMatch = this.syntaxTokens.exclude.exec(trimmedQuery)) !== null) {
+      excludeTerms.push(excludeMatch[1].toLowerCase());
+      remainingQuery = remainingQuery.replace(excludeMatch[0], '');
+    }
+    
+    // 提取字段限定（field:value）
+    const fieldLimits = {};
+    let fieldMatch;
+    const fieldLimitPattern = /(\w+):([^\s]+)/g;
+    while ((fieldMatch = fieldLimitPattern.exec(trimmedQuery)) !== null) {
+      const field = fieldMatch[1].toLowerCase();
+      const value = fieldMatch[2].toLowerCase();
+      if (this.searchableFields[field]) {
+        if (!fieldLimits[field]) {
+          fieldLimits[field] = [];
+        }
+        fieldLimits[field].push(value);
+      }
+      remainingQuery = remainingQuery.replace(fieldMatch[0], '');
+    }
+    
+    // 提取普通搜索词
+    const terms = remainingQuery
+      .split(/\s+/)
+      .filter(term => term.length > 0)
+      .map(term => term.toLowerCase());
+    
+    return {
+      terms,
+      exactTerms,
+      excludeTerms,
+      fieldLimits,
+      rawQuery: trimmedQuery,
+      hasAdvancedSyntax: exactTerms.length > 0 || excludeTerms.length > 0 || Object.keys(fieldLimits).length > 0
+    };
+  }
+
+  /**
+   * 检查标签页是否匹配搜索查询
+   * @param {Object} tab - 标签页对象
+   * @param {Object} parsedQuery - 解析后的查询对象
+   * @param {Array} searchFields - 要搜索的字段列表
+   * @returns {Object} 匹配结果 { matches: boolean, score: number, matches: Object }
+   */
+  matchTab(tab, parsedQuery, searchFields = this.options.defaultSearchFields) {
+    if (!tab || !parsedQuery) {
+      return { matches: false, score: 0, fieldMatches: {} };
+    }
+    
+    const { terms, exactTerms, excludeTerms, fieldLimits } = parsedQuery;
+    
+    // 如果没有任何搜索条件，认为匹配
+    if (terms.length === 0 && exactTerms.length === 0 && Object.keys(fieldLimits).length === 0) {
+      return { matches: true, score: 0, fieldMatches: {} };
+    }
+    
+    let totalScore = 0;
+    const fieldMatches = {};
+    let hasMatch = false;
+    
+    // 首先检查排除项
+    for (const field of searchFields) {
+      const fieldValue = this.getFieldValue(tab, field);
+      if (!fieldValue) continue;
+      
+      const lowerValue = fieldValue.toLowerCase();
+      
+      // 检查是否包含排除项
+      for (const excludeTerm of excludeTerms) {
+        if (lowerValue.includes(excludeTerm)) {
+          return { matches: false, score: 0, fieldMatches: {} };
+        }
+      }
+    }
+    
+    // 检查字段限定
+    for (const [field, values] of Object.entries(fieldLimits)) {
+      const fieldValue = this.getFieldValue(tab, field);
+      if (!fieldValue) {
+        return { matches: false, score: 0, fieldMatches: {} };
+      }
+      
+      const lowerValue = fieldValue.toLowerCase();
+      let fieldMatch = false;
+      
+      for (const value of values) {
+        if (lowerValue.includes(value)) {
+          fieldMatch = true;
+          const weight = this.fieldWeights[field] || 1;
+          totalScore += weight * value.length;
+          
+          if (!fieldMatches[field]) {
+            fieldMatches[field] = [];
+          }
+          fieldMatches[field].push(value);
+        }
+      }
+      
+      if (!fieldMatch) {
+        return { matches: false, score: 0, fieldMatches: {} };
+      }
+      
+      hasMatch = true;
+    }
+    
+    // 检查精确匹配项
+    for (const exactTerm of exactTerms) {
+      let exactMatchFound = false;
+      
+      for (const field of searchFields) {
+        const fieldValue = this.getFieldValue(tab, field);
+        if (!fieldValue) continue;
+        
+        const lowerValue = fieldValue.toLowerCase();
+        
+        if (lowerValue.includes(exactTerm)) {
+          exactMatchFound = true;
+          const weight = this.fieldWeights[field] || 1;
+          totalScore += weight * exactTerm.length * 2; // 精确匹配权重更高
+          
+          if (!fieldMatches[field]) {
+            fieldMatches[field] = [];
+          }
+          fieldMatches[field].push(exactTerm);
+          
+          break;
+        }
+      }
+      
+      if (!exactMatchFound) {
+        return { matches: false, score: 0, fieldMatches: {} };
+      }
+      
+      hasMatch = true;
+    }
+    
+    // 检查普通搜索词
+    for (const term of terms) {
+      let termMatchFound = false;
+      
+      for (const field of searchFields) {
+        const fieldValue = this.getFieldValue(tab, field);
+        if (!fieldValue) continue;
+        
+        const lowerValue = fieldValue.toLowerCase();
+        
+        if (lowerValue.includes(term)) {
+          termMatchFound = true;
+          const weight = this.fieldWeights[field] || 1;
+          
+          // 根据匹配位置计算额外权重
+          const termIndex = lowerValue.indexOf(term);
+          const positionBonus = termIndex === 0 ? 2 : (termIndex < 10 ? 1.5 : 1);
+          
+          totalScore += weight * term.length * positionBonus;
+          
+          if (!fieldMatches[field]) {
+            fieldMatches[field] = [];
+          }
+          if (!fieldMatches[field].includes(term)) {
+            fieldMatches[field].push(term);
+          }
+        }
+      }
+      
+      if (!termMatchFound) {
+        return { matches: false, score: 0, fieldMatches: {} };
+      }
+      
+      hasMatch = true;
+    }
+    
+    return {
+      matches: hasMatch,
+      score: totalScore,
+      fieldMatches
+    };
+  }
+
+  /**
+   * 获取标签页指定字段的值
+   * @param {Object} tab - 标签页对象
+   * @param {string} field - 字段名
+   * @returns {string} 字段值
+   */
+  getFieldValue(tab, field) {
+    if (!tab) return '';
+    
+    switch (field) {
+      case 'title':
+        return tab.title || '';
+      case 'alias':
+        return tab.alias || '';
+      case 'note':
+        return tab.note || '';
+      case 'url':
+        return tab.url || '';
+      case 'domain':
+        try {
+          return new URL(tab.url || '').hostname || '';
+        } catch {
+          return '';
+        }
+      case 'path':
+        try {
+          return new URL(tab.url || '').pathname || '';
+        } catch {
+          return '';
+        }
+      default:
+        return '';
+    }
+  }
+
+  /**
+   * 搜索标签页
+   * @param {Array} tabs - 标签页数组
+   * @param {string} query - 搜索查询
+   * @param {Object} options - 搜索选项
+   * @returns {Array} 搜索结果（按相关度排序）
+   */
+  search(tabs, query, options = {}) {
+    const {
+      searchFields = this.options.defaultSearchFields,
+      sortBy = 'relevance', // 'relevance', 'time', 'visitCount'
+      sortOrder = 'desc'
+    } = options;
+    
+    if (!Array.isArray(tabs)) {
+      return [];
+    }
+    
+    const parsedQuery = this.parseQuery(query);
+    
+    // 如果没有搜索词，返回空结果
+    if (!parsedQuery.rawQuery) {
+      return [];
+    }
+    
+    const results = [];
+    
+    for (const tab of tabs) {
+      const matchResult = this.matchTab(tab, parsedQuery, searchFields);
+      
+      if (matchResult.matches) {
+        results.push({
+          tab,
+          score: matchResult.score,
+          fieldMatches: matchResult.fieldMatches,
+          parsedQuery
+        });
+      }
+    }
+    
+    // 排序
+    this.sortResults(results, sortBy, sortOrder);
+    
+    // 保存到搜索历史（如果是有效查询）
+    if (parsedQuery.rawQuery.length > 1) {
+      this.addToSearchHistory(parsedQuery.rawQuery, results.length);
+    }
+    
+    this.lastQuery = parsedQuery.rawQuery;
+    this.currentResults = results;
+    
+    return results;
+  }
+
+  /**
+   * 对搜索结果排序
+   * @param {Array} results - 搜索结果数组
+   * @param {string} sortBy - 排序方式
+   * @param {string} sortOrder - 排序方向
+   */
+  sortResults(results, sortBy = 'relevance', sortOrder = 'desc') {
+    results.sort((a, b) => {
+      let comparison = 0;
+      
+      switch (sortBy) {
+        case 'relevance':
+          comparison = a.score - b.score;
+          break;
+        case 'time':
+          const timeA = a.tab.openedAt || 0;
+          const timeB = b.tab.openedAt || 0;
+          comparison = timeA - timeB;
+          break;
+        case 'visitCount':
+          const visitsA = a.tab.visitCount || 0;
+          const visitsB = b.tab.visitCount || 0;
+          comparison = visitsA - visitsB;
+          break;
+        default:
+          comparison = a.score - b.score;
+      }
+      
+      return sortOrder === 'desc' ? -comparison : comparison;
+    });
+  }
+
+  /**
+   * 防抖搜索
+   * @param {Function} searchFn - 搜索函数
+   * @param {Array} tabs - 标签页数组
+   * @param {string} query - 搜索查询
+   * @param {Object} options - 搜索选项
+   */
+  debouncedSearch(searchFn, tabs, query, options = {}) {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+    
+    this.debounceTimer = setTimeout(() => {
+      const results = this.search(tabs, query, options);
+      if (typeof searchFn === 'function') {
+        searchFn(results, query);
+      }
+    }, this.options.debounceDelay);
+  }
+
+  /**
+   * 高亮搜索结果中的匹配文本
+   * @param {string} text - 原始文本
+   * @param {Array} searchTerms - 搜索词数组
+   * @param {string} highlightClass - 高亮类名
+   * @returns {string} 带高亮的HTML
+   */
+  highlightMatches(text, searchTerms, highlightClass = this.options.highlightClass) {
+    if (!text || !Array.isArray(searchTerms) || searchTerms.length === 0) {
+      return this.escapeHtml(text);
+    }
+    
+    let result = this.escapeHtml(text);
+    const lowerText = text.toLowerCase();
+    
+    // 按长度降序排序搜索词，确保长词先被匹配
+    const sortedTerms = [...searchTerms].sort((a, b) => b.length - a.length);
+    
+    for (const term of sortedTerms) {
+      if (!term) continue;
+      
+      // 使用正则表达式进行不区分大小写的替换
+      const regex = new RegExp(`(${this.escapeRegExp(term)})`, 'gi');
+      
+      // 只在还没有被高亮的部分进行替换
+      // 这是一个简化版本，实际项目中可能需要更复杂的处理
+      result = result.replace(regex, `<span class="${highlightClass}">$1</span>`);
+    }
+    
+    return result;
+  }
+
+  /**
+   * 转义HTML特殊字符
+   * @param {string} text - 原始文本
+   * @returns {string} 转义后的文本
+   */
+  escapeHtml(text) {
+    if (!text) return '';
+    const div = document.createElement('div');
+    div.textContent = text;
+    return div.innerHTML;
+  }
+
+  /**
+   * 转义正则表达式特殊字符
+   * @param {string} string - 原始字符串
+   * @returns {string} 转义后的字符串
+   */
+  escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  }
+
+  /**
+   * 添加到搜索历史
+   * @param {string} query - 搜索查询
+   * @param {number} resultCount - 结果数量
+   */
+  addToSearchHistory(query, resultCount) {
+    if (!query || query.trim().length === 0) return;
+    
+    const historyItem = {
+      query: query.trim(),
+      timestamp: Date.now(),
+      resultCount: resultCount || 0
+    };
+    
+    // 检查是否已存在相同的查询，如果存在则更新时间戳
+    const existingIndex = this.searchHistory.findIndex(item => 
+      item.query.toLowerCase() === query.toLowerCase()
+    );
+    
+    if (existingIndex !== -1) {
+      this.searchHistory.splice(existingIndex, 1);
+    }
+    
+    // 添加到历史开头
+    this.searchHistory.unshift(historyItem);
+    
+    // 限制历史数量
+    if (this.searchHistory.length > this.options.maxHistoryItems) {
+      this.searchHistory = this.searchHistory.slice(0, this.options.maxHistoryItems);
+    }
+    
+    // 保存到存储
+    this.saveSearchHistory();
+  }
+
+  /**
+   * 获取搜索历史
+   * @param {number} limit - 返回数量限制
+   * @returns {Array} 搜索历史数组
+   */
+  getSearchHistory(limit = 10) {
+    return this.searchHistory.slice(0, limit);
+  }
+
+  /**
+   * 清除搜索历史
+   */
+  clearSearchHistory() {
+    this.searchHistory = [];
+    this.saveSearchHistory();
+  }
+
+  /**
+   * 保存搜索历史到存储
+   */
+  saveSearchHistory() {
+    try {
+      if (typeof chrome !== 'undefined' && chrome.storage && chrome.storage.local) {
+        chrome.storage.local.set({
+          'tabflow:searchHistory': this.searchHistory
+        });
+      } else if (typeof localStorage !== 'undefined') {
+        localStorage.setItem('tabflow:searchHistory', JSON.stringify(this.searchHistory));
+      }
+    } catch (error) {
+      console.warn('Failed to save search history:', error);
+    }
+  }
+
+  /**
+   * 从存储加载搜索历史
+   */
+  loadSearchHistory() {
+    try {
+      if (typeof chrome !== 'undefined' && chrome.storage && chrome.storage.local) {
+        chrome.storage.local.get(['tabflow:searchHistory'], (result) => {
+          if (result['tabflow:searchHistory']) {
+            this.searchHistory = result['tabflow:searchHistory'];
+          }
+        });
+      } else if (typeof localStorage !== 'undefined') {
+        const stored = localStorage.getItem('tabflow:searchHistory');
+        if (stored) {
+          this.searchHistory = JSON.parse(stored);
+        }
+      }
+    } catch (error) {
+      console.warn('Failed to load search history:', error);
+      this.searchHistory = [];
+    }
+  }
+
+  /**
+   * 获取搜索建议
+   * @param {string} partialQuery - 部分输入的查询
+   * @param {Array} tabs - 当前标签页列表
+   * @returns {Array} 建议列表
+   */
+  getSearchSuggestions(partialQuery, tabs = []) {
+    if (!partialQuery || partialQuery.trim().length === 0) {
+      // 返回最近的搜索历史
+      return this.getSearchHistory(5).map(item => ({
+        type: 'history',
+        query: item.query,
+        label: item.query,
+        timestamp: item.timestamp
+      }));
+    }
+    
+    const suggestions = [];
+    const lowerPartial = partialQuery.toLowerCase();
+    
+    // 1. 从搜索历史获取匹配项
+    const historySuggestions = this.searchHistory
+      .filter(item => item.query.toLowerCase().includes(lowerPartial))
+      .slice(0, 3)
+      .map(item => ({
+        type: 'history',
+        query: item.query,
+        label: item.query,
+        timestamp: item.timestamp
+      }));
+    
+    suggestions.push(...historySuggestions);
+    
+    // 2. 从当前标签页获取标题/域名建议
+    if (Array.isArray(tabs) && tabs.length > 0) {
+      const tabSuggestions = [];
+      const seenValues = new Set();
+      
+      for (const tab of tabs) {
+        // 检查标题
+        const title = tab.title || '';
+        if (title.toLowerCase().includes(lowerPartial) && !seenValues.has(title)) {
+          seenValues.add(title);
+          tabSuggestions.push({
+            type: 'title',
+            query: title,
+            label: title,
+            tab: tab
+          });
+        }
+        
+        // 检查域名
+        try {
+          const domain = new URL(tab.url || '').hostname;
+          if (domain && domain.toLowerCase().includes(lowerPartial) && !seenValues.has(domain)) {
+            seenValues.add(domain);
+            tabSuggestions.push({
+              type: 'domain',
+              query: domain,
+              label: domain,
+              tab: tab
+            });
+          }
+        } catch (e) {
+          // 忽略无效URL
+        }
+        
+        // 检查备注
+        if (tab.note) {
+          const note = tab.note;
+          if (note.toLowerCase().includes(lowerPartial) && !seenValues.has(note)) {
+            seenValues.add(note);
+            tabSuggestions.push({
+              type: 'note',
+              query: note,
+              label: note,
+              tab: tab
+            });
+          }
+        }
+        
+        if (tabSuggestions.length >= 5) break;
+      }
+      
+      suggestions.push(...tabSuggestions);
+    }
+    
+    return suggestions.slice(0, 8);
+  }
+}
+
+// 导出模块
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = TabSearchEngine;
+}
+
+// 浏览器环境导出
+if (typeof window !== 'undefined') {
+  window.TabSearchEngine = TabSearchEngine;
+}