leerness 1.36.95 → 1.36.97

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.97",
   "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",