leerness 1.36.95 → 1.36.96

package/CHANGELOG.md

@@ -1,5 +1,101 @@
 # Changelog
 
+## 1.36.96 — 2026-07-31 — 실행기를 만들지 않고 문서를 띄운다 (P-0010)
+
+사용자 요청: *"leerness.html 대신 exe 같은 실행기로 로드맵·그래프·스킬·기술·핸드오프·플랜 마크다운을 그대로 띄울 수 있나? 성능에 영향을 준다면 leerness.html 로 유지하고 거기에 반영."*
+
+**실행기는 만들지 않았다.** exe/Electron 은 런타임 의존성 0 · install script 0 · 사용자 저장소에 실행기 파일 미생성이라는 경계를 깬다 — 그 경계는 1.36.90 에서 테스트로 못박아 뒀다. 사용자가 준 조건("성능에 영향을 준다면 leerness.html 에 반영")이 그대로 답이었다. 같은 목적을 **정적 단일 파일 안에서** 이룬다.
+
+**📄 문서 탭** — `.harness` 핵심 문서 7종(플랜·스킬·기술 프로필·세션 핸드오프·현재 상태·진행 추적·결정 기록)을 `leerness.html` 안에서 그대로 읽는다. 좌측 목록 → 우측 본문, 브라우저만 있으면 된다.
+
+- **렌더러는 최소 부분집합만 해석한다** — 제목(H1~H6) · **단층** 목록(중첩은 평탄화) · 순서 목록(**원문 번호 보존** — 시작값과 건너뛴 번호를 `ol start`·`li value` 로) · 코드펜스 · 표(**정렬 반영**) · 링크 · 강조. 나머지는 **이스케이프된 평문**이다(예외: 자리표시자와 충돌하는 U+0001·U+0002 는 표시 전에 제거한다). 이 파일은 사용자 문서를 그대로 싣기 때문에 파서를 넓힐수록 XSS 면이 넓어진다. 원시 HTML(`<script>`, `<img onerror>`)은 글자로 남고, 링크는 `http(s)`/`mailto`/앵커/상대경로만 통과한다(`javascript:`·`data:`·`vbscript:`·프로토콜 상대 `//` 거부).
+- **자격증명 표지가 있는 문서는 본문을 아예 싣지 않는다.** 값 단위 마스킹을 다섯 번 고쳤고 매번 새 누출 경로가 나왔다(아래) — 그래서 **마스킹을 안전의 전제에서 뺐다**. 표지는 값이 아니라 **형식**으로만 정의해 줄 앞 접두어(`> `·`- `·들여쓰기)·대소문자·base64 조성·placeholder 모양에 의존하지 않는다. 마스킹(`redactSecrets`, 대시보드와 같은 술어)은 표지가 없는 문서에 대한 **두 번째 방어층**으로만 남는다.
+  - 비용을 먼저 쟀다 — 실제 프로젝트 문서 **156개 중 표지가 걸린 파일 1개(0.6%)**. 사실상 공짜라서 채택했다.
+  - 검증: 알려진 경로 **14종**(원본/인용문/목록/들여쓰기/CRLF/END없음 PEM 6 · `~`·`+`·`/` Bearer 3 · 소문자 `bearer` 1 · `AUTH=` 뒤 토큰 1 · placeholder 모양 1 · 반복 문자 1 · DB 접속문자열 1) 전부 본문 미포함. 이후 검수가 보인 **네 형태**(RFC6750 짧은 Bearer · 쿠키 · compact JWE · 강조로 감싼 스킴)도 같은 술어에서 검출된다. 표지 없는 문서는 그대로 실린다.
+- **상한과 고지**: 문서당 64KB · 전체 512KB(**UTF-8 바이트**). 잘리면 `x/y자(뒷부분만)` 로 적는다. 전체 상한이 남은 경우 **잔여 예산만큼 담고**, 잔여가 의미 없는 크기(전체 상한의 1/8, 최대 2KB)면 조각 대신 "담지 않았다"고 고지한다. (기본 7종에서는 7×64KB=448KB 라 전체 상한이 걸리지 않는다 — 목록이 늘 때를 위한 backstop 이고, 상한을 주입해 분기를 실제로 발화시켜 시험한다.) 누적 로그(진행 추적·결정 기록)는 **뒤**를 남기고 그 외는 앞을 남긴다 — 1.36.95 handoff 에서 고친 그 방향 규칙을 그대로 따른다.
+- 실측(이 저장소): 문서 탭이 `leerness.html` 에 더하는 양은 **+39.2KB**(120.8KB → 159.9KB). 자동 생성 기본값은 바꾸지 않았다.
+
+**만들면서 세 번 틀렸고, 셋 다 다른 방식으로 드러났다.**
+
+1. **코드스팬 자리표시자가 본문의 모든 숫자를 삼켰다.** 자리표시자를 감싸는 문자를 빠뜨려 복원 정규식이 `/(\d+)/g` 가 됐고, `1.36.96` 같은 평범한 숫자가 코드로 바뀌었다. 게다가 그 문자를 **원시 제어문자(U+0001)로** 소스에 심어 놓아 눈에 보이지도 않았다 — 명시적 ``\u0001`` 이스케이프로 바꿨다.
+2. **전체 상한 512KB 가 구조적으로 도달 불가능했다.** 7종 × 64KB = 448KB 라 `skipped` 분기가 한 번도 실행되지 않았고, 그걸 검사하던 `every` 는 빈 컬렉션 위에서 공허하게 참이었다. 상한값을 주입 가능하게 해 분기를 실제로 발화시켰다(측정: skipped 3건). 그 과정에서 **159자짜리 쓸모없는 조각**이 "잘림"으로 표시되던 것도 발견해, 잔여 예산이 의미 없으면 조각 대신 "담지 않았다"로 바꿨다.
+3. **좁은 화면에서 레이아웃이 무너졌다** — 190px 고정 내비가 자리를 다 먹어 본문이 한 글자씩 세로로 흘렀다. 테스트로는 보이지 않는 종류라 **실제 브라우저로 열어 봐야** 잡혔다. 760px 이하에서 내비를 가로 칩으로 접는다(실측: 375px 에서 본문 폭 90 → 323px, 가로 스크롤 0).
+
+**그리고 검수가 출하를 막았다 — 10건 중 7건이 재현됐고 전부 고쳤다.**
+
+- **P1 시크릿 누출 — 마스킹이 스캐너보다 약한 목록을 쓰고 있었다.** DB 접속문자열 비밀번호 · GitLab PAT · npm 토큰 · Stripe live 키 · SendGrid · 개인키가 **그대로 화면에 실렸다**(실측 6종). 전부 `catalogs.js` 의 `SECRET_PATTERNS` 에 **이미 있던** 패턴이다 — 한쪽 표면만 강화된 상태로 방치돼 있었다. 같은 목록을 공유하게 하고(placeholder·엔트로피 가드도 스캐너와 동일), 개인키는 BEGIN 줄만이 아니라 **블록 전체**를 지운다(종전엔 본문 base64 가 남았다). `leerness.html` 은 공유·첨부되는 파일이라 결과가 더 나빴다. 이 수정은 대시보드에도 함께 적용된다.
+- **P2 빈 경계 줄 하나가 문서 전체를 지웠다.** 선두 빈 줄 + 초장문 한 줄이면 `keep` 은 1 이 되는데 담긴 내용은 0자였다 — **70,000자 문서가 빈 화면**이 됐다(누적 로그는 끝 개행 하나로 같은 일이 났다). 줄 수가 아니라 담긴 **내용**으로 판정하고, 없으면 경계의 내용 있는 줄을 코드포인트로 자른다.
+- **P2 "64KB/512KB" 가 사실이 아니었다.** UTF-16 코드 단위를 세면서 KB 라고 적어, 한글 문서에서 합계 **1,152KB**(HTML 1.21MB)까지 실렸다. 상한을 UTF-8 바이트로 바꿔 주장을 참으로 만들었다.
+- **P2 링크 정규식이 O(n²) 였다.** 닫히지 않은 대괄호마다 남은 문자열 전체를 다시 훑어 64KB 입력에서 **1,825ms**(최악 2,730ms) 브라우저 메인 스레드가 멈췄다. 수량자를 유계로 바꿔 **41ms**(최악 23ms).
+- **P2 역슬래시 프로토콜 상대 URL 이 통과했다.** 슬래시 2개만 막았는데 브라우저는 역슬래시를 슬래시처럼 읽는다 — `\\host\share` 가 링크가 됐다.
+- **P2 e2e 가 계약을 깨는 변이 3종을 통과시켰다.** 허용 링크는 HTTPS 하나만, 제목은 H2 만 검사했고, `tech`·`progress` 두 문서는 아무것도 확인하지 않아 경로가 끊겨도 초록이었다.
+- **P3 링크를 만든 뒤 강조 정규식이 href 까지 다시 해석했다** — `href="https://a/<b>b</b>/c"`. 완성된 앵커를 자리표시자로 빼 둔다. 문서에 실제로 U+0001 이 있으면 자리표시자와 충돌하던 것도 함께 막았다.
+- **검수가 틀린 것도 있었다.** SendGrid "누출"은 세 번 연속 **내 픽스처**가 틀린 것이었고(뒤가 38자 → 같은 글자 반복 → 39자) 코드는 처음부터 정상이었다. 길이를 손으로 세지 말고 생성하도록 바꿨다. 마스킹 오탐 1건(`password = 사용자가…`)도 1.36.95 규칙만으로 재현해 **회귀가 아님**을 확인했다.
+
+**그리고 재검수가 다시 막았다 — 6건 중 3건이 위 수정이 만든 새 결함이었다.**
+
+- **P1 END 줄이 없는 개인키는 본문이 그대로 남았다.** "블록 전체를 지운다"는 규칙이 `-----END …-----` 를 요구했는데, 붙여넣다 잘린 키가 오히려 흔하다. BEGIN 뒤에 이어지는 base64/헤더 줄까지 함께 지운다.
+- **P2 빈 경계 줄이 두 개면 같은 데이터 소실이 재발했다.** 내가 "담긴 내용으로 판정"한다며 쓴 `acc` 에는 **줄바꿈 바이트가 포함**돼 있었다 — 빈 줄 두 개면 `acc=1` 이 되어 판정을 통과하고 70,000자가 줄바꿈 한 글자로 줄었다. 내용 바이트를 따로 센다. 픽스처를 빈 줄 **한 개**로만 만든 탓에 못 봤다.
+- **P2 스캐너 목록을 그대로 공유한 것이 정상 산문을 파괴했다.** 그 목록에는 `AWS secret …` · `Bearer …` 같은 **탐지 전용 문맥 휴리스틱**이 섞여 있다. 탐지에서 오탐은 경고 한 줄이지만, **가림에서 오탐은 사용자가 보는 문서를 조용히 훼손**한다(대시보드도 같은 함수를 쓴다). 실측: `결정: AWS secret commit <해시> was reverted` → `결정: *** was reverted`. 엔트로피 게이트로는 갈리지 않았다(진짜 AWS 키까지 placeholder 로 판정된다). 문맥 패턴은 가림에서 제외하고, Bearer 는 값에 숫자가 있을 때만 가린다. 남는 구멍(`Authorization:` 없이 적힌 영문자만의 Bearer 토큰)은 명시해 둔다.
+- P3 링크 길이 상한이 **이스케이프 후** 길이에 걸려 원문 796자짜리 정상 쿼리 URL 이 거부됐다(`&`→`&amp;` 팽창). 실측 비교로 라벨 300 / URL 4,000 을 골랐다 — 최악 115ms(무계는 1,747ms).
+- P3 잘림 고지의 "자" 가 UTF-16 코드 단위였다 — 이모지 문서에서 `32,767/60,001자` 로 표시되지만 실제는 `16,384/30,001자`. 코드포인트로 센다.
+- **내 실측이 "신규 오탐 0" 이라고 말했는데도 오탐이 실재했다.** 실제 문서 189개에 그런 문장이 없었을 뿐이다 — **실제 데이터 측정은 구성된 반례를 대체하지 못한다.**
+
+**세 번째 검수에서 7건이 더 나왔고, 같은 자리에서 세 번 틀린 것이 있었다.**
+
+- **P1 암호화 개인키의 본문이 샜다.** 암호화 키는 `Proc-Type:`/`DEK-Info:` 헤더 뒤 **빈 줄**이 오고 본문이 시작하는데, 규칙이 빈 줄에서 멈췄다. 반대로 아무 `Name: value` 줄이나 먹으면 BEGIN 을 인용한 정책 문서의 산문을 삼킨다 — 헤더는 **PEM 표준 이름만** 허용하고 본문 base64 줄이 최소 하나 있을 때만 확장한다.
+- **P1 무관한 산문을 통째로 삼키는 경로가 있었다(변이 실험 중 발견).** `[\s\S]*?` 로 BEGIN 과 END 를 잇는 규칙은 그 사이의 **아무 내용이나** 먹는다 — 종료되지 않은 키 하나가 문서 뒤쪽의 END 줄과 짝지어지면 사이의 모든 문단이 사라진다. 사이에는 PEM 헤더·base64·빈 줄만 허용하도록 좁혔다.
+- **P2 영문자만으로 된 32자 Bearer 토큰과, 구분자 없는 AWS 실값이 샜다.** 앞 라운드에서 오탐을 막으려고 건 조건이 실값까지 놓쳤다. Bearer 는 "숫자가 있거나 32자 이상", AWS 문맥은 패턴을 되살리되 **꼬리 값만** 치환한다(문장 구조는 남는다 — 커밋 해시가 함께 가려지는 것은 감수한다. 누출보다 낫다).
+- **P2 데이터 소실이 세 번째로 재발했다 — CRLF 의 `\r`, 공백, 탭이 "내용"으로 세어졌다.** `keep > 0` → `acc > 0` → `content > 0` 으로 세 번 고쳤고 매번 셈을 조금씩 틀렸다. **같은 자리에서 세 번 틀렸다면 픽스처가 아니라 접근이 틀린 것이다.** 셈을 없앴다 — 줄 단위로 담은 것과 경계 줄을 코드포인트로 자른 것을 **둘 다 만들어 긴 쪽**을 쓴다. 어떤 공백 조합에도 예산을 채우는 쪽이 이긴다.
+- **P2 URL 스킴 판정이 C0 제어문자로 우회됐다.** 탭·개행만 지웠는데 `\x03`·`\x01`·`\x00`·`\x1F`·`\x7F` 를 앞이나 중간에 끼우면 통과했다. C0 전체와 DEL 을 제거한다.
+**네 번째 검수에서 또 7건 — 그리고 "A를 고치면 B가 깨지는" 형태가 두 번 나왔다.**
+
+- **P1 20~31자 영문 Bearer 토큰이 샜다.** 앞 라운드에서 오탐을 막으려 건 길이 문턱(32자)이 실제 토큰을 놓쳤다 — OAuth 토큰 길이는 보장되지 않는다. **길이가 아니라 모양**으로 가른다: 낱말을 이어 붙인 camelCase(각 조각 3자 이상)만 산문으로 보고 나머지는 가린다. `authenticationMiddleware` 는 조각이 14/10자라 산문, `AbCdEfGhIj…` 는 조각이 2자라 토큰이다.
+- **P2 절단이 문서의 제목·푸터를 버렸다.** "줄 단위 결과와 코드포인트 절단 결과 중 긴 쪽" 이라는 앞 라운드의 수정이, 경계 줄이 길면 **앞부분을 통째로 버렸다** — `TITLE` + 초장문이면 `TITLE` 이 사라지고 화면 고지의 "앞부분만" 이 거짓이 된다. 온전한 줄로 채운 뒤 **남은 예산만큼 경계 줄을 이어 붙인다**. 그런데 그렇게만 하면 이번엔 평범한 문서까지 줄 중간에서 잘렸다 — **혼자서는 어떤 예산으로도 담길 수 없는 줄**일 때만 이어 붙이도록 좁혀 두 성질을 함께 만족시켰다.
+- **P2 BEGIN 인용 뒤의 평범한 영문 한 줄을 개인키 본문으로 오인해 지웠다.** 본문 요건이 16자였다. 40자로 올렸더니 이번엔 **줄이 짧게 감긴 키의 본문이 샜다**(내 회귀 확인에서 22자·16자 본문이 남았다). **길이가 아니라 내용**으로 가른다 — 진짜 base64 는 숫자나 `+ / =` 를 포함하고, 영문 낱말을 이어 붙인 식별자는 포함하지 않는다.
+- P3 PGP 블록은 END 앞 `=CRC` 줄을 허용하지 않아 CRC 와 END 가 남았다.
+- **두 번 다 "더 센 조건" 이 아니라 판별 기준 자체를 바꾸는 것이 답이었다.** 길이 문턱을 올렸다 내렸다 하면 한쪽이 반드시 새거나 파괴된다.
+
+**다섯 번째 검수가 그 "판별 기준"마저 양방향으로 깼다 — 그래서 원칙을 정했다.**
+
+- **P1 실제 RSA 키의 영문자 전용 본문 줄에서 51줄이 그대로 노출됐다.** 검수가 진짜 키를 생성해 16자로 감싸니 영문자만인 줄이 나왔고, "진짜 base64 는 숫자나 `+ / =` 를 포함한다"는 내 판별이 무너졌다. 반대 방향도 함께 무너졌다 — `PolicyVersion2026Final` 은 숫자를 포함한 22자 영숫자라 본문으로 분류돼 문서가 훼손됐다.
+- **P1 `Bearer abcdefghijklmnopqrst` · `Bearer CorrectHorseBatteryStaple` 같은 유효한 불투명 토큰이 산문으로 판정돼 노출됐다.** 낱말꼴 예외를 둔 순간 **그 예외가 곧 누출 경로**가 됐다.
+- **다섯 번 시도해 매번 한쪽이 깨졌다면, 그건 판별의 문제가 아니라 원칙의 문제다.** 값의 조성으로 시크릿과 산문을 가르려는 시도에는 반드시 반례가 있다. 그래서 원칙을 정했다 — **표시용 마스킹은 안전한 쪽으로 실패한다.** 값이 아니라 **문맥**으로 판정한다: `BEGIN` 마커 뒤의 **줄 전체에 공백이 없는 줄**은 키 재료로 본다. 산문은 거의 항상 공백을 포함하므로 문단은 살아남고, 어떤 조성의 키 본문도 새지 않는다. Bearer 도 예외를 없앴다.
+- **대가는 명시한다.** BEGIN 을 인용한 문서에서 **바로 뒤의 단일 토큰 한 줄**이 가려지고, `Use Bearer authenticationMiddleware for API requests.` 는 `Use *** for API requests.` 가 된다. 원본 파일은 그대로이고 이건 표시용 스냅샷이므로, 누출보다 이쪽이 낫다. (20자 미만은 카탈로그가 후보로 잡지 않으므로 `Bearer 인증` 같은 표현은 영향이 없다.)
+- 검증: 진짜 RSA 키를 생성해 16자·64자 두 방식으로 감싸고 END 유무까지 조합해 **본문 0줄 누출**을 확인했다.
+
+**여섯 번째 검수가 그 원칙마저 뚫었다 — 그래서 마스킹을 안전의 전제에서 뺐다.**
+
+- **P1 Markdown 인용문(`> `)으로 감싼 실제 개인키가 전량 노출됐다.** 내 규칙은 줄 앞에 공백·탭만 허용했다. README·정책 문서에서 키를 blockquote 로 인용하는 것은 자연스러운 마크다운이다. 16자 래핑에서 51/51, 64자에서 13/13 줄이 그대로 실렸다.
+- **P1 Bearer "예외 없음" 원칙에도 누출 경로가 넷 남아 있었다** — 카탈로그가 대문자 `Bearer` 만 받고 `~`·`+`·`/` 를 문자군에서 빠뜨렸으며, `AUTH=Bearer <토큰>` 은 앞부분만 가려 `AUTH=*** <실토큰>` 이라는 **거짓 안심**을 만들었고, placeholder 모양 토큰은 가드가 통과시켰다.
+- **여섯 번을 고쳤는데도 새 경로가 나온다면, 고치는 방향이 틀린 것이다.** 값 단위 마스킹이 완벽해야 안전한 구조를 버렸다 — **자격증명 표지가 하나라도 있으면 그 문서의 본문을 싣지 않는다.** 이제 마스킹이 부분적으로 실패해도 누출로 이어지지 않는다.
+- **변이가 5건 살아남아 픽스처의 결함도 드러났다** — 시크릿을 한 파일에 몰아넣으면 **표지끼리 서로를 가려 줘서**, 특정 표지를 무력화하는 변이가 그대로 통과했다. 표지 술어는 **하나씩 격리**해 단언한다(7/7 검출). 남은 생존 2건은 `_SECRET_BEARER` 가 먼저 가려 등가가 된 것이라 목록에서 뺐고, 마스킹 제거 변이는 "가드를 통과한 문서에도 두 번째 층이 살아 있는가" 단언을 넣어 잡았다.
+
+**일곱 번째 검수가 가장 아픈 것을 짚었다 — 내가 표면 하나만 보고 안전을 선언했다.**
+
+- **P1 문서 탭을 가드해도 같은 내용이 `nodes`·`roadmap` 으로 그대로 나갔다.** `decision add "Authorization: Bearer <토큰>"` 이 `DATA.nodes[].label` 과 `detail.decision` 에 원문으로 실렸다(실측). 그래프 쪽에는 **마스킹조차 없었다.** "문서 본문을 통째로 제외하므로 마스킹 실패가 누출로 이어지지 않는다"는 내 전제가 성립하지 않았다.
+  - 필드마다 손으로 감싸면 반드시 빠뜨린다(그래서 문서 탭만 덮였다). **임베드 직전 한 곳**에서 모든 문자열을 같은 술어로 통과시킨다 — 지금 있는 표면도, 나중에 추가될 표면도 함께 덮인다.
+  - 실측: decision·task·plan 세 경로 모두 생성 HTML 과 `DATA` 전 경로에서 0건. 정상 항목은 그래프에 그대로 남는다.
+- **P1 표지를 빠져나가는 네 형태** — RFC6750 의 짧은(19자) Bearer, 세션/Set-Cookie, compact JWE(5분절이라 `eyJ…eyJ` 가 아니다), 마크다운 강조로 감싼 `` `Bearer` ``. 넓히기 전에 비용을 쟀다: 실제 문서 156개에서 **추가로 걸리는 파일 0개**라 셋 다 넓혔다.
+**여덟 번째 검수에서 P1 이 처음으로 0 이 됐고, 남은 P2 는 내가 방금 넣은 코드가 원인이었다.**
+
+- **깊이 처리를 세 번 바꿨고, 두 번째 진단이 틀렸다.** ① 상한 12 + **원본 통과** → 12단계 밖이 정규화를 우회(누출). ② "상한이 우회를 만든다"고 보고 **상한을 제거** → 약 24KB 짜리 유효 JSON 하나로 **생성 자체가 실패**(직렬화가 4천 단계에서 스택을 터뜨린다). ③ 상한 200 + **자리표시자 대체** → 8천 단계까지 생성 성공, 누출 0. **문제는 상한이 아니라 상한을 넘겼을 때 원본을 통과시킨 것이었다 — fail-open 이면 우회, fail-safe 면 보호다.**
+- **순환을 막으려 쓴 방문 집합이 정상 데이터를 지웠다.** 전역 집합으로 두면 같은 객체를 두 필드가 공유할 때 두 번째가 순환이 아닌데도 `null` 이 된다(실측). 재귀 스택처럼 **들어갈 때 넣고 나올 때 빼야** 진짜 순환만 끊긴다.
+- **CRLF 문서를 앞에서 자를 때 고립된 `\r` 이 남았다** — `\n` 으로만 나누므로 줄 끝의 `\r` 이 내용으로 세어지고, 재조립 때 개행이 붙지 않으면 제어문자가 표시 데이터에 남는다.
+- **순서 목록 번호가 조용히 바뀌었다** — `2. two` 가 브라우저에서 `1. two` 로, `1·3` 이 `1·2` 로 보였다. 문서의 의미를 바꾸는 것이라 원문 번호를 보존한다. **표 정렬**도 문법으로는 받으면서 의미를 버리고 있었다 — 받은 이상 반영한다.
+- **변이 진단에서 픽스처가 판별점을 비껴간 경우가 셋 더** — CRLF 는 경계 줄이 이어붙어 정상 CRLF 가 되고(상한 안에 들어가는 줄로 교체), 순환은 깊이 상한이 먼저 끊어 주며(출력 크기까지 단언), 깊이 상한은 "생성 성공"만 보면 낮춰도 통과한다(보통 깊이 데이터 보존까지 단언).
+
+- **변이 진단에서 픽스처 함정이 둘 더 나왔다** — 누출 needle 을 `Authorization: Bearer …` 로 만들었더니 **마스킹만으로도 지워져** 표지 가드 제거 변이가 살아남았고(쿠키 형태로 교체), Bearer 문자군 판별 픽스처는 `/`·`~` 를 맨 앞에 둬서 **접두 허용이 흡수**해 버렸다(가운데 배치 + 양쪽 16자 미만으로 교체). 둘 다 가드가 약한 게 아니라 픽스처가 그 경로를 판별하지 못한 경우였다.
+
+- **변이 생존 5건의 원인이 세 갈래로 갈렸다** — 등가 변이 1건(가림 제외 목록이 비어 분기가 무의미), **픽스처 간섭** 3건(한 문서에 PEM 을 몰아넣어 서로를 가려 줬다 → 마스킹 단언을 격리 입력으로 직접 검증), **픽스처가 분기에 도달하지 못한** 1건(산문 뒤 base64 가 없어 규칙이 발동조차 안 했다). 앵커가 유일하지 않아 엉뚱한 규칙을 고치던 것도 유일성 검사가 잡았다.
+
+- **마스킹을 넓혔으니 실제 데이터로 오탐을 쟀다.** 로컬의 실제 leerness 프로젝트 문서 **189개 · 10,431줄**에 걸어 본 결과, 마스킹된 72줄은 **전부 1.36.95 규칙으로도 이미 마스킹되던 줄**이었다 — 이번 변경이 새로 건드린 줄은 **0건**, 반대로 커버리지가 후퇴한 줄도 **0건**. (그 72줄에는 `idempotency_key=run:phase:step` 같은 **기존 규칙의 오탐**이 섞여 있다. 이번 회귀가 아니므로 별도 항목으로 남겼다.)
+- 검증: 게이트 exit 0 · e2e **416/416** · 신규 1블록 · 변이 **81종 81/81**(등가 2건 제외 · 앵커 문제 0) · 자체 헌트 24종 결함 0 · 출구 전수 13종 · 계약 25종(원시 HTML · 엔티티/제로폭 URL · 표 구분줄 오인 · 미종료 펜스 · 주석 · CDATA) · 성능 6종. 실제 브라우저(788px·375px)에서 탭 전환·7종 내비·본문 렌더 확인.
+- **변이 1차에서 4건이 살아남았고 원인이 넷 다 달랐다** — 변이 하네스의 앵커가 유일하지 않아 엉뚱한 함수를 고친 것(하네스 버그), `mdInline` 도 내부에서 이스케이프하므로 XSS 단언만으론 못 잡는 것(단언이 목적이 아니라 부작용만 봄), 이모지만 반복한 픽스처가 서로게이트 쌍 경계에 정확히 맞아 쪼갤 자리가 없던 것, 줄 경계 단언이 tail 문서에만 걸려 non-tail 변이를 못 본 것. 앵커 유일성 검사를 러너에 넣고 나머지 셋은 픽스처를 고쳤다.
+- **계약 검증 도구 자신이 오탐 5건을 냈다.** 출력 전체에서 `on...=` 를 찾아 `&lt;img src=x onerror=1&gt;` 처럼 **이미 이스케이프된 글자**를 속성으로 오인했다. 그대로 믿었으면 없는 버그를 고쳤을 것이다. 실제 태그 안만 보도록 고치고, **탐지기가 진짜 위반을 잡는지 대조군으로 먼저 증명**한 뒤 "위반 0"을 말한다.
+- **게이트 실패 한 번은 내가 만들었다.** 게이트 실행 중에 소스를 고쳤고, 그 편집이 `String.raw` 템플릿 안 주석에 백틱을 넣어 템플릿을 끊었다 — 바로 그 위에 "여기선 백틱을 쓸 수 없다"고 적어 둔 자리였다. 처음엔 동시 실행 간섭이라고 생각했지만 격리 재현으로 5초 만에 진짜 원인이 나왔다.
+- **검수가 살려낸 마지막 변이는 "데이터는 맞는데 화면이 틀리는" 경우였다.** 코드포인트 단언을 데이터에만 걸어 둬서, 화면 고지를 `String.length` 로 되돌리는 변이가 통과했다. 사용자가 보는 것은 화면이다 — 생성물에서 고지가 어느 값을 쓰는지까지 확인한다.
+
 ## 1.36.95 — 2026-07-31 — AI 에게 매 세션 읽히던 파일의 절반이 틀린 과거 수치였다
 
 사용자 질문에서 시작했다 — "Opus 5 처럼 모델에 검증이 내장돼 있으면 하네스가 검증을 또 시키는 건 낭비 아닌가. 구동 모델을 인지해 맞춤으로 알려줄 수 있나?" 조사 결과 **모델 인지는 만들지 않기로 했고**(아래), 대신 그 조사가 훨씬 큰 것을 드러냈다.

package/README.md

@@ -122,7 +122,7 @@ MIT
 <!-- leerness:project-readme:start -->
 ## Leerness Project Harness
 
-이 프로젝트는 Leerness v1.36.95 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
+이 프로젝트는 Leerness v1.36.96 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
 
 ### 정체성 — AI 에이전트 운영 레이어 (UR-0030)
 
@@ -176,7 +176,7 @@ leerness memory restore decision <date|title>
 
 ### MCP server (외부 AI 통합)
 
-Leerness v1.36.95는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **89개 도구**를 노출:
+Leerness v1.36.96는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **89개 도구**를 노출:
 
 ```jsonc
 // 카테고리별
@@ -197,7 +197,7 @@ Leerness v1.36.95는 stdio JSON-RPC MCP server를 내장합니다 — Claude Cod
 `<<autonomous-loop-dynamic>>` 신호만 보내면 AI가:
 1) 다음 라운드 후보 선정 → 2) 코드 변경 → 3) 회귀 테스트 갱신 → 4) 전체 e2e 스위트 통과 → 5) npm publish + git tag → 6) main push → 7) session close → 8) 다음 라운드 예약.
 
-현재 누적: **v1.9.x → 1.36.95 릴리스 태그 이력** (수백 라운드) · _reports/는 비공개 보존.
+현재 누적: **v1.9.x → 1.36.96 릴리스 태그 이력** (수백 라운드) · _reports/는 비공개 보존.
 
 ### 성능 가이드
 
@@ -235,5 +235,5 @@ leerness release pack --close --auto-main-push
 - `.harness/session-handoff.md`: 다음 세션 인수인계 (자동 작성)
 - `.harness/lessons.md` / `decisions.md` / `rules.md`: 영구 메모리 (5 surface)
 
-Last synced by Leerness v1.36.95: 2026-07-31
+Last synced by Leerness v1.36.96: 2026-08-04
 <!-- leerness:project-readme:end -->

package/bin/leerness.js

@@ -34,7 +34,7 @@ const { CAPABILITY_SURFACE, POWERFUL_COMMANDS, ADAPTERS, REUSE_CATEGORIES, REUSE
 const { tokenizeForRank: _tokenizeForRank, expandQuery: _expandQuery, scoreHits: _scoreHits, suggestTerms: _suggestTerms } = require('../lib/search-core');  // 1.36.23: memory search 랭킹 코어(순수·0-deps)
 const { findCorruptedStateJson: _findCorruptedStateJson } = require('../lib/state-integrity');  // 1.36.1 (클린룸 리뷰 FN): .harness/*.json 상태 무결성 (audit/health/check 공유)
 
-const VERSION = '1.36.95';
+const VERSION = '1.36.96';
 
 // 1.9.290 (UR-0037, Codex gpt-5.5 #4 수렴): CLI 전용 부작용은 require 시 실행하지 않는다.
 //   이전: warning listener 제거 / NODE_OPTIONS 변경 / chcp IIFE 가 top-level 즉시 실행 → require('harness') 시 호스트 프로세스 오염.

package/lib/graph.js

@@ -8,6 +8,11 @@
 'use strict';
 const path = require('path');
 const { absRoot, exists, read, writeUtf8, log } = require('./io');
+// 1.36.96 (P-0010): 📄 문서 탭의 시크릿 마스킹은 dashboard 와 **같은 술어**를 쓴다.
+//   표면마다 다시 구현하면 한쪽만 고쳐지는 불일치가 생긴다(1.36.88→1.36.90 에서 이미 겪은 클래스).
+const _redact = require('./pure-utils').redactSecrets;
+//   1.36.96: 마스킹이 **완벽해야 하는 구조를 버렸다** — 자격증명 표지가 있는 문서는 본문을 싣지 않는다.
+const _hasCred = require('./pure-utils').hasCredentialMarker;
 
 // 검증된 프로토타입 템플릿(Claude Preview 렌더+클릭조회 확인). `/*__DATA__*/null` 자리표시자에 JSON 주입.
 // String.raw 필수: 내부 JS 의 `\'` 같은 escape 가 원문 그대로 출력돼 브라우저 JS 엔진이 해석하도록 보존.
@@ -62,10 +67,36 @@ canvas{position:fixed;inset:0;top:46px}
 .cmd.show{display:flex;align-items:center;gap:10px}
 .cmd button{background:#1a2230;border:1px solid var(--line);color:var(--txt);border-radius:5px;padding:3px 9px;cursor:pointer;font:inherit;font-size:10px}
 .note{color:var(--mut);font-size:11px;margin:14px 0 18px;line-height:1.6}
+/* 📄 문서 탭 (1.36.96, P-0010) */
+.dwrap{display:flex;gap:16px;align-items:flex-start}
+.dnav{flex:0 0 190px;position:sticky;top:70px}
+.dnav div{padding:7px 10px;border-radius:7px;cursor:pointer;font-size:12px;color:var(--mut);user-select:none}
+.dnav div.on{background:#1a2230;color:#fff}
+.dbody{flex:1;min-width:0;border:1px solid var(--line);border-radius:10px;padding:16px 22px;background:var(--panel)}
+.md h1,.md h2,.md h3,.md h4,.md h5,.md h6{color:#fff;line-height:1.35;margin:18px 0 10px}
+.md h1{font-size:20px}.md h2{font-size:17px}.md h3{font-size:15px}.md h4,.md h5,.md h6{font-size:13px}
+.md p{margin:0 0 10px;line-height:1.7;word-break:break-word}
+.md ul,.md ol{margin:0 0 10px;padding-left:22px}
+.md li{margin:3px 0;line-height:1.65}
+.md pre{background:#0b0f14;border:1px solid var(--line);border-radius:8px;padding:12px 14px;overflow:auto;margin:0 0 12px}
+.md code{font-family:var(--mono);font-size:12px;color:#7ee787}
+.md pre code{color:#c9d1d9}
+.md table{border-collapse:collapse;margin:0 0 12px;display:block;overflow-x:auto}
+.md th,.md td{border:1px solid var(--line);padding:6px 10px;font-size:12px;text-align:left}
+.md th{background:#141b23;color:#fff}
+.md a{color:#58a6ff}
+/*   좁은 화면에서 190px 고정 내비가 자리를 다 먹어 본문이 한 글자씩 세로로 흘렀다(실제 브라우저에서 확인).
+     테스트로는 안 보이는 종류라 눈으로 봐야 잡힌다. 좁아지면 내비를 가로 칩으로 접는다. */
+@media (max-width:760px){
+  .dwrap{flex-direction:column}
+  .dnav{position:static;flex:0 0 auto;display:flex;flex-wrap:wrap;gap:4px;width:100%}
+  .dnav div{border:1px solid var(--line)}
+  .dbody{width:100%;padding:14px 16px}
+}
 </style></head><body>
 <div id="bar">
   <div class="ttl"><span class="dot"></span><span id="proj">leerness</span><span style="color:var(--mut);font-weight:400">/ ontology</span></div>
-  <div id="tabs"><span class="tab on" data-v="graph">그래프</span><span class="tab" data-v="roadmap">로드맵</span><span class="tab" data-v="tech">🛠 기술</span></div>
+  <div id="tabs"><span class="tab on" data-v="graph">그래프</span><span class="tab" data-v="roadmap">로드맵</span><span class="tab" data-v="tech">🛠 기술</span><span class="tab" data-v="docs">📄 문서</span></div>
   <span class="stat" id="stat"></span>
   <input id="search" placeholder="search nodes…" autocomplete="off">
   <div id="chips"></div>
@@ -76,6 +107,7 @@ canvas{position:fixed;inset:0;top:46px}
 <div id="hint">drag node · scroll zoom · drag bg pan · click node → details · search+Enter jump · f / dblclick fit · p export PNG · Esc close</div>
 <div id="vroadmap" class="view"></div>
 <div id="vtech" class="view"></div>
+<div id="vdocs" class="view"></div>
 <script>
 var DATA = /*__DATA__*/null;
 var COLORS={task:'#58a6ff',plan:'#d29922',decision:'#39d0d8',lesson:'#e3b341',rule:'#bc8cff',skill:'#2dd4bf',feature:'#6e7681'};
@@ -172,7 +204,7 @@ window.addEventListener('keydown',function(ev){ if(ev.target&&ev.target.tagName=
 cv.addEventListener('dblclick',function(ev){ if(!hit(ev.offsetX,ev.offsetY)){_fit=true;fitView();} });
 
 // ── 탭 (1.36.53, UR-0062): 그래프 | 로드맵 | 🛠 기술 (토글 스위치 UI 제거 → CLI 가이드로 대체) ──
-var _views={roadmap:document.getElementById('vroadmap'),tech:document.getElementById('vtech')};
+var _views={roadmap:document.getElementById('vroadmap'),tech:document.getElementById('vtech'),docs:document.getElementById('vdocs')};
 document.querySelectorAll('.tab').forEach(function(t){t.onclick=function(){
   document.querySelectorAll('.tab').forEach(function(x){x.classList.toggle('on',x===t);});
   var v=t.getAttribute('data-v');
@@ -234,10 +266,222 @@ document.querySelectorAll('.tab').forEach(function(t){t.onclick=function(){
     +'· 이 파일은 정적 HTML — 상태 변경은 터미널(또는 AI)에게 위 명령을 실행시키세요. AI 는 토글 상태를 자동 준수합니다.</div></div>';
   el.innerHTML=h;
 })();
+
+// ── 📄 문서 탭 (1.36.96, P-0010) — .harness 핵심 문서 7종을 이 파일 안에서 그대로 읽는다.
+//   렌더러는 **최소 부분집합**만 해석한다: 제목 · 목록 · 코드펜스 · 표 · 링크 · 강조.
+//   그 밖의 모든 것(원시 HTML 포함)은 이스케이프된 평문으로 남는다 — 파서를 넓힐수록 XSS 면이 넓어진다.
+//   이 템플릿은 String.raw 라 리터럴 백틱을 쓸 수 없다(템플릿이 끊긴다) → 정규식/문자열에서 \x60 을 쓴다.
+function mdEsc(s){return String(s==null?'':s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;');}
+// URL 허용: http(s) · mailto · 페이지앵커 · 상대경로. 그 외 **스킴이 붙은 것은 전부 거부**(javascript:, data:, vbscript: …).
+//   브라우저 URL 파서는 탭/개행/CR 을 **제거한 뒤** 스킴을 읽는다 — 실측으로 확인했다(java + 탭 + script:
+//   를 href 에 넣으면 protocol 이 javascript: 로 나온다). 지금은 링크 토크나이저가 공백류를 배제해 그런
+//   입력이 애초에 링크가 되지 않지만 그건 **우연한 안전**이다. 토크나이저를 나중에 넓히면 되살아난다.
+//   (이 주석에 백틱을 쓰면 String.raw 템플릿이 거기서 끊긴다 — 바로 위에 적어 놓고 한 번 어겼다.)
+//   판정 전에 브라우저와 같은 문자를 제거해, 우리가 보는 것과 브라우저가 보는 것을 일치시킨다.
+//   탭·개행뿐 아니라 **C0 제어문자와 DEL 전부**를 제거한다 — 검수 실측에서 \x03·\x01·\x00·\x1F·\x7F 를
+//   앞이나 중간에 끼우면 스킴 판정을 빠져나갔다. 브라우저는 그런 문자를 URL 에서 무시하거나 제거한다.
+function mdUrl(u){var t=String(u||'').replace(/[\x00-\x1F\x7F]/g,'').trim();
+  //   브라우저는 역슬래시를 슬래시처럼 읽는다 — 역슬래시 2개로 시작하는 값은 프로토콜 상대 URL 로 해석된다
+  //   (검수 실측: file://host/share, HTTPS 페이지에서는 https://host/share). 종전엔 슬래시 2개만 막았다.
+  if(/^[\\/]{2}/.test(t))return null;
+  if(/^(https?:\/\/|mailto:|#)/i.test(t))return t;
+  if(/^[a-z][a-z0-9+.\-]*:/i.test(t))return null;
+  return t;}
+function mdInline(s){
+  // 코드스팬을 **먼저** 뽑아 자리표시자로 치환한다 — 안쪽의 * 나 [](…) 가 강조/링크로 해석되면 안 된다.
+  //   자리표시자는 U+0001 로 감싼다(이스케이프된 본문에 절대 나타나지 않는 문자). 감싸는 문자를 빠뜨리면
+  //   복원 정규식이 본문의 **모든 숫자**를 삼킨다 — 초안에서 실제로 그랬다.
+  //   문서에 U+0001 이 실제로 들어 있으면 자리표시자와 충돌한다 — 먼저 지운다(표시용 텍스트라 무해).
+  var out=mdEsc(s).replace(/[\x01\x02]/g,''),codes=[],links=[];
+  out=out.replace(/\x60([^\x60]+)\x60/g,function(m,c){codes.push(c);return '\x01'+(codes.length-1)+'\x01';});
+  //   수량자를 **유계**로 둔다. 종전 [^\]]* 는 닫히지 않은 대괄호마다 남은 문자열 전체를 다시 훑어 O(n²) 였다
+  //   (실측: 64KB 입력 1,825ms · 최악 2,730ms — 그만큼 브라우저 메인 스레드가 멈춘다).
+  //   상한을 넘는 링크는 링크가 되지 않고 글자로 남는다(계약상 안전한 쪽으로 실패한다).
+  //   URL 상한은 **이스케이프 후** 길이에 걸린다 — 원문 796자짜리 정상 쿼리 URL 이 & → &amp; 팽창으로
+  //   1,192자가 되어 거부됐다(검수 실측). 실측 비교로 라벨 300 / URL 4000 을 골랐다:
+  //   최악 115ms(무계는 1,747ms)이고 그 URL 은 링크된다.
+  out=out.replace(/\[([^\]\n]{0,300})\]\(([^)\s]{1,4000})\)/g,function(m,t,u){var v=mdUrl(u);
+    if(v===null)return m;
+    //   완성된 <a> 도 자리표시자로 빼 둔다 — 뒤따르는 강조 정규식이 href 안까지 다시 해석해
+    //   href="https://a/<b>b</b>/c" 처럼 URL 을 훼손했다(검수 실측).
+    links.push('<a href="'+v+'" target="_blank" rel="noopener noreferrer">'+t+'</a>');
+    return '\x02'+(links.length-1)+'\x02';});
+  out=out.replace(/\*\*([^*]+)\*\*/g,'<b>$1</b>');
+  out=out.replace(/(^|[^*])\*([^*\n]+)\*/g,'$1<i>$2</i>');
+  out=out.replace(/\x02(\d+)\x02/g,function(m,i){return links[i];});
+  out=out.replace(/\x01(\d+)\x01/g,function(m,i){return '<code>'+codes[i]+'</code>';});
+  return out;}
+function mdRender(src){
+  var ls=String(src||'').split(/\r?\n/),h='',i=0,list=null,olNext=0;
+  function endList(){if(list){h+='</'+list+'>';list=null;}}
+  function cells(r){return r.replace(/^\s*\|/,'').replace(/\|\s*$/,'').split('|').map(function(c){return c.trim();});}
+  while(i<ls.length){
+    var l=ls[i];
+    if(/^\s*\x60{3,}/.test(l)){                       // 코드펜스 — 안쪽은 어떤 규칙도 적용하지 않는다
+      endList();var buf=[];i++;
+      while(i<ls.length&&!/^\s*\x60{3,}\s*$/.test(ls[i])){buf.push(ls[i]);i++;}
+      i++;h+='<pre><code>'+mdEsc(buf.join('\n'))+'</code></pre>';continue;}
+    var hd=l.match(/^(#{1,6})\s+(.*)$/);
+    if(hd){endList();var n=hd[1].length;h+='<h'+n+'>'+mdInline(hd[2])+'</h'+n+'>';i++;continue;}
+    if(l.indexOf('|')>=0&&i+1<ls.length&&ls[i+1].indexOf('|')>=0&&/^[\s:|\-]*-[\s:|\-]*$/.test(ls[i+1])){
+      endList();
+      //   구분행의 콜론을 문법으로는 받으면서 정렬을 버리면 사용자가 지정한 의미가 조용히 사라진다(검수 실측).
+      //   받은 이상 반영한다 — 왼쪽/가운데/오른쪽. (이 템플릿 안 주석에는 백틱을 쓸 수 없다.)
+      var al=cells(ls[i+1]).map(function(c){
+        var lft=c.charAt(0)===':',rgt=c.charAt(c.length-1)===':';
+        return lft&&rgt?' style="text-align:center"':(rgt?' style="text-align:right"':(lft?' style="text-align:left"':''));});
+      var A=function(k){return al[k]||'';};
+      h+='<table><thead><tr>'+cells(l).map(function(c,k){return '<th'+A(k)+'>'+mdInline(c)+'</th>';}).join('')+'</tr></thead><tbody>';
+      i+=2;
+      while(i<ls.length&&ls[i].indexOf('|')>=0&&ls[i].trim()!==''){
+        h+='<tr>'+cells(ls[i]).map(function(c,k){return '<td'+A(k)+'>'+mdInline(c)+'</td>';}).join('')+'</tr>';i++;}
+      h+='</tbody></table>';continue;}
+    var ul=l.match(/^\s*[-*+]\s+(.*)$/),ol=l.match(/^\s*(\d+)[.)]\s+(.*)$/);
+    if(ul||ol){var want=ul?'ul':'ol';
+      //   원문 번호를 지키지 않으면 "2. two" 가 브라우저에서 "1. two" 로, 1·3 이 1·2 로 표시된다
+      //   — 문서의 의미가 조용히 바뀐다(검수 실측). 시작값은 ol start, 건너뛴 번호는 li value 로 보존한다.
+      if(list!==want){endList();h+=want==='ol'?('<ol start="'+ol[1]+'">'):'<ul>';list=want;olNext=ol?parseInt(ol[1],10):0;}
+      if(ul){h+='<li>'+mdInline(ul[1])+'</li>';}
+      else{var num=parseInt(ol[1],10);h+=(num===olNext?'<li>':'<li value="'+num+'">')+mdInline(ol[2])+'</li>';olNext=num+1;}
+      i++;continue;}
+    if(!l.trim()){endList();i++;continue;}
+    endList();h+='<p>'+mdInline(l)+'</p>';i++;}
+  endList();return h;}
+
+(function(){
+  var dd=(DATA&&DATA.docs)||{files:[]},el=_views.docs,fl=dd.files||[];
+  if(!fl.length){el.innerHTML='<div class="note">문서 없음 — leerness handoff . 로 .harness 를 채우고 재생성하세요.</div>';return;}
+  var kb=function(n){return Math.round((n||0)/1024)+'KB';};
+  el.innerHTML='<div class="note">스냅샷 '+esc(String(dd.at||'').slice(0,19).replace('T',' '))+' UTC · 이 파일은 <b>정적 사본</b>입니다 — 최신 내용은 <b>leerness graph --html</b> 로 재생성하세요. 시크릿 값은 가려집니다(문서당 '+kb(dd.perCap)+' · 전체 '+kb(dd.totalCap)+' 상한).</div>'
+    +'<div class="dwrap"><div class="dnav">'
+    +fl.map(function(f,i){return '<div data-i="'+i+'"'+(i===0?' class="on"':'')+'>'+esc(f.title)+(f.missing?' <span style="color:var(--mut)">(없음)</span>':(f.guarded?' <span style="color:var(--mut)">🔒</span>':(f.truncated?' <span style="color:var(--mut)">✂</span>':'')))+'</div>';}).join('')
+    +'</div><div class="dbody md" id="dbody"></div></div>';
+  var body=document.getElementById('dbody');
+  function show(i){
+    var f=fl[i]||{},h='<div class="sec" style="margin-top:0">'+esc(f.title||'')+' <span style="color:var(--mut);font-weight:400;font-size:11px">'+esc(f.rel||'')+'</span></div>';
+    if(f.missing){h+='<div class="note">아직 없는 파일입니다 — <b>leerness handoff .</b> 실행 시 생성됩니다.</div>';}
+    //   자격증명 표지가 있는 문서는 **본문을 싣지 않는다** — 부분 마스킹의 빈틈으로 새는 것을 구조적으로 막는다.
+    else if(f.guarded){h+='<div class="note">🔒 이 문서에는 <b>자격증명으로 보이는 내용</b>이 있어 본문을 싣지 않았습니다('+(f.charsTotal||0)+'자). 파일을 직접 여세요: '+esc(f.rel||'')+'<br>이 파일은 공유될 수 있으므로, 부분적으로 가리는 대신 통째로 제외합니다.</div>';}
+    else if(f.unreadable){h+='<div class="note">읽지 못했습니다(권한/인코딩). 원본 파일은 그대로입니다 — 직접 여세요.</div>';}
+    else if(f.skipped){h+='<div class="note">⚠ 전체 상한('+kb(dd.totalCap)+')에 도달해 <b>담기지 않았습니다</b> — 원본 '+(f.charsTotal||0)+'자. '+esc(f.rel||'')+' 를 직접 여세요.</div>';}
+    else{
+      //   "자" 는 코드포인트다 — String.length 를 쓰면 이모지 문서에서 두 배로 표시된다(검수 실측).
+      if(f.truncated)h+='<div class="note">⚠ 상한으로 잘렸습니다 — '+(f.chars||0)+'/'+(f.charsTotal||0)+'자('+(f.tail?'뒷부분':'앞부분')+'만). 전체는 '+esc(f.rel||'')+' 를 여세요.</div>';
+      h+=(f.lang==='json')?('<pre><code>'+mdEsc(f.text||'')+'</code></pre>'):mdRender(f.text||'');}
+    body.innerHTML=h;}
+  el.querySelectorAll('.dnav div').forEach(function(n){n.onclick=function(){
+    el.querySelectorAll('.dnav div').forEach(function(x){x.classList.toggle('on',x===n);});
+    show(parseInt(n.getAttribute('data-i'),10));};});
+  show(0);
+})();
 </script></body></html>`;
 
 const _txt = v => (v == null ? '' : String(v));
-function _trunc(s, n) { s = _txt(s); return s.length > n ? s.slice(0, n - 1) + '…' : s; }
+// 1.36.96 (검수 P1): 문서 탭만 가드했는데 **같은 내용이 nodes·roadmap 으로도 임베드**된다 —
+//   `decision add "Authorization: Bearer <토큰>"` 이 DATA.nodes[].label / detail 로 원문 그대로 실렸다(실측).
+//   그래프 쪽에는 마스킹조차 없었다. 임베드되는 **모든 사용자 텍스트**를 같은 술어로 통과시킨다.
+//   자격증명 표지가 있으면 그 항목 텍스트를 통째로 대체하고, 아니면 2차 마스킹만 적용한다.
+const _GUARD_TXT = '🔒 자격증명 표지 — 생략됨';
+const _safe = (v) => { const t = _txt(v); return t && _hasCred(t) ? _GUARD_TXT : _redact(t); };
+function _trunc(s, n) { s = _safe(s); return s.length > n ? s.slice(0, n - 1) + '…' : s; }
+
+// ── 📄 문서 탭 데이터 (1.36.96, P-0010) ──────────────────────────────────────────
+//   사용자 요청은 "exe 실행기로 .harness 마크다운을 띄우기"였다. 실행기는 런타임 의존성 0 · install script 0
+//   경계를 깨므로 만들지 않는다(1.36.90 에서 같은 경계를 테스트로 못박았다). 같은 목적을 정적 단일 파일로 이룬다.
+//   `tail: true` 는 **누적 로그**다 — 앞을 남기면 가장 오래된 것만 보인다(1.36.95 handoff 에서 겪은 그 방향 오류).
+const DOC_FILES = [
+  { key: 'plan', title: '플랜 · 로드맵', rel: '.harness/plan.md' },
+  { key: 'skills', title: '스킬', rel: '.harness/skill-index.md' },
+  { key: 'tech', title: '기술 프로필', rel: '.harness/tech-profile.json', lang: 'json' },
+  { key: 'handoff', title: '세션 핸드오프', rel: '.harness/session-handoff.md' },
+  { key: 'state', title: '현재 상태', rel: '.harness/current-state.md' },
+  { key: 'progress', title: '진행 추적', rel: '.harness/progress-tracker.md', tail: true },
+  { key: 'decisions', title: '결정 기록', rel: '.harness/decisions.md', tail: true },
+];
+const DOC_PER_CAP = 64 * 1024;
+const DOC_TOTAL_CAP = 512 * 1024;
+//   ⚠ 오늘의 목록(7종 × 64KB = 448KB)으로는 전체 상한 512KB 에 **도달할 수 없다** — 목록이 8종 이상으로
+//   늘 때를 위한 backstop 이다. 그래서 caps 를 주입 가능하게 뒀다: 도달 불가능한 분기는 "있다"고만 적으면
+//   공허한 가드가 된다(그 함정을 이 저장소에서 반복해서 밟았다). 테스트가 작은 상한으로 실제로 발화시킨다.
+
+// 줄 경계에서 자르고, 한 줄이 상한보다 길면 **코드포인트** 경계에서 자른다(서로게이트 쌍 분할 금지).
+//   1.36.96 (검수 P2): 상한 단위를 **UTF-8 바이트**로 바꿨다. 종전엔 UTF-16 코드 단위를 세면서 "64KB"라고
+//   적었고, 한글 문서에서는 문서당 실제 192KB · 합계 1.38MB 까지 실려 주장이 사실과 달랐다(실측: 1,152KB).
+const _blen = (x) => Buffer.byteLength(x, 'utf8');
+function _capDoc(s, cap, tail) {
+  s = _txt(s);
+  if (_blen(s) <= cap) return { text: s, truncated: false };
+  const ls = s.split('\n');
+  let acc = 0, keep = 0;
+  if (tail) {
+    for (let i = ls.length - 1; i >= 0; i--) { const add = (keep ? 1 : 0) + _blen(ls[i]); if (acc + add > cap) break; acc += add; keep++; }
+  } else {
+    for (let i = 0; i < ls.length; i++) { const add = (keep ? 1 : 0) + _blen(ls[i]); if (acc + add > cap) break; acc += add; keep++; }
+  }
+  //   **"무엇을 내용으로 셀지"를 판정하지 않는다.** 이 자리에서 데이터 소실이 세 번 재발했다:
+  //     ① `keep > 0` → 경계에 빈 줄 하나면 70,000자가 0자      ② `acc > 0` → 빈 줄 두 개면 1자
+  //     ③ 내용 바이트(content) → CRLF 의 `\r` 과 공백/탭이 내용으로 세어져 다시 1~3자
+  //   매번 셈을 조금씩 틀렸으므로 셈을 없앤다. 온전한 줄로 채운 뒤, **남은 예산만큼 경계 줄을 코드포인트로
+  //   잘라 이어 붙인다**. 어떤 공백 조합에도 예산이 채워지고, 순서가 유지되므로 "앞부분/뒷부분" 고지가 참이 된다.
+  //   (한때 둘 중 긴 쪽만 골랐는데, 경계 줄이 길면 **문서의 제목·푸터가 통째로 사라졌다** — 검수 실측.)
+  let packed = tail ? ls.slice(ls.length - keep).join('\n') : ls.slice(0, keep).join('\n');
+  //   `\n` 으로만 나누므로 CRLF 문서에서는 각 줄 끝에 `\r` 이 남는다. head 방향에서 다음 줄이 안 들어가면
+  //   재조립 때 개행이 붙지 않아 **고립된 CR** 이 꼬리에 남는다(검수 실측: "A\r"). 표시 데이터에 제어문자를
+  //   남기지 않도록 잘라낸다 — tail 방향은 앞에 개행이 붙으므로 해당 없음.
+  if (!tail) packed = packed.replace(/\r$/, '');
+  const line = (tail ? ls[ls.length - 1 - keep] : ls[keep]) || '';
+  //   경계 줄을 **항상** 잘라 붙이면 평범한 문서까지 줄 중간에서 잘린다("줄 경계 절단" 속성이 깨진다).
+  //   혼자서도 상한을 넘는 줄, 즉 **어떤 예산으로도 통째로는 담길 수 없는 줄**일 때만 잘라 붙인다.
+  const mustCut = _blen(line) > cap;
+  const room = mustCut ? cap - acc - (keep && line ? 1 : 0) : 0;   // 이어 붙일 개행 몫까지 뺀다
+  const cps = Array.from(line);
+  let n = 0, len = 0;
+  if (room > 0) {
+    if (tail) { for (let i = cps.length - 1; i >= 0 && len + _blen(cps[i]) <= room; i--) { len += _blen(cps[i]); n++; } }
+    else { for (let i = 0; i < cps.length && len + _blen(cps[i]) <= room; i++) { len += _blen(cps[i]); n++; } }
+  }
+  const part = n ? (tail ? cps.slice(cps.length - n).join('') : cps.slice(0, n).join('')) : '';
+  const text = !part ? packed : (!keep ? part : (tail ? part + '\n' + packed : packed + '\n' + part));
+  return { text, truncated: true };
+}
+
+function buildDocsData(root, nowIso, caps) {
+  const perCap = (caps && caps.perCap) || DOC_PER_CAP;
+  const totalCap = (caps && caps.totalCap) || DOC_TOTAL_CAP;
+  const minSlice = Math.max(256, Math.min(2048, Math.floor(totalCap / 8)));
+  const files = [];
+  let spent = 0;
+  for (const d of DOC_FILES) {
+    const base = { key: d.key, title: d.title, rel: d.rel, lang: d.lang || 'md', tail: !!d.tail };
+    const p = path.join(root, d.rel);
+    if (!exists(p)) { files.push(Object.assign({}, base, { missing: true, text: '', totalChars: 0, truncated: false })); continue; }
+    let raw;
+    try { raw = read(p); } catch { files.push(Object.assign({}, base, { unreadable: true, text: '', totalChars: 0, truncated: false })); continue; }
+    //   **자격증명 표지가 있으면 본문을 싣지 않는다.** 값 단위 마스킹은 다섯 라운드 동안 계속 새어서
+    //   안전의 전제에서 뺐다(마스킹은 아래에서 두 번째 방어층으로만 남는다). 실측 비용 0.6%.
+    if (_hasCred(raw)) {
+      files.push(Object.assign({}, base, {
+        guarded: true, text: '', truncated: false,
+        totalChars: raw.length, charsTotal: Array.from(raw).length, totalBytes: _blen(raw), bytes: 0, chars: 0,
+      }));
+      continue;
+    }
+    const red = _redact(raw);                       // dashboard 와 같은 술어(두 번째 방어층)
+    const remain = totalCap - spent;
+    // 잔여 예산이 의미 없는 크기면 **조각을 싣지 않고 건너뛴다**. 종전엔 remain<=0 일 때만 건너뛰어
+    //   159자짜리 쓸모없는 조각이 "잘림"으로 표시됐다(측정으로 확인). 조각보다 "안 담았다"가 정확하다.
+    if (remain < minSlice) { files.push(Object.assign({}, base, { skipped: true, text: '', totalChars: red.length, totalBytes: _blen(red), bytes: 0, truncated: true, chars: 0, charsTotal: Array.from(red).length })); continue; }
+    const c = _capDoc(red, Math.min(perCap, remain), !!d.tail);
+    spent += _blen(c.text);                                   // 예산도 바이트로 센다(상한과 같은 단위)
+    //   화면 고지의 "자" 는 **코드포인트**여야 한다. String.length(UTF-16 코드 단위)를 쓰면 이모지 문서에서
+    //   32,767/60,001자 로 나오지만 실제로는 16,384/30,001자다(검수 실측). 세어서 함께 싣는다.
+    files.push(Object.assign({}, base, {
+      text: c.text, totalChars: red.length, totalBytes: _blen(red), bytes: _blen(c.text), truncated: c.truncated,
+      chars: Array.from(c.text).length, charsTotal: Array.from(red).length,
+    }));
+  }
+  return { at: nowIso, perCap, totalCap, spent, files };
+}
 
 // 하네스 표면 → {project, version, counts, nodes, edges}. deps 로 in-process 로더 주입(셸링 X).
 function buildGraphData(root, deps = {}) {
@@ -315,7 +559,45 @@ function buildGraphData(root, deps = {}) {
   // 1.36.53 (UR-0062): 기술 프로필 임베드 — 🛠 기술 탭 데이터
   const tech = (typeof deps._loadTechProfile === 'function' ? (deps._loadTechProfile(root) || null) : null) || { current: { languages: [], services: [] }, history: [] };
   const toggleRegistry = deps._toggleRegistry || {};
-  return { project: rd.project || path.basename(root), version: rd.version || '', root, counts, nodes, edges, roadmap, toggles, toggleRegistry, tech };
+  //   필드마다 손으로 감싸면 반드시 빠뜨린다(문서 탭만 가드했다가 nodes·roadmap 으로 샜다).
+  //   **임베드 직전 한 곳**에서 모든 문자열을 통과시킨다 — 지금 있는 표면도, 나중에 추가될 표면도 함께 덮인다.
+  //   id·type 같은 자체 생성 값은 표지에 걸리지 않으므로 무해하다.
+  //   **깊이 제한을 두면 그 너머가 통째로 우회한다.** 순환을 막으려 12단계 상한을 뒀더니, 12단계보다 깊은
+  //   객체는 그대로 반환돼 그 아래 문자열에 정규화가 아예 걸리지 않았다(검수 실측: tech-profile.json 은
+  //   임의 JSON 이라 실 CLI 로 도달 가능). 상한 대신 **방문 집합**으로 순환만 끊는다 — 깊이는 제한하지 않는다.
+  //   방문 집합을 **재귀 스택처럼** 써야 한다. 전역 집합으로 두면 같은 객체를 두 필드가 공유할 때
+  //   두 번째가 순환이 아닌데도 잘려 나간다(검수 실측: `{first:X, second:X}` 의 second 가 null 이 됐다).
+  //   들어갈 때 넣고 **나올 때 뺀다** — 진짜 순환(조상에 자신이 있는 경우)만 끊긴다.
+  //   재귀 깊이도 제한하지 않되, 스택이 터지면 그 가지만 표지 문자열로 대체한다(생성 자체가 실패하면 안 된다).
+  //   깊이 상한 자체가 문제가 아니라 **상한을 넘겼을 때 원본을 그대로 통과시킨 것**이 문제였다(그게 우회였다).
+  //   상한을 넘으면 **자리표시자 문자열로 대체**한다 — 아무것도 새지 않고, 뒤이은 JSON.stringify 도 안전하다
+  //   (직렬화 자체가 약 4천 단계에서 스택을 터뜨린다 — 24KB 짜리 유효 JSON 하나로 생성이 실패했다).
+  const MAXD = 200;                                // 정상 데이터는 이 근처에도 오지 않는다
+  const _deepSafe = (v, path, depth) => {
+    if (typeof v === 'string') return _safe(v);
+    if (!v || typeof v !== 'object') return v;
+    const dep = depth || 0;
+    if (dep > MAXD) return _GUARD_TXT;             // fail-safe: 원본이 아니라 표시 문자열로 대체
+    const p = path || new Set();
+    if (p.has(v)) return null;                     // 조상에 자신이 있다 = 순환 → 잘라낸다
+    p.add(v);
+    try {
+      if (Array.isArray(v)) return v.map(x => _deepSafe(x, p, dep + 1));
+      const o = {};
+      for (const k of Object.keys(v)) o[k] = _deepSafe(v[k], p, dep + 1);
+      return o;
+    } finally {
+      p.delete(v);                                 // 형제 노드가 공유 참조를 다시 쓸 수 있게 되돌린다
+    }
+  };
+  // 1.36.96 (P-0010): 📄 문서 탭 — .harness 핵심 문서 7종 스냅샷(마스킹 + 상한 + 잘림 고지).
+  const docs = buildDocsData(root, deps.nowIso || new Date().toISOString());
+  //   `docs` 는 buildDocsData 에서 **이미 같은 술어를 통과했고 회계(spent/bytes)도 거기서 확정**됐다.
+  //   여기서 다시 변환하면 텍스트가 미세하게 바뀌어 "보고한 spent = 실제 임베드 바이트" 불변식이 깨진다
+  //   (검수 실측: 1바이트 차이). 두 번 처리하지 않는다.
+  const safe = _deepSafe({ project: rd.project || path.basename(root), version: rd.version || '', root, counts, nodes, edges, roadmap, toggles, toggleRegistry, tech });
+  safe.docs = docs;
+  return safe;
 }
 
 // `leerness graph --html [path] [--out file] [--json]` 핸들러.
@@ -338,4 +620,4 @@ function graphHtmlCmd(root, deps = {}, outFile) {
   return summary;
 }
 
-module.exports = { graphHtmlCmd, buildGraphData };
+module.exports = { graphHtmlCmd, buildGraphData, buildDocsData, _capDoc, DOC_FILES, DOC_PER_CAP, DOC_TOTAL_CAP };

package/lib/pure-utils.js

@@ -24,11 +24,121 @@ const _SECRET_ASSIGN = /\b([A-Za-z0-9_]*(?:TOKEN|KEY|SECRET|PASSWORD|PASSWD|PWD|
 //   (헤더 밖의 맨 `Bearer <값>` 은 아래 SHAPE 규칙이 형태로 잡는다 — 산문 훼손 위험을 감수하지 않는다.)
 const _SECRET_AUTH_HEADER = /\b((?:proxy-)?authorization)([ \t]*[:=][ \t]*)(?:(Bearer|Basic|Token|ApiKey|Digest)([ \t]+))?([A-Za-z0-9._~+/-]+=*)/gi;
 const _SECRET_SHAPE = /\b(sk-[A-Za-z0-9_-]{8,}|ghp_[A-Za-z0-9]{16,}|gho_[A-Za-z0-9]{16,}|ghs_[A-Za-z0-9]{16,}|github_pat_[A-Za-z0-9_]{20,}|xox[baprs]-[A-Za-z0-9-]{8,}|AKIA[0-9A-Z]{12,}|ASIA[0-9A-Z]{12,}|AIza[A-Za-z0-9_-]{20,}|eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{5,})/g;
+// 1.36.96 (검수 P1): 마스킹이 **스캐너와 다른(더 약한) 목록**을 쓰고 있었다. 실측으로 6종이 그대로 새어
+//   화면에 실렸다 — DB 접속문자열 비밀번호 · GitLab PAT · npm 토큰 · Stripe live 키 · SendGrid · 개인키 블록.
+//   전부 `SECRET_PATTERNS`(catalogs.js)에 **이미 있던** 패턴이다. 한쪽만 강화된 전형적인 표면 불일치라
+//   같은 목록을 공유한다. placeholder/entropy 가드도 스캐너와 동일하게 적용해 오탐을 늘리지 않는다.
+//   (catalogs.js 는 require 가 없어 순환이 생기지 않는다. 그래도 지연 로드 + 실패 시 기존 규칙만 사용.)
+// 개인키는 **블록 전체**를 지운다. 스캐너는 BEGIN 줄만 탐지하면 충분하지만(있다/없다), 화면에 싣는
+//   텍스트는 본문(base64)이 남으면 키가 그대로 노출된다 — 실측에서 BEGIN 줄만 *** 가 되고 본문은 남았다.
+//   `[\s\S]*?` 는 **BEGIN 과 무관한 END 사이의 산문까지** 삼킨다 — 종료되지 않은 키 하나가 문서 뒤쪽의
+//   END 줄과 짝지어져 그 사이 전부가 사라질 수 있다(변이 실험 중 발견). 사이에는 PEM 헤더·base64·빈 줄만 허용한다.
+//   **문턱과 문자 조성으로는 키 본문과 산문을 가를 수 없다.** 네 번 시도했고 매번 한쪽이 깨졌다:
+//     16자 → 인용 문서의 식별자 삼킴 · 40자 → 짧게 감긴 키 누출 ·
+//     "숫자/기호 포함" → 영문자만인 실제 키 줄 누출(검수가 진짜 RSA 키로 51줄 누출을 재현) ·
+//     그 역 → `PolicyVersion2026Final` 같은 정상 식별자 삼킴.
+//   그래서 값이 아니라 **문맥과 실패 방향**으로 정한다. BEGIN 마커 뒤의 **공백 없는 한 줄**은 키 재료로 본다.
+//   산문은 거의 항상 공백을 포함하므로 문단은 살아남고, 어떤 조성의 키 본문도 새지 않는다.
+//   대가: BEGIN 을 인용한 문서에서 **바로 뒤의 단일 토큰 한 줄**이 가려진다. 원본 파일은 그대로이고
+//   이건 표시용 스냅샷이므로, 누출보다 이 쪽이 낫다 — 표시용 마스킹은 안전한 쪽으로 실패해야 한다.
+//   PGP 블록의 `=CRC` 줄도 이 규칙에 자연히 포함된다.
+const _PEM_HDR = '(?:Proc-Type|DEK-Info|Comment|Subject|Originator|Version|MessageID|Charset|X-[A-Za-z0-9-]+):[^\\r\\n]*';
+//   줄 **끝까지** 공백이 없어야 한다 — 앵커가 없으면 산문 줄의 첫 낱말만 먹고 나머지를 남긴다(실측).
+const _PEM_BODY = '(?!-----)\\S+(?=[ \\t]*(?:\\r?\\n|$))';
+// 1.36.96: **값 단위 마스킹이 완벽해야 하는 구조를 버린다.**
+//   문서 뷰어에서 다섯 라운드 동안 누출 경로가 계속 나왔다 — 인용문(`> `)으로 감싼 PEM, base64 의 `/`·`+`,
+//   소문자 `bearer`, placeholder 모양 토큰, 줄 앞 접두어… 값의 형태로 가르려는 시도마다 반례가 있었다.
+//   그래서 **자격증명 표지가 하나라도 있으면 그 문서의 본문을 아예 싣지 않는다.** 마스킹은 방어의 두 번째 층으로만 남고,
+//   "완벽한 마스킹"이 안전의 전제에서 빠진다.
+//   비용 실측(실제 문서 156개): 표지가 걸린 파일 **1개(0.6%)** — 사실상 공짜다.
+//   표지는 **값이 아니라 형식**으로만 정의한다(줄 앞 접두어·대소문자·본문 조성에 의존하지 않는다).
+//   검수가 표지를 빠져나가는 네 형태를 실행으로 보였다 — RFC6750 의 짧은(19자) Bearer, 세션 쿠키,
+//   compact JWE(5분절이라 `eyJ…eyJ` 형태가 아니다), 마크다운 강조로 감싼 `` `Bearer` `` .
+//   넓히기 전에 비용을 쟀다: 실제 문서 156개에서 **추가로 걸리는 파일 0개**. 그래서 셋 다 넓힌다.
+const _CRED_MARKERS = [
+  /-----BEGIN (?:[A-Z0-9]+ )*PRIVATE KEY(?: BLOCK)?-----/,
+  //   JWT(3분절)와 JWE(5분절)를 함께 — 두 번째 분절이 비어 있을 수 있다(dir 알고리즘)
+  /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]*\.[A-Za-z0-9_-]{2,}/,
+  //   스킴과 값 사이에 마크다운 강조(`**` · `` ` ``)가 낄 수 있다. RFC6750 토큰은 짧을 수 있어 16자로 잡는다.
+  /\bbearer\b[^A-Za-z0-9\r\n]{0,4}[A-Za-z0-9_\-.=+/~]{16,}/i,
+  /\b(?:proxy-)?authorization[ \t]*[:=]/i,
+  /\b(?:set-)?cookie[ \t]*[:=]/i,
+  /\b(?:gh[pousr]_|github_pat_|sk-|sk_live_|rk_live_|xox[baprs]-|xapp-|AKIA|ASIA|AIza|ya29\.|glpat-|npm_|SG\.)/,
+  /\b(?:postgres|postgresql|mysql|mongodb(?:\+srv)?|redis|amqp):\/\/[^:\s/@]+:[^@\s/]+@/i,
+];
+function hasCredentialMarker(s) {
+  const t = String(s == null ? '' : s);
+  return _CRED_MARKERS.some(re => re.test(t));
+}
+
+// 카탈로그의 Bearer 문자군은 `[A-Za-z0-9_\-.=]` 라 base64 의 `/` `+` 에서 끊긴다 — 앞 조각이 20자 미만이면
+//   `Bearer <실토큰>` 이 통째로 남는다(실측: 앞 8자 뒤 `/` 인 40자 토큰이 전혀 가려지지 않았다).
+//   `Authorization:` 헤더 형태는 _SECRET_AUTH_HEADER 가 잡지만 맨 `Bearer …` 는 이 규칙이 필요하다.
+//   스캐너 쪽 문자군도 같은 구멍이 있다(T-0085 로 남겼다) — 여기서는 표시 누출부터 막는다.
+const _SECRET_BEARER = /\bBearer\s+[A-Za-z0-9_\-.=+/]{20,}/g;
+const _SECRET_PEM = new RegExp('-----BEGIN (?:[A-Z0-9]+ )*PRIVATE KEY(?: BLOCK)?-----(?:[ \\t]*\\r?\\n[ \\t]*(?:' + _PEM_HDR + '|' + _PEM_BODY + ')?)*[ \\t]*\\r?\\n[ \\t]*-----END (?:[A-Z0-9]+ )*PRIVATE KEY(?: BLOCK)?-----', 'g');
+//   END 줄이 없으면 위 규칙이 매치되지 않아 BEGIN 줄만 지워지고 **본문 base64 가 그대로 남았다**(검수 실측).
+//   붙여넣다 잘린 키가 흔하므로, BEGIN 뒤에 이어지는 base64/헤더 줄까지 함께 지운다.
+//   ① 암호화 키는 `Proc-Type:`/`DEK-Info:` 헤더 뒤 **빈 줄**이 오고 본문이 시작한다 — 빈 줄에서 멈추면 본문이 샌다.
+//   ② 반대로 아무 `Name: value` 줄이나 먹으면 BEGIN 을 인용한 정책 문서의 산문을 삼킨다(둘 다 검수 실측).
+//   그래서 헤더는 **PEM 표준 이름만** 허용하고, 본문 base64 줄이 **최소 하나** 있을 때만 확장한다.
+const _SECRET_PEM_OPEN = new RegExp('-----BEGIN (?:[A-Z0-9]+ )*PRIVATE KEY(?: BLOCK)?-----(?:[ \\t]*\\r?\\n[ \\t]*' + _PEM_HDR + ')*(?:[ \\t]*\\r?\\n[ \\t]*)*(?:[ \\t]*\\r?\\n[ \\t]*(?:' + _PEM_BODY + '))+[ \\t]*\\r?\\n?', 'g');
+
+// **탐지용 문맥 휴리스틱은 가림에 그대로 쓰면 안 된다.** 탐지의 오탐은 경고 한 줄이지만, 가림의 오탐은
+//   사용자가 보는 문서를 조용히 파괴한다(대시보드도 이 함수를 쓴다). 검수 실측으로 확인한 두 가지:
+//     'AWS secret commit <40자 커밋해시> was reverted' → 문장 전체가 *** 로 사라졌다.
+//     'Use Bearer authenticationMiddleware for API requests.' → 'Use *** for API requests.'
+//   엔트로피 게이트(_looksSecretLike)로는 갈리지 않았다 — 진짜 AWS 키까지 placeholder 로 판정된다(실측).
+//   그래서 문맥 패턴은 가림에서 제외하고, Bearer 는 값에 숫자가 있을 때만 가린다.
+//   남는 구멍: `Authorization:` 없이 적힌 **영문자만으로 된** Bearer 토큰. 헤더 형태는 _SECRET_AUTH_HEADER 가,
+//   실제 토큰 형식(JWT·ghp_·AKIA·sk- 등)은 형태 패턴이 잡는다.
+//   초판은 AWS 문맥 패턴을 통째로 제외했는데, 그러면 `aws secret access key <40자>` 처럼 **구분자 없는 실값이
+//   샌다**(검수 실측). 문장을 삼키지 않으면서 값만 지우도록, 이 패턴은 **꼬리 자격증명만** 치환한다.
+//   commit 해시가 같은 형태라 가려지는 것은 감수한다 — 문장 구조는 남으므로 파괴가 아니다.
+const _REDACT_SKIP = new Set();
+const _REDACT_TAIL = {
+  'AWS Secret Access Key (context)': /(["']?)([A-Za-z0-9/+]{40})(["']?)$/,
+};
+//   Bearer 값도 같은 결론이다. 길이 문턱(32자)은 20~31자 실토큰을 놓쳤고, 모양 판별(camelCase 예외)은
+//   `Bearer abcdefghijklmnopqrst` · `Bearer CorrectHorseBatteryStaple` 같은 **유효한 불투명 토큰을 산문으로
+//   판정해 노출**했다(검수 실측). 불투명 토큰이 소문자나 낱말꼴이 아니라는 보장이 없다 — 예외를 없앤다.
+//   대가: `Use Bearer authenticationMiddleware for API requests.` 같은 문장이 `Use *** for …` 가 된다.
+//   카탈로그가 이미 20자 이상만 후보로 잡으므로 `Bearer 인증` 같은 짧은 표현은 영향이 없다.
+const _REDACT_GUARD = {};
+let _SECRET_CATALOG = null;
+function _secretCatalog() {
+  if (_SECRET_CATALOG) return _SECRET_CATALOG;
+  try { _SECRET_CATALOG = require('./catalogs').SECRET_PATTERNS || []; } catch { _SECRET_CATALOG = []; }
+  return _SECRET_CATALOG;
+}
 function redactSecrets(s, max) {
   let out = String(s == null ? '' : s)
     .replace(_SECRET_AUTH_HEADER, (m, key, sep, scheme, gap) => `${key}${sep}${scheme ? scheme + (gap || ' ') : ''}***`)
     .replace(_SECRET_ASSIGN, (m, k) => `${k}=***`)
-    .replace(_SECRET_SHAPE, '***');
+    .replace(_SECRET_SHAPE, '***')
+    .replace(_SECRET_PEM, '***')
+    .replace(_SECRET_PEM_OPEN, '***\n')
+    .replace(_SECRET_BEARER, '***');
+  for (const p of _secretCatalog()) {
+    const { re, valueGroup, requireSecretLike } = p;
+    if (!re || _REDACT_SKIP.has(p.name)) continue;
+    const guard = _REDACT_GUARD[p.name];
+    try {
+      out = out.replace(re, (...args) => {
+        const m0 = args[0];
+        const val = (valueGroup != null) ? args[valueGroup] : m0;
+        if (!val) return m0;
+        if (guard && !guard(m0)) return m0;                                         // 가림 전용 추가 가드
+        const tailRe = _REDACT_TAIL[p.name];                                        // 꼬리 값만 지우는 패턴
+        if (tailRe) { const t = m0.match(tailRe); return t ? m0.slice(0, m0.length - t[0].length) + t[1] + '***' + t[3] : m0; }
+        if (_isPlaceholderSecret(val)) return m0;                                   // .env.example 의 더미값
+        if (valueGroup != null && requireSecretLike && !_looksSecretLike(val)) return m0;
+        if (valueGroup == null) return '***';
+        const i = m0.indexOf(val);                                                  // 값만 지우고 맥락은 남긴다
+        return i < 0 ? '***' : m0.slice(0, i) + '***' + m0.slice(i + val.length);
+      });
+    } catch { /* 한 패턴이 실패해도 나머지 마스킹은 계속한다 */ }
+  }
   if (max && out.length > max) out = out.slice(0, max) + '…';
   return out;
 }
@@ -1321,7 +1431,7 @@ function _replaceMdSection(content, heading, newBodyLines, opts = {}) {
 module.exports = { _decisionBlocksWithOffset, _blocksWithOffset, _lineOfOffset,
   _parseImplExports, _briefUnfilled, _planGoalUnfilled, _mdSectionBody, _draftAnchors, _replaceMdSection,
   _matchTool, _parsePackageJsonDeps, _parseRequirementsTxt, _buildGlossary, _renderGlossaryMd, GLOSSARY_START, GLOSSARY_END,
-  _isSecretKey, redactSecrets, compareVer, parseHarnessVersion,
+  _isSecretKey, redactSecrets, hasCredentialMarker, compareVer, parseHarnessVersion,
   _isPlaceholderSecret, _looksSecretLike,
   _mergeLines, _mergeEnvLines, _mergeReadmeSection, _managedMerge, _parseSkillsValue,
   _parseArchiveBlocks, _parseSkillCatalog, _renderTeamsMd, _composeTeamPlan, _teamHandoffReminders, _cadenceAssessment, _teamDeployGate, _renderWorkspaceReferenceGuide, _memorySurface, _renderPulseLine,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leerness",
-  "version": "1.36.95",
+  "version": "1.36.96",
   "description": "The AI-coding operations layer that makes \"done\" require evidence — persistent memory, evidence-gated completion checks, and clean handoffs for any AI agent (Claude Code, Codex, Cursor). State lives as plain files in your repo. CLI + MCP, 0 runtime dependencies.",
   "keywords": [
     "leerness",

package/scripts/e2e.js

@@ -8326,6 +8326,461 @@ total++;
   if (!ok) failed++;
 }
 
+// 1.36.96 (P-0010, 사용자 승인 범위): leerness.html 에 📄 문서 탭 — .harness 핵심 문서 7종을 그대로 읽는다.
+//   사용자 요청은 "exe 실행기"였지만 실행기는 **런타임 의존성 0 · install script 0** 경계를 깬다(1.36.90 에서
+//   같은 경계를 테스트로 못박았다). 같은 목적을 정적 단일 파일 안에서 이룬다.
+//   렌더러는 **최소 부분집합**만 해석한다(제목·목록·코드펜스·표·링크·강조). 나머지는 이스케이프된 평문 —
+//   파서를 넓힐수록 XSS 면이 넓어지고, 이 파일은 사용자 문서를 그대로 싣는다.
+//   이 블록이 잡아야 하는 것(전부 변이로 확인): 원시 HTML 통과 · javascript:/data: 링크 · 표/제목/링크텍스트
+//   미이스케이프 · 코드펜스 안 마크다운 해석 · 코드스팬 자리표시자가 본문 숫자를 삼킴 · 시크릿 미마스킹 ·
+//   누적 로그 방향 뒤집힘 · 줄경계/코드포인트 절단 붕괴 · 전체 상한에서 조용한 누락.
+total++;
+{
+  let ok = false;
+  const _d = [];
+  const dbg = {};
+  try {
+    const vm = require('vm');
+    const G = require(path.resolve(path.dirname(CLI), '..', 'lib', 'graph.js'));
+    const w = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-docs96-')); _d.push(w);
+    fs.writeFileSync(path.join(w, 'package.json'), JSON.stringify({ name: 'd96', version: '0.1.0' }, null, 2));
+    cp.spawnSync(process.execPath, [CLI, 'init', w, '--yes', '--no-stale-check'], { encoding: 'utf8', timeout: 180000 });
+    const H = path.join(w, '.harness');
+    const setupOk = fs.existsSync(H);            // 셋업이 조용히 실패하면 아래 단언이 공허해진다
+
+    // ── T1: 렌더러 — 허용 부분집합만 해석하고, 그 밖은 전부 이스케이프된 평문.
+    //   생성된 HTML 에서 함수를 **떼어내 실제로 실행**한다(소스 grep 이 아니라 동작).
+    cp.spawnSync(process.execPath, [CLI, 'graph', w, '--html'], { encoding: 'utf8', timeout: 180000 });
+    const html = fs.readFileSync(path.join(w, 'leerness.html'), 'utf8');
+    const wired = html.includes('data-v="docs"') && /"docs":\{/.test(html) && html.includes('세션 핸드오프');
+    const grab = (n) => { const i = html.indexOf('function ' + n + '('); if (i < 0) return ''; const j = html.indexOf('\nfunction ', i + 1); return html.slice(i, j < 0 ? html.indexOf('\n(function(){', i) : j); };
+    const sb = { console };
+    vm.createContext(sb);
+    vm.runInContext(['mdEsc', 'mdUrl', 'mdInline', 'mdRender'].map(grab).join('\n') + '\nthis.R=mdRender;this.I=mdInline;this.U=mdUrl;', sb);
+    const R2 = sb.R, I2 = sb.I, U2 = sb.U;
+    //   검수 지적: 제목은 H2 만, 허용 링크는 HTTPS 하나만 검사해 나머지가 끊겨도 통과했다.
+    //   경계(H1·H6)와 허용 스킴 전 종류를 각각 단언한다.
+    const T1 = wired
+      && R2('# 하나') === '<h1>하나</h1>' && R2('## 제목') === '<h2>제목</h2>'
+      && R2('### 셋') === '<h3>셋</h3>' && R2('#### 넷') === '<h4>넷</h4>'
+      && R2('##### 다섯') === '<h5>다섯</h5>' && R2('###### 여섯') === '<h6>여섯</h6>'
+      && R2('####### 일곱') === '<p>####### 일곱</p>'      // 7단계는 제목이 아니다(평문)
+      && R2('- a\n- b') === '<ul><li>a</li><li>b</li></ul>'
+      && R2('1. a') === '<ol start="1"><li>a</li></ol>'
+      //   원문 번호를 지키지 않으면 "2. two" 가 브라우저에서 "1. two" 로 보인다 — 문서 의미가 조용히 바뀐다(검수 실측).
+      && R2('2. two') === '<ol start="2"><li>two</li></ol>'
+      && R2('1. one\n3. three') === '<ol start="1"><li>one</li><li value="3">three</li></ol>'
+      //   구분행의 콜론을 문법으로 받으면서 정렬을 버리면 사용자가 지정한 의미가 사라진다(검수 실측).
+      && (function () { const s = R2('| a | b | c |\n|:---|:---:|---:|\n| 1 | 2 | 3 |');
+        return s.includes('text-align:left') && s.includes('text-align:center') && s.includes('text-align:right'); })()
+      && R2('| a |\n|---|\n| 1 |') === '<table><thead><tr><th>a</th></tr></thead><tbody><tr><td>1</td></tr></tbody></table>'
+      && I2('**굵게** 와 *기울임*') === '<b>굵게</b> 와 <i>기울임</i>'
+      && I2('명령 `npm test` 실행') === '명령 <code>npm test</code> 실행'
+      && R2('```js\nvar a=1;\n```') === '<pre><code>var a=1;</code></pre>'
+      && R2('| a |\n|---|\n| 1 |') === '<table><thead><tr><th>a</th></tr></thead><tbody><tr><td>1</td></tr></tbody></table>'
+      //   허용 스킴 4종을 각각 — HTTPS 하나만 보면 http/mailto/앵커/상대경로가 끊겨도 통과한다(검수 실측 변이).
+      && I2('[d](https://example.com/x)') === '<a href="https://example.com/x" target="_blank" rel="noopener noreferrer">d</a>'
+      && /href="http:\/\/e\.test\/a"/.test(I2('[d](http://e.test/a)'))
+      && /href="mailto:a@b\.c"/.test(I2('[d](mailto:a@b.c)'))
+      && /href="#앵커"/.test(I2('[d](#앵커)'))
+      && /href="\.harness\/plan\.md"/.test(I2('[d](.harness/plan.md)'))
+      //   상한은 **이스케이프 후** 길이에 걸린다 — 원문 796자 URL 이 &amp; 팽창으로 거부됐다(검수 실측).
+      //   픽스처가 1,192자라 상한을 1,200 으로 낮추는 변이가 통과했다 — 4,000 에 가까운 길이로 판별한다.
+      && I2('[d](https://e.test/q?' + Array.from({ length: 260 }, (_, i) => 'k' + i + '=v' + i).join('&') + ')').includes('<a ')
+      // 코드스팬 자리표시자가 감싸는 문자를 잃으면 본문의 **모든 숫자**가 코드로 바뀐다(초안이 그랬다)
+      && I2('버전 1.36.96 에서 89 도구') === '버전 1.36.96 에서 89 도구'
+      && I2('`a` 뒤 42 그리고 `b`') === '<code>a</code> 뒤 42 그리고 <code>b</code>'
+      // XSS · 스킴 거부
+      && !/<script/i.test(R2('<script>alert(1)</script>')) && R2('<script>alert(1)</script>').includes('&lt;script&gt;')
+      && !/<img/i.test(R2('<img src=x onerror=alert(1)>')) && R2('<img src=x onerror=alert(1)>').includes('&lt;img')
+      //   부재만 단언하면 함수가 **빈 문자열을 돌려줘도** 통과한다 — 거부된 링크는 원문이 글자로 남아야 하므로
+      //   완전 일치로 단언한다(4가지 위험 스킴 + 프로토콜 상대).
+      && I2('[x](javascript:alert(1))') === '[x](javascript:alert(1))'
+      && I2('[x](JaVaScRiPt:alert(1))') === '[x](JaVaScRiPt:alert(1))'
+      && I2('[x](data:text/html,y)') === '[x](data:text/html,y)'
+      && I2('[x](vbscript:m)') === '[x](vbscript:m)'
+      && I2('[x](//evil.example)') === '[x](//evil.example)'
+      //   브라우저는 역슬래시를 슬래시처럼 읽는다 — 슬래시 2개만 막으면 역슬래시 2개가 통과한다(검수 실측).
+      && U2('\\\\evil.example/share') === null && U2('/\\evil.example/share') === null
+      //   링크를 만든 뒤 강조 정규식이 href 안까지 다시 해석해 URL 을 훼손했다(검수 실측).
+      && I2('[t](https://a/**b**/c)') === '<a href="https://a/**b**/c" target="_blank" rel="noopener noreferrer">t</a>'
+      //   문서에 U+0001/U+0002 가 실제로 있으면 자리표시자와 충돌한다 — 입력에서 제거한다.
+      && I2('a\x01b \u0060c\u0060') === 'ab <code>c</code>' && I2('x\x020y') === 'x0y'
+      //   닫히지 않은 대괄호마다 남은 문자열을 다시 훑던 O(n²)(실측 64KB 1,825ms) — 유계 수량자로 선형.
+      && (function () { const t0 = Date.now(); R2('['.repeat(65536)); return Date.now() - t0 < 400; })()
+      //   "나쁜 것이 없다"만 보면 링크 텍스트를 URL 로 바꿔치기하는 변이가 통과한다(실제로 살아남았다).
+      //   **옳은 것이 있다**(이스케이프된 원문 텍스트)까지 함께 단언한다.
+      && !/<b>/.test(I2('[<b>t</b>](https://a.b)')) && I2('[<b>t</b>](https://a.b)').includes('&lt;b&gt;t&lt;/b&gt;')
+      && !/onmouseover="alert/.test(I2('[x](https://a" onmouseover="alert(1))')) && I2('[x](https://a" onmouseover="alert(1))').includes('&quot;')
+      && !/<b>|<i>/.test(R2('| <b>x</b> |\n|---|\n| <i>y</i> |')) && R2('| <b>x</b> |\n|---|\n| <i>y</i> |').includes('&lt;b&gt;x&lt;/b&gt;')
+      && !/<img/i.test(R2('# <img src=x onerror=1>')) && R2('# <img src=x onerror=1>').includes('&lt;img')
+      //   브라우저는 URL 에서 탭/개행/CR 을 제거한 뒤 스킴을 읽는다(실측: href="java\tscript:…" → protocol
+      //   javascript:). 링크 토크나이저가 공백류를 배제하는 것에 기대지 않고 **술어 자체**가 거부해야 한다.
+      && U2('java\tscript:alert(1)') === null && U2('java\nscript:alert(1)') === null
+      && U2('java\rscript:alert(1)') === null && U2('\tjavascript:alert(1)') === null
+      //   탭·개행만 지우면 다른 C0 제어문자로 빠져나간다(검수 실측: \x03·\x01·\x00·\x1F·\x7F 전부 통과했다)
+      && ['\x00', '\x01', '\x03', '\x1F', '\x7F'].every(c => U2(c + 'javascript:alert(1)') === null)
+      && U2('java\x03script:alert(1)') === null && U2('java\x7Fscript:alert(1)') === null
+      && U2('https://ok.example/a') === 'https://ok.example/a'   // 정상 URL 은 그대로(과잉 거부 아님)
+      // 엔티티·제로폭은 브라우저에서 상대 URL 로 떨어진다(실측: protocol=file:) — 링크가 생겨도 무해하다
+      && !/href="javascript:/i.test(I2('[t](javascript&#58;alert(1))'))
+      // 코드펜스 안은 이스케이프될 뿐 아니라 **마크다운도 해석되지 않아야** 한다
+      //   (mdInline 도 mdEsc 를 부르므로 XSS 단언만으로는 이 변이가 살아남는다)
+      && (function () { const s = R2('```\n**굵게** 와 [링크](https://a.b)\n```'); return s.includes('**굵게**') && !/<b>/.test(s) && !/<a /.test(s); })()
+      //   미종료 코드펜스의 내용을 버려도 잡히지 않았다(검수 실측) — 내용 보존까지 단언한다.
+      && R2('```\nkept line one\nkept line two') === '<pre><code>kept line one\nkept line two</code></pre>'
+      // 허용 밖은 평문 — 주석·CDATA 회귀가 정확한 단언들 사이를 빠져나갔다(검수 실측)
+      && R2('<div class="x">y</div>').includes('&lt;div') && R2('---') === '<p>---</p>'
+      && R2('<!--<img src=x onerror=1>-->') === '<p>&lt;!--&lt;img src=x onerror=1&gt;--&gt;</p>'
+      && R2('<![CDATA[<script>x</script>]]>') === '<p>&lt;![CDATA[&lt;script&gt;x&lt;/script&gt;]]&gt;</p>'
+      && R2('a & b < c > d "e"') === '<p>a &amp; b &lt; c &gt; d &quot;e&quot;</p>';
+    dbg.render = String(T1) + (wired ? '' : ' (배선X)');
+
+    // ── T2: 데이터 — 마스킹 · 방향 · 줄경계 · 코드포인트 · 결측 고지.
+    //   마스킹은 **스캐너와 같은 목록**(catalogs.SECRET_PATTERNS)을 써야 한다. 자체 축소판을 쓰던 종전엔
+    //   DB 접속문자열 비밀번호 · GitLab PAT · npm · Stripe · SendGrid · 개인키 본문이 그대로 화면에 실렸다(검수 실측 6종).
+    //   픽스처는 길이를 손으로 세지 말고 생성한다 — 손으로 센 SendGrid 길이가 세 번 틀렸다.
+    const _CH = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+    let _sd = 7;
+    const _rnd = (n) => { let s = ''; for (let i = 0; i < n; i++) { _sd = (_sd * 1103515245 + 12345) % 2147483648; s += _CH[_sd % _CH.length]; } return s; };
+    const _dbPw = _rnd(20);                     // 값을 직접 들고 있는다 — URL 을 다시 파싱하면 인덱스를 틀린다
+    const SEC = {
+      dbUrl: 'DATABASE_URL=postgres://alice:' + _dbPw + '@db.example/app',
+      glpat: 'glpat-' + _rnd(24),
+      npm: 'npm_' + _rnd(36),
+      stripe: 'sk_live_' + _rnd(24),
+      sendgrid: 'SG.' + _rnd(22) + '.' + _rnd(43),
+      pem: '-----BEGIN RSA PRIVATE KEY-----\n' + _rnd(60) + '\n-----END RSA PRIVATE KEY-----',
+      //   END 줄이 없으면 BEGIN 만 지워지고 본문이 남았다(검수 실측). 붙여넣다 잘린 키가 흔하다.
+      pemOpen: '-----BEGIN EC PRIVATE KEY-----\n' + _rnd(58) + '\n',
+      //   암호화 키는 헤더 뒤 **빈 줄**이 오고 본문이 시작한다 — 빈 줄에서 멈추면 본문이 샌다(검수 실측).
+      pemEnc: '-----BEGIN RSA PRIVATE KEY-----\nProc-Type: 4,ENCRYPTED\nDEK-Info: AES-128-CBC,9F8E7D6C\n\n' + _rnd(60) + '\n-----END RSA PRIVATE KEY-----',
+      //   영문자만으로 된 32자 토큰도 자격증명이다(검수 실측: 그냥 샜다).
+      bearerLetters: 'Bearer QwErTyUiOpAsDfGhJkLzXcVbNmQwErTy',
+      //   구분자 없는 AWS 문맥 실값 — 문맥 패턴을 통째로 제외했더니 샜다(검수 실측).
+      awsBare: 'aws secret access key ' + _rnd(40),
+    };
+    //   가림은 **탐지용 문맥 휴리스틱**을 그대로 쓰면 안 된다 — 정상 산문이 통째로 사라진다(검수 실측).
+    //   **공백이 있는 줄**(=문단)은 보존된다. 공백 없는 단일 토큰 줄과 20자 이상 Bearer 값은
+    //   의도적으로 가린다 — 값의 조성으로는 시크릿과 산문을 가를 수 없고, 표시용 마스킹은 안전한 쪽으로 실패한다.
+    const PROSE_OK = [
+      'Bearer 인증을 도입한다',
+      'Bearer token 을 쓴다',
+      //   BEGIN 을 인용한 정책 문서의 산문(Name: value 형태 포함)을 삼키면 안 된다(검수 실측).
+      'Note: 개인키는 커밋하지 않습니다',
+      'Status: 검토중',
+    ];
+    //   문맥 패턴은 **값만** 지운다 — 문장을 통째로 삼키던 것을 고쳤으므로 구조가 남아야 한다.
+    const PROSE_STRUCT = ['결정: AWS secret commit ', ' was reverted.'];
+    //   plan.md 는 **표지 없는 정상 문서** — 본문이 그대로 실려야 한다(가드가 과잉이면 기능이 죽는다).
+    fs.writeFileSync(path.join(H, 'plan.md'), '# Goal\n\n평범한 문장.\n' + PROSE_OK.join('\n') + '\n'
+      + PROSE_STRUCT[0] + '0123456789abcdef0123456789abcdef01234567' + PROSE_STRUCT[1] + '\n');
+    //   skill-index.md 는 **표지가 있는 문서** — 본문을 아예 싣지 않아야 한다.
+    //   값 단위 마스킹은 다섯 라운드 동안 계속 새어서(인용문 `> ` PEM · base64 의 `/`·`+` · 소문자 bearer ·
+    //   placeholder 모양 토큰) **안전의 전제에서 뺐다**. 표지가 있으면 통째로 제외한다.
+    fs.writeFileSync(path.join(H, 'skill-index.md'), '# Skills\n\n' + Object.values(SEC).join('\n') + '\n');
+    const N2 = 4000;
+    fs.writeFileSync(path.join(H, 'decisions.md'), Array.from({ length: N2 }, (_, i) => '- D' + String(i + 1).padStart(4, '0') + ' 결정 — 근거와 대안을 함께 적는다').join('\n'));
+    //   줄 길이를 들쭉날쭉하게 — 상한이 우연히 줄 끝에 맞으면 "원문 그대로 자르기" 변이가 살아남는다
+    fs.writeFileSync(path.join(H, 'current-state.md'), Array.from({ length: N2 }, (_, i) => '- S' + String(i + 1).padStart(4, '0') + ' 상태 항목 — 충분히 길게 적어 상한을 넘긴다' + 'x'.repeat(i % 7)).join('\n'));
+    //   이모지만 반복하면 상한이 서로게이트 쌍 경계에 정확히 맞아 쪼갤 자리가 없다 — 앞에 1글자를 끼운다
+    //   (skill-index 는 위에서 표지 문서로 쓰므로 서로게이트 검사는 tech-profile 로 옮긴다)
+    fs.writeFileSync(path.join(H, 'tech-profile.json'), 'a' + '🎉'.repeat(G.DOC_PER_CAP));
+    //   검수 지적: tech·progress 두 문서는 T2 에서 아무것도 확인하지 않아 경로가 끊겨도 통과했다.
+    fs.writeFileSync(path.join(H, 'progress-tracker.md'), Array.from({ length: 300 }, (_, i) => '- P' + String(i + 1).padStart(4, '0') + ' 진행 기록').join('\n'));
+    fs.rmSync(path.join(H, 'session-handoff.md'), { force: true });
+    const D2 = G.buildDocsData(w, '2026-07-31T12:34:56.000Z');
+    const g = (k) => D2.files.find(f => f.key === k) || {};
+    const lone = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:^|[^\uD800-\uDBFF])[\uDC00-\uDFFF]/;
+    const _blob = JSON.stringify(D2);
+    const T2 = D2.files.length === 7 && D2.at === '2026-07-31T12:34:56.000Z'
+      //   표지 있는 문서: **본문을 싣지 않는다**. 부분 마스킹의 빈틈으로 새는 것을 구조적으로 막는다.
+      && g('skills').guarded === true && g('skills').text === '' && g('skills').charsTotal > 0
+      //   그리고 임베드 전체 어디에도 실값이 없어야 한다(문자열 전수 검사 — 어느 필드로 새든 잡힌다)
+      && ![_dbPw, SEC.glpat, SEC.npm, SEC.stripe, SEC.sendgrid, SEC.bearerLetters.slice(7),
+        SEC.pem.split('\n')[1], SEC.pemOpen.split('\n')[1], SEC.pemEnc.split('\n')[4], SEC.awsBare.slice(-40),
+      ].some(s => _blob.includes(s))
+      //   반대로 **표지 없는 문서는 그대로 실려야 한다** — 가드가 과잉이면 기능이 죽는다
+      && g('plan').guarded !== true && g('plan').text.includes('평범한 문장.')
+      && PROSE_OK.every(s => g('plan').text.includes(s))
+      && PROSE_STRUCT.every(s => g('plan').text.includes(s))
+      //   가드를 통과한 문서에도 **두 번째 층(마스킹)은 살아 있어야 한다** — 문맥 패턴의 값은 가려지고
+      //   문장 구조는 남는다. 이 단언이 없으면 마스킹을 통째로 지워도 테스트가 통과한다(변이로 확인).
+      && g('plan').text.includes('결정: AWS secret commit ***')
+      && !g('plan').text.includes('0123456789abcdef0123456789abcdef01234567')
+      //   tech(JSON, 코드블록으로 표시) · progress(누적 로그, 뒤를 남김) 두 경로가 실제로 연결돼 있다
+      && g('tech').lang === 'json' && g('tech').missing !== true
+      && g('progress').tail === true && g('progress').text.includes('P0300') && g('progress').missing !== true
+      && g('decisions').truncated === true && g('decisions').text.length <= G.DOC_PER_CAP
+      && g('decisions').text.includes('D' + N2) && !g('decisions').text.includes('D0001')
+      && g('decisions').text.split('\n').every(l => /^- D\d{4} /.test(l))
+      && g('state').text.includes('S0001') && !g('state').text.includes('S' + N2)
+      && g('state').truncated === true && g('state').text.split('\n').every(l => /^- S\d{4} 상태 항목 — 충분히 길게 적어 상한을 넘긴다x*$/.test(l))
+      && !lone.test(g('tech').text) && g('tech').text.length <= G.DOC_PER_CAP   // 서로게이트 검사는 tech 로 이동
+      && g('handoff').missing === true && g('handoff').text === ''
+      && !JSON.stringify(D2.files.map(f => f.rel)).includes(w.replace(/\\/g, '\\\\'));
+    //   마스킹 규칙은 **격리된 입력**으로 직접 잰다. 한 문서에 여러 PEM 을 몰아넣으면 종료되지 않은 키가
+    //   뒤쪽 END 줄과 짝지어져 서로를 가려 주고, 그 덕에 규칙이 깨져도 단언이 통과한다(변이 실험으로 확인).
+    const PUx = require(path.resolve(path.dirname(CLI), '..', 'lib', 'pure-utils.js'));
+    const encBody = _rnd(60), openBody = _rnd(58), letters = 'QwErTyUiOpAsDfGhJkLzXcVbNmQwErTy', awsVal = _rnd(40);
+    const M = {
+      //   ① 암호화 키: 헤더 뒤 **빈 줄**이 오고 본문이 시작한다. END 없이도 본문이 가려져야 한다.
+      encOpen: PUx.redactSecrets('-----BEGIN RSA PRIVATE KEY-----\nProc-Type: 4,ENCRYPTED\nDEK-Info: AES-128-CBC,9F8E\n\n' + encBody + '\n'),
+      //   ② END 없는 평문 키.
+      plainOpen: PUx.redactSecrets('-----BEGIN EC PRIVATE KEY-----\n' + openBody + '\n'),
+      //   ③ BEGIN 을 인용한 정책 문서 — PEM 표준 헤더처럼 보이는 산문도 남아야 한다.
+      prose: PUx.redactSecrets('-----BEGIN RSA PRIVATE KEY-----\nComment: 이 키는 예시입니다\nNote: 커밋 금지\n일반 문장.'),
+      //   판별용: 뒤에 base64 줄이 있어야 헤더 규칙이 실제로 발동한다. 표준 헤더(Comment)는 먹더라도
+      //   **비표준 헤더 형태의 산문**(Note:)에서 멈춰야 한다 — 아무 Name: value 나 먹으면 산문이 사라진다.
+      proseB: PUx.redactSecrets('-----BEGIN RSA PRIVATE KEY-----\nComment: 예시\nNote: 커밋 금지\n' + _rnd(40)),
+      //   ④ 종료되지 않은 키와 무관한 END 가 멀리 떨어져 있어도 그 사이 산문을 삼키면 안 된다.
+      span: PUx.redactSecrets('-----BEGIN RSA PRIVATE KEY-----\n\n중간 산문입니다\n또 다른 줄\n\n-----END RSA PRIVATE KEY-----'),
+      bearer: PUx.redactSecrets('Bearer ' + letters),
+      //   길이 문턱(32자)으로 갈랐더니 20~31자 영문 토큰이 샜다(검수 실측) — 길이가 아니라 모양으로 가른다.
+      bearer20: PUx.redactSecrets('Bearer AbCdEfGhIjKlMnOpQrSt'),
+      bearer31: PUx.redactSecrets('Bearer AbCdEfGhIjKlMnOpQrStUvWxYzABCDE'),
+      //   낱말 예외를 없앴다 — 유효한 불투명 토큰이 소문자/낱말꼴일 수 있어 예외가 곧 누출이었다(검수 실측).
+      bearerWord: PUx.redactSecrets('Use Bearer authenticationMiddleware for API requests.'),
+      bearerLower: PUx.redactSecrets('Bearer abcdefghijklmnopqrst'),
+      bearerCamel: PUx.redactSecrets('Bearer CorrectHorseBatteryStaple'),
+      bearerShort: PUx.redactSecrets('Bearer 인증을 도입한다'),
+      //   카탈로그 문자군이 base64 의 `/` `+` 에서 끊겨 실토큰이 통째로 남았다(실측: 앞 8자 뒤 `/`).
+      bearerSlash: PUx.redactSecrets('Bearer abcdefgh/ijklmnopqrstuvwxyz0123456789'),
+      bearerPlus: PUx.redactSecrets('Bearer abcde+fghijklmnopqrstuvwxyz0123456789'),
+      //   BEGIN 인용 뒤의 **평범한 영문 식별자** 한 줄을 본문으로 오인해 지웠다(검수 실측).
+      //   그렇다고 길이로 올리면 줄이 짧게 감긴 키 본문이 샌다 — 내용(숫자/기호 포함)으로 가른다.
+      quoteWord: PUx.redactSecrets('정책 인용:\n-----BEGIN RSA PRIVATE KEY-----\nNeverCommitPrivateKeys\n다음 문단'),
+      shortBody: PUx.redactSecrets('-----BEGIN RSA PRIVATE KEY-----\nMIIEowIBAAKCAQEA7x9fQ2\nkLmN0pQrStUvWxYz\n-----END RSA PRIVATE KEY-----'),
+      //   PGP 블록은 END 앞에 =CRC 줄이 온다 — 허용하지 않으면 CRC 와 END 가 남는다.
+      pgp: PUx.redactSecrets('-----BEGIN PGP PRIVATE KEY BLOCK-----\nVersion: GnuPG v2\n\n' + _rnd(64) + '\n=AbCd\n-----END PGP PRIVATE KEY BLOCK-----'),
+      awsBare: PUx.redactSecrets('aws secret access key ' + awsVal),
+      awsProse: PUx.redactSecrets('결정: AWS secret commit 0123456789abcdef0123456789abcdef01234567 was reverted.'),
+    };
+    const T2b = !M.encOpen.includes(encBody) && !M.plainOpen.includes(openBody)
+      && M.prose.includes('Comment: 이 키는 예시입니다') && M.prose.includes('Note: 커밋 금지') && M.prose.includes('일반 문장.')
+      && M.proseB.includes('Note: 커밋 금지')
+      && M.span.includes('중간 산문입니다') && M.span.includes('또 다른 줄')
+      && !M.bearer.includes(letters)
+      && !M.bearer20.includes('AbCdEfGhIjKlMnOpQrSt') && !M.bearer31.includes('AbCdEfGhIjKlMnOpQrStUvWxYzABCDE')
+      //   소문자만·낱말꼴 토큰도 가려야 한다(예외를 두면 그 예외가 누출 경로가 된다)
+      && !M.bearerLower.includes('abcdefghijklmnopqrst') && !M.bearerCamel.includes('CorrectHorseBatteryStaple')
+      && M.bearerWord === 'Use *** for API requests.'          // 산문도 함께 가려지는 것이 **의도한 절충**
+      && M.bearerShort === 'Bearer 인증을 도입한다'                 // 20자 미만은 영향 없음
+      && M.bearerSlash === '***' && M.bearerPlus === '***'      // base64 의 / + 에서 끊기면 안 된다
+      //   BEGIN 뒤 공백 없는 단일 토큰 줄은 가려진다(의도) — 그러나 **문단**은 남아야 한다
+      && !M.quoteWord.includes('NeverCommitPrivateKeys') && M.quoteWord.includes('다음 문단')
+      && !M.shortBody.includes('MIIEowIBAAKCAQEA7x9fQ2') && !M.shortBody.includes('kLmN0pQrStUvWxYz')
+      && M.pgp === '***'
+      && !M.awsBare.includes(awsVal)
+      && M.awsProse.includes('결정: AWS secret commit ') && M.awsProse.includes(' was reverted.');
+    //   표지 술어는 **표지 하나씩 격리**해서 잰다. 한 파일에 여러 시크릿을 몰아넣으면 다른 표지가 대신
+    //   가드해 줘서, 특정 표지를 무력화하는 변이가 그대로 통과한다(변이 실험으로 확인).
+    //   표지는 값이 아니라 **형식**으로 정의했으므로 줄 앞 접두어·대소문자·문자군 우회가 모두 막혀야 한다.
+    const HC = PUx.hasCredentialMarker;
+    const T2c = [
+      '-----BEGIN RSA PRIVATE KEY-----',
+      '> -----BEGIN RSA PRIVATE KEY-----',           // 인용문 접두(검수가 재현한 전량 노출 경로)
+      '- -----BEGIN EC PRIVATE KEY-----',            // 목록 접두
+      '    -----BEGIN PGP PRIVATE KEY BLOCK-----',   // 들여쓰기
+      'bearer dddddddddddddddddddddddd',             // 소문자 스킴
+      'Bearer /cccccccccccccccccccccccc',            // base64 의 / 로 시작
+      'Bearer aaaaaaaaaaaaaaaaaaa~ZZZZZZZZZZZZZZZZZZZZ', // token68 의 ~
+      //   특수문자를 **가운데** 두고 양쪽 조각을 16자 미만으로 — 문자군에서 `+ / ~` 를 빼면 여기서 갈린다.
+      //   맨 앞에 두면 접두 허용(`[^A-Za-z0-9]{0,4}`)이 흡수해 뒤 조각만으로 매치돼 변이가 살아남는다(실측).
+      'Bearer abcdefghij/klmnopqrst', 'Bearer abcdefghij+klmnopqrst', 'Bearer abcdefghij~klmnopqrst',
+      'Authorization: Basic YTpi',
+      //   검수가 표지를 빠져나가는 네 형태를 보였다 — 짧은 RFC6750 토큰 · 쿠키 · 5분절 JWE · 강조로 감싼 스킴.
+      'Bearer mF_9.B5f-4.1JqM_x',                        // 19자(RFC6750 은 길이를 보장하지 않는다)
+      'Cookie: session=s%3AabcdefghijklmnopqrstuvwxyzAB',
+      'Set-Cookie: sid=abcdefghijklmnopqrstuvwxyz; HttpOnly',
+      'eyJhbGciOiJkaXIiLCJlbmMiOiJBMjU2R0NNIn0..48V1_ALb6US0.7gg.XFBoMYUZodetZdvTiFvSkQ',  // compact JWE
+      '**Bearer** eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abcdefghij',
+      '`Bearer` AbCdEfGhIjKlMnOpQrStUvWx',
+      'glpat-abcdefghijklmnopqrstuvwx', 'npm_' + _rnd(36), 'ghp_' + _rnd(36), 'AKIA' + _rnd(16),
+      'DATABASE_URL=postgres://alice:pw123456@db/app',
+      'eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.abc',
+    ].every(s => HC(s) === true)
+      //   반대로 평범한 문서는 표지가 없어야 한다 — 여기서 참이 되면 문서가 통째로 안 보인다
+      && ['# 제목\n\n첫 문단입니다.', '- 목록 항목\n- 또 다른 항목', 'Bearer 인증을 도입한다',
+        'https://example.com/docs/keys 를 참고하세요', 'password 정책을 문서화한다',
+        '결정: 인증 방식을 변경한다', 'BEGIN 과 END 사이를 확인하라', 'cookie 정책을 정리한다',
+        'authorization 흐름을 검토한다'].every(s => HC(s) === false);
+    dbg.marker = String(T2c);
+
+    // ── T2d: **문서 탭만 가드하면 소용없다.** 같은 내용이 그래프 노드·로드맵으로도 임베드된다 —
+    //   `decision add "Authorization: Bearer <토큰>"` 이 DATA.nodes[].label / detail 로 원문 그대로 실렸다(검수 실측).
+    //   임베드 직전 한 곳에서 모든 문자열을 통과시키므로, **실제 CLI 경로**로 어느 표면으로든 새지 않는지 확인한다.
+    const w2 = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-gph96-')); _d.push(w2);
+    fs.writeFileSync(path.join(w2, 'package.json'), JSON.stringify({ name: 'g96', version: '0.1.0' }, null, 2));
+    const L2 = (a) => cp.spawnSync(process.execPath, [CLI, ...a], { encoding: 'utf8', timeout: 180000, cwd: w2 });
+    L2(['init', w2, '--yes', '--no-stale-check']);
+    const NEEDLE = { decision: 'DECISIONLEAK_' + _rnd(20), task: 'TASKLEAK_' + _rnd(20), plan: 'PLANLEAK_' + _rnd(20) };
+    L2(['decision', 'add', 'Authorization: Bearer ' + NEEDLE.decision, '--reason', 'audit', '--path', w2]);
+    //   **표지만 잡고 마스킹은 못 잡는 형태**로도 확인한다 — 쿠키는 키 이름에 KEY/TOKEN 이 없어
+    //   마스킹 규칙에 걸리지 않는다. 이게 없으면 "표지 가드 제거" 변이가 마스킹에 가려 살아남는다(실측).
+    L2(['task', 'add', 'Cookie: session=' + NEEDLE.task, '--path', w2]);
+    L2(['plan', 'add', 'Set-Cookie: sid=' + NEEDLE.plan, '--path', w2]);
+    L2(['task', 'add', '평범한 작업 항목입니다', '--path', w2]);
+    L2(['graph', w2, '--html']);
+    const gHtml = fs.readFileSync(path.join(w2, 'leerness.html'), 'utf8');
+    //   **출구 전수 조사** — "고친 출구 하나만 보고 안전을 선언"한 실수를 되풀이하지 않으려면 출구를 세어야 한다.
+    //   사용자 텍스트가 leerness.html 로 나가는 경로를 하나씩 오염시켜, 어느 하나라도 새면 실패한다.
+    //   표지는 **마스킹이 못 잡는 쿠키 형태**로 심는다(마스킹에 가려 통과하는 것을 막는다).
+    const H2 = path.join(w2, '.harness');
+    const SURF = [
+      ['lesson', () => L2(['lesson', 'save', 'Cookie: session=LEAKLESSON_QwErTyUiOpAsDfGh', '--path', w2])],
+      ['rule', () => L2(['rule', 'add', 'Cookie: session=LEAKRULE_QwErTyUiOpAsDfGh', '--trigger', 'every-round', '--path', w2])],
+      ['planfile', () => fs.writeFileSync(path.join(H2, 'plan.md'), '# Goal\n\nCookie: session=LEAKPLANFILE_QwErTyUiOpAsDfGh\n')],
+      ['progress', () => fs.appendFileSync(path.join(H2, 'progress-tracker.md'), '\n- Cookie: session=LEAKPROGRESS_QwErTyUiOpAsDfGh\n')],
+      ['state', () => fs.writeFileSync(path.join(H2, 'current-state.md'), 'Cookie: session=LEAKSTATE_QwErTyUiOpAsDfGh\n')],
+      ['handoff', () => fs.writeFileSync(path.join(H2, 'session-handoff.md'), 'Cookie: session=LEAKHANDOFF_QwErTyUiOpAsDfGh\n')],
+      ['skills', () => fs.writeFileSync(path.join(H2, 'skill-index.md'), 'Cookie: session=LEAKSKILLS_QwErTyUiOpAsDfGh\n')],
+      ['feature', () => fs.writeFileSync(path.join(H2, 'feature-graph.md'), '## F-0001 Cookie: session=LEAKFEATURE_QwErTyUiOpAsDfGh\n- depends-on: F-0002\n')],
+      ['tech', () => { const p = path.join(H2, 'tech-profile.json'); let jj = {}; try { jj = JSON.parse(fs.readFileSync(p, 'utf8')); } catch {} jj.current = jj.current || {}; jj.current.services = [{ id: 'svc', evidence: 'Cookie: session=LEAKTECH_QwErTyUiOpAsDfGh' }]; fs.writeFileSync(p, JSON.stringify(jj, null, 2)); }],
+      //   **깊이 상한을 두면 그 너머가 통째로 우회한다.** tech-profile.json 은 임의 JSON 이라 실 CLI 로 도달 가능하다
+      //   (검수 실측: 12단계 밖 문자열에 정규화가 아예 걸리지 않았다). 얕은 픽스처만으로는 이 변이를 못 잡는다.
+      ['deep', () => {
+        const p = path.join(H2, 'tech-profile.json');
+        let jj = {}; try { jj = JSON.parse(fs.readFileSync(p, 'utf8')); } catch {}
+        let node = { evidence: 'Cookie: session=LEAKDEEP_QwErTyUiOpAsDfGh' };
+        for (let k = 0; k < 40; k++) node = { w: node };
+        jj.deep = node;
+        fs.writeFileSync(p, JSON.stringify(jj, null, 1));
+      }],
+    ];
+    for (const [, fn] of SURF) fn();
+    //   **표지 없는 문서 하나**는 반드시 남겨 둔다 — 전부 가드되면 임베드 텍스트가 0 이라
+    //   "보고 spent = 실제 바이트" 불변식이 공허하게 참이 된다(변이 실험으로 확인).
+    //   내용은 `redactSecrets` 가 **비멱등**인 형태로 둔다(`auth_scheme=***,` 의 쉼표를 2회차에 먹는다 — 실측).
+    //   그래야 "임베드 직전에 다시 변환" 변이가 회계 어긋남으로 드러난다.
+    fs.writeFileSync(path.join(H2, 'decisions.md'),
+      '# 결정\n\n설계 메모: idempotency_key=run:phase:step, auth_scheme=\'\', X_AUTH=false 를 확인한다.\n정상 문단입니다.\n');
+    L2(['graph', w2, '--html']);
+    const gHtml2 = fs.readFileSync(path.join(w2, 'leerness.html'), 'utf8');
+    const T2d = Object.values(NEEDLE).every(v => !gHtml.includes(v))
+      && gHtml.includes('평범한 작업 항목입니다')        // 가드가 과잉이면 그래프가 비어 버린다
+      && SURF.every(([n]) => !gHtml2.includes('LEAK' + n.toUpperCase() + '_QwErTyUiOpAsDfGh'))
+      && gHtml2.includes('평범한 작업 항목입니다')
+      //   **보고한 spent = 실제 임베드 바이트** 불변식. 문서 텍스트를 임베드 직전에 다시 변환하면
+      //   회계만 옛 값으로 남아 어긋난다(검수 실측: 1바이트). 생성물에서 직접 확인한다.
+      && (function () {
+        const gi = gHtml2.indexOf('var DATA = '), gj = gHtml2.indexOf(';\n', gi);
+        const gd = JSON.parse(gHtml2.slice(gi + 11, gj).replace(/\\u003c/g, '<'));
+        const sum = (gd.docs.files || []).reduce((a, f) => a + Buffer.byteLength(f.text || '', 'utf8'), 0);
+        return gd.docs.spent === sum && sum > 0;    // sum===0 이면 불변식이 공허하게 참이다
+      })();
+    //   임베드 정규화의 **경계 3종** — 주입 API 로만 만들 수 있는 형태까지 포함한다.
+    //   ① 공유 참조(순환 아님)를 지우면 정상 데이터가 조용히 사라진다(방문 집합을 전역으로 두면 그렇게 된다).
+    //   ② 진짜 순환은 끊고 생성은 성공해야 한다. ③ 아주 깊은 유효 JSON 으로 **생성 자체가 실패하면 안 된다**
+    //   — 상한이 fail-open(원본 통과)이면 우회, fail-safe(자리표시자 대체)면 보호다. 그 구분을 여기서 못 박는다.
+    const shared = { id: 'svc', evidence: 'SHAREDMARK' };
+    const dShared = G.buildGraphData(w2, { _loadTechProfile: () => ({ current: { languages: [shared], services: [shared] }, history: [] }) });
+    const cyc = { evidence: 'CYCMARK' }; cyc.self = cyc;
+    let cycOk = false;
+    try {
+      const cs = JSON.stringify(G.buildGraphData(w2, { _loadTechProfile: () => ({ current: { languages: [cyc], services: [] }, history: [] }) }));
+      //   순환은 **곧바로** 끊겨야 한다. 깊이 상한이 대신 끊어 주면 결과는 나오지만 200단계가 부풀어 실린다
+      //   — 크기까지 봐야 "순환 차단 제거" 변이가 판별된다(그렇지 않으면 살아남았다).
+      cycOk = cs.includes('CYCMARK') && (cs.match(/"self"/g) || []).length <= 1;
+    } catch { cycOk = false; }
+    let deep = { evidence: 'DEEPMARK' };
+    for (let k = 0; k < 5000; k++) deep = { w: deep };
+    let deepOk = false;
+    try { deepOk = typeof JSON.stringify(G.buildGraphData(w2, { _loadTechProfile: () => ({ current: { languages: [], services: [] }, history: [], deep }) })) === 'string'; } catch { deepOk = false; }
+    //   상한은 **넉넉해야** 한다 — 낮추면 누출은 없지만 정상 데이터가 조용히 사라진다.
+    //   "생성 성공"만 보면 상한을 12 로 낮추는 변이가 통과한다(실측). 보통 깊이의 값이 남는지도 본다.
+    let mid = { evidence: 'MIDMARK' };
+    for (let k = 0; k < 30; k++) mid = { w: mid };
+    let midOk = false;
+    try { midOk = JSON.stringify(G.buildGraphData(w2, { _loadTechProfile: () => ({ current: { languages: [], services: [] }, history: [], mid }) })).includes('MIDMARK'); } catch { midOk = false; }
+    deepOk = deepOk && midOk;
+    const T2e = (JSON.stringify(dShared.tech).match(/SHAREDMARK/g) || []).length === 2 && cycOk && deepOk;
+    dbg.embed = String(T2e);
+    dbg.graph = String(T2d) + ' (출구 ' + (SURF.length + 3) + '종)';
+    dbg.mask = String(T2b);
+    dbg.data = String(T2) + ` (dec ${g('decisions').text.length}/${g('decisions').totalChars} · skills ${g('skills').text.length})`;
+
+    // ── T3: 전체 상한에서 **조용한 누락이 없다**.
+    //   기본값(7종 × 64KB = 448KB)으로는 512KB 상한에 닿을 수 없어 이 분기가 아예 안 돈다 —
+    //   작은 상한을 주입해 실제로 발화시키고, "발화했다"까지 단언한다(안 그러면 every 가 공허하게 참).
+    //   ASCII 픽스처만 쓰면 예산을 **코드 단위로 세는 회귀**가 그대로 통과한다(검수 실측) — 한글을 섞는다.
+    for (const f of ['plan.md', 'skill-index.md', 'current-state.md', 'progress-tracker.md', 'decisions.md']) {
+      fs.writeFileSync(path.join(H, f), ('한글이 섞인 줄 ' + 'x'.repeat(180) + '\n').repeat(400));
+    }
+    const S2 = G.buildDocsData(w, 'x', { perCap: 4096, totalCap: 9000 });
+    //   보고된 spent 가 **실제 바이트**와 같아야 한다 — 코드 단위로 세면 여기서 어긋난다.
+    const S2bytes = S2.files.reduce((a, f) => a + Buffer.byteLength(f.text || '', 'utf8'), 0);
+    const sk2 = S2.files.filter(x => x.skipped);
+    //   상한은 **UTF-8 바이트**여야 한다. 코드 단위로 세면서 "64KB"라 적으면 한글 문서에서 3배가 실린다
+    //   (검수 실측: 합계 512KB 주장 → 실제 1,152KB · HTML 1.21MB).
+    const KO = '한'.repeat(30000);
+    for (const f of ['plan.md', 'skill-index.md', 'current-state.md', 'progress-tracker.md', 'decisions.md', 'tech-profile.json']) {
+      fs.writeFileSync(path.join(H, f), KO);
+    }
+    const B2 = G.buildDocsData(w, 'x');
+    const byteSum = B2.files.reduce((a, f) => a + Buffer.byteLength(f.text || '', 'utf8'), 0);
+    const perByteOk = B2.files.every(f => Buffer.byteLength(f.text || '', 'utf8') <= G.DOC_PER_CAP);
+    //   경계에 **빈 줄**이 하나만 있어도 keep 은 1 이 되지만 담긴 내용은 0자였다 — 초장문 문서가 통째로
+    //   빈 화면이 됐다(검수 실측 70,000자 → 0자). 앞뒤 양쪽 방향으로 확인한다.
+    //   빈 줄 **한 개**만 보면 두 개에서 재발하는 것을 못 잡는다(검수 실측: 1개는 통과, 2개는 1자로 유실).
+    const LONG = 'a'.repeat(70000);
+    const capHead = G._capDoc('\n' + LONG, 65536, false);
+    const capTail = G._capDoc(LONG + '\n', 65536, true);
+    const capHead2 = G._capDoc('\n\n' + LONG, 65536, false);
+    const capTail2 = G._capDoc(LONG + '\n\n', 65536, true);
+    const capHead3 = G._capDoc('\n\n\n\n' + LONG, 65536, false);
+    //   빈 줄의 "내용" 을 세는 방식은 세 번 틀렸다 — CRLF 의 \r, 공백, 탭이 모두 내용으로 세어졌다(검수 실측).
+    //   이제 줄 단위 결과와 코드포인트 절단 결과 중 **긴 쪽**을 쓰므로 어떤 공백 조합에도 예산을 채운다.
+    const capWs = [
+      G._capDoc('\r\n' + LONG, 65536, false), G._capDoc('\r\n\r\n' + LONG, 65536, false),
+      G._capDoc('   \n' + LONG, 65536, false), G._capDoc('\t\n' + LONG, 65536, false),
+      G._capDoc(LONG + '\r\n', 65536, true), G._capDoc(LONG + '\n   ', 65536, true),
+    ];
+    //   코드포인트 고지: **이모지** 문서라야 판별된다 — 한글은 UTF-16 길이와 코드포인트 수가 같아
+    //   고지를 String.length 로 되돌리는 변이가 그대로 통과한다(검수 실측).
+    fs.writeFileSync(path.join(H, 'current-state.md'), '🎉'.repeat(30000));
+    const emo = G.buildDocsData(w, 'x');
+    const anyDoc = emo.files.find(f => f.key === 'state') || {};
+    const T3 = sk2.length > 0 && S2.spent <= 9000 && S2.perCap === 4096 && S2.totalCap === 9000
+      //   화면 고지는 charsTotal(코드포인트)을 쓴다 — totalChars 만 보면 고지를 0 으로 바꿔도 통과한다(검수 실측).
+      && sk2.every(x => x.text === '' && x.totalChars > 0 && x.charsTotal > 0 && x.truncated === true)
+      //   **정확히 상한**인 문서를 "잘렸다"고 표시하면 안 된다(경계 오판) — 잡히지 않던 변이다.
+      && G._capDoc('a'.repeat(65536), 65536, false).truncated === false
+      && G._capDoc('a'.repeat(65537), 65536, false).truncated === true
+      //   minSlice 를 사실상 없애면 **의미 없는 조각**이 실린다 — skipped 개수가 아니라 "조각이 없음"을 단언한다.
+      && S2.files.every(x => x.skipped || x.missing || x.guarded || Buffer.byteLength(x.text || '', 'utf8') >= 256)
+      && S2.files.filter(x => !x.missing).every(x => x.skipped || x.truncated !== undefined)
+      && perByteOk && byteSum <= G.DOC_TOTAL_CAP && byteSum > G.DOC_PER_CAP   // 실제로 여러 문서가 실렸다
+      && S2.spent === S2bytes                                                 // 보고 예산 = 실제 바이트
+      && [capHead, capTail, capHead2, capTail2, capHead3, ...capWs].every(c => c.text.replace(/\s/g, '').length > 60000 && Buffer.byteLength(c.text, 'utf8') <= 65536)
+      //   "앞부분만/뒷부분만" 고지가 참이어야 한다 — 경계 줄이 길다고 제목·푸터를 버리면 안 된다(검수 실측).
+      && G._capDoc('TITLE\n' + LONG, 65536, false).text.startsWith('TITLE\n')
+      && G._capDoc(LONG + '\nFOOTER', 65536, true).text.endsWith('\nFOOTER')
+      && !/\r$/.test(G._capDoc(LONG + '\r\nFOOTER', 65536, true).text)
+      //   `\n` 으로만 나누므로 CRLF 문서는 줄 끝에 `\r` 이 남는다 — head 에서 다음 줄이 안 들어가면
+      //   재조립 때 개행이 붙지 않아 **고립된 CR** 이 꼬리에 남았다(검수 실측: "A\r").
+      //   경계 줄이 **상한 안에 들어가는** 경우라야 판별된다 — 초장문이면 잘린 조각이 이어붙어
+      //   CR 뒤에 개행이 생기고 고립되지 않는다(그 픽스처로는 변이가 살아남았다).
+      && !/\r(?!\n)/.test(G._capDoc('A\r\nBB\r\nC', 4, false).text)
+      && !/\r(?!\n)/.test(G._capDoc('AAAA\r\n' + LONG, 65536, false).text)
+      && Buffer.byteLength(G._capDoc('TITLE\n' + LONG, 65536, false).text, 'utf8') <= 65536
+      //   이모지 문서에서 코드포인트 수는 UTF-16 길이의 **절반**이다 — 두 값이 달라야 판별력이 있다.
+      && anyDoc.chars === Array.from(anyDoc.text || '').length && anyDoc.chars * 2 === (anyDoc.text || '').length
+      && anyDoc.charsTotal === 30000 && anyDoc.totalChars === 60000
+      //   데이터가 코드포인트를 실어도 **화면 고지가 String.length 로 되돌아가면** 사용자가 보는 수치는 다시 틀린다.
+      //   그 변이는 데이터 단언만으로는 살아남았다(실측) — 고지가 어느 값을 쓰는지 생성물에서 확인한다.
+      && /'\+\(f\.chars\|\|0\)\+'\/'\+\(f\.charsTotal\|\|0\)\+'자\(/.test(html)
+      && !/\(f\.text\|\|''\)\.length\+'\/'/.test(html);
+    dbg.cap = String(T3) + ` (skipped ${sk2.length} · spent ${S2.spent}/${S2bytes} · 바이트합 ${byteSum} · 빈경계 ${capHead.text.length}/${capTail.text.length}/${capHead2.text.length}/${capTail2.text.length})`;
+
+    ok = setupOk && T1 && T2 && T2b && T2c && T2d && T2e && T3;
+    if (!ok) console.log(`   [P-0010 디버그] 셋업=${setupOk} 렌더=${dbg.render} 데이터=${dbg.data} 표지=${dbg.marker} 그래프=${dbg.graph} 임베드=${dbg.embed} 마스킹=${dbg.mask} 상한=${dbg.cap}`);
+  } catch (e) { console.log('   [P-0010 디버그] 예외: ' + ((e && e.message) || e)); }
+  finally { _d.forEach(x => { try { fs.rmSync(x, { recursive: true, force: true }); } catch {} }); }
+  console.log(ok ? '✓ B(1.36.96) P-0010 문서 탭: 최소 부분집합 렌더(제목·목록·펜스·표·링크·강조) · XSS 8방향 차단(원시HTML·javascript/data/vbscript/프로토콜상대·속성탈출·표/제목/링크텍스트) · 펜스 안 미해석 · **자격증명 표지 문서는 본문 미포함**(마스킹은 두 번째 층) · 누적로그 tail/일반 head · 줄경계+코드포인트 절단 · 결측/전체상한 명시 고지' : '✗ P-0010 문서 탭 실패');
+  if (!ok) failed++;
+}
+
 // 1.36.94 (헌트 이월 2건 + 자체 검수 반영): ① 형상 무효 스토어에서 **차단 메시지가 안내한 탈출구가
 //   같은 사유로 거부**돼, 남는 실행 가능한 선택지가 "보호를 끄기" 하나였다.
 //   ② `provider add codex --bin codex` 라는 사실상 무변경 재등록이 빌트인 authCheck 를 지워 인증 축을