Add files via upload

README.md

@@ -34,6 +34,7 @@ CyberStrikeAI is an **AI-native security testing platform** built in Go. It inte
 - 📚 Knowledge base with vector search and hybrid retrieval for security expertise
 - 📁 Conversation grouping with pinning, rename, and batch management
 - 🛡️ Vulnerability management with CRUD operations, severity tracking, status workflow, and statistics
+- 📋 Batch task management: create task queues, add multiple tasks, and execute them sequentially
 
 ## Tool Overview
 
@@ -109,6 +110,7 @@ CyberStrikeAI ships with 100+ curated tools covering the whole kill chain:
 - **History & audit** – Every conversation and tool invocation is stored in SQLite with replay.
 - **Conversation groups** – Organize conversations into groups, pin important groups, rename or delete groups via context menu.
 - **Vulnerability management** – Create, update, and track vulnerabilities discovered during testing. Filter by severity (critical/high/medium/low/info), status (open/confirmed/fixed/false_positive), and conversation. View statistics and export findings.
+- **Batch task management** – Create task queues with multiple tasks, add or edit tasks before execution, and run them sequentially. Each task executes as a separate conversation, with status tracking (pending/running/completed/failed/cancelled) and full execution history.
 - **Settings** – Tweak provider keys, MCP enablement, tool toggles, and agent iteration limits.
 
 ### Built-in Safeguards
@@ -221,6 +223,7 @@ CyberStrikeAI ships with 100+ curated tools covering the whole kill chain:
 ### Automation Hooks
 - **REST APIs** – everything the UI uses (auth, conversations, tool runs, monitor, vulnerabilities) is available over JSON.
 - **Vulnerability APIs** – manage vulnerabilities via `/api/vulnerabilities` endpoints: `GET /api/vulnerabilities` (list with filters), `POST /api/vulnerabilities` (create), `GET /api/vulnerabilities/:id` (get), `PUT /api/vulnerabilities/:id` (update), `DELETE /api/vulnerabilities/:id` (delete), `GET /api/vulnerabilities/stats` (statistics).
+- **Batch Task APIs** – manage batch task queues via `/api/batch-tasks` endpoints: `POST /api/batch-tasks` (create queue), `GET /api/batch-tasks` (list queues), `GET /api/batch-tasks/:queueId` (get queue), `POST /api/batch-tasks/:queueId/start` (start execution), `POST /api/batch-tasks/:queueId/cancel` (cancel), `DELETE /api/batch-tasks/:queueId` (delete), `POST /api/batch-tasks/:queueId/tasks` (add task), `PUT /api/batch-tasks/:queueId/tasks/:taskId` (update task), `DELETE /api/batch-tasks/:queueId/tasks/:taskId` (delete task). Tasks execute sequentially, each creating a separate conversation with full status tracking.
 - **Task control** – pause/resume/stop long scans, re-run steps with new params, or stream transcripts.
 - **Audit & security** – rotate passwords via `/api/auth/change-password`, enforce short-lived sessions, and restrict MCP ports at the network layer when exposing the service.
 
@@ -318,6 +321,7 @@ Build an attack chain for the latest engagement and export the node list with se
 
 ## Changelog (Recent)
 
+- 2025-12-26 – Added batch task management feature: create task queues with multiple tasks, add/edit/delete tasks before execution, and execute them sequentially. Each task runs as a separate conversation with status tracking (pending/running/completed/failed/cancelled). All queues and tasks are persisted in the database.
 - 2025-12-25 – Added vulnerability management feature: full CRUD operations for tracking vulnerabilities discovered during testing. Supports severity levels (critical/high/medium/low/info), status workflow (open/confirmed/fixed/false_positive), filtering by conversation/severity/status, and comprehensive statistics dashboard.
 - 2025-12-25 – Added conversation grouping feature: organize conversations into groups, pin groups to top, rename/delete groups via context menu. All group data is persisted in the database.
 - 2025-12-24 – Refactored attack chain generation logic, achieving 2x faster generation speed. Redesigned attack chain frontend visualization for improved user experience.

README_CN.md

@@ -32,6 +32,7 @@ CyberStrikeAI 是一款 **AI 原生安全测试平台**，基于 Go 构建，集
 - 📚 知识库功能：向量检索与混合搜索，为 AI 提供安全专业知识
 - 📁 对话分组管理：支持分组创建、置顶、重命名、删除等操作
 - 🛡️ 漏洞管理功能：完整的漏洞 CRUD 操作，支持严重程度分级、状态流转、按对话/严重程度/状态过滤，以及统计看板
+- 📋 批量任务管理：创建任务队列，批量添加任务，依次顺序执行，支持任务编辑与状态跟踪
 
 ## 工具概览
 
@@ -107,6 +108,7 @@ CyberStrikeAI 是一款 **AI 原生安全测试平台**，基于 Go 构建，集
 - **会话历史**：所有对话与工具调用保存在 SQLite，可随时重放。
 - **对话分组**：将对话按项目或主题组织到不同分组，支持置顶、重命名、删除等操作，所有数据持久化存储。
 - **漏洞管理**：在测试过程中创建、更新和跟踪发现的漏洞。支持按严重程度（严重/高/中/低/信息）、状态（待确认/已确认/已修复/误报）和对话进行过滤，查看统计信息并导出发现。
+- **批量任务管理**：创建任务队列，批量添加多个任务，执行前可编辑或删除任务，然后依次顺序执行。每个任务会作为独立对话执行，支持完整的状态跟踪（待执行/执行中/已完成/失败/已取消）和执行历史。
 - **可视化配置**：在界面中切换模型、启停工具、设置迭代次数等。
 
 ### 默认安全措施
@@ -219,6 +221,7 @@ CyberStrikeAI 是一款 **AI 原生安全测试平台**，基于 Go 构建，集
 ### 自动化与安全
 - **REST API**：认证、会话、任务、监控、漏洞管理等接口全部开放，可与 CI/CD 集成。
 - **漏洞管理 API**：通过 `/api/vulnerabilities` 端点管理漏洞：`GET /api/vulnerabilities`（列表，支持过滤）、`POST /api/vulnerabilities`（创建）、`GET /api/vulnerabilities/:id`（获取）、`PUT /api/vulnerabilities/:id`（更新）、`DELETE /api/vulnerabilities/:id`（删除）、`GET /api/vulnerabilities/stats`（统计）。
+- **批量任务 API**：通过 `/api/batch-tasks` 端点管理批量任务队列：`POST /api/batch-tasks`（创建队列）、`GET /api/batch-tasks`（列表）、`GET /api/batch-tasks/:queueId`（获取队列）、`POST /api/batch-tasks/:queueId/start`（开始执行）、`POST /api/batch-tasks/:queueId/cancel`（取消）、`DELETE /api/batch-tasks/:queueId`（删除队列）、`POST /api/batch-tasks/:queueId/tasks`（添加任务）、`PUT /api/batch-tasks/:queueId/tasks/:taskId`（更新任务）、`DELETE /api/batch-tasks/:queueId/tasks/:taskId`（删除任务）。任务依次顺序执行，每个任务创建独立对话，支持完整状态跟踪。
 - **任务控制**：支持暂停/终止长任务、修改参数后重跑、流式获取日志。
 - **安全管理**：`/api/auth/change-password` 可即时轮换口令；建议在暴露 MCP 端口时配合网络层 ACL。
 
@@ -315,6 +318,7 @@ CyberStrikeAI/
 ```
 
 ## Changelog（近期）
+- 2025-12-26 —— 新增批量任务管理功能：支持创建任务队列，批量添加多个任务，执行前可编辑或删除任务，然后依次顺序执行。每个任务作为独立对话运行，支持状态跟踪（待执行/执行中/已完成/失败/已取消），所有队列和任务数据持久化存储到数据库。
 - 2025-12-25 —— 新增漏洞管理功能：完整的漏洞 CRUD 操作，支持跟踪测试过程中发现的漏洞。支持严重程度分级（严重/高/中/低/信息）、状态流转（待确认/已确认/已修复/误报）、按对话/严重程度/状态过滤，以及统计看板。
 - 2025-12-25 —— 新增对话分组功能：支持创建分组、将对话移动到分组、分组置顶、重命名和删除等操作，所有分组数据持久化存储到数据库。
 - 2025-12-24 —— 重构攻击链生成逻辑，生成速度提升一倍。重构攻击链前端页面展示，优化用户体验。

internal/app/app.go

@@ -423,6 +423,18 @@ func setupRoutes(
 		// Agent Loop 取消与任务列表
 		protected.POST("/agent-loop/cancel", agentHandler.CancelAgentLoop)
 		protected.GET("/agent-loop/tasks", agentHandler.ListAgentTasks)
+		protected.GET("/agent-loop/tasks/completed", agentHandler.ListCompletedTasks)
+
+		// 批量任务管理
+		protected.POST("/batch-tasks", agentHandler.CreateBatchQueue)
+		protected.GET("/batch-tasks", agentHandler.ListBatchQueues)
+		protected.GET("/batch-tasks/:queueId", agentHandler.GetBatchQueue)
+		protected.POST("/batch-tasks/:queueId/start", agentHandler.StartBatchQueue)
+		protected.POST("/batch-tasks/:queueId/cancel", agentHandler.CancelBatchQueue)
+		protected.DELETE("/batch-tasks/:queueId", agentHandler.DeleteBatchQueue)
+		protected.PUT("/batch-tasks/:queueId/tasks/:taskId", agentHandler.UpdateBatchTask)
+		protected.POST("/batch-tasks/:queueId/tasks", agentHandler.AddBatchTask)
+		protected.DELETE("/batch-tasks/:queueId/tasks/:taskId", agentHandler.DeleteBatchTask)
 
 		// 对话历史
 		protected.POST("/conversations", conversationHandler.CreateConversation)

internal/database/batch_task.go

@@ -0,0 +1,314 @@
+package database
+
+import (
+	"database/sql"
+	"fmt"
+	"time"
+
+	"go.uber.org/zap"
+)
+
+// BatchTaskQueueRow 批量任务队列数据库行
+type BatchTaskQueueRow struct {
+	ID           string
+	Status       string
+	CreatedAt    time.Time
+	StartedAt    sql.NullTime
+	CompletedAt  sql.NullTime
+	CurrentIndex int
+}
+
+// BatchTaskRow 批量任务数据库行
+type BatchTaskRow struct {
+	ID             string
+	QueueID        string
+	Message        string
+	ConversationID sql.NullString
+	Status         string
+	StartedAt      sql.NullTime
+	CompletedAt    sql.NullTime
+	Error          sql.NullString
+	Result         sql.NullString
+}
+
+// CreateBatchQueue 创建批量任务队列
+func (db *DB) CreateBatchQueue(queueID string, tasks []map[string]interface{}) error {
+	tx, err := db.Begin()
+	if err != nil {
+		return fmt.Errorf("开始事务失败: %w", err)
+	}
+	defer tx.Rollback()
+
+	now := time.Now()
+	_, err = tx.Exec(
+		"INSERT INTO batch_task_queues (id, status, created_at, current_index) VALUES (?, ?, ?, ?)",
+		queueID, "pending", now, 0,
+	)
+	if err != nil {
+		return fmt.Errorf("创建批量任务队列失败: %w", err)
+	}
+
+	// 插入任务
+	for _, task := range tasks {
+		taskID, ok := task["id"].(string)
+		if !ok {
+			continue
+		}
+		message, ok := task["message"].(string)
+		if !ok {
+			continue
+		}
+		
+		_, err = tx.Exec(
+			"INSERT INTO batch_tasks (id, queue_id, message, status) VALUES (?, ?, ?, ?)",
+			taskID, queueID, message, "pending",
+		)
+		if err != nil {
+			return fmt.Errorf("创建批量任务失败: %w", err)
+		}
+	}
+
+	return tx.Commit()
+}
+
+// GetBatchQueue 获取批量任务队列
+func (db *DB) GetBatchQueue(queueID string) (*BatchTaskQueueRow, error) {
+	var row BatchTaskQueueRow
+	var createdAt string
+	err := db.QueryRow(
+		"SELECT id, status, created_at, started_at, completed_at, current_index FROM batch_task_queues WHERE id = ?",
+		queueID,
+	).Scan(&row.ID, &row.Status, &createdAt, &row.StartedAt, &row.CompletedAt, &row.CurrentIndex)
+	if err == sql.ErrNoRows {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, fmt.Errorf("查询批量任务队列失败: %w", err)
+	}
+
+	parsedTime, parseErr := time.Parse("2006-01-02 15:04:05", createdAt)
+	if parseErr != nil {
+		// 尝试其他时间格式
+		parsedTime, parseErr = time.Parse(time.RFC3339, createdAt)
+		if parseErr != nil {
+			db.logger.Warn("解析创建时间失败", zap.String("createdAt", createdAt), zap.Error(parseErr))
+			parsedTime = time.Now()
+		}
+	}
+	row.CreatedAt = parsedTime
+	return &row, nil
+}
+
+// GetAllBatchQueues 获取所有批量任务队列
+func (db *DB) GetAllBatchQueues() ([]*BatchTaskQueueRow, error) {
+	rows, err := db.Query(
+		"SELECT id, status, created_at, started_at, completed_at, current_index FROM batch_task_queues ORDER BY created_at DESC",
+	)
+	if err != nil {
+		return nil, fmt.Errorf("查询批量任务队列列表失败: %w", err)
+	}
+	defer rows.Close()
+
+	var queues []*BatchTaskQueueRow
+	for rows.Next() {
+		var row BatchTaskQueueRow
+		var createdAt string
+		if err := rows.Scan(&row.ID, &row.Status, &createdAt, &row.StartedAt, &row.CompletedAt, &row.CurrentIndex); err != nil {
+			return nil, fmt.Errorf("扫描批量任务队列失败: %w", err)
+		}
+		parsedTime, parseErr := time.Parse("2006-01-02 15:04:05", createdAt)
+		if parseErr != nil {
+			parsedTime, parseErr = time.Parse(time.RFC3339, createdAt)
+			if parseErr != nil {
+				db.logger.Warn("解析创建时间失败", zap.String("createdAt", createdAt), zap.Error(parseErr))
+				parsedTime = time.Now()
+			}
+		}
+		row.CreatedAt = parsedTime
+		queues = append(queues, &row)
+	}
+
+	return queues, nil
+}
+
+// GetBatchTasks 获取批量任务队列的所有任务
+func (db *DB) GetBatchTasks(queueID string) ([]*BatchTaskRow, error) {
+	rows, err := db.Query(
+		"SELECT id, queue_id, message, conversation_id, status, started_at, completed_at, error, result FROM batch_tasks WHERE queue_id = ? ORDER BY id",
+		queueID,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("查询批量任务失败: %w", err)
+	}
+	defer rows.Close()
+
+	var tasks []*BatchTaskRow
+	for rows.Next() {
+		var task BatchTaskRow
+		if err := rows.Scan(
+			&task.ID, &task.QueueID, &task.Message, &task.ConversationID,
+			&task.Status, &task.StartedAt, &task.CompletedAt, &task.Error, &task.Result,
+		); err != nil {
+			return nil, fmt.Errorf("扫描批量任务失败: %w", err)
+		}
+		tasks = append(tasks, &task)
+	}
+
+	return tasks, nil
+}
+
+// UpdateBatchQueueStatus 更新批量任务队列状态
+func (db *DB) UpdateBatchQueueStatus(queueID, status string) error {
+	var err error
+	now := time.Now()
+	
+	if status == "running" {
+		_, err = db.Exec(
+			"UPDATE batch_task_queues SET status = ?, started_at = COALESCE(started_at, ?) WHERE id = ?",
+			status, now, queueID,
+		)
+	} else if status == "completed" || status == "cancelled" {
+		_, err = db.Exec(
+			"UPDATE batch_task_queues SET status = ?, completed_at = COALESCE(completed_at, ?) WHERE id = ?",
+			status, now, queueID,
+		)
+	} else {
+		_, err = db.Exec(
+			"UPDATE batch_task_queues SET status = ? WHERE id = ?",
+			status, queueID,
+		)
+	}
+	
+	if err != nil {
+		return fmt.Errorf("更新批量任务队列状态失败: %w", err)
+	}
+	return nil
+}
+
+// UpdateBatchTaskStatus 更新批量任务状态
+func (db *DB) UpdateBatchTaskStatus(queueID, taskID, status string, conversationID, result, errorMsg string) error {
+	var err error
+	now := time.Now()
+	
+	// 构建更新语句
+	var updates []string
+	var args []interface{}
+	
+	updates = append(updates, "status = ?")
+	args = append(args, status)
+	
+	if conversationID != "" {
+		updates = append(updates, "conversation_id = ?")
+		args = append(args, conversationID)
+	}
+	
+	if result != "" {
+		updates = append(updates, "result = ?")
+		args = append(args, result)
+	}
+	
+	if errorMsg != "" {
+		updates = append(updates, "error = ?")
+		args = append(args, errorMsg)
+	}
+	
+	if status == "running" {
+		updates = append(updates, "started_at = COALESCE(started_at, ?)")
+		args = append(args, now)
+	}
+	
+	if status == "completed" || status == "failed" || status == "cancelled" {
+		updates = append(updates, "completed_at = COALESCE(completed_at, ?)")
+		args = append(args, now)
+	}
+	
+	args = append(args, queueID, taskID)
+	
+	// 构建SQL语句
+	sql := "UPDATE batch_tasks SET "
+	for i, update := range updates {
+		if i > 0 {
+			sql += ", "
+		}
+		sql += update
+	}
+	sql += " WHERE queue_id = ? AND id = ?"
+	
+	_, err = db.Exec(sql, args...)
+	if err != nil {
+		return fmt.Errorf("更新批量任务状态失败: %w", err)
+	}
+	return nil
+}
+
+// UpdateBatchQueueCurrentIndex 更新批量任务队列的当前索引
+func (db *DB) UpdateBatchQueueCurrentIndex(queueID string, currentIndex int) error {
+	_, err := db.Exec(
+		"UPDATE batch_task_queues SET current_index = ? WHERE id = ?",
+		currentIndex, queueID,
+	)
+	if err != nil {
+		return fmt.Errorf("更新批量任务队列当前索引失败: %w", err)
+	}
+	return nil
+}
+
+// UpdateBatchTaskMessage 更新批量任务消息
+func (db *DB) UpdateBatchTaskMessage(queueID, taskID, message string) error {
+	_, err := db.Exec(
+		"UPDATE batch_tasks SET message = ? WHERE queue_id = ? AND id = ?",
+		message, queueID, taskID,
+	)
+	if err != nil {
+		return fmt.Errorf("更新批量任务消息失败: %w", err)
+	}
+	return nil
+}
+
+// AddBatchTask 添加任务到批量任务队列
+func (db *DB) AddBatchTask(queueID, taskID, message string) error {
+	_, err := db.Exec(
+		"INSERT INTO batch_tasks (id, queue_id, message, status) VALUES (?, ?, ?, ?)",
+		taskID, queueID, message, "pending",
+	)
+	if err != nil {
+		return fmt.Errorf("添加批量任务失败: %w", err)
+	}
+	return nil
+}
+
+// DeleteBatchTask 删除批量任务
+func (db *DB) DeleteBatchTask(queueID, taskID string) error {
+	_, err := db.Exec(
+		"DELETE FROM batch_tasks WHERE queue_id = ? AND id = ?",
+		queueID, taskID,
+	)
+	if err != nil {
+		return fmt.Errorf("删除批量任务失败: %w", err)
+	}
+	return nil
+}
+
+// DeleteBatchQueue 删除批量任务队列
+func (db *DB) DeleteBatchQueue(queueID string) error {
+	tx, err := db.Begin()
+	if err != nil {
+		return fmt.Errorf("开始事务失败: %w", err)
+	}
+	defer tx.Rollback()
+
+	// 删除任务（外键会自动级联删除）
+	_, err = tx.Exec("DELETE FROM batch_tasks WHERE queue_id = ?", queueID)
+	if err != nil {
+		return fmt.Errorf("删除批量任务失败: %w", err)
+	}
+
+	// 删除队列
+	_, err = tx.Exec("DELETE FROM batch_task_queues WHERE id = ?", queueID)
+	if err != nil {
+		return fmt.Errorf("删除批量任务队列失败: %w", err)
+	}
+
+	return tx.Commit()
+}
+

internal/database/database.go

@@ -189,6 +189,32 @@ func (db *DB) initTables() error {
 		FOREIGN KEY (conversation_id) REFERENCES conversations(id) ON DELETE CASCADE
 	);`
 
+	// 创建批量任务队列表
+	createBatchTaskQueuesTable := `
+	CREATE TABLE IF NOT EXISTS batch_task_queues (
+		id TEXT PRIMARY KEY,
+		status TEXT NOT NULL,
+		created_at DATETIME NOT NULL,
+		started_at DATETIME,
+		completed_at DATETIME,
+		current_index INTEGER NOT NULL DEFAULT 0
+	);`
+
+	// 创建批量任务表
+	createBatchTasksTable := `
+	CREATE TABLE IF NOT EXISTS batch_tasks (
+		id TEXT PRIMARY KEY,
+		queue_id TEXT NOT NULL,
+		message TEXT NOT NULL,
+		conversation_id TEXT,
+		status TEXT NOT NULL,
+		started_at DATETIME,
+		completed_at DATETIME,
+		error TEXT,
+		result TEXT,
+		FOREIGN KEY (queue_id) REFERENCES batch_task_queues(id) ON DELETE CASCADE
+	);`
+
 	// 创建索引
 	createIndexes := `
 	CREATE INDEX IF NOT EXISTS idx_messages_conversation_id ON messages(conversation_id);
@@ -212,6 +238,8 @@ func (db *DB) initTables() error {
 	CREATE INDEX IF NOT EXISTS idx_vulnerabilities_severity ON vulnerabilities(severity);
 	CREATE INDEX IF NOT EXISTS idx_vulnerabilities_status ON vulnerabilities(status);
 	CREATE INDEX IF NOT EXISTS idx_vulnerabilities_created_at ON vulnerabilities(created_at);
+	CREATE INDEX IF NOT EXISTS idx_batch_tasks_queue_id ON batch_tasks(queue_id);
+	CREATE INDEX IF NOT EXISTS idx_batch_task_queues_created_at ON batch_task_queues(created_at);
 	`
 
 	if _, err := db.Exec(createConversationsTable); err != nil {
@@ -258,6 +286,14 @@ func (db *DB) initTables() error {
 		return fmt.Errorf("创建vulnerabilities表失败: %w", err)
 	}
 
+	if _, err := db.Exec(createBatchTaskQueuesTable); err != nil {
+		return fmt.Errorf("创建batch_task_queues表失败: %w", err)
+	}
+
+	if _, err := db.Exec(createBatchTasksTable); err != nil {
+		return fmt.Errorf("创建batch_tasks表失败: %w", err)
+	}
+
 	// 为已有表添加新字段（如果不存在）- 必须在创建索引之前
 	if err := db.migrateConversationsTable(); err != nil {
 		db.logger.Warn("迁移conversations表失败", zap.Error(err))

internal/handler/agent.go

@@ -7,8 +7,8 @@ import (
 	"fmt"
 	"net/http"
 	"strings"
-	"unicode/utf8"
 	"time"
+	"unicode/utf8"
 
 	"cyberstrike-ai/internal/agent"
 	"cyberstrike-ai/internal/database"
@@ -25,16 +25,16 @@ func safeTruncateString(s string, maxLen int) string {
 	if utf8.RuneCountInString(s) <= maxLen {
 		return s
 	}
-	
+
 	// 将字符串转换为 rune 切片以正确计算字符数
 	runes := []rune(s)
 	if len(runes) <= maxLen {
 		return s
 	}
-	
+
 	// 截断到最大长度
 	truncated := string(runes[:maxLen])
-	
+
 	// 尝试在标点符号或空格处截断，使截断更自然
 	// 在截断点往前查找合适的断点（不超过20%的长度）
 	searchRange := maxLen / 5
@@ -43,7 +43,7 @@ func safeTruncateString(s string, maxLen int) string {
 	}
 	breakChars := []rune("，。、 ,.;:!?！？/\\-_")
 	bestBreakPos := len(runes[:maxLen])
-	
+
 	for i := bestBreakPos - 1; i >= bestBreakPos-searchRange && i >= 0; i-- {
 		for _, breakChar := range breakChars {
 			if runes[i] == breakChar {
@@ -52,7 +52,7 @@ func safeTruncateString(s string, maxLen int) string {
 			}
 		}
 	}
-	
+
 found:
 	truncated = string(runes[:bestBreakPos])
 	return truncated + "..."
@@ -64,6 +64,7 @@ type AgentHandler struct {
 	db               *database.DB
 	logger           *zap.Logger
 	tasks            *AgentTaskManager
+	batchTaskManager *BatchTaskManager
 	knowledgeManager interface { // 知识库管理器接口
 		LogRetrieval(conversationID, messageID, query, riskType string, retrievedItems []string) error
 	}
@@ -71,11 +72,20 @@ type AgentHandler struct {
 
 // NewAgentHandler 创建新的Agent处理器
 func NewAgentHandler(agent *agent.Agent, db *database.DB, logger *zap.Logger) *AgentHandler {
+	batchTaskManager := NewBatchTaskManager()
+	batchTaskManager.SetDB(db)
+
+	// 从数据库加载所有批量任务队列
+	if err := batchTaskManager.LoadFromDB(); err != nil {
+		logger.Warn("从数据库加载批量任务队列失败", zap.Error(err))
+	}
+
 	return &AgentHandler{
-		agent:  agent,
-		db:     db,
-		logger: logger,
-		tasks:  NewAgentTaskManager(),
+		agent:            agent,
+		db:               db,
+		logger:           logger,
+		tasks:            NewAgentTaskManager(),
+		batchTaskManager: batchTaskManager,
 	}
 }
 
@@ -724,6 +734,283 @@ func (h *AgentHandler) ListAgentTasks(c *gin.Context) {
 	})
 }
 
+// ListCompletedTasks 列出最近完成的任务历史
+func (h *AgentHandler) ListCompletedTasks(c *gin.Context) {
+	c.JSON(http.StatusOK, gin.H{
+		"tasks": h.tasks.GetCompletedTasks(),
+	})
+}
+
+// BatchTaskRequest 批量任务请求
+type BatchTaskRequest struct {
+	Tasks []string `json:"tasks" binding:"required"` // 任务列表，每行一个任务
+}
+
+// CreateBatchQueue 创建批量任务队列
+func (h *AgentHandler) CreateBatchQueue(c *gin.Context) {
+	var req BatchTaskRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if len(req.Tasks) == 0 {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "任务列表不能为空"})
+		return
+	}
+
+	// 过滤空任务
+	validTasks := make([]string, 0, len(req.Tasks))
+	for _, task := range req.Tasks {
+		if task != "" {
+			validTasks = append(validTasks, task)
+		}
+	}
+
+	if len(validTasks) == 0 {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "没有有效的任务"})
+		return
+	}
+
+	queue := h.batchTaskManager.CreateBatchQueue(validTasks)
+	c.JSON(http.StatusOK, gin.H{
+		"queueId": queue.ID,
+		"queue":   queue,
+	})
+}
+
+// GetBatchQueue 获取批量任务队列
+func (h *AgentHandler) GetBatchQueue(c *gin.Context) {
+	queueID := c.Param("queueId")
+	queue, exists := h.batchTaskManager.GetBatchQueue(queueID)
+	if !exists {
+		c.JSON(http.StatusNotFound, gin.H{"error": "队列不存在"})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"queue": queue})
+}
+
+// ListBatchQueues 列出所有批量任务队列
+func (h *AgentHandler) ListBatchQueues(c *gin.Context) {
+	queues := h.batchTaskManager.GetAllQueues()
+	c.JSON(http.StatusOK, gin.H{"queues": queues})
+}
+
+// StartBatchQueue 开始执行批量任务队列
+func (h *AgentHandler) StartBatchQueue(c *gin.Context) {
+	queueID := c.Param("queueId")
+	queue, exists := h.batchTaskManager.GetBatchQueue(queueID)
+	if !exists {
+		c.JSON(http.StatusNotFound, gin.H{"error": "队列不存在"})
+		return
+	}
+
+	if queue.Status != "pending" && queue.Status != "paused" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "队列状态不允许启动"})
+		return
+	}
+
+	// 在后台执行批量任务
+	go h.executeBatchQueue(queueID)
+
+	h.batchTaskManager.UpdateQueueStatus(queueID, "running")
+	c.JSON(http.StatusOK, gin.H{"message": "批量任务已开始执行", "queueId": queueID})
+}
+
+// CancelBatchQueue 取消批量任务队列
+func (h *AgentHandler) CancelBatchQueue(c *gin.Context) {
+	queueID := c.Param("queueId")
+	success := h.batchTaskManager.CancelQueue(queueID)
+	if !success {
+		c.JSON(http.StatusNotFound, gin.H{"error": "队列不存在或无法取消"})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"message": "批量任务已取消"})
+}
+
+// DeleteBatchQueue 删除批量任务队列
+func (h *AgentHandler) DeleteBatchQueue(c *gin.Context) {
+	queueID := c.Param("queueId")
+	success := h.batchTaskManager.DeleteQueue(queueID)
+	if !success {
+		c.JSON(http.StatusNotFound, gin.H{"error": "队列不存在"})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"message": "批量任务队列已删除"})
+}
+
+// UpdateBatchTask 更新批量任务消息
+func (h *AgentHandler) UpdateBatchTask(c *gin.Context) {
+	queueID := c.Param("queueId")
+	taskID := c.Param("taskId")
+
+	var req struct {
+		Message string `json:"message" binding:"required"`
+	}
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "无效的请求参数: " + err.Error()})
+		return
+	}
+
+	if req.Message == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "任务消息不能为空"})
+		return
+	}
+
+	err := h.batchTaskManager.UpdateTaskMessage(queueID, taskID, req.Message)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	// 返回更新后的队列信息
+	queue, exists := h.batchTaskManager.GetBatchQueue(queueID)
+	if !exists {
+		c.JSON(http.StatusNotFound, gin.H{"error": "队列不存在"})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"message": "任务已更新", "queue": queue})
+}
+
+// AddBatchTask 添加任务到批量任务队列
+func (h *AgentHandler) AddBatchTask(c *gin.Context) {
+	queueID := c.Param("queueId")
+
+	var req struct {
+		Message string `json:"message" binding:"required"`
+	}
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "无效的请求参数: " + err.Error()})
+		return
+	}
+
+	if req.Message == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "任务消息不能为空"})
+		return
+	}
+
+	task, err := h.batchTaskManager.AddTaskToQueue(queueID, req.Message)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	// 返回更新后的队列信息
+	queue, exists := h.batchTaskManager.GetBatchQueue(queueID)
+	if !exists {
+		c.JSON(http.StatusNotFound, gin.H{"error": "队列不存在"})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"message": "任务已添加", "task": task, "queue": queue})
+}
+
+// DeleteBatchTask 删除批量任务
+func (h *AgentHandler) DeleteBatchTask(c *gin.Context) {
+	queueID := c.Param("queueId")
+	taskID := c.Param("taskId")
+
+	err := h.batchTaskManager.DeleteTask(queueID, taskID)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	// 返回更新后的队列信息
+	queue, exists := h.batchTaskManager.GetBatchQueue(queueID)
+	if !exists {
+		c.JSON(http.StatusNotFound, gin.H{"error": "队列不存在"})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"message": "任务已删除", "queue": queue})
+}
+
+// executeBatchQueue 执行批量任务队列
+func (h *AgentHandler) executeBatchQueue(queueID string) {
+	h.logger.Info("开始执行批量任务队列", zap.String("queueId", queueID))
+
+	for {
+		// 检查队列状态
+		queue, exists := h.batchTaskManager.GetBatchQueue(queueID)
+		if !exists || queue.Status == "cancelled" || queue.Status == "completed" {
+			break
+		}
+
+		// 获取下一个任务
+		task, hasNext := h.batchTaskManager.GetNextTask(queueID)
+		if !hasNext {
+			// 所有任务完成
+			h.batchTaskManager.UpdateQueueStatus(queueID, "completed")
+			h.logger.Info("批量任务队列执行完成", zap.String("queueId", queueID))
+			break
+		}
+
+		// 更新任务状态为运行中
+		h.batchTaskManager.UpdateTaskStatus(queueID, task.ID, "running", "", "")
+
+		// 创建新对话
+		title := safeTruncateString(task.Message, 50)
+		conv, err := h.db.CreateConversation(title)
+		var conversationID string
+		if err != nil {
+			h.logger.Error("创建对话失败", zap.String("queueId", queueID), zap.String("taskId", task.ID), zap.Error(err))
+			h.batchTaskManager.UpdateTaskStatus(queueID, task.ID, "failed", "", "创建对话失败: "+err.Error())
+			h.batchTaskManager.MoveToNextTask(queueID)
+			continue
+		}
+		conversationID = conv.ID
+
+		// 保存conversationId到任务中（即使是运行中状态也要保存，以便查看对话）
+		h.batchTaskManager.UpdateTaskStatusWithConversationID(queueID, task.ID, "running", "", "", conversationID)
+
+		// 保存用户消息
+		_, err = h.db.AddMessage(conversationID, "user", task.Message, nil)
+		if err != nil {
+			h.logger.Error("保存用户消息失败", zap.String("queueId", queueID), zap.String("taskId", task.ID), zap.String("conversationId", conversationID), zap.Error(err))
+		}
+
+		// 执行任务
+		h.logger.Info("执行批量任务", zap.String("queueId", queueID), zap.String("taskId", task.ID), zap.String("message", task.Message), zap.String("conversationId", conversationID))
+
+		ctx, cancel := context.WithTimeout(context.Background(), 30*time.Minute)
+		result, err := h.agent.AgentLoopWithConversationID(ctx, task.Message, []agent.ChatMessage{}, conversationID)
+		cancel()
+
+		if err != nil {
+			h.logger.Error("批量任务执行失败", zap.String("queueId", queueID), zap.String("taskId", task.ID), zap.String("conversationId", conversationID), zap.Error(err))
+			h.batchTaskManager.UpdateTaskStatus(queueID, task.ID, "failed", "", err.Error())
+		} else {
+			h.logger.Info("批量任务执行成功", zap.String("queueId", queueID), zap.String("taskId", task.ID), zap.String("conversationId", conversationID))
+
+			// 保存助手回复
+			_, err = h.db.AddMessage(conversationID, "assistant", result.Response, result.MCPExecutionIDs)
+			if err != nil {
+				h.logger.Error("保存助手消息失败", zap.String("queueId", queueID), zap.String("taskId", task.ID), zap.String("conversationId", conversationID), zap.Error(err))
+			}
+
+			// 保存ReAct数据
+			if result.LastReActInput != "" || result.LastReActOutput != "" {
+				if err := h.db.SaveReActData(conversationID, result.LastReActInput, result.LastReActOutput); err != nil {
+					h.logger.Warn("保存ReAct数据失败", zap.String("queueId", queueID), zap.String("taskId", task.ID), zap.Error(err))
+				} else {
+					h.logger.Info("已保存ReAct数据", zap.String("queueId", queueID), zap.String("taskId", task.ID), zap.String("conversationId", conversationID))
+				}
+			}
+
+			// 保存结果
+			h.batchTaskManager.UpdateTaskStatusWithConversationID(queueID, task.ID, "completed", result.Response, "", conversationID)
+		}
+
+		// 移动到下一个任务
+		h.batchTaskManager.MoveToNextTask(queueID)
+
+		// 检查是否被取消
+		queue, _ = h.batchTaskManager.GetBatchQueue(queueID)
+		if queue.Status == "cancelled" {
+			break
+		}
+	}
+}
+
 // loadHistoryFromReActData 从保存的ReAct数据恢复历史消息上下文
 // 采用与攻击链生成类似的拼接逻辑：优先使用保存的last_react_input和last_react_output，若不存在则回退到消息表
 func (h *AgentHandler) loadHistoryFromReActData(conversationID string) ([]agent.ChatMessage, error) {

internal/handler/batch_task_manager.go

@@ -0,0 +1,589 @@
+package handler
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"fmt"
+	"sync"
+	"time"
+
+	"cyberstrike-ai/internal/database"
+)
+
+// BatchTask 批量任务项
+type BatchTask struct {
+	ID             string     `json:"id"`
+	Message        string     `json:"message"`
+	ConversationID string     `json:"conversationId,omitempty"`
+	Status         string     `json:"status"` // pending, running, completed, failed, cancelled
+	StartedAt      *time.Time `json:"startedAt,omitempty"`
+	CompletedAt    *time.Time `json:"completedAt,omitempty"`
+	Error          string     `json:"error,omitempty"`
+	Result         string     `json:"result,omitempty"`
+}
+
+// BatchTaskQueue 批量任务队列
+type BatchTaskQueue struct {
+	ID           string       `json:"id"`
+	Tasks        []*BatchTask `json:"tasks"`
+	Status       string       `json:"status"` // pending, running, paused, completed, cancelled
+	CreatedAt    time.Time    `json:"createdAt"`
+	StartedAt    *time.Time   `json:"startedAt,omitempty"`
+	CompletedAt  *time.Time   `json:"completedAt,omitempty"`
+	CurrentIndex int          `json:"currentIndex"`
+	mu           sync.RWMutex
+}
+
+// BatchTaskManager 批量任务管理器
+type BatchTaskManager struct {
+	db     *database.DB
+	queues map[string]*BatchTaskQueue
+	mu     sync.RWMutex
+}
+
+// NewBatchTaskManager 创建批量任务管理器
+func NewBatchTaskManager() *BatchTaskManager {
+	return &BatchTaskManager{
+		queues: make(map[string]*BatchTaskQueue),
+	}
+}
+
+// SetDB 设置数据库连接
+func (m *BatchTaskManager) SetDB(db *database.DB) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.db = db
+}
+
+// CreateBatchQueue 创建批量任务队列
+func (m *BatchTaskManager) CreateBatchQueue(tasks []string) *BatchTaskQueue {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	queueID := time.Now().Format("20060102150405") + "-" + generateShortID()
+	queue := &BatchTaskQueue{
+		ID:           queueID,
+		Tasks:        make([]*BatchTask, 0, len(tasks)),
+		Status:       "pending",
+		CreatedAt:    time.Now(),
+		CurrentIndex: 0,
+	}
+
+	// 准备数据库保存的任务数据
+	dbTasks := make([]map[string]interface{}, 0, len(tasks))
+
+	for _, message := range tasks {
+		if message == "" {
+			continue // 跳过空行
+		}
+		taskID := generateShortID()
+		task := &BatchTask{
+			ID:      taskID,
+			Message: message,
+			Status:  "pending",
+		}
+		queue.Tasks = append(queue.Tasks, task)
+		dbTasks = append(dbTasks, map[string]interface{}{
+			"id":      taskID,
+			"message": message,
+		})
+	}
+
+	// 保存到数据库
+	if m.db != nil {
+		if err := m.db.CreateBatchQueue(queueID, dbTasks); err != nil {
+			// 如果数据库保存失败，记录错误但继续（使用内存缓存）
+			// 这里可以添加日志记录
+		}
+	}
+
+	m.queues[queueID] = queue
+	return queue
+}
+
+// GetBatchQueue 获取批量任务队列
+func (m *BatchTaskManager) GetBatchQueue(queueID string) (*BatchTaskQueue, bool) {
+	m.mu.RLock()
+	queue, exists := m.queues[queueID]
+	m.mu.RUnlock()
+
+	if exists {
+		return queue, true
+	}
+
+	// 如果内存中不存在，尝试从数据库加载
+	if m.db != nil {
+		if queue := m.loadQueueFromDB(queueID); queue != nil {
+			m.mu.Lock()
+			m.queues[queueID] = queue
+			m.mu.Unlock()
+			return queue, true
+		}
+	}
+
+	return nil, false
+}
+
+// loadQueueFromDB 从数据库加载单个队列
+func (m *BatchTaskManager) loadQueueFromDB(queueID string) *BatchTaskQueue {
+	if m.db == nil {
+		return nil
+	}
+
+	queueRow, err := m.db.GetBatchQueue(queueID)
+	if err != nil || queueRow == nil {
+		return nil
+	}
+
+	taskRows, err := m.db.GetBatchTasks(queueID)
+	if err != nil {
+		return nil
+	}
+
+	queue := &BatchTaskQueue{
+		ID:           queueRow.ID,
+		Status:       queueRow.Status,
+		CreatedAt:    queueRow.CreatedAt,
+		CurrentIndex: queueRow.CurrentIndex,
+		Tasks:        make([]*BatchTask, 0, len(taskRows)),
+	}
+
+	if queueRow.StartedAt.Valid {
+		queue.StartedAt = &queueRow.StartedAt.Time
+	}
+	if queueRow.CompletedAt.Valid {
+		queue.CompletedAt = &queueRow.CompletedAt.Time
+	}
+
+	for _, taskRow := range taskRows {
+		task := &BatchTask{
+			ID:      taskRow.ID,
+			Message: taskRow.Message,
+			Status:  taskRow.Status,
+		}
+		if taskRow.ConversationID.Valid {
+			task.ConversationID = taskRow.ConversationID.String
+		}
+		if taskRow.StartedAt.Valid {
+			task.StartedAt = &taskRow.StartedAt.Time
+		}
+		if taskRow.CompletedAt.Valid {
+			task.CompletedAt = &taskRow.CompletedAt.Time
+		}
+		if taskRow.Error.Valid {
+			task.Error = taskRow.Error.String
+		}
+		if taskRow.Result.Valid {
+			task.Result = taskRow.Result.String
+		}
+		queue.Tasks = append(queue.Tasks, task)
+	}
+
+	return queue
+}
+
+// GetAllQueues 获取所有队列
+func (m *BatchTaskManager) GetAllQueues() []*BatchTaskQueue {
+	m.mu.RLock()
+	result := make([]*BatchTaskQueue, 0, len(m.queues))
+	for _, queue := range m.queues {
+		result = append(result, queue)
+	}
+	m.mu.RUnlock()
+
+	// 如果数据库可用，确保所有数据库中的队列都已加载到内存
+	if m.db != nil {
+		dbQueues, err := m.db.GetAllBatchQueues()
+		if err == nil {
+			m.mu.Lock()
+			for _, queueRow := range dbQueues {
+				if _, exists := m.queues[queueRow.ID]; !exists {
+					if queue := m.loadQueueFromDB(queueRow.ID); queue != nil {
+						m.queues[queueRow.ID] = queue
+						result = append(result, queue)
+					}
+				}
+			}
+			m.mu.Unlock()
+		}
+	}
+
+	return result
+}
+
+// LoadFromDB 从数据库加载所有队列
+func (m *BatchTaskManager) LoadFromDB() error {
+	if m.db == nil {
+		return nil
+	}
+
+	queueRows, err := m.db.GetAllBatchQueues()
+	if err != nil {
+		return err
+	}
+
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	for _, queueRow := range queueRows {
+		if _, exists := m.queues[queueRow.ID]; exists {
+			continue // 已存在，跳过
+		}
+
+		taskRows, err := m.db.GetBatchTasks(queueRow.ID)
+		if err != nil {
+			continue // 跳过加载失败的任务
+		}
+
+		queue := &BatchTaskQueue{
+			ID:           queueRow.ID,
+			Status:       queueRow.Status,
+			CreatedAt:    queueRow.CreatedAt,
+			CurrentIndex: queueRow.CurrentIndex,
+			Tasks:        make([]*BatchTask, 0, len(taskRows)),
+		}
+
+		if queueRow.StartedAt.Valid {
+			queue.StartedAt = &queueRow.StartedAt.Time
+		}
+		if queueRow.CompletedAt.Valid {
+			queue.CompletedAt = &queueRow.CompletedAt.Time
+		}
+
+		for _, taskRow := range taskRows {
+			task := &BatchTask{
+				ID:      taskRow.ID,
+				Message: taskRow.Message,
+				Status:  taskRow.Status,
+			}
+			if taskRow.ConversationID.Valid {
+				task.ConversationID = taskRow.ConversationID.String
+			}
+			if taskRow.StartedAt.Valid {
+				task.StartedAt = &taskRow.StartedAt.Time
+			}
+			if taskRow.CompletedAt.Valid {
+				task.CompletedAt = &taskRow.CompletedAt.Time
+			}
+			if taskRow.Error.Valid {
+				task.Error = taskRow.Error.String
+			}
+			if taskRow.Result.Valid {
+				task.Result = taskRow.Result.String
+			}
+			queue.Tasks = append(queue.Tasks, task)
+		}
+
+		m.queues[queueRow.ID] = queue
+	}
+
+	return nil
+}
+
+// UpdateTaskStatus 更新任务状态
+func (m *BatchTaskManager) UpdateTaskStatus(queueID, taskID, status string, result, errorMsg string) {
+	m.UpdateTaskStatusWithConversationID(queueID, taskID, status, result, errorMsg, "")
+}
+
+// UpdateTaskStatusWithConversationID 更新任务状态（包含conversationId）
+func (m *BatchTaskManager) UpdateTaskStatusWithConversationID(queueID, taskID, status string, result, errorMsg, conversationID string) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	queue, exists := m.queues[queueID]
+	if !exists {
+		return
+	}
+
+	for _, task := range queue.Tasks {
+		if task.ID == taskID {
+			task.Status = status
+			if result != "" {
+				task.Result = result
+			}
+			if errorMsg != "" {
+				task.Error = errorMsg
+			}
+			if conversationID != "" {
+				task.ConversationID = conversationID
+			}
+			now := time.Now()
+			if status == "running" && task.StartedAt == nil {
+				task.StartedAt = &now
+			}
+			if status == "completed" || status == "failed" || status == "cancelled" {
+				task.CompletedAt = &now
+			}
+			break
+		}
+	}
+
+	// 同步到数据库
+	if m.db != nil {
+		if err := m.db.UpdateBatchTaskStatus(queueID, taskID, status, conversationID, result, errorMsg); err != nil {
+			// 记录错误但继续（使用内存缓存）
+		}
+	}
+}
+
+// UpdateQueueStatus 更新队列状态
+func (m *BatchTaskManager) UpdateQueueStatus(queueID, status string) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	queue, exists := m.queues[queueID]
+	if !exists {
+		return
+	}
+
+	queue.Status = status
+	now := time.Now()
+	if status == "running" && queue.StartedAt == nil {
+		queue.StartedAt = &now
+	}
+	if status == "completed" || status == "cancelled" {
+		queue.CompletedAt = &now
+	}
+
+	// 同步到数据库
+	if m.db != nil {
+		if err := m.db.UpdateBatchQueueStatus(queueID, status); err != nil {
+			// 记录错误但继续（使用内存缓存）
+		}
+	}
+}
+
+// UpdateTaskMessage 更新任务消息（仅限待执行状态）
+func (m *BatchTaskManager) UpdateTaskMessage(queueID, taskID, message string) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	queue, exists := m.queues[queueID]
+	if !exists {
+		return fmt.Errorf("队列不存在")
+	}
+
+	// 检查队列状态，只有待执行状态的队列才能编辑任务
+	if queue.Status != "pending" {
+		return fmt.Errorf("只有待执行状态的队列才能编辑任务")
+	}
+
+	// 查找并更新任务
+	for _, task := range queue.Tasks {
+		if task.ID == taskID {
+			// 只有待执行状态的任务才能编辑
+			if task.Status != "pending" {
+				return fmt.Errorf("只有待执行状态的任务才能编辑")
+			}
+			task.Message = message
+
+			// 同步到数据库
+			if m.db != nil {
+				if err := m.db.UpdateBatchTaskMessage(queueID, taskID, message); err != nil {
+					return fmt.Errorf("更新任务消息失败: %w", err)
+				}
+			}
+			return nil
+		}
+	}
+
+	return fmt.Errorf("任务不存在")
+}
+
+// AddTaskToQueue 添加任务到队列（仅限待执行状态）
+func (m *BatchTaskManager) AddTaskToQueue(queueID, message string) (*BatchTask, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	queue, exists := m.queues[queueID]
+	if !exists {
+		return nil, fmt.Errorf("队列不存在")
+	}
+
+	// 检查队列状态，只有待执行状态的队列才能添加任务
+	if queue.Status != "pending" {
+		return nil, fmt.Errorf("只有待执行状态的队列才能添加任务")
+	}
+
+	if message == "" {
+		return nil, fmt.Errorf("任务消息不能为空")
+	}
+
+	// 生成任务ID
+	taskID := generateShortID()
+	task := &BatchTask{
+		ID:      taskID,
+		Message: message,
+		Status:  "pending",
+	}
+
+	// 添加到内存队列
+	queue.Tasks = append(queue.Tasks, task)
+
+	// 同步到数据库
+	if m.db != nil {
+		if err := m.db.AddBatchTask(queueID, taskID, message); err != nil {
+			// 如果数据库保存失败，从内存中移除
+			queue.Tasks = queue.Tasks[:len(queue.Tasks)-1]
+			return nil, fmt.Errorf("添加任务失败: %w", err)
+		}
+	}
+
+	return task, nil
+}
+
+// DeleteTask 删除任务（仅限待执行状态）
+func (m *BatchTaskManager) DeleteTask(queueID, taskID string) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	queue, exists := m.queues[queueID]
+	if !exists {
+		return fmt.Errorf("队列不存在")
+	}
+
+	// 检查队列状态，只有待执行状态的队列才能删除任务
+	if queue.Status != "pending" {
+		return fmt.Errorf("只有待执行状态的队列才能删除任务")
+	}
+
+	// 查找并删除任务
+	taskIndex := -1
+	for i, task := range queue.Tasks {
+		if task.ID == taskID {
+			// 只有待执行状态的任务才能删除
+			if task.Status != "pending" {
+				return fmt.Errorf("只有待执行状态的任务才能删除")
+			}
+			taskIndex = i
+			break
+		}
+	}
+
+	if taskIndex == -1 {
+		return fmt.Errorf("任务不存在")
+	}
+
+	// 从内存队列中删除
+	queue.Tasks = append(queue.Tasks[:taskIndex], queue.Tasks[taskIndex+1:]...)
+
+	// 同步到数据库
+	if m.db != nil {
+		if err := m.db.DeleteBatchTask(queueID, taskID); err != nil {
+			// 如果数据库删除失败，恢复内存中的任务
+			// 这里需要重新插入，但为了简化，我们只记录错误
+			return fmt.Errorf("删除任务失败: %w", err)
+		}
+	}
+
+	return nil
+}
+
+// GetNextTask 获取下一个待执行的任务
+func (m *BatchTaskManager) GetNextTask(queueID string) (*BatchTask, bool) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+
+	queue, exists := m.queues[queueID]
+	if !exists {
+		return nil, false
+	}
+
+	for i := queue.CurrentIndex; i < len(queue.Tasks); i++ {
+		task := queue.Tasks[i]
+		if task.Status == "pending" {
+			queue.CurrentIndex = i
+			return task, true
+		}
+	}
+
+	return nil, false
+}
+
+// MoveToNextTask 移动到下一个任务
+func (m *BatchTaskManager) MoveToNextTask(queueID string) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	queue, exists := m.queues[queueID]
+	if !exists {
+		return
+	}
+
+	queue.CurrentIndex++
+
+	// 同步到数据库
+	if m.db != nil {
+		if err := m.db.UpdateBatchQueueCurrentIndex(queueID, queue.CurrentIndex); err != nil {
+			// 记录错误但继续（使用内存缓存）
+		}
+	}
+}
+
+// CancelQueue 取消队列
+func (m *BatchTaskManager) CancelQueue(queueID string) bool {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	queue, exists := m.queues[queueID]
+	if !exists {
+		return false
+	}
+
+	if queue.Status == "completed" || queue.Status == "cancelled" {
+		return false
+	}
+
+	queue.Status = "cancelled"
+	now := time.Now()
+	queue.CompletedAt = &now
+
+	// 取消所有待执行的任务
+	for _, task := range queue.Tasks {
+		if task.Status == "pending" {
+			task.Status = "cancelled"
+			task.CompletedAt = &now
+			// 同步到数据库
+			if m.db != nil {
+				m.db.UpdateBatchTaskStatus(queueID, task.ID, "cancelled", "", "", "")
+			}
+		}
+	}
+
+	// 同步队列状态到数据库
+	if m.db != nil {
+		if err := m.db.UpdateBatchQueueStatus(queueID, "cancelled"); err != nil {
+			// 记录错误但继续（使用内存缓存）
+		}
+	}
+
+	return true
+}
+
+// DeleteQueue 删除队列
+func (m *BatchTaskManager) DeleteQueue(queueID string) bool {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	_, exists := m.queues[queueID]
+	if !exists {
+		return false
+	}
+
+	// 从数据库删除
+	if m.db != nil {
+		if err := m.db.DeleteBatchQueue(queueID); err != nil {
+			// 记录错误但继续（使用内存缓存）
+		}
+	}
+
+	delete(m.queues, queueID)
+	return true
+}
+
+// generateShortID 生成短ID
+func generateShortID() string {
+	b := make([]byte, 4)
+	rand.Read(b)
+	return time.Now().Format("150405") + "-" + hex.EncodeToString(b)
+}

internal/handler/task_manager.go

@@ -23,16 +23,31 @@ type AgentTask struct {
 	cancel func(error)
 }
 
+// CompletedTask 已完成的任务（用于历史记录）
+type CompletedTask struct {
+	ConversationID string    `json:"conversationId"`
+	Message        string    `json:"message,omitempty"`
+	StartedAt      time.Time `json:"startedAt"`
+	CompletedAt    time.Time `json:"completedAt"`
+	Status         string    `json:"status"`
+}
+
 // AgentTaskManager 管理正在运行的Agent任务
 type AgentTaskManager struct {
-	mu    sync.RWMutex
-	tasks map[string]*AgentTask
+	mu             sync.RWMutex
+	tasks          map[string]*AgentTask
+	completedTasks []*CompletedTask // 最近完成的任务历史
+	maxHistorySize int              // 最大历史记录数
+	historyRetention time.Duration  // 历史记录保留时间
 }
 
 // NewAgentTaskManager 创建任务管理器
 func NewAgentTaskManager() *AgentTaskManager {
 	return &AgentTaskManager{
-		tasks: make(map[string]*AgentTask),
+		tasks:            make(map[string]*AgentTask),
+		completedTasks:   make([]*CompletedTask, 0),
+		maxHistorySize:   50,                    // 最多保留50条历史记录
+		historyRetention: 24 * time.Hour,       // 保留24小时
 	}
 }
 
@@ -118,9 +133,49 @@ func (m *AgentTaskManager) FinishTask(conversationID string, finalStatus string)
 		task.Status = finalStatus
 	}
 
+	// 保存到历史记录
+	completedTask := &CompletedTask{
+		ConversationID: task.ConversationID,
+		Message:        task.Message,
+		StartedAt:       task.StartedAt,
+		CompletedAt:     time.Now(),
+		Status:          finalStatus,
+	}
+	
+	// 添加到历史记录
+	m.completedTasks = append(m.completedTasks, completedTask)
+	
+	// 清理过期和过多的历史记录
+	m.cleanupHistory()
+
+	// 从运行任务中移除
 	delete(m.tasks, conversationID)
 }
 
+// cleanupHistory 清理过期的历史记录
+func (m *AgentTaskManager) cleanupHistory() {
+	now := time.Now()
+	cutoffTime := now.Add(-m.historyRetention)
+	
+	// 过滤掉过期的记录
+	validTasks := make([]*CompletedTask, 0, len(m.completedTasks))
+	for _, task := range m.completedTasks {
+		if task.CompletedAt.After(cutoffTime) {
+			validTasks = append(validTasks, task)
+		}
+	}
+	
+	// 如果仍然超过最大数量，只保留最新的
+	if len(validTasks) > m.maxHistorySize {
+		// 按完成时间排序，保留最新的
+		// 由于是追加的，最新的在最后，所以直接取最后N个
+		start := len(validTasks) - m.maxHistorySize
+		validTasks = validTasks[start:]
+	}
+	
+	m.completedTasks = validTasks
+}
+
 // GetActiveTasks 返回所有正在运行的任务
 func (m *AgentTaskManager) GetActiveTasks() []*AgentTask {
 	m.mu.RLock()
@@ -137,3 +192,35 @@ func (m *AgentTaskManager) GetActiveTasks() []*AgentTask {
 	}
 	return result
 }
+
+// GetCompletedTasks 返回最近完成的任务历史
+func (m *AgentTaskManager) GetCompletedTasks() []*CompletedTask {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	
+	// 清理过期记录（只读锁，不影响其他操作）
+	// 注意：这里不能直接调用cleanupHistory，因为需要写锁
+	// 所以返回时过滤过期记录
+	now := time.Now()
+	cutoffTime := now.Add(-m.historyRetention)
+	
+	result := make([]*CompletedTask, 0, len(m.completedTasks))
+	for _, task := range m.completedTasks {
+		if task.CompletedAt.After(cutoffTime) {
+			result = append(result, task)
+		}
+	}
+	
+	// 按完成时间倒序排序（最新的在前）
+	// 由于是追加的，最新的在最后，需要反转
+	for i, j := 0, len(result)-1; i < j; i, j = i+1, j-1 {
+		result[i], result[j] = result[j], result[i]
+	}
+	
+	// 限制返回数量
+	if len(result) > m.maxHistorySize {
+		result = result[:m.maxHistorySize]
+	}
+	
+	return result
+}

web/static/css/style.css

@@ -6187,6 +6187,728 @@ header {
     background: rgba(0, 102, 255, 0.1);
 }
 
+/* 任务管理页面样式 */
+.tasks-stats-bar {
+    display: flex;
+    gap: 24px;
+    padding: 16px 20px;
+    background: linear-gradient(135deg, rgba(0, 102, 255, 0.05) 0%, rgba(0, 102, 255, 0.02) 100%);
+    border: 1px solid rgba(0, 102, 255, 0.15);
+    border-radius: 12px;
+    box-shadow: var(--shadow-sm);
+    margin-bottom: 24px;
+    flex-wrap: wrap;
+}
+
+.tasks-controls {
+    margin-bottom: 24px;
+}
+
+.tasks-filters {
+    display: flex;
+    gap: 16px;
+    align-items: flex-end;
+    flex-wrap: wrap;
+    padding: 16px;
+    background: var(--bg-secondary);
+    border: 1px solid var(--border-color);
+    border-radius: 12px;
+}
+
+.tasks-filters label {
+    display: flex;
+    flex-direction: column;
+    gap: 6px;
+    font-size: 0.875rem;
+    color: var(--text-secondary);
+    font-weight: 500;
+}
+
+.tasks-filters select {
+    padding: 8px 12px;
+    border: 1px solid var(--border-color);
+    border-radius: 6px;
+    font-size: 0.875rem;
+    background: var(--bg-primary);
+    color: var(--text-primary);
+    min-width: 150px;
+    cursor: pointer;
+    transition: all 0.2s;
+}
+
+.tasks-filters select:focus {
+    outline: none;
+    border-color: var(--accent-color);
+    box-shadow: 0 0 0 2px rgba(0, 102, 255, 0.1);
+}
+
+.tasks-filters select:hover {
+    border-color: var(--accent-color);
+}
+
+.tasks-batch-actions {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    padding: 12px 16px;
+    background: rgba(0, 102, 255, 0.05);
+    border: 1px solid rgba(0, 102, 255, 0.2);
+    border-radius: 8px;
+    margin-top: 12px;
+}
+
+.tasks-batch-actions span {
+    font-size: 0.875rem;
+    color: var(--text-primary);
+    font-weight: 500;
+}
+
+.auto-refresh-toggle {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    font-size: 0.875rem;
+    color: var(--text-primary);
+    cursor: pointer;
+    user-select: none;
+}
+
+.auto-refresh-toggle input[type="checkbox"] {
+    width: 18px;
+    height: 18px;
+    cursor: pointer;
+    accent-color: var(--accent-color);
+}
+
+.page-header-actions {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+}
+
+.show-history-toggle {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    font-size: 0.875rem;
+    color: var(--text-primary);
+    cursor: pointer;
+    user-select: none;
+    margin-left: auto;
+}
+
+.show-history-toggle input[type="checkbox"] {
+    width: 18px;
+    height: 18px;
+    cursor: pointer;
+    accent-color: var(--accent-color);
+}
+
+.tasks-history-section {
+    margin-top: 32px;
+    padding-top: 24px;
+    border-top: 2px solid var(--border-color);
+}
+
+.tasks-history-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 16px;
+    padding-bottom: 12px;
+    border-bottom: 1px solid var(--border-color);
+}
+
+.tasks-history-title {
+    font-size: 0.9375rem;
+    font-weight: 600;
+    color: var(--text-secondary);
+}
+
+.task-item-history {
+    opacity: 0.85;
+}
+
+.task-item-history:hover {
+    opacity: 1;
+}
+
+.task-history-badge {
+    font-size: 0.875rem;
+    margin-left: 4px;
+    opacity: 0.7;
+}
+
+.task-stat-item {
+    display: flex;
+    flex-direction: column;
+    gap: 4px;
+}
+
+.task-stat-label {
+    font-size: 0.8125rem;
+    color: var(--text-secondary);
+    font-weight: 500;
+}
+
+.task-stat-value {
+    font-size: 1.5rem;
+    font-weight: 600;
+    color: var(--accent-color);
+}
+
+.tasks-list {
+    display: flex;
+    flex-direction: column;
+    gap: 16px;
+}
+
+.tasks-empty {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    padding: 60px 20px;
+    text-align: center;
+    color: var(--text-secondary);
+}
+
+.tasks-empty p {
+    font-size: 1rem;
+    margin-bottom: 16px;
+}
+
+.task-item {
+    background: var(--bg-primary);
+    border: 1px solid var(--border-color);
+    border-radius: 12px;
+    padding: 20px;
+    box-shadow: var(--shadow-sm);
+    transition: all 0.2s ease;
+}
+
+.task-item:hover {
+    box-shadow: var(--shadow-md);
+    transform: translateY(-2px);
+}
+
+.task-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    gap: 16px;
+    flex-wrap: wrap;
+}
+
+.task-info {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    flex: 1;
+    min-width: 200px;
+}
+
+.task-checkbox {
+    display: flex;
+    align-items: center;
+    cursor: pointer;
+}
+
+.task-checkbox input[type="checkbox"] {
+    width: 18px;
+    height: 18px;
+    cursor: pointer;
+    accent-color: var(--accent-color);
+}
+
+.task-checkbox-placeholder {
+    width: 18px;
+    height: 18px;
+}
+
+.task-status {
+    display: inline-flex;
+    align-items: center;
+    padding: 4px 12px;
+    border-radius: 12px;
+    font-size: 0.8125rem;
+    font-weight: 500;
+    white-space: nowrap;
+}
+
+.task-status-running {
+    background: rgba(0, 123, 255, 0.1);
+    color: var(--accent-color);
+    border: 1px solid rgba(0, 123, 255, 0.3);
+}
+
+.task-status-cancelling {
+    background: rgba(255, 193, 7, 0.1);
+    color: #b8860b;
+    border: 1px solid rgba(255, 193, 7, 0.3);
+}
+
+.task-status-completed {
+    background: rgba(40, 167, 69, 0.1);
+    color: var(--success-color);
+    border: 1px solid rgba(40, 167, 69, 0.3);
+}
+
+.task-status-failed,
+.task-status-timeout {
+    background: rgba(220, 53, 69, 0.1);
+    color: var(--error-color);
+    border: 1px solid rgba(220, 53, 69, 0.3);
+}
+
+.task-status-cancelled {
+    background: rgba(108, 117, 125, 0.1);
+    color: var(--text-secondary);
+    border: 1px solid rgba(108, 117, 125, 0.3);
+}
+
+.task-status-unknown {
+    background: var(--bg-secondary);
+    color: var(--text-secondary);
+    border: 1px solid var(--border-color);
+}
+
+.task-message {
+    font-size: 0.9375rem;
+    color: var(--text-primary);
+    font-weight: 500;
+    word-break: break-word;
+}
+
+.task-actions {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    flex-wrap: wrap;
+}
+
+.task-time {
+    font-size: 0.8125rem;
+    color: var(--text-secondary);
+    white-space: nowrap;
+}
+
+.task-duration {
+    font-size: 0.8125rem;
+    color: var(--accent-color);
+    font-weight: 500;
+    white-space: nowrap;
+    padding: 4px 8px;
+    background: rgba(0, 102, 255, 0.1);
+    border-radius: 4px;
+}
+
+.task-details {
+    margin-top: 12px;
+    padding-top: 12px;
+    border-top: 1px solid var(--border-color);
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    font-size: 0.8125rem;
+}
+
+.task-id-label {
+    color: var(--text-secondary);
+    font-weight: 500;
+}
+
+.task-id-value {
+    color: var(--text-primary);
+    font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
+    background: var(--bg-secondary);
+    padding: 2px 8px;
+    border-radius: 4px;
+    word-break: break-all;
+    cursor: pointer;
+    transition: all 0.2s;
+}
+
+.task-id-value:hover {
+    background: var(--bg-tertiary);
+    color: var(--accent-color);
+}
+
+@media (max-width: 768px) {
+    .tasks-stats-bar {
+        flex-direction: column;
+        gap: 12px;
+    }
+    
+    .task-stat-item {
+        flex-direction: row;
+        justify-content: space-between;
+        align-items: center;
+    }
+    
+    .tasks-filters {
+        flex-direction: column;
+        align-items: stretch;
+    }
+    
+    .tasks-filters select {
+        min-width: 100%;
+    }
+    
+    .tasks-batch-actions {
+        flex-direction: column;
+        align-items: stretch;
+    }
+    
+    .page-header-actions {
+        flex-direction: column;
+        align-items: stretch;
+    }
+    
+    .task-header {
+        flex-direction: column;
+        align-items: flex-start;
+    }
+    
+    .task-actions {
+        width: 100%;
+        justify-content: flex-end;
+        flex-wrap: wrap;
+    }
+    
+    .task-duration {
+        font-size: 0.75rem;
+        padding: 2px 6px;
+    }
+}
+
+/* 批量任务相关样式 */
+.batch-queues-section {
+    margin-top: 32px;
+    padding-top: 24px;
+    border-top: 2px solid var(--border-color);
+}
+
+.batch-queues-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 16px;
+    padding-bottom: 12px;
+    border-bottom: 1px solid var(--border-color);
+}
+
+.batch-queues-header h3 {
+    margin: 0;
+    font-size: 1.125rem;
+    font-weight: 600;
+    color: var(--text-primary);
+}
+
+.batch-queues-list {
+    display: flex;
+    flex-direction: column;
+    gap: 16px;
+}
+
+.batch-queue-item {
+    background: var(--bg-primary);
+    border: 1px solid var(--border-color);
+    border-radius: 12px;
+    padding: 20px;
+    box-shadow: var(--shadow-sm);
+    transition: all 0.2s ease;
+    cursor: pointer;
+}
+
+.batch-queue-item:hover {
+    box-shadow: var(--shadow-md);
+    transform: translateY(-2px);
+    border-color: var(--accent-color);
+}
+
+.batch-queue-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    gap: 16px;
+    margin-bottom: 12px;
+    flex-wrap: wrap;
+}
+
+.batch-queue-info {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    flex: 1;
+    flex-wrap: wrap;
+}
+
+.batch-queue-status {
+    display: inline-flex;
+    align-items: center;
+    padding: 4px 12px;
+    border-radius: 12px;
+    font-size: 0.8125rem;
+    font-weight: 500;
+    white-space: nowrap;
+}
+
+.batch-queue-status-pending {
+    background: rgba(108, 117, 125, 0.1);
+    color: var(--text-secondary);
+    border: 1px solid rgba(108, 117, 125, 0.3);
+}
+
+.batch-queue-status-running {
+    background: rgba(0, 123, 255, 0.1);
+    color: var(--accent-color);
+    border: 1px solid rgba(0, 123, 255, 0.3);
+}
+
+.batch-queue-status-completed {
+    background: rgba(40, 167, 69, 0.1);
+    color: var(--success-color);
+    border: 1px solid rgba(40, 167, 69, 0.3);
+}
+
+.batch-queue-status-cancelled {
+    background: rgba(108, 117, 125, 0.1);
+    color: var(--text-secondary);
+    border: 1px solid rgba(108, 117, 125, 0.3);
+}
+
+.batch-queue-id {
+    font-size: 0.8125rem;
+    color: var(--text-secondary);
+    font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
+}
+
+.batch-queue-time {
+    font-size: 0.8125rem;
+    color: var(--text-secondary);
+}
+
+.batch-queue-progress {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    min-width: 200px;
+}
+
+.batch-queue-progress-bar {
+    flex: 1;
+    height: 8px;
+    background: var(--bg-secondary);
+    border-radius: 4px;
+    overflow: hidden;
+}
+
+.batch-queue-progress-fill {
+    height: 100%;
+    background: linear-gradient(90deg, var(--accent-color) 0%, var(--accent-hover) 100%);
+    transition: width 0.3s ease;
+}
+
+.batch-queue-progress-text {
+    font-size: 0.8125rem;
+    color: var(--text-secondary);
+    white-space: nowrap;
+    min-width: 60px;
+    text-align: right;
+}
+
+.batch-queue-stats {
+    display: flex;
+    gap: 16px;
+    flex-wrap: wrap;
+    font-size: 0.8125rem;
+    color: var(--text-secondary);
+}
+
+.batch-queue-stats span {
+    white-space: nowrap;
+}
+
+.batch-queue-detail-info {
+    margin-bottom: 24px;
+    padding: 16px;
+    background: var(--bg-secondary);
+    border-radius: 8px;
+}
+
+.batch-queue-detail-info .detail-item {
+    margin-bottom: 8px;
+    font-size: 0.875rem;
+}
+
+.batch-queue-detail-info .detail-item strong {
+    color: var(--text-primary);
+    margin-right: 8px;
+}
+
+.batch-queue-tasks-list {
+    max-height: 500px;
+    overflow-y: auto;
+}
+
+.batch-queue-tasks-list h4 {
+    margin: 0 0 16px 0;
+    font-size: 1rem;
+    font-weight: 600;
+    color: var(--text-primary);
+}
+
+.batch-task-item {
+    background: var(--bg-primary);
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    padding: 16px;
+    margin-bottom: 12px;
+    transition: all 0.2s ease;
+}
+
+.batch-task-item:hover {
+    box-shadow: var(--shadow-sm);
+}
+
+.batch-task-item-active {
+    border-color: var(--accent-color);
+    background: rgba(0, 102, 255, 0.02);
+}
+
+.batch-task-header {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    margin-bottom: 8px;
+    flex-wrap: wrap;
+}
+
+.batch-task-header .btn-small {
+    margin-left: auto;
+    flex-shrink: 0;
+}
+
+.batch-task-header .batch-task-edit-btn {
+    margin-left: 8px;
+}
+
+.batch-task-header .batch-task-delete-btn {
+    margin-left: 8px;
+}
+
+.batch-task-index {
+    font-weight: 600;
+    color: var(--text-secondary);
+    min-width: 30px;
+}
+
+.batch-task-status {
+    display: inline-flex;
+    align-items: center;
+    padding: 2px 8px;
+    border-radius: 8px;
+    font-size: 0.75rem;
+    font-weight: 500;
+    white-space: nowrap;
+}
+
+.batch-task-status-pending {
+    background: rgba(108, 117, 125, 0.1);
+    color: var(--text-secondary);
+}
+
+.batch-task-status-running {
+    background: rgba(0, 123, 255, 0.1);
+    color: var(--accent-color);
+}
+
+.batch-task-status-completed {
+    background: rgba(40, 167, 69, 0.1);
+    color: var(--success-color);
+}
+
+.batch-task-status-failed {
+    background: rgba(220, 53, 69, 0.1);
+    color: var(--error-color);
+}
+
+.batch-task-status-cancelled {
+    background: rgba(108, 117, 125, 0.1);
+    color: var(--text-secondary);
+}
+
+.batch-task-message {
+    flex: 1;
+    font-size: 0.875rem;
+    color: var(--text-primary);
+    word-break: break-word;
+}
+
+.batch-task-time {
+    font-size: 0.75rem;
+    color: var(--text-secondary);
+    margin-top: 4px;
+}
+
+.batch-task-error {
+    font-size: 0.8125rem;
+    color: var(--error-color);
+    margin-top: 8px;
+    padding: 8px;
+    background: rgba(220, 53, 69, 0.05);
+    border-radius: 4px;
+    border-left: 3px solid var(--error-color);
+}
+
+.batch-task-result {
+    font-size: 0.8125rem;
+    color: var(--text-primary);
+    margin-top: 8px;
+    padding: 8px;
+    background: var(--bg-secondary);
+    border-radius: 4px;
+    max-height: 150px;
+    overflow-y: auto;
+    word-break: break-word;
+}
+
+.batch-import-stats {
+    display: none;
+    padding: 8px 12px;
+    background: rgba(0, 102, 255, 0.05);
+    border: 1px solid rgba(0, 102, 255, 0.2);
+    border-radius: 6px;
+    font-size: 0.875rem;
+    color: var(--accent-color);
+}
+
+.batch-import-stat {
+    font-weight: 500;
+}
+
+@media (max-width: 768px) {
+    .batch-queue-header {
+        flex-direction: column;
+        align-items: flex-start;
+    }
+    
+    .batch-queue-progress {
+        width: 100%;
+    }
+    
+    .batch-queue-stats {
+        flex-direction: column;
+        gap: 8px;
+    }
+    
+    .batch-task-header {
+        flex-direction: column;
+        align-items: flex-start;
+    }
+}
+
 /* 漏洞管理页面样式 */
 .vulnerability-dashboard {
     margin-bottom: 24px;

web/static/js/chat.js

@@ -3778,7 +3778,18 @@ let pendingGroupMappings = {}; // 待保留的分组映射（用于处理后端A
 async function loadGroups() {
     try {
         const response = await apiFetch('/api/groups');
-        groupsCache = await response.json();
+        if (!response.ok) {
+            groupsCache = [];
+            return;
+        }
+        const data = await response.json();
+        // 确保groupsCache是有效数组
+        if (Array.isArray(data)) {
+            groupsCache = data;
+        } else {
+            // 如果返回的不是数组，使用空数组（不打印警告，因为可能后端返回了错误格式但我们要优雅处理）
+            groupsCache = [];
+        }
 
         const groupsList = document.getElementById('conversation-groups-list');
         if (!groupsList) return;
@@ -4723,13 +4734,20 @@ async function loadConversationGroupMapping() {
             groups = groupsCache;
         } else {
             const response = await apiFetch('/api/groups');
-            groups = await response.json();
-        }
-        
-        // 确保groups是有效数组
-        if (!Array.isArray(groups)) {
-            console.warn('loadConversationGroupMapping: groups不是有效数组，使用空数组');
-            groups = [];
+            if (!response.ok) {
+                // 如果API请求失败，使用空数组，不打印警告（这是正常错误处理）
+                groups = [];
+            } else {
+                groups = await response.json();
+                // 确保groups是有效数组，只在真正异常时才打印警告
+                if (!Array.isArray(groups)) {
+                    // 只在返回的不是数组且不是null/undefined时才打印警告（可能是后端返回了错误格式）
+                    if (groups !== null && groups !== undefined) {
+                        console.warn('loadConversationGroupMapping: groups不是有效数组，使用空数组', groups);
+                    }
+                    groups = [];
+                }
+            }
         }
         
         // 保存待保留的映射

web/static/js/router.js

@@ -3,14 +3,37 @@ let currentPage = 'chat';
 
 // 初始化路由
 function initRouter() {
-    // 默认显示对话页面
-    switchPage('chat');
-    
     // 从URL hash读取页面（如果有）
     const hash = window.location.hash.slice(1);
-    if (hash && ['chat', 'vulnerabilities', 'mcp-monitor', 'mcp-management', 'knowledge-management', 'knowledge-retrieval-logs', 'settings'].includes(hash)) {
-        switchPage(hash);
+    if (hash) {
+        const hashParts = hash.split('?');
+        const pageId = hashParts[0];
+        if (pageId && ['chat', 'vulnerabilities', 'mcp-monitor', 'mcp-management', 'knowledge-management', 'knowledge-retrieval-logs', 'settings', 'tasks'].includes(pageId)) {
+            switchPage(pageId);
+            
+            // 如果是chat页面且带有conversation参数，加载对应对话
+            if (pageId === 'chat' && hashParts.length > 1) {
+                const params = new URLSearchParams(hashParts[1]);
+                const conversationId = params.get('conversation');
+                if (conversationId) {
+                    setTimeout(() => {
+                        // 尝试多种方式调用loadConversation
+                        if (typeof loadConversation === 'function') {
+                            loadConversation(conversationId);
+                        } else if (typeof window.loadConversation === 'function') {
+                            window.loadConversation(conversationId);
+                        } else {
+                            console.warn('loadConversation function not found');
+                        }
+                    }, 500);
+                }
+            }
+            return;
+        }
     }
+    
+    // 默认显示对话页面
+    switchPage('chat');
 }
 
 // 切换页面
@@ -178,6 +201,12 @@ function initPage(pageId) {
         case 'chat':
             // 对话页面已由chat.js初始化
             break;
+        case 'tasks':
+            // 初始化任务管理页面
+            if (typeof initTasksPage === 'function') {
+                initTasksPage();
+            }
+            break;
         case 'mcp-monitor':
             // 初始化监控面板
             if (typeof refreshMonitorPanel === 'function') {
@@ -211,6 +240,11 @@ function initPage(pageId) {
             }
             break;
     }
+    
+    // 清理其他页面的定时器
+    if (pageId !== 'tasks' && typeof cleanupTasksPage === 'function') {
+        cleanupTasksPage();
+    }
 }
 
 // 页面加载完成后初始化路由
@@ -221,10 +255,48 @@ document.addEventListener('DOMContentLoaded', function() {
     // 监听hash变化
     window.addEventListener('hashchange', function() {
         const hash = window.location.hash.slice(1);
-        if (hash && ['chat', 'vulnerabilities', 'mcp-monitor', 'mcp-management', 'knowledge-management', 'knowledge-retrieval-logs', 'settings'].includes(hash)) {
-            switchPage(hash);
+        // 处理带参数的hash（如 chat?conversation=xxx）
+        const hashParts = hash.split('?');
+        const pageId = hashParts[0];
+        
+        if (pageId && ['chat', 'tasks', 'vulnerabilities', 'mcp-monitor', 'mcp-management', 'knowledge-management', 'knowledge-retrieval-logs', 'settings'].includes(pageId)) {
+            switchPage(pageId);
+            
+            // 如果是chat页面且带有conversation参数，加载对应对话
+            if (pageId === 'chat' && hashParts.length > 1) {
+                const params = new URLSearchParams(hashParts[1]);
+                const conversationId = params.get('conversation');
+                if (conversationId) {
+                    setTimeout(() => {
+                        // 尝试多种方式调用loadConversation
+                        if (typeof loadConversation === 'function') {
+                            loadConversation(conversationId);
+                        } else if (typeof window.loadConversation === 'function') {
+                            window.loadConversation(conversationId);
+                        } else {
+                            console.warn('loadConversation function not found');
+                        }
+                    }, 200);
+                }
+            }
         }
     });
+    
+    // 页面加载时也检查hash参数
+    const hash = window.location.hash.slice(1);
+    if (hash) {
+        const hashParts = hash.split('?');
+        const pageId = hashParts[0];
+        if (pageId === 'chat' && hashParts.length > 1) {
+            const params = new URLSearchParams(hashParts[1]);
+            const conversationId = params.get('conversation');
+            if (conversationId && typeof loadConversation === 'function') {
+                setTimeout(() => {
+                    loadConversation(conversationId);
+                }, 500);
+            }
+        }
+    }
 });
 
 // 切换侧边栏折叠/展开

web/templates/index.html

@@ -76,6 +76,17 @@
                             <span>对话</span>
                         </div>
                     </div>
+                    <div class="nav-item" data-page="tasks">
+                        <div class="nav-item-content" data-title="任务管理" onclick="switchPage('tasks')">
+                            <svg width="20" height="20" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+                                <path d="M13 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V9z" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+                                <polyline points="13 2 13 9 20 9" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+                                <line x1="9" y1="13" x2="15" y2="13" stroke="currentColor" stroke-width="2" stroke-linecap="round"/>
+                                <line x1="9" y1="17" x2="15" y2="17" stroke="currentColor" stroke-width="2" stroke-linecap="round"/>
+                            </svg>
+                            <span>任务管理</span>
+                        </div>
+                    </div>
                     <div class="nav-item" data-page="vulnerabilities">
                         <div class="nav-item-content" data-title="漏洞管理" onclick="switchPage('vulnerabilities')">
                             <svg width="20" height="20" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
@@ -541,6 +552,31 @@
                     </div>
                 </div>
 
+                <!-- 任务管理页面 -->
+                <div id="page-tasks" class="page">
+                    <div class="page-header">
+                        <h2>任务管理</h2>
+                        <div class="page-header-actions">
+                            <button class="btn-primary" onclick="showBatchImportModal()">批量导入任务</button>
+                            <label class="auto-refresh-toggle">
+                                <input type="checkbox" id="tasks-auto-refresh" checked onchange="toggleTasksAutoRefresh(this.checked)">
+                                <span>自动刷新</span>
+                            </label>
+                            <button class="btn-secondary" onclick="refreshBatchQueues()">刷新</button>
+                        </div>
+                    </div>
+                    <div class="page-content">
+                        <!-- 批量任务队列列表 -->
+                        <div class="batch-queues-section" id="batch-queues-section" style="display: none;">
+                            <div class="batch-queues-header">
+                                <h3>批量任务队列</h3>
+                                <button class="btn-secondary btn-small" onclick="refreshBatchQueues()">刷新</button>
+                            </div>
+                            <div id="batch-queues-list" class="batch-queues-list"></div>
+                        </div>
+                    </div>
+                </div>
+
                 <!-- 系统设置页面 -->
                 <div id="page-settings" class="page">
                     <div class="page-header">
@@ -1096,6 +1132,91 @@
         </div>
     </div>
 
+    <!-- 批量导入任务模态框 -->
+    <div id="batch-import-modal" class="modal">
+        <div class="modal-content" style="max-width: 800px;">
+            <div class="modal-header">
+                <h2>批量导入任务</h2>
+                <span class="modal-close" onclick="closeBatchImportModal()">&times;</span>
+            </div>
+            <div class="modal-body">
+                <div class="form-group">
+                    <label for="batch-tasks-input">任务列表（每行一个任务）<span style="color: red;">*</span></label>
+                    <textarea id="batch-tasks-input" rows="15" placeholder="请输入任务列表，每行一个任务，例如：&#10;扫描 192.168.1.1 的开放端口&#10;检查 https://example.com 是否存在SQL注入&#10;枚举 example.com 的子域名" style="font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace; font-size: 0.875rem; line-height: 1.5;"></textarea>
+                    <div class="form-hint" style="margin-top: 8px;">
+                        <strong>提示：</strong>每行输入一个任务指令，系统将依次执行这些任务。空行会被自动忽略。
+                    </div>
+                </div>
+                <div class="form-group">
+                    <div id="batch-import-stats" class="batch-import-stats"></div>
+                </div>
+            </div>
+            <div class="modal-footer">
+                <button class="btn-secondary" onclick="closeBatchImportModal()">取消</button>
+                <button class="btn-primary" onclick="createBatchQueue()">创建队列</button>
+            </div>
+        </div>
+    </div>
+
+    <!-- 批量任务队列详情模态框 -->
+    <div id="batch-queue-detail-modal" class="modal">
+        <div class="modal-content" style="max-width: 900px;">
+            <div class="modal-header">
+                <h2 id="batch-queue-detail-title">批量任务队列详情</h2>
+                <div class="modal-header-actions">
+                    <button class="btn-secondary" id="batch-queue-add-task-btn" onclick="showAddBatchTaskModal()" style="display: none;">添加任务</button>
+                    <button class="btn-secondary" id="batch-queue-start-btn" onclick="startBatchQueue()" style="display: none;">开始执行</button>
+                    <button class="btn-secondary btn-danger" id="batch-queue-cancel-btn" onclick="cancelBatchQueue()" style="display: none;">取消队列</button>
+                    <button class="btn-secondary btn-danger" id="batch-queue-delete-btn" onclick="deleteBatchQueue()" style="display: none;">删除队列</button>
+                    <span class="modal-close" onclick="closeBatchQueueDetailModal()">&times;</span>
+                </div>
+            </div>
+            <div class="modal-body">
+                <div id="batch-queue-detail-content"></div>
+            </div>
+        </div>
+    </div>
+
+    <!-- 编辑批量任务模态框 -->
+    <div id="edit-batch-task-modal" class="modal">
+        <div class="modal-content" style="max-width: 600px;">
+            <div class="modal-header">
+                <h2>编辑任务</h2>
+                <span class="modal-close" onclick="closeEditBatchTaskModal()">&times;</span>
+            </div>
+            <div class="modal-body">
+                <div class="form-group">
+                    <label for="edit-task-message">任务消息</label>
+                    <textarea id="edit-task-message" class="form-control" rows="5" placeholder="请输入任务消息"></textarea>
+                </div>
+                <div class="form-actions">
+                    <button class="btn-primary" onclick="saveBatchTask()">保存</button>
+                    <button class="btn-secondary" onclick="closeEditBatchTaskModal()">取消</button>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- 添加批量任务模态框 -->
+    <div id="add-batch-task-modal" class="modal">
+        <div class="modal-content" style="max-width: 600px;">
+            <div class="modal-header">
+                <h2>添加任务</h2>
+                <span class="modal-close" onclick="closeAddBatchTaskModal()">&times;</span>
+            </div>
+            <div class="modal-body">
+                <div class="form-group">
+                    <label for="add-task-message">任务消息</label>
+                    <textarea id="add-task-message" class="form-control" rows="5" placeholder="请输入任务消息"></textarea>
+                </div>
+                <div class="form-actions">
+                    <button class="btn-primary" onclick="saveAddBatchTask()">添加</button>
+                    <button class="btn-secondary" onclick="closeAddBatchTaskModal()">取消</button>
+                </div>
+            </div>
+        </div>
+    </div>
+
     <!-- 漏洞编辑模态框 -->
     <div id="vulnerability-modal" class="modal">
         <div class="modal-content" style="max-width: 900px;">
@@ -1171,6 +1292,7 @@
     <script src="/static/js/settings.js"></script>
     <script src="/static/js/knowledge.js"></script>
     <script src="/static/js/vulnerability.js?v=4"></script>
+    <script src="/static/js/tasks.js"></script>
 </body>
 </html>