diff --git a/README.md b/README.md
index cd6ed60..821e1ef 100644
--- a/README.md
+++ b/README.md
@@ -66,14 +66,18 @@ eh-downloader-wails/
 ├── internal/
 │   ├── eh/                  ★ 协议核心（可独立测试，无 UI 依赖）
 │   │   ├── eh.go            ①画廊页分页 → ②/s/ → ③hath直链 → 下载
+│   │   ├── limiter.go       全局限流器
 │   │   ├── eh_test.go       单元测试
+│   │   ├── limiter_test.go  限流测试（含并发穿透）
 │   │   └── e2e_test.go      端到端链路测试（httptest 模拟 EH）
 │   └── core/
-│       ├── engine.go        任务编排、并发池、退避重试、断点续传
+│       ├── engine.go        任务编排、双层并发、退避重试、整轮扫尾
 │       ├── store.go         JSON 原子写 + 任务状态机
 │       ├── paths.go         目录模板引擎 + 路径安全清洗
+│       ├── manifest.go      画廊目录清单（.ehdl.json）
 │       ├── bridge.go        本地 HTTP 桥口（供油猴推送）
-│       └── *_test.go        单测
+│       ├── *_test.go        单测
+│       └── concurrency_test.go  并发/限流/扫尾集成测试
 ├── frontend/
 │   ├── index.html           界面（沿用原版）
 │   ├── js/api.js            ★ IPC 适配层：window.eh.* → Wails bindings
@@ -189,12 +193,79 @@ https://oclzqqk.gyktyewfonyf.hath.network:39656/h/4e9af9f.../keystamp=1791448200
 | 下载目录 | `~/Downloads/EH` | 每个画廊一个子目录 |
 | 代理模式 | 自动探测 | off / http / socks5 |
 | 代理地址 | 自动探测 | 常见端口 7890/7897/1087/1080/8080/10808/10809/8888 |
-| 并发数 | 3 | 建议 2~4 |
+| **画廊并发** | **5** | 同时处理几个画廊（1–20） |
+| **单画廊页并发** | **8** | 每个画廊内同时下几张图（1–20） |
+| **请求间隔** | **0 秒** | 全局最小请求间隔，0 = 不限流 |
 | 超时 | 30s | |
 | 下载分辨率 | 站点默认 | `auto` / `org` / 数字 |
 | 目录模板 | `{title}` | |
 | 油猴推送端口 | 37777 | |
 
+### 并发怎么算
+
+**总并发 = 画廊并发 × 页并发**，默认 `5 × 8 = 40` 张图同时下载。
+
+```
+画廊并发 5
+├── 画廊A：8 张图同时下
+├── 画廊B：8 张图同时下
+├── 画廊C：8 张图同时下
+├── 画廊D：8 张图同时下
+└── 画廊E：8 张图同时下
+= 最多 40 张同时下载
+```
+
+如果队列里只有 1 个画廊，就只有 1 份并发在跑（8 张），其余 4 个 worker 空转。
+
+### 全局限流
+
+对齐参考实现（E-Hentai Downloader 的「请求间隔」）：用一个全局 `nextRequestTime`，
+每个请求排到它之后，再把它往后推 `interval` 毫秒。
+
+**限的是所有请求**，包括 `/s/` 解析和图片下载 —— 每页要发 2 个请求，所以
+40 并发在开启限流时也会被串成每 `interval` 放行一个。
+
+高并发下频繁遇到 429 时，1~2 秒的间隔很有效。
+
+### 失败重试与整轮扫尾
+
+单页失败时的退避重试：
+
+```
+第1次失败 → 等 0.8s + 随机 0~0.4s
+第2次失败 → 等 1.6s + 随机
+第3次失败 → 等 3.2s + 随机
+第4次失败 → 放弃，记入失败清单
+```
+
+只有「像是临时问题」才重试（连接重置、超时、429/502/503/504、socket hang up）。
+401/403/404、画廊不存在、页面结构变化这类**重试也没用**的直接判死。
+
+**整轮扫尾**：所有画廊跑完后，自动把所有失败页**重新扫 1 轮**（同样走完整 4 次重试）。
+扫尾后仍失败就标记「部分失败」并停下 —— 这时你可以换个代理线路，再点一次
+「开始下载」，已下的文件会自动跳过，只补缺的那些。
+
+### 画廊目录清单（.ehdl.json）
+
+每个画廊目录下会写一份 `.ehdl.json`：
+
+```json
+{
+  "version": 1,
+  "gid": "4239274",
+  "token": "55e069b6b9",
+  "title": "[Noxe] 0820 Qingxiao",
+  "totalPages": 206,
+  "donePages": [1, 2, 3, 5],
+  "failedPages": [4],
+  "updatedAt": 1791475732842
+}
+```
+
+作用：断点续传的依据是「文件在且非空」，但那有个盲区 —— 如果 `state.json`
+丢了，程序就不知道这个画廊**原本应该有多少张**。清单补上了这个认知，
+扫目录就能算出「应该 206 张，现在只有 4 张」。
+
 状态文件：
 - Windows：`%APPDATA%\EH Downloader\state.json`
 - macOS：`~/Library/Application Support/EH Downloader/state.json`
@@ -231,7 +302,7 @@ go test ./internal/eh/ -v   # 协议层（含端到端）
 go test -race ./...         # 竞态检测
 ```
 
-37 个用例覆盖：
+62 个用例覆盖：
 - 输入解析（多行/分隔符/去重/注释）
 - hath 直链正则（含不该匹配的负例）
 - xres 改写（auto/org/数字）
@@ -241,6 +312,10 @@ go test -race ./...         # 竞态检测
 - 目录模板展开 + 路径穿越防护 + Windows 保留名
 - 断点续传、取消清理 .part
 - 状态机（清除已完成/失败重排/崩溃归位/文件损坏回落）
+- **双层并发**（mock 服务器实测并发峰值 = 8 页 / 5 画廊）
+- **全局限流**（并发穿透验证 + 精确计时）
+- **整轮扫尾**（首轮 4 次重试全挂 → 扫尾救回 / 永久失败 → partial）
+- **画廊清单**（读写往返、目录扫描、state.json 丢失后的恢复）
 
 ## 免责声明
 
diff --git a/app.go b/app.go
index c315af6..9abe260 100644
--- a/app.go
+++ b/app.go
@@ -191,8 +191,14 @@ func (a *App) SetSettings(patch map[string]interface{}) core.Settings {
 	next := a.store.UpdateSettings(patch)
 
 	// 同步到引擎
-	if _, ok := patch["concurrency"]; ok {
-		a.engine.SetConcurrency(next.Concurrency)
+	if _, ok := patch["galleryConcurrency"]; ok {
+		a.engine.SetGalleryConcurrency(next.GalleryConcurrency)
+	}
+	if _, ok := patch["pageConcurrency"]; ok {
+		a.engine.SetPageConcurrency(next.PageConcurrency)
+	}
+	if _, ok := patch["requestIntervalMs"]; ok {
+		a.engine.SetRequestInterval(next.RequestIntervalMs)
 	}
 	if _, ok := patch["timeout"]; ok {
 		a.engine.Client().SetTimeout(time.Duration(next.Timeout) * time.Millisecond)
@@ -241,6 +247,69 @@ func (a *App) Placeholders() []string {
 	return core.ListPlaceholders()
 }
 
+// EngineInfo 引擎当前的并发配置（前端用来显示"总上限 = 画廊 × 页"）
+type EngineInfo struct {
+	Running           bool `json:"running"`
+	Queued            int  `json:"queued"`
+	GalleryConcurrency int `json:"galleryConcurrency"`
+	PageConcurrency   int  `json:"pageConcurrency"`
+	MaxConcurrent     int  `json:"maxConcurrent"`
+	RequestIntervalMs int  `json:"requestIntervalMs"`
+}
+
+// EngineInfo 取引擎状态和并发配置
+func (a *App) EngineInfo() EngineInfo {
+	g := a.engine.GalleryConcurrency()
+	p := a.engine.PageConcurrency()
+	return EngineInfo{
+		Running:            a.engine.IsRunning(),
+		Queued:             a.engine.QueueLength(),
+		GalleryConcurrency: g,
+		PageConcurrency:    p,
+		MaxConcurrent:      g * p,
+		RequestIntervalMs:  int(a.engine.Client().RequestInterval().Milliseconds()),
+	}
+}
+
+// ScanManifestsResult 扫描下载目录的结果
+type ScanManifestsResult struct {
+	Found    int   `json:"found"`
+	Adopted  int   `json:"adopted"`
+	Root     string `json:"root"`
+	Note     string `json:"note"`
+}
+
+// ScanDownloadDir 扫描下载目录里的画廊清单，把 state.json 里缺的信息补上。
+// 场景：用户删了 state.json，靠清单重建"这个画廊应该有多少张"的认知。
+func (a *App) ScanDownloadDir() ScanManifestsResult {
+	root := a.store.Settings().DownloadRoot
+	if root == "" {
+		root = core.DefaultDownloadRoot()
+	}
+
+	manifests := core.ScanManifests(root)
+	res := ScanManifestsResult{Root: root, Found: len(manifests)}
+	if len(manifests) == 0 {
+		res.Note = "下载目录里没找到画廊清单（.ehdl.json）"
+		return res
+	}
+
+	for _, m := range manifests {
+		// 找到对应任务（按 gid 匹配，token 可能有差异所以只按 gid）
+		t := a.store.FindTaskByGID(m.GID)
+		if t == nil {
+			continue
+		}
+		if core.ReconcileTask(t, m) {
+			a.store.UpsertTask(*t)
+			res.Adopted++
+		}
+	}
+
+	res.Note = fmt.Sprintf("扫描到 %d 个画廊清单，补全了 %d 个任务", res.Found, res.Adopted)
+	return res
+}
+
 // ---------------------------------------------------------------- 任务
 
 // ListTasks 全部任务
@@ -368,7 +437,16 @@ func (a *App) Start(onlyGids []string) StartResult {
 	}
 	go a.engine.Start(ctx)
 
-	a.emitLog("info", fmt.Sprintf("开始下载 %d 个画廊（并发 %d）", len(targets), len(targets)))
+	g := a.engine.GalleryConcurrency()
+	p := a.engine.PageConcurrency()
+	iv := a.engine.Client().RequestInterval().Milliseconds()
+	msg := fmt.Sprintf("开始下载 %d 个画廊（画廊并发 %d × 页并发 %d，最多 %d 张同时下载）",
+		len(targets), g, p, g*p)
+	if iv > 0 {
+		msg += fmt.Sprintf("，请求间隔 %dms", iv)
+	}
+	a.emitLog("info", msg)
+
 	return StartResult{Started: true, Count: len(targets)}
 }
 
diff --git a/frontend/index.html b/frontend/index.html
index e71398a..ac10100 100644
--- a/frontend/index.html
+++ b/frontend/index.html
@@ -157,9 +157,23 @@
     </label>
 
     <label class="field">
-      <span>并发数：<b id="set-conc-v">3</b></span>
-      <input type="range" id="set-conc" min="1" max="8" step="1" value="3" />
-      <small>每个画廊要发 2N+1 次请求，建议 2~4。调太高容易被限流。</small>
+      <span>画廊并发：<b id="set-gconc-v">5</b> 个</span>
+      <input type="range" id="set-gconc" min="1" max="20" step="1" value="5" />
+      <small>同时处理几个画廊。</small>
+    </label>
+
+    <label class="field">
+      <span>单画廊页并发：<b id="set-pconc-v">8</b> 张</span>
+      <input type="range" id="set-pconc" min="1" max="20" step="1" value="8" />
+      <small>每个画廊内部同时下几张图。<br>
+      总并发 = 画廊并发 × 页并发，默认 <b id="set-max">40</b> 张同时下载。</small>
+    </label>
+
+    <label class="field">
+      <span>请求间隔：<b id="set-interval-v">0</b> 秒</span>
+      <input type="range" id="set-interval" min="0" max="50" step="1" value="0" />
+      <small>所有请求之间的最小间隔（全局生效，含 /s/ 解析与图片下载）。0 = 不限流。<br>
+      高并发下如果频繁遇到 429，可以调到 1~2 秒。</small>
     </label>
 
     <label class="field">
diff --git a/frontend/js/api.js b/frontend/js/api.js
index becf5c2..4e64e70 100644
--- a/frontend/js/api.js
+++ b/frontend/js/api.js
@@ -30,12 +30,16 @@ window.eh = {
 
   // ---- 引擎 ----
   status: async () => requireGo().Status(),
+  engineInfo: async () => requireGo().EngineInfo(),
   start: async (payload) => {
     const gids = (payload && payload.onlyGids) || [];
     return requireGo().Start(gids);
   },
   stop: async () => requireGo().Stop(),
 
+  // ---- 扫描下载目录（用 .ehdl.json 清单补全丢失的任务信息）----
+  scanDownloadDir: async () => requireGo().ScanDownloadDir(),
+
   // ---- 系统 ----
   pickDir: async () => requireGo().PickDir(),
   exportFailed: async (gid) => {
diff --git a/frontend/js/renderer.js b/frontend/js/renderer.js
index f319a38..873502b 100644
--- a/frontend/js/renderer.js
+++ b/frontend/js/renderer.js
@@ -134,17 +134,28 @@ async function loadSettings() {
   $('set-dir').value = settings.downloadRoot || '';
   $('set-proxy').value = settings.proxy || '';
   $('set-proxymode').value = settings.proxyMode || 'off';
-  $('set-conc').value = settings.concurrency || 3;
-  $('set-conc-v').textContent = settings.concurrency || 3;
+  $('set-gconc').value = settings.galleryConcurrency || 5;
+  $('set-gconc-v').textContent = settings.galleryConcurrency || 5;
+  $('set-pconc').value = settings.pageConcurrency || 8;
+  $('set-pconc-v').textContent = settings.pageConcurrency || 8;
+  $('set-interval').value = Math.round((settings.requestIntervalMs || 0) / 1000);
+  $('set-interval-v').textContent = Math.round((settings.requestIntervalMs || 0) / 1000);
   $('set-to').value = Math.round((settings.timeout || 30000) / 1000);
   $('set-to-v').textContent = Math.round((settings.timeout || 30000) / 1000);
   $('set-xres').value = String(settings.xres || 'auto');
   $('set-bridgeport').value = String(settings.bridgePort || 37777);
   $('set-dirtpl').value = settings.dirTemplate || '{title}';
+  updateMaxConcurrent();
   renderPresets();
   refreshPreview();
 }
 
+function updateMaxConcurrent() {
+  const g = parseInt($('set-gconc').value, 10) || 5;
+  const p = parseInt($('set-pconc').value, 10) || 8;
+  $('set-max').textContent = g * p;
+}
+
 const DIR_PRESETS = [
   ['{title}', '仅标题'],
   ['{artist}/{title}', '按作者'],
@@ -208,7 +219,15 @@ function bind() {
     if (d) $('set-dir').value = d;
   };
 
-  $('set-conc').oninput = (e) => { $('set-conc-v').textContent = e.target.value; };
+  $('set-gconc').oninput = (e) => {
+    $('set-gconc-v').textContent = e.target.value;
+    updateMaxConcurrent();
+  };
+  $('set-pconc').oninput = (e) => {
+    $('set-pconc-v').textContent = e.target.value;
+    updateMaxConcurrent();
+  };
+  $('set-interval').oninput = (e) => { $('set-interval-v').textContent = e.target.value; };
   $('set-to').oninput = (e) => { $('set-to-v').textContent = e.target.value; };
   $('set-dirtpl').oninput = () => { renderPresets(); refreshPreview(); };
 
@@ -293,7 +312,9 @@ async function saveSettings() {
     proxy: $('set-proxy').value.trim(),
     proxyMode: $('set-proxymode').value,
     xres: $('set-xres').value,
-    concurrency: parseInt($('set-conc').value, 10),
+    galleryConcurrency: parseInt($('set-gconc').value, 10),
+    pageConcurrency: parseInt($('set-pconc').value, 10),
+    requestIntervalMs: parseInt($('set-interval').value, 10) * 1000,
     timeout: parseInt($('set-to').value, 10) * 1000,
     bridgePort: parseInt($('set-bridgeport').value, 10) || 37777,
     dirTemplate: $('set-dirtpl').value.trim() || '{title}',
@@ -301,7 +322,13 @@ async function saveSettings() {
   await window.eh.setSettings(patch);
   $('set-msg').textContent = '';
   closeModal('modal-settings');
-  pushLog({ level: 'ok', msg: '设置已保存', at: Date.now() });
+  const max = patch.galleryConcurrency * patch.pageConcurrency;
+  pushLog({
+    level: 'ok',
+    msg: `设置已保存 · 画廊并发 ${patch.galleryConcurrency} × 页并发 ${patch.pageConcurrency}（最多 ${max} 张同时下载）` +
+         (patch.requestIntervalMs ? ` · 请求间隔 ${patch.requestIntervalMs / 1000} 秒` : ''),
+    at: Date.now(),
+  });
 }
 
 async function doStart() {
diff --git a/frontend/wailsjs/go/main/App.d.ts b/frontend/wailsjs/go/main/App.d.ts
index 9ac0d94..13fd84b 100644
--- a/frontend/wailsjs/go/main/App.d.ts
+++ b/frontend/wailsjs/go/main/App.d.ts
@@ -11,6 +11,8 @@ export function ClearFinished():Promise<Record<string, any>>;
 
 export function CountDone():Promise<number>;
 
+export function EngineInfo():Promise<main.EngineInfo>;
+
 export function ExportFailed(arg1:string):Promise<string>;
 
 export function GetSettings():Promise<core.Settings>;
@@ -29,6 +31,8 @@ export function RemoveTask(arg1:string,arg2:string):Promise<Array<core.Task>>;
 
 export function RequeueFailed():Promise<Array<core.Task>>;
 
+export function ScanDownloadDir():Promise<main.ScanManifestsResult>;
+
 export function SelectAll(arg1:Array<string>):Promise<Array<core.Task>>;
 
 export function SetSettings(arg1:Record<string, any>):Promise<core.Settings>;
diff --git a/frontend/wailsjs/go/main/App.js b/frontend/wailsjs/go/main/App.js
index 43d1869..c2c398f 100644
--- a/frontend/wailsjs/go/main/App.js
+++ b/frontend/wailsjs/go/main/App.js
@@ -18,6 +18,10 @@ export function CountDone() {
   return window['go']['main']['App']['CountDone']();
 }
 
+export function EngineInfo() {
+  return window['go']['main']['App']['EngineInfo']();
+}
+
 export function ExportFailed(arg1) {
   return window['go']['main']['App']['ExportFailed'](arg1);
 }
@@ -54,6 +58,10 @@ export function RequeueFailed() {
   return window['go']['main']['App']['RequeueFailed']();
 }
 
+export function ScanDownloadDir() {
+  return window['go']['main']['App']['ScanDownloadDir']();
+}
+
 export function SelectAll(arg1) {
   return window['go']['main']['App']['SelectAll'](arg1);
 }
diff --git a/frontend/wailsjs/go/models.ts b/frontend/wailsjs/go/models.ts
index 6549ee6..509dbfe 100644
--- a/frontend/wailsjs/go/models.ts
+++ b/frontend/wailsjs/go/models.ts
@@ -20,7 +20,9 @@ export namespace core {
 	    downloadRoot: string;
 	    proxy: string;
 	    proxyMode: string;
-	    concurrency: number;
+	    galleryConcurrency: number;
+	    pageConcurrency: number;
+	    requestIntervalMs: number;
 	    timeout: number;
 	    xres: string;
 	    bridgePort: number;
@@ -36,7 +38,9 @@ export namespace core {
 	        this.downloadRoot = source["downloadRoot"];
 	        this.proxy = source["proxy"];
 	        this.proxyMode = source["proxyMode"];
-	        this.concurrency = source["concurrency"];
+	        this.galleryConcurrency = source["galleryConcurrency"];
+	        this.pageConcurrency = source["pageConcurrency"];
+	        this.requestIntervalMs = source["requestIntervalMs"];
 	        this.timeout = source["timeout"];
 	        this.xres = source["xres"];
 	        this.bridgePort = source["bridgePort"];
@@ -139,6 +143,46 @@ export namespace main {
 	        this.error = source["error"];
 	    }
 	}
+	export class EngineInfo {
+	    running: boolean;
+	    queued: number;
+	    galleryConcurrency: number;
+	    pageConcurrency: number;
+	    maxConcurrent: number;
+	    requestIntervalMs: number;
+	
+	    static createFrom(source: any = {}) {
+	        return new EngineInfo(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.running = source["running"];
+	        this.queued = source["queued"];
+	        this.galleryConcurrency = source["galleryConcurrency"];
+	        this.pageConcurrency = source["pageConcurrency"];
+	        this.maxConcurrent = source["maxConcurrent"];
+	        this.requestIntervalMs = source["requestIntervalMs"];
+	    }
+	}
+	export class ScanManifestsResult {
+	    found: number;
+	    adopted: number;
+	    root: string;
+	    note: string;
+	
+	    static createFrom(source: any = {}) {
+	        return new ScanManifestsResult(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.found = source["found"];
+	        this.adopted = source["adopted"];
+	        this.root = source["root"];
+	        this.note = source["note"];
+	    }
+	}
 	export class StartResult {
 	    started: boolean;
 	    reason: string;
diff --git a/internal/core/concurrency_test.go b/internal/core/concurrency_test.go
new file mode 100644
index 0000000..9338fc9
--- /dev/null
+++ b/internal/core/concurrency_test.go
@@ -0,0 +1,507 @@
+package core
+
+// 双层并发 + 扫尾 的集成测试：用 httptest 模拟 EH 服务器，
+// 记录每个时刻有多少请求在飞，验证「页并发」真的生效。
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"eh-downloader-wails/internal/eh"
+)
+
+// mockEH 一个可控的 EH 模拟器
+type mockEH struct {
+	srv *httptest.Server
+
+	mu sync.Mutex
+	// 记录并发峰值
+	inFlight    int32
+	peakFlight  int32
+	totalReqs   int64
+	// 每页失败次数（第一次失败 -> 成功，模拟可重试错误）
+	failOnce map[int]int32
+	// 哪些页彻底失败
+	alwaysFail map[int]bool
+	// 慢响应（ms），用于观察并发
+	delayMs int32
+}
+
+func newMockEH(totalPages int) *mockEH {
+	m := &mockEH{
+		failOnce:   map[int]int32{},
+		alwaysFail: map[int]bool{},
+		delayMs:    5,
+	}
+
+	mux := http.NewServeMux()
+
+	// 画廊页（一次性给全，避免分页逻辑干扰测试）
+	mux.HandleFunc("/g/", func(w http.ResponseWriter, r *http.Request) {
+		m.track(func() {
+			var sb strings.Builder
+			sb.WriteString(`<html><head><title>[Test] Gallery - E-Hentai Galleries</title>`)
+			sb.WriteString(`<meta name="description" content="Free Hentai Doujinshi Gallery: [Test] Gallery: x" />`)
+			sb.WriteString(`</head><body><div id="taglist"><table>`)
+			sb.WriteString(`<tr><td class="tc">artist:</td><td><div class="gtl"><a href="/tag/artist:x">X</a></div></td></tr>`)
+			sb.WriteString(`</table></div>`)
+			for i := 1; i <= totalPages; i++ {
+				sb.WriteString(fmt.Sprintf(
+					`<a href="/s/k%03d/999-%d"><div title="Page %d: %03d.png"></div></a>`,
+					i, i, i, i))
+			}
+			sb.WriteString(fmt.Sprintf(`Showing 1 - %d of %d images</body></html>`, totalPages, totalPages))
+			w.Write([]byte(sb.String()))
+		})
+	})
+
+	// /s/ 解析页 —— 返回的图片 URL 指向 mock 服务器自己
+	mux.HandleFunc("/s/", func(w http.ResponseWriter, r *http.Request) {
+		m.track(func() {
+			// /s/k001/999-1 -> page 1
+			page := 1
+			if idx := strings.LastIndex(r.URL.Path, "-"); idx > 0 {
+				page, _ = strconv.Atoi(r.URL.Path[idx+1:])
+			}
+			// 图片 URL 用 mock 服务器自己的地址，否则请求到不了本地。
+			// （真实的 hath URL 是随机子域+随机端口，协议逻辑在 eh.go 里测），
+			// 这里只验证「解析出的 URL 被拿去下载」这条链路。
+			base := m.URL()
+			w.Write([]byte(fmt.Sprintf(
+				`<html><img src="%s/img/%03d.png?xres=800"/></html>`, base, page)))
+		})
+	})
+
+	// 图片本体
+	mux.HandleFunc("/img/", func(w http.ResponseWriter, r *http.Request) {
+		m.track(func() {
+			page := 0
+			name := r.URL.Path[strings.LastIndex(r.URL.Path, "/")+1:]
+			fmt.Sscanf(name, "%03d.png", &page)
+
+			m.mu.Lock()
+			always := m.alwaysFail[page]
+			n := m.failOnce[page]
+			if !always && n > 0 {
+				m.failOnce[page] = n - 1
+			}
+			m.mu.Unlock()
+
+			if always {
+				w.WriteHeader(http.StatusServiceUnavailable)
+				return
+			}
+			if n > 0 {
+				w.WriteHeader(http.StatusServiceUnavailable)
+				return
+			}
+			w.Write([]byte("image-data-" + name))
+		})
+	})
+
+	m.srv = httptest.NewServer(mux)
+	return m
+}
+
+// track 统计并发峰值
+func (m *mockEH) track(fn func()) {
+	cur := atomic.AddInt32(&m.inFlight, 1)
+	atomic.AddInt64(&m.totalReqs, 1)
+	for {
+		old := atomic.LoadInt32(&m.peakFlight)
+		if cur <= old || atomic.CompareAndSwapInt32(&m.peakFlight, old, cur) {
+			break
+		}
+	}
+	time.Sleep(time.Duration(m.delayMs) * time.Millisecond)
+	defer atomic.AddInt32(&m.inFlight, -1)
+	fn()
+}
+
+func (m *mockEH) URL() string { return m.srv.URL }
+func (m *mockEH) Close()       { m.srv.Close() }
+func (m *mockEH) peak() int32  { return atomic.LoadInt32(&m.peakFlight) }
+
+// 把 hath URL 指向 mock 服务器
+func (m *mockEH) installBase() func() {
+	old := eh.EHBase
+	eh.EHBase = m.srv.URL
+	return func() { eh.EHBase = old }
+}
+
+func newEngineFor(t *testing.T, root string, g, p int) (*Engine, *Store) {
+	t.Helper()
+	s := NewStore(filepath.Join(t.TempDir(), "state.json"))
+	s.UpdateSettings(map[string]interface{}{
+		"downloadRoot":       root,
+		"dirTemplate":        "{gid}",
+		"galleryConcurrency": g,
+		"pageConcurrency":    p,
+		"proxy":              "",
+		"proxyMode":          "off",
+		"timeout":            10000,
+	})
+	e := NewEngine(s, &noopSink{}, s.Settings())
+	return e, s
+}
+
+func addOne(t *testing.T, s *Store, gid, token string) {
+	t.Helper()
+	s.AddTasks([]eh.GalleryRef{{GID: gid, Token: token}})
+}
+
+// 页并发真的生效：单画廊 8 并发时，服务器侧应看到并发 > 1
+func TestPageConcurrencyWorks(t *testing.T) {
+	const total = 20
+
+	m := newMockEH(total)
+	defer m.Close()
+	restore := m.installBase()
+	defer restore()
+
+	root := t.TempDir()
+	e, s := newEngineFor(t, root, 1, 8)
+	addOne(t, s, "999", "tok")
+
+	e.Enqueue(s.Tasks())
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	e.Start(ctx)
+
+	task := s.FindTask("999", "tok")
+	if task.Status != "done" {
+		t.Fatalf("应全部下完，实际状态 %s (done=%d failed=%d)", task.Status, task.Done, task.Failed)
+	}
+	if task.Done != total {
+		t.Errorf("应下 %d 张，实际 %d", total, task.Done)
+	}
+
+	// 页并发 8 => 峰值并发应该 > 1
+	if m.peak() < 2 {
+		t.Errorf("页并发 8 时服务器侧并发峰值只有 %d，说明页级并发没生效", m.peak())
+	}
+	t.Logf("页并发峰值 = %d（期望接近 8）", m.peak())
+
+	// 文件都要在
+	for i := 1; i <= total; i++ {
+		name := filepath.Join(root, "999", fmt.Sprintf("%03d.png", i))
+		if st, err := os.Stat(name); err != nil || st.Size() == 0 {
+			t.Errorf("第 %d 张图没下好", i)
+		}
+	}
+
+	// 清单也要写
+	mf, err := ReadManifest(filepath.Join(root, "999"))
+	if err != nil || mf == nil {
+		t.Fatalf("画廊清单没写: %v", err)
+	}
+	if mf.TotalPages != total || len(mf.DonePages) != total {
+		t.Errorf("清单内容不对: total=%d done=%d", mf.TotalPages, len(mf.DonePages))
+	}
+}
+
+// 页并发=1 时应退化成串行
+func TestPageConcurrencyOneIsSerial(t *testing.T) {
+	const total = 8
+
+	m := newMockEH(total)
+	defer m.Close()
+	restore := m.installBase()
+	defer restore()
+
+	root := t.TempDir()
+	e, s := newEngineFor(t, root, 1, 1)
+	addOne(t, s, "888", "tok")
+
+	e.Enqueue(s.Tasks())
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	e.Start(ctx)
+
+	if s.FindTask("888", "tok").Status != "done" {
+		t.Error("应全部下完")
+	}
+	if m.peak() > 1 {
+		t.Errorf("页并发 1 时不该有并发请求，峰值 %d", m.peak())
+	}
+}
+
+// 重试：首轮失败（503）后应重试成功，不该进扫尾失败
+func TestRetryThenSucceed(t *testing.T) {
+	const total = 4
+
+	m := newMockEH(total)
+	defer m.Close()
+	restore := m.installBase()
+	defer restore()
+
+	// 每页都先失败一次
+	m.mu.Lock()
+	for i := 1; i <= total; i++ {
+		m.failOnce[i] = 1
+	}
+	m.mu.Unlock()
+
+	root := t.TempDir()
+	e, s := newEngineFor(t, root, 1, 4)
+	addOne(t, s, "777", "tok")
+
+	e.Enqueue(s.Tasks())
+	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
+	defer cancel()
+	e.Start(ctx)
+
+	task := s.FindTask("777", "tok")
+	if task.Status != "done" {
+		t.Errorf("重试后应全部成功，实际 %s (failed=%d)", task.Status, task.Failed)
+	}
+	if task.Failed != 0 {
+		t.Errorf("不该有失败，实际 %d", task.Failed)
+	}
+}
+
+// 整轮扫尾：首轮必定失败（4 次重试全挂），扫尾再试仍失败 -> 标记 partial
+// 但如果扫尾时恢复成功，应该是 done
+func TestSweepRetrySucceeds(t *testing.T) {
+	const total = 3
+
+	m := newMockEH(total)
+	defer m.Close()
+	restore := m.installBase()
+	defer restore()
+
+	// 每页失败次数 = 首轮重试次数(4) + 1，确保首轮 4 次全挂，
+	// 扫尾时能成功
+	m.mu.Lock()
+	for i := 1; i <= total; i++ {
+		m.failOnce[i] = 5
+	}
+	m.mu.Unlock()
+
+	root := t.TempDir()
+	e, s := newEngineFor(t, root, 1, 3)
+	addOne(t, s, "666", "tok")
+
+	e.Enqueue(s.Tasks())
+	ctx, cancel := context.WithTimeout(context.Background(), 120*time.Second)
+	defer cancel()
+	e.Start(ctx)
+
+	task := s.FindTask("666", "tok")
+	if task.Status != "done" {
+		t.Errorf("扫尾后应全部成功，实际 %s (done=%d failed=%d)", task.Status, task.Done, task.Failed)
+	}
+	if task.Failed != 0 {
+		t.Errorf("扫尾后不该有失败，实际 %d", task.Failed)
+	}
+	for i := 1; i <= total; i++ {
+		name := filepath.Join(root, "666", fmt.Sprintf("%03d.png", i))
+		if st, err := os.Stat(name); err != nil || st.Size() == 0 {
+			t.Errorf("第 %d 张没下好", i)
+		}
+	}
+}
+
+// 彻底失败（一直 503）-> partial，且扫尾也救不回来
+func TestPermanentFailureMarksPartial(t *testing.T) {
+	const total = 2
+
+	m := newMockEH(total)
+	defer m.Close()
+	restore := m.installBase()
+	defer restore()
+
+	m.mu.Lock()
+	for i := 1; i <= total; i++ {
+		m.alwaysFail[i] = true
+	}
+	m.mu.Unlock()
+
+	root := t.TempDir()
+	e, s := newEngineFor(t, root, 1, 2)
+	addOne(t, s, "555", "tok")
+
+	e.Enqueue(s.Tasks())
+	ctx, cancel := context.WithTimeout(context.Background(), 120*time.Second)
+	defer cancel()
+	e.Start(ctx)
+
+	task := s.FindTask("555", "tok")
+	if task.Status != "partial" {
+		t.Errorf("全失败应标记 partial，实际 %s", task.Status)
+	}
+	if task.Failed != total {
+		t.Errorf("失败数应为 %d，实际 %d", total, task.Failed)
+	}
+	if len(task.FailedList) != total {
+		t.Errorf("失败清单应有 %d 条，实际 %d", total, len(task.FailedList))
+	}
+}
+
+// 断点续传：已有文件不重下
+func TestResumeWithExistingFiles(t *testing.T) {
+	const total = 6
+
+	m := newMockEH(total)
+	defer m.Close()
+	restore := m.installBase()
+	defer restore()
+
+	root := t.TempDir()
+	dir := filepath.Join(root, "444")
+	os.MkdirAll(dir, 0o755)
+
+	// 预先放好 4 张
+	for i := 1; i <= 4; i++ {
+		os.WriteFile(filepath.Join(dir, fmt.Sprintf("%03d.png", i)), []byte("image-data"), 0o644)
+	}
+
+	e, s := newEngineFor(t, root, 1, 4)
+	addOne(t, s, "444", "tok")
+
+	before := m.totalReqs
+	e.Enqueue(s.Tasks())
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	e.Start(ctx)
+
+	task := s.FindTask("444", "tok")
+	if task.Status != "done" {
+		t.Errorf("应下完，实际 %s (done=%d)", task.Status, task.Done)
+	}
+	if task.Done != total {
+		t.Errorf("完成数应为 %d，实际 %d", total, task.Done)
+	}
+
+	// 只该请求剩下的 2 页（每页 2 个请求 = 4 次）
+	used := m.totalReqs - before
+	if used > 8 {
+		t.Errorf("已有 4 张却发了 %d 次请求 —— 断点续传没生效", used)
+	}
+	t.Logf("续传只用了 %d 次请求（4 张已存在，应只用 4 次）", used)
+}
+
+// 多个画廊并行：画廊并发生效
+func TestGalleryConcurrencyWorks(t *testing.T) {
+	const (
+		galleries = 5
+		pages     = 4
+	)
+
+	m := newMockEH(pages)
+	defer m.Close()
+	restore := m.installBase()
+	defer restore()
+
+	root := t.TempDir()
+	e, s := newEngineFor(t, root, galleries, 1)
+	for i := 1; i <= galleries; i++ {
+		gid := strconv.Itoa(300 + i)
+		addOne(t, s, gid, "tok")
+	}
+
+	e.Enqueue(s.Tasks())
+	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
+	defer cancel()
+	e.Start(ctx)
+
+	for i := 1; i <= galleries; i++ {
+		gid := strconv.Itoa(300 + i)
+		task := s.FindTask(gid, "tok")
+		if task == nil || task.Status != "done" {
+			t.Errorf("画廊 %s 没下完: %v", gid, task)
+		}
+	}
+
+	// 画廊并发 5 => 峰值并发应该 > 1
+	if m.peak() < 2 {
+		t.Errorf("画廊并发 5 时峰值只有 %d，并发没生效", m.peak())
+	}
+	t.Logf("画廊并发峰值 = %d", m.peak())
+}
+
+// 全局限流在引擎里生效
+func TestEngineRespectsRateLimit(t *testing.T) {
+	const total = 6
+
+	m := newMockEH(total)
+	defer m.Close()
+	restore := m.installBase()
+	defer restore()
+
+	root := t.TempDir()
+	e, s := newEngineFor(t, root, 1, 4)
+	e.SetRequestInterval(80) // 80ms
+	addOne(t, s, "333", "tok")
+
+	e.Enqueue(s.Tasks())
+	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
+	defer cancel()
+
+	start := time.Now()
+	e.Start(ctx)
+	elapsed := time.Since(start)
+
+	task := s.FindTask("333", "tok")
+	if task.Status != "done" {
+		t.Fatalf("应下完，实际 %s", task.Status)
+	}
+	// 6 页 = 6 次 /s/ + 6 次图片 = 12 次请求，至少 11 个间隔 = 880ms
+	wantMin := 11 * 80 * time.Millisecond
+	if elapsed < wantMin {
+		t.Errorf("限流 80ms 时 %d 次请求应至少耗时 %v，实际 %v", 12, wantMin, elapsed)
+	}
+	t.Logf("12 次请求限流 80ms，实际耗时 %v", elapsed)
+}
+
+// 取消：页级并发下点停止要能真的中断
+func TestCancelWithPageConcurrency(t *testing.T) {
+	const total = 30
+
+	m := newMockEH(total)
+	defer m.Close()
+	m.delayMs = 50 // 放慢点，方便中途取消
+	restore := m.installBase()
+	defer restore()
+
+	root := t.TempDir()
+	e, s := newEngineFor(t, root, 1, 8)
+	addOne(t, s, "222", "tok")
+
+	e.Enqueue(s.Tasks())
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	done := make(chan struct{})
+	go func() { e.Start(ctx); close(done) }()
+
+	time.Sleep(300 * time.Millisecond)
+	e.Stop() // 相当于点「停止」
+
+	select {
+	case <-done:
+	case <-time.After(5 * time.Second):
+		t.Fatal("取消后应该在 5 秒内返回")
+	}
+
+	task := s.FindTask("222", "tok")
+	if task.Status != "queued" {
+		t.Errorf("取消后任务应退回 queued 等待续传，实际 %s", task.Status)
+	}
+	// 已下的文件还在（断点续传的基础）
+	dir := filepath.Join(root, "222")
+	files, _ := os.ReadDir(dir)
+	if len(files) > 0 {
+		t.Logf("取消前已下 %d 个文件，续传时会跳过", len(files))
+	}
+}
\ No newline at end of file
diff --git a/internal/core/engine.go b/internal/core/engine.go
index 6523180..83b4188 100644
--- a/internal/core/engine.go
+++ b/internal/core/engine.go
@@ -49,47 +49,90 @@ type Engine struct {
 	client *eh.Client
 	sink   EventSink
 
-	mu          sync.Mutex
-	concurrency int
-	running     bool
-	cancel      context.CancelFunc
-	queue       []Task
+	mu              sync.Mutex
+	galleryWorkers  int
+	pageConcurrency int
+	running         bool
+	cancel          context.CancelFunc
+	queue           []Task
 }
 
 // NewEngine 建引擎
 func NewEngine(store *Store, sink EventSink, settings Settings) *Engine {
 	e := &Engine{
-		store:  store,
-		sink:   sink,
-		client: eh.NewClient(time.Duration(settings.Timeout)*time.Millisecond,
-			settings.Proxy, settings.ProxyMode, settings.Xres),
-		concurrency: settings.Concurrency,
-	}
-	if e.concurrency < 1 {
-		e.concurrency = 3
-	}
-	if e.concurrency > 8 {
-		e.concurrency = 8
+		store:           store,
+		sink:            sink,
+		client:          eh.NewClient(time.Duration(settings.Timeout)*time.Millisecond, settings.Proxy, settings.ProxyMode, settings.Xres),
+		galleryWorkers:  clampInt(settings.GalleryConcurrency, 1, 20, 5),
+		pageConcurrency: clampInt(settings.PageConcurrency, 1, 20, 8),
 	}
+	e.client.SetRequestInterval(time.Duration(settings.RequestIntervalMs) * time.Millisecond)
 	return e
 }
 
+// clampInt 把值夹到 [lo, hi]。0 或负数视为「没设置」，用默认值。
+func clampInt(v, lo, hi, def int) int {
+	if v <= 0 {
+		return def
+	}
+	if v < lo {
+		return lo
+	}
+	if v > hi {
+		return hi
+	}
+	return v
+}
+
 // Client 暴露给 app 层改配置用
 func (e *Engine) Client() *eh.Client { return e.client }
 
 // SetConcurrency 运行时改并发
 func (e *Engine) SetConcurrency(n int) {
-	if n < 1 {
-		n = 1
-	}
-	if n > 8 {
-		n = 8
-	}
 	e.mu.Lock()
-	e.concurrency = n
+	e.galleryWorkers = clampInt(n, 1, 20, 5)
 	e.mu.Unlock()
 }
 
+// SetGalleryConcurrency 改画廊并发
+func (e *Engine) SetGalleryConcurrency(n int) { e.SetConcurrency(n) }
+
+// SetPageConcurrency 改单画廊页并发
+func (e *Engine) SetPageConcurrency(n int) {
+	e.mu.Lock()
+	e.pageConcurrency = clampInt(n, 1, 20, 8)
+	e.mu.Unlock()
+}
+
+// SetRequestInterval 改全局请求间隔（毫秒）
+func (e *Engine) SetRequestInterval(ms int) {
+	if ms < 0 {
+		ms = 0
+	}
+	e.client.SetRequestInterval(time.Duration(ms) * time.Millisecond)
+}
+
+// GalleryConcurrency 当前画廊并发
+func (e *Engine) GalleryConcurrency() int {
+	e.mu.Lock()
+	defer e.mu.Unlock()
+	return e.galleryWorkers
+}
+
+// PageConcurrency 当前页并发
+func (e *Engine) PageConcurrency() int {
+	e.mu.Lock()
+	defer e.mu.Unlock()
+	return e.pageConcurrency
+}
+
+// emitTask 把任务状态推给 UI
+func (e *Engine) emitTask(t Task) {
+	if e.sink != nil {
+		e.sink.TaskUpdate(t)
+	}
+}
+
 func (e *Engine) IsRunning() bool {
 	e.mu.Lock()
 	defer e.mu.Unlock()
@@ -138,9 +181,12 @@ func (e *Engine) Start(ctx context.Context) {
 		return
 	}
 	e.running = true
+	e.mu.Unlock()
+
 	ctx, cancel := context.WithCancel(ctx)
+	e.mu.Lock()
 	e.cancel = cancel
-	n := e.concurrency
+	n := e.galleryWorkers
 	e.mu.Unlock()
 
 	defer func() {
@@ -256,59 +302,266 @@ func (e *Engine) runTask(ctx context.Context, task Task) {
 	}
 	e.save(task)
 
-	// ② ③ 逐页：解析 URL → 下载
-	total := len(gallery.Pages)
-	for _, p := range gallery.Pages {
-		if ctx.Err() != nil {
-			e.markCanceled(task)
+	// ② ③ 页级并发下载
+	st := &pageState{
+		task:   &task,
+		dir:    dir,
+		pages:  gallery.Pages,
+		gid:    task.GID,
+		token:  task.Token,
+		title:  gallery.Title,
+		total:  len(gallery.Pages),
+		engine: e,
+	}
+
+	// 先做一遍快速扫描：已存在的直接算完成，剩下的才进队列
+	st.scanExisting()
+	st.saveManifest()
+
+	// 页级 worker 池
+	n := e.pageConcurrency
+	if n > len(st.pending) {
+		n = len(st.pending)
+	}
+	if n > 0 {
+		var wg sync.WaitGroup
+		work := make(chan eh.GalleryPageInfo, len(st.pending))
+		for _, p := range st.pending {
+			work <- p
+		}
+		close(work)
+
+		for i := 0; i < n; i++ {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				for p := range work {
+					st.downloadPage(ctx, p)
+				}
+			}()
+		}
+		wg.Wait()
+	}
+
+	// ---- 整轮扫尾：把刚失败的页再扫一遍 ----
+	if st.failedCount() > 0 && ctx.Err() == nil {
+		e.log("info", fmt.Sprintf("画廊 %s：%d 页首轮失败，开始扫尾重试", task.GID, st.failedCount()))
+
+		retry := st.collectFailed()
+		// 扫尾时清掉 failedList，让结果反映最终状态
+		st.clearFailures()
+
+		var wg sync.WaitGroup
+		work := make(chan eh.GalleryPageInfo, len(retry))
+		for _, p := range retry {
+			work <- p
+		}
+		close(work)
+
+		n := e.pageConcurrency
+		if n > len(retry) {
+			n = len(retry)
+		}
+		for i := 0; i < n; i++ {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				for p := range work {
+					st.downloadPage(ctx, p)
+				}
+			}()
+		}
+		wg.Wait()
+
+		if st.failedCount() > 0 {
+			e.log("warn", fmt.Sprintf(
+				"画廊 %s：扫尾后仍有 %d 页失败（换个线路再点「开始下载」可续传）",
+				task.GID, st.failedCount()))
+		} else {
+			e.log("ok", fmt.Sprintf("画廊 %s：扫尾重试全部成功", task.GID))
+		}
+	}
+
+	st.saveManifest()
+
+	if ctx.Err() != nil {
+		e.markCanceled(task)
+		return
+	}
+
+	t := st.snapshot()
+	if t.Failed > 0 {
+		t.Status = "partial"
+	} else {
+		t.Status = "done"
+	}
+	e.save(t)
+}
+
+// pageState 是「一个画廊的页级下载状态」，所有字段都由 mutex 保护，
+// 因为页级 worker 是并发的。
+type pageState struct {
+	mu     sync.Mutex
+	engine *Engine
+
+	task  *Task
+	dir   string
+	gid   string
+	token string
+	title string
+	total int
+
+	pages   []eh.GalleryPageInfo
+	pending []eh.GalleryPageInfo
+
+	done    map[int]bool
+	failed  map[int]string // 页码 -> 错误
+	failedL []FailedItem
+}
+
+// scanExisting 扫描已有文件（断点续传的第一依据：文件在且非空 = 完成）
+func (s *pageState) scanExisting() {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	s.done = map[int]bool{}
+	s.failed = map[int]string{}
+	s.failedL = nil
+
+	if s.task.Pages == nil {
+		s.task.Pages = map[string]string{}
+	}
+
+	for _, p := range s.pages {
+		fname := targetName(p, s.gid, s.total)
+		dest := filepath.Join(s.dir, fname)
+		if st, err := os.Stat(dest); err == nil && st.Size() > 0 {
+			s.done[p.Page] = true
+			s.task.Pages[strconv.Itoa(p.Page)] = "done"
+		} else {
+			s.pending = append(s.pending, p)
+		}
+	}
+	s.task.Done = len(s.done)
+}
+
+// downloadPage 下单页（解析 URL → 下载），内部含 4 次退避重试
+func (s *pageState) downloadPage(ctx context.Context, p eh.GalleryPageInfo) {
+	if ctx.Err() != nil {
+		return
+	}
+
+	fname := targetName(p, s.gid, s.total)
+	dest := filepath.Join(s.dir, fname)
+
+	err := s.engine.withRetry(ctx, func() error {
+		imgURL, e := s.engine.client.ResolveImageURL(ctx, p.SPath)
+		if e != nil {
+			return e
+		}
+		_, e = s.engine.client.DownloadImage(ctx, imgURL, dest, nil)
+		return e
+	})
+
+	s.mu.Lock()
+	k := strconv.Itoa(p.Page)
+	if err != nil {
+		if ctx.Err() != nil || errors.Is(err, ErrCanceled) {
+			s.mu.Unlock()
+			s.markCanceled()
 			return
 		}
-
-		fname := targetName(p, task.GID, total)
-		dest := filepath.Join(dir, fname)
-
-		// 断点续传：文件在就算完成（文件系统即真相，状态文件丢了也能续）
-		if st, err := os.Stat(dest); err == nil && st.Size() > 0 {
-			task.Done++
-			task.Pages[strconv.Itoa(p.Page)] = "done"
-			e.progress(task)
-			continue
-		}
-
-		page := p.Page
-		err := e.withRetry(ctx, func() error {
-			imgURL, err := e.client.ResolveImageURL(ctx, p.SPath)
-			if err != nil {
-				return err
-			}
-			_, err = e.client.DownloadImage(ctx, imgURL, dest, nil)
-			return err
-		})
-		if err != nil {
-			if ctx.Err() != nil || errors.Is(err, ErrCanceled) {
-				e.markCanceled(task)
-				return
-			}
-			task.Failed++
-			task.Pages[strconv.Itoa(page)] = "failed"
-			task.FailedList = append(task.FailedList, FailedItem{
-				Page: page, File: fname, Error: err.Error(),
-			})
-			e.progress(task)
-			continue
-		}
-
-		task.Done++
-		task.Pages[strconv.Itoa(page)] = "done"
-		e.progress(task)
-	}
-
-	if task.Failed > 0 {
-		task.Status = "partial"
+		s.failed[p.Page] = err.Error()
+		s.failedL = append(s.failedL, FailedItem{Page: p.Page, File: fname, Error: err.Error()})
+		s.task.Pages[k] = "failed"
 	} else {
-		task.Status = "done"
+		s.done[p.Page] = true
+		s.task.Pages[k] = "done"
 	}
-	e.save(task)
+	s.syncCountsLocked()
+	snap := s.snapshotLocked()
+	s.mu.Unlock()
+
+	s.engine.emitTask(snap)
+}
+
+func (s *pageState) syncCountsLocked() {
+	s.task.Done = len(s.done)
+	s.task.Failed = len(s.failed)
+	s.task.FailedList = append([]FailedItem(nil), s.failedL...)
+}
+
+func (s *pageState) snapshotLocked() Task {
+	s.syncCountsLocked()
+	t := *s.task
+	return t
+}
+
+func (s *pageState) snapshot() Task {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return s.snapshotLocked()
+}
+
+func (s *pageState) failedCount() int {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return len(s.failed)
+}
+
+func (s *pageState) clearFailures() {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.failed = map[int]string{}
+	s.failedL = nil
+	s.task.Failed = 0
+	s.task.FailedList = []FailedItem{}
+}
+
+// collectFailed 收集失败页（清空失败表前先取出）
+func (s *pageState) collectFailed() []eh.GalleryPageInfo {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	failed := intSet(keysOf(s.failed))
+	var out []eh.GalleryPageInfo
+	for _, p := range s.pages {
+		if failed[p.Page] {
+			out = append(out, p)
+		}
+	}
+	return out
+}
+
+// markCanceled 任一页发现取消就整体标记
+func (s *pageState) markCanceled() {
+	s.engine.markCanceled(s.snapshot())
+}
+
+func (s *pageState) saveManifest() {
+	s.mu.Lock()
+	done := keysOf(s.done)
+	failed := keysOf(s.failed)
+	t := *s.task
+	s.mu.Unlock()
+
+	WriteManifest(s.dir, Manifest{
+		GID:        s.gid,
+		Token:      s.token,
+		Title:      s.title,
+		TotalPages: s.total,
+		DonePages:  done,
+		FailedPage: failed,
+		CreatedAt:  t.CreatedAt,
+	})
+}
+
+func keysOf[V any](m map[int]V) []int {
+	out := make([]int, 0, len(m))
+	for k := range m {
+		out = append(out, k)
+	}
+	return out
 }
 
 // targetName 页码补零，保证排序
@@ -395,17 +648,9 @@ func (e *Engine) fail(task Task, err error) {
 	e.log("error", fmt.Sprintf("画廊 %s 失败：%s", task.GID, msg))
 }
 
-func (e *Engine) progress(task Task) {
-	if e.sink != nil {
-		e.sink.TaskUpdate(task)
-	}
-}
-
 func (e *Engine) save(task Task) {
 	task = e.store.UpsertTask(task)
-	if e.sink != nil {
-		e.sink.TaskUpdate(task)
-	}
+	e.emitTask(task)
 }
 
 func (e *Engine) log(level, msg string) {
diff --git a/internal/core/engine_test.go b/internal/core/engine_test.go
index 77fedd9..0f06f89 100644
--- a/internal/core/engine_test.go
+++ b/internal/core/engine_test.go
@@ -20,7 +20,13 @@ func newTestStore(t *testing.T) (*Store, string) {
 func TestStoreDefaults(t *testing.T) {
 	s, _ := newTestStore(t)
 	st := s.Settings()
-	if st.Concurrency != 3 || st.Timeout != 30000 || st.BridgePort != 37777 {
+	if st.GalleryConcurrency != 5 || st.PageConcurrency != 8 {
+		t.Errorf("并发默认值不对: 画廊%d 页%d", st.GalleryConcurrency, st.PageConcurrency)
+	}
+	if st.RequestIntervalMs != 0 {
+		t.Errorf("请求间隔默认应为 0（不限流），实际 %d", st.RequestIntervalMs)
+	}
+	if st.Timeout != 30000 || st.BridgePort != 37777 {
 		t.Errorf("默认值不对: %+v", st)
 	}
 	if st.DirTemplate != "{title}" {
@@ -34,13 +40,24 @@ func TestStoreDefaults(t *testing.T) {
 // 原子写 + 重新加载
 func TestStorePersist(t *testing.T) {
 	s, path := newTestStore(t)
-	s.UpdateSettings(map[string]interface{}{"concurrency": 5, "proxy": "http://127.0.0.1:7890"})
+	s.UpdateSettings(map[string]interface{}{
+		"galleryConcurrency": 6,
+		"pageConcurrency":    10,
+		"requestIntervalMs":  250,
+		"proxy":              "http://127.0.0.1:7890",
+	})
 	s.Flush()
 
 	s2 := NewStore(path)
 	got := s2.Settings()
-	if got.Concurrency != 5 {
-		t.Errorf("并发没存住: %d", got.Concurrency)
+	if got.GalleryConcurrency != 6 {
+		t.Errorf("画廊并发没存住: %d", got.GalleryConcurrency)
+	}
+	if got.PageConcurrency != 10 {
+		t.Errorf("页并发没存住: %d", got.PageConcurrency)
+	}
+	if got.RequestIntervalMs != 250 {
+		t.Errorf("请求间隔没存住: %d", got.RequestIntervalMs)
 	}
 	if got.Proxy != "http://127.0.0.1:7890" {
 		t.Errorf("代理没存住: %q", got.Proxy)
@@ -172,7 +189,7 @@ func TestStoreCorruptedFile(t *testing.T) {
 	os.WriteFile(p, []byte("{ 这不是合法 JSON"), 0o644)
 
 	s := NewStore(p)
-	if s.Settings().Concurrency != 3 {
+	if s.Settings().GalleryConcurrency != 5 {
 		t.Error("损坏文件应回落到默认设置")
 	}
 	if len(s.Tasks()) != 0 {
@@ -221,13 +238,75 @@ func TestEngineResumeSkipsExisting(t *testing.T) {
 func TestEngineConcurrencyClamp(t *testing.T) {
 	s, _ := newTestStore(t)
 	e := NewEngine(s, nil, s.Settings())
-	e.SetConcurrency(99)
-	if e.concurrency != 8 {
-		t.Errorf("并发应被限制到 8，实际 %d", e.concurrency)
+
+	// 默认
+	if e.GalleryConcurrency() != 5 {
+		t.Errorf("默认画廊并发应为 5，实际 %d", e.GalleryConcurrency())
 	}
-	e.SetConcurrency(0)
-	if e.concurrency != 1 {
-		t.Errorf("并发应被限制到 1，实际 %d", e.concurrency)
+	if e.PageConcurrency() != 8 {
+		t.Errorf("默认页并发应为 8，实际 %d", e.PageConcurrency())
+	}
+
+	// 越界要夹到合理范围而不是 panic
+	e.SetGalleryConcurrency(99)
+	if e.GalleryConcurrency() != 20 {
+		t.Errorf("画廊并发应夹到 20，实际 %d", e.GalleryConcurrency())
+	}
+	e.SetGalleryConcurrency(0)
+	if e.GalleryConcurrency() != 5 {
+		t.Errorf("画廊并发 0 应回落默认 5，实际 %d", e.GalleryConcurrency())
+	}
+
+	e.SetPageConcurrency(99)
+	if e.PageConcurrency() != 20 {
+		t.Errorf("页并发应夹到 20，实际 %d", e.PageConcurrency())
+	}
+	e.SetPageConcurrency(-1)
+	if e.PageConcurrency() != 8 {
+		t.Errorf("页并发 -1 应回落默认 8，实际 %d", e.PageConcurrency())
+	}
+
+	// 正常范围
+	e.SetGalleryConcurrency(5)
+	e.SetPageConcurrency(8)
+	if e.GalleryConcurrency()*e.PageConcurrency() != 40 {
+		t.Errorf("理论总并发应为 40，实际 %d", e.GalleryConcurrency()*e.PageConcurrency())
+	}
+}
+
+// 旧配置文件（只有 concurrency 字段）要能平滑迁移
+func TestSettingsMigration(t *testing.T) {
+	dir := t.TempDir()
+	p := filepath.Join(dir, "state.json")
+	// 模拟旧版 state.json：只有 concurrency，没有新的三个字段
+	old := `{
+      "settings": {
+        "downloadRoot": "D:/dl",
+        "proxy": "http://127.0.0.1:7890",
+        "proxyMode": "http",
+        "concurrency": 4,
+        "timeout": 45000,
+        "xres": "auto",
+        "bridgePort": 37777,
+        "dirTemplate": "{title}"
+      },
+      "tasks": []
+    }`
+	os.WriteFile(p, []byte(old), 0o644)
+
+	s := NewStore(p)
+	got := s.Settings()
+	if got.GalleryConcurrency != 5 {
+		t.Errorf("旧配置迁移后画廊并发应为默认 5，实际 %d", got.GalleryConcurrency)
+	}
+	if got.PageConcurrency != 8 {
+		t.Errorf("旧配置迁移后页并发应为默认 8，实际 %d", got.PageConcurrency)
+	}
+	if got.Proxy != "http://127.0.0.1:7890" {
+		t.Errorf("旧配置的代理丢了: %q", got.Proxy)
+	}
+	if got.Timeout != 45000 {
+		t.Errorf("旧配置的超时丢了: %d", got.Timeout)
 	}
 }
 
diff --git a/internal/core/manifest.go b/internal/core/manifest.go
new file mode 100644
index 0000000..f76de4a
--- /dev/null
+++ b/internal/core/manifest.go
@@ -0,0 +1,179 @@
+package core
+
+// 画廊目录清单（.ehdl.json）
+//
+// 为什么需要：断点续传的第一依据是「文件在不在」，但那有个盲区 ——
+// 如果 state.json 丢了或被删，程序就不知道这个画廊「原本应该有多少张」，
+// 也就不知道漏了哪些。
+//
+// 所以每个画廊目录下写一份清单，记录 gid/token/总页数/已完成页码。
+// 哪怕状态文件没了，扫目录也能重建进度。
+//
+// 文件名固定为 .ehdl.json（点开头，Linux/macOS 下也默认隐藏）。
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strconv"
+	"time"
+)
+
+// ManifestFileName 清单文件名
+const ManifestFileName = ".ehdl.json"
+
+// ManifestVersion 清单格式版本（将来结构变了靠这个迁移）
+const ManifestVersion = 1
+
+// Manifest 单个画廊的下载清单
+type Manifest struct {
+	Version    int      `json:"version"`
+	GID        string   `json:"gid"`
+	Token      string   `json:"token"`
+	Title      string   `json:"title"`
+	TotalPages int      `json:"totalPages"`
+	DonePages  []int    `json:"donePages"`
+	FailedPage []int    `json:"failedPages"`
+	CreatedAt  int64    `json:"createdAt"`
+	UpdatedAt  int64    `json:"updatedAt"`
+	Tool       string   `json:"tool"`
+	Note       string   `json:"note,omitempty"`
+}
+
+// WriteManifest 写画廊清单（原子写）
+func WriteManifest(dir string, m Manifest) error {
+	if err := os.MkdirAll(dir, 0o755); err != nil {
+		return err
+	}
+
+	m.Version = ManifestVersion
+	m.UpdatedAt = time.Now().UnixMilli()
+	if m.CreatedAt == 0 {
+		m.CreatedAt = m.UpdatedAt
+	}
+	m.Tool = AppName
+	if m.DonePages == nil {
+		m.DonePages = []int{}
+	}
+	if m.FailedPage == nil {
+		m.FailedPage = []int{}
+	}
+	sortInts(m.DonePages)
+	sortInts(m.FailedPage)
+
+	data, err := json.MarshalIndent(m, "", "  ")
+	if err != nil {
+		return err
+	}
+
+	path := filepath.Join(dir, ManifestFileName)
+	tmp := path + ".tmp"
+	if err := os.WriteFile(tmp, data, 0o644); err != nil {
+		return err
+	}
+	return os.Rename(tmp, path)
+}
+
+// ReadManifest 读画廊清单，文件不存在返回 (nil, nil)
+func ReadManifest(dir string) (*Manifest, error) {
+	path := filepath.Join(dir, ManifestFileName)
+	data, err := os.ReadFile(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, nil
+		}
+		return nil, err
+	}
+
+	var m Manifest
+	if err := json.Unmarshal(data, &m); err != nil {
+		return nil, err
+	}
+	if m.DonePages == nil {
+		m.DonePages = []int{}
+	}
+	if m.FailedPage == nil {
+		m.FailedPage = []int{}
+	}
+	return &m, nil
+}
+
+// ScanManifests 扫描下载根目录下所有画廊清单（跳过隐藏目录/非画廊目录）
+func ScanManifests(root string) []*Manifest {
+	entries, err := os.ReadDir(root)
+	if err != nil {
+		return nil
+	}
+
+	var out []*Manifest
+	for _, e := range entries {
+		if !e.IsDir() {
+			continue
+		}
+		// 点开头的是系统/隐藏目录，跳过
+		if len(e.Name()) > 0 && e.Name()[0] == '.' {
+			continue
+		}
+		m, err := ReadManifest(filepath.Join(root, e.Name()))
+		if err != nil || m == nil {
+			continue
+		}
+		out = append(out, m)
+	}
+	return out
+}
+
+// ReconcileTask 拿清单里的信息补全任务（state.json 缺信息时的兜底）。
+// 返回是否真的补进了新东西。
+func ReconcileTask(t *Task, m *Manifest) bool {
+	if m == nil {
+		return false
+	}
+	changed := false
+	if t.Title == "" && m.Title != "" {
+		t.Title = m.Title
+		changed = true
+	}
+	if t.TotalPages == 0 && m.TotalPages > 0 {
+		t.TotalPages = m.TotalPages
+		changed = true
+	}
+	if t.Pages == nil {
+		t.Pages = map[string]string{}
+	}
+	// 清单说 done 的，补进任务（已存在的键不重复算改动）
+	for _, p := range m.DonePages {
+		k := strconv.Itoa(p)
+		if _, exists := t.Pages[k]; exists {
+			continue
+		}
+		t.Pages[k] = "done"
+		changed = true
+	}
+	return changed
+}
+
+func sortInts(s []int) {
+	for i := 1; i < len(s); i++ {
+		for j := i; j > 0 && s[j] < s[j-1]; j-- {
+			s[j], s[j-1] = s[j-1], s[j]
+		}
+	}
+}
+
+func intSet(s []int) map[int]bool {
+	m := make(map[int]bool, len(s))
+	for _, x := range s {
+		m[x] = true
+	}
+	return m
+}
+
+func intsFromSet(m map[int]bool) []int {
+	out := make([]int, 0, len(m))
+	for k := range m {
+		out = append(out, k)
+	}
+	sortInts(out)
+	return out
+}
\ No newline at end of file
diff --git a/internal/core/manifest_test.go b/internal/core/manifest_test.go
new file mode 100644
index 0000000..2b96fbd
--- /dev/null
+++ b/internal/core/manifest_test.go
@@ -0,0 +1,241 @@
+package core
+
+// 画廊清单（.ehdl.json）测试
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"eh-downloader-wails/internal/eh"
+)
+
+func TestManifestRoundTrip(t *testing.T) {
+	dir := t.TempDir()
+
+	m := Manifest{
+		GID:        "4239274",
+		Token:      "55e069b6b9",
+		Title:      "[Noxe] Test",
+		TotalPages: 206,
+		DonePages:  []int{3, 1, 2},
+		FailedPage: []int{10, 9},
+	}
+
+	if err := WriteManifest(dir, m); err != nil {
+		t.Fatalf("写清单失败: %v", err)
+	}
+
+	// 文件应该真的存在
+	p := filepath.Join(dir, ManifestFileName)
+	if _, err := os.Stat(p); err != nil {
+		t.Fatalf("清单文件没生成: %v", err)
+	}
+	// 不该残留 .tmp
+	if _, err := os.Stat(p + ".tmp"); err == nil {
+		t.Error("临时文件没清理")
+	}
+
+	got, err := ReadManifest(dir)
+	if err != nil {
+		t.Fatalf("读清单失败: %v", err)
+	}
+	if got == nil {
+		t.Fatal("读回来的清单是 nil")
+	}
+
+	if got.GID != m.GID || got.Token != m.Token {
+		t.Errorf("gid/token 不对: %s/%s", got.GID, got.Token)
+	}
+	if got.TotalPages != 206 {
+		t.Errorf("总页数不对: %d", got.TotalPages)
+	}
+	if got.Version != ManifestVersion {
+		t.Errorf("版本号不对: %d", got.Version)
+	}
+
+	// 页码应该被排序过
+	for i := 1; i < len(got.DonePages); i++ {
+		if got.DonePages[i] < got.DonePages[i-1] {
+			t.Errorf("donePages 没排序: %v", got.DonePages)
+			break
+		}
+	}
+	if len(got.DonePages) != 3 {
+		t.Errorf("donePages 数量不对: %v", got.DonePages)
+	}
+}
+
+func TestManifestNotExist(t *testing.T) {
+	dir := t.TempDir()
+	m, err := ReadManifest(dir)
+	if err != nil {
+		t.Errorf("不存在时不该报错: %v", err)
+	}
+	if m != nil {
+		t.Error("不存在时该返回 nil")
+	}
+}
+
+func TestManifestCorrupted(t *testing.T) {
+	dir := t.TempDir()
+	os.WriteFile(filepath.Join(dir, ManifestFileName), []byte("{坏掉的 json"), 0o644)
+
+	if _, err := ReadManifest(dir); err == nil {
+		t.Error("坏 json 应该报错")
+	}
+}
+
+func TestScanManifests(t *testing.T) {
+	root := t.TempDir()
+
+	// 两个正常画廊
+	d1 := filepath.Join(root, "画廊A")
+	d2 := filepath.Join(root, "画廊B")
+	os.MkdirAll(d1, 0o755)
+	os.MkdirAll(d2, 0o755)
+	WriteManifest(d1, Manifest{GID: "111", Token: "a", TotalPages: 10, DonePages: []int{1, 2}})
+	WriteManifest(d2, Manifest{GID: "222", Token: "b", TotalPages: 5, DonePages: []int{1}})
+
+	// 一个非画廊目录（没清单）
+	os.MkdirAll(filepath.Join(root, "普通文件夹"), 0o755)
+
+	// 一个隐藏目录（该跳过）
+	hidden := filepath.Join(root, ".hidden")
+	os.MkdirAll(hidden, 0o755)
+	WriteManifest(hidden, Manifest{GID: "999", Token: "z"})
+
+	got := ScanManifests(root)
+	if len(got) != 2 {
+		t.Fatalf("应扫到 2 个清单，实际 %d: %+v", len(got), got)
+	}
+
+	found := map[string]bool{}
+	for _, m := range got {
+		found[m.GID] = true
+	}
+	if !found["111"] || !found["222"] {
+		t.Errorf("扫到的画廊不对: %v", found)
+	}
+	if found["999"] {
+		t.Error("隐藏目录不该被扫到")
+	}
+}
+
+// 用清单补全丢失的任务信息
+func TestReconcileTask(t *testing.T) {
+	m := &Manifest{
+		GID:        "111",
+		TotalPages: 206,
+		Title:      "从清单恢复的标题",
+		DonePages:  []int{1, 2, 3, 7},
+	}
+
+	// 模拟 state.json 丢了的任务
+	task := &Task{GID: "111", Token: "a", Pages: map[string]string{}}
+
+	if !ReconcileTask(task, m) {
+		t.Error("应该有修改")
+	}
+	if task.Title != "从清单恢复的标题" {
+		t.Errorf("标题没补上: %q", task.Title)
+	}
+	if task.TotalPages != 206 {
+		t.Errorf("总页数没补上: %d", task.TotalPages)
+	}
+	if len(task.Pages) != 4 {
+		t.Errorf("已完成页没补上: %v", task.Pages)
+	}
+	if task.Pages["7"] != "done" {
+		t.Errorf("第 7 页该是 done: %v", task.Pages)
+	}
+
+	// 已有信息不该被覆盖
+	task2 := &Task{
+		GID: "111", Title: "已有标题", TotalPages: 10,
+		Pages: map[string]string{"1": "done", "2": "done", "3": "done", "7": "done"},
+	}
+	if ReconcileTask(task2, m) {
+		t.Error("清单内容都已存在时不该报改动")
+	}
+	if task2.Title != "已有标题" {
+		t.Errorf("已有标题被覆盖了: %q", task2.Title)
+	}
+	if task2.TotalPages != 10 {
+		t.Errorf("已有总页数被覆盖了: %d", task2.TotalPages)
+	}
+
+	// 完全空白任务 + 空清单：不该有任何改动
+	empty := &Task{GID: "999", Pages: map[string]string{}}
+	if ReconcileTask(empty, &Manifest{GID: "999"}) {
+		t.Error("空清单不该产生改动")
+	}
+}
+
+// state.json 丢失的真实场景：完整走一遍
+func TestManifestEnablesResumeWithoutState(t *testing.T) {
+	root := t.TempDir()
+	dir := filepath.Join(root, "某画廊")
+	os.MkdirAll(dir, 0o755)
+
+	// 模拟：之前下过 3 张，清单记录了
+	WriteManifest(dir, Manifest{
+		GID:        "4239274",
+		Token:      "abc",
+		Title:      "测试",
+		TotalPages: 10,
+		DonePages:  []int{1, 2, 3},
+	})
+	for i := 1; i <= 3; i++ {
+		os.WriteFile(filepath.Join(dir, "00"+string(rune('0'+i))+".png"), []byte("data"), 0o644)
+	}
+
+	// 现在 state.json 完全丢失，只能靠清单 + 文件系统
+	ms := ScanManifests(root)
+	if len(ms) != 1 {
+		t.Fatalf("应扫到 1 个，实际 %d", len(ms))
+	}
+
+	m := ms[0]
+	if m.TotalPages != 10 {
+		t.Errorf("总页数不该: %d", m.TotalPages)
+	}
+
+	// 靠文件系统知道哪几张有了
+	have := 0
+	for i := 1; i <= m.TotalPages; i++ {
+		name := "00" + string(rune('0'+i)) + ".png"
+		if st, err := os.Stat(filepath.Join(dir, name)); err == nil && st.Size() > 0 {
+			have++
+		}
+	}
+	if have != 3 {
+		t.Errorf("应有 3 张已下载，实际 %d", have)
+	}
+	// 还差 7 张 —— 这是清单带来的价值
+	if m.TotalPages-have != 7 {
+		t.Errorf("应还差 7 张，实际 %d", m.TotalPages-have)
+	}
+}
+
+func TestFindTaskByGID(t *testing.T) {
+	s, _ := newTestStore(t)
+	s.AddTasks([]eh.GalleryRef{{GID: "111", Token: "tokA"}})
+
+	// token 对不上也能按 gid 找到
+	task := s.FindTaskByGID("111")
+	if task == nil {
+		t.Fatal("应该找得到")
+	}
+	if task.Token != "tokA" {
+		t.Errorf("token 不对: %s", task.Token)
+	}
+
+	if s.FindTaskByGID("999") != nil {
+		t.Error("不存在的 gid 应返回 nil")
+	}
+	// token 精确匹配仍要正常工作
+	if s.FindTask("111", "tokA") == nil {
+		t.Error("精确查找应该能找到")
+	}
+}
\ No newline at end of file
diff --git a/internal/core/store.go b/internal/core/store.go
index b9eb4c7..b41adee 100644
--- a/internal/core/store.go
+++ b/internal/core/store.go
@@ -22,11 +22,16 @@ type Settings struct {
 	DownloadRoot string `json:"downloadRoot"`
 	Proxy        string `json:"proxy"`
 	ProxyMode    string `json:"proxyMode"` // off | http | socks5
-	Concurrency  int    `json:"concurrency"`
-	Timeout      int    `json:"timeout"` // 毫秒
-	Xres         string `json:"xres"`    // auto | org | 数字(长边上限)
-	BridgePort   int    `json:"bridgePort"`
-	DirTemplate  string `json:"dirTemplate"`
+	// GalleryConcurrency 同时处理几个画廊
+	GalleryConcurrency int `json:"galleryConcurrency"`
+	// PageConcurrency 每个画廊内同时下几张图（总上限 = 两者相乘）
+	PageConcurrency int `json:"pageConcurrency"`
+	// RequestIntervalMs 全局请求间隔（毫秒，0 = 不限流）
+	RequestIntervalMs int    `json:"requestIntervalMs"`
+	Timeout            int    `json:"timeout"` // 毫秒
+	Xres               string `json:"xres"`    // auto | org | 数字(长边上限)
+	BridgePort         int    `json:"bridgePort"`
+	DirTemplate        string `json:"dirTemplate"`
 
 	// 内部字段：是否已探测过代理（不暴露给前端）
 	Probed bool `json:"_probed"`
@@ -67,14 +72,16 @@ type State struct {
 // DefaultSettings 返回默认设置
 func DefaultSettings() Settings {
 	return Settings{
-		DownloadRoot: "",
-		Proxy:        "",
-		ProxyMode:    "off",
-		Concurrency:  3,
-		Timeout:      30000,
-		Xres:         "auto",
-		BridgePort:   37777,
-		DirTemplate:  "{title}",
+		DownloadRoot:        "",
+		Proxy:               "",
+		ProxyMode:           "off",
+		GalleryConcurrency:  5,
+		PageConcurrency:     8,
+		RequestIntervalMs:   0,
+		Timeout:             30000,
+		Xres:                "auto",
+		BridgePort:          37777,
+		DirTemplate:         "{title}",
 	}
 }
 
@@ -110,8 +117,14 @@ func (s *Store) load() {
 			if loaded.Settings.DownloadRoot == "" {
 				loaded.Settings.DownloadRoot = def.DownloadRoot
 			}
-			if loaded.Settings.Concurrency <= 0 {
-				loaded.Settings.Concurrency = def.Concurrency
+			if loaded.Settings.GalleryConcurrency <= 0 {
+				loaded.Settings.GalleryConcurrency = def.GalleryConcurrency
+			}
+			if loaded.Settings.PageConcurrency <= 0 {
+				loaded.Settings.PageConcurrency = def.PageConcurrency
+			}
+			if loaded.Settings.RequestIntervalMs < 0 {
+				loaded.Settings.RequestIntervalMs = 0
 			}
 			if loaded.Settings.Timeout <= 0 {
 				loaded.Settings.Timeout = def.Timeout
@@ -261,6 +274,19 @@ func (s *Store) FindTask(gid, token string) *Task {
 	return nil
 }
 
+// FindTaskByGID 只按 gid 找（清单恢复用 —— token 可能对不上）
+func (s *Store) FindTaskByGID(gid string) *Task {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	for i := range s.state.Tasks {
+		if s.state.Tasks[i].GID == gid {
+			c := s.state.Tasks[i].clone()
+			return &c
+		}
+	}
+	return nil
+}
+
 // AddTasks 批量加任务（已存在的跳过），返回新增数
 func (s *Store) AddTasks(refs []eh.GalleryRef) int {
 	s.mu.Lock()
diff --git a/internal/eh/eh.go b/internal/eh/eh.go
index c961984..b295a4e 100644
--- a/internal/eh/eh.go
+++ b/internal/eh/eh.go
@@ -172,6 +172,8 @@ var (
 
 	// hath 全图 URL：随机子域 + 随机端口 + keystamp 签名
 	reHath = regexp.MustCompile(`(?i)https://[a-z0-9-]+(?:\.[a-z0-9-]+)*\.hath\.network(?::\d+)?/[^\s"'<>)\]]+`)
+	// 兜底：CDN 换域名时，从页面里抓第一个看起来像图片的 URL
+	reImgAny = regexp.MustCompile(`(?i)https?://[^\s"'<>)\]]+\.(?:png|jpe?g|webp|gif)(?:\?[^\s"'<>)\]]*)?`)
 )
 
 // parseMeta 从画廊页 HTML 的 #taglist 表格解析 艺术家/社团/分类/标签
@@ -275,6 +277,8 @@ type Client struct {
 	proxy     string
 	proxyMode string // off | http | socks5
 	xres      string // auto | org | 数字(长边上限)
+
+	limiter *Limiter
 }
 
 // NewClient 建客户端
@@ -285,7 +289,26 @@ func NewClient(timeout time.Duration, proxyURL, proxyMode, xres string) *Client
 	if xres == "" {
 		xres = "auto"
 	}
-	return &Client{timeout: timeout, proxy: proxyURL, proxyMode: proxyMode, xres: xres}
+	return &Client{
+		timeout:   timeout,
+		proxy:     proxyURL,
+		proxyMode: proxyMode,
+		xres:      xres,
+		limiter:   NewLimiter(0),
+	}
+}
+
+// SetRequestInterval 设置全局请求间隔（0 = 不限流）
+func (c *Client) SetRequestInterval(d time.Duration) {
+	if d < 0 {
+		d = 0
+	}
+	c.limiter.SetInterval(d)
+}
+
+// RequestInterval 当前请求间隔
+func (c *Client) RequestInterval() time.Duration {
+	return c.limiter.Interval()
 }
 
 // SetProxy 改代理配置
@@ -358,6 +381,11 @@ func (c *Client) httpClient(timeout time.Duration) *http.Client {
 }
 
 func (c *Client) get(ctx context.Context, u string, timeout time.Duration) (*http.Response, error) {
+	// 全局限流：所有请求（含 /s/ 解析与画廊页）统一排队
+	if err := c.limiter.Wait(ctx); err != nil {
+		return nil, err
+	}
+
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, u, nil)
 	if err != nil {
 		return nil, err
@@ -506,11 +534,14 @@ func (c *Client) ResolveImageURL(ctx context.Context, sPath string) (string, err
 	if err != nil {
 		return "", err
 	}
-	m := reHath.FindString(html)
-	if m == "" {
-		return "", fmt.Errorf("未能从 /s/ 页面解析出图片地址: %s", sPath)
+	if m := reHath.FindString(html); m != "" {
+		return c.applyXres(DecodeEntities(m)), nil
 	}
-	return c.applyXres(DecodeEntities(m)), nil
+	// CDN 换域名时的兜底：抓页面上第一个图片 URL
+	if m := reImgAny.FindString(html); m != "" {
+		return c.applyXres(DecodeEntities(m)), nil
+	}
+	return "", fmt.Errorf("未能从 /s/ 页面解析出图片地址: %s", sPath)
 }
 
 var (
@@ -542,6 +573,11 @@ func (c *Client) applyXres(u string) string {
 func (c *Client) DownloadImage(ctx context.Context, imgURL, destPath string, onProgress func(received, total int64)) (int64, error) {
 	_, _, baseTimeout := c.snapshot()
 
+	// 图片本体也要限流
+	if err := c.limiter.Wait(ctx); err != nil {
+		return 0, err
+	}
+
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, imgURL, nil)
 	if err != nil {
 		return 0, err
diff --git a/internal/eh/limiter.go b/internal/eh/limiter.go
new file mode 100644
index 0000000..55dfce7
--- /dev/null
+++ b/internal/eh/limiter.go
@@ -0,0 +1,87 @@
+package eh
+
+// 全局限流器
+//
+// 算法对齐参考实现（E-Hentai Downloader 的「请求间隔」设置）：
+// 用一个全局的 nextRequestTime，每次请求都把自己排到它后面，再把它往后推。
+//
+//	next = max(next, now) + interval
+//	等待到 next 时刻再真正发出
+//
+// 效果是「所有请求之间至少间隔 interval 毫秒」，与并发数无关 ——
+// 哪怕 40 个 worker 同时来，也会被串成每 interval 放行一个。
+//
+// interval = 0 时完全旁路，不产生任何额外开销。
+
+import (
+	"context"
+	"sync"
+	"time"
+)
+
+// Limiter 全局请求节流器
+type Limiter struct {
+	mu       sync.Mutex
+	interval time.Duration
+	next     time.Time // 下一个请求允许发出的时刻
+}
+
+// NewLimiter 建限流器（interval <= 0 表示不限流）
+func NewLimiter(interval time.Duration) *Limiter {
+	if interval < 0 {
+		interval = 0
+	}
+	return &Limiter{interval: interval}
+}
+
+// SetInterval 运行时改间隔
+func (l *Limiter) SetInterval(d time.Duration) {
+	if d < 0 {
+		d = 0
+	}
+	l.mu.Lock()
+	l.interval = d
+	l.mu.Unlock()
+}
+
+// Interval 当前间隔
+func (l *Limiter) Interval() time.Duration {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	return l.interval
+}
+
+// Wait 占用一个请求名额，必要时阻塞到放行时刻。
+// 返回 error 是为了能响应取消（点「停止」时不该继续排队）。
+func (l *Limiter) Wait(ctx context.Context) error {
+	l.mu.Lock()
+	interval := l.interval
+	if interval <= 0 {
+		l.mu.Unlock()
+		return ctx.Err()
+	}
+
+	now := time.Now()
+	// 关键：如果过去的排队已经堆积，next 可能远在未来，
+	// 这里取 max 让第一个请求立刻发出去，避免冷启动时集体等一大轮。
+	if l.next.Before(now) {
+		l.next = now
+	}
+	at := l.next
+	l.next = at.Add(interval)
+	l.mu.Unlock()
+
+	delay := time.Until(at)
+	if delay <= 0 {
+		return ctx.Err()
+	}
+
+	t := time.NewTimer(delay)
+	defer t.Stop()
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	case <-t.C:
+		return nil
+	}
+}
\ No newline at end of file
diff --git a/internal/eh/limiter_test.go b/internal/eh/limiter_test.go
new file mode 100644
index 0000000..f5820a4
--- /dev/null
+++ b/internal/eh/limiter_test.go
@@ -0,0 +1,197 @@
+package eh
+
+// 限流器测试：验证「所有请求之间至少间隔 N 毫秒」，
+// 以及并发情况下也不会穿透（这正是对齐参考脚本的关键行为）。
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"sync"
+	"testing"
+	"time"
+)
+
+// testWriter 是 httptest 响应写的最小接口
+type testWriter interface {
+	WriteHeader(int)
+	Write([]byte) (int, error)
+}
+
+func newTestServer(t *testing.T, h func(testWriter)) *httptest.Server {
+	t.Helper()
+	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		h(w)
+	}))
+}
+
+// interval=0 必须完全旁路，不能有任何额外延迟
+func TestLimiterZeroIsNoop(t *testing.T) {
+	l := NewLimiter(0)
+
+	start := time.Now()
+	var wg sync.WaitGroup
+	for i := 0; i < 50; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			l.Wait(context.Background())
+		}()
+	}
+	wg.Wait()
+
+	if elapsed := time.Since(start); elapsed > 200*time.Millisecond {
+		t.Errorf("interval=0 时不该有等待，实际耗时 %v", elapsed)
+	}
+}
+
+// 串行请求：每次都该等满间隔
+func TestLimiterSerialSpacing(t *testing.T) {
+	const interval = 100 * time.Millisecond
+	l := NewLimiter(interval)
+	ctx := context.Background()
+
+	start := time.Now()
+	for i := 0; i < 3; i++ {
+		if err := l.Wait(ctx); err != nil {
+			t.Fatal(err)
+		}
+	}
+	elapsed := time.Since(start)
+
+	// 3 个请求 => 等 2 次间隔（第 1 个立即放行）
+	wantMin := 2 * interval
+	if elapsed < wantMin {
+		t.Errorf("3 个请求应至少等 %v，实际 %v（限流没生效）", wantMin, elapsed)
+	}
+}
+
+// 并发请求也不能穿透：N 个同时来，应该被拉成串行
+func TestLimiterConcurrentSpacing(t *testing.T) {
+	const (
+		interval = 50 * time.Millisecond
+		n        = 5
+	)
+	l := NewLimiter(interval)
+	ctx := context.Background()
+
+	start := time.Now()
+	release := make([]time.Time, n)
+
+	var wg sync.WaitGroup
+	for i := 0; i < n; i++ {
+		wg.Add(1)
+		go func(idx int) {
+			defer wg.Done()
+			if err := l.Wait(ctx); err != nil {
+				t.Error(err)
+				return
+			}
+			release[idx] = time.Now()
+		}(i)
+	}
+	wg.Wait()
+
+	elapsed := time.Since(start)
+	// n 个请求 => 至少等 (n-1) 个间隔
+	wantMin := time.Duration(n-1) * interval
+	if elapsed < wantMin {
+		t.Errorf("%d 个并发请求应至少耗时 %v，实际 %v（限流被穿透）", n, wantMin, elapsed)
+	}
+}
+
+// 取消要能立即返回，不能卡在排队里
+func TestLimiterCancel(t *testing.T) {
+	l := NewLimiter(500 * time.Millisecond)
+	ctx, cancel := context.WithCancel(context.Background())
+
+	// 先占掉一个名额，让后面的排在后面
+	l.Wait(context.Background())
+
+	go func() {
+		time.Sleep(50 * time.Millisecond)
+		cancel()
+	}()
+
+	start := time.Now()
+	err := l.Wait(ctx)
+	if err == nil {
+		t.Error("取消后 Wait 应该返回错误")
+	}
+	if elapsed := time.Since(start); elapsed > 200*time.Millisecond {
+		t.Errorf("取消后应立即返回，实际等��� %v", elapsed)
+	}
+}
+
+// 运行时改间隔要生效
+func TestLimiterSetInterval(t *testing.T) {
+	l := NewLimiter(0)
+	if l.Interval() != 0 {
+		t.Error("初始间隔应为 0")
+	}
+
+	l.SetInterval(200 * time.Millisecond)
+	if l.Interval() != 200*time.Millisecond {
+		t.Errorf("改间隔失败: %v", l.Interval())
+	}
+
+	// 负数要被夹成 0
+	l.SetInterval(-100 * time.Millisecond)
+	if l.Interval() != 0 {
+		t.Errorf("负间隔应夹成 0，实际 %v", l.Interval())
+	}
+}
+
+// 负数构造要夹成 0
+func TestNewLimiterNegative(t *testing.T) {
+	l := NewLimiter(-time.Second)
+	if l.Interval() != 0 {
+		t.Errorf("负间隔应夹成 0，实际 %v", l.Interval())
+	}
+}
+
+// Client 的限流开关
+func TestClientRequestInterval(t *testing.T) {
+	c := NewClient(5*time.Second, "", "off", "auto")
+	if c.RequestInterval() != 0 {
+		t.Error("默认不该限流")
+	}
+
+	c.SetRequestInterval(150 * time.Millisecond)
+	if c.RequestInterval() != 150*time.Millisecond {
+		t.Errorf("设置失败: %v", c.RequestInterval())
+	}
+
+	c.SetRequestInterval(-5)
+	if c.RequestInterval() != 0 {
+		t.Errorf("负数应夹成 0，实际 %v", c.RequestInterval())
+	}
+}
+
+// 限流要真的作用到 HTTP 请求上（起个服务器实测）
+func TestLimiterAppliesToRequests(t *testing.T) {
+	srv := newTestServer(t, func(w testWriter) {
+		w.WriteHeader(200)
+		w.Write([]byte("ok"))
+	})
+	defer srv.Close()
+
+	const interval = 60 * time.Millisecond
+	c := NewClient(5*time.Second, "", "off", "auto")
+	c.SetRequestInterval(interval)
+
+	start := time.Now()
+	for i := 0; i < 4; i++ {
+		if _, err := c.getText(context.Background(), srv.URL+"/x"); err != nil {
+			t.Fatalf("第 %d 次请求失败: %v", i+1, err)
+		}
+	}
+	elapsed := time.Since(start)
+
+	// 4 个请求 = 8 次 HTTP 调用？不 —— 这里只有 getText，一次一个请求，
+	// 但下载会额外算一次。总共 4 次请求，至少 3 个间隔。
+	wantMin := 3 * interval
+	if elapsed < wantMin {
+		t.Errorf("4 次请求应至少耗时 %v，实际 %v", wantMin, elapsed)
+	}
+}
\ No newline at end of file