@chrono-meta/fh-gate 3.4.0 → 3.6.0

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

@@ -1,181 +0,0 @@
-#!/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/test_preprep_lanes_rp.py

@@ -1,184 +0,0 @@
-#!/usr/bin/env python3
-"""R1~R5 · P1/P3 self-test — known-pair 계량 + 실물 재현.
-
-exit 0 = 전부 통과 · 1 = 실패 있음 · 2 = 픽스처 생성 불가(python-pptx 부재 등, UNMEASURED)
-
-구성:
-  ① known-pair — `fixtures/mk_slide_fixtures.py` 로 R1·R2·R4·R5·P1·P3 를 테스트 시점에 만든다
-     (R3 는 예외 — 실물 구조 2장을 줄인 `fixtures/fixture_R3_{positive,negative}.pptx` 를 쓴다.
-     선두 줄 판별이 절대좌표·srgbClr 런 구조에 기대므로, 검출기 가정대로 «생성»한 픽스처는
-     검출기 자신을 검증 못 한다 — 자기참조. `tracks-meta` 원장이 지목한 방침)
-  ② --baseline 델타 모드 — 편집 전/후 한 쌍에서 새 어긋남 1건만 잡히는지
-  ③ 실물 재현 — 실제 백업 pptx(환경변수 PREPREP_REAL_CORPUS 가 가리키는 디렉터리, 있을 때만)에 돌려 원장이 인용한 실사고 4+1건이
-     그대로 뜨는지 확인한다. 그 코퍼스가 없는 머신에서는 SKIP(«통과»로 세지 않는다).
-"""
-import os
-import sys
-
-HERE = os.path.dirname(os.path.abspath(__file__))
-sys.path.insert(0, HERE)
-sys.path.insert(0, os.path.join(HERE, 'fixtures'))
-
-PASS, FAIL, SKIP = 0, 0, 0
-
-
-def ok(msg):
-    global PASS
-    PASS += 1
-    print('  ✅', msg)
-
-
-def ng(msg):
-    global FAIL
-    FAIL += 1
-    print('  ❌', msg)
-
-
-def sk(msg):
-    global SKIP
-    SKIP += 1
-    print('  ⏭ ', msg, '— SKIPPED (PASS 아님)')
-
-
-def codes_of(deck_path, LSR):
-    deck = LSR.Deck(deck_path)
-    F = LSR.analyze(deck)
-    return F, {k for k, _, _ in F}
-
-
-def run_known_pairs(fx_dir):
-    print('\n[1] known-pair — R1·R2·R4·R5·P1·P3 (생성 픽스처) + R3 (실물 픽스처)')
-    import lane_slide_relations as LSR
-    import lane_geometry as LG
-
-    # R1
-    _, cp = codes_of(os.path.join(fx_dir, 'r1_pos.pptx'), LSR)
-    _, cn = codes_of(os.path.join(fx_dir, 'r1_neg.pptx'), LSR)
-    ok('R1 known-positive 검출') if 'R1' in cp else ng(f'R1 known-positive 미검출 ({cp})')
-    ok('R1 known-negative 무검출') if 'R1' not in cn else ng(f'R1 known-negative에서 오탐 ({cn})')
-
-    # R2
-    _, cp = codes_of(os.path.join(fx_dir, 'r2_pos.pptx'), LSR)
-    _, cn = codes_of(os.path.join(fx_dir, 'r2_neg.pptx'), LSR)
-    ok('R2 known-positive 검출') if 'R2' in cp else ng(f'R2 known-positive 미검출 ({cp})')
-    ok('R2 known-negative 무검출') if 'R2' not in cn else ng(f'R2 known-negative에서 오탐 ({cn})')
-
-    # R3 — 실물 픽스처 (자기참조 회피)
-    r3p = os.path.join(HERE, 'fixtures', 'fixture_R3_positive.pptx')
-    r3n = os.path.join(HERE, 'fixtures', 'fixture_R3_negative.pptx')
-    if os.path.exists(r3p) and os.path.exists(r3n):
-        _, cp = codes_of(r3p, LSR)
-        _, cn = codes_of(r3n, LSR)
-        ok('R3 known-positive(실물 2장) 검출') if 'R3' in cp else ng(f'R3 known-positive 미검출 ({cp})')
-        ok('R3 known-negative(실물 2장) 무검출') if 'R3' not in cn else ng(f'R3 known-negative에서 오탐 ({cn})')
-    else:
-        sk('R3 known-pair — fixture_R3_{positive,negative}.pptx 없음')
-
-    # R4
-    Fp, cp = codes_of(os.path.join(fx_dir, 'r4_pos.pptx'), LSR)
-    Fn, cn = codes_of(os.path.join(fx_dir, 'r4_neg.pptx'), LSR)
-    ok('R4 known-positive 검출(아웃라이어 500자)') if 'R4' in cp else ng(f'R4 known-positive 미검출 ({cp})')
-    ok('R4 known-negative 무검출(동값 분포)') if 'R4' not in cn else ng(f'R4 known-negative에서 오탐 ({cn})')
-
-    # R5
-    Fp, cp = codes_of(os.path.join(fx_dir, 'r5_pos.pptx'), LSR)
-    Fn, cn = codes_of(os.path.join(fx_dir, 'r5_neg.pptx'), LSR)
-    ok('R5 known-positive 검출(비율 30.0)') if 'R5' in cp else ng(f'R5 known-positive 미검출 ({cp})')
-    ok('R5 known-negative 무검출(동일 비율)') if 'R5' not in cn else ng(f'R5 known-negative에서 오탐 ({cn})')
-
-    # P1 — 3팔(임계 안 소폭 이동은 뜼다 · 임계 밖 큰 이동은 안 뜼다 · 무이동은 안 뜼다)
-    lines, compared = LG.collect_lines(os.path.join(fx_dir, 'p1.pptx'), 200000, 63500)
-    p1_lines = [l for l in lines if 'gate_bar' in l]
-    ok(f'P1 대조된 도형-쌍 {compared} > 0 (비교 안함 아님)') if compared > 0 else ng('P1 compared=0 — UNMEASURED')
-    ok(f'P1 후보 정확히 1건(임계 안 이동만)') if len(p1_lines) == 1 else ng(f'P1 후보 {len(p1_lines)}건 (want 1) — {p1_lines}')
-    if p1_lines:
-        ok('P1 유일 후보가 정확히 (1→2p) 소폭 이동 — 큰 이동(2→3p)·무이동(3→4p)은 안 뜬다') \
-            if '1p→2' in p1_lines[0].replace(' ', '') else ng(f'P1 후보가 엉뚱한 쌍을 가리킨다 {p1_lines}')
-
-    # P3
-    lines3, _ = LG.collect_lines(os.path.join(fx_dir, 'p3.pptx'), 200000, 63500)
-    p3_lines = [l for l in lines3 if 'stub' in l]
-    ok('P3 후보 정확히 1건(임계 안 틀/겹침만)') if len(p3_lines) == 1 else ng(f'P3 후보 {len(p3_lines)}건 (want 1) — {p3_lines}')
-
-
-def run_baseline_delta(fx_dir):
-    print('\n[2] --baseline 델타 모드 — 편집 전/후 한 쌍')
-    import lane_geometry as LG
-    new, gone, cmp_b, cmp_c = LG.delta(os.path.join(fx_dir, 'geo_base.pptx'),
-                                        os.path.join(fx_dir, 'geo_edited.pptx'), 200000, 63500)
-    ok('델타 새 어긋남 정확히 1건') if len(new) == 1 else ng(f'델타 새 어긋남 {len(new)}건 (want 1)')
-    ok('델타 사라진 어긋남 0건(깨끗한 기준본)') if len(gone) == 0 else ng(f'델타 사라진 어긋남 {len(gone)}건 (want 0)')
-    ok(f'기준본 대조 {cmp_b} > 0 · 현재본 대조 {cmp_c} > 0') if cmp_b > 0 and cmp_c > 0 \
-        else ng(f'기준본/현재본 대조 0 있음 — UNMEASURED (cmp_b={cmp_b}, cmp_c={cmp_c})')
-    # scan(cfg, root) 래퍼로도 동일하게 도는지 확인 (preprep.py 가 실제로 부르는 경로)
-    cfg = {'surfaces_by_id': {'built_deck': {'path': os.path.join(fx_dir, 'geo_edited.pptx')}},
-           'geometry': {'baseline': os.path.join(fx_dir, 'geo_base.pptx')}}
-    fP, nP = LG.scan(cfg, '.')
-    ok('scan(cfg, root) 래퍼가 델타 모드로 도고 새 어긋남 1건을 notes 에 낸다') \
-        if any('새 어긋남 1건' in n for n in nP) else ng(f'scan() 델타 출력 이상 — {nP}')
-
-
-REAL_BASE = os.environ.get('PREPREP_REAL_CORPUS', '')  # 기본값 없음 — 다른 머신에서 거짓 SKIP 방지(SKIP != PASS)
-REAL_TARGETS = [
-    ('ifkakao26_slides_v1.3_pre-engine-strip_20260904_210857.pptx', 'R1', 40,
-     '선두 줄이 «그러나»로 뒤집는데'),
-    ('ifkakao26_slides_v1.3_pre-40p_20260904_213452.pptx', 'R2', 41,
-     '«이 셋/세 가지»라 부르는데 번호가 없다'),
-    ('ifkakao26_slides_v1.3_pre-38trim_20260904_210428.pptx', 'R4', 38,
-     '화면 250자'),
-    ('ifkakao26_slides_v1.3_pre-40p_20260904_213452.pptx', 'R5', 112,
-     '29.2자/초'),
-]
-
-
-def run_real_corpus():
-    print('\n[3] 실물 재현 (PREPREP_REAL_CORPUS 백업, 있을 때만) — 원장이 인용한 실사고 4+1건')
-    if not os.path.isdir(REAL_BASE):
-        sk(f'실물 코퍼스 미지정/미존재({REAL_BASE or "PREPREP_REAL_CORPUS unset"}) — SKIP, 통과 아님')
-        return
-    import lane_slide_relations as LSR
-    import lane_geometry as LG
-    for fname, code, want_page, want_sub in REAL_TARGETS:
-        p = os.path.join(REAL_BASE, fname)
-        if not os.path.exists(p):
-            sk(f'{fname} 없음 — 재현 건너뜀')
-            continue
-        deck = LSR.Deck(p)
-        F = LSR.analyze(deck)
-        hit = [x for x in F if x[0] == code and abs(x[1] - want_page) <= 1 and want_sub in x[2]]
-        ok(f'{code} 실물 재현 — {fname} 약 {want_page}p — {hit[0][2][:60] if hit else ""}') \
-            if hit else ng(f'{code} 실물 미재현 — {fname}')
-
-    # P1/P3 36p (보너스 확인 — 원장이 명시적으로 요구한 4건에는 없지만 신호 자체의 원적 사건)
-    align36 = os.path.join(REAL_BASE, 'ifkakao26_slides_v1.3_pre-align36_222442.pptx')
-    if os.path.exists(align36):
-        lines, compared = LG.collect_lines(align36, 200000, 63500)
-        hit_p1 = any('s5017' in l and '35000' in l and '35p' in l.replace(' ', '') for l in lines)
-        hit_p3 = any('s5016' in l and 's5017' in l and '35000' in l for l in lines)
-        ok('P1 실물 재현 — 35p→36p s5017 x -35,000') if hit_p1 else ng('P1 실물 미재현')
-        ok('P3 실물 재현 — 36p s5016→s5017 겹침 35,000') if hit_p3 else ng('P3 실물 미재현')
-    else:
-        sk('ifkakao26_slides_v1.3_pre-align36_222442.pptx 없음 — P1/P3 보너스 재현 건너뜀')
-
-
-def main():
-    try:
-        import mk_slide_fixtures
-    except ImportError as e:
-        print(f'❌ python-pptx 또는 픽스처 모듈 부재 — UNMEASURED: {e}')
-        return 2
-    import tempfile
-    fx_dir = tempfile.mkdtemp(prefix='preprep_lanes_rp_')
-    mk_slide_fixtures.build_all(fx_dir)
-    print(f'픽스처 생성: {fx_dir}')
-
-    run_known_pairs(fx_dir)
-    run_baseline_delta(fx_dir)
-    run_real_corpus()
-
-    print(f'\n결과: {PASS} passed · {FAIL} failed · {SKIP} skipped (skip != pass)')
-    return 1 if FAIL else 0
-
-
-if __name__ == '__main__':
-    sys.exit(main())