@@ -429,16 +429,21 @@ x 必须为正。因阈值停下的调用（`stop_reason="max_budget"`）→ `Mo
   与时钟无关（沿 first-parent 的提交时间不一定递减：过期的提交跳过而不是就此停止；路径用 `-z` 读取，非 ASCII 文件名不被
   引号转义）；合并/squash 式默认分支上每个 first-parent 提交就是一个合入的 PR。这就是设计 §7.3 的 PR 窗口，从镜像离线
   读取（不走 GitHub API，没有速率限制）。
-- `init_deepen`（阶段 3）：按窗口内源文件改动数（`make_include`：源根、`exclude`、语言后缀）给模块排序，从高到低：没有路由
-  的模块跳过（记入 notes）；模块的 owner 是以**最具体**方式（`most_specific`）拥有其文件最多的 owner——同时也覆盖它的更宽
-  owner 从不拿走组件的规则；该 owner 已承载规则的模块跳过（对指标无增益）——owner **承载规则**指 owner 页本身有生效规则，
-  或（仅当 owner 是入口页/prose 页时）**同一目录**下有含生效规则的页（不看子目录，否则任何组件有了规则仓库入口就算承载；
-  owner 本身是规则页却没有生效规则时不承载，不看兄弟页）。其余模块每个
-  一次生成调用：模块代码带行号、字节上限（这是深度阶段，读代码本身），产出带行范围证据的规则 → 证据必须在本模块文件内 →
-  共用筛查（D5、钉点证据与声明、落位、咨询性判定）→ 经 `ops.apply_operations` 追加到 owner 的规则页（owner 页本身是规则页
-  时用它，否则用旁边的 `rules.md`；已有规则只追加、不修改，满页转兄弟页）。每写完一个模块重算承载规则的 PR 加权覆盖率，
-  达到 `coverage_target`、预算用完或热模块用尽即停。报告：路由/承载规则两种覆盖率的 before/after、窗口 PR 数、仍无规则的热路径（`uncovered_hot`：没有承载规则的 owner 到达的
-  源文件（按最具体 owner 判断），包括已路由但 owner 无规则的；`unrouted_hot` 另列完全无路由的）。
+- `init_deepen`（阶段 3）：工作单位是**组**——一个模块里最具体 owner（`most_specific`，并列时取路由顺序第一个）相同的
+  文件（`_groups`）。所以一个模块的文件分属多个 owner 时，每个 owner 各深化一次，热文件不会因为它所在模块的多数 owner
+  已有规则而被漏掉（afd-plugin 试点：`attention_model_runner.py` 等热文件的最具体 owner 与模块多数 owner 不同，按模块
+  循环永远到不了它们）。组按窗口内这些文件的改动数（`make_include`：源根、`exclude`、语言后缀）降序（同数按模块、owner）：
+  没有路由的热文件记入 notes（前 5 个）；owner 已承载规则的组跳过（对指标无增益，计数记入 notes）——owner **承载规则**指
+  owner 页本身有生效规则，或（仅当 owner 是入口页/prose 页时）**同一目录**下有含生效规则的页（不看子目录，否则任何组件
+  有了规则仓库入口就算承载；owner 本身是规则页却没有生效规则时不承载，不看兄弟页）。其余组每个一次生成调用：只给**该组**
+  的文件（带行号、字节上限；这是深度阶段，读代码本身），产出带行范围证据的规则 → 证据必须在本组文件内 → 共用筛查（D5、
+  钉点证据与声明、落位、咨询性判定）→ 经 `ops.apply_operations` 追加到 owner 的规则页（owner 页本身是规则页时用它，否则用
+  旁边的 `rules.md`；已有规则只追加、不修改，满页转兄弟页）。每写完一组重算承载规则的 PR 加权覆盖率，达到
+  `coverage_target`、预算用完或热组用尽即停，并**总是**在 notes（因而在 PR 正文）里写一条 `deepen stopped: …`：达到目标；
+  预算用完（剩余组进 `unfinished`，标 `module <m> (owner <o>)`）；或“每个热组都已访问；未达目标（X% < Y%）”——低于目标时
+  附上仍无规则的最热文件（前 5 个）。低于目标从不静默结束。报告：路由/承载规则两种覆盖率的 before/after、窗口 PR 数、仍无
+  规则的热路径（`uncovered_hot`：最具体 owner 不承载规则的源文件，包括已路由但 owner 无规则的；`unrouted_hot` 另列完全
+  无路由的）。
 - 同一 PR 打开 shadow：`flip_to_shadow` 对 adapter manifest 做**文本**编辑，只改 `knowledge_lifecycle` 块里同缩进的
   `enabled`（→ `true`，缺失则插在块头下）与 `mode`（→ `shadow`）两行，注释、顺序与其他行逐字保留；没有该块 → 在任何模型调用
   之前 `blocked`。`_check_flip` 校验：只能改这一个 manifest，`check_flip_to_shadow`（除这两个键外解析值不变、head 开启且为
 
@@ -3,18 +3,23 @@
 
 Depth pass. The PR window is the pin's own first-parent history (bounded by
 ``init.pr_window_count`` / ``pr_window_max_age_days``, measured from the
-pin's commit time). Modules are taken by churn in that window, highest first;
-a module's owner is the one that owns most of its files MOST SPECIFICALLY
-(``init_coverage.most_specific``: a catch-all prefix never wins over a
-component's), and a module whose owner already bears rules is skipped (it adds
-nothing to the metric). For each other module one generator call reads its code at the
-pin (byte-bounded, with line numbers) and proposes rules with line-ranged
-evidence; the rules go through the shared screening — the docs redundancy
-filter (D5), evidence inside the module, pinned claims, placement, the
-advisory judge — and are appended to the owner's rule page (never editing an
-existing rule; a full page spills to a sibling). The pass stops when the
-rule-bearing PR-weighted coverage reaches ``init.coverage_target``, the budget
-runs out, or no hot module is left.
+pin's commit time). The unit of work is a GROUP: the files of one module that
+share one most specific owner (``init_coverage.most_specific``: a catch-all
+prefix never wins over a component's), so a module whose files belong to
+several owners is deepened once per owner — a hot file is never left behind
+because its module's majority owner already has rules. Groups are taken by
+churn in the window, highest first; a group whose owner already bears rules is
+skipped (it adds nothing to the metric). For each other group one generator
+call reads the group's code at the pin (byte-bounded, with line numbers) and
+proposes rules with line-ranged evidence; the rules go through the shared
+screening — the docs redundancy filter (D5), evidence inside the group's
+files, pinned claims, placement, the advisory judge — and are appended to the
+owner's rule page (never editing an existing rule; a full page spills to a
+sibling). The pass stops when the rule-bearing PR-weighted coverage reaches
+``init.coverage_target``, the budget runs out, or no hot group is left, and it
+always says which in the record's notes (and so the PR body): a pass never
+ends below the target without the reason and the hottest files still
+without rules.
 
 The same PR turns the repository's knowledge service on in shadow mode: a
 textual edit of exactly the ``enabled`` / ``mode`` lines of the adapter's
@@ -42,6 +47,7 @@
 MAX_CODE_BYTES = 100_000
 MAX_CODE_FILES = 60
 MAX_HOT_LIST = 30
+MAX_STOP_FILES = 5
 _HEADER = re.compile(r"^knowledge_lifecycle:\s*(?:#.*)?$")
 _KEY_LINE = re.compile(r"^(?P<indent>[ \t]+)(?P<key>enabled|mode):(?P<space>[ \t]*)(?P<value>[^#\n]*?)"
                        r"(?P<comment>[ \t]+#[^\n]*)?(?P<eol>\r?\n?)$")
@@ -127,31 +133,46 @@ def _build(self, tree: Path) -> InitRecord:
                                                  max_age_days=init.pr_window_max_age_days)
         include = make_include(init.source_roots, init.exclude, suffixes(language))
         before = pr_weighted_coverage(prs, owners, include=include, rule_pages=self._rule_pages(owners))
-        churn = self._churn(prs, modules, include)
+        groups, unrouted = self._groups(prs, modules, owners, include)
+        if unrouted:
+            self.record.notes.append(f"{len(unrouted)} hot source file(s) no route reaches (modules stage), "
+                                     f"no rules: " + ", ".join(f"{p} ({n})" for p, n in unrouted[:MAX_STOP_FILES]))
         self._ids = self._id_source()
         written: dict[str, str] = {}
         evidence = []
         current = before
-        for index, (key, count) in enumerate(churn):
-            if current.rule_bearing_ratio >= init.coverage_target:
-                self.record.notes.append(f"coverage target {init.coverage_target:.0%} reached; "
-                                         f"{len(churn) - index} hot module(s) left as they are")
+        target = init.coverage_target
+        skipped = 0
+        stop = ""
+        for index, (key, owner, files, count) in enumerate(groups):
+            if current.rule_bearing_ratio >= target:
+                stop = (f"coverage target {target:.0%} reached; "
+                        f"{len(groups) - index} hot group(s) left as they are")
                 break
-            files = modules[key]["files"]
-            owner = self._owner(files, owners)
-            if owner is None:
-                self.record.notes.append(f"module {key}: no route reaches it (modules stage), no rules")
-                continue
             if owner.path in self._rule_pages(owners):
-                continue      # its owner already bears rules: nothing to add to the metric
+                skipped += 1  # its owner already bears rules: nothing to add to the metric
+                continue
             try:
                 kept = self._deepen(tree, key, files, owner)
             except BudgetExhausted as exc:
-                self.record.unfinished += [f"module {k}: {exc}" for k, _ in churn[index:]]
+                self.record.unfinished += [f"module {k} (owner {o.owner}): {exc}" for k, o, _, _ in groups[index:]]
+                stop = (f"budget exhausted with {len(groups) - index} hot group(s) left; "
+                        f"{self._short_of(current.rule_bearing_ratio, target)}")
                 break
             written.update({c.rule_id: c.section for c in kept})
             evidence += [e for c in kept for e in c.evidence]
             current = pr_weighted_coverage(prs, owners, include=include, rule_pages=self._rule_pages(owners))
+        if not stop:
+            stop = (f"coverage target {target:.0%} reached; no hot group left"
+                    if current.rule_bearing_ratio >= target
+                    else f"every hot group visited; {self._short_of(current.rule_bearing_ratio, target)}")
+        if current.rule_bearing_ratio < target:
+            hottest = self._without_rules(prs, owners, include)[:MAX_STOP_FILES]
+            if hottest:
+                stop += "; hottest files without rules: " + ", ".join(f"{p} ({n})" for p, n in hottest)
+        self.record.notes.append(f"deepen stopped: {stop}")
+        if skipped:
+            self.record.notes.append(f"{skipped} hot group(s) skipped: their owner already bears rules")
         self.record.coverage = {
             "pr_routed": {"before": round(before.routed_ratio, 4), "after": round(current.routed_ratio, 4)},
             "pr_rule_bearing": {"before": round(before.rule_bearing_ratio, 4),
@@ -168,12 +189,36 @@ def _build(self, tree: Path) -> InitRecord:
 
     # -- the window ----------------------------------------------------------------
     @staticmethod
-    def _churn(prs, modules, include) -> list[tuple[str, int]]:
-        """Modules by source-file changes in the window, highest first."""
-        from .init_coverage import churn_by_module
+    def _short_of(ratio: float, target: float) -> str:
+        return f"target not reached ({ratio:.0%} < {target:.0%})"
 
-        filtered = [[f for f in files if include(f)] for files in prs]
-        return [(k, n) for k, n in churn_by_module(filtered, modules) if n > 0]
+    @staticmethod
+    def _groups(prs, modules, owners: list[Owner], include
+                ) -> tuple[list[tuple[str, Owner, list[str], int]], list[tuple[str, int]]]:
+        """The hot groups — ``(module, owner, files, churn)`` for every module
+        and most specific owner of some of its files, churn = changes of those
+        files in the window — highest churn first (ties by module, then owner),
+        and the changed source files of modules no route reaches, by churn. A
+        file several owners own equally goes to the first in routing order."""
+        changes: Counter[str] = Counter()
+        for files in prs:
+            for path in {PurePosixPath(f.strip().strip("/")).as_posix() for f in files}:
+                if include(path):
+                    changes[path] += 1
+        grouped: dict[tuple[str, str], tuple[Owner, list[str]]] = {}
+        unrouted: Counter[str] = Counter()
+        for key in sorted(modules):
+            for path in modules[key]["files"]:
+                owner = next(iter(most_specific(path, owners)), None)
+                if owner is None:
+                    if changes[path]:
+                        unrouted[path] = changes[path]
+                    continue
+                grouped.setdefault((key, owner.owner), (owner, []))[1].append(path)
+        groups = [(key, owner, files, sum(changes[f] for f in files))
+                  for (key, _), (owner, files) in grouped.items()]
+        groups = sorted((g for g in groups if g[3] > 0), key=lambda g: (-g[3], g[0], g[1].owner))
+        return groups, sorted(unrouted.items(), key=lambda item: (-item[1], item[0]))
 
     def _without_rules(self, prs, owners: list[Owner], include) -> list[tuple[str, int]]:
         """Changed source files of the window whose most specific owners bear
@@ -186,17 +231,6 @@ def _without_rules(self, prs, owners: list[Owner], include) -> list[tuple[str, i
                     missed[path] += 1
         return sorted(missed.items(), key=lambda item: (-item[1], item[0]))
 
-    @staticmethod
-    def _owner(files: list[str], owners: list[Owner]) -> Owner | None:
-        """The owner that owns most of a module's files most specifically
-        (routing order breaks ties): a broader owner that merely also reaches
-        them never takes a component's rules."""
-        counts = {o.owner: 0 for o in owners}
-        for path in files:
-            for owner in most_specific(path, owners):
-                counts[owner.owner] += 1
-        return max((o for o in owners if counts[o.owner]), key=lambda o: counts[o.owner], default=None)
-
     # -- rule pages ------------------------------------------------------------------
     def _active_rules(self, path: str) -> int:
         text = self.head.get(path)
@@ -285,7 +319,7 @@ def validate(data: dict) -> None:
         for candidate in self._to_candidates(data, page, f"code:{key}"):
             outside = [e.get("path") for e in candidate.evidence if str(e.get("path") or "") not in inside]
             if outside:
-                self._drop(candidate, f"evidence outside module {key}: {outside}")
+                self._drop(candidate, f"evidence outside module {key}'s files owned by {owner.owner}: {outside}")
                 continue
             candidates.append(candidate)
         kept = self._screen(candidates)