Add files via upload

config.yaml

@@ -10,7 +10,7 @@
 # ============================================
 
 # 前端显示的版本号（可选，不填则显示默认版本）
-version: "v1.4.14"
+version: "v1.4.16"
 # 服务器配置
 server:
   host: 0.0.0.0 # 监听地址，0.0.0.0 表示监听所有网络接口

go.mod

@@ -21,6 +21,7 @@ require (
 	github.com/modelcontextprotocol/go-sdk v1.2.0
 	github.com/open-dingtalk/dingtalk-stream-sdk-go v0.9.1
 	github.com/pkoukk/tiktoken-go v0.1.8
+	github.com/robfig/cron/v3 v3.0.1
 	go.uber.org/zap v1.26.0
 	golang.org/x/time v0.14.0
 	gopkg.in/yaml.v3 v3.0.1

go.sum

@@ -136,6 +136,8 @@ github.com/pkoukk/tiktoken-go v0.1.8 h1:85ENo+3FpWgAACBaEUVp+lctuTcYUO7BtmfhlN/Q
 github.com/pkoukk/tiktoken-go v0.1.8/go.mod h1:9NiV+i9mJKGj1rYOT+njbv+ZwA/zJxYdewGl6qVatpg=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
+github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
 github.com/rollbar/rollbar-go v1.0.2/go.mod h1:AcFs5f0I+c71bpHlXNNDbOWJiKwjFDtISeXco0L5PKQ=
 github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
 github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=

internal/app/app.go

@@ -404,6 +404,13 @@ func New(cfg *config.Config, log *logger.Logger) (*App, error) {
 	}
 	configHandler.SetSkillsToolRegistrar(skillsRegistrar)
 
+	handler.RegisterBatchTaskMCPTools(mcpServer, agentHandler, log.Logger)
+	batchTaskToolRegistrar := func() error {
+		handler.RegisterBatchTaskMCPTools(mcpServer, agentHandler, log.Logger)
+		return nil
+	}
+	configHandler.SetBatchTaskToolRegistrar(batchTaskToolRegistrar)
+
 	// 设置知识库初始化器（用于动态初始化，需要在 App 创建后设置）
 	configHandler.SetKnowledgeInitializer(func() (*handler.KnowledgeHandler, error) {
 		knowledgeHandler, err := initializeKnowledge(cfg, db, knowledgeDBConn, mcpServer, agentHandler, app, log.Logger)
@@ -652,6 +659,7 @@ func setupRoutes(
 		protected.GET("/batch-tasks/:queueId", agentHandler.GetBatchQueue)
 		protected.POST("/batch-tasks/:queueId/start", agentHandler.StartBatchQueue)
 		protected.POST("/batch-tasks/:queueId/pause", agentHandler.PauseBatchQueue)
+		protected.PUT("/batch-tasks/:queueId/schedule-enabled", agentHandler.SetBatchQueueScheduleEnabled)
 		protected.DELETE("/batch-tasks/:queueId", agentHandler.DeleteBatchQueue)
 		protected.PUT("/batch-tasks/:queueId/tasks/:taskId", agentHandler.UpdateBatchTask)
 		protected.POST("/batch-tasks/:queueId/tasks", agentHandler.AddBatchTask)
@@ -1333,8 +1341,8 @@ func registerWebshellManagementTools(mcpServer *mcp.Server, db *database.DB, web
 
 	// manage_webshell_add - 添加新的 webshell 连接
 	addTool := mcp.Tool{
-		Name:        builtin.ToolManageWebshellAdd,
-		Description: "添加新的 WebShell 连接到管理系统。支持 PHP、ASP、ASPX、JSP 等类型的一句话木马。",
+		Name:             builtin.ToolManageWebshellAdd,
+		Description:      "添加新的 WebShell 连接到管理系统。支持 PHP、ASP、ASPX、JSP 等类型的一句话木马。",
 		ShortDescription: "添加 WebShell 连接",
 		InputSchema: map[string]interface{}{
 			"type": "object",
@@ -1425,8 +1433,8 @@ func registerWebshellManagementTools(mcpServer *mcp.Server, db *database.DB, web
 
 	// manage_webshell_update - 更新 webshell 连接
 	updateTool := mcp.Tool{
-		Name:        builtin.ToolManageWebshellUpdate,
-		Description: "更新已存在的 WebShell 连接信息。",
+		Name:             builtin.ToolManageWebshellUpdate,
+		Description:      "更新已存在的 WebShell 连接信息。",
 		ShortDescription: "更新 WebShell 连接",
 		InputSchema: map[string]interface{}{
 			"type": "object",
@@ -1522,8 +1530,8 @@ func registerWebshellManagementTools(mcpServer *mcp.Server, db *database.DB, web
 
 	// manage_webshell_delete - 删除 webshell 连接
 	deleteTool := mcp.Tool{
-		Name:        builtin.ToolManageWebshellDelete,
-		Description: "删除指定的 WebShell 连接。",
+		Name:             builtin.ToolManageWebshellDelete,
+		Description:      "删除指定的 WebShell 连接。",
 		ShortDescription: "删除 WebShell 连接",
 		InputSchema: map[string]interface{}{
 			"type": "object",
@@ -1564,8 +1572,8 @@ func registerWebshellManagementTools(mcpServer *mcp.Server, db *database.DB, web
 
 	// manage_webshell_test - 测试 webshell 连接
 	testTool := mcp.Tool{
-		Name:        builtin.ToolManageWebshellTest,
-		Description: "测试指定的 WebShell 连接是否可用，会尝试执行一个简单的命令（如 whoami 或 dir）。",
+		Name:             builtin.ToolManageWebshellTest,
+		Description:      "测试指定的 WebShell 连接是否可用，会尝试执行一个简单的命令（如 whoami 或 dir）。",
 		ShortDescription: "测试 WebShell 连接",
 		InputSchema: map[string]interface{}{
 			"type": "object",

internal/database/batch_task.go

@@ -3,6 +3,7 @@ package database
 import (
 	"database/sql"
 	"fmt"
+	"strings"
 	"time"
 
 	"go.uber.org/zap"
@@ -10,14 +11,22 @@ import (
 
 // BatchTaskQueueRow 批量任务队列数据库行
 type BatchTaskQueueRow struct {
-	ID           string
-	Title        sql.NullString
-	Role         sql.NullString
-	Status       string
-	CreatedAt    time.Time
-	StartedAt    sql.NullTime
-	CompletedAt  sql.NullTime
-	CurrentIndex int
+	ID                    string
+	Title                 sql.NullString
+	Role                  sql.NullString
+	AgentMode             sql.NullString
+	ScheduleMode          sql.NullString
+	CronExpr              sql.NullString
+	NextRunAt             sql.NullTime
+	ScheduleEnabled       sql.NullInt64
+	LastScheduleTriggerAt sql.NullTime
+	LastScheduleError     sql.NullString
+	LastRunError          sql.NullString
+	Status                string
+	CreatedAt             time.Time
+	StartedAt             sql.NullTime
+	CompletedAt           sql.NullTime
+	CurrentIndex          int
 }
 
 // BatchTaskRow 批量任务数据库行
@@ -34,7 +43,16 @@ type BatchTaskRow struct {
 }
 
 // CreateBatchQueue 创建批量任务队列
-func (db *DB) CreateBatchQueue(queueID string, title string, role string, tasks []map[string]interface{}) error {
+func (db *DB) CreateBatchQueue(
+	queueID string,
+	title string,
+	role string,
+	agentMode string,
+	scheduleMode string,
+	cronExpr string,
+	nextRunAt *time.Time,
+	tasks []map[string]interface{},
+) error {
 	tx, err := db.Begin()
 	if err != nil {
 		return fmt.Errorf("开始事务失败: %w", err)
@@ -42,9 +60,14 @@ func (db *DB) CreateBatchQueue(queueID string, title string, role string, tasks
 	defer tx.Rollback()
 
 	now := time.Now()
+	var nextRunAtValue interface{}
+	if nextRunAt != nil {
+		nextRunAtValue = *nextRunAt
+	}
+
 	_, err = tx.Exec(
-		"INSERT INTO batch_task_queues (id, title, role, status, created_at, current_index) VALUES (?, ?, ?, ?, ?, ?)",
-		queueID, title, role, "pending", now, 0,
+		"INSERT INTO batch_task_queues (id, title, role, agent_mode, schedule_mode, cron_expr, next_run_at, schedule_enabled, status, created_at, current_index) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+		queueID, title, role, agentMode, scheduleMode, cronExpr, nextRunAtValue, 1, "pending", now, 0,
 	)
 	if err != nil {
 		return fmt.Errorf("创建批量任务队列失败: %w", err)
@@ -60,7 +83,7 @@ func (db *DB) CreateBatchQueue(queueID string, title string, role string, tasks
 		if !ok {
 			continue
 		}
-		
+
 		_, err = tx.Exec(
 			"INSERT INTO batch_tasks (id, queue_id, message, status) VALUES (?, ?, ?, ?)",
 			taskID, queueID, message, "pending",
@@ -78,9 +101,9 @@ func (db *DB) GetBatchQueue(queueID string) (*BatchTaskQueueRow, error) {
 	var row BatchTaskQueueRow
 	var createdAt string
 	err := db.QueryRow(
-		"SELECT id, title, role, status, created_at, started_at, completed_at, current_index FROM batch_task_queues WHERE id = ?",
+		"SELECT id, title, role, agent_mode, schedule_mode, cron_expr, next_run_at, schedule_enabled, last_schedule_trigger_at, last_schedule_error, last_run_error, status, created_at, started_at, completed_at, current_index FROM batch_task_queues WHERE id = ?",
 		queueID,
-	).Scan(&row.ID, &row.Title, &row.Role, &row.Status, &createdAt, &row.StartedAt, &row.CompletedAt, &row.CurrentIndex)
+	).Scan(&row.ID, &row.Title, &row.Role, &row.AgentMode, &row.ScheduleMode, &row.CronExpr, &row.NextRunAt, &row.ScheduleEnabled, &row.LastScheduleTriggerAt, &row.LastScheduleError, &row.LastRunError, &row.Status, &createdAt, &row.StartedAt, &row.CompletedAt, &row.CurrentIndex)
 	if err == sql.ErrNoRows {
 		return nil, nil
 	}
@@ -104,7 +127,7 @@ func (db *DB) GetBatchQueue(queueID string) (*BatchTaskQueueRow, error) {
 // GetAllBatchQueues 获取所有批量任务队列
 func (db *DB) GetAllBatchQueues() ([]*BatchTaskQueueRow, error) {
 	rows, err := db.Query(
-		"SELECT id, title, role, status, created_at, started_at, completed_at, current_index FROM batch_task_queues ORDER BY created_at DESC",
+		"SELECT id, title, role, agent_mode, schedule_mode, cron_expr, next_run_at, schedule_enabled, last_schedule_trigger_at, last_schedule_error, last_run_error, 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)
@@ -115,7 +138,7 @@ func (db *DB) GetAllBatchQueues() ([]*BatchTaskQueueRow, error) {
 	for rows.Next() {
 		var row BatchTaskQueueRow
 		var createdAt string
-		if err := rows.Scan(&row.ID, &row.Title, &row.Role, &row.Status, &createdAt, &row.StartedAt, &row.CompletedAt, &row.CurrentIndex); err != nil {
+		if err := rows.Scan(&row.ID, &row.Title, &row.Role, &row.AgentMode, &row.ScheduleMode, &row.CronExpr, &row.NextRunAt, &row.ScheduleEnabled, &row.LastScheduleTriggerAt, &row.LastScheduleError, &row.LastRunError, &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)
@@ -135,7 +158,7 @@ func (db *DB) GetAllBatchQueues() ([]*BatchTaskQueueRow, error) {
 
 // ListBatchQueues 列出批量任务队列（支持筛选和分页）
 func (db *DB) ListBatchQueues(limit, offset int, status, keyword string) ([]*BatchTaskQueueRow, error) {
-	query := "SELECT id, title, role, status, created_at, started_at, completed_at, current_index FROM batch_task_queues WHERE 1=1"
+	query := "SELECT id, title, role, agent_mode, schedule_mode, cron_expr, next_run_at, schedule_enabled, last_schedule_trigger_at, last_schedule_error, last_run_error, status, created_at, started_at, completed_at, current_index FROM batch_task_queues WHERE 1=1"
 	args := []interface{}{}
 
 	// 状态筛选
@@ -163,7 +186,7 @@ func (db *DB) ListBatchQueues(limit, offset int, status, keyword string) ([]*Bat
 	for rows.Next() {
 		var row BatchTaskQueueRow
 		var createdAt string
-		if err := rows.Scan(&row.ID, &row.Title, &row.Role, &row.Status, &createdAt, &row.StartedAt, &row.CompletedAt, &row.CurrentIndex); err != nil {
+		if err := rows.Scan(&row.ID, &row.Title, &row.Role, &row.AgentMode, &row.ScheduleMode, &row.CronExpr, &row.NextRunAt, &row.ScheduleEnabled, &row.LastScheduleTriggerAt, &row.LastScheduleError, &row.LastRunError, &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)
@@ -237,7 +260,7 @@ func (db *DB) GetBatchTasks(queueID string) ([]*BatchTaskRow, error) {
 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 = ?",
@@ -254,7 +277,7 @@ func (db *DB) UpdateBatchQueueStatus(queueID, status string) error {
 			status, queueID,
 		)
 	}
-	
+
 	if err != nil {
 		return fmt.Errorf("更新批量任务队列状态失败: %w", err)
 	}
@@ -265,41 +288,41 @@ func (db *DB) UpdateBatchQueueStatus(queueID, status string) error {
 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 {
@@ -309,7 +332,7 @@ func (db *DB) UpdateBatchTaskStatus(queueID, taskID, status string, conversation
 		sql += update
 	}
 	sql += " WHERE queue_id = ? AND id = ?"
-	
+
 	_, err = db.Exec(sql, args...)
 	if err != nil {
 		return fmt.Errorf("更新批量任务状态失败: %w", err)
@@ -329,6 +352,107 @@ func (db *DB) UpdateBatchQueueCurrentIndex(queueID string, currentIndex int) err
 	return nil
 }
 
+// UpdateBatchQueueSchedule 更新批量任务队列调度相关信息
+func (db *DB) UpdateBatchQueueSchedule(queueID, scheduleMode, cronExpr string, nextRunAt *time.Time) error {
+	var nextRunAtValue interface{}
+	if nextRunAt != nil {
+		nextRunAtValue = *nextRunAt
+	}
+	_, err := db.Exec(
+		"UPDATE batch_task_queues SET schedule_mode = ?, cron_expr = ?, next_run_at = ? WHERE id = ?",
+		scheduleMode, cronExpr, nextRunAtValue, queueID,
+	)
+	if err != nil {
+		return fmt.Errorf("更新批量任务调度配置失败: %w", err)
+	}
+	return nil
+}
+
+// UpdateBatchQueueScheduleEnabled 是否允许 Cron 自动触发（手工「开始执行」不受影响）
+func (db *DB) UpdateBatchQueueScheduleEnabled(queueID string, enabled bool) error {
+	v := 0
+	if enabled {
+		v = 1
+	}
+	_, err := db.Exec(
+		"UPDATE batch_task_queues SET schedule_enabled = ? WHERE id = ?",
+		v, queueID,
+	)
+	if err != nil {
+		return fmt.Errorf("更新批量任务调度开关失败: %w", err)
+	}
+	return nil
+}
+
+// RecordBatchQueueScheduledTriggerStart 记录一次由调度触发的开始时间并清空调度层错误
+func (db *DB) RecordBatchQueueScheduledTriggerStart(queueID string, at time.Time) error {
+	_, err := db.Exec(
+		"UPDATE batch_task_queues SET last_schedule_trigger_at = ?, last_schedule_error = NULL WHERE id = ?",
+		at, queueID,
+	)
+	if err != nil {
+		return fmt.Errorf("记录调度触发时间失败: %w", err)
+	}
+	return nil
+}
+
+// SetBatchQueueLastScheduleError 调度启动失败等原因（如状态不允许、重置失败）
+func (db *DB) SetBatchQueueLastScheduleError(queueID, msg string) error {
+	_, err := db.Exec(
+		"UPDATE batch_task_queues SET last_schedule_error = ? WHERE id = ?",
+		msg, queueID,
+	)
+	if err != nil {
+		return fmt.Errorf("写入调度错误信息失败: %w", err)
+	}
+	return nil
+}
+
+// SetBatchQueueLastRunError 最近一轮执行中出现的子任务失败摘要（空串表示清空）
+func (db *DB) SetBatchQueueLastRunError(queueID, msg string) error {
+	var v interface{}
+	if strings.TrimSpace(msg) == "" {
+		v = nil
+	} else {
+		v = msg
+	}
+	_, err := db.Exec(
+		"UPDATE batch_task_queues SET last_run_error = ? WHERE id = ?",
+		v, queueID,
+	)
+	if err != nil {
+		return fmt.Errorf("写入最近运行错误失败: %w", err)
+	}
+	return nil
+}
+
+// ResetBatchQueueForRerun 重置队列和任务状态用于下一轮调度执行
+func (db *DB) ResetBatchQueueForRerun(queueID string) error {
+	tx, err := db.Begin()
+	if err != nil {
+		return fmt.Errorf("开始事务失败: %w", err)
+	}
+	defer tx.Rollback()
+
+	_, err = tx.Exec(
+		"UPDATE batch_task_queues SET status = ?, current_index = 0, started_at = NULL, completed_at = NULL WHERE id = ?",
+		"pending", queueID,
+	)
+	if err != nil {
+		return fmt.Errorf("重置批量任务队列状态失败: %w", err)
+	}
+
+	_, err = tx.Exec(
+		"UPDATE batch_tasks SET status = ?, conversation_id = NULL, started_at = NULL, completed_at = NULL, error = NULL, result = NULL WHERE queue_id = ?",
+		"pending", queueID,
+	)
+	if err != nil {
+		return fmt.Errorf("重置批量任务状态失败: %w", err)
+	}
+
+	return tx.Commit()
+}
+
 // UpdateBatchTaskMessage 更新批量任务消息
 func (db *DB) UpdateBatchTaskMessage(queueID, taskID, message string) error {
 	_, err := db.Exec(
@@ -387,4 +511,3 @@ func (db *DB) DeleteBatchQueue(queueID string) error {
 
 	return tx.Commit()
 }
-

internal/database/database.go

@@ -205,6 +205,15 @@ func (db *DB) initTables() error {
 	CREATE TABLE IF NOT EXISTS batch_task_queues (
 		id TEXT PRIMARY KEY,
 		title TEXT,
+		role TEXT,
+		agent_mode TEXT NOT NULL DEFAULT 'single',
+		schedule_mode TEXT NOT NULL DEFAULT 'manual',
+		cron_expr TEXT,
+		next_run_at DATETIME,
+		schedule_enabled INTEGER NOT NULL DEFAULT 1,
+		last_schedule_trigger_at DATETIME,
+		last_schedule_error TEXT,
+		last_run_error TEXT,
 		status TEXT NOT NULL,
 		created_at DATETIME NOT NULL,
 		started_at DATETIME,
@@ -495,7 +504,7 @@ func (db *DB) migrateConversationGroupMappingsTable() error {
 	return nil
 }
 
-// migrateBatchTaskQueuesTable 迁移batch_task_queues表，添加title和role字段
+// migrateBatchTaskQueuesTable 迁移batch_task_queues表，补充新字段
 func (db *DB) migrateBatchTaskQueuesTable() error {
 	// 检查title字段是否存在
 	var count int
@@ -535,6 +544,131 @@ func (db *DB) migrateBatchTaskQueuesTable() error {
 		}
 	}
 
+	// 检查agent_mode字段是否存在
+	var agentModeCount int
+	err = db.QueryRow("SELECT COUNT(*) FROM pragma_table_info('batch_task_queues') WHERE name='agent_mode'").Scan(&agentModeCount)
+	if err != nil {
+		if _, addErr := db.Exec("ALTER TABLE batch_task_queues ADD COLUMN agent_mode TEXT NOT NULL DEFAULT 'single'"); addErr != nil {
+			errMsg := strings.ToLower(addErr.Error())
+			if !strings.Contains(errMsg, "duplicate column") && !strings.Contains(errMsg, "already exists") {
+				db.logger.Warn("添加agent_mode字段失败", zap.Error(addErr))
+			}
+		}
+	} else if agentModeCount == 0 {
+		if _, err := db.Exec("ALTER TABLE batch_task_queues ADD COLUMN agent_mode TEXT NOT NULL DEFAULT 'single'"); err != nil {
+			db.logger.Warn("添加agent_mode字段失败", zap.Error(err))
+		}
+	}
+
+	// 检查schedule_mode字段是否存在
+	var scheduleModeCount int
+	err = db.QueryRow("SELECT COUNT(*) FROM pragma_table_info('batch_task_queues') WHERE name='schedule_mode'").Scan(&scheduleModeCount)
+	if err != nil {
+		if _, addErr := db.Exec("ALTER TABLE batch_task_queues ADD COLUMN schedule_mode TEXT NOT NULL DEFAULT 'manual'"); addErr != nil {
+			errMsg := strings.ToLower(addErr.Error())
+			if !strings.Contains(errMsg, "duplicate column") && !strings.Contains(errMsg, "already exists") {
+				db.logger.Warn("添加schedule_mode字段失败", zap.Error(addErr))
+			}
+		}
+	} else if scheduleModeCount == 0 {
+		if _, err := db.Exec("ALTER TABLE batch_task_queues ADD COLUMN schedule_mode TEXT NOT NULL DEFAULT 'manual'"); err != nil {
+			db.logger.Warn("添加schedule_mode字段失败", zap.Error(err))
+		}
+	}
+
+	// 检查cron_expr字段是否存在
+	var cronExprCount int
+	err = db.QueryRow("SELECT COUNT(*) FROM pragma_table_info('batch_task_queues') WHERE name='cron_expr'").Scan(&cronExprCount)
+	if err != nil {
+		if _, addErr := db.Exec("ALTER TABLE batch_task_queues ADD COLUMN cron_expr TEXT"); addErr != nil {
+			errMsg := strings.ToLower(addErr.Error())
+			if !strings.Contains(errMsg, "duplicate column") && !strings.Contains(errMsg, "already exists") {
+				db.logger.Warn("添加cron_expr字段失败", zap.Error(addErr))
+			}
+		}
+	} else if cronExprCount == 0 {
+		if _, err := db.Exec("ALTER TABLE batch_task_queues ADD COLUMN cron_expr TEXT"); err != nil {
+			db.logger.Warn("添加cron_expr字段失败", zap.Error(err))
+		}
+	}
+
+	// 检查next_run_at字段是否存在
+	var nextRunAtCount int
+	err = db.QueryRow("SELECT COUNT(*) FROM pragma_table_info('batch_task_queues') WHERE name='next_run_at'").Scan(&nextRunAtCount)
+	if err != nil {
+		if _, addErr := db.Exec("ALTER TABLE batch_task_queues ADD COLUMN next_run_at DATETIME"); addErr != nil {
+			errMsg := strings.ToLower(addErr.Error())
+			if !strings.Contains(errMsg, "duplicate column") && !strings.Contains(errMsg, "already exists") {
+				db.logger.Warn("添加next_run_at字段失败", zap.Error(addErr))
+			}
+		}
+	} else if nextRunAtCount == 0 {
+		if _, err := db.Exec("ALTER TABLE batch_task_queues ADD COLUMN next_run_at DATETIME"); err != nil {
+			db.logger.Warn("添加next_run_at字段失败", zap.Error(err))
+		}
+	}
+
+	// schedule_enabled：0=暂停 Cron 自动调度，1=允许（手工执行不受影响）
+	var scheduleEnCount int
+	err = db.QueryRow("SELECT COUNT(*) FROM pragma_table_info('batch_task_queues') WHERE name='schedule_enabled'").Scan(&scheduleEnCount)
+	if err != nil {
+		if _, addErr := db.Exec("ALTER TABLE batch_task_queues ADD COLUMN schedule_enabled INTEGER NOT NULL DEFAULT 1"); addErr != nil {
+			errMsg := strings.ToLower(addErr.Error())
+			if !strings.Contains(errMsg, "duplicate column") && !strings.Contains(errMsg, "already exists") {
+				db.logger.Warn("添加schedule_enabled字段失败", zap.Error(addErr))
+			}
+		}
+	} else if scheduleEnCount == 0 {
+		if _, err := db.Exec("ALTER TABLE batch_task_queues ADD COLUMN schedule_enabled INTEGER NOT NULL DEFAULT 1"); err != nil {
+			db.logger.Warn("添加schedule_enabled字段失败", zap.Error(err))
+		}
+	}
+
+	var lastTrigCount int
+	err = db.QueryRow("SELECT COUNT(*) FROM pragma_table_info('batch_task_queues') WHERE name='last_schedule_trigger_at'").Scan(&lastTrigCount)
+	if err != nil {
+		if _, addErr := db.Exec("ALTER TABLE batch_task_queues ADD COLUMN last_schedule_trigger_at DATETIME"); addErr != nil {
+			errMsg := strings.ToLower(addErr.Error())
+			if !strings.Contains(errMsg, "duplicate column") && !strings.Contains(errMsg, "already exists") {
+				db.logger.Warn("添加last_schedule_trigger_at字段失败", zap.Error(addErr))
+			}
+		}
+	} else if lastTrigCount == 0 {
+		if _, err := db.Exec("ALTER TABLE batch_task_queues ADD COLUMN last_schedule_trigger_at DATETIME"); err != nil {
+			db.logger.Warn("添加last_schedule_trigger_at字段失败", zap.Error(err))
+		}
+	}
+
+	var lastSchedErrCount int
+	err = db.QueryRow("SELECT COUNT(*) FROM pragma_table_info('batch_task_queues') WHERE name='last_schedule_error'").Scan(&lastSchedErrCount)
+	if err != nil {
+		if _, addErr := db.Exec("ALTER TABLE batch_task_queues ADD COLUMN last_schedule_error TEXT"); addErr != nil {
+			errMsg := strings.ToLower(addErr.Error())
+			if !strings.Contains(errMsg, "duplicate column") && !strings.Contains(errMsg, "already exists") {
+				db.logger.Warn("添加last_schedule_error字段失败", zap.Error(addErr))
+			}
+		}
+	} else if lastSchedErrCount == 0 {
+		if _, err := db.Exec("ALTER TABLE batch_task_queues ADD COLUMN last_schedule_error TEXT"); err != nil {
+			db.logger.Warn("添加last_schedule_error字段失败", zap.Error(err))
+		}
+	}
+
+	var lastRunErrCount int
+	err = db.QueryRow("SELECT COUNT(*) FROM pragma_table_info('batch_task_queues') WHERE name='last_run_error'").Scan(&lastRunErrCount)
+	if err != nil {
+		if _, addErr := db.Exec("ALTER TABLE batch_task_queues ADD COLUMN last_run_error TEXT"); addErr != nil {
+			errMsg := strings.ToLower(addErr.Error())
+			if !strings.Contains(errMsg, "duplicate column") && !strings.Contains(errMsg, "already exists") {
+				db.logger.Warn("添加last_run_error字段失败", zap.Error(addErr))
+			}
+		}
+	} else if lastRunErrCount == 0 {
+		if _, err := db.Exec("ALTER TABLE batch_task_queues ADD COLUMN last_run_error TEXT"); err != nil {
+			db.logger.Warn("添加last_run_error字段失败", zap.Error(err))
+		}
+	}
+
 	return nil
 }
 

internal/handler/agent.go

@@ -24,6 +24,7 @@ import (
 	"cyberstrike-ai/internal/skills"
 
 	"github.com/gin-gonic/gin"
+	"github.com/robfig/cron/v3"
 	"go.uber.org/zap"
 )
 
@@ -81,6 +82,9 @@ type AgentHandler struct {
 	}
 	skillsManager     *skills.Manager // Skills管理器
 	agentsMarkdownDir string          // 多代理：Markdown 子 Agent 目录（绝对路径，空则不从磁盘合并）
+	batchCronParser   cron.Parser
+	batchRunnerMu     sync.Mutex
+	batchRunning      map[string]struct{}
 }
 
 // NewAgentHandler 创建新的Agent处理器
@@ -93,14 +97,18 @@ func NewAgentHandler(agent *agent.Agent, db *database.DB, cfg *config.Config, lo
 		logger.Warn("从数据库加载批量任务队列失败", zap.Error(err))
 	}
 
-	return &AgentHandler{
+	handler := &AgentHandler{
 		agent:            agent,
 		db:               db,
 		logger:           logger,
 		tasks:            NewAgentTaskManager(),
 		batchTaskManager: batchTaskManager,
 		config:           cfg,
+		batchCronParser:  cron.NewParser(cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow | cron.Descriptor),
+		batchRunning:     make(map[string]struct{}),
 	}
+	go handler.batchQueueSchedulerLoop()
+	return handler
 }
 
 // SetKnowledgeManager 设置知识库管理器（用于记录检索日志）
@@ -1575,9 +1583,26 @@ func (h *AgentHandler) ListCompletedTasks(c *gin.Context) {
 
 // BatchTaskRequest 批量任务请求
 type BatchTaskRequest struct {
-	Title string   `json:"title"`                    // 任务标题（可选）
-	Tasks []string `json:"tasks" binding:"required"` // 任务列表，每行一个任务
-	Role  string   `json:"role,omitempty"`           // 角色名称（可选，空字符串表示默认角色）
+	Title        string   `json:"title"`                    // 任务标题（可选）
+	Tasks        []string `json:"tasks" binding:"required"` // 任务列表，每行一个任务
+	Role         string   `json:"role,omitempty"`           // 角色名称（可选，空字符串表示默认角色）
+	AgentMode    string   `json:"agentMode,omitempty"`      // single | multi
+	ScheduleMode string   `json:"scheduleMode,omitempty"`   // manual | cron
+	CronExpr     string   `json:"cronExpr,omitempty"`       // scheduleMode=cron 时必填
+}
+
+func normalizeBatchQueueAgentMode(mode string) string {
+	if strings.TrimSpace(mode) == "multi" {
+		return "multi"
+	}
+	return "single"
+}
+
+func normalizeBatchQueueScheduleMode(mode string) string {
+	if strings.TrimSpace(mode) == "cron" {
+		return "cron"
+	}
+	return "manual"
 }
 
 // CreateBatchQueue 创建批量任务队列
@@ -1606,7 +1631,25 @@ func (h *AgentHandler) CreateBatchQueue(c *gin.Context) {
 		return
 	}
 
-	queue := h.batchTaskManager.CreateBatchQueue(req.Title, req.Role, validTasks)
+	agentMode := normalizeBatchQueueAgentMode(req.AgentMode)
+	scheduleMode := normalizeBatchQueueScheduleMode(req.ScheduleMode)
+	cronExpr := strings.TrimSpace(req.CronExpr)
+	var nextRunAt *time.Time
+	if scheduleMode == "cron" {
+		if cronExpr == "" {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "启用 Cron 调度时，调度表达式不能为空"})
+			return
+		}
+		schedule, err := h.batchCronParser.Parse(cronExpr)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "无效的 Cron 表达式: " + err.Error()})
+			return
+		}
+		next := schedule.Next(time.Now())
+		nextRunAt = &next
+	}
+
+	queue := h.batchTaskManager.CreateBatchQueue(req.Title, req.Role, agentMode, scheduleMode, cronExpr, nextRunAt, validTasks)
 	c.JSON(http.StatusOK, gin.H{
 		"queueId": queue.ID,
 		"queue":   queue,
@@ -1699,21 +1742,15 @@ func (h *AgentHandler) ListBatchQueues(c *gin.Context) {
 // StartBatchQueue 开始执行批量任务队列
 func (h *AgentHandler) StartBatchQueue(c *gin.Context) {
 	queueID := c.Param("queueId")
-	queue, exists := h.batchTaskManager.GetBatchQueue(queueID)
-	if !exists {
+	ok, err := h.startBatchQueueExecution(queueID, false)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+	if !ok {
 		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})
 }
 
@@ -1728,6 +1765,28 @@ func (h *AgentHandler) PauseBatchQueue(c *gin.Context) {
 	c.JSON(http.StatusOK, gin.H{"message": "批量任务已暂停"})
 }
 
+// SetBatchQueueScheduleEnabled 开启/关闭 Cron 自动调度（手工执行不受影响）
+func (h *AgentHandler) SetBatchQueueScheduleEnabled(c *gin.Context) {
+	queueID := c.Param("queueId")
+	if _, exists := h.batchTaskManager.GetBatchQueue(queueID); !exists {
+		c.JSON(http.StatusNotFound, gin.H{"error": "队列不存在"})
+		return
+	}
+	var req struct {
+		ScheduleEnabled bool `json:"scheduleEnabled"`
+	}
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+	if !h.batchTaskManager.SetScheduleEnabled(queueID, req.ScheduleEnabled) {
+		c.JSON(http.StatusNotFound, gin.H{"error": "队列不存在"})
+		return
+	}
+	queue, _ := h.batchTaskManager.GetBatchQueue(queueID)
+	c.JSON(http.StatusOK, gin.H{"queue": queue})
+}
+
 // DeleteBatchQueue 删除批量任务队列
 func (h *AgentHandler) DeleteBatchQueue(c *gin.Context) {
 	queueID := c.Param("queueId")
@@ -1824,8 +1883,125 @@ func (h *AgentHandler) DeleteBatchTask(c *gin.Context) {
 	c.JSON(http.StatusOK, gin.H{"message": "任务已删除", "queue": queue})
 }
 
+func (h *AgentHandler) markBatchQueueRunning(queueID string) bool {
+	h.batchRunnerMu.Lock()
+	defer h.batchRunnerMu.Unlock()
+	if _, exists := h.batchRunning[queueID]; exists {
+		return false
+	}
+	h.batchRunning[queueID] = struct{}{}
+	return true
+}
+
+func (h *AgentHandler) unmarkBatchQueueRunning(queueID string) {
+	h.batchRunnerMu.Lock()
+	defer h.batchRunnerMu.Unlock()
+	delete(h.batchRunning, queueID)
+}
+
+func (h *AgentHandler) nextBatchQueueRunAt(cronExpr string, from time.Time) (*time.Time, error) {
+	expr := strings.TrimSpace(cronExpr)
+	if expr == "" {
+		return nil, nil
+	}
+	schedule, err := h.batchCronParser.Parse(expr)
+	if err != nil {
+		return nil, err
+	}
+	next := schedule.Next(from)
+	return &next, nil
+}
+
+func (h *AgentHandler) startBatchQueueExecution(queueID string, scheduled bool) (bool, error) {
+	queue, exists := h.batchTaskManager.GetBatchQueue(queueID)
+	if !exists {
+		return false, nil
+	}
+	if !h.markBatchQueueRunning(queueID) {
+		return true, nil
+	}
+
+	if scheduled {
+		if queue.ScheduleMode != "cron" {
+			h.unmarkBatchQueueRunning(queueID)
+			err := fmt.Errorf("队列未启用 cron 调度")
+			h.batchTaskManager.SetLastScheduleError(queueID, err.Error())
+			return true, err
+		}
+		if queue.Status == "running" || queue.Status == "paused" || queue.Status == "cancelled" {
+			h.unmarkBatchQueueRunning(queueID)
+			err := fmt.Errorf("当前队列状态不允许被调度执行")
+			h.batchTaskManager.SetLastScheduleError(queueID, err.Error())
+			return true, err
+		}
+		if !h.batchTaskManager.ResetQueueForRerun(queueID) {
+			h.unmarkBatchQueueRunning(queueID)
+			err := fmt.Errorf("重置队列失败")
+			h.batchTaskManager.SetLastScheduleError(queueID, err.Error())
+			return true, err
+		}
+		queue, _ = h.batchTaskManager.GetBatchQueue(queueID)
+	} else if queue.Status != "pending" && queue.Status != "paused" {
+		h.unmarkBatchQueueRunning(queueID)
+		return true, fmt.Errorf("队列状态不允许启动")
+	}
+
+	if queue != nil && queue.AgentMode == "multi" && (h.config == nil || !h.config.MultiAgent.Enabled) {
+		h.unmarkBatchQueueRunning(queueID)
+		err := fmt.Errorf("当前队列配置为多代理，但系统未启用多代理")
+		if scheduled {
+			h.batchTaskManager.SetLastScheduleError(queueID, err.Error())
+		}
+		return true, err
+	}
+
+	if scheduled {
+		h.batchTaskManager.RecordScheduledRunStart(queueID)
+	}
+	h.batchTaskManager.UpdateQueueStatus(queueID, "running")
+	if queue != nil && queue.ScheduleMode == "cron" {
+		nextRunAt, err := h.nextBatchQueueRunAt(queue.CronExpr, time.Now())
+		if err == nil {
+			h.batchTaskManager.UpdateQueueSchedule(queueID, "cron", queue.CronExpr, nextRunAt)
+		}
+	}
+
+	go h.executeBatchQueue(queueID)
+	return true, nil
+}
+
+func (h *AgentHandler) batchQueueSchedulerLoop() {
+	ticker := time.NewTicker(20 * time.Second)
+	defer ticker.Stop()
+	for range ticker.C {
+		queues := h.batchTaskManager.GetAllQueues()
+		now := time.Now()
+		for _, queue := range queues {
+			if queue == nil || queue.ScheduleMode != "cron" || !queue.ScheduleEnabled || queue.Status == "cancelled" || queue.Status == "running" || queue.Status == "paused" {
+				continue
+			}
+			nextRunAt := queue.NextRunAt
+			if nextRunAt == nil {
+				next, err := h.nextBatchQueueRunAt(queue.CronExpr, now)
+				if err != nil {
+					h.logger.Warn("批量任务 cron 表达式无效，跳过调度", zap.String("queueId", queue.ID), zap.String("cronExpr", queue.CronExpr), zap.Error(err))
+					continue
+				}
+				h.batchTaskManager.UpdateQueueSchedule(queue.ID, "cron", queue.CronExpr, next)
+				nextRunAt = next
+			}
+			if nextRunAt != nil && (nextRunAt.Before(now) || nextRunAt.Equal(now)) {
+				if _, err := h.startBatchQueueExecution(queue.ID, true); err != nil {
+					h.logger.Warn("自动调度批量任务失败", zap.String("queueId", queue.ID), zap.Error(err))
+				}
+			}
+		}
+	}
+}
+
 // executeBatchQueue 执行批量任务队列
 func (h *AgentHandler) executeBatchQueue(queueID string) {
+	defer h.unmarkBatchQueueRunning(queueID)
 	h.logger.Info("开始执行批量任务队列", zap.String("queueId", queueID))
 
 	for {
@@ -1838,7 +2014,17 @@ func (h *AgentHandler) executeBatchQueue(queueID string) {
 		// 获取下一个任务
 		task, hasNext := h.batchTaskManager.GetNextTask(queueID)
 		if !hasNext {
-			// 所有任务完成
+			// 所有任务完成：汇总子任务失败信息便于排障
+			q, ok := h.batchTaskManager.GetBatchQueue(queueID)
+			lastRunErr := ""
+			if ok {
+				for _, t := range q.Tasks {
+					if t.Status == "failed" && t.Error != "" {
+						lastRunErr = t.Error
+					}
+				}
+			}
+			h.batchTaskManager.SetLastRunError(queueID, lastRunErr)
 			h.batchTaskManager.UpdateQueueStatus(queueID, "completed")
 			h.logger.Info("批量任务队列执行完成", zap.String("queueId", queueID))
 			break
@@ -1918,7 +2104,13 @@ func (h *AgentHandler) executeBatchQueue(queueID string) {
 		h.batchTaskManager.SetTaskCancel(queueID, cancel)
 		// 使用队列配置的角色工具列表（如果为空，表示使用所有工具）
 		// 注意：skills不会硬编码注入，但会在系统提示词中提示AI这个角色推荐使用哪些skills
-		useBatchMulti := h.config != nil && h.config.MultiAgent.Enabled && h.config.MultiAgent.BatchUseMultiAgent
+		useBatchMulti := false
+		if queue.AgentMode == "multi" {
+			useBatchMulti = h.config != nil && h.config.MultiAgent.Enabled
+		} else if queue.AgentMode == "" {
+			// 兼容历史数据：未配置队列代理模式时，沿用旧的系统级开关
+			useBatchMulti = h.config != nil && h.config.MultiAgent.Enabled && h.config.MultiAgent.BatchUseMultiAgent
+		}
 		var result *agent.AgentLoopResult
 		var resultMA *multiagent.RunResult
 		var runErr error

internal/handler/batch_task_manager.go

@@ -27,24 +27,32 @@ type BatchTask struct {
 
 // BatchTaskQueue 批量任务队列
 type BatchTaskQueue struct {
-	ID           string       `json:"id"`
-	Title        string       `json:"title,omitempty"`
-	Role         string       `json:"role,omitempty"` // 角色名称（空字符串表示默认角色）
-	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
+	ID                    string       `json:"id"`
+	Title                 string       `json:"title,omitempty"`
+	Role                  string       `json:"role,omitempty"` // 角色名称（空字符串表示默认角色）
+	AgentMode             string       `json:"agentMode"`      // single | multi
+	ScheduleMode          string       `json:"scheduleMode"`   // manual | cron
+	CronExpr              string       `json:"cronExpr,omitempty"`
+	NextRunAt             *time.Time   `json:"nextRunAt,omitempty"`
+	ScheduleEnabled       bool         `json:"scheduleEnabled"`
+	LastScheduleTriggerAt *time.Time   `json:"lastScheduleTriggerAt,omitempty"`
+	LastScheduleError     string       `json:"lastScheduleError,omitempty"`
+	LastRunError          string       `json:"lastRunError,omitempty"`
+	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
-	taskCancels   map[string]context.CancelFunc // 存储每个队列当前任务的取消函数
-	mu            sync.RWMutex
+	db          *database.DB
+	queues      map[string]*BatchTaskQueue
+	taskCancels map[string]context.CancelFunc // 存储每个队列当前任务的取消函数
+	mu          sync.RWMutex
 }
 
 // NewBatchTaskManager 创建批量任务管理器
@@ -63,19 +71,32 @@ func (m *BatchTaskManager) SetDB(db *database.DB) {
 }
 
 // CreateBatchQueue 创建批量任务队列
-func (m *BatchTaskManager) CreateBatchQueue(title, role string, tasks []string) *BatchTaskQueue {
+func (m *BatchTaskManager) CreateBatchQueue(
+	title, role, agentMode, scheduleMode, cronExpr string,
+	nextRunAt *time.Time,
+	tasks []string,
+) *BatchTaskQueue {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 
 	queueID := time.Now().Format("20060102150405") + "-" + generateShortID()
 	queue := &BatchTaskQueue{
-		ID:           queueID,
-		Title:        title,
-		Role:         role,
-		Tasks:        make([]*BatchTask, 0, len(tasks)),
-		Status:       "pending",
-		CreatedAt:    time.Now(),
-		CurrentIndex: 0,
+		ID:              queueID,
+		Title:           title,
+		Role:            role,
+		AgentMode:       normalizeBatchQueueAgentMode(agentMode),
+		ScheduleMode:    normalizeBatchQueueScheduleMode(scheduleMode),
+		CronExpr:        strings.TrimSpace(cronExpr),
+		NextRunAt:       nextRunAt,
+		ScheduleEnabled: true,
+		Tasks:           make([]*BatchTask, 0, len(tasks)),
+		Status:          "pending",
+		CreatedAt:       time.Now(),
+		CurrentIndex:    0,
+	}
+	if queue.ScheduleMode != "cron" {
+		queue.CronExpr = ""
+		queue.NextRunAt = nil
 	}
 
 	// 准备数据库保存的任务数据
@@ -100,7 +121,16 @@ func (m *BatchTaskManager) CreateBatchQueue(title, role string, tasks []string)
 
 	// 保存到数据库
 	if m.db != nil {
-		if err := m.db.CreateBatchQueue(queueID, title, role, dbTasks); err != nil {
+		if err := m.db.CreateBatchQueue(
+			queueID,
+			title,
+			role,
+			queue.AgentMode,
+			queue.ScheduleMode,
+			queue.CronExpr,
+			queue.NextRunAt,
+			dbTasks,
+		); err != nil {
 			// 如果数据库保存失败，记录错误但继续（使用内存缓存）
 			// 这里可以添加日志记录
 		}
@@ -151,6 +181,8 @@ func (m *BatchTaskManager) loadQueueFromDB(queueID string) *BatchTaskQueue {
 
 	queue := &BatchTaskQueue{
 		ID:           queueRow.ID,
+		AgentMode:    "single",
+		ScheduleMode: "manual",
 		Status:       queueRow.Status,
 		CreatedAt:    queueRow.CreatedAt,
 		CurrentIndex: queueRow.CurrentIndex,
@@ -163,6 +195,33 @@ func (m *BatchTaskManager) loadQueueFromDB(queueID string) *BatchTaskQueue {
 	if queueRow.Role.Valid {
 		queue.Role = queueRow.Role.String
 	}
+	if queueRow.AgentMode.Valid {
+		queue.AgentMode = normalizeBatchQueueAgentMode(queueRow.AgentMode.String)
+	}
+	if queueRow.ScheduleMode.Valid {
+		queue.ScheduleMode = normalizeBatchQueueScheduleMode(queueRow.ScheduleMode.String)
+	}
+	if queueRow.CronExpr.Valid && queue.ScheduleMode == "cron" {
+		queue.CronExpr = strings.TrimSpace(queueRow.CronExpr.String)
+	}
+	if queueRow.NextRunAt.Valid && queue.ScheduleMode == "cron" {
+		t := queueRow.NextRunAt.Time
+		queue.NextRunAt = &t
+	}
+	queue.ScheduleEnabled = true
+	if queueRow.ScheduleEnabled.Valid && queueRow.ScheduleEnabled.Int64 == 0 {
+		queue.ScheduleEnabled = false
+	}
+	if queueRow.LastScheduleTriggerAt.Valid {
+		t := queueRow.LastScheduleTriggerAt.Time
+		queue.LastScheduleTriggerAt = &t
+	}
+	if queueRow.LastScheduleError.Valid {
+		queue.LastScheduleError = strings.TrimSpace(queueRow.LastScheduleError.String)
+	}
+	if queueRow.LastRunError.Valid {
+		queue.LastRunError = strings.TrimSpace(queueRow.LastRunError.String)
+	}
 	if queueRow.StartedAt.Valid {
 		queue.StartedAt = &queueRow.StartedAt.Time
 	}
@@ -347,6 +406,8 @@ func (m *BatchTaskManager) LoadFromDB() error {
 
 		queue := &BatchTaskQueue{
 			ID:           queueRow.ID,
+			AgentMode:    "single",
+			ScheduleMode: "manual",
 			Status:       queueRow.Status,
 			CreatedAt:    queueRow.CreatedAt,
 			CurrentIndex: queueRow.CurrentIndex,
@@ -359,6 +420,33 @@ func (m *BatchTaskManager) LoadFromDB() error {
 		if queueRow.Role.Valid {
 			queue.Role = queueRow.Role.String
 		}
+		if queueRow.AgentMode.Valid {
+			queue.AgentMode = normalizeBatchQueueAgentMode(queueRow.AgentMode.String)
+		}
+		if queueRow.ScheduleMode.Valid {
+			queue.ScheduleMode = normalizeBatchQueueScheduleMode(queueRow.ScheduleMode.String)
+		}
+		if queueRow.CronExpr.Valid && queue.ScheduleMode == "cron" {
+			queue.CronExpr = strings.TrimSpace(queueRow.CronExpr.String)
+		}
+		if queueRow.NextRunAt.Valid && queue.ScheduleMode == "cron" {
+			t := queueRow.NextRunAt.Time
+			queue.NextRunAt = &t
+		}
+		queue.ScheduleEnabled = true
+		if queueRow.ScheduleEnabled.Valid && queueRow.ScheduleEnabled.Int64 == 0 {
+			queue.ScheduleEnabled = false
+		}
+		if queueRow.LastScheduleTriggerAt.Valid {
+			t := queueRow.LastScheduleTriggerAt.Time
+			queue.LastScheduleTriggerAt = &t
+		}
+		if queueRow.LastScheduleError.Valid {
+			queue.LastScheduleError = strings.TrimSpace(queueRow.LastScheduleError.String)
+		}
+		if queueRow.LastRunError.Valid {
+			queue.LastRunError = strings.TrimSpace(queueRow.LastRunError.String)
+		}
 		if queueRow.StartedAt.Valid {
 			queue.StartedAt = &queueRow.StartedAt.Time
 		}
@@ -469,6 +557,127 @@ func (m *BatchTaskManager) UpdateQueueStatus(queueID, status string) {
 	}
 }
 
+// UpdateQueueSchedule 更新队列调度配置
+func (m *BatchTaskManager) UpdateQueueSchedule(queueID, scheduleMode, cronExpr string, nextRunAt *time.Time) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	queue, exists := m.queues[queueID]
+	if !exists {
+		return
+	}
+
+	queue.ScheduleMode = normalizeBatchQueueScheduleMode(scheduleMode)
+	if queue.ScheduleMode == "cron" {
+		queue.CronExpr = strings.TrimSpace(cronExpr)
+		queue.NextRunAt = nextRunAt
+	} else {
+		queue.CronExpr = ""
+		queue.NextRunAt = nil
+	}
+
+	if m.db != nil {
+		if err := m.db.UpdateBatchQueueSchedule(queueID, queue.ScheduleMode, queue.CronExpr, queue.NextRunAt); err != nil {
+			// 记录错误但继续（使用内存缓存）
+		}
+	}
+}
+
+// SetScheduleEnabled 暂停/恢复 Cron 自动调度（不影响手工执行）
+func (m *BatchTaskManager) SetScheduleEnabled(queueID string, enabled bool) bool {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	queue, exists := m.queues[queueID]
+	if !exists {
+		return false
+	}
+	queue.ScheduleEnabled = enabled
+	if m.db != nil {
+		_ = m.db.UpdateBatchQueueScheduleEnabled(queueID, enabled)
+	}
+	return true
+}
+
+// RecordScheduledRunStart Cron 触发成功、即将执行子任务时调用
+func (m *BatchTaskManager) RecordScheduledRunStart(queueID string) {
+	now := time.Now()
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	queue, exists := m.queues[queueID]
+	if !exists {
+		return
+	}
+	queue.LastScheduleTriggerAt = &now
+	queue.LastScheduleError = ""
+	if m.db != nil {
+		_ = m.db.RecordBatchQueueScheduledTriggerStart(queueID, now)
+	}
+}
+
+// SetLastScheduleError 调度层失败（未成功开始执行）
+func (m *BatchTaskManager) SetLastScheduleError(queueID, msg string) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	queue, exists := m.queues[queueID]
+	if !exists {
+		return
+	}
+	queue.LastScheduleError = strings.TrimSpace(msg)
+	if m.db != nil {
+		_ = m.db.SetBatchQueueLastScheduleError(queueID, queue.LastScheduleError)
+	}
+}
+
+// SetLastRunError 最近一轮批量执行中的失败摘要
+func (m *BatchTaskManager) SetLastRunError(queueID, msg string) {
+	msg = strings.TrimSpace(msg)
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	queue, exists := m.queues[queueID]
+	if !exists {
+		return
+	}
+	queue.LastRunError = msg
+	if m.db != nil {
+		_ = m.db.SetBatchQueueLastRunError(queueID, msg)
+	}
+}
+
+// ResetQueueForRerun 重置队列与子任务状态，供 cron 下一轮执行
+func (m *BatchTaskManager) ResetQueueForRerun(queueID string) bool {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	queue, exists := m.queues[queueID]
+	if !exists {
+		return false
+	}
+	queue.Status = "pending"
+	queue.CurrentIndex = 0
+	queue.StartedAt = nil
+	queue.CompletedAt = nil
+	queue.NextRunAt = nil
+	for _, task := range queue.Tasks {
+		task.Status = "pending"
+		task.ConversationID = ""
+		task.StartedAt = nil
+		task.CompletedAt = nil
+		task.Error = ""
+		task.Result = ""
+	}
+
+	if m.db != nil {
+		if err := m.db.ResetBatchQueueForRerun(queueID); err != nil {
+			return false
+		}
+	}
+	return true
+}
+
 // UpdateTaskMessage 更新任务消息（仅限待执行状态）
 func (m *BatchTaskManager) UpdateTaskMessage(queueID, taskID, message string) error {
 	m.mu.Lock()

internal/handler/batch_task_mcp.go

@@ -0,0 +1,533 @@
+package handler
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+
+	"cyberstrike-ai/internal/mcp"
+	"cyberstrike-ai/internal/mcp/builtin"
+
+	"go.uber.org/zap"
+)
+
+// RegisterBatchTaskMCPTools 注册批量任务队列相关 MCP 工具（需传入已初始化 DB 的 AgentHandler）
+func RegisterBatchTaskMCPTools(mcpServer *mcp.Server, h *AgentHandler, logger *zap.Logger) {
+	if mcpServer == nil || h == nil || logger == nil {
+		return
+	}
+
+	reg := func(tool mcp.Tool, fn func(ctx context.Context, args map[string]interface{}) (*mcp.ToolResult, error)) {
+		mcpServer.RegisterTool(tool, fn)
+	}
+
+	// --- list ---
+	reg(mcp.Tool{
+		Name:             builtin.ToolBatchTaskList,
+		Description:      "列出批量任务队列，支持按状态筛选与关键字搜索。用于查看队列 id、状态、进度及 Cron 配置等。",
+		ShortDescription: "列出批量任务队列",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"status": map[string]interface{}{
+					"type":        "string",
+					"description": "筛选状态：all（默认）、pending、running、paused、completed、cancelled",
+					"enum":        []string{"all", "pending", "running", "paused", "completed", "cancelled"},
+				},
+				"keyword": map[string]interface{}{
+					"type":        "string",
+					"description": "按队列 ID 或标题模糊搜索",
+				},
+				"page": map[string]interface{}{
+					"type":        "integer",
+					"description": "页码，从 1 开始，默认 1",
+				},
+				"page_size": map[string]interface{}{
+					"type":        "integer",
+					"description": "每页条数，默认 20，最大 100",
+				},
+			},
+		},
+	}, func(ctx context.Context, args map[string]interface{}) (*mcp.ToolResult, error) {
+		status := mcpArgString(args, "status")
+		if status == "" {
+			status = "all"
+		}
+		keyword := mcpArgString(args, "keyword")
+		page := int(mcpArgFloat(args, "page"))
+		if page <= 0 {
+			page = 1
+		}
+		pageSize := int(mcpArgFloat(args, "page_size"))
+		if pageSize <= 0 {
+			pageSize = 20
+		}
+		if pageSize > 100 {
+			pageSize = 100
+		}
+		offset := (page - 1) * pageSize
+		queues, total, err := h.batchTaskManager.ListQueues(pageSize, offset, status, keyword)
+		if err != nil {
+			return batchMCPTextResult(fmt.Sprintf("列出队列失败: %v", err), true), nil
+		}
+		totalPages := (total + pageSize - 1) / pageSize
+		if totalPages == 0 {
+			totalPages = 1
+		}
+		payload := map[string]interface{}{
+			"queues":      queues,
+			"total":       total,
+			"page":        page,
+			"page_size":   pageSize,
+			"total_pages": totalPages,
+		}
+		logger.Info("MCP batch_task_list", zap.String("status", status), zap.Int("total", total))
+		return batchMCPJSONResult(payload)
+	})
+
+	// --- get ---
+	reg(mcp.Tool{
+		Name:             builtin.ToolBatchTaskGet,
+		Description:      "根据 queue_id 获取单个批量任务队列详情（含子任务列表、Cron、调度开关与最近错误信息）。",
+		ShortDescription: "获取批量任务队列详情",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"queue_id": map[string]interface{}{
+					"type":        "string",
+					"description": "队列 ID",
+				},
+			},
+			"required": []string{"queue_id"},
+		},
+	}, func(ctx context.Context, args map[string]interface{}) (*mcp.ToolResult, error) {
+		qid := mcpArgString(args, "queue_id")
+		if qid == "" {
+			return batchMCPTextResult("queue_id 不能为空", true), nil
+		}
+		queue, ok := h.batchTaskManager.GetBatchQueue(qid)
+		if !ok {
+			return batchMCPTextResult("队列不存在: "+qid, true), nil
+		}
+		return batchMCPJSONResult(queue)
+	})
+
+	// --- create ---
+	reg(mcp.Tool{
+		Name: builtin.ToolBatchTaskCreate,
+		Description: `创建新的批量任务队列。任务列表使用 tasks（字符串数组）或 tasks_text（多行，每行一条）。
+agent_mode: single（默认）或 multi（需系统启用多代理）。schedule_mode: manual（默认）或 cron；为 cron 时必须提供 cron_expr（如 "0 */6 * * *"）。
+重要：创建成功后队列处于 pending，不会自动开始跑子任务。若要立即执行或手工开跑，必须再调用工具 batch_task_start（传入返回的 queue_id）。Cron 队列若需按表达式自动触发下一轮，还需保持调度开关开启（可用 batch_task_schedule_enabled）。`,
+		ShortDescription: "创建批量任务队列（创建后需 batch_task_start 才会执行）",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"title": map[string]interface{}{
+					"type":        "string",
+					"description": "可选标题",
+				},
+				"role": map[string]interface{}{
+					"type":        "string",
+					"description": "角色名称，空表示默认",
+				},
+				"tasks": map[string]interface{}{
+					"type":        "array",
+					"description": "任务指令列表，每项一条",
+					"items":       map[string]interface{}{"type": "string"},
+				},
+				"tasks_text": map[string]interface{}{
+					"type":        "string",
+					"description": "多行文本，每行一条任务（与 tasks 二选一）",
+				},
+				"agent_mode": map[string]interface{}{
+					"type":        "string",
+					"description": "single 或 multi",
+					"enum":        []string{"single", "multi"},
+				},
+				"schedule_mode": map[string]interface{}{
+					"type":        "string",
+					"description": "manual 或 cron",
+					"enum":        []string{"manual", "cron"},
+				},
+				"cron_expr": map[string]interface{}{
+					"type":        "string",
+					"description": "schedule_mode 为 cron 时必填",
+				},
+			},
+		},
+	}, func(ctx context.Context, args map[string]interface{}) (*mcp.ToolResult, error) {
+		tasks, errMsg := batchMCPTasksFromArgs(args)
+		if errMsg != "" {
+			return batchMCPTextResult(errMsg, true), nil
+		}
+		title := mcpArgString(args, "title")
+		role := mcpArgString(args, "role")
+		agentMode := normalizeBatchQueueAgentMode(mcpArgString(args, "agent_mode"))
+		scheduleMode := normalizeBatchQueueScheduleMode(mcpArgString(args, "schedule_mode"))
+		cronExpr := strings.TrimSpace(mcpArgString(args, "cron_expr"))
+		var nextRunAt *time.Time
+		if scheduleMode == "cron" {
+			if cronExpr == "" {
+				return batchMCPTextResult("Cron 调度模式下 cron_expr 不能为空", true), nil
+			}
+			sch, err := h.batchCronParser.Parse(cronExpr)
+			if err != nil {
+				return batchMCPTextResult("无效的 Cron 表达式: "+err.Error(), true), nil
+			}
+			n := sch.Next(time.Now())
+			nextRunAt = &n
+		}
+		queue := h.batchTaskManager.CreateBatchQueue(title, role, agentMode, scheduleMode, cronExpr, nextRunAt, tasks)
+		logger.Info("MCP batch_task_create", zap.String("queueId", queue.ID), zap.Int("taskCount", len(tasks)))
+		return batchMCPJSONResult(map[string]interface{}{
+			"queue_id": queue.ID,
+			"queue":    queue,
+			"reminder": "队列已创建，当前为 pending。需要开始执行时请调用 MCP工具 batch_task_start（queue_id 同上）。Cron 自动调度需 schedule_enabled 为 true，可用 batch_task_schedule_enabled。",
+		})
+	})
+
+	// --- start ---
+	reg(mcp.Tool{
+		Name: builtin.ToolBatchTaskStart,
+		Description: `启动或继续执行批量任务队列（pending / paused）。
+与 batch_task_create 配合使用：仅创建队列不会自动执行，需调用本工具才会开始跑子任务。`,
+		ShortDescription: "启动/继续批量任务队列（创建后需调用才会执行）",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"queue_id": map[string]interface{}{
+					"type":        "string",
+					"description": "队列 ID",
+				},
+			},
+			"required": []string{"queue_id"},
+		},
+	}, func(ctx context.Context, args map[string]interface{}) (*mcp.ToolResult, error) {
+		qid := mcpArgString(args, "queue_id")
+		if qid == "" {
+			return batchMCPTextResult("queue_id 不能为空", true), nil
+		}
+		ok, err := h.startBatchQueueExecution(qid, false)
+		if !ok {
+			return batchMCPTextResult("队列不存在: "+qid, true), nil
+		}
+		if err != nil {
+			return batchMCPTextResult("启动失败: "+err.Error(), true), nil
+		}
+		logger.Info("MCP batch_task_start", zap.String("queueId", qid))
+		return batchMCPTextResult("已提交启动，队列将开始执行。", false), nil
+	})
+
+	// --- pause ---
+	reg(mcp.Tool{
+		Name:             builtin.ToolBatchTaskPause,
+		Description:      "暂停正在运行的批量任务队列（当前子任务会被取消）。",
+		ShortDescription: "暂停批量任务队列",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"queue_id": map[string]interface{}{
+					"type":        "string",
+					"description": "队列 ID",
+				},
+			},
+			"required": []string{"queue_id"},
+		},
+	}, func(ctx context.Context, args map[string]interface{}) (*mcp.ToolResult, error) {
+		qid := mcpArgString(args, "queue_id")
+		if qid == "" {
+			return batchMCPTextResult("queue_id 不能为空", true), nil
+		}
+		if !h.batchTaskManager.PauseQueue(qid) {
+			return batchMCPTextResult("无法暂停：队列不存在或当前非 running 状态", true), nil
+		}
+		logger.Info("MCP batch_task_pause", zap.String("queueId", qid))
+		return batchMCPTextResult("队列已暂停。", false), nil
+	})
+
+	// --- delete queue ---
+	reg(mcp.Tool{
+		Name:             builtin.ToolBatchTaskDelete,
+		Description:      "删除批量任务队列及其子任务记录。",
+		ShortDescription: "删除批量任务队列",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"queue_id": map[string]interface{}{
+					"type":        "string",
+					"description": "队列 ID",
+				},
+			},
+			"required": []string{"queue_id"},
+		},
+	}, func(ctx context.Context, args map[string]interface{}) (*mcp.ToolResult, error) {
+		qid := mcpArgString(args, "queue_id")
+		if qid == "" {
+			return batchMCPTextResult("queue_id 不能为空", true), nil
+		}
+		if !h.batchTaskManager.DeleteQueue(qid) {
+			return batchMCPTextResult("删除失败：队列不存在", true), nil
+		}
+		logger.Info("MCP batch_task_delete", zap.String("queueId", qid))
+		return batchMCPTextResult("队列已删除。", false), nil
+	})
+
+	// --- schedule enabled ---
+	reg(mcp.Tool{
+		Name: builtin.ToolBatchTaskScheduleEnabled,
+		Description: `设置是否允许 Cron 自动触发该队列。关闭后仍保留 Cron 表达式，仅停止定时自动跑；可用手工「启动」执行。
+仅对 schedule_mode 为 cron 的队列有意义。`,
+		ShortDescription: "开关批量任务 Cron 自动调度",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"queue_id": map[string]interface{}{
+					"type":        "string",
+					"description": "队列 ID",
+				},
+				"schedule_enabled": map[string]interface{}{
+					"type":        "boolean",
+					"description": "true 允许定时触发，false 仅手工执行",
+				},
+			},
+			"required": []string{"queue_id", "schedule_enabled"},
+		},
+	}, func(ctx context.Context, args map[string]interface{}) (*mcp.ToolResult, error) {
+		qid := mcpArgString(args, "queue_id")
+		if qid == "" {
+			return batchMCPTextResult("queue_id 不能为空", true), nil
+		}
+		en, ok := mcpArgBool(args, "schedule_enabled")
+		if !ok {
+			return batchMCPTextResult("schedule_enabled 必须为布尔值", true), nil
+		}
+		if _, exists := h.batchTaskManager.GetBatchQueue(qid); !exists {
+			return batchMCPTextResult("队列不存在", true), nil
+		}
+		if !h.batchTaskManager.SetScheduleEnabled(qid, en) {
+			return batchMCPTextResult("更新失败", true), nil
+		}
+		queue, _ := h.batchTaskManager.GetBatchQueue(qid)
+		logger.Info("MCP batch_task_schedule_enabled", zap.String("queueId", qid), zap.Bool("enabled", en))
+		return batchMCPJSONResult(queue)
+	})
+
+	// --- add task ---
+	reg(mcp.Tool{
+		Name:             builtin.ToolBatchTaskAdd,
+		Description:      "向处于 pending 状态的队列追加一条子任务。",
+		ShortDescription: "批量队列添加子任务",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"queue_id": map[string]interface{}{
+					"type":        "string",
+					"description": "队列 ID",
+				},
+				"message": map[string]interface{}{
+					"type":        "string",
+					"description": "任务指令内容",
+				},
+			},
+			"required": []string{"queue_id", "message"},
+		},
+	}, func(ctx context.Context, args map[string]interface{}) (*mcp.ToolResult, error) {
+		qid := mcpArgString(args, "queue_id")
+		msg := strings.TrimSpace(mcpArgString(args, "message"))
+		if qid == "" || msg == "" {
+			return batchMCPTextResult("queue_id 与 message 均不能为空", true), nil
+		}
+		task, err := h.batchTaskManager.AddTaskToQueue(qid, msg)
+		if err != nil {
+			return batchMCPTextResult(err.Error(), true), nil
+		}
+		queue, _ := h.batchTaskManager.GetBatchQueue(qid)
+		logger.Info("MCP batch_task_add_task", zap.String("queueId", qid), zap.String("taskId", task.ID))
+		return batchMCPJSONResult(map[string]interface{}{"task": task, "queue": queue})
+	})
+
+	// --- update task ---
+	reg(mcp.Tool{
+		Name:             builtin.ToolBatchTaskUpdate,
+		Description:      "修改 pending 队列中仍为 pending 的子任务文案。",
+		ShortDescription: "更新批量子任务内容",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"queue_id": map[string]interface{}{
+					"type":        "string",
+					"description": "队列 ID",
+				},
+				"task_id": map[string]interface{}{
+					"type":        "string",
+					"description": "子任务 ID",
+				},
+				"message": map[string]interface{}{
+					"type":        "string",
+					"description": "新的任务指令",
+				},
+			},
+			"required": []string{"queue_id", "task_id", "message"},
+		},
+	}, func(ctx context.Context, args map[string]interface{}) (*mcp.ToolResult, error) {
+		qid := mcpArgString(args, "queue_id")
+		tid := mcpArgString(args, "task_id")
+		msg := strings.TrimSpace(mcpArgString(args, "message"))
+		if qid == "" || tid == "" || msg == "" {
+			return batchMCPTextResult("queue_id、task_id、message 均不能为空", true), nil
+		}
+		if err := h.batchTaskManager.UpdateTaskMessage(qid, tid, msg); err != nil {
+			return batchMCPTextResult(err.Error(), true), nil
+		}
+		queue, _ := h.batchTaskManager.GetBatchQueue(qid)
+		logger.Info("MCP batch_task_update_task", zap.String("queueId", qid), zap.String("taskId", tid))
+		return batchMCPJSONResult(queue)
+	})
+
+	// --- remove task ---
+	reg(mcp.Tool{
+		Name:             builtin.ToolBatchTaskRemove,
+		Description:      "从 pending 队列中删除仍为 pending 的子任务。",
+		ShortDescription: "删除批量子任务",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"queue_id": map[string]interface{}{
+					"type":        "string",
+					"description": "队列 ID",
+				},
+				"task_id": map[string]interface{}{
+					"type":        "string",
+					"description": "子任务 ID",
+				},
+			},
+			"required": []string{"queue_id", "task_id"},
+		},
+	}, func(ctx context.Context, args map[string]interface{}) (*mcp.ToolResult, error) {
+		qid := mcpArgString(args, "queue_id")
+		tid := mcpArgString(args, "task_id")
+		if qid == "" || tid == "" {
+			return batchMCPTextResult("queue_id 与 task_id 均不能为空", true), nil
+		}
+		if err := h.batchTaskManager.DeleteTask(qid, tid); err != nil {
+			return batchMCPTextResult(err.Error(), true), nil
+		}
+		queue, _ := h.batchTaskManager.GetBatchQueue(qid)
+		logger.Info("MCP batch_task_remove_task", zap.String("queueId", qid), zap.String("taskId", tid))
+		return batchMCPJSONResult(queue)
+	})
+
+	logger.Info("批量任务 MCP 工具已注册", zap.Int("count", 10))
+}
+
+func batchMCPTextResult(text string, isErr bool) *mcp.ToolResult {
+	return &mcp.ToolResult{
+		Content: []mcp.Content{{Type: "text", Text: text}},
+		IsError: isErr,
+	}
+}
+
+func batchMCPJSONResult(v interface{}) (*mcp.ToolResult, error) {
+	b, err := json.MarshalIndent(v, "", "  ")
+	if err != nil {
+		return batchMCPTextResult(fmt.Sprintf("JSON 编码失败: %v", err), true), nil
+	}
+	return &mcp.ToolResult{Content: []mcp.Content{{Type: "text", Text: string(b)}}}, nil
+}
+
+func batchMCPTasksFromArgs(args map[string]interface{}) ([]string, string) {
+	if raw, ok := args["tasks"]; ok && raw != nil {
+		switch t := raw.(type) {
+		case []interface{}:
+			out := make([]string, 0, len(t))
+			for _, x := range t {
+				if s, ok := x.(string); ok {
+					if tr := strings.TrimSpace(s); tr != "" {
+						out = append(out, tr)
+					}
+				}
+			}
+			if len(out) > 0 {
+				return out, ""
+			}
+		}
+	}
+	if txt := mcpArgString(args, "tasks_text"); txt != "" {
+		lines := strings.Split(txt, "\n")
+		out := make([]string, 0, len(lines))
+		for _, line := range lines {
+			if tr := strings.TrimSpace(line); tr != "" {
+				out = append(out, tr)
+			}
+		}
+		if len(out) > 0 {
+			return out, ""
+		}
+	}
+	return nil, "需要提供 tasks（字符串数组）或 tasks_text（多行文本，每行一条任务）"
+}
+
+func mcpArgString(args map[string]interface{}, key string) string {
+	v, ok := args[key]
+	if !ok || v == nil {
+		return ""
+	}
+	switch t := v.(type) {
+	case string:
+		return strings.TrimSpace(t)
+	case float64:
+		return strings.TrimSpace(strconv.FormatFloat(t, 'f', -1, 64))
+	case json.Number:
+		return strings.TrimSpace(t.String())
+	default:
+		return strings.TrimSpace(fmt.Sprint(t))
+	}
+}
+
+func mcpArgFloat(args map[string]interface{}, key string) float64 {
+	v, ok := args[key]
+	if !ok || v == nil {
+		return 0
+	}
+	switch t := v.(type) {
+	case float64:
+		return t
+	case int:
+		return float64(t)
+	case int64:
+		return float64(t)
+	case json.Number:
+		f, _ := t.Float64()
+		return f
+	case string:
+		f, _ := strconv.ParseFloat(strings.TrimSpace(t), 64)
+		return f
+	default:
+		return 0
+	}
+}
+
+func mcpArgBool(args map[string]interface{}, key string) (val bool, ok bool) {
+	v, exists := args[key]
+	if !exists {
+		return false, false
+	}
+	switch t := v.(type) {
+	case bool:
+		return t, true
+	case string:
+		s := strings.ToLower(strings.TrimSpace(t))
+		if s == "true" || s == "1" || s == "yes" {
+			return true, true
+		}
+		if s == "false" || s == "0" || s == "no" {
+			return false, true
+		}
+	case float64:
+		return t != 0, true
+	}
+	return false, false
+}

internal/handler/config.go

@@ -37,6 +37,9 @@ type WebshellToolRegistrar func() error
 // SkillsToolRegistrar Skills工具注册器接口
 type SkillsToolRegistrar func() error
 
+// BatchTaskToolRegistrar 批量任务 MCP 工具注册器（ApplyConfig 时重新注册）
+type BatchTaskToolRegistrar func() error
+
 // RetrieverUpdater 检索器更新接口
 type RetrieverUpdater interface {
 	UpdateConfig(config *knowledge.RetrievalConfig)
@@ -68,6 +71,7 @@ type ConfigHandler struct {
 	vulnerabilityToolRegistrar VulnerabilityToolRegistrar // 漏洞工具注册器（可选）
 	webshellToolRegistrar      WebshellToolRegistrar      // WebShell 工具注册器（可选）
 	skillsToolRegistrar        SkillsToolRegistrar        // Skills工具注册器（可选）
+	batchTaskToolRegistrar     BatchTaskToolRegistrar     // 批量任务 MCP 工具（可选）
 	retrieverUpdater           RetrieverUpdater           // 检索器更新器（可选）
 	knowledgeInitializer       KnowledgeInitializer       // 知识库初始化器（可选）
 	appUpdater                 AppUpdater                 // App更新器（可选）
@@ -141,6 +145,13 @@ func (h *ConfigHandler) SetSkillsToolRegistrar(registrar SkillsToolRegistrar) {
 	h.skillsToolRegistrar = registrar
 }
 
+// SetBatchTaskToolRegistrar 设置批量任务 MCP 工具注册器
+func (h *ConfigHandler) SetBatchTaskToolRegistrar(registrar BatchTaskToolRegistrar) {
+	h.mu.Lock()
+	defer h.mu.Unlock()
+	h.batchTaskToolRegistrar = registrar
+}
+
 // SetRetrieverUpdater 设置检索器更新器
 func (h *ConfigHandler) SetRetrieverUpdater(updater RetrieverUpdater) {
 	h.mu.Lock()
@@ -999,6 +1010,16 @@ func (h *ConfigHandler) ApplyConfig(c *gin.Context) {
 		}
 	}
 
+	// 重新注册批量任务 MCP 工具
+	if h.batchTaskToolRegistrar != nil {
+		h.logger.Info("重新注册批量任务 MCP 工具")
+		if err := h.batchTaskToolRegistrar(); err != nil {
+			h.logger.Error("重新注册批量任务 MCP 工具失败", zap.Error(err))
+		} else {
+			h.logger.Info("批量任务 MCP 工具已重新注册")
+		}
+	}
+
 	// 如果知识库启用，重新注册知识库工具
 	if h.config.Knowledge.Enabled && h.knowledgeToolRegistrar != nil {
 		h.logger.Info("重新注册知识库工具")

internal/mcp/builtin/constants.go

@@ -11,14 +11,14 @@ const (
 	ToolSearchKnowledgeBase    = "search_knowledge_base"
 
 	// Skills工具
-	ToolListSkills    = "list_skills"
-	ToolReadSkill     = "read_skill"
+	ToolListSkills = "list_skills"
+	ToolReadSkill  = "read_skill"
 
 	// WebShell 助手工具（AI 在 WebShell 管理 - AI 助手 中使用）
-	ToolWebshellExec       = "webshell_exec"
-	ToolWebshellFileList   = "webshell_file_list"
-	ToolWebshellFileRead   = "webshell_file_read"
-	ToolWebshellFileWrite  = "webshell_file_write"
+	ToolWebshellExec      = "webshell_exec"
+	ToolWebshellFileList  = "webshell_file_list"
+	ToolWebshellFileRead  = "webshell_file_read"
+	ToolWebshellFileWrite = "webshell_file_write"
 
 	// WebShell 连接管理工具（用于通过 MCP 管理 webshell 连接）
 	ToolManageWebshellList   = "manage_webshell_list"
@@ -26,6 +26,18 @@ const (
 	ToolManageWebshellUpdate = "manage_webshell_update"
 	ToolManageWebshellDelete = "manage_webshell_delete"
 	ToolManageWebshellTest   = "manage_webshell_test"
+
+	// 批量任务队列（与 Web 端批量任务一致，供模型创建/启停/查询队列）
+	ToolBatchTaskList            = "batch_task_list"
+	ToolBatchTaskGet             = "batch_task_get"
+	ToolBatchTaskCreate          = "batch_task_create"
+	ToolBatchTaskStart           = "batch_task_start"
+	ToolBatchTaskPause           = "batch_task_pause"
+	ToolBatchTaskDelete          = "batch_task_delete"
+	ToolBatchTaskScheduleEnabled = "batch_task_schedule_enabled"
+	ToolBatchTaskAdd             = "batch_task_add_task"
+	ToolBatchTaskUpdate          = "batch_task_update_task"
+	ToolBatchTaskRemove          = "batch_task_remove_task"
 )
 
 // IsBuiltinTool 检查工具名称是否是内置工具
@@ -44,7 +56,17 @@ func IsBuiltinTool(toolName string) bool {
 		ToolManageWebshellAdd,
 		ToolManageWebshellUpdate,
 		ToolManageWebshellDelete,
-		ToolManageWebshellTest:
+		ToolManageWebshellTest,
+		ToolBatchTaskList,
+		ToolBatchTaskGet,
+		ToolBatchTaskCreate,
+		ToolBatchTaskStart,
+		ToolBatchTaskPause,
+		ToolBatchTaskDelete,
+		ToolBatchTaskScheduleEnabled,
+		ToolBatchTaskAdd,
+		ToolBatchTaskUpdate,
+		ToolBatchTaskRemove:
 		return true
 	default:
 		return false
@@ -68,5 +90,15 @@ func GetAllBuiltinTools() []string {
 		ToolManageWebshellUpdate,
 		ToolManageWebshellDelete,
 		ToolManageWebshellTest,
+		ToolBatchTaskList,
+		ToolBatchTaskGet,
+		ToolBatchTaskCreate,
+		ToolBatchTaskStart,
+		ToolBatchTaskPause,
+		ToolBatchTaskDelete,
+		ToolBatchTaskScheduleEnabled,
+		ToolBatchTaskAdd,
+		ToolBatchTaskUpdate,
+		ToolBatchTaskRemove,
 	}
 }

web/static/css/style.css

@@ -441,7 +441,9 @@ body {
     /* 确保底部左右角都是圆角 */
     border-bottom-left-radius: 8px;
     border-bottom-right-radius: 8px;
-    overflow: hidden;
+    /* 勿用 overflow:hidden：会覆盖 .page-content 的 overflow-y:auto，任务多时无法滚动 */
+    overflow-x: hidden;
+    overflow-y: auto;
 }
 
 /* 对话页面布局 */
@@ -8196,6 +8198,41 @@ header {
     overflow: hidden;
 }
 
+/* 列表 + 底部分页同一外框，与 MCP 监控「表格 + 分页」一致 */
+.batch-queues-board {
+    border: 1px solid var(--border-color);
+    border-radius: 12px;
+    overflow: hidden;
+    width: 100%;
+    box-sizing: border-box;
+    background: var(--bg-primary);
+}
+
+.batch-queues-board .batch-queues-list {
+    margin-bottom: 0;
+    padding: 12px 16px;
+    box-sizing: border-box;
+}
+
+.batch-queues-board #batch-queues-pagination {
+    margin-top: 0;
+    padding: 0;
+    background: transparent;
+    border: none;
+    box-shadow: none;
+    border-radius: 0;
+    width: 100%;
+    box-sizing: border-box;
+}
+
+.batch-queues-board #batch-queues-pagination .monitor-pagination {
+    margin-top: 0;
+}
+
+.batch-queues-filters.tasks-filters {
+    margin-bottom: 12px;
+}
+
 .batch-queues-header {
     display: flex;
     justify-content: space-between;
@@ -8214,26 +8251,370 @@ header {
 .batch-queues-list {
     display: flex;
     flex-direction: column;
-    gap: 16px;
-    margin-bottom: 16px;
+    gap: 12px;
+    margin-bottom: 28px;
 }
 
 .batch-queue-item {
     background: var(--bg-primary);
     border: 1px solid var(--border-color);
-    border-radius: 12px;
-    padding: 20px;
+    border-radius: 14px;
+    padding: 14px 16px;
     box-shadow: var(--shadow-sm);
-    transition: all 0.2s ease;
+    transition: border-color 0.2s ease, box-shadow 0.2s ease, transform 0.2s ease;
     cursor: pointer;
 }
 
 .batch-queue-item:hover {
     box-shadow: var(--shadow-md);
-    transform: translateY(-2px);
+    transform: translateY(-1px);
     border-color: var(--accent-color);
 }
 
+.batch-queue-item--cron-wait {
+    border-left: 3px solid var(--accent-color);
+}
+
+.batch-queue-item--cron-wait:hover {
+    border-color: var(--accent-color);
+}
+
+.batch-queue-item__inner {
+    display: flex;
+    flex-direction: column;
+    gap: 10px;
+    min-width: 0;
+}
+
+.batch-queue-item__top {
+    display: flex;
+    align-items: flex-start;
+    justify-content: space-between;
+    gap: 10px 14px;
+}
+
+.batch-queue-item__top-actions {
+    flex-shrink: 0;
+    margin-top: 1px;
+}
+
+.batch-queue-icon-btn {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 36px;
+    height: 36px;
+    padding: 0;
+    border-radius: 10px;
+    border: 1px solid var(--border-color);
+    background: var(--bg-secondary);
+    color: var(--text-secondary);
+    cursor: pointer;
+    transition: color 0.15s ease, border-color 0.15s ease, background 0.15s ease;
+}
+
+.batch-queue-icon-btn:hover {
+    color: var(--error-color, #dc3545);
+    border-color: rgba(220, 53, 69, 0.35);
+    background: rgba(220, 53, 69, 0.06);
+}
+
+.batch-queue-icon-btn__svg {
+    display: block;
+}
+
+.batch-queue-item__band {
+    display: flex;
+    flex-wrap: wrap;
+    align-items: center;
+    gap: 12px 16px;
+    padding: 12px 14px;
+    margin: 0;
+    background: var(--bg-secondary);
+    border-radius: 10px;
+    border: 1px solid var(--border-color);
+}
+
+.batch-queue-item__band-left {
+    flex: 1 1 220px;
+    min-width: 0;
+}
+
+.batch-queue-item__band-right {
+    flex: 1 1 200px;
+    min-width: 160px;
+    max-width: 100%;
+    margin-left: auto;
+    display: flex;
+    flex-direction: column;
+    gap: 6px;
+    align-items: stretch;
+}
+
+.batch-queue-progress-meta--band {
+    align-items: stretch;
+    text-align: right;
+}
+
+.batch-queue-progress-meta--band .batch-queue-progress-note {
+    text-align: right;
+    max-width: none;
+}
+
+@media (max-width: 520px) {
+    .batch-queue-item__band-right {
+        margin-left: 0;
+        flex-basis: 100%;
+    }
+
+    .batch-queue-progress-meta--band {
+        text-align: left;
+    }
+
+    .batch-queue-progress-meta--band .batch-queue-progress-note {
+        text-align: left;
+    }
+}
+
+.batch-queue-card-row {
+    display: flex;
+    flex-wrap: wrap;
+    align-items: flex-start;
+    justify-content: space-between;
+    gap: 16px 20px;
+    margin-bottom: 12px;
+}
+
+.batch-queue-primary {
+    flex: 1 1 280px;
+    min-width: 0;
+    display: flex;
+    flex-direction: column;
+    gap: 10px;
+}
+
+.batch-queue-card-title {
+    margin: 0;
+    font-size: 1rem;
+    font-weight: 600;
+    color: var(--text-primary);
+    line-height: 1.35;
+    letter-spacing: -0.015em;
+}
+
+.batch-queue-card-title--muted {
+    color: var(--text-secondary);
+    font-weight: 500;
+}
+
+.batch-queue-chips {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 6px;
+    align-items: center;
+}
+
+.batch-queue-chip {
+    display: inline-flex;
+    align-items: center;
+    gap: 5px;
+    padding: 4px 11px;
+    border-radius: 999px;
+    font-size: 0.75rem;
+    font-weight: 500;
+    color: var(--text-secondary);
+    background: var(--bg-secondary);
+    border: 1px solid var(--border-color);
+    max-width: 100%;
+}
+
+.batch-queue-chip-emoji {
+    font-size: 0.875rem;
+    line-height: 1;
+    flex-shrink: 0;
+}
+
+.batch-queue-chip-text {
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    max-width: 200px;
+}
+
+.batch-queue-chip--role .batch-queue-chip-text {
+    max-width: 160px;
+}
+
+.batch-queue-chip--schedule {
+    color: var(--accent-color);
+    border-color: var(--border-color);
+    background: var(--bg-primary);
+    box-shadow: inset 2px 0 0 0 var(--accent-color);
+}
+
+.batch-queue-chip--warn {
+    color: #b45309;
+    border-color: rgba(180, 83, 9, 0.35);
+    background: rgba(251, 191, 36, 0.12);
+}
+
+.batch-queue-status-row {
+    display: flex;
+    flex-wrap: wrap;
+    align-items: center;
+    gap: 8px 12px;
+}
+
+.batch-queue-next-run {
+    display: inline-flex;
+    align-items: center;
+    gap: 8px;
+    padding: 6px 12px;
+    border-radius: 10px;
+    background: var(--bg-primary);
+    border: 1px solid var(--border-color);
+    border-left: 3px solid var(--accent-color);
+    font-size: 0.8125rem;
+    font-weight: 500;
+    color: var(--text-primary);
+}
+
+.batch-queue-next-run__icon {
+    font-size: 1rem;
+    line-height: 1;
+    opacity: 0.88;
+}
+
+.batch-queue-next-run__text {
+    line-height: 1.35;
+}
+
+.batch-queue-footnotes {
+    display: flex;
+    flex-wrap: wrap;
+    align-items: center;
+    gap: 6px 8px;
+    margin-top: 2px;
+    font-size: 0.75rem;
+    color: var(--text-secondary);
+}
+
+.batch-queue-footnotes__id code {
+    font-size: 0.7rem;
+    padding: 2px 7px;
+    border-radius: 6px;
+    background: var(--bg-secondary);
+    border: 1px solid var(--border-color);
+    word-break: break-all;
+    color: var(--text-secondary);
+}
+
+.batch-queue-footnotes__sep {
+    opacity: 0.45;
+    user-select: none;
+}
+
+.batch-queue-side {
+    flex: 0 1 232px;
+    display: flex;
+    flex-direction: column;
+    align-items: flex-end;
+    gap: 10px;
+}
+
+.batch-queue-delete-btn {
+    font-size: 0.75rem !important;
+    padding: 5px 12px !important;
+    color: var(--text-secondary) !important;
+    border-color: var(--border-color) !important;
+    background: var(--bg-primary) !important;
+}
+
+.batch-queue-delete-btn:hover {
+    color: var(--error-color, #dc3545) !important;
+    border-color: rgba(220, 53, 69, 0.4) !important;
+    background: rgba(220, 53, 69, 0.06) !important;
+}
+
+.batch-queue-progress-stack {
+    width: 100%;
+    min-width: 200px;
+}
+
+.batch-queue-progress-bar.batch-queue-progress-bar--card {
+    height: 10px;
+    border-radius: 999px;
+    background: var(--bg-secondary);
+    overflow: hidden;
+}
+
+.batch-queue-progress-fill--cron-wait {
+    background: linear-gradient(90deg, var(--accent-color), var(--accent-hover), var(--accent-color));
+    background-size: 200% 100%;
+    animation: batch-queue-progress-shimmer 2.4s ease infinite;
+}
+
+@keyframes batch-queue-progress-shimmer {
+    0% {
+        background-position: 100% 0;
+    }
+    100% {
+        background-position: -100% 0;
+    }
+}
+
+.batch-queue-progress-stack .batch-queue-progress-meta {
+    width: 100%;
+    align-items: flex-end;
+}
+
+.batch-queue-progress-fraction {
+    color: var(--text-secondary);
+    font-weight: 400;
+    font-size: 0.8125rem;
+}
+
+.batch-queue-stats--pills {
+    margin: 0;
+    padding-top: 10px;
+    border-top: 1px solid var(--border-color);
+    gap: 8px;
+}
+
+.batch-queue-stat-pill {
+    display: inline-flex;
+    align-items: baseline;
+    gap: 6px;
+    padding: 5px 11px;
+    border-radius: 8px;
+    background: var(--bg-secondary);
+    border: 1px solid var(--border-color);
+    font-size: 0.75rem;
+}
+
+.batch-queue-stat-pill__k {
+    color: var(--text-secondary);
+    font-weight: 500;
+}
+
+.batch-queue-stat-pill__v {
+    font-weight: 600;
+    color: var(--text-primary);
+    font-variant-numeric: tabular-nums;
+}
+
+.batch-queue-stat-pill--ok .batch-queue-stat-pill__v {
+    color: var(--success-color);
+}
+
+.batch-queue-stat-pill--err .batch-queue-stat-pill__v {
+    color: var(--error-color);
+}
+
+.batch-queue-stat-pill--muted .batch-queue-stat-pill__v {
+    color: var(--text-secondary);
+}
+
 .batch-queue-header {
     display: flex;
     justify-content: space-between;
@@ -8273,12 +8654,106 @@ header {
     border: 1px solid rgba(0, 123, 255, 0.3);
 }
 
+.batch-queue-cron-active {
+    box-shadow: 0 0 0 1px rgba(0, 123, 255, 0.15);
+}
+
+.batch-queue-status-paused {
+    background: rgba(255, 193, 7, 0.12);
+    color: #b38600;
+    border: 1px solid rgba(255, 193, 7, 0.45);
+}
+
 .batch-queue-status-completed {
     background: rgba(40, 167, 69, 0.1);
     color: var(--success-color);
     border: 1px solid rgba(40, 167, 69, 0.3);
 }
 
+/* Cron 队列：本轮跑完、等待下次触发（区别于「一次性任务已完成」） */
+.batch-queue-status-cron-cycle {
+    background: var(--bg-primary);
+    color: var(--text-primary);
+    border: 1px dashed var(--accent-color);
+}
+
+.batch-queue-status-wrap {
+    display: inline-flex;
+    flex-direction: column;
+    align-items: flex-start;
+    gap: 4px;
+    max-width: 100%;
+}
+
+.batch-queue-cron-sublabel {
+    font-size: 0.75rem;
+    color: var(--accent-color);
+    font-weight: 500;
+    line-height: 1.35;
+    max-width: 280px;
+}
+
+.batch-queue-cron-sublabel.detail {
+    margin-top: 6px;
+    max-width: none;
+}
+
+.batch-queue-detail-status-wrap {
+    display: flex;
+    flex-direction: column;
+    align-items: flex-start;
+    gap: 4px;
+}
+
+.batch-queue-progress-meta {
+    display: flex;
+    flex-direction: column;
+    align-items: flex-end;
+    gap: 4px;
+    min-width: 0;
+}
+
+.batch-queue-progress-note {
+    font-size: 0.72rem;
+    color: var(--text-secondary);
+    line-height: 1.35;
+    text-align: right;
+    max-width: 240px;
+}
+
+.batch-queue-progress-note.detail {
+    text-align: left;
+    max-width: none;
+    margin-top: 2px;
+    opacity: 0.95;
+}
+
+.batch-queue-cron-callout {
+    display: flex;
+    gap: 12px;
+    align-items: flex-start;
+    padding: 12px 14px;
+    margin-bottom: 8px;
+    border-radius: 10px;
+    border: 1px solid var(--border-color);
+    border-left: 3px solid var(--accent-color);
+    background: var(--bg-secondary);
+}
+
+.batch-queue-cron-callout-icon {
+    font-size: 1.25rem;
+    line-height: 1.2;
+    flex-shrink: 0;
+    opacity: 0.9;
+}
+
+.batch-queue-cron-callout p {
+    margin: 0;
+    font-size: 0.875rem;
+    line-height: 1.5;
+    color: var(--text-primary);
+}
+
 .batch-queue-status-cancelled {
     background: rgba(108, 117, 125, 0.1);
     color: var(--text-secondary);
@@ -8337,6 +8812,288 @@ header {
     white-space: nowrap;
 }
 
+/* 批量队列详情：信息分层（状态 → 摘要 → 告警 → 折叠技术信息） */
+.batch-queue-detail-layout {
+    margin-bottom: 20px;
+}
+
+.batch-queue-detail-hero {
+    display: flex;
+    flex-direction: column;
+    align-items: flex-start;
+    gap: 8px;
+    padding: 14px 16px;
+    margin-bottom: 14px;
+    background: var(--bg-secondary);
+    border-radius: 10px;
+    border: 1px solid var(--border-color);
+}
+
+.batch-queue-detail-hero__sub {
+    margin: 0;
+    font-size: 0.875rem;
+    color: var(--text-primary);
+    line-height: 1.45;
+}
+
+.batch-queue-detail-hero__note {
+    margin: 0;
+    font-size: 0.8125rem;
+    color: var(--text-secondary);
+    line-height: 1.45;
+}
+
+.batch-queue-detail-kv {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(240px, 1fr));
+    gap: 10px 20px;
+    margin-bottom: 14px;
+}
+
+.bq-kv {
+    display: grid;
+    grid-template-columns: minmax(100px, 34%) 1fr;
+    gap: 8px 12px;
+    align-items: start;
+    padding: 8px 0;
+    border-bottom: 1px solid var(--border-color);
+    font-size: 0.875rem;
+}
+
+.bq-kv--block {
+    grid-column: 1 / -1;
+    grid-template-columns: minmax(100px, 28%) 1fr;
+}
+
+.bq-kv:last-child {
+    border-bottom: none;
+}
+
+.bq-kv__k {
+    color: var(--text-secondary);
+    font-weight: 500;
+    font-size: 0.8125rem;
+}
+
+.bq-kv__v {
+    color: var(--text-primary);
+    word-break: break-word;
+}
+
+.bq-kv__v code {
+    font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
+    font-size: 0.8125rem;
+    background: var(--bg-secondary);
+    padding: 2px 6px;
+    border-radius: 4px;
+}
+
+.bq-kv__v--control {
+    min-width: 0;
+}
+
+@media (max-width: 520px) {
+    .bq-kv,
+    .bq-kv--block {
+        grid-template-columns: 1fr;
+        gap: 4px;
+    }
+}
+
+.bq-cron-toggle {
+    display: flex;
+    align-items: flex-start;
+    gap: 10px;
+    cursor: pointer;
+    margin: 0;
+}
+
+.bq-cron-toggle input {
+    margin-top: 3px;
+    flex-shrink: 0;
+}
+
+.bq-cron-toggle__hint {
+    font-size: 0.8125rem;
+    color: var(--text-secondary);
+    line-height: 1.45;
+}
+
+.bq-alert {
+    padding: 10px 12px;
+    border-radius: 8px;
+    margin-bottom: 12px;
+    font-size: 0.8125rem;
+}
+
+.bq-alert--err {
+    background: rgba(220, 53, 69, 0.07);
+    border: 1px solid rgba(220, 53, 69, 0.28);
+    color: var(--text-primary);
+}
+
+.bq-alert--err strong {
+    display: block;
+    color: var(--error-color);
+    font-size: 0.8125rem;
+    margin-bottom: 4px;
+}
+
+.bq-alert--err p {
+    margin: 0;
+    color: var(--text-primary);
+    word-break: break-word;
+}
+
+.batch-queue-detail-tech {
+    margin-bottom: 8px;
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    background: var(--bg-primary);
+    padding: 0 12px;
+}
+
+.batch-queue-detail-tech__sum {
+    cursor: pointer;
+    font-size: 0.8125rem;
+    font-weight: 600;
+    color: var(--text-secondary);
+    padding: 10px 0;
+    list-style: none;
+}
+
+.batch-queue-detail-tech__sum::-webkit-details-marker {
+    display: none;
+}
+
+.batch-queue-detail-tech__body {
+    padding: 4px 0 12px;
+    border-top: 1px solid var(--border-color);
+}
+
+.batch-queue-detail-tech__body .bq-kv:first-child {
+    padding-top: 10px;
+}
+
+.batch-queue-cron-callout--compact {
+    margin-bottom: 12px;
+    padding: 10px 12px;
+}
+
+.batch-queue-cron-callout--compact p {
+    font-size: 0.8125rem;
+}
+
+/* 列表卡片紧凑布局 */
+.batch-queue-item__config {
+    margin: 4px 0 0;
+    font-size: 0.8125rem;
+    color: var(--text-secondary);
+    line-height: 1.4;
+}
+
+.batch-queue-item__idline {
+    margin: 6px 0 0;
+    font-size: 0.75rem;
+    color: var(--text-secondary);
+    display: flex;
+    flex-wrap: wrap;
+    align-items: center;
+    gap: 4px 6px;
+}
+
+.batch-queue-item__idline code {
+    font-size: 0.7rem;
+    padding: 1px 6px;
+    border-radius: 4px;
+    background: var(--bg-secondary);
+    border: 1px solid var(--border-color);
+    word-break: break-all;
+}
+
+.batch-queue-item__idsep {
+    opacity: 0.45;
+    user-select: none;
+}
+
+.batch-queue-inline-warn {
+    color: #b45309;
+    font-weight: 500;
+    font-size: 0.8125rem;
+}
+
+.batch-queue-item__mid {
+    display: flex;
+    flex-wrap: wrap;
+    align-items: center;
+    gap: 10px 16px;
+    padding: 10px 0 6px;
+    border-top: 1px solid var(--border-color);
+    border-bottom: 1px solid var(--border-color);
+}
+
+.batch-queue-item__mid-left {
+    display: flex;
+    flex-wrap: wrap;
+    align-items: center;
+    gap: 8px 12px;
+    flex: 1 1 200px;
+    min-width: 0;
+}
+
+.batch-queue-item__sublabel {
+    font-size: 0.8125rem;
+    color: var(--text-primary);
+    line-height: 1.35;
+}
+
+.batch-queue-item__mid-right {
+    flex: 0 1 200px;
+    min-width: 140px;
+    display: flex;
+    flex-direction: column;
+    gap: 4px;
+    align-items: stretch;
+}
+
+.batch-queue-progress-bar--list {
+    height: 8px;
+}
+
+.batch-queue-item__pct {
+    font-size: 0.75rem;
+    color: var(--text-secondary);
+    text-align: right;
+}
+
+.batch-queue-item__pct-frac {
+    font-variant-numeric: tabular-nums;
+}
+
+.batch-queue-statsline {
+    display: flex;
+    flex-wrap: wrap;
+    align-items: center;
+    gap: 4px 0;
+    font-size: 0.75rem;
+    color: var(--text-secondary);
+    padding-top: 8px;
+}
+
+.batch-queue-statsline__sep {
+    margin: 0 8px;
+    opacity: 0.4;
+    user-select: none;
+}
+
+.batch-queue-statsline__item--ok {
+    color: var(--success-color);
+}
+
+.batch-queue-statsline__item--err {
+    color: var(--error-color);
+}
+
 .batch-queue-detail-info {
     margin-bottom: 24px;
     padding: 20px;
@@ -8421,12 +9178,21 @@ header {
     color: var(--text-primary);
 }
 
+.batch-queue-detail-layout + .batch-queue-tasks-list h4 {
+    margin-top: 4px;
+}
+
+.batch-queue-item__title-col {
+    flex: 1;
+    min-width: 0;
+}
+
 .batch-task-item {
     background: var(--bg-primary);
     border: 1px solid var(--border-color);
     border-radius: 8px;
-    padding: 16px;
-    margin-bottom: 12px;
+    padding: 12px 14px;
+    margin-bottom: 10px;
     transition: all 0.2s ease;
 }
 
@@ -8556,15 +9322,56 @@ header {
         flex-direction: column;
         align-items: flex-start;
     }
-    
+
+    .batch-queue-item__top {
+        flex-wrap: wrap;
+        gap: 8px 10px;
+    }
+
+    .batch-queue-item__mid {
+        flex-direction: column;
+        align-items: stretch;
+    }
+
+    .batch-queue-item__mid-right {
+        flex: 1 1 auto;
+        max-width: none;
+    }
+
+    .batch-queue-item__pct {
+        text-align: left;
+    }
+
+    .batch-queue-card-row {
+        flex-direction: column;
+    }
+
+    .batch-queue-side {
+        flex-basis: auto;
+        width: 100%;
+        align-items: stretch;
+    }
+
+    .batch-queue-delete-btn {
+        align-self: flex-end;
+    }
+
+    .batch-queue-progress-stack {
+        min-width: 0;
+    }
+
     .batch-queue-progress {
         width: 100%;
     }
-    
+
     .batch-queue-stats {
         flex-direction: column;
         gap: 8px;
     }
+
+    .batch-queue-stats--pills {
+        justify-content: flex-start;
+    }
     
     .batch-task-header {
         flex-direction: column;

web/static/i18n/en-US.json

@@ -254,6 +254,14 @@
     "conversationIdLabel": "Conversation ID",
     "statusPending": "Pending",
     "statusPaused": "Paused",
+    "statusCronCycleIdle": "Round done · scheduled loop",
+    "statusCronRunning": "Running · cron queue",
+    "cronNextRunLine": "Next run: {{time}}",
+    "cronRoundDoneProgressHint": "Cron queue: subtasks finished; next round starts on schedule",
+    "cronRunningProgressHint": "This round is running; the next full cycle follows Cron / next run time",
+    "cronPendingScheduled": "Cron scheduled · next {{time}}",
+    "cronPendingProgressNote": "Will start on schedule, or click Start to run a round now",
+    "cronRecurringCallout": "Cron queues start a new round at each scheduled time. Turn off \"Allow Cron auto-run\" to stop looping.",
     "confirmCancelTasks": "Cancel {{n}} selected task(s)?",
     "batchCancelResultPartial": "Batch cancel: {{success}} succeeded, {{fail}} failed",
     "batchCancelResultSuccess": "Successfully cancelled {{n}} task(s)",
@@ -276,6 +284,7 @@
     "deleteQueueConfirm": "Delete this batch queue? This cannot be undone.",
     "deleteQueueFailed": "Failed to delete batch queue",
     "batchQueueTitle": "Batch task queue",
+    "batchQueueUntitled": "Untitled queue",
     "resumeExecute": "Resume",
     "taskIncomplete": "Task information incomplete",
     "cannotGetTaskMessageInput": "Cannot get task message input",
@@ -285,7 +294,7 @@
     "addTaskFailed": "Failed to add task",
     "confirmDeleteTask": "Delete this task?\n\nTask: {{message}}\n\nThis cannot be undone.",
     "deleteTaskFailed": "Failed to delete task",
-    "paginationShow": "{{start}}-{{end}} of {{total}}",
+    "paginationShow": "Show {{start}}-{{end}} of {{total}} records",
     "paginationPerPage": "Per page",
     "paginationFirst": "First",
     "paginationPrev": "Previous",
@@ -1494,6 +1503,18 @@
     "role": "Role",
     "defaultRole": "Default",
     "roleHint": "Select a role; all tasks will be executed using that role's configuration (prompt and tools).",
+    "agentMode": "Agent mode",
+    "agentModeSingle": "Single-agent (ReAct)",
+    "agentModeMulti": "Multi-agent (Eino)",
+    "agentModeHint": "Single-agent is recommended by default; use multi-agent for complex tasks (requires system multi-agent enabled).",
+    "scheduleMode": "Schedule mode",
+    "scheduleModeManual": "Manual",
+    "scheduleModeCron": "Cron expression",
+    "scheduleModeHint": "Manual is for one-time runs; Cron is for recurring runs. Validate tasks manually first.",
+    "cronExpr": "Cron expression",
+    "cronExprPlaceholder": "e.g. 0 */2 * * * (run every 2 hours)",
+    "cronExprHint": "Use standard 5-field Cron: minute hour day month weekday. Example: `0 2 * * *` runs at 02:00 daily.",
+    "cronExprRequired": "Please fill in a Cron expression when Cron schedule is selected",
     "tasksList": "Task list (one task per line)",
     "tasksListPlaceholder": "Enter task list, one per line",
     "tasksListPlaceholderExample": "Enter task list, one per line, for example:\nScan open ports of 192.168.1.1\nCheck if https://example.com has SQL injection\nEnumerate subdomains of example.com",
@@ -1514,13 +1535,22 @@
     "status": "Status",
     "createdAt": "Created at",
     "startedAt": "Started at",
+    "nextRunAt": "Next run at",
+    "scheduleCronAuto": "Allow Cron auto-run",
+    "scheduleCronAutoHint": "When off, the cron expression is kept but the queue will not run on schedule; use Start to run manually.",
+    "lastScheduleTriggerAt": "Last scheduled trigger",
+    "lastScheduleError": "Last schedule error",
+    "lastRunError": "Last run failure summary",
+    "cronSchedulePausedBadge": "Schedule paused",
+    "scheduleToggleFailed": "Failed to update schedule toggle",
     "completedAt": "Completed at",
     "taskTotal": "Total tasks",
     "taskList": "Task list",
     "startLabel": "Start",
     "completeLabel": "Complete",
     "errorLabel": "Error",
-    "resultLabel": "Result"
+    "resultLabel": "Result",
+    "technicalDetails": "Technical details (ID, times, schedule)"
   },
   "editBatchTaskModal": {
     "title": "Edit task",

web/static/i18n/zh-CN.json

@@ -254,6 +254,14 @@
     "conversationIdLabel": "对话ID",
     "statusPending": "待执行",
     "statusPaused": "已暂停",
+    "statusCronCycleIdle": "本轮已完成 · 定时循环中",
+    "statusCronRunning": "执行中 · 定时队列",
+    "cronNextRunLine": "下次执行：{{time}}",
+    "cronRoundDoneProgressHint": "定时队列：子任务已跑完，到点将自动下一轮",
+    "cronRunningProgressHint": "本轮执行中；下一整轮仍按 Cron 与「下次执行时间」排程",
+    "cronPendingScheduled": "Cron 已排程 · 下次 {{time}}",
+    "cronPendingProgressNote": "到点将自动开始；也可手动点「开始执行」立即跑一轮",
+    "cronRecurringCallout": "Cron 队列会在「下次执行时间」自动开始新一轮；关闭「允许 Cron 自动调度」即停止循环。",
     "confirmCancelTasks": "确定要取消 {{n}} 个任务吗？",
     "batchCancelResultPartial": "批量取消完成：成功 {{success}} 个，失败 {{fail}} 个",
     "batchCancelResultSuccess": "成功取消 {{n}} 个任务",
@@ -276,6 +284,7 @@
     "deleteQueueConfirm": "确定要删除这个批量任务队列吗？此操作不可恢复。",
     "deleteQueueFailed": "删除批量任务队列失败",
     "batchQueueTitle": "批量任务队列",
+    "batchQueueUntitled": "未命名队列",
     "resumeExecute": "继续执行",
     "taskIncomplete": "任务信息不完整",
     "cannotGetTaskMessageInput": "无法获取任务消息输入框",
@@ -285,7 +294,7 @@
     "addTaskFailed": "添加任务失败",
     "confirmDeleteTask": "确定要删除这个任务吗？\n\n任务内容: {{message}}\n\n此操作不可恢复。",
     "deleteTaskFailed": "删除任务失败",
-    "paginationShow": "显示 {{start}}-{{end}} / 共 {{total}} 条",
+    "paginationShow": "显示 {{start}}-{{end}} / 共 {{total}} 条记录",
     "paginationPerPage": "每页显示",
     "paginationFirst": "首页",
     "paginationPrev": "上一页",
@@ -1494,6 +1503,18 @@
     "role": "角色",
     "defaultRole": "默认",
     "roleHint": "选择一个角色，所有任务将使用该角色的配置（提示词和工具）执行。",
+    "agentMode": "代理模式",
+    "agentModeSingle": "单代理（ReAct）",
+    "agentModeMulti": "多代理（Eino）",
+    "agentModeHint": "建议默认单代理；复杂任务可使用多代理（需系统已启用多代理）。",
+    "scheduleMode": "调度方式",
+    "scheduleModeManual": "手工执行",
+    "scheduleModeCron": "调度表达式（Cron）",
+    "scheduleModeHint": "手工执行用于一次性任务；Cron 用于周期任务，建议先手工验证任务正确性。",
+    "cronExpr": "Cron 表达式",
+    "cronExprPlaceholder": "例如：0 */2 * * *（每2小时执行一次）",
+    "cronExprHint": "采用标准 5 段 Cron：分 时 日 月 周，例如 `0 2 * * *` 表示每天 02:00 执行。",
+    "cronExprRequired": "请选择 Cron 调度后填写 Cron 表达式",
     "tasksList": "任务列表（每行一个任务）",
     "tasksListPlaceholder": "请输入任务列表，每行一个任务",
     "tasksListPlaceholderExample": "请输入任务列表，每行一个任务，例如：\n扫描 192.168.1.1 的开放端口\n检查 https://example.com 是否存在SQL注入\n枚举 example.com 的子域名",
@@ -1514,13 +1535,22 @@
     "status": "状态",
     "createdAt": "创建时间",
     "startedAt": "开始时间",
+    "nextRunAt": "下次执行时间",
+    "scheduleCronAuto": "允许 Cron 自动调度",
+    "scheduleCronAutoHint": "关闭后仅保留表达式配置，不会按时间自动跑；可随时手工点「开始执行」。",
+    "lastScheduleTriggerAt": "最近调度触发时间",
+    "lastScheduleError": "最近调度失败原因",
+    "lastRunError": "最近运行失败摘要",
+    "cronSchedulePausedBadge": "调度已暂停",
+    "scheduleToggleFailed": "更新调度开关失败",
     "completedAt": "完成时间",
     "taskTotal": "任务总数",
     "taskList": "任务列表",
     "startLabel": "开始",
     "completeLabel": "完成",
     "errorLabel": "错误",
-    "resultLabel": "结果"
+    "resultLabel": "结果",
+    "technicalDetails": "技术信息（ID / 时间 / 调度）"
   },
   "editBatchTaskModal": {
     "title": "编辑任务",

web/static/js/settings.js

@@ -125,8 +125,6 @@ async function loadConfig(loadTools = true) {
         if (maMode) maMode.value = (ma.default_mode === 'multi') ? 'multi' : 'single';
         const maRobot = document.getElementById('multi-agent-robot-use');
         if (maRobot) maRobot.checked = ma.robot_use_multi_agent === true;
-        const maBatch = document.getElementById('multi-agent-batch-use');
-        if (maBatch) maBatch.checked = ma.batch_use_multi_agent === true;
         
         // 填充知识库配置
         const knowledgeEnabledCheckbox = document.getElementById('knowledge-enabled');
@@ -820,7 +818,7 @@ async function applySettings() {
                 enabled: document.getElementById('multi-agent-enabled')?.checked === true,
                 default_mode: document.getElementById('multi-agent-default-mode')?.value === 'multi' ? 'multi' : 'single',
                 robot_use_multi_agent: document.getElementById('multi-agent-robot-use')?.checked === true,
-                batch_use_multi_agent: document.getElementById('multi-agent-batch-use')?.checked === true
+                batch_use_multi_agent: false
             },
             knowledge: knowledgeConfig,
             robots: {

web/static/js/tasks.js

@@ -3,6 +3,60 @@ function _t(key, opts) {
     return typeof window.t === 'function' ? window.t(key, opts) : key;
 }
 
+/** 插值不转 HTML 实体（避免日期里的 / 变成 / 再被 escapeHtml 成乱码） */
+function _tPlain(key, opts) {
+    if (typeof window.t !== 'function') return key;
+    const base = opts && typeof opts === 'object' ? opts : {};
+    const interp = base.interpolation && typeof base.interpolation === 'object' ? base.interpolation : {};
+    return window.t(key, {
+        ...base,
+        interpolation: { escapeValue: false, ...interp }
+    });
+}
+
+/** Cron 队列在「本轮 completed」等状态下的展示文案（底层 status 不变，仅 UI 强调循环调度） */
+function getBatchQueueStatusPresentation(queue) {
+    const map = {
+        pending: { text: _t('tasks.statusPending'), class: 'batch-queue-status-pending' },
+        running: { text: _t('tasks.statusRunning'), class: 'batch-queue-status-running' },
+        paused: { text: _t('tasks.statusPaused'), class: 'batch-queue-status-paused' },
+        completed: { text: _t('tasks.statusCompleted'), class: 'batch-queue-status-completed' },
+        cancelled: { text: _t('tasks.statusCancelled'), class: 'batch-queue-status-cancelled' }
+    };
+    const base = map[queue.status] || { text: queue.status, class: 'batch-queue-status-unknown' };
+    const cronOn = queue.scheduleMode === 'cron' && queue.scheduleEnabled !== false;
+    const nextStr = queue.nextRunAt ? new Date(queue.nextRunAt).toLocaleString() : '';
+    const empty = { sublabel: null, progressNote: null, callout: null };
+
+    if (cronOn && queue.status === 'completed') {
+        return {
+            text: _t('tasks.statusCronCycleIdle'),
+            class: 'batch-queue-status-cron-cycle',
+            sublabel: nextStr ? _tPlain('tasks.cronNextRunLine', { time: nextStr }) : null,
+            progressNote: _t('tasks.cronRoundDoneProgressHint'),
+            callout: _t('tasks.cronRecurringCallout')
+        };
+    }
+    if (cronOn && queue.status === 'running') {
+        return {
+            text: _t('tasks.statusCronRunning'),
+            class: 'batch-queue-status-running batch-queue-cron-active',
+            sublabel: nextStr ? _tPlain('tasks.cronNextRunLine', { time: nextStr }) : null,
+            progressNote: _t('tasks.cronRunningProgressHint'),
+            callout: null
+        };
+    }
+    if (cronOn && queue.status === 'pending' && nextStr) {
+        return {
+            ...base,
+            ...empty,
+            sublabel: _tPlain('tasks.cronPendingScheduled', { time: nextStr }),
+            progressNote: _t('tasks.cronPendingProgressNote')
+        };
+    }
+    return { ...base, ...empty };
+}
+
 // HTML转义函数（如果未定义）
 if (typeof escapeHtml === 'undefined') {
     function escapeHtml(text) {
@@ -725,6 +779,9 @@ async function showBatchImportModal() {
     const input = document.getElementById('batch-tasks-input');
     const titleInput = document.getElementById('batch-queue-title');
     const roleSelect = document.getElementById('batch-queue-role');
+    const agentModeSelect = document.getElementById('batch-queue-agent-mode');
+    const scheduleModeSelect = document.getElementById('batch-queue-schedule-mode');
+    const cronExprInput = document.getElementById('batch-queue-cron-expr');
     if (modal && input) {
         input.value = '';
         if (titleInput) {
@@ -734,6 +791,16 @@ async function showBatchImportModal() {
         if (roleSelect) {
             roleSelect.value = '';
         }
+        if (agentModeSelect) {
+            agentModeSelect.value = 'single';
+        }
+        if (scheduleModeSelect) {
+            scheduleModeSelect.value = 'manual';
+        }
+        if (cronExprInput) {
+            cronExprInput.value = '';
+        }
+        handleBatchScheduleModeChange();
         updateBatchImportStats('');
         
         // 加载并填充角色列表
@@ -776,6 +843,24 @@ function closeBatchImportModal() {
     }
 }
 
+function handleBatchScheduleModeChange() {
+    const scheduleModeSelect = document.getElementById('batch-queue-schedule-mode');
+    const cronGroup = document.getElementById('batch-queue-cron-group');
+    const cronExprInput = document.getElementById('batch-queue-cron-expr');
+    const isCron = scheduleModeSelect && scheduleModeSelect.value === 'cron';
+    if (cronGroup) {
+        cronGroup.style.display = isCron ? 'block' : 'none';
+    }
+    if (cronExprInput) {
+        if (isCron) {
+            cronExprInput.setAttribute('required', 'required');
+        } else {
+            cronExprInput.removeAttribute('required');
+            cronExprInput.value = '';
+        }
+    }
+}
+
 // 更新新建任务统计
 function updateBatchImportStats(text) {
     const statsEl = document.getElementById('batch-import-stats');
@@ -807,6 +892,9 @@ async function createBatchQueue() {
     const input = document.getElementById('batch-tasks-input');
     const titleInput = document.getElementById('batch-queue-title');
     const roleSelect = document.getElementById('batch-queue-role');
+    const agentModeSelect = document.getElementById('batch-queue-agent-mode');
+    const scheduleModeSelect = document.getElementById('batch-queue-schedule-mode');
+    const cronExprInput = document.getElementById('batch-queue-cron-expr');
     if (!input) return;
     
     const text = input.value.trim();
@@ -827,6 +915,13 @@ async function createBatchQueue() {
     
     // 获取角色（可选，空字符串表示默认角色）
     const role = roleSelect ? roleSelect.value || '' : '';
+    const agentMode = agentModeSelect ? (agentModeSelect.value === 'multi' ? 'multi' : 'single') : 'single';
+    const scheduleMode = scheduleModeSelect ? (scheduleModeSelect.value === 'cron' ? 'cron' : 'manual') : 'manual';
+    const cronExpr = cronExprInput ? cronExprInput.value.trim() : '';
+    if (scheduleMode === 'cron' && !cronExpr) {
+        alert(_t('batchImportModal.cronExprRequired'));
+        return;
+    }
     
     try {
         const response = await apiFetch('/api/batch-tasks', {
@@ -834,7 +929,7 @@ async function createBatchQueue() {
             headers: {
                 'Content-Type': 'application/json',
             },
-            body: JSON.stringify({ title, tasks, role }),
+            body: JSON.stringify({ title, tasks, role, agentMode, scheduleMode, cronExpr }),
         });
         
         if (!response.ok) {
@@ -978,15 +1073,7 @@ function renderBatchQueues() {
     }
     
     list.innerHTML = queues.map(queue => {
-        const statusMap = {
-            'pending': { text: _t('tasks.statusPending'), class: 'batch-queue-status-pending' },
-            'running': { text: _t('tasks.statusRunning'), class: 'batch-queue-status-running' },
-            'paused': { text: _t('tasks.statusPaused'), class: 'batch-queue-status-paused' },
-            'completed': { text: _t('tasks.statusCompleted'), class: 'batch-queue-status-completed' },
-            'cancelled': { text: _t('tasks.statusCancelled'), class: 'batch-queue-status-cancelled' }
-        };
-        
-        const status = statusMap[queue.status] || { text: queue.status, class: 'batch-queue-status-unknown' };
+        const pres = getBatchQueueStatusPresentation(queue);
         
         // 统计任务状态
         const stats = {
@@ -1010,58 +1097,73 @@ function renderBatchQueues() {
         // 允许删除待执行、已完成或已取消状态的队列
         const canDelete = queue.status === 'pending' || queue.status === 'completed' || queue.status === 'cancelled';
         
-        const titleDisplay = queue.title ? `<span class="batch-queue-title" style="font-weight: 600; color: var(--text-primary); margin-right: 8px;">${escapeHtml(queue.title)}</span>` : '';
-        
-        // 显示角色信息（使用正确的角色图标）
         const loadedRoles = batchQueuesState.loadedRoles || [];
         const roleIcon = getRoleIconForDisplay(queue.role, loadedRoles);
         const roleName = queue.role && queue.role !== '' ? queue.role : _t('batchQueueDetailModal.defaultRole');
-        const roleDisplay = `<span class="batch-queue-role" style="margin-right: 8px;" title="${_t('batchQueueDetailModal.role')}: ${escapeHtml(roleName)}">${roleIcon} ${escapeHtml(roleName)}</span>`;
-        
+        const isCronCycleIdle = queue.scheduleMode === 'cron' && queue.scheduleEnabled !== false && queue.status === 'completed';
+        const cardMod = isCronCycleIdle ? ' batch-queue-item--cron-wait' : '';
+        const progressFillMod = isCronCycleIdle ? ' batch-queue-progress-fill--cron-wait' : '';
+
+        const agentLabel = queue.agentMode === 'multi' ? _t('batchImportModal.agentModeMulti') : _t('batchImportModal.agentModeSingle');
+        let scheduleLabel = queue.scheduleMode === 'cron' ? _t('batchImportModal.scheduleModeCron') : _t('batchImportModal.scheduleModeManual');
+        if (queue.scheduleMode === 'cron' && queue.cronExpr) {
+            scheduleLabel += ` (${queue.cronExpr})`;
+        }
+        const configLine = [roleName, agentLabel, scheduleLabel].map(s => escapeHtml(s)).join(' · ');
+        const cronPausedNote = queue.scheduleMode === 'cron' && queue.scheduleEnabled === false
+            ? ` <span class="batch-queue-inline-warn" title="${escapeHtml(_t('batchQueueDetailModal.scheduleCronAutoHint'))}">(${escapeHtml(_t('batchQueueDetailModal.cronSchedulePausedBadge'))})</span>`
+            : '';
+        const shortId = queue.id.length > 14 ? escapeHtml(queue.id.slice(0, 12)) + '\u2026' : escapeHtml(queue.id);
+        const titleBlock = queue.title
+            ? `<h4 class="batch-queue-card-title">${escapeHtml(queue.title)}</h4>`
+            : `<h4 class="batch-queue-card-title batch-queue-card-title--muted">${escapeHtml(_t('tasks.batchQueueUntitled'))}</h4>`;
+        const doneCount = stats.completed + stats.failed + stats.cancelled;
+        const statsCompact = `<span class="batch-queue-statsline__item">${escapeHtml(_t('tasks.totalLabel'))}\u00a0${stats.total}</span><span class="batch-queue-statsline__sep">\u00b7</span><span class="batch-queue-statsline__item">${escapeHtml(_t('tasks.pendingLabel'))}\u00a0${stats.pending}</span><span class="batch-queue-statsline__sep">\u00b7</span><span class="batch-queue-statsline__item">${escapeHtml(_t('tasks.runningLabel'))}\u00a0${stats.running}</span><span class="batch-queue-statsline__sep">\u00b7</span><span class="batch-queue-statsline__item batch-queue-statsline__item--ok">${escapeHtml(_t('tasks.completedLabel'))}\u00a0${stats.completed}</span><span class="batch-queue-statsline__sep">\u00b7</span><span class="batch-queue-statsline__item batch-queue-statsline__item--err">${escapeHtml(_t('tasks.failedLabel'))}\u00a0${stats.failed}</span>${stats.cancelled > 0 ? `<span class="batch-queue-statsline__sep">\u00b7</span><span class="batch-queue-statsline__item">${escapeHtml(_t('tasks.cancelledLabel'))}\u00a0${stats.cancelled}</span>` : ''}`;
+
         return `
-            <div class="batch-queue-item" data-queue-id="${queue.id}" onclick="showBatchQueueDetail('${queue.id}')">
-                <div class="batch-queue-header">
-                    <div class="batch-queue-info" style="flex: 1;">
-                        ${titleDisplay}
-                        ${roleDisplay}
-                        <span class="batch-queue-status ${status.class}">${status.text}</span>
-                        <span class="batch-queue-id">${_t('tasks.queueIdLabel')}: ${escapeHtml(queue.id)}</span>
-                        <span class="batch-queue-time">${_t('tasks.createdTimeLabel')}: ${new Date(queue.createdAt).toLocaleString()}</span>
-                    </div>
-                    <div class="batch-queue-progress">
-                        <div class="batch-queue-progress-bar">
-                            <div class="batch-queue-progress-fill" style="width: ${progress}%"></div>
+            <div class="batch-queue-item batch-queue-item--compact${cardMod}" data-queue-id="${queue.id}" onclick="showBatchQueueDetail('${queue.id}')">
+                <div class="batch-queue-item__inner">
+                    <div class="batch-queue-item__top">
+                        <div class="batch-queue-item__title-col">
+                            ${titleBlock}
+                            <p class="batch-queue-item__config">${configLine}${cronPausedNote}</p>
+                            <p class="batch-queue-item__idline"><code title="${escapeHtml(queue.id)}">${shortId}</code><span class="batch-queue-item__idsep">\u00b7</span><span>${escapeHtml(_t('tasks.createdTimeLabel'))}\u00a0${escapeHtml(new Date(queue.createdAt).toLocaleString())}</span></p>
+                        </div>
+                        <div class="batch-queue-item__top-actions" onclick="event.stopPropagation();">
+                            ${canDelete ? `<button type="button" class="batch-queue-icon-btn" onclick="deleteBatchQueueFromList('${queue.id}')" title="${escapeHtml(_t('tasks.deleteQueue'))}" aria-label="${escapeHtml(_t('tasks.deleteQueue'))}"><svg class="batch-queue-icon-btn__svg" width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M3 6h18"/><path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6"/><path d="M8 6V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"/><path d="M10 11v6"/><path d="M14 11v6"/></svg></button>` : ''}
                         </div>
-                        <span class="batch-queue-progress-text">${progress}% (${stats.completed + stats.failed + stats.cancelled}/${stats.total})</span>
                     </div>
-                    <div class="batch-queue-actions" style="display: flex; align-items: center; gap: 8px; margin-left: 12px;" onclick="event.stopPropagation();">
-                        ${canDelete ? `<button class="btn-secondary btn-small btn-danger" onclick="deleteBatchQueueFromList('${queue.id}')" title="${_t('tasks.deleteQueue')}">${_t('common.delete')}</button>` : ''}
+                    <div class="batch-queue-item__mid">
+                        <div class="batch-queue-item__mid-left">
+                            <span class="batch-queue-status ${pres.class}">${escapeHtml(pres.text)}</span>
+                            ${pres.sublabel ? `<span class="batch-queue-item__sublabel">${escapeHtml(pres.sublabel)}</span>` : ''}
+                        </div>
+                        <div class="batch-queue-item__mid-right">
+                            <div class="batch-queue-progress-bar batch-queue-progress-bar--card batch-queue-progress-bar--list">
+                                <div class="batch-queue-progress-fill${progressFillMod}" style="width: ${progress}%"></div>
+                            </div>
+                            <span class="batch-queue-item__pct">${progress}%\u00a0<span class="batch-queue-item__pct-frac">(${doneCount}/${stats.total})</span></span>
+                        </div>
                     </div>
-                </div>
-                <div class="batch-queue-stats">
-                    <span>${_t('tasks.totalLabel')}: ${stats.total}</span>
-                    <span>${_t('tasks.pendingLabel')}: ${stats.pending}</span>
-                    <span>${_t('tasks.runningLabel')}: ${stats.running}</span>
-                    <span style="color: var(--success-color);">${_t('tasks.completedLabel')}: ${stats.completed}</span>
-                    <span style="color: var(--error-color);">${_t('tasks.failedLabel')}: ${stats.failed}</span>
-                    ${stats.cancelled > 0 ? `<span style="color: var(--text-secondary);">${_t('tasks.cancelledLabel')}: ${stats.cancelled}</span>` : ''}
+                    <div class="batch-queue-statsline" aria-label="${escapeHtml(_t('tasks.batchQueueTitle'))}">${statsCompact}</div>
                 </div>
             </div>
         `;
+
     }).join('');
     
     // 渲染分页控件
     renderBatchQueuesPagination();
 }
 
-// 渲染批量任务队列分页控件（参考Skills管理页面样式）
+// 渲染批量任务队列分页控件（结构与样式对齐 MCP 监控 .monitor-pagination）
 function renderBatchQueuesPagination() {
     const paginationContainer = document.getElementById('batch-queues-pagination');
     if (!paginationContainer) return;
     
     const { currentPage, pageSize, total, totalPages } = batchQueuesState;
     
-    // 即使只有一页也显示分页信息（参考Skills样式）
+    // 即使只有一页也显示分页信息（与 MCP 监控一致）
     if (total === 0) {
         paginationContainer.innerHTML = '';
         return;
@@ -1071,7 +1173,7 @@ function renderBatchQueuesPagination() {
     const start = total === 0 ? 0 : (currentPage - 1) * pageSize + 1;
     const end = total === 0 ? 0 : Math.min(currentPage * pageSize, total);
     
-    let paginationHTML = '<div class="pagination">';
+    let paginationHTML = '<div class="monitor-pagination">';
     
     // 左侧：显示范围信息和每页数量选择器（参考Skills样式）
     paginationHTML += `
@@ -1103,41 +1205,6 @@ function renderBatchQueuesPagination() {
     paginationHTML += '</div>';
     
     paginationContainer.innerHTML = paginationHTML;
-    
-    // 确保分页组件与列表内容区域对齐（不包括滚动条）
-    function alignPaginationWidth() {
-        const batchQueuesList = document.getElementById('batch-queues-list');
-        if (batchQueuesList && paginationContainer) {
-            // 获取列表的实际内容宽度（不包括滚动条）
-            const listClientWidth = batchQueuesList.clientWidth; // 可视区域宽度（不包括滚动条）
-            const listScrollHeight = batchQueuesList.scrollHeight; // 内容总高度
-            const listClientHeight = batchQueuesList.clientHeight; // 可视区域高度
-            const hasScrollbar = listScrollHeight > listClientHeight;
-            
-            // 如果列表有垂直滚动条，分页组件应该与列表内容区域对齐（clientWidth）
-            // 如果没有滚动条，使用100%宽度
-            if (hasScrollbar) {
-                // 分页组件应该与列表内容区域对齐，不包括滚动条
-                paginationContainer.style.width = `${listClientWidth}px`;
-            } else {
-                // 如果没有滚动条，使用100%宽度
-                paginationContainer.style.width = '100%';
-            }
-        }
-    }
-    
-    // 立即执行一次
-    alignPaginationWidth();
-    
-    // 监听窗口大小变化和列表内容变化
-    const resizeObserver = new ResizeObserver(() => {
-        alignPaginationWidth();
-    });
-    
-    const batchQueuesList = document.getElementById('batch-queues-list');
-    if (batchQueuesList) {
-        resizeObserver.observe(batchQueuesList);
-    }
 }
 
 // 跳转到指定页面
@@ -1198,7 +1265,8 @@ async function showBatchQueueDetail(queueId) {
         const result = await response.json();
         const queue = result.queue;
         batchQueuesState.currentQueueId = queueId;
-        
+        const pres = getBatchQueueStatusPresentation(queue);
+
         if (title) {
             // textContent 本身会做转义；这里不要再 escapeHtml，否则会把 && 显示成 &amp;...（看起来像“变形/乱码”）
             title.textContent = queue.title ? _t('tasks.batchQueueTitle') + ' - ' + String(queue.title) : _t('tasks.batchQueueTitle');
@@ -1227,15 +1295,6 @@ async function showBatchQueueDetail(queueId) {
             deleteBtn.style.display = (queue.status === 'pending' || queue.status === 'completed' || queue.status === 'cancelled' || queue.status === 'paused') ? 'inline-block' : 'none';
         }
         
-        // 队列状态映射
-        const queueStatusMap = {
-            'pending': { text: _t('tasks.statusPending'), class: 'batch-queue-status-pending' },
-            'running': { text: _t('tasks.statusRunning'), class: 'batch-queue-status-running' },
-            'paused': { text: _t('tasks.statusPaused'), class: 'batch-queue-status-paused' },
-            'completed': { text: _t('tasks.statusCompleted'), class: 'batch-queue-status-completed' },
-            'cancelled': { text: _t('tasks.statusCancelled'), class: 'batch-queue-status-cancelled' }
-        };
-        
         // 任务状态映射
         const taskStatusMap = {
             'pending': { text: _t('tasks.statusPending'), class: 'batch-task-status-pending' },
@@ -1245,13 +1304,10 @@ async function showBatchQueueDetail(queueId) {
             'cancelled': { text: _t('tasks.statusCancelled'), class: 'batch-task-status-cancelled' }
         };
         
-        // 获取角色信息（如果队列有角色配置）
-        let roleDisplay = '';
+        let roleLineVal = '';
         if (queue.role && queue.role !== '') {
-            // 如果有角色配置，尝试获取角色详细信息
             let roleName = queue.role;
-            let roleIcon = '👤';
-            // 从已加载的角色列表中查找角色图标
+            let roleIcon = '\uD83D\uDC64';
             if (Array.isArray(loadedRoles) && loadedRoles.length > 0) {
                 const role = loadedRoles.find(r => r.name === roleName);
                 if (role && role.icon) {
@@ -1262,23 +1318,21 @@ async function showBatchQueueDetail(queueId) {
                             const codePoint = parseInt(unicodeMatch[1], 16);
                             icon = String.fromCodePoint(codePoint);
                         } catch (e) {
-                            // 转换失败，使用默认图标
+                            // ignore
                         }
                     }
                     roleIcon = icon;
                 }
             }
-            roleDisplay = `<div class="detail-item">
-                <span class="detail-label">` + _t('batchQueueDetailModal.role') + `</span>
-                <span class="detail-value">${roleIcon} ${escapeHtml(roleName)}</span>
-            </div>`;
+            roleLineVal = roleIcon + ' ' + escapeHtml(roleName);
         } else {
-            // 默认角色
-            roleDisplay = `<div class="detail-item">
-                <span class="detail-label">` + _t('batchQueueDetailModal.role') + `</span>
-                <span class="detail-value">🔵 ` + _t('batchQueueDetailModal.defaultRole') + `</span>
-            </div>`;
+            roleLineVal = '\uD83D\uDD35 ' + escapeHtml(_t('batchQueueDetailModal.defaultRole'));
         }
+        const agentModeText = queue.agentMode === 'multi' ? _t('batchImportModal.agentModeMulti') : _t('batchImportModal.agentModeSingle');
+        const scheduleModeText = queue.scheduleMode === 'cron' ? _t('batchImportModal.scheduleModeCron') : _t('batchImportModal.scheduleModeManual');
+        const scheduleDetail = escapeHtml(scheduleModeText) + (queue.scheduleMode === 'cron' && queue.cronExpr ? `（${escapeHtml(queue.cronExpr)}）` : '');
+        const showProgressNoteInModal = !!(pres.progressNote && !pres.callout);
+
         
         // 保存滚动位置，防止刷新时滚动条弹回顶部
         const modalBody = content.closest('.modal-body');
@@ -1287,36 +1341,34 @@ async function showBatchQueueDetail(queueId) {
         const savedTasksListScrollTop = tasksList ? tasksList.scrollTop : 0;
 
         content.innerHTML = `
-            <div class="batch-queue-detail-info">
-                ${queue.title ? `<div class="detail-item">
-                    <span class="detail-label">` + _t('batchQueueDetailModal.queueTitle') + `</span>
-                    <span class="detail-value">${escapeHtml(queue.title)}</span>
-                </div>` : ''}
-                ${roleDisplay}
-                <div class="detail-item">
-                    <span class="detail-label">` + _t('batchQueueDetailModal.queueId') + `</span>
-                    <span class="detail-value"><code>${escapeHtml(queue.id)}</code></span>
-                </div>
-                <div class="detail-item">
-                    <span class="detail-label">` + _t('batchQueueDetailModal.status') + `</span>
-                    <span class="detail-value"><span class="batch-queue-status ${queueStatusMap[queue.status]?.class || ''}">${queueStatusMap[queue.status]?.text || queue.status}</span></span>
-                </div>
-                <div class="detail-item">
-                    <span class="detail-label">` + _t('batchQueueDetailModal.createdAt') + `</span>
-                    <span class="detail-value">${new Date(queue.createdAt).toLocaleString()}</span>
-                </div>
-                ${queue.startedAt ? `<div class="detail-item">
-                    <span class="detail-label">` + _t('batchQueueDetailModal.startedAt') + `</span>
-                    <span class="detail-value">${new Date(queue.startedAt).toLocaleString()}</span>
-                </div>` : ''}
-                ${queue.completedAt ? `<div class="detail-item">
-                    <span class="detail-label">` + _t('batchQueueDetailModal.completedAt') + `</span>
-                    <span class="detail-value">${new Date(queue.completedAt).toLocaleString()}</span>
-                </div>` : ''}
-                <div class="detail-item">
-                    <span class="detail-label">` + _t('batchQueueDetailModal.taskTotal') + `</span>
-                    <span class="detail-value">${queue.tasks.length}</span>
+            <div class="batch-queue-detail-layout">
+            <section class="batch-queue-detail-hero">
+                <span class="batch-queue-status ${pres.class}">${escapeHtml(pres.text)}</span>
+                ${pres.sublabel ? `<p class="batch-queue-detail-hero__sub">${escapeHtml(pres.sublabel)}</p>` : ''}
+                ${showProgressNoteInModal ? `<p class="batch-queue-detail-hero__note">${escapeHtml(pres.progressNote)}</p>` : ''}
+            </section>
+            <section class="batch-queue-detail-kv">
+                ${queue.title ? `<div class="bq-kv"><span class="bq-kv__k">${escapeHtml(_t('batchQueueDetailModal.queueTitle'))}</span><span class="bq-kv__v">${escapeHtml(queue.title)}</span></div>` : ''}
+                <div class="bq-kv"><span class="bq-kv__k">${escapeHtml(_t('batchQueueDetailModal.role'))}</span><span class="bq-kv__v">${roleLineVal}</span></div>
+                <div class="bq-kv"><span class="bq-kv__k">${escapeHtml(_t('batchImportModal.agentMode'))}</span><span class="bq-kv__v">${escapeHtml(agentModeText)}</span></div>
+                <div class="bq-kv"><span class="bq-kv__k">${escapeHtml(_t('batchImportModal.scheduleMode'))}</span><span class="bq-kv__v">${scheduleDetail}</span></div>
+                <div class="bq-kv"><span class="bq-kv__k">${escapeHtml(_t('batchQueueDetailModal.taskTotal'))}</span><span class="bq-kv__v">${queue.tasks.length}</span></div>
+                ${queue.scheduleMode === 'cron' ? `<div class="bq-kv bq-kv--block"><span class="bq-kv__k">${escapeHtml(_t('batchQueueDetailModal.scheduleCronAuto'))}</span><span class="bq-kv__v bq-kv__v--control"><label class="bq-cron-toggle"><input type="checkbox" ${queue.scheduleEnabled !== false ? 'checked' : ''} onchange="updateBatchQueueScheduleEnabled(this.checked)" /><span class="bq-cron-toggle__hint">${escapeHtml(_t('batchQueueDetailModal.scheduleCronAutoHint'))}</span></label></span></div>` : ''}
+            </section>
+            ${queue.lastScheduleError ? `<div class="bq-alert bq-alert--err"><strong>${escapeHtml(_t('batchQueueDetailModal.lastScheduleError'))}</strong><p>${escapeHtml(queue.lastScheduleError)}</p></div>` : ''}
+            ${queue.lastRunError ? `<div class="bq-alert bq-alert--err"><strong>${escapeHtml(_t('batchQueueDetailModal.lastRunError'))}</strong><p>${escapeHtml(queue.lastRunError)}</p></div>` : ''}
+            ${pres.callout ? `<div class="batch-queue-cron-callout batch-queue-cron-callout--compact"><span class="batch-queue-cron-callout-icon" aria-hidden="true">\u21BB</span><p>${escapeHtml(pres.callout)}</p></div>` : ''}
+            <details class="batch-queue-detail-tech">
+                <summary class="batch-queue-detail-tech__sum">${escapeHtml(_t('batchQueueDetailModal.technicalDetails'))}</summary>
+                <div class="batch-queue-detail-tech__body">
+                    <div class="bq-kv"><span class="bq-kv__k">${escapeHtml(_t('batchQueueDetailModal.queueId'))}</span><span class="bq-kv__v"><code>${escapeHtml(queue.id)}</code></span></div>
+                    <div class="bq-kv"><span class="bq-kv__k">${escapeHtml(_t('batchQueueDetailModal.createdAt'))}</span><span class="bq-kv__v">${escapeHtml(new Date(queue.createdAt).toLocaleString())}</span></div>
+                    ${queue.startedAt ? `<div class="bq-kv"><span class="bq-kv__k">${escapeHtml(_t('batchQueueDetailModal.startedAt'))}</span><span class="bq-kv__v">${escapeHtml(new Date(queue.startedAt).toLocaleString())}</span></div>` : ''}
+                    ${queue.completedAt ? `<div class="bq-kv"><span class="bq-kv__k">${escapeHtml(_t('batchQueueDetailModal.completedAt'))}</span><span class="bq-kv__v">${escapeHtml(new Date(queue.completedAt).toLocaleString())}</span></div>` : ''}
+                    ${queue.scheduleMode === 'cron' && queue.nextRunAt && !pres.sublabel ? `<div class="bq-kv"><span class="bq-kv__k">${escapeHtml(_t('batchQueueDetailModal.nextRunAt'))}</span><span class="bq-kv__v">${escapeHtml(new Date(queue.nextRunAt).toLocaleString())}</span></div>` : ''}
+                    ${queue.lastScheduleTriggerAt ? `<div class="bq-kv"><span class="bq-kv__k">${escapeHtml(_t('batchQueueDetailModal.lastScheduleTriggerAt'))}</span><span class="bq-kv__v">${escapeHtml(new Date(queue.lastScheduleTriggerAt).toLocaleString())}</span></div>` : ''}
                 </div>
+            </details>
             </div>
             <div class="batch-queue-tasks-list">
                 <h4>` + _t('batchQueueDetailModal.taskList') + `</h4>
@@ -1834,6 +1886,28 @@ async function deleteBatchTask(queueId, taskId) {
     }
 }
 
+async function updateBatchQueueScheduleEnabled(enabled) {
+    const queueId = batchQueuesState.currentQueueId;
+    if (!queueId) return;
+    try {
+        const response = await apiFetch(`/api/batch-tasks/${queueId}/schedule-enabled`, {
+            method: 'PUT',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ scheduleEnabled: enabled }),
+        });
+        if (!response.ok) {
+            const result = await response.json().catch(() => ({}));
+            throw new Error(result.error || _t('batchQueueDetailModal.scheduleToggleFailed'));
+        }
+        showBatchQueueDetail(queueId);
+        refreshBatchQueues();
+    } catch (e) {
+        console.error(e);
+        alert(_t('batchQueueDetailModal.scheduleToggleFailed') + ': ' + e.message);
+        showBatchQueueDetail(queueId);
+    }
+}
+
 // 导出函数
 window.showBatchImportModal = showBatchImportModal;
 window.closeBatchImportModal = closeBatchImportModal;
@@ -1857,3 +1931,28 @@ window.closeAddBatchTaskModal = closeAddBatchTaskModal;
 window.saveAddBatchTask = saveAddBatchTask;
 window.deleteBatchTaskFromElement = deleteBatchTaskFromElement;
 window.deleteBatchQueueFromList = deleteBatchQueueFromList;
+window.handleBatchScheduleModeChange = handleBatchScheduleModeChange;
+window.updateBatchQueueScheduleEnabled = updateBatchQueueScheduleEnabled;
+
+// 语言切换后，列表/分页/详情弹窗由 JS 渲染的文案需用当前语言重绘（applyTranslations 不会处理 innerHTML 内容）
+document.addEventListener('languagechange', function () {
+    try {
+        const tasksPage = document.getElementById('page-tasks');
+        if (!tasksPage || !tasksPage.classList.contains('active')) {
+            return;
+        }
+        if (document.getElementById('batch-queues-list')) {
+            renderBatchQueues();
+        }
+        const detailModal = document.getElementById('batch-queue-detail-modal');
+        if (
+            detailModal &&
+            detailModal.style.display === 'block' &&
+            batchQueuesState.currentQueueId
+        ) {
+            showBatchQueueDetail(batchQueuesState.currentQueueId);
+        }
+    } catch (e) {
+        console.warn('languagechange tasks refresh failed', e);
+    }
+});

web/templates/index.html

@@ -1150,9 +1150,10 @@
                                            oninput="filterBatchQueues()">
                                 </label>
                             </div>
-                            <div id="batch-queues-list" class="batch-queues-list"></div>
-                            <!-- 分页控件 -->
-                            <div id="batch-queues-pagination" class="pagination-container pagination-fixed"></div>
+                            <div class="batch-queues-board">
+                                <div id="batch-queues-list" class="batch-queues-list"></div>
+                                <div id="batch-queues-pagination" class="pagination-container"></div>
+                            </div>
                         </div>
                     </div>
                 </div>
@@ -1430,14 +1431,6 @@
                                             </label>
                                             <small class="form-hint" data-i18n="settingsBasic.multiAgentRobotUseHint">需同时勾选「启用多代理」；调用量与成本更高。</small>
                                         </div>
-                                        <div class="form-group">
-                                            <label class="checkbox-label">
-                                                <input type="checkbox" id="multi-agent-batch-use" class="modern-checkbox" />
-                                                <span class="checkbox-custom"></span>
-                                                <span class="checkbox-text" data-i18n="settingsBasic.multiAgentBatchUse">批量任务队列也使用多代理</span>
-                                            </label>
-                                            <small class="form-hint" data-i18n="settingsBasic.multiAgentBatchUseHint">开启后，任务管理中按队列执行的每个子任务将走 Eino DeepAgent（需启用多代理）。</small>
-                                        </div>
                                     </div>
                                 </div>
 
@@ -2322,6 +2315,27 @@ version: 1.0.0<br>
                     </select>
                     <div class="form-hint" style="margin-top: 4px;" data-i18n="batchImportModal.roleHint">选择一个角色，所有任务将使用该角色的配置（提示词和工具）执行。</div>
                 </div>
+                <div class="form-group">
+                    <label for="batch-queue-agent-mode" data-i18n="batchImportModal.agentMode">代理模式</label>
+                    <select id="batch-queue-agent-mode" style="width: 100%; padding: 8px; border: 1px solid #ddd; border-radius: 4px; font-size: 0.875rem;">
+                        <option value="single" data-i18n="batchImportModal.agentModeSingle">单代理（ReAct）</option>
+                        <option value="multi" data-i18n="batchImportModal.agentModeMulti">多代理（Eino）</option>
+                    </select>
+                    <div class="form-hint" style="margin-top: 4px;" data-i18n="batchImportModal.agentModeHint">建议默认单代理；复杂任务可使用多代理（需系统已启用多代理）。</div>
+                </div>
+                <div class="form-group">
+                    <label for="batch-queue-schedule-mode" data-i18n="batchImportModal.scheduleMode">调度方式</label>
+                    <select id="batch-queue-schedule-mode" onchange="handleBatchScheduleModeChange()" style="width: 100%; padding: 8px; border: 1px solid #ddd; border-radius: 4px; font-size: 0.875rem;">
+                        <option value="manual" data-i18n="batchImportModal.scheduleModeManual">手工执行</option>
+                        <option value="cron" data-i18n="batchImportModal.scheduleModeCron">调度表达式（Cron）</option>
+                    </select>
+                    <div class="form-hint" style="margin-top: 4px;" data-i18n="batchImportModal.scheduleModeHint">手工执行用于一次性任务；Cron 用于周期任务，建议先手工验证任务正确性。</div>
+                </div>
+                <div class="form-group" id="batch-queue-cron-group" style="display: none;">
+                    <label for="batch-queue-cron-expr"><span data-i18n="batchImportModal.cronExpr">Cron 表达式</span><span style="color: red;">*</span></label>
+                    <input type="text" id="batch-queue-cron-expr" data-i18n="batchImportModal.cronExprPlaceholder" data-i18n-attr="placeholder" placeholder="例如：0 */2 * * *（每2小时执行一次）" />
+                    <div class="form-hint" style="margin-top: 4px;" data-i18n="batchImportModal.cronExprHint">采用标准 5 段 Cron：分 时 日 月 周，例如 `0 2 * * *` 表示每天 02:00 执行。</div>
+                </div>
                 <div class="form-group">
                     <label for="batch-tasks-input"><span data-i18n="batchImportModal.tasksList">任务列表（每行一个任务）</span><span style="color: red;">*</span></label>
                     <textarea id="batch-tasks-input" rows="15" data-i18n="batchImportModal.tasksListPlaceholderExample" data-i18n-attr="placeholder" 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>