@chrono-meta/fh-gate 2.15.1 → 3.1.0

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

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""R1·R2·R4·R5·P1·P3 의 known-pair pptx 를 **테스트 시점에** 만든다 — 레포에 커밋하지 않는다.
+
+🟥 R3 는 여기서 안 만든다. 선두 줄 판별이 절대좌표(LEAD_MAX_Y·LEAD_MIN_CX)와 srgbClr 런 구조에
+   기대므로, 검출기 가정에 맞춰 python-pptx 로 «생성»한 픽스처는 검출기 자신을 검증 못 한다
+   (자기참조). 대신 실물 구조를 그대로 2장으로 줄인 `fixture_R3_positive.pptx` ·
+   `fixture_R3_negative.pptx` 를 쓴다(이 디렉터리에 실물로 있다).
+
+슬라이드 크기는 원 코퍼스와 같은 1920pt 계열(24,384,000 × 13,716,000 EMU)로 맞춘다 — P1/P3 는
+상대좌표 비교라 크기 자체는 판정에 안 들어가지만, R1/R3 의 `LEAD_MIN_CX`(12,000,000 EMU) 가
+«슬라이드 절반 폭» 정도를 가정하므로 실물 규모에서 벗어나면 그 가정을 검증 못 한다.
+"""
+import os
+from pptx import Presentation
+from pptx.util import Emu
+from pptx.dml.color import RGBColor
+
+SLIDE_W, SLIDE_H = Emu(24384000), Emu(13716000)
+ACCENT = RGBColor(0xFA, 0xE1, 0x00)
+
+
+def _new_deck():
+    prs = Presentation()
+    prs.slide_width, prs.slide_height = SLIDE_W, SLIDE_H
+    return prs
+
+
+def _blank(prs):
+    return prs.slides.add_slide(prs.slide_layouts[6])
+
+
+def _box(slide, name, x, y, w, h, text=None, accent=False):
+    tb = slide.shapes.add_textbox(Emu(x), Emu(y), Emu(w), Emu(h))
+    tb.name = name
+    if text is not None:
+        p = tb.text_frame.paragraphs[0]
+        r = p.add_run()
+        r.text = text
+        if accent:
+            r.font.color.rgb = ACCENT
+    return tb
+
+
+def _notes(slide, text):
+    slide.notes_slide.notes_text_frame.text = text
+
+
+# ── R1 orphan-connective ─────────────────────────────────────────────────────
+# 제목은 폭을 좁혀 lead 자격에서 뺀다(LEAD_MIN_CX=12,000,000 미만) — 선두 줄만 lead 로 잡히게.
+def r1(path, positive):
+    prs = _new_deck()
+    s0 = _blank(prs)
+    _box(s0, 'title0', 100000, 100000, 5000000, 500000, '첫 장')
+    prev_body = ('오늘은 깃허브 사용법을 설명합니다' if not positive
+                 else '오늘은 배포 절차를 설명합니다')
+    _box(s0, 'body0', 100000, 2000000, 8000000, 800000, prev_body)
+    s1 = _blank(prs)
+    _box(s1, 'title1', 100000, 100000, 5000000, 500000, '둘째 장')
+    _box(s1, 'lead1', 100000, 900000, 14000000, 900000, '그러나 깃허브는 막을 자리를 줄 뿐입니다')
+    _box(s1, 'body1', 100000, 2500000, 8000000, 800000, '본문 내용입니다')
+    prs.save(path)
+
+
+# ── R2 enum-dropped ──────────────────────────────────────────────────────────
+def r2(path, positive):
+    prs = _new_deck()
+    s0 = _blank(prs)
+    _box(s0, 'enum0', 100000, 100000, 14000000, 900000,
+         '① 속도 개선 ② 품질 향상 ③ 비용 절감')
+    s1 = _blank(prs)
+    _box(s1, 'title1', 100000, 100000, 14000000, 900000, '이 셋 중 무엇이 가장 중요한가')
+    body = ('① 속도 ② 품질 ③ 비용을 함께 고려합니다' if not positive
+            else '속도와 품질과 비용을 함께 고려합니다')
+    _box(s1, 'body1', 100000, 2000000, 14000000, 900000, body)
+    prs.save(path)
+
+
+# ── R4 screen-heavy (자기 분포 P90, N=12) ────────────────────────────────────
+# 🟥 negative 는 «값을 살짝 낮춘 아웃라이어」가 아니라 **전부 동값**으로 짠다 — N=12 처럼 작은
+#    표본에서는 살짝 낮춰도 sorted 순서상 «둘째로 큰 값」이 바뀌어 p90 인덱스가 다른 정상값을
+#    가리키고, 그 값이 다시 «최댓값이라 p90 초과」가 되는 자기충족 오탐이 난다(실측으로 확인).
+#    전부 동값이면 어떤 값도 p90 을 **엄격히** 못 넘어(같음은 초과가 아니다) 후보가 구조적으로 0.
+def r4(path, positive):
+    prs = _new_deck()
+    for i in range(12):
+        s = _blank(prs)
+        n = 500 if (positive and i == 6) else 30
+        _box(s, f'body{i}', 100000, 100000, 14000000, 900000, '가' * n)
+    prs.save(path)
+
+
+# ── R5 read-load (신규 글자 ÷ 발화 초, 자기 분포 P90, N=12) ─────────────────
+# 같은 이유로 negative 는 «전부 동일 비율」로 짠다(위 R4 와 같은 원리).
+def r5(path, positive):
+    """정상 슬라이드: 신규 64자 · 발화 12초(64/5.36≈12) → 비율 5.33.
+    아웃라이어(positive 만, 7번째 장): 신규 150자 · 발화 5초(27/5.36≈5) → 비율 30.0."""
+    prs = _new_deck()
+    for i in range(12):
+        s = _blank(prs)
+        if positive and i == 6:
+            _box(s, 'body_outlier', 100000, 100000, 14000000, 2000000,
+                 '완전히새로운화면내용' * 15)  # 150자, 이전 장과 겹치지 않는 새 문자열
+            _notes(s, '가' * 27)              # round(27/5.36) = 5초
+        else:
+            # 접두 2자리 인덱스로 매 장을 다르게 만든다(집합 차집합 비교라 «신규»로 잡히려면
+            # 이전 장과 텍스트가 겹치면 안 된다) — 나머지 62자는 동일해 길이는 항상 64자다
+            _box(s, f'body{i}', 100000, 100000, 14000000, 2000000, f'{i:02d}' + '가' * 62)
+            _notes(s, '가' * 64)              # round(64/5.36) = 12초
+    prs.save(path)
+
+
+# ── P1 build-jitter (같은 이름 도형, 연속 4장) ───────────────────────────────
+def p1(path):
+    """4장 · 이름 «gate_bar» 공유. 쌍(1→2)=임계 안 소폭 이동(뜸) · (2→3)=임계 밖 큰 이동(안 뜸) ·
+    (3→4)=무이동(안 뜸). compared=3 이어야 «비교 안 함»이 아니다."""
+    prs = _new_deck()
+    xs = [1000000, 1030000, 6030000, 6030000]  # +30,000(JIT 200,000 안) · +5,000,000(밖) · +0
+    for x in xs:
+        s = _blank(prs)
+        _box(s, 'gate_bar', x, 2000000, 1000000, 500000, '게이트 막대')
+    prs.save(path)
+
+
+# ── P3 adjacency (오른끝 ↔ 왼끝) ─────────────────────────────────────────────
+def p3(path):
+    """slide1 = 임계 안 어긋남(뜸) · slide2 = 정확히 맞닿음(0, 안 뜸) + 임계 밖 큰 틈(안 뜸)."""
+    prs = _new_deck()
+    s1 = _blank(prs)
+    _box(s1, 'stub_a', 1000000, 2000000, 1000000, 500000, 'A')     # 오른끝 2,000,000
+    _box(s1, 'bar_b', 2020000, 2000000, 1000000, 500000, 'B')      # 왼끝 2,020,000 · 틈 20,000(<ALN)
+    s2 = _blank(prs)
+    _box(s2, 'stub_c', 1000000, 2000000, 1000000, 500000, 'C')     # 오른끝 2,000,000
+    _box(s2, 'bar_d', 2000000, 2000000, 1000000, 500000, 'D')      # 왼끝 2,000,000 · 틈 0 (맞닿음)
+    _box(s2, 'stub_e', 1000000, 4000000, 1000000, 500000, 'E')     # 오른끝 2,000,000
+    _box(s2, 'bar_f', 3000000, 4000000, 1000000, 500000, 'F')      # 왼끝 3,000,000 · 틈 1,000,000(>ALN)
+    prs.save(path)
+
+
+# ── P1/P3 --baseline 델타 쌍 ──────────────────────────────────────────────────
+def geometry_baseline_pair(base_path, edited_path):
+    """base = 깨끗한 2장(후보 0). edited = 2장째 도형 하나를 소폭(30,000 EMU) 옮긴 사본
+    (새 P1 후보 정확히 1건)."""
+    prs = _new_deck()
+    s1 = _blank(prs)
+    _box(s1, 'gate_bar', 1000000, 2000000, 1000000, 500000, '게이트')
+    s2 = _blank(prs)
+    _box(s2, 'gate_bar', 1000000, 2000000, 1000000, 500000, '게이트')
+    prs.save(base_path)
+
+    prs2 = _new_deck()
+    t1 = _blank(prs2)
+    _box(t1, 'gate_bar', 1000000, 2000000, 1000000, 500000, '게이트')
+    t2 = _blank(prs2)
+    _box(t2, 'gate_bar', 1030000, 2000000, 1000000, 500000, '게이트')  # +30,000 EMU
+    prs2.save(edited_path)
+
+
+def build_all(outdir):
+    os.makedirs(outdir, exist_ok=True)
+    r1(os.path.join(outdir, 'r1_pos.pptx'), True)
+    r1(os.path.join(outdir, 'r1_neg.pptx'), False)
+    r2(os.path.join(outdir, 'r2_pos.pptx'), True)
+    r2(os.path.join(outdir, 'r2_neg.pptx'), False)
+    r4(os.path.join(outdir, 'r4_pos.pptx'), True)
+    r4(os.path.join(outdir, 'r4_neg.pptx'), False)
+    r5(os.path.join(outdir, 'r5_pos.pptx'), True)
+    r5(os.path.join(outdir, 'r5_neg.pptx'), False)
+    p1(os.path.join(outdir, 'p1.pptx'))
+    p3(os.path.join(outdir, 'p3.pptx'))
+    geometry_baseline_pair(os.path.join(outdir, 'geo_base.pptx'),
+                            os.path.join(outdir, 'geo_edited.pptx'))
+    return outdir
+
+
+if __name__ == '__main__':
+    import sys, tempfile
+    d = sys.argv[1] if len(sys.argv) > 1 else tempfile.mkdtemp(prefix='preprep_fixtures_')
+    build_all(d)
+    print('built into', d)

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