diff --git a/lib/Projectrans/Phase2Translator.py b/lib/Projectrans/Phase2Translator.py
index 829e94d..a62f49e 100644
--- a/lib/Projectrans/Phase2Translator.py
+++ b/lib/Projectrans/Phase2Translator.py
@@ -447,21 +447,18 @@ def _ParseDwarfSubprograms(dump_text: str) -> list[tuple[int, int, str]]:
     return result
 
 
-def _PickWorkerCount(n_files: int, per_worker_mb: int = 350) -> int:
-    """按可用物理内存动态限制并行 worker 数，避免多进程编译内存峰值 OOM。
+# 显式并行度覆盖：TPC_JOBS=N（N>=1）——使用者明确指定 worker 数并**自行承担**
+# 内存风险（含 N=1 即显式接受串行）。设了它就不再走内存校验/预分配。
+_JOBS_ENV: str = 'TPC_JOBS'
+# 已通过"预分配校验"的预算（MB）：同一预算不重复校验（翻译/编译两阶段各查一次）
+_MemProbeDone: set[int] = set()
+# 预分配校验的分块大小（MB）：分块提交并**全部持有**到校验结束（峰值 = 预算），
+# 结束后立即整体释放 —— 紧接其后就创建 worker 进程，OS 直接复用这批刚释放的页。
+_MEM_PROBE_CHUNK_MB: int = 256
 
-    单 worker 预估 per_worker_mb（Python 解释器 + llvmlite module + 共享
-    符号表快照）；系统可用内存不足时降为单 worker 串行，内存充足时回落到
-    cpu_count 并行。Windows 用 GlobalMemoryStatusEx 读 ullAvailPhys。
 
-    per_worker_mb=350（2026-08-22 从 700 调低）：实测翻译阶段 worker 稳态
-    内存 ~110MB（tasklist 观察）、峰值 ~300MB；原 700MB 过保守——可用内存
-    稍紧（<2.8GB）就整体降级单 worker 串行，76 文件逐个翻译 1180s，并行
-    时 ~400s，时间波动 2-3 倍（用户反馈"编译时间不稳定"的根因之一）。
-    """
-    base = min(os.cpu_count() or 4, n_files)
-    if base <= 1:
-        return base
+def _MemStatus() -> tuple[int, int]:
+    """(可用物理内存 MB, 物理内存总量 MB)；读取失败返回 (-1, -1)，调用方按"未知"处理"""
     try:
         import ctypes
 
@@ -481,11 +478,97 @@ def _PickWorkerCount(n_files: int, per_worker_mb: int = 350) -> int:
         stat = _MemStat()
         stat.dwLength = ctypes.sizeof(_MemStat)
         if ctypes.windll.kernel32.GlobalMemoryStatusEx(ctypes.byref(stat)):
-            avail_mb = stat.ullAvailPhys // (1024 * 1024)
-            by_mem = max(1, avail_mb // per_worker_mb)
-            return max(1, min(base, by_mem))
+            return (stat.ullAvailPhys // (1024 * 1024),
+                    stat.ullTotalPhys // (1024 * 1024))
     except Exception:
         pass
+    return (-1, -1)
+
+
+def _ProbeReserveMb(mb: int) -> bool:
+    """预分配校验：一次性提交 mb MB（分块持有后整体释放），成功返回 True。
+
+    为什么要"预分配"而不是只读 ullAvailPhys：可用物理内存含大量**可回收**的
+    缓存页/其他进程随时会吃掉的余量，只按它决策会出现"这一秒够、真跑起来不够"
+    的波动（编译时间在 400s / 1180s 两档之间随机跳的直接来源）。先真正把预算
+    拿到手（页级提交）再放掉，等于向 OS 确认过这笔预算确实可分配。
+    """
+    if mb <= 0:
+        return True
+    Bufs = []
+    Left = mb
+    try:
+        while Left > 0:
+            Cur = min(_MEM_PROBE_CHUNK_MB, Left)
+            Bufs.append(bytearray(Cur * 1024 * 1024))
+            Left -= Cur
+        return True
+    except MemoryError:
+        return False
+    finally:
+        del Bufs
+
+
+def _PickWorkerCount(n_files: int, per_worker_mb: int = 350) -> int:
+    """并行 worker 数的**唯一**决策入口（CPU 上限 + 内存预分配双约束）。
+
+    口径（用户 2026-10-01 定，取代旧"内存紧就降级串行"）：
+      1. **不降级**：内存不足**绝不**静默退回单 worker 串行 —— 旧实现 `by_mem =
+         max(1, avail_mb // per_worker_mb)` 在可用内存稍紧时就整体降为串行，
+         同一条命令 76 文件逐个翻译 1180s、并行 ~400s，时间随机跳 2-3 倍
+         （profile 实证：224857 那次主进程 0 次 _translate_file＝并行，438s；
+          231916/235354 两次主进程 75 次 _translate_file＝串行，1048s/1168s）。
+      2. **预分配 + 强制预留**：先按 base×per_worker_mb 做一次性提交校验
+         （_ProbeReserveMb），拿到就并行、拿不到就 fail-fast 报出"可用/需要"
+         数字，由使用者释放内存或**显式** TPC_JOBS=N 接受其它并行度。
+      3. 显式 TPC_JOBS=N 优先且跳过校验（使用者自行承担内存风险，N=1 即显式串行）。
+
+    单 worker 预估 per_worker_mb（Python 解释器 + llvmlite module + 共享符号表
+    快照）；实测翻译阶段 worker 稳态 ~110MB、峰值 ~300MB，故取 350（编译阶段
+    调用方传 400）。Windows 用 GlobalMemoryStatusEx 读物理内存。
+    """
+    base = min(os.cpu_count() or 4, n_files)
+    if base <= 1:
+        return base
+    env_jobs: str | None = os.environ.get(_JOBS_ENV)
+    if env_jobs:
+        try:
+            want = int(env_jobs)
+        except ValueError:
+            want = base
+        want = max(1, min(want, base))
+        _vlog().info(
+            f"  [并行] {_JOBS_ENV}={env_jobs} → workers={want}"
+            f"（显式指定，跳过内存校验与预分配）")
+        return want
+    avail_mb, total_mb = _MemStatus()
+    need_mb = base * per_worker_mb
+    if avail_mb < 0:
+        # 读不到内存信息：不阻塞编译（按 CPU 上限并行），但必须显式告知
+        _vlog().warning(
+            f"  [并行] 无法读取物理内存状态，按 CPU 上限取 workers={base}"
+            f"（预算 {need_mb}MB）")
+        return base
+    if avail_mb < need_mb:
+        # 不降级：报数字 + 两条出路（释放内存 / 显式 TPC_JOBS=N）
+        raise RuntimeError(
+            f"[并行翻译] 内存不足，拒绝降级为串行（串行会让编译时间从 ~400s 掉到 ~1180s 档）："
+            f"需要预留 {need_mb}MB（{base} worker × {per_worker_mb}MB），"
+            f"当前可用 {avail_mb}MB / 总量 {total_mb}MB。"
+            f"请释放内存后重跑；若确实要少开 worker（含串行），显式设 {_JOBS_ENV}=N 重跑。")
+    if need_mb not in _MemProbeDone:
+        _t0: float = _time.time()
+        if not _ProbeReserveMb(need_mb):
+            raise RuntimeError(
+                f"[并行翻译] 预分配校验失败：无法一次性提交 {need_mb}MB"
+                f"（{base} worker × {per_worker_mb}MB；可用显示 {avail_mb}MB / 总量 {total_mb}MB）。"
+                f"请释放内存后重跑；若确实要少开 worker（含串行），显式设 {_JOBS_ENV}=N 重跑。")
+        _MemProbeDone.add(need_mb)
+        _vlog().info(
+            f"  [并行] 预分配校验通过：{need_mb}MB 可一次性提交"
+            f"（{_time.time() - _t0:.2f}s，已释放待 worker 进程复用）")
+    _vlog().info(
+        f"  [并行] workers={base}（预算 {need_mb}MB ≤ 可用 {avail_mb}MB / 总量 {total_mb}MB）")
     return base