@chrono-meta/fh-gate 3.0.0 → 3.1.0

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

@@ -22,18 +22,46 @@ usage: interslide_deps.py <draft.md> <builder.py> [--all]
 import sys, re, ast, os
 
 # 어휘는 **실물에서 뽑았다**(pre-자립화 S9 원문). 지어내지 않았다.
-SCREEN_REUSE = ('그대로', '같은 화면', '이어서', '화면 유지', '왼쪽 그대로', '오른쪽 그대로')
+# 🟥 2026-09-04 수리(신호 §4) — 바깥 자리에 있던 **맨몸 「그대로」를 뺐다**. 121장 실물 코퍼스에서
+#    「경고가 떠도 그대로 승인한다」·「제출본 그대로 머지」처럼 **평범한 부사**로 훨씬 더 자주 쓰여,
+#    L8 UNRESOLVED 9건 중 다수가 이 낱말 하나가 만들었다(손검증 → 전부 오탐). 맨몸을 빼고
+#    **화면에 결박된 표기만** 남긴다 — 「그대로」 앞에 화면을 가리키는 말이 없으면 화면 재사용이
+#    아니라 그냥 부사다. [[feedback_regex_bind_not_add.md]] 와 같은 원리(결박, 어휘 추가가 아니라).
+SCREEN_REUSE = ('같은 화면', '이어서', '화면 유지',
+                '화면 그대로', '이 화면 그대로', '왼쪽 그대로', '오른쪽 그대로')
 DIRECTION    = ('오른쪽', '왼쪽', '위에서', '아래', '옆')
 VISUAL_VERB  = ('보셨', '보신', '보시는', '보시면', '보였')
 RECALL       = ('방금', '아까', '조금 전', '앞서', '앞에서', '지금까지')
 SOFT_ONLY    = ('말씀드린', '말씀드렸', '설명드린', '그 세', '앞의')
 
-def units(src):
-    """(sid, 헤딩, 본문) 순서대로. 🚫 은퇴 표기 절은 «죽은 것»으로 표시해 같이 낸다."""
+_DEFAULT_UNIT_PATTERN = r'^### (S[0-9]+(?:-[a-z])?)\s*·'
+
+
+def units(src, pattern=None):
+    """(sid, 헤딩, 본문) 순서대로. 🚫 은퇴 표기 절은 «죽은 것»으로 표시해 같이 낸다.
+
+    🟥 2026-09-04 수리(신호 §3-1) — 초판은 절 헤딩 정규식을 **여기 하드코딩**했다. 같은
+       `surfaces.yaml unit_pattern` 을 `preprep.py manuscript_ids()` 는 이미 읽는데 이 함수는
+       안 읽어서, «절을 무엇으로 보나»에 대한 관대함이 **두 곳에서 따로 갈렸다**
+       ([[feedback_divergent_leniency_duplicate_normalizers]]). `pattern` 인자로 받는다 —
+       미지정이면 이 코퍼스의 기존 패턴으로 하위호환.
+    🟥 정규식을 다시 짓지 않는다 — `manuscript_ids()`(preprep.py)와 **같은 head/slice 기법**
+       (헤딩 위치를 전부 찾고 다음 헤딩 시작 전까지를 본문으로 슬라이스)을 쓴다. lookahead 로
+       "다음 헤딩" 을 다시 정의하면 그 자체가 세 번째 갈래가 된다.
+    `pattern`: 절 헤딩을 여는 정규식, **캡처 그룹 하나**(절 id)만 가진다
+       (예: r'^###\\s+(S[0-9]+(?:-[a-z])?)\\s*·').
+    """
+    pat = pattern or _DEFAULT_UNIT_PATTERN
     out = []
-    for m in re.finditer(r'^### (S[0-9]+(?:-[a-z])?)\s*·([^\n]*)\n(.*?)(?=^### |\Z)', src, re.M | re.S):
-        retired = any(t in m.group(2) for t in ('🚫', '제거됨', '폐기'))
-        out.append((m.group(1), m.group(2).strip(), m.group(3), retired))
+    heads = list(re.finditer(pat + r'([^\n]*)', src, re.M))
+    for i, m in enumerate(heads):
+        end = heads[i + 1].start() if i + 1 < len(heads) else len(src)
+        head_line = m.group(2)
+        body = src[m.end():end]
+        if body.startswith('\n'):
+            body = body[1:]         # 헤딩 줄 자신의 개행 — 옛 구현은 본문에 안 담았다(동치 유지)
+        retired = any(t in head_line for t in ('🚫', '제거됨', '폐기'))
+        out.append((m.group(1), head_line.strip(), body, retired))
     return out
 
 # 🟥 런 #14 에서 이미 한 번 겪은 결함이 여기서 재현됐다: 원고의 **주석 블록**도 `>` 라서
@@ -107,7 +135,12 @@ def referents(line):
         t = re.sub(DEICTIC_PREFIX, '', m.group(1).strip(' .,·「」«»')).strip()
         # 지시어만 벗기면 남는 말이 너무 짧거나 흔하면 대상이 못 된다
         if len(t) >= 2: cands.append(t)
-    for m in re.finditer(r'[그저]\s*([가-힣A-Za-z][가-힣A-Za-z0-9 ]{1,12})', line):
+    # 🟥 2026-09-04 수리(신호 §4) — 초판은 `[그저]` 로 **「저」도 지시어**로 잡았다. 한국어
+    #    존댓말 1인칭 「저희」가 「저 + 희…」로 물려 대상어가 «희 하네스의 활용 구조입» 같은
+    #    파편이 됐다(실측: S25). 「저」는 지시어(저것 · 저 사람)와 1인칭 겸양어(저 · 저희)를
+    #    **같은 글자로 겸하는 다의어**라 이 정규식 자리에서 원리적으로 갈리지 않는다 — 지시어
+    #    쪽만 원하면 「그」만 남기고 「저」는 뺀다(놓치는 지시어보다 존댓말 오탐이 더 흔하다).
+    for m in re.finditer(r'그\s*([가-힣A-Za-z][가-힣A-Za-z0-9 ]{1,12})', line):
         cands.append(m.group(1).strip())
     return [c for c in dict.fromkeys(cands) if c not in COMMON and len(c) >= 2]
 
@@ -141,15 +174,16 @@ def wired_ids(builder):
                 return {v[0] for v in ast.literal_eval(src[start:i+1]).values() if v[0]}
     raise RuntimeError('NOTE_MAP 괄호 불균형')
 
-def analyze(draft, builder, show_all=False):
+def analyze(draft, builder, show_all=False, pattern=None):
     """계산부 — 출력하지 않는다. 레인 배선이 이걸 부른다(main 은 이걸 «찍기만» 한다).
 
     🟥 로직을 복제하지 않으려고 뺀 것이다. CLI 와 레인이 각자 계산하면
     관대함이 갈려서 한쪽만 통과하는 입력이 조용히 생긴다.
+    `pattern`: 원고 표면의 `unit_pattern` 선언(있으면) — units() 로 그대로 전달한다.
     반환: dict(error, n_units, n_retired, n_wired, edges, broken, unresolved)
     """
     try:
-        us = units(open(draft, encoding='utf-8').read())
+        us = units(open(draft, encoding='utf-8').read(), pattern=pattern)
         wired = wired_ids(builder)
     except Exception as e:
         return {'error': f'{e}', 'edges': [], 'broken': [], 'unresolved': []}
@@ -188,7 +222,62 @@ def analyze(draft, builder, show_all=False):
             'n_wired': len(wired), 'edges': edges, 'broken': broken, 'unresolved': unresolved}
 
 
+def selftest():
+    """known-pair — 신호 §3-1·§4 수리가 실제로 짝을 가르는지. 안 가르면 장식이다."""
+    ok = True
+
+    # ── L8 §4-a: 「저」를 지시어 정규식에서 뺐다 — 존댓말 「저희」오탐 재발 방지 ──────────
+    cases_ref = [
+        ('known-positive(존댓말 「저희」 — 지시 대상이면 안 된다)',
+         '저희 하네스의 활용 구조입니다 . 보시는 것처럼 세 층입니다 .', False),
+        ('known-negative(진짜 지시어 「그」 — 여전히 잡혀야 한다)',
+         '그 하네스는 이렇게 동작합니다 .', True),
+    ]
+    for name, line, want_hit in cases_ref:
+        got = referents(line)
+        hit = bool(got) == want_hit
+        ok &= hit
+        print(f'  {"PASS" if hit else "FAIL"}  referents {name}: {got}')
+
+    # ── L8 §4-b: SCREEN_REUSE 맨몸 「그대로」를 뺐다 — 화면 결박 표기만 남는다 ──────────
+    cases_scr = [
+        ('known-positive(평범한 부사 — 화면 재사용 아니다)', '경고가 떠도 그대로 승인한다', False),
+        ('known-positive(다른 문맥의 부사)', '제출본 그대로 머지', False),
+        ('known-negative(화면 결박 — 여전히 잡혀야 한다)', '왼쪽 그대로', True),
+        ('known-negative(화면 결박 변형)', '이 화면 그대로 두면 됩니다', True),
+    ]
+    for name, line, want_hit in cases_scr:
+        got = any(c in line for c in SCREEN_REUSE)
+        hit = got == want_hit
+        ok &= hit
+        print(f'  {"PASS" if hit else "FAIL"}  SCREEN_REUSE {name}: hit={got}')
+
+    # ── §3-1: units() 가 pattern 인자를 받고, 미지정 시 하위호환 ──────────────────────
+    src_default = '### S1 · 제목\n🗣\n> 본문\n\n### S2 · 둘째\n🗣\n> 본문2\n'
+    default_ids = [u[0] for u in units(src_default)]
+    ok3 = default_ids == ['S1', 'S2']
+    ok &= ok3
+    print(f'  {"PASS" if ok3 else "FAIL"}  units() 기본 패턴 하위호환: {default_ids}')
+
+    src_custom = '### U1 · 제목\n🗣\n> 본문\n\n### U2 · 둘째\n🗣\n> 본문2\n'
+    custom_ids = [u[0] for u in units(src_custom, pattern=r'^###\s+(U[0-9]+)\s*·')]
+    ok4 = custom_ids == ['U1', 'U2']
+    ok &= ok4
+    print(f'  {"PASS" if ok4 else "FAIL"}  units() 커스텀 unit_pattern 수용: {custom_ids}')
+    # 기본 패턴으로는 U1/U2 코퍼스를 못 읽어야 한다 — «항상 통과»하는 계기가 아님을 확인
+    default_on_custom = units(src_custom)
+    ok5 = default_on_custom == []
+    ok &= ok5
+    print(f'  {"PASS" if ok5 else "FAIL"}  기본 패턴은 U-접두를 못 읽는다(계기가 진짜 pattern 을 씀): '
+          f'{len(default_on_custom)}건')
+
+    print('interslide_deps SELFTEST:', 'PASS' if ok else 'FAIL — 이 계기의 출력을 쓰지 마라')
+    return 0 if ok else 1
+
+
 def main():
+    if '--self-test' in sys.argv:
+        return selftest()
     if len(sys.argv) < 3: print(__doc__); return 2
     draft, builder = sys.argv[1], sys.argv[2]
     show_all = '--all' in sys.argv

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

@@ -47,7 +47,10 @@ def scan(cfg, texts, surf_meta, mod):
     findings, notes = [], []
     for sid in sorted(spoken):
         text = texts[sid][0]
-        us = [u for u in mod.units(text) if not u[3]]      # 은퇴 절 제외
+        # 🟥 2026-09-04 — units() 가 pattern 을 받는다. 이 표면의 unit_pattern 선언을 넘긴다
+        #    (interslide_deps 신호 §3-1 과 같은 수리 — 두 곳이 각자 관대함을 갖지 않게 한다).
+        _pat = surf_meta.get(sid, {}).get('unit_pattern')
+        us = [u for u in mod.units(text, pattern=_pat) if not u[3]]      # 은퇴 절 제외
         if len(us) < 2:
             notes.append(f'L10 adjacent-dup : {sid} — 절 {len(us)}개, 인접 쌍 없음 (0 아님)')
             continue

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

@@ -0,0 +1,95 @@
+"""L12 diagram — **도해가 «지금 JSON» 에서 검증을 거쳐 구워졌나.**
+
+## 존재 근거 (2026-09-05, archify × preprep 결합 실측)
+
+도해를 타입 있는 JSON → 외부 렌더러(archify) → PNG → pptx 로 넣는 경로가 뚫렸다. 그 경로의 사각은
+셋이고, 셋 다 «PNG 가 있다»로는 안 보인다:
+  ① JSON 을 고쳤는데 PNG 는 옛 것(재생성 안 함)         — 빌드는 성공, 그림은 거짓
+  ② validate 를 못 통과한 JSON 을 손으로 렌더해 넣음      — 겹침·라벨 마스킹이 화면에
+  ③ 픽셀은 충분한데 viewBox 가 넓어 글자가 12pt 로 떨어짐 — «해상도 OK» 인데 못 읽는다
+
+## 무엇을 재고 무엇을 안 재나
+
+- 잰다 — `kind: diagram_source` 표면마다 `render:` PNG 옆의 **굽기 영수증**(`*.receipt.json`,
+  `diagram_from_json.py` 가 쓴다)을 읽어: 영수증 존재 · JSON sha 일치 · validate ok(showcase) ·
+  PNG 실제 폭(IHDR 을 직접 읽는다 — 영수증 자기신고가 아니다) ≥ min_px · viewBox 폭 ≤ max ·
+  pad ≥ min.
+- 안 잰다 — 그림이 «좋은가». 그건 §방법론 ⓒ «도해를 건드렸으면 렌더한다» 의 사람 몫이다.
+- 🟥 영수증이 없는 PNG(손으로 넣은 그림)는 **UNMEASURED 로 낸다** — 0 이 아니고, 통과도 아니다.
+  이 레인은 «생성기를 거친 그림»만 본다. 사각은 좁아지지 좁아지지 닫히지 않는다(SKILL.md §갈라 적는 것).
+
+## 차단인 이유
+선언된 표면에 한해 «지문이 다르다 / validate 가 아니다 / 폭이 모자란다» 는 애매하지 않은 사실이다.
+오탐의 최저비용 무마는 «다시 굽는 것»이라 원고를 망가뜨리는 방향이 아니다.
+"""
+import hashlib, json, os, struct
+
+
+def _sha(p):
+    h = hashlib.sha256(); h.update(open(p, 'rb').read()); return h.hexdigest()
+
+
+def _png_w(p):
+    with open(p, 'rb') as f: head = f.read(24)
+    if head[:8] != b'\x89PNG\r\n\x1a\n': raise ValueError('PNG 아님')
+    return struct.unpack('>II', head[16:24])[0]
+
+
+def _resolve(root, p):
+    return os.path.normpath(os.path.join(root, os.path.expanduser(p)))
+
+
+def scan(cfg, root):
+    """(findings, notes). findings 튜플 = (sid, kind, ref, lit, why) — preprep.py 의 USE 계열."""
+    surfs = [s for s in cfg.get('surfaces', []) if s.get('kind') == 'diagram_source']
+    if not surfs:
+        return [], ['L12 diagram : diagram_source 표면 없음 — NOT_CONFIGURED (0 아님)']
+    spec = cfg.get('diagram') or {}
+    min_px = int(spec.get('min_px', 3840)); max_vb = float(spec.get('max_viewbox_w', 720)); min_pad = float(spec.get('min_pad', 0.02))
+    findings, notes = [], []
+    n_ok = n_unm = 0
+    for s in surfs:
+        sid = s['id']; jp = _resolve(root, s['path'])
+        if not os.path.exists(jp):
+            notes.append(f'L12 diagram : {sid} JSON 없음({jp}) — UNMEASURED (0 아님)'); n_unm += 1; continue
+        rp_png = s.get('render')
+        if not rp_png:
+            notes.append(f'L12 diagram : {sid} render(PNG) 미선언 — UNMEASURED (0 아님)'); n_unm += 1; continue
+        png = _resolve(root, rp_png); rec = png[:-4] + '.receipt.json' if png.endswith('.png') else png + '.receipt.json'
+        if not os.path.exists(png):
+            findings.append((sid, 'diagram', 'render', os.path.basename(png), 'L12 선언된 PNG 가 디스크에 없다 — 굽지 않았거나 경로가 틀렸다')); continue
+        if not os.path.exists(rec):
+            notes.append(f'L12 diagram : {sid} 굽기 영수증 없음({os.path.basename(rec)}) — 손으로 넣은 그림은 이 레인이 못 본다. UNMEASURED (0 아님)'); n_unm += 1; continue
+        try: r = json.load(open(rec, encoding='utf-8'))
+        except Exception as e:
+            findings.append((sid, 'diagram', 'receipt', os.path.basename(rec), f'L12 영수증 파싱 실패({type(e).__name__}) — 채널이 깨졌다')); continue
+        bad = False
+        if r.get('spec_sha256') != _sha(jp):
+            findings.append((sid, 'diagram', 'stale', os.path.basename(png), 'L12 JSON 지문이 영수증과 다르다 — JSON 을 고친 뒤 다시 굽지 않았다')); bad = True
+        if not (r.get('validate') or {}).get('ok') or (r.get('validate') or {}).get('profile') != 'showcase':
+            findings.append((sid, 'diagram', 'validate', os.path.basename(png), 'L12 showcase validate 통과 기록이 없다 — 검증 안 된 그림')); bad = True
+        try: w = _png_w(png)
+        except Exception as e:
+            findings.append((sid, 'diagram', 'png', os.path.basename(png), f'L12 PNG 헤더 읽기 실패({e})')); continue
+        if w < min_px:
+            # 자른(crop) PNG 는 캔버스보다 좁다 — 영수증의 png_size 가 아니라 «crop 전 캔버스»가 하한을 넘겼는지 본다.
+            # 🟥 캔버스 폭은 영수증 자기신고다. IHDR 실측(w)과 함께 둘 다 적어 감사자가 가르게 한다.
+            canvas_w = None
+            cv = r.get('canvas')
+            if isinstance(cv, str) and 'x' in cv.lower() and cv.lower() != 'auto':
+                canvas_w = int(cv.lower().split('x')[0])
+            elif r.get('crop'):
+                canvas_w = min_px if r.get('png_size') else None   # auto 캔버스는 스크립트가 하한 이상으로만 만든다
+            if not (r.get('crop') and canvas_w and canvas_w >= min_px):
+                findings.append((sid, 'diagram', 'resolution', os.path.basename(png), f'L12 PNG 폭 {w} < 하한 {min_px} (장표 2×)')); bad = True
+            else:
+                notes.append(f'L12 diagram : {sid} 자른 PNG 폭 {w}(IHDR) — 캔버스 {canvas_w}(영수증 자기신고) 로 하한 판정')
+        vbw = r.get('viewbox_w')
+        if vbw is None or float(vbw) > max_vb:
+            findings.append((sid, 'diagram', 'viewbox', os.path.basename(png), f'L12 viewBox 폭 {vbw} > 상한 {max_vb:.0f} — 글자 배율 미달(라벨≈{12*1728/float(vbw or 1):.0f}pt)')); bad = True
+        if float(r.get('pad', 0)) < min_pad:
+            findings.append((sid, 'diagram', 'pad', os.path.basename(png), f'L12 여백 {r.get("pad")} < 하한 {min_pad}')); bad = True
+        if not bad: n_ok += 1
+    notes.append(f'L12 diagram : 표면 {len(surfs)} · 통과 {n_ok} · UNMEASURED {n_unm} · 발견 {len(findings)} '
+                 f'(하한 {min_px}px · viewBox≤{max_vb:.0f} · pad≥{min_pad})')
+    return findings, notes

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

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+"""P1·P3 — 도형 배치 검사 둘. the private companion store's origin script (lane_geometry.py(2026-09-04,
+36p 사고에서 역산)를 preprep 관례로 이식한 것 — 로직은 그대로다.
+정본: `tracks-meta/fh_signal_2026-09-04_preprep-evolution.md` §2.
+
+  P1 build-jitter   같은 이름의 도형이 «연속한 두 장»에서 조금 다른 자리에 있다
+                    → 넘길 때 튄다. 실사고: 노란 게이트 막대가 직전 장 대비 35,000 EMU 밀려
+                      회색 연결선과 겹쳤다. 큰 차이는 «의도한 이동»이라 제외한다.
+  P3 adjacency      한 도형의 «오른쪽 끝»과 다른 도형의 «왼쪽 끝»이 맞닿으려다 어긋났다
+                    → 실제 결함이 이 형태였다(회색 스텁 끝 ↔ 막대 시작, 35,000 겹침).
+
+🟥 **P2(near-miss, 같은 종류 모서리끼리만 대조)는 미포함이다 — 채택하지 않는다.** 실사고가
+   못 잡히는 이유가 설계 근거였다: 실제 결함은 「회색 스텁 오른쪽 끝 ↔ 막대 왼쪽 끝」이라는
+   **다른 종류** 모서리의 인접 관계인데, P2 는 왼↔왼·오른↔오른만 봐서 구조적으로 못 잡는다.
+   그 관계는 P3 가 이미 덮는다. 새 레인을 짤 때 «같은 종류끼리»가 기본값이라는 것을 의심하라.
+
+🟥 둘 다 advisory. 임계는 사람이 정한다(기본 JIT=200,000 EMU · ALN=63,500 EMU=5pt ·
+   1pt=12,700 EMU). `surfaces.yaml` 의 `geometry.jitter_emu` / `geometry.align_emu` 로 바꾼다.
+🟥 «차이 0» 은 정상이고 «차이 큼» 도 정상이다. 이 검사가 보는 것은 그 사이뿐이다.
+
+## 🟥 목록으로 읽지 마라 — 델타로 읽어라
+
+실측: P3 는 원 코퍼스에서 기저 오탐이 76건이다(아이콘 무리 내부 · 맵 라벨의 «의도된» 겹침).
+그 목록에서 진짜를 골라낼 방법이 없다. 그런데 편집 전/후를 대조하면 **차이가 정확히 그
+한 줄**이었다. ⇒ 절대 목록은 회귀 도구로 못 쓰고 **편집 전후 델타는 정확하다.**
+`surfaces.yaml` 의 `geometry.baseline`(이전 판 pptx 경로)이 있으면 이 레인은 델타 모드로 돈다
+— 「지금 몇 건이냐」가 아니라 «내가 방금 뭘 어긋냈냐»를 묻는 회귀 도구다.
+
+## 🟥 P1 이 «비교 안 함»을 «튐 없음»으로 속일 수 있는 자리 (계기 결함, 미리 적는다)
+
+`shapes()` 는 **한 장 안에서 이름이 겹치는 도형을 통째로 버린다**(`len(v) == 1` 만 남긴다) —
+겹치는 이름끼리는 대조할 대상을 하나로 못 정하기 때문이다. python-pptx 기본 이름
+(`TextBox 1` 류)은 장마다 새로 매겨져 **이름이 우연히 안 겹칠 수 있고**, 대조 자체가 0건이
+되는 입력에서도 「후보 0건」이 똑같이 출력된다 — 그 0 은 **「튐 없음」이 아니라 「비교 안 함」**
+이다(이 저장소가 이름 붙인 「레인이 초록인 이유는 셋」의 ②). ⇒ `scan()` 은 **비교된 도형-쌍
+수**를 항상 같이 낸다 — 0 이면 UNMEASURED 로 읽어야 한다는 뜻이다.
+"""
+import zipfile, re, os, collections
+
+EMU_PT = 12700
+
+
+def shapes(z, sn):
+    """한 슬라이드의 도형을 {이름: (x,y,cx,cy,text)} 로. 이름 중복은 대조 못 하니 뺀다."""
+    x = z.read('ppt/slides/slide%d.xml' % sn).decode('utf-8')
+    out = {}
+    for m in re.finditer(r'<p:(sp|cxnSp)>.*?</p:\1>', 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)
+        if not (nm and o):
+            continue
+        t = re.sub(r'\s+', ' ', ' '.join(re.findall(r'<a:t>([^<]*)</a:t>', b))).strip()
+        out.setdefault(nm.group(1), []).append(
+            (int(o.group(1)), int(o.group(2)), int(o.group(3)), int(o.group(4)), t))
+    return {k: v[0] for k, v in out.items() if len(v) == 1}
+
+
+def _order(z):
+    rels = dict(re.findall(r'Id="([^"]+)"[^>]*Target="slides/slide(\d+)\.xml"',
+                            z.read('ppt/_rels/presentation.xml.rels').decode('utf-8')))
+    lst = re.search(r'<p:sldIdLst>.*?</p:sldIdLst>',
+                     z.read('ppt/presentation.xml').decode('utf-8'), re.S).group(0)
+    return [int(rels[r]) for r in re.findall(r'<p:sldId id="\d+" r:id="([^"]+)"/>', lst)]
+
+
+def load_slides(path):
+    z = zipfile.ZipFile(path)
+    return [shapes(z, sn) for sn in _order(z)]
+
+
+def p1_lines(S, JIT):
+    """build-jitter 후보. 반환: (lines, compared) — compared=0 이면 대조 대상이 아예 없었다는
+    뜻이라 «튐 0건»과 «UNMEASURED」를 갈라야 한다."""
+    lines, compared = [], 0
+    for i in range(1, len(S)):
+        for nm, cur in S[i].items():
+            prv = S[i - 1].get(nm)
+            if not prv:
+                continue
+            compared += 1
+            d = [cur[k] - prv[k] for k in range(4)]
+            mx = max(abs(v) for v in d)
+            if 0 < mx <= JIT:
+                lab = ['x', 'y', 'cx', 'cy']
+                moved = ' · '.join(f'{lab[k]} {d[k]:+d}' for k in range(4) if d[k])
+                lines.append(f"   {i:>3}p→{i+1:<3}p {nm[:16]:16} {moved}  ({mx/EMU_PT:.2f}pt)  "
+                             f"«{cur[4][:26]}»")
+    return lines, compared
+
+
+def p3_lines(S, ALN):
+    """adjacency 후보 — A 오른쪽 끝 ↔ B 왼쪽 끝, 세로로 겹치는 띠에 있을 때만."""
+    lines = []
+    for i, sh in enumerate(S):
+        items = [(nm, v) for nm, v in sh.items() if v[2] > 0 and v[3] > 0]
+        for a in range(len(items)):
+            for b in range(len(items)):
+                if a == b:
+                    continue
+                na, va = items[a]
+                nb, vb = items[b]
+                oy = min(va[1] + va[3], vb[1] + vb[3]) - max(va[1], vb[1])
+                if oy <= 0:
+                    continue
+                gap = vb[0] - (va[0] + va[2])  # A 오른쪽 → B 왼쪽
+                if 0 < abs(gap) <= ALN:
+                    kind = '겹침' if gap < 0 else '틈'
+                    lines.append(f"   {i+1:>3}p {na[:14]:14} 오른끝 → {nb[:14]:14} 왼끝  "
+                                 f"{kind} {abs(gap):>6} EMU ({abs(gap)/EMU_PT:.2f}pt)")
+    return lines
+
+
+def collect_lines(path, JIT, ALN):
+    """(lines, compared) — P1+P3 합친 후보 줄과, P1 이 실제로 대조한 도형-쌍 수."""
+    S = load_slides(path)
+    l1, compared = p1_lines(S, JIT)
+    l3 = p3_lines(S, ALN)
+    return l1 + l3, compared
+
+
+def delta(base_path, cur_path, JIT, ALN):
+    """편집 전/후 델타 — 절대 목록이 아니라 **차이**로 읽는 용법(정확했던 것). P3 는 SYS 를 안 쓰니
+    양쪽에 같은 규칙을 그대로 적용하면 된다(계기 자기결함이 P2 전용이라 여기 안 옮는다)."""
+    bl, cmp_b = collect_lines(base_path, JIT, ALN)
+    cur, cmp_c = collect_lines(cur_path, JIT, ALN)
+    b = set(bl)
+    new = [l for l in cur if l not in b]
+    gone = [l for l in bl if l not in set(cur)]
+    return new, gone, cmp_b, cmp_c
+
+
+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 관례)."""
+    deck_s = (cfg.get('surfaces_by_id') or {}).get('built_deck')
+    if not deck_s:
+        return [], ['P1/P3 geometry : built_deck 미선언 — NOT_CONFIGURED (0 아님)']
+    deck = _resolve(root, deck_s['path'])
+    if not os.path.exists(deck):
+        return [], [f'P1/P3 geometry : built_deck 실물 없음({deck}) — UNMEASURED (0 아님)']
+    spec = cfg.get('geometry') or {}
+    JIT = int(spec.get('jitter_emu', 200000))
+    ALN = int(spec.get('align_emu', 63500))
+    base_p = spec.get('baseline')
+    notes = []
+
+    if base_p:
+        base = _resolve(root, base_p)
+        if not os.path.exists(base):
+            return [], [f'P1/P3 geometry : baseline 실물 없음({base}) — UNMEASURED (0 아님)']
+        try:
+            new, gone, cmp_b, cmp_c = delta(base, deck, JIT, ALN)
+        except Exception as e:
+            return [], [f'P1/P3 geometry : 계기 오류({type(e).__name__}: {e}) — UNMEASURED (0 아님)']
+        notes.append(f'P1/P3 geometry(델타) : 기준 {os.path.basename(base)} 대비 '
+                     f'새 어긋남 {len(new)}건 · 사라진 어긋남 {len(gone)}건 🟥 advisory '
+                     f'(P1 대조된 도형-쌍: 기준 {cmp_b} · 현재 {cmp_c}'
+                     + ('' if cmp_b and cmp_c else ' — 🟥 0건이면 UNMEASURED, 「튐 없음」이 아니다') + ')')
+        for l in new:
+            notes.append('   + ' + l.strip())
+        for l in gone:
+            notes.append('   - ' + l.strip())
+        return [], notes
+
+    try:
+        lines, compared = collect_lines(deck, JIT, ALN)
+    except Exception as e:
+        return [], [f'P1/P3 geometry : 계기 오류({type(e).__name__}: {e}) — UNMEASURED (0 아님)']
+    notes.append(f'P1/P3 geometry(목록) : 후보 {len(lines)}건 — 🟥 절대 목록으로 읽지 마라, '
+                 f'P3 기저 오탐이 코퍼스마다 수십 건일 수 있다(원 코퍼스 실측 76건). '
+                 f'`geometry.baseline` 을 쓰는 편집-델타 용법이 정확하다 '
+                 f'(P1 대조된 도형-쌍 {compared}'
+                 + ('' if compared else ' — 🟥 UNMEASURED, 「튐 없음」이 아니다') + ')')
+    for l in lines:
+        notes.append(l)
+    return [], notes

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

@@ -74,7 +74,10 @@ def scan(texts, surf_meta, max_report=8, mod=None):
         text = texts[sid][0]
         if mod is not None:
             speech = []
-            for _uid, _h, body, _r in mod.units(text):
+            # 🟥 2026-09-04 — units() 가 이제 pattern 을 받는다. 이 표면의 surfaces.yaml
+            #    unit_pattern 선언을 그대로 넘긴다(interslide_deps 신호 §3-1 과 같은 수리).
+            _pat = surf_meta.get(sid, {}).get('unit_pattern')
+            for _uid, _h, body, _r in mod.units(text, pattern=_pat):
                 _sc, sp = mod.blocks(body)
                 speech.append(sp if isinstance(sp, str) else '\n'.join(sp))
             text = '\n'.join(speech) or text

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

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+"""L13 — «N 페이지» 리터럴 장 번호 참조가 실재하는 장을 가리키나 (2026-09-06 신설).
+
+WHY: 장을 하나 빼면 그 뒤 번호가 통째로 당겨진다. preprep 의 이웃 레인들은 **말로 가리키는
+것**만 본다 — L5/L8 은 화면 재사용·시각 지시를, R1~R5 는 접속어·소유권을. **숫자로 가리키는
+것은 어느 레인도 안 봤다.** 실사고 계기: if(kakao) 덱에서 42장을 빼자 43~121 이 한 칸씩
+당겨졌고, 「깨진 참조가 어디냐」를 손으로 훑어야 했다(2026-09-06, 운영자 지적).
+
+🟥 이 레인의 난점은 검출이 아니라 **분류**다. 같은 «숫자+단위»가 세 가지 다른 것을 가리킨다 —
+실측 코퍼스(그 덱 121장)에서 셋이 **전부** 나왔다:
+
+    SLIDE     「40p 부제가 …」          → 진짜 장 참조. 이것만 검사 대상이다
+    SECTION   「3장에서 게이트부터」      → 슬라이드가 아니라 **섹션**(그 덱의 sec-guide 「3. 어떻게 만들었나」)
+    CITATION  「arXiv:2606.05647 (4p)」 → 인용 **논문 쪽수**
+
+셋을 안 가르면 오탐 덩어리가 된다. 그래서 판별자는 코퍼스에서 기계로 뽑는다:
+  · SECTION  — 덱의 섹션 라벨(「N. 제목」)에서 N 집합을 모으고, 「N장」 형태이면서 그 집합에
+              속하면 섹션이다. 라벨이 없으면 이 분기는 **비활성**이고 그 사실을 노트에 적는다.
+  · CITATION — 같은 줄에 인용 표지(arXiv/doi/『』/pp./4자리 연도)가 있으면 인용 쪽수다.
+
+🟥 **판정은 «존재»만 한다** — «그 번호가 맞는 장을 가리키나»는 의미 판단이라 안 본다
+(§Mechanization Boundary: 기록의 속성만 단언한다). 그래서 finding 은 **범위 밖 참조**
+하나뿐이고, 자기 자신 참조·정상 참조는 노트로만 나간다.
+
+🟥 **참조 0건은 «통과»가 아니다** — 추출이 죽어도 0이 나온다. 0이면 UNMEASURED 로 적는다.
+"""
+import os
+import re
+
+# 「40p」 「40 페이지」 「40쪽」 「3장에서」…
+REF = re.compile(r'(?<![0-9A-Za-z])(\d{1,3})\s*(p\b|페이지|쪽(?!수)|장(?=에서|의|을|부터|에))')
+# 🟥 `\s+` 가 하중을 진다 — 초판은 `\s*` 였고 실측 코퍼스의 «62.5%» 를 «62번 섹션»으로
+#    먹었다. 그러면 진짜 「62장」 참조가 조용히 SECTION 으로 분류돼 사라진다.
+#    섹션 라벨은 점 뒤에 공백이 있다(「3. 어떻게 만들었나」). 소수점은 없다.
+SECTION_LABEL = re.compile(r'^\s*(\d{1,2})\.\s+\S')
+SECTION_MAX = 20      # 섹션이 20을 넘는 덱은 없다 — 넘으면 라벨이 아니다
+SECTION_MIN_SLIDES = 2  # 섹션 라벨은 여러 장에 반복된다(한 장짜리는 라벨이 아니다)
+CITE = re.compile(r'arXiv|doi|『|』|pp\.|\b(19|20)\d{2}\b', re.I)
+
+
+def _texts(slide):
+    scr, note = [], ''
+    for sh in slide.shapes:
+        if sh.has_text_frame:
+            t = ' '.join(r.text for p in sh.text_frame.paragraphs for r in p.runs)
+            if t.strip():
+                scr.append(t)
+    if slide.has_notes_slide:
+        note = slide.notes_slide.notes_text_frame.text or ''
+    return scr, note
+
+
+def section_numbers(prs):
+    """섹션 라벨(「N. 제목」)에서 N 을 모은다. 못 모으면 빈 집합 — 그 사실이 노트에 적힌다.
+
+    세 조건을 **함께** 건다: 점 뒤 공백(소수점 배제) · N ≤ SECTION_MAX · 여러 장에 반복.
+    하나만 걸면 실측에서 뚫린다(위 주석의 62.5% 사례).
+    """
+    seen = {}
+    for i, s in enumerate(prs.slides, 1):
+        for sh in s.shapes:
+            if not sh.has_text_frame:
+                continue
+            for p in sh.text_frame.paragraphs:
+                line = ''.join(r.text for r in p.runs).strip()
+                m = SECTION_LABEL.match(line)
+                if m and len(line) < 40:
+                    n = int(m.group(1))
+                    if n <= SECTION_MAX:
+                        seen.setdefault(n, set()).add(i)
+    return {n for n, slides in seen.items() if len(slides) >= SECTION_MIN_SLIDES}
+
+
+def classify(num, unit, line, secs):
+    if CITE.search(line):
+        return 'CITATION'
+    if unit.startswith('장') and num in secs:
+        return 'SECTION'
+    return 'SLIDE'
+
+
+def analyze(prs):
+    total = len(prs.slides)
+    secs = section_numbers(prs)
+    rows = []
+    for i, s in enumerate(prs.slides, 1):
+        scr, note = _texts(s)
+        for where, chunks in (('화면', scr), ('대본', note.split('\n'))):
+            for line in chunks:
+                for m in REF.finditer(line):
+                    n, unit = int(m.group(1)), m.group(2)
+                    kind = classify(n, unit, line, secs)
+                    rows.append((i, where, n, unit, kind, line.strip()[:70]))
+    return total, secs, rows
+
+
+def scan(cfg, root):
+    deck_s = (cfg.get('surfaces_by_id') or {}).get('built_deck')
+    if not deck_s:
+        return [], ['L13 slide-refs : built_deck 미선언 — NOT_CONFIGURED (0 아님)']
+    path = os.path.normpath(os.path.join(root, os.path.expanduser(deck_s['path'])))
+    if not os.path.exists(path):
+        return [], [f'L13 slide-refs : built_deck 실물 없음({path}) — UNMEASURED (0 아님)']
+    try:
+        from pptx import Presentation
+        prs = Presentation(path)
+        total, secs, rows = analyze(prs)
+    except Exception as e:
+        return [], [f'L13 slide-refs : 계기 오류({type(e).__name__}: {e}) — UNMEASURED (0 아님)']
+
+    per = {}
+    for _, _, _, _, k, _ in rows:
+        per[k] = per.get(k, 0) + 1
+    notes = [f'L13 slide-refs : {total}장 · 참조 {len(rows)}건 '
+             f'(SLIDE {per.get("SLIDE",0)} · SECTION {per.get("SECTION",0)} · CITATION {per.get("CITATION",0)}) '
+             f'· 섹션 번호 집합 {sorted(secs) if secs else "없음 — SECTION 분기 비활성"}']
+    if not rows:
+        notes.append('   ⚠️ 참조 0건 — 「깨끗하다」가 아니라 **UNMEASURED** 다(추출이 죽어도 0이 나온다). '
+                     '덱에 번호 참조가 원래 없으면 정상이고, 그 사실을 여기서 확인해라')
+        return [], notes
+
+    findings = []
+    for i, where, n, unit, kind, line in rows:
+        if kind != 'SLIDE':
+            continue
+        if n < 1 or n > total:
+            findings.append((f'{path}#s{i}', 'use',
+                             f'L13 장 번호 참조가 범위 밖이다 — s{i} [{where}] →{n} (총 {total}장) : {line}'))
+            notes.append(f'   ❌ s{i:3} [{where}] →{n:3}  범위 밖(총 {total}) : {line}')
+        elif n == i:
+            notes.append(f'   ⚠️ s{i:3} [{where}] →{n:3}  자기 자신 참조 : {line}')
+        else:
+            notes.append(f'   ·  s{i:3} [{where}] →{n:3}  : {line}')
+    return findings, notes