@chrono-meta/fh-gate 3.0.0 → 3.1.0

package/plugins/fh-commons/skills/preprep/lane_slide_relations.py

@@ -0,0 +1,300 @@
+#!/usr/bin/env python3
+"""R1~R5 — 장 사이·장 안의 «관계» 검사 다섯. the private companion store's origin script (lane_slide_relations.py
+(2026-09-04, 실사용 하루치에서 역산)를 preprep 관례로 이식한 것 — 로직은 그대로다.
+정본: `tracks-meta/fh_signal_2026-09-04_preprep-evolution.md` §1.
+
+preprep L8(interslide) 은 «가리킨 대상이 있나»(화면 재사용 · 시각 지시)를 본다. 아래 다섯은
+그 사정거리 밖에서 실제로 놓친 결함이다(L8 HARD 목록에 그 장들이 아예 안 뜬다).
+
+  R1 orphan-connective  선두 줄이 «그러나/그래서»로 시작하는데, 그 문장의 주어가
+                        **직전 장 어디에도 없다** → 받을 말 없이 뒤집는다
+                        실사고: 40p 부제 «그러나 깃허브는 막을 자리를 줄 뿐…» (39p 에 깃허브 0회)
+
+  R2 enum-dropped       앞 장이 ①②③ 으로 센 것을, 이 장이 «이 셋 중…» 이라 부르면서
+                        **번호를 하나도 안 달았다** → 1:1 대응이 안 보인다
+                        실사고: 40p 가 38·39p 의 셋을 소유권으로 재편하며 번호를 버렸다
+                        (원장 재현 결과 41p — 표 이웃 프레임이라 쪽수가 한 칸 어긋난다)
+
+  R3 lead-term-unbacked 선두 줄이 **강조색으로 선언한 낱말**이 그 장 다른 어디에도 없다
+                        → 화면이 자기 부제를 못 받친다
+                        실사고: 20p 부제가 «방법론» 을 말하는데 장에 방법론이 없었다
+
+  R4 screen-heavy       화면 자수가 이 덱 자기 분포의 상위권 → 한 장에 너무 많이 얹었다
+  R5 read-load          **직전 장 대비 새로 뜬 글자** ÷ 발화 초 — 화면은 늘었는데 말은 짧다.
+                        🟥 대사만 줄이고 화면을 그대로 두면 이 값이 올라간다. 그게 역효과다.
+                        🟥 «새로 뜬 글자»로 재는 이유: 빌드 프레임은 앞 장에서 이미 읽은 화면이라
+                           총 자수로 재면 44p(발화 4초·화면 240자) 같은 것이 1위로 뜬다 — 오탐이다.
+                        🟥 **무대 지시**([간지]/[진행])는 발화로 세지 않는다 — 대본 자수 규칙과 같이
+                           간다. 안 빼면 Q&A·참고문헌 장이 부담 1·4위로 잘못 오른다.
+
+🟥 다섯 다 **advisory** 다. 판정은 사람이 한다. preprep 배선(`preprep.py`)은 이 레인의
+   findings 를 종료코드에 태우지 않는다 — L8·L11 과 같은 자리다.
+🟥 강조색은 덱마다 다르므로 `surfaces.yaml` 의 `slide_relations.accent` 로 받는다
+   (기본값 FAE100 — 원 코퍼스의 그 회사 옐로. 다른 덱에 옮기면 재선언해야 한다).
+
+## 🟥 R3 «조이는 과정» — 옮길 때 반드시 같이 옮겨야 하는 것 (초판이 겪은 오탐 29건의 원인)
+
+- **선두 줄 판별** — 「y 로 두 번째 도형」은 도해 라벨(「① 커밋할 때」류)을 문다.
+  ⇒ 「제목 아래 · 가로로 길게 · 한 줄」(`y < LEAD_MAX_Y` · `w > LEAD_MIN_CX` · `cy < 1.2M`)로
+  정의한다 — 아래 `Deck.lead()`.
+- **강조 비교** — 통문장 부분일치는 조사 하나로 갈린다. ⇒ **조사 벗긴 낱말 집합** 교집합으로 본다
+  (`strip_josa` + `terms`).
+- **활용 어미 제외** — 「막고 서는」·「고친 것을 되돌려서」는 낭독 리듬이지 낱말 선언이 아니다
+  (`VERBAL_END`).
+- 🟥 **전역 빈도 필터를 R3 에 걸면 안 된다** — 「방법론」처럼 덱에 흔한 낱말이 **바로 이 장에서**
+  빠지는 것이 결함인데, 흔하다는 이유로 걸러 진짜를 죽이게 된다. R3 는 「이 장 안에 있나」만 본다
+  (R2 의 `distinct()` 전역빈도 필터와는 다른 자리다 — 섞지 않는다).
+- **R2 는 세는 낱말을 «제목»에서만 찾는다** — 본문에서 찾으면 딴 「세 가지」에 물린다.
+
+## 🟥 R5 는 «신규 글자»로 재야 한다 (총량으로 재면 뒤집힌다)
+
+총 자수 기준이면 부담 1위가 **이미 앞 장에서 다 나온 빌드 프레임**으로 뒤집힌다 — 청중은 새로
+안 읽는다. 직전 장 대비 신규분(`Deck.new_chars`)으로 재야 진짜가 남는다. 그리고 무대 지시를
+발화로 세면 Q&A·참고문헌 장이 부담 상위에 잘못 오른다(`Deck.STAGE` 로 뺀다).
+
+## R4·R5 임계 — 숫자를 코드에 박지 않는다
+
+임계는 **이 덱 자기 분포**의 P90 에서 뽑는다(`statistics` + `sorted(...)[int(n*0.9)]`). 값은
+발표마다 다시 재야 한다. ⚠️ **이 레인은 게이트가 아니라 순위표다** — 정의상 늘 그 덱의 상위
+약 10%가 뜬다. 「후보 0건」을 목표로 삼지 마라.
+
+## 증거 등급 (§7, 인용 전에 읽어라)
+
+R1·R2 는 **실제 백업본**에서 뜬 결함이다. R3 는 **합성 뮤턴트**(사람이 실물 2장을 줄여 만든
+`fixtures/fixture_R3_{positive,negative}.pptx`)로만 계량됐다 — 자연 발생본이 파일로 안 남았다.
+**묶어서 「전부 실물」이라 쓰지 마라.** R4·R5 는 순위표라 known-pair 자체가 성립 형태가 다르다
+(오탐/미탐이 아니라 「1위가 진짜인가」로 잰다). reps=1, 이 저장소 자기 바(≥3) 미달.
+"""
+import zipfile, re, os
+
+CONNECTIVE = ('그러나', '하지만', '그런데', '그래서', '따라서', '그러므로', '반면')
+ENUM = ('①', '②', '③', '④', '⑤', '첫째', '둘째', '셋째')
+COUNT_WORD = re.compile(r'이\s*(셋|둘|넷|다섯)\s*중|(세|두|네|다섯)\s*가지|(셋|둘|넷)\s*중')
+# 조사·흔한 낱말은 «대상»이 못 된다
+STOP = set('것 수 때 곳 점 등 및 저희 우리 오늘 이번 발표 지금 여기 그것 이것 하나 자리 경우'.split())
+TOKEN = re.compile(r'[가-힣A-Za-z][가-힣A-Za-z0-9]{1,11}')
+JOSA = re.compile(r'(은|는|이|가|을|를|의|도|만|과|와|에|에서|으로|로|라는|처럼|보다)$')
+# 활용 어미로 끝나면 «낱말 선언»이 아니라 문장 조각이다 (「막고 서는」 · 「고친 것을 되돌려서」)
+VERBAL_END = re.compile(r'(는|은|고|서|며|야|지|다|까|나|면|아|어)$')
+
+
+def strip_josa(t):
+    for _ in range(2):
+        t2 = JOSA.sub('', t)
+        if t2 == t or len(t2) < 2:
+            break
+        t = t2
+    return t
+
+
+class Deck:
+    """pptx 를 장 단위 텍스트+위치로 읽는다. 텍스트 레이어만 본다(이미지 구운 텍스트는 안 보인다)."""
+
+    def __init__(self, path, accent='FAE100'):
+        self.z = zipfile.ZipFile(path)
+        self.accent = accent
+        rels = dict(re.findall(r'Id="([^"]+)"[^>]*Target="slides/slide(\d+)\.xml"',
+                                self.z.read('ppt/_rels/presentation.xml.rels').decode('utf-8')))
+        lst = re.search(r'<p:sldIdLst>.*?</p:sldIdLst>',
+                         self.z.read('ppt/presentation.xml').decode('utf-8'), re.S).group(0)
+        self.order = [int(rels[r]) for r in re.findall(r'<p:sldId id="\d+" r:id="([^"]+)"/>', lst)]
+        self.shapes = [self._shapes(sn) for sn in self.order]
+
+    def _shapes(self, sn):
+        x = self.z.read('ppt/slides/slide%d.xml' % sn).decode('utf-8')
+        out = []
+        for m in re.finditer(r'<p:sp>.*?</p:sp>', x, re.S):
+            b = m.group(0)
+            nm = re.search(r'name="([^"]*)"', b)
+            o = re.search(r'<a:off x="(-?\d+)" y="(-?\d+)"/><a:ext cx="(\d+)" cy="(\d+)"', b)
+            t = ' '.join(re.findall(r'<a:t>([^<]*)</a:t>', b)).strip()
+            if not t:
+                continue
+            acc = [re.sub(r'<[^>]+>', '', r) for r in re.findall(
+                r'<a:r><a:rPr[^>]*>(?:(?!</a:r>).)*?%s(?:(?!</a:r>).)*?<a:t>([^<]*)</a:t>'
+                % self.accent, b, re.S)]
+            out.append({'name': nm.group(1) if nm else '?',
+                        'y': int(o.group(2)) if o else 0,
+                        'w': int(o.group(3)) if o else 0,
+                        'cy': int(o.group(4)) if o else 0,
+                        'text': re.sub(r'\s+', ' ', t),
+                        'accent': [a.strip() for a in acc if a.strip()]})
+        return out
+
+    STAGE = ('[간지]', '[진행]', '[ 간지', '[ 진행')
+
+    def notes(self, i):
+        p = 'ppt/slides/_rels/slide%d.xml.rels' % self.order[i]
+        if p not in self.z.namelist():
+            return ''
+        m = re.search(r'notesSlide(\d+)', self.z.read(p).decode('utf-8'))
+        if not m:
+            return ''
+        return re.sub(r'\s+', ' ', ' '.join(re.findall(
+            r'<a:t>([^<]*)</a:t>',
+            self.z.read('ppt/notesSlides/notesSlide%s.xml' % m.group(1)).decode('utf-8')))).strip()
+
+    def spoken_sec(self, i):
+        """발화 초. 🟥 무대 지시([간지]·[진행])는 발화가 아니다 — 대본 자수 규칙과 같이 간다."""
+        n = self.notes(i)
+        if not n or any(n.lstrip().startswith(t) for t in self.STAGE):
+            return None
+        return round(len(re.sub(r'\s', '', n)) / 5.36)
+
+    def screen_chars(self, i):
+        return sum(len(re.sub(r'\s', '', s['text'])) for s in self.shapes[i])
+
+    def new_chars(self, i):
+        cur = {s['text'] for s in self.shapes[i]}
+        prev = {s['text'] for s in self.shapes[i - 1]} if i else set()
+        return sum(len(re.sub(r'\s', '', t)) for t in cur - prev)
+
+    def text(self, i):
+        return ' '.join(s['text'] for s in self.shapes[i])
+
+    # 선두 줄 = «제목 바로 아래에 가로로 길게 깔린 한 줄». 도해 라벨과 갈라야 한다
+    #  🟥 초판은 «y 로 두 번째 도형»이라고 했다가 도해 안 라벨(「① 커밋할 때」)을 물었다.
+    LEAD_MAX_Y, LEAD_MIN_CX = 4200000, 12000000
+
+    def lead(self, i):
+        sh = [s for s in self.shapes[i]
+              if s['cy'] and s['name'] != 'sec-guide'
+              and s['y'] < self.LEAD_MAX_Y and s['cy'] < 1200000
+              and s['w'] > self.LEAD_MIN_CX]
+        if not sh:
+            return None
+        sh.sort(key=lambda s: s['y'])
+        return sh[-1]  # 제목이 위, 부제가 그 아래
+
+
+def doc_freq(deck):
+    from collections import Counter
+    c = Counter()
+    for i in range(len(deck.order)):
+        for t in terms(deck.text(i)):
+            c[t] += 1
+    return c, len(deck.order)
+
+
+def terms(txt):
+    return {strip_josa(t) for t in TOKEN.findall(txt)
+            if len(strip_josa(t)) >= 2 and strip_josa(t) not in STOP}
+
+
+def analyze(deck):
+    """계산부 — findings 만 낸다. 출력은 호출자(`scan`) 몫이다(interslide_deps.analyze 와 같은
+    분리: CLI/레인이 각자 계산하면 관대함이 갈린다)."""
+    F = []
+    df, N = doc_freq(deck)
+
+    def distinct(t):
+        return df.get(t, 0) <= max(2, N * 0.15)
+
+    for i in range(len(deck.order)):
+        page, lead = i + 1, deck.lead(i)
+        cur, prev = deck.text(i), deck.text(i - 1) if i else ''
+
+        # ── R1 선두 줄의 접속 부사가 받을 말이 없다
+        if lead:
+            for c in CONNECTIVE:
+                if not lead['text'].startswith(c):
+                    continue
+                rest = lead['text'][len(c):].strip()
+                subj = next((strip_josa(t) for t in TOKEN.findall(rest)
+                             if len(strip_josa(t)) >= 2 and strip_josa(t) not in STOP), None)
+                if subj and subj not in prev:
+                    F.append(('R1', page, f'선두 줄이 «{c}»로 뒤집는데 «{subj}»가 직전 장에 없다'
+                                          f' ▸ {lead["text"][:60]}'))
+                break
+
+        # ── R2 앞 장이 번호로 센 것을 번호 없이 다시 묶는다
+        title = min(deck.shapes[i], key=lambda s: s['y'])['text'] if deck.shapes[i] else ''
+        # 🟥 세는 낱말이 «제목»에 있어야 한다. 본문에 있는 다른 「세 가지」에 물린다.
+        if COUNT_WORD.search(title) and not any(e in cur for e in ENUM):
+            for back in (1, 2, 3):
+                if i - back < 0:
+                    break
+                ptxt = deck.text(i - back)
+                if sum(e in ptxt for e in ENUM) < 2:
+                    continue
+                # 🟥 «가까이 번호가 있다»만으로는 안 된다 — 다른 「세 가지」에 물릴 수 있다.
+                #    같은 셋을 다시 묶는 것인지는 **드문 낱말을 공유하는가**로 본다.
+                shared = {t for t in terms(cur) & terms(ptxt) if distinct(t)}
+                if len(shared) >= 3:
+                    F.append(('R2', page, f'«이 셋/세 가지»라 부르는데 번호가 없다 — '
+                                          f'{i - back + 1}p 가 번호로 센 것과 '
+                                          f'«{", ".join(sorted(shared)[:4])}» 를 공유한다'))
+                    break
+
+        # ── R3 선두 줄이 강조로 선언한 낱말이 이 장 어디에도 없다
+        if lead:
+            body = ' '.join(s['text'] for s in deck.shapes[i] if s is not lead)
+            btok = terms(body)
+            for a in lead['accent']:
+                # 🟥 통문장 부분일치로 보면 안 된다 — 조사 하나로 갈린다. 낱말 집합으로 본다.
+                # 🟥 전역 빈도(distinct) 로 거르면 안 된다 — 흔한 낱말이 바로 이 장에서 빠지는
+                #    것이 결함이다. 여기서 묻는 건 «이 장 안에 있나» 뿐이다.
+                key = strip_josa(a.strip(' ,.·'))
+                if VERBAL_END.search(key):
+                    continue  # 활용형 강조는 낭독 리듬이지 «선언»이 아니다
+                atok = terms(a)
+                if not atok or len(a.strip()) > 14:
+                    continue  # 긴 강조는 «선언»이 아니라 문장이다
+                if not (atok & btok):
+                    F.append(('R3', page, f'선두 줄이 «{a.strip()}»를 강조해 놓고 '
+                                          f'장 안에 그 낱말이 없다'))
+
+    # ── R4 / R5 — 임계는 «이 덱 자기 분포»에서 뽑는다. 숫자를 지어내지 않는다.
+    import statistics
+    sc = [deck.screen_chars(i) for i in range(len(deck.order))]
+    if sc:
+        p90 = sorted(sc)[int(len(sc) * 0.9)]
+        for i in range(len(deck.order)):
+            if sc[i] > p90:
+                F.append(('R4', i + 1, f'화면 {sc[i]}자 — 이 덱 상위 10% '
+                                       f'(중앙 {int(statistics.median(sc))}자 · P90 {p90}자)'))
+    load = []
+    for i in range(len(deck.order)):
+        sec = deck.spoken_sec(i)
+        if not sec or sec < 3:
+            continue
+        n = deck.new_chars(i)
+        if n < 60:
+            continue
+        load.append((i, n, sec, n / sec))
+    if load:
+        lp90 = sorted(x[3] for x in load)[int(len(load) * 0.9)]
+        med = statistics.median(x[3] for x in load)
+        for i, n, sec, r in load:
+            if r > lp90:
+                F.append(('R5', i + 1, f'새로 뜬 {n}자를 {sec}초에 — {r:.1f}자/초 '
+                                       f'(중앙 {med:.1f} · P90 {lp90:.1f}) ▸ 화면을 줄이거나 말을 늘려라'))
+    return F
+
+
+def _resolve(root, p):
+    return os.path.normpath(os.path.join(root, os.path.expanduser(p)))
+
+
+def scan(cfg, root):
+    """preprep.py 가 부르는 레인 진입점. (findings, notes) — 🟥 **advisory 고정**:
+    호출자는 findings 를 버리고 notes 만 취한다(L8·L11 관례). 여기서도 findings 를 채워
+    반환은 하되, 그 자체가 «종료코드에 안 태운다»는 약속을 깨지 않는다 — 판단은 호출부에 있다.
+    """
+    deck_s = (cfg.get('surfaces_by_id') or {}).get('built_deck')
+    if not deck_s:
+        return [], ['R1-R5 slide-relations : built_deck 미선언 — NOT_CONFIGURED (0 아님)']
+    path = _resolve(root, deck_s['path'])
+    if not os.path.exists(path):
+        return [], [f'R1-R5 slide-relations : built_deck 실물 없음({path}) — UNMEASURED (0 아님)']
+    accent = (cfg.get('slide_relations') or {}).get('accent', 'FAE100')
+    try:
+        deck = Deck(path, accent=accent)
+        F = analyze(deck)
+    except Exception as e:
+        return [], [f'R1-R5 slide-relations : 계기 오류({type(e).__name__}: {e}) — UNMEASURED (0 아님)']
+    notes = [f'R1-R5 slide-relations : {len(deck.order)}장 · 후보 {len(F)}건 '
+             f'🟥 advisory, 판정은 사람 (순위표 성격의 R4/R5 포함 — 「후보 0」을 목표로 삼지 마라)']
+    for k, p, m in sorted(F, key=lambda x: x[1]):
+        notes.append(f'   {k} {p:3}p {m}')
+    return F, notes

package/plugins/fh-commons/skills/preprep/preprep.py

@@ -9,6 +9,7 @@
   L2 unit-ref   — 표면 쌍의 단위 참조 정합 (대상의 «은퇴 선언 어휘»를 존중 — 안 하면 20% FP)
   L3 inventory  — 선언된 표면이 실물로 있나 (부재 = UNMEASURED, **0 이 아니다**)
   L4 getput     — 왕복 no-op 컨트롤. **v0.1 미배선 → NOT_WIRED 로 말한다**(거짓 초록 금지)
+  L12 diagram   — 타입 JSON 도해가 «지금 JSON» 에서 validate 를 거쳐 구워졌나 (lane_diagram.py · 2026-09-05)
 
 exit 0 = 전 레인 통과 · 1 = 발견 있음 · 2 = 계기 오류/미측정으로 판정 불가 (PASS 아님)
 
@@ -25,6 +26,24 @@ def load(path):
 def resolve(root, p):
     return os.path.normpath(os.path.join(root, os.path.expanduser(p)))
 
+# 🟥 2026-09-04 수리(신호 §3-2) — canon_terms/jargon_terms 는 이제까지 **HERE(이 스크립트
+#    위치)** 기준으로만 풀렸다. 자산군 쪽(surfaces.yaml 이 있는 root)에 실제 목록 파일을 두면
+#    못 찾았고, 실사용에서 절대경로를 넣어서야 돌았다(문서에도 없던 함정).
+#    ⇒ root 를 먼저 보고, 없을 때만 HERE(스킬 배포본에 딸린 example 계열)로 물러난다 —
+#    스킬을 설치 위치와 무관하게 그대로 돌릴 수 있어야 하므로 폴백 자체는 남긴다. 폴백을
+#    썼다는 사실은 출력에 «(skill-dir fallback)» 로 남긴다(조용히 넘기지 않는다).
+def resolve_declared(root, value):
+    """(경로, skill-dir 폴백 여부). 절대경로면 그대로. root 에 없으면 HERE 로 시도한다."""
+    if os.path.isabs(value):
+        return value, False
+    p_root = resolve(root, value)
+    if os.path.exists(p_root):
+        return p_root, False
+    p_here = resolve(HERE, value)
+    if os.path.exists(p_here):
+        return p_here, True
+    return p_root, False   # 둘 다 없다 — root 기준 경로를 대서 에러 메시지가 뭘 찾았는지 보이게 한다
+
 # 🟥 2026-08-25 신설 — 선언 경로가 판번호로 하드코딩돼 stale 해지는 클래스(G2).
 #    실측: surfaces.yaml 이 v4.6 을 가리키는 동안 실제 산출물은 v7.5 였다(12판 차이).
 #    ⚠️ **최신본으로 자동 추종하지 않는다** — 옛 판을 «일부러» 재는 경우를 뺏기 때문이다.
@@ -71,6 +90,31 @@ def read_text(path, kind):
         src = open(path, encoding='utf-8', errors='replace').read()
         lits = re.findall(r'"([^"\n]{2,})"|\'([^\'\n]{2,})\'', src)
         return '\n'.join(a or b for a, b in lits)
+    if kind == 'diagram_source':
+        # 🟥 2026-09-05 신설 — 타입 있는 도해 JSON(archify 스키마). figure_source 와 같은 이유로
+        #   «그림은 못 읽지만 그림을 그리는 소스는 읽는다». 노드 label/sublabel/tag · 간선 label ·
+        #   레인/구간/그룹 label · 카드 문장만 뽑는다(id·type 같은 기계 낱말은 L1/L5 에 안 태운다).
+        #   굽기 정합(지금 JSON 의 그림인가 · validate · 해상도)은 L12(lane_diagram.py) 몫이다.
+        import json as _json
+        d = _json.load(open(path, encoding='utf-8'))
+        out = []
+        for key in ('lanes', 'phases', 'groups', 'nodes', 'edges', 'participants', 'messages', 'states', 'transitions', 'components', 'relationships', 'stages', 'flows'):
+            for it in d.get(key) or []:
+                if isinstance(it, dict):
+                    for f in ('label', 'sublabel', 'tag', 'note'):
+                        if it.get(f): out.append(str(it[f]))
+        for c in d.get('cards') or []:
+            if isinstance(c, dict):
+                if c.get('title'): out.append(str(c['title']))
+                out += [str(x) for x in (c.get('items') or [])]
+        m = d.get('meta') or {}
+        for f in ('title', 'subtitle'):
+            if m.get(f): out.append(str(m[f]))
+        for v in m.get('views') or []:
+            if isinstance(v, dict):
+                for f in ('label', 'note'):
+                    if v.get(f): out.append(str(v[f]))
+        return '\n'.join(out)
     if kind == 'keynote':
         raise RuntimeError('keynote: 사람만 읽는 면 — 기계 어댑터 없음')
     raise RuntimeError(f'unknown kind: {kind}')
@@ -160,9 +204,24 @@ def hits(text, lit, speech_marker=None):  # yields (cls, line_no, line)
 
 # ── L1 canon ──────────────────────────────────────────────────────────────────
 def lane_canon(cfg, root, texts, surf_meta):
-    terms = load(resolve(HERE, cfg['canon_terms']) if not os.path.isabs(cfg['canon_terms'])
-                 else cfg['canon_terms'])
     findings, notes = [], []
+    ct_cfg = cfg.get('canon_terms')
+    if not ct_cfg:
+        return [], ['L1 canon : canon_terms 미선언 — NOT_CONFIGURED (0 아님)']
+    ct_path, ct_fb = resolve_declared(root, ct_cfg)
+    if ct_fb:
+        notes.append(f'L1 canon : canon_terms 를 root 에서 못 찾아 스킬 위치로 폴백 '
+                     f'(skill-dir fallback) — {ct_path}')
+    # 🟥 2026-09-04 수리(신호 §3-3) — 파일 부재가 여기서 `FileNotFoundError` 트레이스백으로
+    #    죽었다. 이 스킬 자신의 교리가 「부재 ↔ 0 을 가른다 · UNMEASURED 로 낸다」인데 자기
+    #    코드가 그걸 어기고 있었다([[feedback_rule_misdescribes_its_own_machine]] 과 같은 족).
+    #    ⇒ UNMEASURED 로 낮춰 잡고 **나머지 레인은 계속 돈다**(L1 하나가 죽는다고 전체가
+    #    안 죽는다 — main() 은 이 함수를 감싸지 않으므로 여기서 반드시 잡아야 한다).
+    try:
+        terms = load(ct_path)
+    except Exception as e:
+        return [], [f'L1 canon : canon_terms 부재({ct_path}) — UNMEASURED (0 아님): '
+                    f'{type(e).__name__}: {e}']
 
     # L1-a 원장 ↔ 기계 목록 커버리지 (이 하네스가 잡는 결함이 자기 자신에게도 난다)
     ledger = resolve(root, cfg['canon_ledger'])
@@ -366,12 +425,23 @@ def lane_jargon(cfg, root, texts, surf_meta):
     «선언한 것 중 풀이 없는 게 없다»이다. 0 을 «깨끗하다»로 읽지 말 것."""
     cfgp = cfg.get('jargon_terms')
     if not cfgp: return [], ['L5 jargon : 선언 파일 없음 — NOT_CONFIGURED (0 아님)']
-    spec = load(resolve(HERE, cfgp) if not os.path.isabs(cfgp) else cfgp)
+    # 🟥 2026-09-04 — canon_terms 와 같은 수리(신호 §3-2·3-3): root 우선 · HERE 폴백 ·
+    #    부재는 크래시가 아니라 UNMEASURED.
+    jt_path, jt_fb = resolve_declared(root, cfgp)
+    jt_notes = []
+    if jt_fb:
+        jt_notes.append(f'L5 jargon : jargon_terms 를 root 에서 못 찾아 스킬 위치로 폴백 '
+                        f'(skill-dir fallback) — {jt_path}')
+    try:
+        spec = load(jt_path)
+    except Exception as e:
+        return [], [f'L5 jargon : jargon_terms 부재({jt_path}) — UNMEASURED (0 아님): '
+                    f'{type(e).__name__}: {e}']
     win = int(spec.get('gloss_window', 2))
-    findings, notes = [], []
+    findings, notes = [], list(jt_notes)
     spoken = [sid for sid, m in surf_meta.items() if m.get('spoken')]
     if not spoken:
-        return [], ['L5 jargon : 낭독면 선언 0 — UNMEASURED (0 아님)']
+        return [], notes + ['L5 jargon : 낭독면 선언 0 — UNMEASURED (0 아님)']
     checked = glossed = 0
     for sid in spoken:
         if sid not in texts: continue
@@ -577,7 +647,9 @@ def lane_interslide(cfg, root):
         import importlib.util
         sp = importlib.util.spec_from_file_location('interslide_deps', mod_p)
         m = importlib.util.module_from_spec(sp); sp.loader.exec_module(m)
-        r = m.analyze(draft_p, build_p)
+        # 🟥 2026-09-04 — 원고 표면의 unit_pattern 선언을 analyze() 로 그대로 넘긴다
+        #    (신호 §3-1 수리 — units() 하드코딩을 없앤 절반이 여기다).
+        r = m.analyze(draft_p, build_p, pattern=ms.get('unit_pattern'))
     except Exception as e:
         return [], [f'L8 interslide : 계기 오류({e}) — UNMEASURED (0 아님)']
     if r.get('error'):
@@ -701,8 +773,17 @@ def main():
     #    별도 모듈 레인(L9/L10/L11)이라 둘 다 센다.
     #    [[feedback_rule_misdescribes_its_own_machine]] · [[feedback_instrument_vs_target_and_budget]]
     _lanes = sorted(n[5:] for n in globals() if n.startswith('lane_') and callable(globals()[n]))
-    _mods = sorted(m for m in ('lane_promise', 'lane_adjacent_dup', 'lane_progression')
+    _mods = sorted(m for m in ('lane_promise', 'lane_adjacent_dup', 'lane_progression',
+                                'lane_slide_relations', 'lane_geometry', 'lane_diagram', 'lane_slide_refs')
                    if os.path.exists(os.path.join(HERE, m + '.py')))
+    # 🟥 2026-09-04 신설 — `--lane R1,R2,...` 로 **새 모듈 레인(R1-R5·P1/P3)만** 골라 끈다/켠다.
+    #    L1~L11 은 아직 이 필터를 안 탄다(usage 줄의 --lane 은 그쪽엔 미배선인 채 남아 있다 —
+    #    있는 척하지 않는다). 최소 접촉 원칙: 기존 L* 배선은 안 건드린다.
+    _lane_arg = sys.argv[sys.argv.index('--lane') + 1] if '--lane' in sys.argv else None
+    _wanted = set(_lane_arg.split(',')) if _lane_arg else None
+
+    def _lane_on(*codes):
+        return _wanted is None or any(c in _wanted for c in codes)
     print(f"── 발표 준비 하네스 v0.1 ──")
     print(f"   판: {os.path.realpath(__file__)}")
     print(f"   레인 {len(_lanes)}(내장): {' · '.join(_lanes)}")
@@ -726,7 +807,11 @@ def main():
     for i, why in unreadable: print(f"   {ANSI_UNK} 기계 어댑터 없음: {i} — {why}  (UNMEASURED)")
 
     findings, notes = [], []
-    surf_meta = {s['id']: {'marker': s.get('speech_marker'), 'spoken': s.get('spoken', False)}
+    # 🟥 2026-09-04 — 'unit_pattern' 을 추가했다. L6 pacing 은 이미 이 필드를 읽고 있었는데
+    #    (surf_meta[sid].get('unit_pattern')) 여기서 채워준 적이 없어 **항상 None** 이었다 —
+    #    L10/L11 도 같은 필드로 units() 에 pattern 을 전달하므로 여기가 단일 공급처가 된다.
+    surf_meta = {s['id']: {'marker': s.get('speech_marker'), 'spoken': s.get('spoken', False),
+                           'unit_pattern': s.get('unit_pattern')}
                  for s in cfg['surfaces']}
     f1, n1 = lane_canon(cfg, root, texts, surf_meta); findings += f1; notes += n1
     try:
@@ -763,6 +848,42 @@ def main():
     f6, n6 = lane_pacing(cfg, root, texts, surf_meta); findings += f6; notes += n6
     f7, n7 = lane_regen(cfg, root); findings += f7; notes += n7
     f8, n8 = lane_interslide(cfg, root); findings += f8; notes += n8
+    if _lane_on('R1', 'R2', 'R3', 'R4', 'R5', 'R'):
+        try:
+            import lane_slide_relations
+            _fR, _nR = lane_slide_relations.scan(cfg, root)
+            notes += _nR   # advisory 고정 — findings 에 안 태운다(L8·L11 관례)
+        except Exception as _e:
+            notes.append('R1-R5 slide-relations : 계기 미실행 — NOT_WIRED (%s: %s) (0 아님)'
+                         % (type(_e).__name__, _e))
+    # L13 slide-refs — 「N p」 리터럴 장 번호 참조가 실재하는 장을 가리키나(2026-09-06 신설).
+    #   이웃 레인들은 «말로 가리키는 것»만 본다(L5/L8 화면 재사용·시각 지시 · R1~R5 접속어).
+    #   숫자 참조는 아무도 안 봤고, 장을 빼면 그 뒤가 통째로 당겨진다.
+    #   차단은 «범위 밖» 하나뿐 — 「그 번호가 맞는 장인가」는 의미 판단이라 안 본다.
+    try:
+        import lane_slide_refs
+        _f13, _n13 = lane_slide_refs.scan(cfg, root)
+        findings += _f13; notes += _n13
+    except Exception as _e:
+        notes.append('L13 slide-refs : 계기 미실행 — NOT_WIRED (%s: %s) (0 아님)'
+                     % (type(_e).__name__, _e))
+    # L12 diagram — 타입 JSON 도해가 «지금 JSON» 에서 validate 를 거쳐 구워졌나(2026-09-05 신설).
+    #   차단: 선언된 diagram_source 표면에 한해 지문·validate·해상도·viewBox 폭·여백을 본다.
+    #   영수증 없는 PNG(손그림)는 UNMEASURED 노트로만 — 0 이 아니다.
+    try:
+        import lane_diagram
+        _f12, _n12 = lane_diagram.scan(cfg, root)
+        findings += _f12; notes += _n12
+    except Exception as _e:
+        notes.append('L12 diagram : 계기 미실행 — NOT_WIRED (%s: %s) (0 아님)' % (type(_e).__name__, _e))
+    if _lane_on('P1', 'P3', 'P'):
+        try:
+            import lane_geometry
+            _fP, _nP = lane_geometry.scan(cfg, root)
+            notes += _nP   # advisory 고정 — findings 에 안 태운다(L8·L11 관례)
+        except Exception as _e:
+            notes.append('P1/P3 geometry : 계기 미실행 — NOT_WIRED (%s: %s) (0 아님)'
+                         % (type(_e).__name__, _e))
 
     for n in notes: print(f"   · {n}")
     use = [f for f in findings if f[1] != 'mention']