atlas-project-harness 0.2.0-beta.2 → 0.2.0-beta.21

package/validators/validate_adr.py

@@ -2,11 +2,12 @@
 """atlas 校验器 —— 架构决策记录（ADR）长效资产守卫（2026-10-13）。
 
 守一件事：
-  项目级长效架构决策唯一落地于 `product/adr/NNNN-<slug>.md`。
+  项目级长效架构决策唯一落地于 `资产根/adr/NNNN-<slug>.md`（资产根默认 `product/`，
+  由项目根 `atlas.config.yaml` 的 `layout.assets_root` 解析）。
   规范文档形态，保障状态合法性、决策确定性与版本演进追溯。
 
 判定（三态 + WARN）：
-  - 无 `product/adr/` 目录或目录为空 ⇒ SKIP（尚未创建任何 ADR，非失败）。
+  - 无 `资产根/adr/` 目录或目录为空 ⇒ SKIP（尚未创建任何 ADR，非失败）。
   - 有 ADR 文件：
       * 编号唯一：无同号异名冲突（0001-foo ⇔ 0001-bar）。
       * Frontmatter 合法：status 必须属于 {proposed, accepted, superseded, deprecated}。
@@ -30,7 +31,10 @@ import re
 import sys
 from pathlib import Path
 
-ADR_DIR_RELPATH = Path("product") / "adr"
+if str(Path(__file__).resolve().parents[1]) not in sys.path:
+    sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+from _support.layout import LayoutError, load_layout  # noqa: E402
+
 ADR_FILENAME_PATTERN = re.compile(r"^(\d{4})-[a-z0-9_-]+\.md$", re.IGNORECASE)
 VALID_STATUSES = {"proposed", "accepted", "superseded", "deprecated"}
 
@@ -89,10 +93,16 @@ def extract_section(text: str, section_kw: str) -> str | None:
 
 def validate_adr(root: Path) -> Result:
     res = Result()
-    adr_dir = root / ADR_DIR_RELPATH
+    try:
+        lay = load_layout(root)
+    except LayoutError as exc:
+        res.add("项目布局配置", "FAIL", str(exc))
+        return res
+    adr_dir = lay.adr_dir
 
     if not adr_dir.exists() or not adr_dir.is_dir():
-        res.add("adr_dir_exists", "SKIP", f"前置未声明（未就绪，非失败）：无 {ADR_DIR_RELPATH}/")
+        res.add("adr_dir_exists", "SKIP",
+                f"前置未声明（未就绪，非失败）：无 {lay.print_value('adr')}/")
         return res
 
     files = [f for f in adr_dir.iterdir() if f.is_file() and not f.name.startswith(".")]

package/validators/validate_design_exemptions.py

@@ -3,7 +3,8 @@
 
 守一件事（机器对账取代 prose 约定）：
 
-  `product/design.md`（视觉设计档案，frontend-design skill 写、atlas 只读）里
+  `资产根/design.md`（资产根默认 `product/`，由项目根 `atlas.config.yaml` 解析；
+  视觉设计档案，frontend-design skill 写、atlas 只读）里
   「已有豁免」中的 detect 类豁免写作 `detect:<rule-id>`；同一组 rule id 必须
   出现在项目根 `.impeccable/config.json` 的 `detector.ignoreRules` —— **双向
   集合相等**。
@@ -13,7 +14,7 @@
   单侧缺失 = 报警关了没人知道为什么（缺台账），或台账说关了其实没关（缺配置）。
 
 判定（三态，`§B120`）：
-  - 无 `product/design.md` ⇒ **SKIP**（档案未建 = 未就绪，不是失败）。
+  - 无 `资产根/design.md` ⇒ **SKIP**（档案未建 = 未就绪，不是失败）。
   - 档案 `detect:<id>` 集合 ⇔ 配置 `detector.ignoreRules` 集合相等 ⇒ PASS
     （两侧皆空是合法退化态）。
   - 任一侧多出 ⇒ FAIL，双向差集指名。
@@ -38,7 +39,10 @@ import re
 import sys
 from pathlib import Path
 
-DESIGN_RELPATH = Path("product") / "design.md"
+if str(Path(__file__).resolve().parents[1]) not in sys.path:
+    sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+from _support.layout import LayoutError, load_layout  # noqa: E402
+
 CONFIG_RELPATH = Path(".impeccable") / "config.json"
 DETECT_TOKEN = re.compile(r"detect:([A-Za-z0-9][A-Za-z0-9_-]*)")
 
@@ -87,12 +91,17 @@ def config_ignore_rules(cfg_path: Path) -> set[str]:
 
 def run(root: Path) -> Result:
     res = Result()
-    design = root / DESIGN_RELPATH
+    try:
+        lay = load_layout(root)
+    except LayoutError as exc:
+        res.add("项目布局配置", "FAIL", str(exc))
+        return res
+    design = lay.design
     if not design.is_file():
         res.add("设计档案存在", "SKIP",
-                "无 product/design.md（档案未建，未就绪非失败）")
+                f"无 {lay.print_value('design')}（档案未建，未就绪非失败）")
         return res
-    res.add("设计档案存在", "PASS", DESIGN_RELPATH.as_posix())
+    res.add("设计档案存在", "PASS", lay.print_value("design"))
 
     ids = design_detect_ids(design.read_text(encoding="utf-8", errors="replace"))
     cfg = root / CONFIG_RELPATH

package/validators/validate_e2e_index.py

@@ -40,6 +40,10 @@ import re
 import sys
 from pathlib import Path
 
+if str(Path(__file__).resolve().parents[1]) not in sys.path:
+    sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+from _support.layout import LayoutError, load_layout  # noqa: E402
+
 
 def _format_list(items: list[str], max_show: int = 20) -> str:
     if not items:
@@ -61,6 +65,9 @@ url_merge = load_module("url_merge")
 # 用例 ID 文法体单源（正文归 rings/e2e/reference.md §5.3；锚点本处自留）
 case_id = load_module("case_id")
 stack_profile = load_module("stack_profile")
+# 维度 token 单源（D153）：区间展开 / 中文邻接 / 疑似写法出声归 `_support/ac_coverage.py`。
+ac_coverage = load_module("ac_coverage")
+parse_dims_cell = ac_coverage.parse_dims_cell
 # 契约 §5.5（2026-10-16，issue #R1/#R3）：行内注释剥除口径与内核**同一函数对象**（I3）——
 # 剥注释口径**全域单源**（`_support/stack_profile.strip_inline_comment`，2026-10-17 D104 ⑦ 清偿）：
 # `_code()` 是该口径在本文件的唯一出口，本文件内**不得**再出现 `split("#", 1)[0]`（MB8 钉守着）。
@@ -102,8 +109,8 @@ REFRESH_WORDS = ("刷新", "reload", "refresh")
 I18N_HINTS = (re.compile(r"\bt\("), re.compile(r"\b[a-z]+\.[a-z]+\.[a-z]+\b"), re.compile(r"\b[A-Z]{2,}_[A-Z_]+\b"))
 
 # 分片 step / expected 的动词词表（契约 `rings/e2e/reference.md` §5.5，2026-09-23 定）
-ACTION_VERBS = ("click", "fill", "select", "check", "uncheck", "press", "hover", "refresh", "goto", "waitFor", "download", "upload", "dispatch")
-ASSERT_VERBS = ("text", "contains", "count", "countOptions", "visible", "hidden", "enabled", "disabled", "checked", "unchecked", "value", "attr", "delta")
+ACTION_VERBS = ("click", "fill", "select", "check", "uncheck", "press", "type", "hover", "refresh", "goto", "waitFor", "download", "upload", "dispatch")
+ASSERT_VERBS = ("text", "contains", "count", "countOptions", "visible", "hidden", "enabled", "disabled", "checked", "unchecked", "value", "attr", "delta", "request")
 # 契约 §5.6 R9：`expected` 行可加**行首前缀**，显式声明该断言的判据形状。
 # 本校验器只负责**形态项**（前缀后是词表内的动词 / 不嵌套 / `unchanged:` 的用例有提交性动作）；
 # **不判**断言是否空转，也不判初始态成不成立（那是运行期零步基线的职责，§6.0 C-new）。
@@ -264,10 +271,11 @@ def seed_models_check(root: Path, blocks: dict[str, dict]) -> tuple[str, str]:
         ("PASS", f"{len(seeds)} 条用例的 seed 与 {len(models)} 个表/模型对账通过")
 
 
-def upload_fixture_check(root: Path, blocks: dict[str, dict]) -> tuple[str, str]:
+def upload_fixture_check(root: Path, blocks: dict[str, dict], lay=None) -> tuple[str, str]:
     """`upload` 行的 fixture 引用闭环（契约 §5.5，B201-1，2026-10-12）。
 
-    值 = 相对 `product/e2e/fixtures/` 的文件路径（与 §5.8 mock 同基线、同一 fixtures 树）。
+    值 = 相对 `<资产根>/e2e/fixtures/` 的文件路径（资产根默认 `product/`；
+    与 §5.8 mock 同基线、同一 fixtures 树）。
     判据（结构门）：**值形态**（非空 / 非绝对路径 / 无 `..` 段）+ **文件存在**。无用例声明
     `upload` ⇒ PASS（空集合法，N/A 不是通过的反面——空集就是合法形态）。生成器侧生成期
     同款检查（缺 ⇒ exit 2 列明）——两侧同步，防「校验器放行、生成器认不得」的半通状态。
@@ -280,7 +288,7 @@ def upload_fixture_check(root: Path, blocks: dict[str, dict]) -> tuple[str, str]
                 uploads.append((cid, parts[2].strip() if len(parts) > 2 else ""))
     if not uploads:
         return "PASS", "无用例声明 `upload`（可选动作词）"
-    fixtures = root / "product" / "e2e" / "fixtures"
+    fixtures = (lay or load_layout(root)).e2e_fixtures_dir
     bad: list[str] = []
     for cid, rel in uploads:
         if not rel:
@@ -334,7 +342,12 @@ def _route_hit(p: str, page_routes) -> bool:
 
 def validate(root: Path) -> Result:
     res = Result()
-    e2e = root / "product" / "e2e"
+    try:
+        lay = load_layout(root)
+    except LayoutError as exc:
+        res.add("项目布局配置", "FAIL", str(exc))
+        return res
+    e2e = lay.e2e_dir
     index = e2e / "e2e-index.md"
     cases = e2e / "cases"
     shard_files = sorted(cases.glob("*.md")) if cases.is_dir() else []
@@ -444,7 +457,7 @@ def validate(root: Path) -> Result:
         res.add("页面表合法", "PASS" if not page_bad2 else "FAIL",
                 f"路由非/开头或重复={page_bad2[:8]}" if page_bad2 else "")
     if known is None:
-        known = {md.stem for md in (root / "product" / "e2e" / "cases").glob("*.md")}
+        known = {md.stem for md in lay.e2e_cases_dir.glob("*.md")}
         res.add("页面表合法", "WARN", "索引无页面表（E1 起应有；暂按分片文件名推导页清单）")
     if known is not None and page_rows:
         miss = sorted({g["页面"] for g in grid} - known)
@@ -505,7 +518,7 @@ def validate(root: Path) -> Result:
     # 关联AC
     ac_bad = [g["用例ID"] for g in grid if not AC_RE.match(g["关联AC"])]
     res.add("关联AC 格式", "PASS" if not ac_bad else "FAIL", f"{ac_bad[:8]}")
-    prd_files = sorted((root / "product" / "prd").glob("*-prd.md")) if (root / "product" / "prd").is_dir() else []
+    prd_files = sorted(lay.prd_dir.glob("*-prd.md")) if lay.prd_dir.is_dir() else []
     if not prd_files:
         res.add("关联AC 可达", "N/A", "门控态：无域级 PRD")
     else:
@@ -583,34 +596,13 @@ def validate(root: Path) -> Result:
                 (detail + "；残留待裁决（清零后升 FAIL，规则在 shared/gates.md §3 AC⇔用例行）")
                 if gaps else detail)
 
-    # AC × 覆盖维度（D130，2026-10-21）：
-    # 检验已在域级 PRD 声明适用维度的 AC，其 E2E 用例是否覆盖了声明的维度（C01-C14 前端裁剪版）。
-    # 仅对已实现域且已有用例挂靠的 AC 计算；未声明适用维度的项目按 N/A 兜底，不报假缺口。
-    # 解析口径（评审 Minor 修正）：① `\b` 对 CJK 邻接失效（「C01正常流」不命中）⇒ 改前后界定符；
-    # ② 「C01-C03」区间须展开（否则只命中两端、中间维度被误报缺口）；③ 不做「含『维度』二字即跳过」
-    # 的粗暴表头过滤（会误杀「C13 状态维度」这类数据行）——表头/分隔行首格不是 AC 形态，天然不被外层正则命中。
-    _DIM_TOKEN = r"C(?:0[1-9]|1[0-4])"
-    _dim_range_re = re.compile(rf"(?<![0-9A-Za-z])({_DIM_TOKEN})\s*[-~至]\s*({_DIM_TOKEN})(?![0-9])")
-    _dim_code_re = re.compile(rf"(?<![0-9A-Za-z]){_DIM_TOKEN}(?![0-9])")
-    _dim_looks_re = re.compile(r"[Cc]\d{1,2}")
-
-    def _parse_dims(raw) -> tuple[set[str], bool]:
-        """覆盖维度文本 → (命中维度集合, 是否含疑似维度写法)。区间展开、中文邻接可命中。"""
-        text = str(raw or "")
-        dims: set[str] = set()
-        for m in _dim_range_re.finditer(text):
-            lo, hi = int(m.group(1)[1:]), int(m.group(2)[1:])
-            if lo > hi:
-                lo, hi = hi, lo
-            dims |= {f"C{i:02d}" for i in range(lo, hi + 1)}
-        dims |= set(_dim_code_re.findall(text))
-        return dims, bool(_dim_looks_re.search(text))
-
+    # 解析口径归 `_support/ac_coverage.py::parse_dims_cell`（D153 单源，行为与 D130 逐字节一致）：
+    # 区间展开、中文邻接、疑似写法出声；本文件不再自持第二份 parser。
     declared_ac_dims: dict[str, set[str]] = {}
     for p in prd_files:
         seg = p.read_text(encoding="utf-8")
         for m in re.finditer(r"^\|\s*`?(AC-[A-Z0-9]+-\d{3})`?\s*\|[^|\n]*\|[^|\n]*\|([^|\n]+)\|", seg, re.M):
-            dims, _looks = _parse_dims(m.group(2))
+            dims, _looks = parse_dims_cell(m.group(2))
             if dims:
                 declared_ac_dims[m.group(1)] = dims
 
@@ -621,7 +613,7 @@ def validate(root: Path) -> Result:
         acid = g["关联AC"]
         blk = blocks.get(cid, {})
         for d_str in (blk.get("覆盖维度") or []):
-            found, looks = _parse_dims(d_str)
+            found, looks = parse_dims_cell(d_str)
             if not found and looks:
                 bad_case_dims.append(f"{cid}:{d_str}")
             covered_ac_dims.setdefault(acid, set()).update(found)
@@ -683,6 +675,7 @@ def validate(root: Path) -> Result:
     verb_bad, assert_bad, goto_param, contradict = [], [], [], []
     goto_path: list[str] = []
     auth_bad: list[str] = []
+    target_bad: list[str] = []   # `靶场:` 取值不在 `e2e.targets` 闭集内（多靶场，beta.16）
     guard_bad: list[str] = []
     session_bad: list[str] = []
     switch_bad: list[str] = []
@@ -697,7 +690,7 @@ def validate(root: Path) -> Result:
     # 段缺失 / keys 为空 ⇒ 该靶场不允许任何该类预设（用例出现对应行即 FAIL）。
     # `session_preset`（2026-10-16，issue #13）与 `query_preset`（2026-10-18，`DESIGN.md` D109）
     # 同族：同为**前提面**，两个载体各一段。
-    _prof_path = root / "product" / "stack-profile.yaml"
+    _prof_path = lay.stack_profile
 
     def _preset_keys(sub: str, field: str = "keys") -> set[str]:
         if not _prof_path.is_file():
@@ -714,11 +707,30 @@ def validate(root: Path) -> Result:
     _session_keys = _preset_keys("session_preset")
     _query_keys = _preset_keys("query_preset")
     _hash_query_keys = _preset_keys("query_preset", "hash_keys")
+
+    # 契约 §5.4/§5.5（多靶场，beta.16）：具名靶场登记表 `e2e.targets`（可选闭集）。
+    # 用例 `靶场:` 名字必须 ∈ 此表；表内路由与页面表路由同属「登记地址」——
+    # `goto` / `守卫` 路径门同样放行（地址仍单源于 stack-profile，不开放自由路径）。
+    def _named_targets() -> dict[str, str]:
+        if not _prof_path.is_file():
+            return {}
+        try:
+            cfg = stack_profile.parse_profile(_prof_path.read_text(encoding="utf-8")).get("e2e") or {}
+        except Exception:
+            return {}
+        t = cfg.get("targets") if isinstance(cfg, dict) else None
+        if not isinstance(t, dict):
+            return {}
+        return {str(k).strip(): str(v or "").strip() for k, v in t.items() if str(k).strip()}
+
+    _named_targets_map = _named_targets()
+    _target_routes = list(_named_targets_map.values())
     nested_prefix, unchanged_no_action = [], []
     initial_no_reason = []
     after_bad = []
     waitfor_assert = []
     delta_bad = []
+    request_bad = []
     cross_page_bad = []
     # R10 门用反查表 page_routes_map 已在页面表解析处（上方）构建
     for g in grid:
@@ -857,7 +869,8 @@ def validate(root: Path) -> Result:
             p = parts[1].strip()
             # 契约 §5.5（2026-10-18，D109 / 2026-10-22 hash 查询）：`goto` 可带常规查询与
             # hash 查询 ⇒ 路径门按**去双查询后的路径形态**匹配（`_route_hit` 内部同口径）。
-            if _route_hit(p, page_routes):
+            # 契约 §5.4/§5.5（多靶场，beta.16）：已登记靶场路由同属「登记地址」，同门放行。
+            if _route_hit(p, page_routes) or _route_hit(p, _target_routes):
                 continue
             goto_path.append(f"{g['用例ID']}:{p}")
         # 契约 §5.7（2026-09-30 补）：`auth` 取值白名单（preset | none）——文本期挡住，
@@ -865,6 +878,11 @@ def validate(root: Path) -> Result:
         auth = d.get("auth", "preset")
         if auth not in ("preset", "none"):
             auth_bad.append(f"{g['用例ID']}:auth={auth}")
+        # 契约 §5.4/§5.5（多靶场，beta.16）：`靶场:` 取值闭集 —— 名字必须 ∈ `e2e.targets`；
+        # 整段未声明而用例钉名 ⇒ FAIL（与生成器中止双保险，不猜）。
+        _target_decl = d.get("靶场")
+        if isinstance(_target_decl, str) and _target_decl.strip() and _target_decl.strip() not in _named_targets_map:
+            target_bad.append(f"{g['用例ID']}:{_target_decl.strip()}")
         # 契约 §5.5（2026-10-16 补，issue #13）：`会话:` 行形态 + 键白名单。
         # 与生成器中止**双保险**（文本期挡 + 生成期中止）：白名单是项目级声明，
         # 防把「数据态」走私成会话参数（§5.7 禁令不破）。
@@ -898,7 +916,8 @@ def validate(root: Path) -> Result:
             # 出现绕过 `parse_block` 的带注释原始值（上游 F1 之后端到端已造不出污染值），
             # 本门也不把注释当路径。与 `goto` 门 / `会话` 门共用同一 `strip_inline_comment`。
             _guard_path = strip_inline_comment(_guard).strip()
-            if page_routes and not _route_hit(_guard_path, page_routes):
+            # 契约 §5.4/§5.5（多靶场，beta.16）：已登记靶场路由同属「登记地址」，同门放行。
+            if page_routes and not _route_hit(_guard_path, page_routes) and not _route_hit(_guard_path, _target_routes):
                 guard_bad.append(f"{g['用例ID']}:{_guard_path}")
 
         # 契约 §5.6 R7（2026-09-23 补；**2026-09-25 修正为真矛盾对**）：同一条用例内，对同一
@@ -919,7 +938,7 @@ def validate(root: Path) -> Result:
         for raw in raw_exp:
             e = _strip_prefix(raw)
             bits = _code(e).split(" ")
-            if len(bits) >= 2 and bits[0] in ASSERT_VERBS:
+            if len(bits) >= 2 and bits[0] in ASSERT_VERBS and bits[0] != "request":
                 verbs_by_slice.setdefault((_step_anchor(raw), bits[1]), set()).add(bits[0])
         for (slice_n, tid), verbs in verbs_by_slice.items():
             where = f"{g['用例ID']}:{tid}" + (f"@after:{slice_n}" if slice_n else "")
@@ -950,6 +969,26 @@ def validate(root: Path) -> Result:
             m_anchor = AFTER_RE.match(raw.lstrip())
             if m_anchor is not None or (m_anchor.group(2) if m_anchor else raw).lstrip().startswith(LINE_PREFIXES):
                 delta_bad.append(f"{g['用例ID']}:叠写")
+        # D142：`request <api> <json-path> <expected>` 形态门。三态缺席语义、api 后缀、
+        # 必须有 step（动作锚点）；`(空)` 因无法区分「缺失 / null」而拒绝。
+        for raw in raw_exp:
+            has_kind = raw.lstrip().startswith(LINE_PREFIXES)
+            code = _code(_strip_prefix(raw))
+            if not code.startswith("request "):
+                continue
+            mreq = re.match(r"^request\s+(\S+)\s+(\S+)\s+(.+)$", code)
+            if not mreq:
+                request_bad.append(f"{g['用例ID']}:形态（需 request <api> <path> <expected>）")
+                continue
+            api, _path, expected = mreq.groups()
+            if has_kind:
+                request_bad.append(f"{g['用例ID']}:与 initial/unchanged 叠写")
+            if not re.fullmatch(r"[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)+", api):
+                request_bad.append(f"{g['用例ID']}:api 须为带点后缀（{api}）")
+            if expected.strip() == "(空)":
+                request_bad.append(f"{g['用例ID']}:(空) 三态不明，请用 (缺席)/null/\"\"")
+            if not step:
+                request_bad.append(f"{g['用例ID']}:无 step（动作锚点不存在）")
         # 契约 §5.6 R10（2026-10-05 补，P11）：跨页用例终态断言必须落首列页（断言落点页）。
         # 多页用例中，未加 after: 步骤锚的 expected 断言如果在非首列页上求值，会因为目标 DOM 缺失而沦为空洞真。
         pgs = d.get("pages", [])
@@ -1070,6 +1109,8 @@ def validate(root: Path) -> Result:
     res.add("守卫 路径 ∈ 页面表", "PASS" if not guard_bad else "FAIL",
             f"页面表外路径={_format_list(guard_bad)}（契约 §5.5：守卫导航用的具体路径也不得私藏于分片）" if guard_bad else "")
     res.add("auth 取值合法", "PASS" if not auth_bad else "FAIL", f"白名单外（允许 preset|none）={_format_list(auth_bad)}")
+    res.add("靶场 取值合法", "PASS" if not target_bad else "FAIL",
+            f"不在 `e2e.targets` 闭集内 / 未登记即钉名={_format_list(target_bad)}（契约 §5.4/§5.5：具名靶场必须先在 stack-profile 登记）" if target_bad else "")
     res.add("会话 取值合法", "PASS" if not session_bad else "FAIL",
             f"形态非法 / 白名单外={_format_list(session_bad)}（契约 §5.5：键须在 `e2e.session_preset.keys` 内）" if session_bad else "")
     res.add("参数 声明有效", "PASS" if not inject_bad else "FAIL",
@@ -1093,6 +1134,8 @@ def validate(root: Path) -> Result:
             f"`waitFor` 出现在 expected（应写在 step）= {_format_list(waitfor_assert)}")
     res.add("delta 相对断言形态", "PASS" if not delta_bad else "FAIL",
             f"`delta` 值须为 `±N` 且不得与豁免通道/步骤锚叠写 = {_format_list(delta_bad)}")
+    res.add("request 断言形态", "PASS" if not request_bad else "FAIL",
+            f"`request` 需 api 带点后缀 + json-path + 三态值，且必须有 step = {_format_list(request_bad)}")
     res.add("豁免前缀不嵌套", "PASS" if not nested_prefix else "FAIL", f"{_format_list(nested_prefix)}")
     res.add("步骤锚合法", "PASS" if not after_bad else "FAIL", f"{_format_list(after_bad)}")
     res.add("跨页终态断言落首列页", "PASS" if not cross_page_bad else "FAIL", f"{_format_list(cross_page_bad)}")
@@ -1112,8 +1155,36 @@ def validate(root: Path) -> Result:
     _lvl, _det = seed_models_check(root, blocks)
     res.add("seed × models 对账", _lvl, _det)
     # 契约 §5.5（B201-1，2026-10-12）：upload 行的 fixture 引用存在（值形态 + 文件存在）
-    _lvl, _det = upload_fixture_check(root, blocks)
+    _lvl, _det = upload_fixture_check(root, blocks, lay)
     res.add("upload fixture 引用存在", _lvl, _det)
+    # D143：manual.md 旧行 + `atlas-manual` 块（解析单源 `_support/manual_block.py`）
+    manual_path = e2e / "manual.md"
+    if not manual_path.is_file():
+        res.add("manual 走查项形态", "N/A", "无 manual.md（可选增强）")
+    else:
+        try:
+            from _support.manual_block import parse_manual
+            manual_items = parse_manual(manual_path.read_text(encoding="utf-8"))
+        except Exception as exc:  # 坏块必须响亮失败，不得静默忽略
+            res.add("manual 走查项形态", "FAIL", f"解析失败：{exc}")
+        else:
+            manual_bad: list[str] = []
+            seen_ids: set[str] = set()
+            for m in manual_items:
+                mid = m.get("id") or ""
+                if not mid:
+                    manual_bad.append("缺 ID")
+                elif mid in seen_ids:
+                    manual_bad.append(f"{mid}:ID 重复")
+                seen_ids.add(mid)
+                if m.get("page") not in known:
+                    manual_bad.append(f"{mid}:页面不在页面表（{m.get('page')}）")
+                steps = m.get("steps") or []
+                for i, s in enumerate(steps, 1):
+                    if not s.get("action") or not s.get("expect"):
+                        manual_bad.append(f"{mid}:步骤{i} 缺操作/观察")
+            res.add("manual 走查项形态", "PASS" if not manual_bad else "FAIL",
+                    f"{_format_list(manual_bad)}" if manual_bad else "")
     return res
 
 

package/validators/validate_e2e_mocks.py

@@ -39,6 +39,7 @@ HERE = Path(__file__).resolve().parent
 if str(HERE.parent) not in sys.path:
     sys.path.insert(0, str(HERE.parent))
 from _support.siblings import load_module  # noqa: E402
+from _support.layout import LayoutError, load_layout  # noqa: E402
 
 
 class Result:
@@ -152,15 +153,21 @@ def mock_after_step_violations(text: str, case_block_re, list_keys: set[str]) ->
 
 def validate(root: Path) -> Result:
     res = Result()
-    e2e_dir = root / "product" / "e2e"
+    try:
+        lay = load_layout(root)
+    except LayoutError as exc:
+        res.add("项目布局配置", "FAIL", str(exc))
+        return res
+    e2e_dir = lay.e2e_dir
     cases_dir = e2e_dir / "cases"
     index = e2e_dir / "e2e-index.md"
     if not index.is_file() or not cases_dir.is_dir():
-        res.add("mock 门前置", "N/A", "E2E 用例资产未建（缺 product/e2e/e2e-index.md 或 cases/）")
+        res.add("mock 门前置", "N/A",
+                f"E2E 用例资产未建（缺 {lay.print_value('e2e')}/e2e-index.md 或 cases/）")
         return res
 
     gen = load_generator()
-    prof_path = root / "product" / "stack-profile.yaml"
+    prof_path = lay.stack_profile
     e2e_cfg: dict = {}
     if prof_path.is_file():
         e2e_cfg = gen.parse_profile(prof_path.read_text(encoding="utf-8")).get("e2e") or {}
@@ -175,7 +182,7 @@ def validate(root: Path) -> Result:
     raw_prefix = mock_cfg.get("api_prefix")
     prefix = raw_prefix if raw_prefix is not None else ("/" if mode in ("on", "auto") else None)
 
-    shards = gen.gather_cases(cases_dir)
+    shards = gen.gather_cases(cases_dir, lay.print_value("e2e_cases"))
     mock_pages = sorted(p for p, items in shards.items() if any(c.get("mock") for c in items))
     mock_case_ids = [c["id"] for items in shards.values() for c in items if c.get("mock")]
 
@@ -237,7 +244,7 @@ def validate(root: Path) -> Result:
 
     missing = sorted({r for r in refs if not _resolve_fixture(r).is_file()})
     res.add("fixture 引用存在", "PASS" if not missing else "FAIL",
-            f"缺={missing[:8]}（引用相对 product/e2e/，须以 fixtures/ 开头）")
+            f"缺={missing[:8]}（引用相对 {lay.print_value('e2e')}/，须以 fixtures/ 开头）")
     if fixtures_root.is_dir():
         on_disk = sorted("fixtures/" + p.relative_to(fixtures_root).as_posix()
                          for p in fixtures_root.glob("**/*.json"))