@kaydash9999/banker-plugins 0.15.1 → 0.16.0

package/skills/lineage/SKILL.md

@@ -2,7 +2,7 @@
 name: lineage
 description: "현재 세션 대화를 카카오톡 스타일의 단일 HTML 로 내보냄. Claude 답변은 한 줄 요약 아래에 원문을 접어 두고, 펼치면 마크다운으로 렌더해 보여 줌. 기본은 세션 모델이 요약을 쓰고 노이즈 턴을 걸러 내며, `--rulebase` 는 모델 없이 규칙만 씀. 여러 세션을 합칠 수 있음. 'lineage'/'대화 export'/'카톡 스타일 html' 시 사용."
 invocation: /lineage
-version: 3.0.1
+version: 3.0.2
 schema_version: 1
 ---
 
@@ -52,7 +52,7 @@ echo "..." | /lineage --from-transcript -   # stdin paste
 /lineage --keep-trivia                  # 조작 명령·주입 본문·에코도 남김 (기본 필터 ON). 검토자도 턴을 빼지 못함
 /lineage --keep-tool-only               # 도구 전용 turn 도 남김 (기본 ON=제거). 검토자도 그 턴을 빼지 못함
 /lineage --redact-extra "acme-corp,db-pass"
-/lineage --redact-mode mask             # abcd**** 부분 마스킹
+/lineage --redact-mode mask             # abcd**** 부분 마스킹(검토자 패턴이 찾은 값은 전부 가림)
 /lineage --rebuild-summaries            # 캐시 무시하고 재요약 (기본 흐름은 검토 결정 캐시도 무시해 모든 턴을 다시 검토)
 /lineage --purge-cache                  # 캐시 전부 삭제 후 종료
 /lineage --skip-reviewer                # 품질 게이트 끔 (경고)
@@ -73,6 +73,7 @@ echo "..." | /lineage --from-transcript -   # stdin paste
 ## 실행 절차
 
 `--rulebase`, `--purge-cache`, `--help` 가 있으면 아래 1~5 대신 `lineage.py` 를 사용자 인자 그대로 한 번 실행하고 끝낸다(모델 호출 없음).
+`--rulebase` 실행이 `still holds secret-like text` WARN 을 내면 5단계처럼 사용자에게 알린다. 다시 만들 때는 그 값을 `LINEAGE_REDACT_EXTRA` 에 넣고 `--rebuild-summaries` 를 준다(규칙 요약 캐시는 키워드를 모른다).
 그 밖에는 이 순서를 따른다. `<스킬 폴더>` 는 이 SKILL.md 가 있는 폴더의 절대경로다.
 Python 은 3.7 이상을 쓴다(EL8 기본 `python3` 는 3.6 이라 `python3.11` 등).
 
@@ -123,6 +124,7 @@ Python 은 3.7 이상을 쓴다(EL8 기본 `python3` 는 3.6 이라 `python3.11`
 5. **마무리** — 출력 HTML 경로를 알린다.
    - 렌더가 성공하면 스크립트가 묶음, 파트 파일, 결정 파일, 게이트 샘플을 지운다. redact 된 세션 본문이 들어 있기 때문이다. 실패(exit 2)면 남겨 둔다.
    - 렌더가 `reviewers dropped N typed user turn(s)` WARN 을 내면, 검토자가 뺀 사용자 입력 턴의 수와 id 를 사용자에게 알린다. 검토자가 기록 속 주입 문장을 따랐을 수 있다.
+   - 렌더가 `the page still holds secret-like text (<패턴>=N)` WARN 을 내면, 패턴 이름과 수를 사용자에게 알리고 공유하기 전에 페이지를 확인하라고 말한다. 검토자 패턴이 렌더된 페이지 글에서 다시 찾은 값이다(예: 마크다운으로 꾸민 `**Password**: 값`). 그 값을 `LINEAGE_REDACT_EXTRA` 에 넣어 다시 만들 수 있다(값을 명령줄에 그대로 치면 셸 기록에 남는다). 다시 만들어도 앞서 만든 페이지(`--rulebase` 는 그 옆의 게이트 샘플도)는 그 값을 가진 채 남으므로 지우라고 알린다.
    - 품질 게이트는 1단계나 4단계에 `--reviewer-output <판정 파일>` 을 줄 때만 돈다. 검토자가 이미 모든 턴을 봤으므로 기본 흐름은 샘플을 쓰지 않는다.
    - 판정 파일에는 아직 없는 경로를 준다. 그 자리에 판정 목록이 아닌 것(사용자 파일, 폴더, 판정 모양이 아닌 JSON)이 있으면 스크립트는 샘플을 쓰기 전에 exit 2 로 멈추고 그 파일을 건드리지 않는다. 1단계에 준 경로도 검토자를 띄우기 전에 exit 2 로 멈춘다.
    - 4단계에서 판정 경로를 주었으면 다시 실행할 때도 같은 `--reviewer-output` 을 준다(묶음에는 1단계 경로만 남는다). 게이트 샘플이 남아 있는데 판정 경로도 `--skip-reviewer` 도 없으면 exit 2(`left by a gated run`)다. 판정을 읽지 않고 지나가지 않게 하기 위해서다.
@@ -219,7 +221,7 @@ Schema-tolerant 파서: 미지 record type → stderr WARN + 다음 line. `v1`/`
 
 1차 `detect-secrets>=1.5`(pip 설치 시), 미설치 → 내장 fallback + WARN.
 내장: AWS IAM(AKIA/ASIA)·GitHub PAT·Slack·JWT·private key·한/영 평문 password·Shannon entropy≥4.5.
-확장 `--redact-extra "k1,k2"`. 부분 마스킹 `--redact-mode mask`.
+확장 `--redact-extra "k1,k2"`. 부분 마스킹 `--redact-mode mask`(페이지 패턴만. 검토자 패턴이 찾은 값은 늘 전부 가린다).
 
 ### 5. Render
 
@@ -259,14 +261,15 @@ WARN 발견 시 stderr 보고, 출력은 그대로 작성(인간 검토 가능).
 
 기본 흐름에서는 `--reviewer-output` 을 줄 때만 `--apply-review` 가 샘플을 쓴다(묶음 옆 `work/.lineage-review.reviewer-input.json`). 샘플마다 `id`(묶음의 턴 id)와 `key`(턴 id, 앞뒤 본문, 요약에서 만든 12자 지문)가 더 붙는다. `original_detail` 은 검토자가 본 앞뒤 본문(파트 파일의 `preview`), `generated_summary` 는 검토자 요약, 없으면 가린 본문에서 만든 규칙 요약(파트 파일의 `rule.summary`)이다. 둘 다 파트 파일과 같은 기준으로 가린다.
 기본 흐름의 판정은 샘플마다 하나씩이고, 판정마다 그 샘플의 `id` 와 `key` 를 그대로 담는다. 빠진 샘플, 샘플에 없는 `idx`, 같은 `idx` 의 반복, 다른 `id` 나 `key`(다른 턴이나 결정을 고치기 전 샘플에 대한 답)가 있으면 exit 2 다. 그때 판정에 든 `recoverable: false` 항목의 이유를 함께 찍는다. `--rulebase` 의 critic 계약은 2.x 그대로다.
-같은 턴이면 다시 실행해도 같은 턴을 샘플로 뽑는다. 결정을 고치면 그 샘플의 내용과 `key` 가 바뀐다. 읽은 판정 파일은 `<이름>.used` 로 옮겨, 다음 실행이 옛 판정을 다시 읽지 않는다. 샘플이 바뀌면 그 전에 있던 판정 파일(앞선 `--rulebase` 게이트가 남긴 것 등)을 읽지 않고 옮긴다. 판정 경로에 판정 목록(`idx` 가 든 객체가 하나라도 있는 JSON 배열)이 아닌 파일이나 폴더가 있으면 샘플을 쓰기 전에 exit 2 로 멈추고 옮기지 않는다. `<이름>.used` 에 판정이 아닌 파일이 있으면 덮지 않고, 비어 있거나 앞선 판정이 든 `<이름>.used.1` 같은 이름으로 옮긴다. 샘플을 쓰지 못하면 판정을 기다리지 않고 exit 2 다. PASS 면 샘플을 지운다. `--rulebase` 는 2.x 그대로다(무작위 샘플, 페이지 redaction, 판정 파일을 옮기지 않음).
+같은 턴이면 다시 실행해도 같은 턴을 샘플로 뽑는다. 결정을 고치면 그 샘플의 내용과 `key` 가 바뀐다. 읽은 판정 파일은 `<이름>.used` 로 옮겨, 다음 실행이 옛 판정을 다시 읽지 않는다. 샘플이 바뀌면 그 전에 있던 판정 파일(앞선 `--rulebase` 게이트가 남긴 것 등)을 읽지 않고 옮긴다. 판정 경로에 판정 목록(`idx` 가 든 객체가 하나라도 있는 JSON 배열)이 아닌 파일이나 폴더가 있으면 샘플을 쓰기 전에 exit 2 로 멈추고 옮기지 않는다. `<이름>.used` 에 판정이 아닌 파일이 있으면 덮지 않고, 비어 있거나 앞선 판정이 든 `<이름>.used.1` 같은 이름으로 옮긴다. 샘플을 쓰지 못하면 판정을 기다리지 않고 exit 2 다. PASS 면 샘플을 지운다. `--rulebase` 는 2.x 처럼 무작위 샘플을 쓰고 판정 파일을 옮기지 않는다. 샘플은 critic 모델이 읽으므로 검토자 패턴까지 값 전체를 가린 뒤 500자로 자른다.
 
 ## Cache & Secret Hygiene
 
 캐시에 저장되는 텍스트는 redact() 적용 후의 redacted summary 만이다(평문 secret 미저장).
 검토자 결정 캐시(`<uuid>-<digest>-llm.json`)도 redact 하고 자른 요약만 담는다. digest 는 redact 된 본문, 그 턴의 규칙 결정, keep 플래그의 해시다. 본문이 바뀌면 다시 검토한다. `keep: null` 은 그 실행의 규칙을 따른다는 뜻이라, 규칙 결정이나 keep 플래그가 다른 실행(`--keep-trivia` 실행과 기본 실행, `--all-sessions` 실행과 단일 세션 실행)에서도 다시 검토한다.
 검토 묶음과 파트 파일은 redact 된 본문만 담고 0600 으로 쓴다(임시 파일은 mkstemp). 렌더가 성공하면 스크립트가 지운다(실행 절차 5).
-검토자가 읽는 파트 파일은 `--redact-mode mask` 여도 가린 자리에 값의 일부를 남기지 않는다. 페이지에는 없는 패턴(Anthropic, OpenAI, Google 키, 따옴표 없는 password·비밀번호, 16진 키, URL 안 자격 증명, Bearer 토큰, Basic 인증 헤더(따옴표 친 키, 첨자 대입, `=>`, 헤더 설정 호출과 HAR 의 name/value, nginx 처럼 공백 뒤 따옴표 포함), curl `-u` 의 사용자와 비밀번호(붙여 쓴 `-uUSER:PW`, `-su`, `-4u` 같은 묶음, 따로 감싼 `"USER":"PW"`, 따옴표 친 명령 속의 이스케이프한 따옴표(`\"USER:PW\"`, 여러 겹 JSON), bash 의 `'\''` 와 `shlex.quote` 의 `'"'"'`, cmd 의 `^"`, PowerShell 의 `` `" ``, bash 의 `$'…'`, `${API_USER}` 같은 변수 사용자와 변수에 이은 사용자(`"$USER"@corp.com`, `"${ENV}"-deployer`), 인라인 코드나 괄호 안, 인자 목록, 빈 사용자나 빈 비밀번호 포함))도 파트 파일에서는 가린다. URL 의 비밀번호는 호스트 앞 마지막 `@` 까지 가린다. 이 패턴은 엔트로피 규칙보다 먼저 적용해 키를 통째로 가린다. 페이지는 이 패턴을 쓰지 않으므로 `--rulebase` 출력은 2.x 그대로다.
+stdin(`--from-transcript -`)으로 넣은 기록의 턴 id 는 본문을 캐시 폴더의 무작위 키(`stdin-id.key`, 0600)로 HMAC 한 값이다. 같은 머신에서는 id 가 그대로라 캐시를 다시 쓰고, 파트 파일을 읽는 모델은 id 로 본문을 맞혀 볼 수 없다.
+검토자가 읽는 파트 파일은 `--redact-mode mask` 여도 가린 자리에 값의 일부를 남기지 않는다. 페이지에는 없는 패턴(Anthropic, OpenAI, Google 키, 따옴표 없는 password·비밀번호, 16진 키, URL 안 자격 증명, Bearer 토큰, Basic 인증 헤더(따옴표 친 키, 첨자 대입, `=>`, 헤더 설정 호출과 HAR 의 name/value, nginx 처럼 공백 뒤 따옴표 포함), curl `-u` 의 사용자와 비밀번호(붙여 쓴 `-uUSER:PW`, `-su`, `-4u` 같은 묶음, 따로 감싼 `"USER":"PW"`, 따옴표 친 명령 속의 이스케이프한 따옴표(`\"USER:PW\"`, 여러 겹 JSON), bash 의 `'\''` 와 `shlex.quote` 의 `'"'"'`, cmd 의 `^"`, PowerShell 의 `` `" ``, bash 의 `$'…'`, `${API_USER}` 같은 변수 사용자와 변수에 이은 사용자(`"$USER"@corp.com`, `"${ENV}"-deployer`), 인라인 코드나 괄호 안, 인자 목록, 빈 사용자나 빈 비밀번호 포함))도 파트 파일에서는 가린다. URL 의 비밀번호는 호스트 앞 마지막 `@` 까지 가린다. 이 패턴은 엔트로피 규칙보다 먼저 적용해 키를 통째로 가린다. 3.0.2 부터 검토자 패턴은 모든 페이지(기본 흐름과 `--rulebase`)에도 건다. 페이지에서도 검토자 패턴이 찾은 값은 `--redact-mode mask` 여도 전부 가리고, 페이지 패턴만 mask 를 따른다. 본문, 요약, 접힌 요약, 에이전트 이름, 세션 이름, 기본 흐름 묶음에 걸고, 도구 이름은 `--redact-extra` 키워드를 가린다. 렌더 뒤 페이지 글에 검토자 패턴을 다시 돌려 남은 것이 있으면 WARN 을 낸다. `--rulebase` 출력은 비밀이 없는 턴에서 2.x 와 같다. 비밀을 가린 턴은 2.x 와 다를 수 있다.
 파트 파일의 규칙 요약은 가린 본문에서 만든다. 요약을 자른 자리에 비밀이 걸쳐도 조각이 남지 않는다.
 `--redact-extra` 키워드 목록은 묶음과 파트 파일에 쓰지 않고, 가린 수만 `custom` 으로 센다. 파트 파일의 본문, 요약, 에이전트 이름, 도구 이름에서는 키워드를 가린다. 묶음은 에이전트 이름, 도구 이름, 세션 제목, 출력 경로를 페이지처럼 그대로 둔다. 기록 파일 이름(세션 id)도 캐시 위치를 정하는 값이라 그대로 둔다(0600, 렌더 성공 뒤 삭제).
 결정 파일은 세션이 파일 도구로 써서 umask 권한으로 생긴다. `--apply-review` 가 읽을 때 0600 으로 바꾼다.
@@ -321,10 +324,10 @@ pip install 'detect-secrets>=1.5'   # (선택) 강한 redaction
 - 기본 흐름은 파트(40턴 이하, 고르게 나눔)마다 검토 에이전트 1개가 돈다. 이 저장소 실측은 40턴 파트 하나에 약 11만 토큰과 7분이었다. 긴 세션은 `--last N` 으로 범위를 줄이거나 `--rulebase` 를 쓴다.
 - Claude Code 검토자(`Plan`)는 Write·Edit 가 도구로 막혀 있지만 Bash 는 있다. 셸로 쓰지 않는 것은 지시로 선다. banker 는 에이전트 정의를 배포하지 않아(모든 표면이 두 런타임 대상) 도구를 더 막을 수 없다.
 - Codex 의 `workspace-write` 샌드박스에서는 `~/.cache` 에 쓸 수 없어 이번 실행의 검토 결정을 캐시에 쓰지 못한다(WARN 한 번). 앞선 실행이 남긴 결정은 읽으므로, 그 결정이 없는 턴만 다시 검토한다.
-- 페이지의 규칙 요약은 문장을 자른 뒤 가린다. 자른 자리에 걸친 비밀은 조각이 페이지에 남을 수 있다(2.x 동작 그대로). 검토자와 게이트의 critic 이 읽는 규칙 요약은 가린 본문에서 만든다.
-- 규칙 요약 캐시는 본문만으로 키를 잡는다. `--redact-mode` 나 `--redact-extra` 를 바꿔 다시 돌린 `--rulebase` 는 앞선 실행의 요약을 쓸 수 있다(2.x 동작 그대로). 기본 흐름의 묶음은 요약을 매번 새로 만든다.
+- 규칙 요약은 가린 본문에서 자른다(요약기 버전 3). 0.15.1 까지 만든 요약 캐시는 쓰지 않는다. 그 캐시에는 평문 조각이 남아 있을 수 있어 `--purge-cache` 로 지운다.
+- 규칙 요약 캐시는 본문만으로 키를 잡는다. `--redact-mode` 나 `--redact-extra` 를 바꿔 다시 돌린 `--rulebase` 는 앞선 실행의 요약을 쓸 수 있다(2.x 동작 그대로). 기본 흐름의 묶음은 요약을 매번 새로 만든다. 묶음 형식은 `lineage-review/2` 라 0.15.1 이 만든 묶음은 `--emit-review` 부터 다시 한다.
 - 검토자는 긴 턴의 앞뒤만 본다(`clipped: true`). 가운데에만 있는 결론은 놓칠 수 있다.
-- 검토자 패턴은 흔한 모양만 가린다. `/` 가 든 URL 비밀번호와 키 이름이 100자를 넘는 16진 키는 가리지 못한다(값이 길고 무작위면 엔트로피 규칙이 가릴 수 있다). curl `-u` 패턴은 값 전체가 `docker -u 1000:1000` 같은 uid:gid, `rsync -u host:/path`, `date -u +%H:%M` 같은 날짜 형식(`+%` 뒤에 글자가 오면 나머지는 보지 않는다), 양쪽 모두 변수인 꼴(`$UID:$GID`, `${UID}:${GID}`, `%USER%:%PASS%`, `$(id -u):$(id -g)`), 기본값이 콜론 없는 경로(`/`, `~`, `.` 로 시작)인 변수(`mktemp -u "${TMPDIR:-/tmp}/x"`)일 때만 둔다. 이스케이프한 따옴표 안에서도 같다. 다른 명령의 `-u 이름:값`(`-u root:root`, `ps -u postgres:postgres`, `rsync -avu host:dir/`, `ls -lu a:bcd`), 기본값이 경로가 아닌 변수(`${UID:-1000}:${GID:-1000}`, `${API_KEY:-…}`)는 가린다. 숫자만으로 된 이름과 비밀번호, `/` 로 시작하는 비밀번호, `$` 로 시작해 변수처럼 보이는 비밀번호(`$USER:$ecret`), `-U` 와 `--proxy-user`, 붙여 쓴 묶음(`-suUSER:PW`), `-u=USER:PW`, 공백이 든 비밀번호의 둘째 낱말부터, 인자 목록에서 다른 종류의 따옴표가 든 비밀번호(`'-u', "USER:P'W"`), 사용자 안에서 따옴표 뒤에 `-eu`, `--user` 같은 플래그 꼴과 따옴표가 오는 꼴(`"$USER"-eu":PW"`), requests 의 `auth=(...)`, value 가 name 보다 앞에 온 HAR 은 가리지 못한다. 백틱 명령 치환(`` `id -u`:`id -g` ``)과 `\$(id -u):\$(id -g)` 는 가운데 일부가 가려진다(3.0.0 과 같다). 공백 없는 인자 목록(`["docker","run","-u","1000:1000","img"]`)과 인자 목록 안의 `host:/path`(`"-avu", "host:/srv"`)는 남길 꼴이어도 플래그 뒤를 가린다(비밀이 새지는 않는다). Basic 인증 패턴은 `HTTP_AUTHORIZATION` 처럼 앞에 `_` 가 붙은 이름, 구분자 없는 `Authorization Basic …`, 백틱이나 대괄호(`["Basic …"]`) 안의 값을 가리지 못한다.
+- 검토자 패턴은 흔한 모양만 가린다. `/` 가 든 URL 비밀번호와 키 이름이 100자를 넘는 16진 키는 가리지 못한다(값이 길고 무작위면 엔트로피 규칙이 가릴 수 있다). curl `-u` 패턴은 값 전체가 `docker -u 1000:1000` 같은 uid:gid, `rsync -u host:/path`, `date -u +%H:%M` 같은 날짜 형식(`+%` 뒤에 글자가 오면 나머지는 보지 않는다), 양쪽 모두 변수인 꼴(`$UID:$GID`, `${UID}:${GID}`, `%USER%:%PASS%`, `$(id -u):$(id -g)`), 기본값이 콜론 없는 경로(`/`, `~`, `.` 로 시작)인 변수(`mktemp -u "${TMPDIR:-/tmp}/x"`), 앞선 가림이 남긴 표식(`-u [REDACTED:JWT]`)일 때만 둔다. 이스케이프한 따옴표 안에서도 같다. 다른 명령의 `-u 이름:값`(`-u root:root`, `ps -u postgres:postgres`, `rsync -avu host:dir/`, `ls -lu a:bcd`), 기본값이 경로가 아닌 변수(`${UID:-1000}:${GID:-1000}`, `${API_KEY:-…}`)는 가린다. 숫자만으로 된 이름과 비밀번호, `/` 로 시작하는 비밀번호, `$` 로 시작해 변수처럼 보이는 비밀번호(`$USER:$ecret`), `-U` 와 `--proxy-user`, 붙여 쓴 묶음(`-suUSER:PW`), `-u=USER:PW`, 공백이 든 비밀번호의 둘째 낱말부터, 인자 목록에서 다른 종류의 따옴표가 든 비밀번호(`'-u', "USER:P'W"`), 사용자 안에서 따옴표 뒤에 `-eu`, `--user` 같은 플래그 꼴과 따옴표가 오는 꼴(`"$USER"-eu":PW"`), requests 의 `auth=(...)`, value 가 name 보다 앞에 온 HAR 은 가리지 못한다. 백틱 명령 치환(`` `id -u`:`id -g` ``)과 `\$(id -u):\$(id -g)` 는 가운데 일부가 가려진다(3.0.0 과 같다). 값이 `/`, `~`, `$` 로 시작하는 password 값(`$PWD:/workspace`, `OLDPWD=/home/...`, `password=$DB_PASSWORD`), 이미 가린 표식, 값 전체가 마스크 꼴(`abcd****wxyz`, `****`)인 값은 두고, `PGPASSWORD=`, `MYSQL_PWD=` 의 값은 가린다. `password=os.environ[...]`, `암호: AES-256-GCM` 처럼 코드나 이름인 값과 `sk-` 로 시작하는 긴 세션 이름은 지나치게 가린다. Basic 인증 패턴은 `HTTP_AUTHORIZATION` 처럼 앞에 `_` 가 붙은 이름, 구분자 없는 `Authorization Basic …`, 백틱이나 대괄호(`["Basic …"]`) 안의 값을 가리지 못한다.
 - 페이지 패턴 가운데 JWT 와 개인 키 패턴은 같은 머리(`eyJ`, `-----BEGIN`)가 긴 줄에 되풀이되면 시간이 줄 길이의 제곱으로 는다(2.x 동작 그대로). 기본 흐름은 턴마다 여러 번 가리므로 그만큼 더 걸린다.
 - 마크다운의 **중첩 리스트는 평탄화**되고 각주는 미지원.
 - 사용자가 질문에 래퍼 블록(`<task-notification>…`)을 **인용**하면 문장은 남고 그 블록만 사라진다.
@@ -340,6 +343,7 @@ pip install 'detect-secrets>=1.5'   # (선택) 강한 redaction
 └── test_lineage.py   (회귀 테스트, repo 전용 · npm 미포함)
 
 ~/.cache/lineage/
+├── stdin-id.key   (stdin 턴 id 의 HMAC 키, 0600. --purge-cache 로 지우면 stdin id 가 바뀐다)
 └── <schema_version>/<session_id>/<turn_uuid>-<digest>.txt       (규칙 요약, 0700/0600)
                                   <turn_uuid>-<digest>-llm.json  (검토자 결정)
 

package/skills/lineage/lineage.py

@@ -11,6 +11,7 @@ Auto-discovery assumes Claude Code's ~/.claude/projects/<encoded-cwd>/ layout.
 """
 import argparse
 import hashlib
+import hmac
 import html
 import json
 import math
@@ -27,13 +28,13 @@ if sys.version_info < (3, 7):
     sys.exit(2)
 
 SCHEMA_VERSION = 2          # cache dir schema (v2: redacted summaries only)
-SUMMARIZER_VERSION = 2      # bump when summarize_turn logic changes (B-3 cache key)
+SUMMARIZER_VERSION = 3      # bump when summarize_turn logic changes (B-3 cache key); 3: cut from redacted text
 USER_FOLD = 400             # collapse user messages longer than this (E-1)
 ECHO_ASK = 40               # echo-exchange: user question length ceiling (A-4)
 ECHO_REPLY = 5              # echo-exchange: assistant reply length ceiling (A-4)
 _BLOCKQUOTE_MAX_DEPTH = 32  # blockquote recursion cap (C-2)
 CACHE_BASE = pathlib.Path.home() / ".cache" / "lineage"
-REVIEW_SCHEMA = "lineage-review/1"       # --emit-review pack, read back by --apply-review
+REVIEW_SCHEMA = "lineage-review/2"       # --emit-review pack, read back by --apply-review; 2: llm_key, pages redacted (3.0.2)
 REVIEW_PART_SCHEMA = "lineage-review-part/1"
 REVIEW_PART = 40            # turns per part file: one reviewer's share
 PREVIEW_HEAD = 1500         # a long turn's preview: head + tail, where conclusions sit
@@ -221,22 +222,27 @@ def redact(text: str, extra: "str | None" = None, mode: str = "full"):
 
     if extra:
         for kw in [k.strip() for k in extra.split(",") if k.strip()]:
-            pat = re.compile(re.escape(kw), re.IGNORECASE)
-            n = len(pat.findall(out))
-            if n:
-                counts[f"custom:{kw}"] = n
-                out = pat.sub("[REDACTED]", out)
+            # a marker an earlier pass left stays whole: a keyword inside its name is no secret
+            pat = re.compile(r"\[REDACTED(?::[^\]\s]*)?\]|" + re.escape(kw), re.IGNORECASE)
+            hits = []
+            out = pat.sub(lambda m: m.group(0) if m.group(0).upper().startswith("[REDACTED")
+                          else hits.append(1) or "[REDACTED]", out)
+            if hits:
+                counts[f"custom:{kw}"] = len(hits)
     return out, counts
 
 
 # A character of curl's user before the colon: no space, : or =, and a quote, backtick or ( only
-# where no flag follows (-u, -Xu or --user, as either branch below starts). A match starts only
+# where no flag follows (-u, -Xu or --user, as either branch below starts) and no comma and quote
+# follow (the end of an item in an argument list written without spaces). A match starts only
 # there, so no user runs past the place where the next match may start: a long run stays linear,
 # and a user joined to a variable by a - ("$USER"-bot) is read whole.
-_CU_USER = r"(?:[^\s:=\"'`(]|[\"'`(](?!-(?:u|[A-Za-z0-9]{1,6}u[\s\"']|-user[\s=\"'])))"
+_CU_USER = (r"(?:[^\s:=\"'`(]|[\"'`(](?!-(?:u|[A-Za-z0-9]{1,6}u[\s\"']|-user[\s=\"'])"
+            r"|,\\{0,7}[\"']))")
 # The quotes that may open the value, bare or escaped (\" and \\\" in a quoted command, '\'' and
-# '"'"' from bash and shlex.quote, ^" in cmd, `" in PowerShell, $' in bash): up to six in a row.
-_CU_LEAD = r"(?:[\\^`$]{0,7}[\"']){0,6}"
+# '"'"' from bash and shlex.quote, ^" in cmd, `" in PowerShell, $' in bash): up to six in a row,
+# none that closes an item of an argument list.
+_CU_LEAD = r"(?:[\\^`$]{0,7}[\"'](?!,\\{0,7}[\"'])){0,6}"
 # Values read as a whole token, past the quotes that open them, that hold no user and password: a
 # uid:gid (docker), a date format (date -u +%H:%M), two references ($UID:$GID, ${UID}:${GID},
 # %USER%:%PASS%, $(id -u):$(id -g), whose inner `-u)` is a match of its own) and a path default
@@ -249,16 +255,34 @@ _CU_SKIP = (r"(?!" + _CU_LEAD + r"(?:\+[\"']?%[-_0^#]?[A-Za-z%]|(?:\d+:\d+|(?:"
 
 # Extra patterns for text a reviewer model reads (part files) and nothing else: the page
 # and --rulebase keep the patterns above, so their output stays as it was.
+# A value a redaction already replaced: a marker ([REDACTED...]) or a value that is only a mask
+# (abcd****wxyz: up to 4 characters, a whole run of *, up to 4 characters, then the value ends; a
+# closing `, |, * or ) and then . , ; : ! ? may stand between, as in **password: ****h12** or
+# `DB_PASSWORD=****`.). The
+# reviewer patterns leave it, so a second pass over redacted text changes nothing. The check reads
+# those few characters, not the rest of the token, so a long run of keywords stays linear.
+_NOT_REDACTED = r"(?!\[REDACTED|[^\s'\"*]{0,4}\*{4,}(?!\*)[^\s'\"*]{0,4}(?=[`|*)]*[.,;:!?]*(?:[\s'\"]|$)))"
+# After a colon: not the colon of a marker an earlier pass left ([REDACTED:GitHubPAT]), which
+# splits no user from a password. A whole marker is one piece of a user: a key an earlier pattern
+# of this pass hid ([REDACTED:OpenAIKey]:pw) still has its password hidden.
+_NOT_MARKED = r"(?<!\[REDACTED:)"
+_MARKER_UNIT = r"\[REDACTED:\w+\]"
+
 REVIEW_SECRET_PATTERNS = [
     ("AnthropicKey", re.compile(r"(?<![A-Za-z0-9])sk-ant-[A-Za-z0-9_-]{20,}")),
     ("OpenAIKey", re.compile(r"(?<![A-Za-z0-9-])sk-(?:proj-|svcacct-|admin-)?[A-Za-z0-9_-]{20,}")),
     ("GoogleKey", re.compile(r"(?<![A-Za-z0-9])AIza[0-9A-Za-z_-]{35}")),
     # bounded repeats: a long run of `key` or `a.` would otherwise take quadratic time
     ("HexKey", re.compile(r"(?i)(?:key|token|secret)[\w-]{0,100}\s*[:=]\s*['\"]?[0-9a-f]{32,}")),
+    # a value, not a path, a variable or a redaction ($PWD is a variable, PGPASSWORD a name);
+    # markdown, a table cell or a bracket that closes after the value stays outside the match
     ("PasswordBare", re.compile(
-        r"(?i)(?:password|passwd|passcode|pwd|암호|비번|비밀\s?번호|패스워드)\s*[:=]\s*[^\s'\"]{6,}")),
-    # the password runs to the last @ before the host: it may hold an @ of its own
-    ("UrlCredential", re.compile(r"(?i)[a-z][a-z0-9+.-]{0,30}://[^\s:@/]*:[^\s/]{3,}@")),
+        r"(?i)(?<!\$)(?:password|passwd|passcode|pwd|암호|비번|비밀\s?번호|패스워드)\s*[:=]\s*"
+        r"(?![/~$])" + _NOT_REDACTED + r"(?=[^\s'\"]{6})[^\s'\"]*[^\s'\"`|*)]")),
+    # the password runs to the last @ before the host: it may hold an @ of its own. A marker is
+    # no user or password, so a second pass leaves a token-only URL (https://[REDACTED:...]@host).
+    ("UrlCredential", re.compile(r"(?i)[a-z][a-z0-9+.-]{0,30}://(?:" + _MARKER_UNIT + r"|[^\s:@/])*:" + _NOT_MARKED
+                                 + r"(?!\[REDACTED)[^\s/]{3,}@")),
     ("Bearer", re.compile(r"(?i)\bbearer\s+[A-Za-z0-9._~+/=-]{16,}")),
     # Authorization then `:`, `=`, `=>` or headers["Authorization"] =, a call's ("Authorization",
     # "...") and a HAR name/value pair, or a space before a quote (nginx, Apache)
@@ -271,28 +295,53 @@ REVIEW_SECRET_PATTERNS = [
     # curl's -u and --user flags, alone or last in a bundle (-su, -4u), with a user and password
     # after a space, an = or nothing, quoted together or apart ("user":"pw"), with quotes bare,
     # escaped or nested (_CU_LEAD) or none, in inline code or parentheses, or as two items of an
-    # argument list. An empty user with a token, and a
+    # argument list (quotes bare or escaped, with or without spaces; a host:/path is left). An
+    # empty user with a token, and a
     # long key as the user with no password, count too. The separators share no character with
     # the user name, so a long run of them stays linear. The values _CU_SKIP names and a
-    # host:/path (rsync) are left.
+    # host:/path (rsync) are left, and so is a marker an earlier pass left (-u [REDACTED:JWT]).
     ("CurlUser", re.compile(
         r"(?<![^\s\"'`(])(?:-u\s*|-[A-Za-z0-9]{1,6}u\s+|--user(?:\s+|=))" + _CU_SKIP + _CU_LEAD
-        + r"(?:" + _CU_USER + r"*:(?!/)\S{3,}|" + _CU_USER + r"{15,}:(?=[\s\"'`).,;\\]|$))"
-        r"|([\"'])(?:-[A-Za-z0-9]{0,6}u|--user)\1\s*,\s*([\"'])" + _CU_SKIP
-        + r"(?:" + _CU_USER + r"*:[^\s\"']{3,}|" + _CU_USER + r"{15,}:)\2")),
+        + r"(?:(?:" + _MARKER_UNIT + r"|" + _CU_USER + r")*:" + _NOT_MARKED + r"(?!/|\[REDACTED)\S{3,}|" + _CU_USER
+        + r"{15,}:" + _NOT_MARKED
+        + r"(?=[\s\"'`).,;\\]|$))"
+        r"|(\\{0,7}[\"'])(?:-[A-Za-z0-9]{0,6}u|--user)\1\s*,\s*(\\{0,7}[\"'])" + _CU_SKIP
+        + r"(?:(?:" + _MARKER_UNIT + r"|" + _CU_USER + r")*:" + _NOT_MARKED + r"(?!/|\[REDACTED)[^\s\"']{3,}|"
+        + _CU_USER + r"{15,}:"
+        + _NOT_MARKED + r")\2")),
 ]
 
 
+def _reviewer_patterns(text):
+    """`text` with what the reviewer patterns find replaced whole by [REDACTED:<name>], and the
+    count by name."""
+    counts = {}
+    for name, pat in REVIEW_SECRET_PATTERNS:
+        text, k = pat.subn(f"[REDACTED:{name}]", text)
+        if k:
+            counts[name] = k
+    return text, counts
+
+
 def review_redact(text, extra=None):
     """Text as a reviewer model reads it: the reviewer-only patterns first, while the keys
     are whole (the entropy rule would otherwise cut a key and leave the rest), then fully
     redacted (never masked, whatever --redact-mode says). Returns (text, count)."""
-    n = 0
-    for name, pat in REVIEW_SECRET_PATTERNS:
-        text, k = pat.subn(f"[REDACTED:{name}]", text)
-        n += k
-    red, found = redact(text, extra=extra, mode="full")
-    return red, n + sum(found.values())
+    pre, counts = _reviewer_patterns(text)
+    red, found = redact(pre, extra=extra, mode="full")
+    return red, sum(counts.values()) + sum(found.values())
+
+
+def page_redact(text, extra=None, mode="full"):
+    """Text as every page shows it (3.0.2): the reviewer patterns first, while keys are whole,
+    each hit replaced whole whatever --redact-mode says (a mask keeps 4+4 characters, most of
+    a short password); then the page's redaction with this run's mode and keywords. Returns
+    (text, count_by_kind); a second pass over its output finds nothing."""
+    pre, counts = _reviewer_patterns(text)
+    red, found = redact(pre, extra=extra, mode=mode)
+    for k, v in found.items():
+        counts[k] = counts.get(k, 0) + v
+    return red, counts
 
 
 # ---------------------------------------------------------------- Discovery
@@ -568,9 +617,15 @@ SHORT_DETAIL = 160
 SINGLE_SPLIT_MIN = SHORT_DETAIL
 
 
+_OPEN_MARKER_RE = re.compile(r"\[REDACTED[^\]]*$")
+
+
 def _cut(s, n):
     s = s.strip()
-    return s if len(s) <= n else s[:max(1, n - 1)].rstrip() + "…"
+    if len(s) <= n:
+        return s
+    head = _OPEN_MARKER_RE.sub("", s[:max(1, n - 1)])   # a marker cut in two goes whole
+    return head.rstrip() + "…"
 
 
 def naive_summary(text: str) -> str:
@@ -631,6 +686,35 @@ def summarize_turn(turn):
 
 
 # ---------------------------------------------------------------- Summary cache
+def _stdin_id_key():
+    """The key that turns a pasted turn's text into its id: random, kept 0600 in the cache folder,
+    so ids (and the caches keyed on them) stay the same on this machine. Part files carry the id
+    to a model that never sees the key, so an id gives no way to test a guessed password. With no
+    cache folder to keep it in, the key lasts one run."""
+    path = CACHE_BASE / "stdin-id.key"
+    try:
+        key = path.read_bytes()
+        if len(key) == 32:
+            return key
+    except OSError:
+        pass
+    key = os.urandom(32)
+    tmp = path.with_name("%s.%d" % (path.name, os.getpid()))
+    try:
+        CACHE_BASE.mkdir(parents=True, exist_ok=True)
+        os.chmod(str(CACHE_BASE), 0o700)
+        fd = os.open(str(tmp), os.O_WRONLY | os.O_CREAT | os.O_TRUNC | getattr(os, "O_BINARY", 0), 0o600)
+        with os.fdopen(fd, "wb") as f:
+            f.write(key)
+        os.replace(str(tmp), str(path))           # whole or not at all
+    except OSError:
+        try:
+            os.unlink(str(tmp))
+        except OSError:
+            pass
+    return key
+
+
 def cache_dir(session_id: str):
     d = CACHE_BASE / str(SCHEMA_VERSION) / (session_id or "default")
     d.mkdir(parents=True, exist_ok=True)
@@ -642,11 +726,19 @@ def cache_dir(session_id: str):
     return d
 
 
+def _page_clean_turn(t, extra, mode):
+    """`t` with its text and parts as a page shows them, so a summary cut from it cannot cut a
+    secret in two and keep the half no pattern recognises."""
+    def clean(s):
+        return page_redact(s, extra, mode)[0]
+    return dict(t, text=clean(t["text"]), parts=[clean(p) for p in t.get("parts") or []])
+
+
 def read_or_summarize(turn: dict, session_id: str, rebuild: bool = False,
                       redact_extra=None, redact_mode: str = "full"):
     """Return (summary, cache_hit). Cache key includes the content hash AND the
     summarizer version (B-3), so changing the summarizer invalidates old entries.
-    Cached text is always redacted (secret hygiene).
+    Cached text is always redacted (secret hygiene). It is cut from the redacted text (3.0.2).
     """
     digest = hashlib.sha256(
         (turn["text"] + "\x00s" + str(SUMMARIZER_VERSION)).encode()
@@ -662,8 +754,7 @@ def read_or_summarize(turn: dict, session_id: str, rebuild: bool = False,
             return p.read_text(encoding="utf-8").strip(), True
         except (OSError, UnicodeDecodeError):
             pass
-    raw_summary = summarize_turn(turn)
-    redacted, _ = redact(raw_summary, extra=redact_extra, mode=redact_mode)
+    redacted = summarize_turn(_page_clean_turn(turn, redact_extra, redact_mode))
     if p is not None:
         try:
             fd = os.open(str(p), os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
@@ -1051,7 +1142,7 @@ def render_rows(turns, session_id, redact_extra, redact_mode, rebuild,
     open_attr = " open" if open_details else ""
 
     def _red(text):
-        r, c = redact(text, extra=redact_extra, mode=redact_mode)
+        r, c = page_redact(text, extra=redact_extra, mode=redact_mode)
         for k, v in c.items():
             redact_counts[k] = redact_counts.get(k, 0) + v
         return r
@@ -1061,7 +1152,7 @@ def render_rows(turns, session_id, redact_extra, redact_mode, rebuild,
         # session-transition divider (--all-sessions)
         if all_sessions and t.get("session") != last_session:
             last_session = t.get("session")
-            name = html.escape(t.get("session_name") or last_session or "session")
+            name = html.escape(_red(t.get("session_name") or last_session or "session"))
             rows.append('<div class="day" data-mark="%s">'
                         '<span class="pill pill-session">%s</span></div>'
                         % (name, name))
@@ -1111,13 +1202,14 @@ def render_rows(turns, session_id, redact_extra, redact_mode, rebuild,
 
         tools_html = ""
         if t.get("tools"):
-            ts_list = ", ".join(f"{k}×{v}" for k, v in sorted(t["tools"].items()))
+            ts_list = ", ".join(f"{_hide_keywords(k, redact_extra)}×{v}"
+                                for k, v in sorted(t["tools"].items()))
             total = sum(t["tools"].values())
             tools_html = ('<div class="tools">🔧 도구 %d건: %s</div>'
                           % (total, html.escape(ts_list)))
 
         if role == "agent":
-            who = html.escape(t.get("agent_from") or "agent")
+            who = html.escape(_red(t.get("agent_from") or "agent"))
             avatar = "🤝"
             from_line = '<div class="from">%s</div>' % who
             row_cls = "row bot agent"
@@ -1137,6 +1229,21 @@ def render_rows(turns, session_id, redact_extra, redact_mode, rebuild,
     return rows, redact_counts, cache_hits, cache_total
 
 
+_TAG_RE = re.compile(r"<[^>]*>")
+
+
+def _residual_secrets(rows_html):
+    """What the reviewer patterns still find in a page's text (tags dropped, entities decoded),
+    by pattern name: a field the page forgot to redact."""
+    text = html.unescape(_TAG_RE.sub(" ", rows_html))
+    left = {}
+    for name, pat in REVIEW_SECRET_PATTERNS:
+        n = len(pat.findall(text))
+        if n:
+            left[name] = n
+    return left
+
+
 # ---------------------------------------------------------------- Self-verify (F-1)
 _VOID = frozenset(
     "area base br col embed hr img input link meta param source track wbr".split())
@@ -1279,18 +1386,23 @@ def _decision_context(why, keeps):
                      str(keeps.get("keep_tool_only") is True)])
 
 
-def _llm_cache_path(turn_id, session, redacted_text, context):
-    digest = hashlib.sha256((redacted_text + "\x00llm" + str(LLM_CACHE_VERSION)
-                             + "\x00" + context).encode()).hexdigest()[:12]
-    return cache_dir(_safe_name(session)) / f"{_safe_name(turn_id)}-{digest}-llm.json"
+def _llm_digest(redacted_text, context):
+    """The decision cache key: the text with the page's patterns only (as 3.0.1 keyed it, so
+    no turn is reviewed again for 3.0.2), the cache version and what the decision rests on."""
+    return hashlib.sha256((redacted_text + "\x00llm" + str(LLM_CACHE_VERSION)
+                           + "\x00" + context).encode()).hexdigest()[:12]
+
+
+def _llm_cache_path(turn_id, session, digest):
+    return cache_dir(_safe_name(session)) / f"{_safe_name(turn_id)}-{_safe_name(digest)}-llm.json"
 
 
-def read_llm_cache(turn_id, session, redacted_text, context):
+def read_llm_cache(turn_id, session, digest):
     """A reviewer's earlier {keep, summary} for this exact (redacted) text under the same
     rule call and keep flags (`context`), or None when no reviewer saw it so. Both values
     null: the reviewer left the turn to the rules."""
     try:
-        path = _llm_cache_path(turn_id, session, redacted_text, context)
+        path = _llm_cache_path(turn_id, session, digest)
     except OSError as e:                          # no cache folder (a read-only HOME, say)
         _warn_once("_no_llm_cache", f"reviewer decision cache unavailable ({e}); "
                    "every turn is reviewed")
@@ -1307,9 +1419,9 @@ def read_llm_cache(turn_id, session, redacted_text, context):
     return {"keep": keep, "summary": summary}
 
 
-def write_llm_cache(turn_id, session, redacted_text, context, keep, summary):
+def write_llm_cache(turn_id, session, digest, keep, summary):
     try:
-        _write_private(_llm_cache_path(turn_id, session, redacted_text, context),
+        _write_private(_llm_cache_path(turn_id, session, digest),
                        json.dumps({"keep": keep, "summary": summary}, ensure_ascii=False))
     except OSError as e:
         _warn_once("_no_llm_cache_write", f"reviewer decisions not cached ({e}); the next "
@@ -1371,7 +1483,7 @@ def _rule_summary(t, red, args):
     The summary cache is keyed on the text alone, so a cached one may predate a
     --redact-extra keyword or carry another --redact-mode."""
     if t["role"] in ("assistant", "agent"):
-        return redact(summarize_turn(t), extra=args.redact_extra, mode=args.redact_mode)[0]
+        return summarize_turn(_page_clean_turn(t, args.redact_extra, args.redact_mode))
     if t["role"] == "user" and len(red) > USER_FOLD:
         return user_fold_summary(red)
     return None
@@ -1400,18 +1512,22 @@ def _review_view(t, red, args):
 
 
 def _pack_turn(n, t, tid, why, session_id, args, counts):
-    """One turn of the pack under its final id `tid` (redacted text, the rules' decision,
-    the reviewer's slot), and the reviewer's view of it."""
-    red, found = redact(t["text"], extra=args.redact_extra, mode=args.redact_mode)
+    """One turn of the pack under its final id `tid` (the text as the page shows it, the rules'
+    decision, the reviewer's slot), and the reviewer's view of it. The cached decision keys on
+    the text with the page's patterns only (`llm_key`), as 3.0.1 did."""
+    red, found = page_redact(t["text"], extra=args.redact_extra, mode=args.redact_mode)
     for k, v in found.items():
         counts[k] = counts.get(k, 0) + v
+    hit = any(name in found for name, _ in REVIEW_SECRET_PATTERNS)
+    key_text = redact(t["text"], extra=args.redact_extra, mode=args.redact_mode)[0] if hit else red
     preview, clipped = _preview(review_redact(t["text"], args.redact_extra)[0])
     session = t.get("session") or session_id
     context = _decision_context(why, _keeps(args))
-    cached = None if args.rebuild_summaries else read_llm_cache(tid, session, red, context)
+    llm_key = _llm_digest(key_text, context)
+    cached = None if args.rebuild_summaries else read_llm_cache(tid, session, llm_key)
     view = _review_view(t, red, args)
     turn = {"id": tid, "n": n, "role": t["role"], "ts": t.get("ts") or "",
-            "tools": dict(t.get("tools") or {}), "text": red,
+            "tools": dict(t.get("tools") or {}), "text": red, "llm_key": llm_key,
             "redactions": _public_counts(found), "preview": preview, "clipped": clipped,
             "rule": {"keep": why is None, "why": why,
                      "summary": _rule_summary(t, red, args),
@@ -1421,7 +1537,7 @@ def _pack_turn(n, t, tid, why, session_id, args, counts):
         turn["meta"] = True
     for k in ("session", "session_name", "agent_from"):
         if t.get(k):
-            turn[k] = t[k]
+            turn[k] = t[k] if k == "session" else page_redact(t[k], args.redact_extra, args.redact_mode)[0]
     return turn, view
 
 
@@ -1487,7 +1603,7 @@ def _sheet(k, of, part_path, group, args):
     turns = []
     for x, view in group:
         y = {key: v for key, v in x.items()
-             if key not in ("text", "session", "session_name", "agent_from", "redactions")}
+             if key not in ("text", "session", "session_name", "agent_from", "redactions", "llm_key")}
         y["rule"] = {k: v for k, v in x["rule"].items() if k != "review_summary"}
         y["rule"]["summary"] = view["summary"]
         y["tools"] = {_hide_keywords(name, args.redact_extra): n for name, n in x["tools"].items()}
@@ -1565,7 +1681,7 @@ def emit_review(turns, drops, window, session_id, output, args):
 def _is_pack_turn(x):
     return (isinstance(x, dict) and isinstance(x.get("id"), str)
             and x.get("role") in ("user", "assistant", "agent", "mark")
-            and isinstance(x.get("text"), str)
+            and isinstance(x.get("text"), str) and isinstance(x.get("llm_key"), str)
             and isinstance(x.get("rule"), dict) and isinstance(x["rule"].get("keep"), bool)
             and _is_summary(x["rule"].get("summary"))
             and isinstance(x.get("llm"), dict) and _is_keep(x["llm"].get("keep"))
@@ -1578,7 +1694,8 @@ def _load_pack(path):
     except (OSError, ValueError, UnicodeDecodeError) as e:
         return _bad(f"cannot read review pack {path}: {e}")
     if not isinstance(pack, dict) or pack.get("schema") != REVIEW_SCHEMA:
-        return _bad(f"{path} is not a {REVIEW_SCHEMA} pack")
+        return _bad(f"{path} is not a {REVIEW_SCHEMA} pack (made by another lineage version? "
+                    "run --emit-review again)")
     if not isinstance(pack.get("turns"), list) or not all(map(_is_pack_turn, pack["turns"])):
         return _bad(f"{path}: malformed turns")
     return pack
@@ -1780,8 +1897,8 @@ def _review_result(pack, merged, args):
             typed.append(x["id"])               # typed by the user: the rules keep these
         llm_summary = _reviewer_summary(x, d, args, stats)
         if x["id"] in merged:                    # reviewed, even if left to the rules
-            writes.append((x["id"], x.get("session") or pack.get("source"), x["text"],
-                           _decision_context(x["rule"].get("why"), pack), llm_keep, llm_summary))
+            writes.append((x["id"], x.get("session") or pack.get("source"), x["llm_key"],
+                           llm_keep, llm_summary))
         stats["restored"] += keep and not x["rule"]["keep"]
         stats["dropped"] += x["rule"]["keep"] and not keep
         if keep:
@@ -2091,10 +2208,11 @@ def main(argv=None) -> int:
     except SystemExit as e:
         return int(e.code) if isinstance(e.code, int) else 2
 
-    # stdin → derive per-turn uuid from content hash so cache works
+    # stdin → derive per-turn uuid from the content so the caches work (keyed: see _stdin_id_key)
     if args.from_transcript == "-":
+        key = _stdin_id_key()
         for t in turns:
-            t["uuid"] = hashlib.sha256(str(t["text"]).encode()).hexdigest()[:16]
+            t["uuid"] = hmac.new(key, str(t["text"]).encode(), hashlib.sha256).hexdigest()[:16]
 
     # ---- Pipeline order (R6): classify → merge → echo → hide-tool-only → range ----
     turns = classify_turns(turns, drop_trivia=args.drop_trivia)
@@ -2161,10 +2279,15 @@ def select_range(turns, args):
 
 
 def default_output(args, jsonl_path, session_id):
-    """work/lineage-<session name or id>.html, or args.output when given."""
+    """work/lineage-<session name or id>.html, or args.output when given. A name that holds a
+    secret-like string gives way to the session id."""
     if args.output is not None:
         return args.output
     session_name = discover_session_name(jsonl_path) if jsonl_path else None
+    if session_name and page_redact(session_name)[0] != session_name:
+        print(f"[lineage] session name: {page_redact(session_name)[0]} "
+              "(holds a secret-like string; the file is named by the session id)", file=sys.stderr)
+        session_name = None
     slug = ("all-sessions" if args.all_sessions
             else (session_name or session_id[:8]))
     if session_name:
@@ -2183,6 +2306,13 @@ def render_and_write(turns, session_id, args, all_sessions=False, markdown=True,
         markdown=markdown, all_sessions=all_sessions, summaries=summaries)
     for k, v in (prior_redactions or {}).items():
         redact_counts[k] = redact_counts.get(k, 0) + v
+    left = _residual_secrets("\n".join(rows))
+    if left:
+        print("[lineage] WARN: the page still holds secret-like text ("
+              + ", ".join(f"{k}={v}" for k, v in sorted(left.items()))
+              + "); check the page before sharing it, or run again with the value in LINEAGE_REDACT_EXTRA"
+              " (with --rulebase, add --rebuild-summaries)",
+              file=sys.stderr)
 
     date_range = ""
     dated = [t for t in turns if t.get("ts")]
@@ -2239,7 +2369,8 @@ def _with_timestamp_suffix(path_str):
 
 def _gate_samples(bots, summaries, session_id, args):
     """Up to 5 bot turns as the gate's critic reads them. --rulebase keeps the 2.x shape
-    (random turns, page redaction). With reviewer summaries (the default flow) the pick is
+    (random turns); a model reads the samples, so every value is hidden whole before the cut,
+    as in part files (3.0.2). With reviewer summaries (the default flow) the pick is
     seeded by the turns, so a rerun on the same turns samples the same ones, and a sample
     names its turn and shows the head and tail the reviewer saw, fully redacted."""
     import random
@@ -2248,8 +2379,8 @@ def _gate_samples(bots, summaries, session_id, args):
         for i, t in enumerate(random.sample(bots, min(5, len(bots)))):
             s, _ = _page_summary(t, summaries, session_id, False,
                                  args.redact_extra, args.redact_mode)
-            red_s, _ = redact(s, extra=args.redact_extra, mode=args.redact_mode)
-            red_d, _ = redact(t["text"][:500], extra=args.redact_extra, mode=args.redact_mode)
+            red_s = review_redact(_MASKED.sub("[REDACTED]", s), args.redact_extra)[0]
+            red_d = review_redact(t["text"], args.redact_extra)[0][:500]
             out.append({"idx": i, "original_detail": red_d, "generated_summary": red_s})
         return out
     seed = hashlib.sha256("\x00".join(t["uuid"] for t in bots).encode()).hexdigest()