leerness 1.36.166 → 1.36.167

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 1.36.167 — 2026-08-26
+
+- T-0145: 장기 운영 프로젝트의 레거시 완료 증거를 소급 수정하지 않고 명시적 tracker 경계 이전의 현재 실패만 exact 행+사유 SHA-256 지문으로 격리하는 claims baseline을 추가했습니다. verify-claim --all과 gate --claims는 원판정 실패·baseline 부채·현재 차단 및 진단 상세를 분리해 보고하고, --raw/개별 검증은 원판정을 유지합니다. 행 변경·신규 실패·경계 밖 항목·손상 baseline은 fail-closed하며, 생성 명령은 기존 baseline을 덮어쓰지 않아 변경 행의 재승인을 차단합니다. CLI·MCP·클린룸 프로브로 검증합니다.
+
 ## 1.36.166 — 2026-08-26
 
 - T-0144: unknown/foreign/malformed CLI 플래그를 migration과 쓰기 전에 exit 1로 거부하고 commands 카탈로그의 verify-code·contract verify 누락을 보완했습니다. 명령별 strict route와 값 누락·부울 equals·language 선택값 회귀 probe를 npm test에 추가했습니다.

package/README.md

@@ -85,6 +85,16 @@ The generated workflow is production-grade: it **pins the leerness version** (re
 
 Then make that check **required** in GitHub branch protection. Now a PR that skips verification (or whose claims fail) **cannot merge** — the gate runs independently of the agent, returns a non-zero exit code, and blocks. That is the difference between a guideline and a guardrail. For exact per-claim enforcement, run `leerness gate --claims` — it adds a 6th check that runs `verify-claim` on **every** completed task and fails the gate if any "done" task's evidence doesn't match reality (the default 5-check gate already blocks false-done via heuristics; `--claims` makes it precise).
 
+For a mature repository that predates strict claim verification, do not rewrite historical evidence merely to make the gate green. Create an explicit, reviewed debt boundary instead:
+
+```bash
+leerness verify-claim baseline create --before T-0123 --yes
+leerness verify-claim --all          # applies exact-match legacy debt policy
+leerness verify-claim --all --raw    # ignores the baseline and audits raw verdicts
+```
+
+The baseline stores no replacement evidence. It accepts only failures before the named tracker row whose **complete row and failure reasons still match their SHA-256 fingerprint**. A changed legacy row, a newly failing task, an entry at/after the boundary, or a corrupt baseline fails closed. `verify-claim <T-ID>` always remains raw for focused audits. Creation is one-shot: the CLI refuses to recalculate or overwrite an existing baseline, so a changed historical row cannot be relaundered by rerunning the command. The tracked `.leerness/claims-baseline.json` is repository policy, not a signature against a malicious repository writer: protect any removal or replacement with ordinary branch review and CODEOWNERS when the threat model requires that separation.
+
 For secrets, pair the gate with a **dedicated scanner** in the same workflow. `scan secrets` gives your agent the same signal locally; a dedicated scanner is the hard-guarantee layer:
 
 ```yaml
@@ -105,7 +115,7 @@ For secrets, pair the gate with a **dedicated scanner** in the same workflow. `s
 
 - **Memory** — `task` / `plan` / `decision` / `lesson` / `rule`: canonical JSON + markdown projections, archive/restore.
 - **Handoff** — `handoff` (session start context) · `session close` (closing report). Survives agent swaps.
-- **Verification** — `verify-claim` (evidence vs reality, stub/fake-test/inflated-count detection, `--run-tests --test-cmd` for any language; `--all` checks **every** completed claim at once for CI) · `contract verify` (spec ↔ impl) · `gate` (one-call CI gate).
+- **Verification** — `verify-claim` (evidence vs reality, stub/fake-test/inflated-count detection, `--run-tests --test-cmd` for any language; `--all` checks every completed claim for CI; `baseline create --before <T-ID> --yes` isolates fingerprint-bound legacy debt; `--raw` audits the original verdicts) · `contract verify` (spec ↔ impl) · `gate` (one-call CI gate).
 - **Audit** — `audit` · `lazy detect` · `drift check` keep the workspace honest over time.
 - **Security** — `scan secrets` (committed-secret detection) · `encoding check` (BOM/CP949) — also runs at `session close`.
 - **Visualize** — `graph --html` writes a self-contained interactive ontology graph (`leerness.html`) of the whole harness (memory surfaces + skills + feature-graph) — click a node to read its content. Optional tracked auto-refresh: `LEERNESS_AUTO_GRAPH=1 leerness handoff . --writeback`.
@@ -128,7 +138,7 @@ MIT
 <!-- leerness:project-readme:start -->
 ## Leerness Project Harness
 
-이 프로젝트는 Leerness v1.36.166 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
+이 프로젝트는 Leerness v1.36.167 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
 
 ### 정체성 — AI 에이전트 운영 레이어 (UR-0030)
 
@@ -182,7 +192,7 @@ leerness memory restore decision <date|title>
 
 ### MCP server (외부 AI 통합)
 
-Leerness v1.36.166는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **89개 도구**를 노출:
+Leerness v1.36.167는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **89개 도구**를 노출:
 
 ```jsonc
 // 카테고리별
@@ -203,7 +213,7 @@ Leerness v1.36.166는 stdio JSON-RPC MCP server를 내장합니다 — Claude Co
 `<<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.166 릴리스 태그 이력** (수백 라운드) · _reports/는 비공개 보존.
+현재 누적: **v1.9.x → 1.36.167 릴리스 태그 이력** (수백 라운드) · _reports/는 비공개 보존.
 
 ### 성능 가이드
 
@@ -241,5 +251,5 @@ leerness release pack --close --auto-main-push
 - `.leerness/session-handoff.md`: 다음 세션 인수인계 (자동 작성)
 - `.leerness/lessons.md` / `decisions.md` / `rules.md`: 영구 메모리 (5 surface)
 
-Last synced by Leerness v1.36.166: 2026-08-26
+Last synced by Leerness v1.36.167: 2026-08-26
 <!-- leerness:project-readme:end -->

package/bin/leerness.js

@@ -36,6 +36,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): .leerness/*.json 상태 무결성 (audit/health/check 공유)
 const _cursorHook = require('../lib/cursor-session-hook');
+const _claimsBaseline = require('../lib/claims-baseline');
 const {
   CANONICAL_WORKSPACE_DIR,
   LEGACY_WORKSPACE_DIR,
@@ -47,7 +48,7 @@ const {
   migrateLegacyWorkspace,
 } = require('../lib/workspace-dir');
 
-const VERSION = '1.36.166';
+const VERSION = '1.36.167';
 
 // 1.9.290 (UR-0037, Codex gpt-5.5 #4 수렴): CLI 전용 부작용은 require 시 실행하지 않는다.
 //   이전: warning listener 제거 / NODE_OPTIONS 변경 / chcp IIFE 가 top-level 즉시 실행 → require('harness') 시 호스트 프로세스 오염.
@@ -1318,7 +1319,7 @@ leerness memory restore <surface> <target>   # archive → active 복귀 (DELETE
     '.leerness/test-evidence-policy.md': fm('test-evidence-policy', ['검증 결과 기록 시'], ['검증 형식 변경'], `# Test Evidence Policy\n\n매 검증은 \`.leerness/review-evidence.md\`에 누적 기록합니다.\n\n## Format\n\`\`\`\n## YYYY-MM-DD HH:MM\nTask: T-XXXX\nCommand: <명령>\nExit: <코드>\nNote: <주요 결과 요약>\nArtifacts: <스크린샷/로그 경로>\n\`\`\`\n`),
     '.leerness/review-evidence.md': fm('review-evidence', ['진행 보고','릴리즈 검토'], ['검증 결과 기록'], `# Review Evidence\n\nVerification command/result history. Append-only.\n`),
     '.leerness/AX_PLAN_GUIDE.md': fm('ax-plan-guide', ['계획 수립/변경','신규 프로젝트'], ['계획 가이드 변경'], `# AX Plan Guide\n\n1. 사용자 요청이 기존 plan.md 범위 내인지 확인합니다.\n2. 새 범위라면 plan.md(milestone)와 progress-tracker.md(T-id) 양쪽에 추가합니다.\n3. 사용자가 범위를 드랍하면 삭제 대신 dropped 표기를 추가합니다.\n4. 신규 프로젝트는 코딩 전에 plan.md/project-brief.md를 채웁니다.\n`),
-    '.leerness/AX_MIGRATION_GUIDE.md': fm('ax-migration-guide', ['마이그레이션 전'], ['마이그레이션 정책 변경'], `# AX Migration Guide\n\n- Back up before changes (\`.leerness/archive/\`).\n- 기존 프로젝트 메모리 보존 (preserve-by-default).\n- .env.example/.gitignore는 라인 단위 머지.\n- 보호 파일을 삭제하지 않습니다.\n- 마이그레이션 보고서는 \`.leerness/migration-report.md\`.\n- 자동: \`leerness update --yes\`가 위 절차를 백업·머지·검증까지 한번에 수행합니다.\n`),
+    '.leerness/AX_MIGRATION_GUIDE.md': fm('ax-migration-guide', ['마이그레이션 전'], ['마이그레이션 정책 변경'], `# AX Migration Guide\n\n- Back up before changes (\`.leerness/archive/\`).\n- 기존 프로젝트 메모리 보존 (preserve-by-default).\n- .env.example/.gitignore는 라인 단위 머지.\n- 보호 파일을 삭제하지 않습니다.\n- 마이그레이션 보고서는 \`.leerness/migration-report.md\`.\n- 자동: \`leerness update --yes\`가 위 절차를 백업·머지·검증까지 한번에 수행합니다.\n- 레거시 완료 증거는 소급 수정하지 않습니다. 명시적 경계 이전의 현재 실패만 \`leerness verify-claim baseline create --before <T-ID> --yes\`로 격리합니다.\n- claims baseline은 전체 tracker 행+실패 사유 지문이 같을 때만 적용됩니다. 변경·신규 실패·손상 baseline은 fail-closed하며 \`verify-claim --all --raw\`로 원판정을 감사합니다.\n- 생성된 claims baseline은 CLI로 덮어쓰지 않습니다. 새 정책이 필요하면 기존 tracked 파일의 제거/교체를 별도 코드리뷰로 승인합니다.\n`),
     '.leerness/AX_NEW_PROJECT_GUIDE.md': fm('ax-new-project-guide', ['신규 프로젝트 감지'], ['신규 설치 정책 변경'], `# AX New Project Guide\n\nBefore coding, ask or infer the project goal, users, scope, out-of-scope, stack, deployment target, and milestones. Then fill plan.md and project-brief.md.\n`),
     '.leerness/AX_SKILL_LIBRARY_GUIDE.md': fm('ax-skill-library-guide', ['스킬 학습/검증/업로드'], ['스킬 정책 변경'], `# AX Skill Library Guide\n\nValidated skills require metadata, sensitive data scan, AI verification, dry-run publish, and explicit execute approval.\n`),
     '.leerness/skill-index.md': fm('skill-index', ['작업별 스킬 선택'], ['스킬 추가/삭제'], `# Skill Index\n\n| ID | Korean Name | Capabilities | Last Updated | Verification |\n|---|---|---|---|---|\n${skillRows}\n`),
@@ -1342,7 +1343,7 @@ leerness memory restore <surface> <target>   # archive → active 복귀 (DELETE
     _files['.leerness/test-evidence-policy.md'] = fm('test-evidence-policy', ['recording verification results'], ['verification format changes'], `# Test Evidence Policy\n\nEvery verification is appended to \`.leerness/review-evidence.md\`.\n\n## Format\n\`\`\`\n## YYYY-MM-DD HH:MM\nTask: T-XXXX\nCommand: <command>\nExit: <code>\nNote: <key result summary>\nArtifacts: <screenshot/log paths>\n\`\`\`\n`, 'en');
     _files['.leerness/review-evidence.md'] = fm('review-evidence', ['progress reports', 'release review'], ['verification results recorded'], `# Review Evidence\n\nVerification command/result history. Append-only.\n`, 'en');
     _files['.leerness/AX_PLAN_GUIDE.md'] = fm('ax-plan-guide', ['planning/plan changes', 'new project'], ['plan guide changes'], `# AX Plan Guide\n\n1. Check whether the user's request is within the current plan.md scope.\n2. If it is new scope, add it to both plan.md (milestone) and progress-tracker.md (T-id).\n3. When the user drops scope, mark it dropped instead of deleting.\n4. For new projects, fill plan.md/project-brief.md before coding.\n`, 'en');
-    _files['.leerness/AX_MIGRATION_GUIDE.md'] = fm('ax-migration-guide', ['before migration'], ['migration policy changes'], `# AX Migration Guide\n\n- Back up before changes (\`.leerness/archive/\`).\n- Preserve existing project memory (preserve-by-default).\n- Merge .env.example/.gitignore line by line.\n- Never delete protected files.\n- Migration report: \`.leerness/migration-report.md\`.\n- Automatic: \`leerness update --yes\` performs backup, merge, and verification in one step.\n`, 'en');
+    _files['.leerness/AX_MIGRATION_GUIDE.md'] = fm('ax-migration-guide', ['before migration'], ['migration policy changes'], `# AX Migration Guide\n\n- Back up before changes (\`.leerness/archive/\`).\n- Preserve existing project memory (preserve-by-default).\n- Merge .env.example/.gitignore line by line.\n- Never delete protected files.\n- Migration report: \`.leerness/migration-report.md\`.\n- Automatic: \`leerness update --yes\` performs backup, merge, and verification in one step.\n- Never rewrite legacy completion evidence. Isolate only current failures before an explicit boundary with \`leerness verify-claim baseline create --before <T-ID> --yes\`.\n- A claims baseline applies only while the full tracker row and failure reasons match. Changed/new failures or a corrupt baseline fail closed; audit raw verdicts with \`verify-claim --all --raw\`.\n- The CLI never overwrites a created claims baseline. Approve removal or replacement of the tracked policy file as a separate code-reviewed change.\n`, 'en');
     _files['.leerness/AX_NEW_PROJECT_GUIDE.md'] = fm('ax-new-project-guide', ['new project detected'], ['fresh-install policy changes'], `# AX New Project Guide\n\nBefore coding, ask or infer the project goal, users, scope, out-of-scope, stack, deployment target, and milestones. Then fill plan.md and project-brief.md.\n`, 'en');
     _files['.leerness/AX_SKILL_LIBRARY_GUIDE.md'] = fm('ax-skill-library-guide', ['skill learning/verification/upload'], ['skill policy changes'], `# AX Skill Library Guide\n\nValidated skills require metadata, sensitive data scan, AI verification, dry-run publish, and explicit execute approval.\n`, 'en');
     _files['.leerness/skill-index.md'] = fm('skill-index', ['choosing skills per task'], ['skills added/removed'], `# Skill Index\n\n| ID | Korean Name | Capabilities | Last Updated | Verification |\n|---|---|---|---|---|\n${skillRows}\n`, 'en');
@@ -5552,20 +5553,40 @@ function _selfTestCases() {
     } },
     { name: '1.33.3 (verify-claim --all → gate+MCP): _verifyClaimsAll 코어(exit 없음) + gate --claims opt-in 6번째(기본 5 유지) + MCP leerness_verify_claim_all def↔case', run: () => {
       const src = read(__filename);
-      const coreDef = src.match(/function _verifyClaimsAll\(root\) \{[\s\S]*?\n\}/);  // 함수 본문만 캡처(첫 줄머리 } 까지)
-      const core = !!coreDef && coreDef[0].includes('return { ok: failed.length === 0, total: doneRows.length, failed: failed.length, results };') && !/process\.exit\(/.test(coreDef[0]);  // 코어는 절대 process.exit( 안 함(게이트 step 집계 보호)
+      const coreDef = src.match(/function _verifyClaimsAll\(root, options = \{\}\) \{[\s\S]*?\n\}/);  // 함수 본문만 캡처(첫 줄머리 } 까지)
+      const core = !!coreDef && coreDef[0].includes('const raw = { ok: failed.length === 0, total: doneRows.length, failed: failed.length, results };')
+        && coreDef[0].includes('_claimsBaseline.applyBaseline(rows, raw') && !/process\.exit\(/.test(coreDef[0]);  // 코어는 절대 process.exit( 안 함(게이트 step 집계 보호)
       // 1.36.82: 헤더 문자열을 **정확 리터럴**로 잡으면 그 줄을 만질 때마다 자기 줄만 매칭해 조용히 통과한다
       //   (이번 라운드에만 두 번 그렇게 됐다). 표현이 아니라 **불변식**을 본다:
       //   헤더가 withClaims 로 5/6 을 계산하고, --claims 일 때만 verify-claims 단계가 붙는다.
       const gateOptIn = src.includes("const withClaims = has('--claims');")
         && /# leerness gate \(\$\{[^}]*withClaims \? 6 : 5[^}]*\} checks\)/.test(src)
-        && src.includes("if (withClaims) step('verify-claims', () => { const r = _verifyClaimsAll(root);");
-      const reuse = src.includes('const res = _verifyClaimsAll(root);');  // CLI 도 코어 공유(분기 없음)
+        && /if \(withClaims\) step\('verify-claims',[\s\S]{0,100}?const r = _verifyClaimsAll\(root\)/.test(src);
+      const reuse = src.includes("const res = _verifyClaimsAll(root, { raw: has('--raw') });");  // CLI 도 코어 공유(분기 없음)
       const tools = require('../lib/mcp-tools');
       const def = tools.find(t => t.name === 'leerness_verify_claim_all');
       const mcpOk = !!def && def.requiredTier === 'read-only' && src.includes("case 'leerness_verify_claim_all':") && /case 'leerness_verify_claim_all':[\s\S]{0,160}'verify-claim', '--all'[\s\S]{0,80}'--json'/.test(src);
       return core && gateOptIn && reuse && mcpOk && tools.length >= 84;
     } },
+    { name: '1.36.167 (T-0145): claims baseline은 경계 이전 exact 행+사유만 승인하고 새/변경 실패·손상은 fail-closed (행위)', run: () => {
+      const b = require('../lib/claims-baseline');
+      const row = (id, status, evidence, nextAction = 'next') => ({ id, status, request: `request ${id}`, evidence, nextAction, updated: '2026-08-26' });
+      const rows = [row('T-0001', 'done', 'legacy prose'), row('T-0002', 'in-progress', 'boundary'), row('T-0003', 'done', 'new prose')];
+      const raw = { ok: false, total: 2, failed: 2, results: [
+        { id: 'T-0001', request: 'request T-0001', status: 'done', ok: false, reasons: ['unverifiable-claim'] },
+        { id: 'T-0003', request: 'request T-0003', status: 'done', ok: false, reasons: ['unverifiable-claim'] },
+      ] };
+      const built = b.buildBaseline(rows, raw, { beforeTaskId: 'T-0002', version: VERSION, createdAt: '2026-08-26T00:00:00.000Z' });
+      const valid = b.validateBaseline(built.doc).ok && built.doc.entries.length === 1;
+      const applied = b.applyBaseline(rows, raw, { state: 'valid', file: 'fixture', doc: built.doc });
+      const changedRows = [{ ...rows[0], nextAction: 'changed' }, rows[1], rows[2]];
+      const changed = b.applyBaseline(changedRows, raw, { state: 'valid', file: 'fixture', doc: built.doc });
+      const corrupt = b.validateBaseline({ ...built.doc, integrity: 'sha256:' + '0'.repeat(64) });
+      return valid && applied.ok === false && applied.baselined === 1 && applied.failed === 1
+        && applied.baseline.newFailures.includes('T-0003')
+        && changed.baselined === 0 && changed.failed === 2 && changed.baseline.mismatched.includes('T-0001')
+        && corrupt.ok === false && corrupt.problems.includes('integrity-mismatch');
+    } },
     { name: '14th 버그헌트 P2 (UR-0178/0179/0180): completed→done 정규화 + rule archive _cellSafe + nextRuleId 아카이브 스캔 (1.11.3)', run: () => {
       if (_normTaskStatus('completed') !== 'done' || _normTaskStatus('verified') !== 'done' || _normTaskStatus('in-progress') !== 'in-progress') return false;
       const src = read(__filename);
@@ -10967,7 +10988,7 @@ function commandsCmd(root) {
       { cmd: 'scan secrets [path]', desc: '시크릿 탐지', descEn: 'secret detection' },
       { cmd: 'encoding check [path]', desc: '인코딩 검증', descEn: 'encoding verification' },
       { cmd: 'lazy detect [path] [--json]', desc: '게으른 작업 감지 (1.9.101)', descEn: 'detect lazy/incomplete work (1.9.101)' },
-      { cmd: 'verify-claim <T-ID|--all> [--run-tests] [--test-cmd "<명령>"] [--strict-claims] [--require-evidence]', cmdEn: 'verify-claim <T-ID|--all> [--run-tests] [--test-cmd "<command>"] [--strict-claims] [--require-evidence]', desc: '주장 검증 (1.9.18~26) — --all: 모든 done 주장 일괄 검증(CI·스케일, 1.33.2) · --require-evidence: done 주장에 파일+테스트 근거 강제 (1.9.287) · --test-cmd: 비-JS 테스트 명령 (1.17.2)', descEn: 'verify a claim (1.9.18~26) — --all: verify every done claim at once (CI/scale, 1.33.2) · --require-evidence: require file + test evidence on done claims (1.9.287) · --test-cmd: non-JS test command (1.17.2)' },
+      { cmd: 'verify-claim <T-ID|--all> [--run-tests] [--strict-claims] [--raw] · baseline create --before <T-ID> --yes|show', cmdEn: 'verify-claim <T-ID|--all> [--run-tests] [--strict-claims] [--raw] · baseline create --before <T-ID> --yes|show', desc: '주장 검증 — --all은 명시적 legacy baseline 적용, --raw는 원판정 감사. baseline create는 경계 이전 exact 행+사유 실패만 격리하며 evidence를 수정하지 않음 (1.36.167)', descEn: 'claim verification — --all applies an explicit legacy baseline; --raw audits raw verdicts. baseline create isolates only exact row+reason failures before a boundary without editing evidence (1.36.167)' },
       { cmd: 'verify-code [path] [--build] [--bench] [--strict]', desc: '프로젝트 테스트·린트·타입검사 자동 감지 실행 + 검증 증거 기록', descEn: 'auto-detect and run project tests/lint/typecheck, then record verification evidence' },
       { cmd: 'contract verify <spec.md> <impl.js> [--allow-empty] [--json]', desc: '명세의 함수·필드 선언과 구현 export 정적 대조', descEn: 'statically compare functions and fields declared in a spec with implementation exports' },
       { cmd: `lens [${_lensDomainList()}] [--json]`, desc: '분야별 자기질문 품질 렌즈 + 분야간 인과관계 (1.18.3 · database/contract/recovery/observability 는 심화, axes 는 8축 경량 점검)', descEn: 'per-domain self-question quality lenses + cross-domain causality (1.18.3 · database/contract/recovery/observability are deep dives, axes is a light 8-axis check)' },
@@ -14628,11 +14649,15 @@ const _STRICT_COMMAND_FLAGS = {
   about: { allowed: [], globals: [..._COMMON_COMMAND_FLAGS, '--json'], usage: 'about [--json]' },
   identity: { allowed: [], globals: [..._COMMON_COMMAND_FLAGS, '--json'], usage: 'identity [--json]' },
   gate: { allowed: ['--claims', '--require-referee'], globals: [..._COMMON_COMMAND_FLAGS, '--json'], usage: 'gate [path] [--claims] [--require-referee <id>] [--json]' },
+  'verify-claim': { allowed: ['--all', '--run-tests', '--test-cmd', '--strict-claims', '--require-evidence', '--lenient', '--referee', '--raw'], globals: [..._COMMON_COMMAND_FLAGS, '--json'], usage: 'verify-claim <T-ID|--all> [--run-tests] [--strict-claims] [--raw] [--json]' },
+  'verify-claim baseline create': { allowed: ['--before', '--yes'], globals: [..._COMMON_COMMAND_FLAGS, '--json'], usage: 'verify-claim baseline create --before <T-ID> --yes [--json]' },
+  'verify-claim baseline show': { allowed: [], globals: [..._COMMON_COMMAND_FLAGS, '--json'], usage: 'verify-claim baseline show [--json]' },
   'verify-code': { allowed: ['--build', '--bench', '--strict'], globals: [..._COMMON_COMMAND_FLAGS], usage: 'verify-code [path] [--build] [--bench] [--strict]' },
   'contract verify': { allowed: ['--allow-empty'], globals: [..._COMMON_COMMAND_FLAGS, '--json'], usage: 'contract verify <spec.md> <impl.js> [--allow-empty] [--json]' },
 };
 function _validateCommandFlags(cmd, args) {
-  const route = cmd === 'contract' && args[1] === 'verify' ? 'contract verify' : cmd;
+  let route = cmd === 'contract' && args[1] === 'verify' ? 'contract verify' : cmd;
+  if (cmd === 'verify-claim' && args[1] === 'baseline') route = `verify-claim baseline ${args[2] || ''}`.trim();
   const cfg = _STRICT_COMMAND_FLAGS[route];
   if (!cfg) return true;
   return _rejectUnknownFlags(cfg.allowed, cfg.usage, { globals: cfg.globals });
@@ -18849,7 +18874,10 @@ function verifyClaimCmd(root, taskId, opts = {}) {
 //   1.34.1 (16th리뷰 정직화): 기본 게이트 5체크는 워크스페이스-상태 휴리스틱(handoff/test-run/evidence 부재 등)으로 거짓완료를 잡고, 콘텐츠-레벨 주장(파일 존재·테스트 카운트·스텁·optimism)은 검사하지 않음. verify-claim --all 은 그 콘텐츠 차원을 추가 — lazy detect 가 깨끗한(handoff·테스트기록 완비) 성숙 프로젝트에선 5체크가 통과해도 이 검사만 콘텐츠 거짓을 잡음(실증: gate 기본 exit 0 vs --claims exit 1).
 // 1.33.3: 일괄 검증 코어 — 렌더/exit 없이 결과만 반환. verifyClaimAllCmd(CLI 렌더+exit) 와 gate --claims(opt-in 체크) 가 공유.
 //   gate 의 step() 은 process.exit 가 아니라 process.exitCode 로 실패를 감지하므로, 코어는 절대 process.exit 하지 않음(게이트 프로세스 조기종료 방지).
-function _verifyClaimsAll(root) {
+// 1.36.167 (T-0145): 오래된 프로젝트의 검증기 도입 이전 완료 행을 소급 수정하지 않으면서도 새 실패를
+//   계속 차단한다. 기준선은 명시적 tracker 경계 이전의 **현재 실패만** 담고, 전체 행+사유 지문이 같을 때만
+//   정책상 승인한다. 행/사유 변경·새 실패·손상 파일은 fail-closed. --raw 는 원판정을 계속 감사한다.
+function _verifyClaimsAll(root, options = {}) {
   root = absRoot(root);
   const rows = readProgressRows(root);
   const doneRows = rows.filter(r => /done|완료|completed/i.test(String(r.status || '')));
@@ -18858,30 +18886,111 @@ function _verifyClaimsAll(root) {
   const runMemo = {};
   const results = doneRows.map(r => verifyClaimCmd(root, r.id, { collect: true, runMemo }));
   const failed = results.filter(x => x && !x.ok);
-  return { ok: failed.length === 0, total: doneRows.length, failed: failed.length, results };
+  const raw = { ok: failed.length === 0, total: doneRows.length, failed: failed.length, results };
+  return _claimsBaseline.applyBaseline(rows, raw, options.raw ? null : _claimsBaseline.loadBaseline(root), { raw: !!options.raw });
 }
 function verifyClaimAllCmd(root) {
   root = absRoot(root);
   const _j = has('--json');
   const _L = _uiLang(root); const t = (ko, en) => (_L === 'en' ? en : ko);
-  const res = _verifyClaimsAll(root);
+  const res = _verifyClaimsAll(root, { raw: has('--raw') });
   const { results, total } = res;
   if (_j) {
-    log(JSON.stringify({ ok: res.ok, root: path.basename(root), total, failed: res.failed, results }, null, 2));
-    if (res.failed) process.exitCode = 1;
+    log(JSON.stringify({ ok: res.ok, root: path.basename(root), total, failed: res.failed, rawFailed: res.rawFailed, baselined: res.baselined, baseline: res.baseline, errors: res.errors, results }, null, 2));
+    if (!res.ok) process.exitCode = 1;
     return;
   }
-  log(`# verify-claim --all (${path.basename(root)})`);
+  log(`# verify-claim --all${has('--raw') ? ' --raw' : ''} (${path.basename(root)})`);
+  if (res.errors && res.errors.length) {
+    fail(t(`claims baseline 사용 불가: ${res.errors.join(', ')} (${(res.baseline && res.baseline.problems || []).join(', ') || 'context invalid'})`, `claims baseline unusable: ${res.errors.join(', ')} (${(res.baseline && res.baseline.problems || []).join(', ') || 'context invalid'})`));
+    return process.exit(1);
+  }
   if (!total) { log(t('  완료(done) 주장이 없어 검증할 항목이 없습니다.', '  No completed (done) claims to verify.')); return; }
-  log(t(`  완료 주장 ${total}건 검증 — 통과 ${total - res.failed} · 실패 ${res.failed}`, `  Verified ${total} completed claim(s) — pass ${total - res.failed} · fail ${res.failed}`));
+  log(t(`  완료 주장 ${total}건 — 원판정 실패 ${res.rawFailed} · 레거시 부채 승인 ${res.baselined} · 현재 차단 ${res.failed}`, `  ${total} completed claim(s) — raw failures ${res.rawFailed} · accepted legacy debt ${res.baselined} · blocking now ${res.failed}`));
   log('');
   for (const r of results) {
-    if (r.ok) log(`  ✓ ${r.id}  ${String(r.request || '').slice(0, 60)}`);
+    if (r && r.baselineAccepted) log(`  ≈ ${r.id}  ${String(r.request || '').slice(0, 48)}  ${t('← 레거시 부채', '← legacy debt')}: ${(r.baselineReasons || []).join(', ')}`);
+    else if (r.ok) log(`  ✓ ${r.id}  ${String(r.request || '').slice(0, 60)}`);
     else log(`  ✗ ${r.id}  ${String(r.request || '').slice(0, 50)}  ${t('← 불일치', '← mismatch')}: ${r.reasons.join(', ')}`);
   }
   log('');
   if (res.failed) { log(t(`  ⚠ ${res.failed}건의 완료 주장이 증거와 불일치 — 재검토 권장 (개별 상세: leerness verify-claim <T-ID>)`, `  ⚠ ${res.failed} completed claim(s) do not match evidence — review (per-task detail: leerness verify-claim <T-ID>)`)); return process.exit(1); }
-  log(t(`  ✓ 모든 완료 주장이 증거와 일치`, `  ✓ all completed claims match evidence`));
+  if (res.baselined) log(t(`  ✓ 신규·변경된 완료 주장에 차단 실패 없음 (레거시 부채 ${res.baselined}건은 baseline에 격리; --raw로 원판정 감사)`, `  ✓ no blocking failure in new or changed claims (${res.baselined} legacy debt item(s) isolated by baseline; audit raw verdicts with --raw)`));
+  else log(t(`  ✓ 모든 완료 주장이 증거와 일치`, `  ✓ all completed claims match evidence`));
+}
+
+function claimBaselineCmd(root, sub) {
+  root = absRoot(root);
+  const json = has('--json');
+  const _L = _uiLang(root); const t = (ko, en) => (_L === 'en' ? en : ko);
+  const loaded = _claimsBaseline.loadBaseline(root);
+  if (sub === 'show') {
+    if (loaded.state === 'invalid') {
+      failJson(json, 'baseline_invalid', t(`claims-baseline.json 손상/형상 무효: ${(loaded.problems || []).join(', ')}`, `claims-baseline.json is corrupt or invalid: ${(loaded.problems || []).join(', ')}`));
+      return;
+    }
+    if (json) {
+      log(JSON.stringify({ ok: true, state: loaded.state, path: loaded.file, baseline: loaded.doc }, null, 2));
+      return;
+    }
+    if (loaded.state === 'absent') { log(t('claims baseline 없음', 'no claims baseline')); return; }
+    log(`# claims baseline (${path.basename(root)})`);
+    log(t(`  경계: ${loaded.doc.beforeTaskId} 이전 · 부채 ${loaded.doc.entries.length}건 · 생성 ${loaded.doc.createdAt}`, `  boundary: before ${loaded.doc.beforeTaskId} · debt ${loaded.doc.entries.length} · created ${loaded.doc.createdAt}`));
+    return;
+  }
+  if (sub !== 'create') {
+    failJson(json, 'unknown_subcommand', t('사용법: leerness verify-claim baseline create --before <T-ID> --yes | baseline show', 'usage: leerness verify-claim baseline create --before <T-ID> --yes | baseline show'));
+    return;
+  }
+  if (!has('--yes')) {
+    failJson(json, 'confirmation_required', t('레거시 실패를 정책 부채로 승인하려면 --yes가 필요합니다 (evidence 원문은 수정하지 않음)', '--yes is required to acknowledge legacy failures as policy debt (historical evidence is not modified)'));
+    return;
+  }
+  const beforeTaskId = arg('--before', null);
+  if (!beforeTaskId || beforeTaskId === true) {
+    failJson(json, 'missing_boundary', t('--before <T-ID>가 필요합니다. 이 경계와 이후의 실패는 절대 baseline에 포함되지 않습니다.', '--before <T-ID> is required. Failures at or after that boundary are never baselined.'));
+    return;
+  }
+  if (loaded.state === 'invalid') {
+    failJson(json, 'baseline_invalid', t(`기존 claims-baseline.json이 손상되어 덮어쓰지 않습니다: ${(loaded.problems || []).join(', ')}`, `existing claims-baseline.json is invalid and will not be overwritten: ${(loaded.problems || []).join(', ')}`));
+    return;
+  }
+  if (loaded.state === 'valid') {
+    failJson(json, 'baseline_exists', t('기존 claims-baseline.json은 불변 정책으로 취급되어 다시 계산하거나 덮어쓰지 않습니다. 새 정책이 필요하면 tracked 파일 변경을 별도 코드리뷰로 승인하세요.', 'existing claims-baseline.json is treated as immutable policy and will not be recalculated or overwritten. Approve any tracked policy-file change in a separate code review.'));
+    return;
+  }
+  const rows = readProgressRows(root);
+  const raw = _verifyClaimsAll(root, { raw: true });
+  let built;
+  try { built = _claimsBaseline.buildBaseline(rows, raw, { beforeTaskId, version: VERSION, createdAt: now() }); }
+  catch (error) {
+    failJson(json, error && error.code === 'E_CLAIMS_BASELINE_BOUNDARY' ? 'boundary_not_found' : 'baseline_create_failed', error.message);
+    return;
+  }
+  if (!built.doc.entries.length) {
+    failJson(json, 'nothing_to_baseline', t(`${beforeTaskId} 이전에 실패한 완료 주장이 없습니다. 빈 기준선은 만들지 않습니다.`, `there are no failed completed claims before ${beforeTaskId}; an empty baseline was not created.`));
+    return;
+  }
+  let file;
+  try { file = _claimsBaseline.saveBaseline(root, built.doc, _withLock); }
+  catch (error) {
+    failJson(json, error && error.code === 'E_CLAIMS_BASELINE_EXISTS' ? 'baseline_exists' : 'baseline_write_failed', error.message);
+    return;
+  }
+  const out = {
+    ok: true,
+    path: file,
+    beforeTaskId,
+    evaluatedBefore: built.stats.evaluatedBefore,
+    baselined: built.stats.baselined,
+    blockingAtOrAfterBoundary: built.stats.failuresAtOrAfterBoundary,
+    historicalEvidenceModified: false,
+    integrity: built.doc.integrity,
+    replaced: false,
+  };
+  if (json) { log(JSON.stringify(out, null, 2)); return; }
+  ok(t(`claims baseline 생성: ${built.stats.baselined}건 격리 · ${beforeTaskId}와 이후는 제외`, `claims baseline created: ${built.stats.baselined} isolated · ${beforeTaskId} and later excluded`));
+  log(t(`  evidence 원문 수정 0 · 행/사유 변경 시 면제 무효 · 새 실패 차단 ${out.blockingAtOrAfterBoundary}건`, `  historical evidence edits 0 · any row/reason change invalidates its exemption · ${out.blockingAtOrAfterBoundary} new failure(s) still block`));
 }
 
 // 1.9.22: orchestrate — Ollama 로컬 LLM으로 best-of-N 멀티 에이전트 시뮬
@@ -21040,7 +21149,21 @@ function gate(root) {
   step('encoding check', () => encodingCheck(root));
   step('lazy detect', () => lazyDetect(root));
   // 1.33.3: opt-in 정밀 per-claim 검증. 코어(_verifyClaimsAll)는 exit 안 하고 결과만 반환 → step 의 exitCode 감지로 실패 집계. 비-json 모드는 불일치 task 를 fail() 로 표면화.
-  if (withClaims) step('verify-claims', () => { const r = _verifyClaimsAll(root); if (!r.ok) { process.exitCode = 1; if (!jsonMode) r.results.filter(x => x && !x.ok).forEach(x => fail(`${x.id} 불일치: ${x.reasons.join(', ')}`)); } });
+  // 1.36.167: 기준선이 있으면 정확히 일치하는 과거 실패만 별도 부채로 승인한다. JSON은 원판정/승인/현재차단을
+  //   모두 노출해 "실패가 사라졌다"고 오해하지 않게 하고, 손상 baseline은 별도 오류로 fail-closed한다.
+  if (withClaims) step('verify-claims', () => {
+    const r = _verifyClaimsAll(root);
+    _stepDetail = { total: r.total, failed: r.failed, rawFailed: r.rawFailed, baselined: r.baselined, baselineState: r.baseline && r.baseline.state, baseline: r.baseline, ...(r.errors && r.errors.length ? { errors: r.errors } : {}) };
+    if (!r.ok) {
+      process.exitCode = 1;
+      if (!jsonMode) {
+        if (r.errors && r.errors.length) fail(`claims baseline 사용 불가: ${r.errors.join(', ')} (${(r.baseline && r.baseline.problems || []).join(', ')})`);
+        r.results.filter(x => x && !x.ok).forEach(x => fail(`${x.id} 불일치: ${x.reasons.join(', ')}`));
+      }
+    } else if (!jsonMode && r.baselined) {
+      log(`  ⓘ 레거시 부채 ${r.baselined}건은 지문 일치 baseline으로 격리됨 (원판정 실패 ${r.rawFailed}건 · --raw 감사 가능)`);
+    }
+  });
   // 1.36.82 (공허한 가드 스윕 High #2, 실측 확인): `referee verify` 성공 시 툴이 사용자에게
   //   "이제 gate --require-referee <id> 가 이 검증기를 신뢰합니다" 라고 **안내하는데 gate 는 이 플래그를 읽지도 않았다**.
   //   사용자는 안내받은 명령을 CI 에 넣고 검증기가 머지를 막는다고 믿지만 아무 일도 일어나지 않았고,
@@ -24964,7 +25087,7 @@ function _mcpToCliArgs(name, args, targetPath) {
           case 'leerness_drift_check':     cliArgs = ['drift', 'check', targetPath, '--json']; break;
           case 'leerness_audit':           cliArgs = ['audit', targetPath, '--json', ...(args.fix ? ['--fix'] : []), ...(args.strict ? ['--strict'] : [])]; break;
           case 'leerness_verify_claim':    cliArgs = ['verify-claim', args.taskId, '--path', targetPath, ...(args.refereeId ? ['--referee', String(args.refereeId)] : []), ...(args.runTests ? ['--run-tests'] : []), ...(args.strictClaims ? ['--strict-claims'] : []), ...(args.lenient ? ['--lenient'] : [])]; break;
-          case 'leerness_verify_claim_all': cliArgs = ['verify-claim', '--all', '--path', targetPath, '--json', ...(args.runTests ? ['--run-tests'] : []), ...(args.strictClaims ? ['--strict-claims'] : []), ...(args.lenient ? ['--lenient'] : [])]; break;  // 1.33.3: 모든 done 주장 일괄 검증(--json 강제 → process.exitCode 만, 하드 exit 없음)
+          case 'leerness_verify_claim_all': cliArgs = ['verify-claim', '--all', '--path', targetPath, '--json', ...(args.runTests ? ['--run-tests'] : []), ...(args.strictClaims ? ['--strict-claims'] : []), ...(args.lenient ? ['--lenient'] : []), ...(args.raw ? ['--raw'] : [])]; break;  // 1.33.3/1.36.167: 일괄검증 + 원판정 감사
           case 'leerness_contract_verify': cliArgs = ['contract', 'verify', args.spec, args.impl]; break;
           case 'leerness_agents_list':     cliArgs = ['agents', 'list', '--json']; break;
           case 'leerness_reuse_map':       cliArgs = ['reuse-map', targetPath, ...(args.allApps ? ['--all-apps'] : []), ...(args.strictElements ? ['--strict-elements'] : []), '--json']; break;
@@ -29726,8 +29849,10 @@ STATUS & DIAGNOSTICS
   whats-new [path]                Recent version changes
 
 VERIFICATION (evidence-gated "done")
-  verify-claim <T-ID> [--run-tests] [--test-cmd "..."] [--json]
-                                  Check evidence vs reality (stub / fake-test / inflated-count detection)
+  verify-claim <T-ID|--all> [--run-tests] [--raw] [--json]
+                                  Check evidence vs reality; --raw ignores a legacy baseline
+  verify-claim baseline create --before <T-ID> --yes | baseline show
+                                  Isolate fingerprint-bound legacy debt without editing evidence
   contract verify <spec.md> <impl.js> [--json] [--allow-empty]   Spec <-> implementation match (empty spec rejected unless --allow-empty)
   verify-code [path] [--build] [--bench]          Run tests/lint/typecheck, record evidence
   gate [path]                     One-call CI gate: verify + audit + scan + encoding + lazy
@@ -30326,7 +30451,13 @@ async function main() {
   //   측정이 관측 대상을 바꾸면 안 된다.
   if (cmd === 'handoff')      { const _hp = arg('--path', args[1] || process.cwd()); const _hr = handoffCmd(_hp); if (has('--writeback') && process.env.LEERNESS_HOOK !== '1') { try { _tech.refreshTechProfile(_hp); } catch {} _maybeAutoGraph(_hp); } return _hr; }   // T-0136: 기본은 추적 파일 쓰기 0. 명시적 --writeback 만 기존 프로필/그래프 투영을 갱신한다.
   if (cmd === 'reuse-map')    return reuseMapCmd(arg('--path', args[1] || process.cwd()));
-  if (cmd === 'verify-claim') { const _p = arg('--path', process.cwd()); if (args[1] === '--all' || has('--all')) return verifyClaimAllCmd(_p); return verifyClaimCmd(_p, args[1]); }  // 1.33.2: --all → 모든 done 주장 일괄 검증
+  if (cmd === 'verify-claim') {
+    const _p = arg('--path', process.cwd());
+    if (args[1] === 'baseline') return claimBaselineCmd(_p, args[2]);
+    if (args[1] === '--all' || has('--all')) return verifyClaimAllCmd(_p);
+    if (has('--raw')) return failJson(has('--json'), 'raw_requires_all', '--raw 는 verify-claim --all 에서만 사용합니다. 개별 task 판정은 항상 원판정입니다.');
+    return verifyClaimCmd(_p, args[1]);
+  }  // 1.33.2/1.36.167: --all 일괄검증 + 명시적 legacy baseline
   if (cmd === 'orchestrate')  return await orchestrateCmd(arg('--path', process.cwd()), args.slice(1).filter(x => !x.startsWith('-')));
   if (cmd === 'llm-bench' && args[1] === 'record') return llmBenchRecordCmd(arg('--path', process.cwd()));
   if (cmd === 'deps')         return depsImpactCmd(arg('--path', process.cwd()), args[1]);

package/lib/claims-baseline.js

@@ -0,0 +1,272 @@
+// lib/claims-baseline.js — explicit, fingerprint-bound legacy claim debt.
+//
+// A baseline never edits historical evidence and never makes a new failure pass.
+// It can acknowledge only failures that existed before an explicit tracker-row
+// boundary, and only while the complete row plus the verifier reasons remain
+// byte-for-byte equivalent after canonical JSON normalization.
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { absRoot, exists, read, mkdirp, writeUtf8 } = require('./io');
+
+const SCHEMA_VERSION = 1;
+const KIND = 'leerness-claims-baseline';
+const POLICY = 'exact-progress-row-and-reasons';
+const FILE_NAME = 'claims-baseline.json';
+
+function baselinePath(root) {
+  return path.join(absRoot(root), '.leerness', FILE_NAME);
+}
+
+function _canonical(value) {
+  if (Array.isArray(value)) return '[' + value.map(_canonical).join(',') + ']';
+  if (value && typeof value === 'object') {
+    return '{' + Object.keys(value).sort().map(k => JSON.stringify(k) + ':' + _canonical(value[k])).join(',') + '}';
+  }
+  return JSON.stringify(value);
+}
+
+function _sha256(value) {
+  return crypto.createHash('sha256').update(_canonical(value)).digest('hex');
+}
+
+function _normalizedRow(row) {
+  return {
+    id: String(row && row.id || ''),
+    status: String(row && row.status || ''),
+    request: String(row && row.request || ''),
+    evidence: String(row && row.evidence || ''),
+    nextAction: String(row && row.nextAction || ''),
+    updated: String(row && row.updated || ''),
+  };
+}
+
+function normalizeReasons(reasons) {
+  return Array.from(new Set((Array.isArray(reasons) ? reasons : [])
+    .map(x => String(x || '').trim()).filter(Boolean))).sort();
+}
+
+function claimFingerprint(row, reasons) {
+  return _sha256({ row: _normalizedRow(row), reasons: normalizeReasons(reasons) });
+}
+
+function _withoutIntegrity(doc) {
+  const out = { ...doc };
+  delete out.integrity;
+  return out;
+}
+
+function _integrity(doc) {
+  return 'sha256:' + _sha256(_withoutIntegrity(doc));
+}
+
+function validateBaseline(doc) {
+  const problems = [];
+  if (!doc || typeof doc !== 'object' || Array.isArray(doc)) return { ok: false, problems: ['root-not-object'] };
+  if (doc.schemaVersion !== SCHEMA_VERSION) problems.push('unsupported-schema');
+  if (doc.kind !== KIND) problems.push('wrong-kind');
+  if (doc.policy !== POLICY) problems.push('wrong-policy');
+  if (typeof doc.createdAt !== 'string' || Number.isNaN(Date.parse(doc.createdAt))) problems.push('invalid-created-at');
+  if (typeof doc.createdByVersion !== 'string' || !doc.createdByVersion.trim()) problems.push('invalid-created-by-version');
+  if (typeof doc.beforeTaskId !== 'string' || !/^[A-Z]+-\d{3,}$/.test(doc.beforeTaskId)) problems.push('invalid-before-task');
+  if (!Number.isInteger(doc.evaluatedBefore) || doc.evaluatedBefore < 0) problems.push('invalid-evaluated-before');
+  if (!Number.isInteger(doc.rawFailedBefore) || doc.rawFailedBefore < 0) problems.push('invalid-raw-failed-before');
+  if (!Array.isArray(doc.entries)) problems.push('entries-not-array');
+  const ids = new Set();
+  for (const entry of Array.isArray(doc.entries) ? doc.entries : []) {
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) { problems.push('invalid-entry'); continue; }
+    if (typeof entry.id !== 'string' || !/^[A-Z]+-\d{3,}$/.test(entry.id)) problems.push('invalid-entry-id');
+    else if (ids.has(entry.id)) problems.push('duplicate-entry-id');
+    else ids.add(entry.id);
+    if (!/^[a-f0-9]{64}$/.test(String(entry.fingerprint || ''))) problems.push('invalid-entry-fingerprint');
+    const reasons = normalizeReasons(entry.reasons);
+    const reasonsAreCanonical = Array.isArray(entry.reasons)
+      && entry.reasons.every(reason => typeof reason === 'string' && reason.trim())
+      && JSON.stringify(entry.reasons) === JSON.stringify(reasons);
+    if (!reasons.length || !reasonsAreCanonical) problems.push('invalid-entry-reasons');
+  }
+  if (doc.rawFailedBefore !== (Array.isArray(doc.entries) ? doc.entries.length : -1)) problems.push('failed-count-mismatch');
+  if (!/^sha256:[a-f0-9]{64}$/.test(String(doc.integrity || ''))) problems.push('invalid-integrity-format');
+  else if (doc.integrity !== _integrity(doc)) problems.push('integrity-mismatch');
+  return { ok: problems.length === 0, problems: Array.from(new Set(problems)) };
+}
+
+function loadBaseline(root) {
+  const file = baselinePath(root);
+  if (!exists(file)) return { state: 'absent', file, doc: null, problems: [] };
+  let doc;
+  try { doc = JSON.parse(read(file)); }
+  catch (error) { return { state: 'invalid', file, doc: null, problems: ['invalid-json'], error: error.message }; }
+  const checked = validateBaseline(doc);
+  if (!checked.ok) return { state: 'invalid', file, doc, problems: checked.problems };
+  return { state: 'valid', file, doc, problems: [] };
+}
+
+function buildBaseline(rows, rawResult, options = {}) {
+  const beforeTaskId = String(options.beforeTaskId || '');
+  const boundaryIndex = rows.findIndex(row => row.id === beforeTaskId);
+  if (boundaryIndex < 0) {
+    const error = new Error(`progress-tracker boundary not found: ${beforeTaskId}`);
+    error.code = 'E_CLAIMS_BASELINE_BOUNDARY';
+    throw error;
+  }
+  const eligibleRows = rows.slice(0, boundaryIndex).filter(row => /done|완료|completed/i.test(String(row.status || '')));
+  const eligible = new Map(eligibleRows.map(row => [row.id, row]));
+  const failures = (rawResult.results || []).filter(result => result && !result.ok && eligible.has(result.id));
+  const entries = failures.map(result => ({
+    id: result.id,
+    fingerprint: claimFingerprint(eligible.get(result.id), result.reasons),
+    reasons: normalizeReasons(result.reasons),
+  }));
+  const doc = {
+    schemaVersion: SCHEMA_VERSION,
+    kind: KIND,
+    createdAt: String(options.createdAt || new Date().toISOString()),
+    createdByVersion: String(options.version || 'unknown'),
+    beforeTaskId,
+    policy: POLICY,
+    evaluatedBefore: eligibleRows.length,
+    rawFailedBefore: entries.length,
+    entries,
+  };
+  doc.integrity = _integrity(doc);
+  return {
+    doc,
+    stats: {
+      evaluatedBefore: eligibleRows.length,
+      baselined: entries.length,
+      failuresAtOrAfterBoundary: (rawResult.results || []).filter(result => result && !result.ok && !eligible.has(result.id)).length,
+    },
+  };
+}
+
+function saveBaseline(root, doc, withLock) {
+  const checked = validateBaseline(doc);
+  if (!checked.ok) {
+    const error = new Error(`refusing to write invalid claims baseline: ${checked.problems.join(', ')}`);
+    error.code = 'E_CLAIMS_BASELINE_INVALID';
+    throw error;
+  }
+  const file = baselinePath(root);
+  const write = () => {
+    mkdirp(path.dirname(file));
+    if (exists(file)) {
+      const error = new Error(`claims baseline already exists and will not be overwritten: ${file}`);
+      error.code = 'E_CLAIMS_BASELINE_EXISTS';
+      throw error;
+    }
+    const temp = file + `.tmp-${process.pid}-${Date.now()}`;
+    writeUtf8(temp, JSON.stringify(doc, null, 2) + '\n');
+    try { fs.renameSync(temp, file); }
+    catch (error) {
+      try { fs.rmSync(temp, { force: true }); } catch {}
+      throw error;
+    }
+  };
+  if (typeof withLock === 'function') withLock(file, write);
+  else write();
+  return file;
+}
+
+function _rawResult(rawResult, state, extra = {}) {
+  return {
+    ...rawResult,
+    rawFailed: rawResult.failed,
+    baselined: 0,
+    baseline: { state, ...extra },
+    errors: [],
+  };
+}
+
+function applyBaseline(rows, rawResult, loaded, options = {}) {
+  if (options.raw) return _rawResult(rawResult, 'ignored');
+  if (!loaded || loaded.state === 'absent') return _rawResult(rawResult, 'absent', { file: loaded && loaded.file });
+  if (loaded.state !== 'valid') {
+    return {
+      ..._rawResult(rawResult, 'invalid', { file: loaded.file, problems: loaded.problems || [] }),
+      ok: false,
+      errors: ['baseline-invalid'],
+    };
+  }
+
+  const doc = loaded.doc;
+  const duplicateIds = rows.map(row => row.id).filter((id, index, all) => all.indexOf(id) !== index);
+  const boundaryIndex = rows.findIndex(row => row.id === doc.beforeTaskId);
+  const rowIndex = new Map(rows.map((row, index) => [row.id, index]));
+  const outOfScope = doc.entries.filter(entry => !rowIndex.has(entry.id) || rowIndex.get(entry.id) >= boundaryIndex).map(entry => entry.id);
+  if (boundaryIndex < 0 || duplicateIds.length || outOfScope.length) {
+    const problems = [
+      ...(boundaryIndex < 0 ? ['boundary-missing'] : []),
+      ...(duplicateIds.length ? ['duplicate-progress-id'] : []),
+      ...(outOfScope.length ? ['entry-outside-boundary'] : []),
+    ];
+    return {
+      ..._rawResult(rawResult, 'invalid-context', { file: loaded.file, problems, outOfScope: outOfScope.slice(0, 20) }),
+      ok: false,
+      errors: ['baseline-invalid-context'],
+    };
+  }
+
+  const rowsById = new Map(rows.map(row => [row.id, row]));
+  const entriesById = new Map(doc.entries.map(entry => [entry.id, entry]));
+  let accepted = 0;
+  const mismatched = [];
+  const newFailures = [];
+  const acceptedIds = new Set();
+  const results = (rawResult.results || []).map(result => {
+    if (!result || result.ok) return result;
+    const entry = entriesById.get(result.id);
+    if (!entry) { newFailures.push(result.id); return result; }
+    const fingerprint = claimFingerprint(rowsById.get(result.id), result.reasons);
+    if (fingerprint !== entry.fingerprint) {
+      mismatched.push(result.id);
+      return { ...result, baselineAccepted: false, baselineMismatch: true };
+    }
+    accepted++;
+    acceptedIds.add(result.id);
+    return {
+      ...result,
+      ok: true,
+      rawOk: false,
+      reasons: [],
+      baselineAccepted: true,
+      baselineReasons: normalizeReasons(result.reasons),
+    };
+  });
+  const failed = results.filter(result => result && !result.ok).length;
+  const inactiveEntries = doc.entries.filter(entry => !acceptedIds.has(entry.id) && !mismatched.includes(entry.id)).map(entry => entry.id);
+  return {
+    ok: failed === 0,
+    total: rawResult.total,
+    failed,
+    rawFailed: rawResult.failed,
+    baselined: accepted,
+    results,
+    baseline: {
+      state: 'applied',
+      file: loaded.file,
+      beforeTaskId: doc.beforeTaskId,
+      entries: doc.entries.length,
+      accepted,
+      mismatched: mismatched.slice(0, 20),
+      newFailures: newFailures.slice(0, 20),
+      inactiveEntries: inactiveEntries.slice(0, 20),
+    },
+    errors: [],
+  };
+}
+
+module.exports = {
+  SCHEMA_VERSION,
+  FILE_NAME,
+  baselinePath,
+  normalizeReasons,
+  claimFingerprint,
+  validateBaseline,
+  loadBaseline,
+  buildBaseline,
+  saveBaseline,
+  applyBaseline,
+};

package/lib/mcp-tools.js

@@ -8,7 +8,7 @@ module.exports = [
   { name: 'leerness_drift_check', requiredTier: 'read-only', description: '1.9.136 — AI 에이전트 leerness 미사용 drift 자동 감지 JSON ({ root, score, level, signals[], healthy }). 5+ 신호 + 4단계 레벨 (🟢 healthy / 🟡 warning / 🟠 caution / 🔴 critical). 보안 신호 통합 (1.9.78)', inputSchema: { type: 'object', properties: { path: { type: 'string' } } } },
   { name: 'leerness_audit', requiredTier: 'safe-write', description: '1.9.102 — 워크스페이스 일관성 감사 JSON (warnings/failures/fixed/healthy + findings[]. kind 11종: design_dup/design_system_default/reuse_map_empty/milestone_unlinked/handoff_not_generated/current_state_stale/readme_version_mismatch/npm_cve/gitignore_missing_secrets/env_keys_missing/strict_promoted)', inputSchema: { type: 'object', properties: { path: { type: 'string' }, fix: { type: 'boolean' }, strict: { type: 'boolean' } } } },
   { name: 'leerness_verify_claim', requiredTier: 'read-only', description: 'AI 거짓 완료 자동 검증 (evidence 파일 + 실 테스트 실행). 1.9.309(UR-0048): done/완료 주장은 evidence(수정파일+테스트) 기본 강제 — 증거 없는 done 은 FAIL(exit 1). lenient=true 로 완화, runTests/strictClaims 추가 가능. 응답 verdict.evidenceComplete 포함.', inputSchema: { type: 'object', properties: { taskId: { type: 'string' }, path: { type: 'string' }, runTests: { type: 'boolean' }, strictClaims: { type: 'boolean' }, lenient: { type: 'boolean' }, refereeId: { type: 'string' } }, required: ['taskId'] } },
-  { name: 'leerness_verify_claim_all', requiredTier: 'read-only', description: '1.33.3 — 모든 done/완료 주장을 한 번에 검증(CI·스케일). progress-tracker 의 done 항목 전부를 verify-claim 정밀 검사(파일 존재·스텁·부풀린 카운트·증거 완전성)로 일괄 점검. 응답 { ok, total, failed, results:[{id,ok,reasons}] }. 세션 마감 전 "내 완료 주장 전부 증거와 맞는가?" 자가 점검용. runTests/strictClaims/lenient 추가 가능.', inputSchema: { type: 'object', properties: { path: { type: 'string' }, runTests: { type: 'boolean' }, strictClaims: { type: 'boolean' }, lenient: { type: 'boolean' } } } },
+  { name: 'leerness_verify_claim_all', requiredTier: 'read-only', description: '1.33.3/1.36.167 — 모든 done/완료 주장을 한 번에 검증(CI·스케일). 명시적 claims baseline이 있으면 exact 행+실패사유 지문이 같은 경계 이전 레거시 부채만 격리하고 새/변경 실패는 계속 차단한다. 응답 { ok, total, failed, rawFailed, baselined, baseline, results }. raw=true면 baseline을 무시하고 원판정을 감사한다.', inputSchema: { type: 'object', properties: { path: { type: 'string' }, runTests: { type: 'boolean' }, strictClaims: { type: 'boolean' }, lenient: { type: 'boolean' }, raw: { type: 'boolean' } } } },
   { name: 'leerness_contract_verify', requiredTier: 'read-only', description: '명세 ↔ 구현 함수/필드 일치 자동 검사', inputSchema: { type: 'object', properties: { spec: { type: 'string' }, impl: { type: 'string' } }, required: ['spec', 'impl'] } },
   { name: 'leerness_agents_list', requiredTier: 'read-only', description: '외부 AI CLI 가용성 표 (claude/codex/agy/copilot 상태 + 환경변수 활성화 여부)', inputSchema: { type: 'object', properties: {} } },
   { name: 'leerness_reuse_map', requiredTier: 'read-only', description: '워크스페이스 중복 함수/capability 자동 감지 (--all-apps + fuzzy 매칭)', inputSchema: { type: 'object', properties: { path: { type: 'string' }, allApps: { type: 'boolean' }, strictElements: { type: 'boolean' } } } },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leerness",
-  "version": "1.36.166",
+  "version": "1.36.167",
   "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",
@@ -50,7 +50,7 @@
   "scripts": {
     "test": "node ./scripts/lint.js && node ./scripts/workspace-dir-source-ratchet.js && node ./scripts/workspace-dir-migration-probe.js && node ./scripts/lock-probe.js && node ./scripts/platform-smoke.js && node ./scripts/verify-code-cross-runtime-probe.js && node ./scripts/release-runtime-probe.js && node ./bin/leerness.js --version && node ./bin/leerness.js selftest && node ./scripts/e2e-core.js && node ./scripts/handoff-readonly-probe.js && npm run test:commands && npm run test:installed && node ./scripts/e2e.js",
     "test:core": "node ./scripts/lint.js && node ./scripts/workspace-dir-source-ratchet.js && node ./scripts/workspace-dir-migration-probe.js && node ./scripts/lock-probe.js && node ./scripts/platform-smoke.js && node ./scripts/verify-code-cross-runtime-probe.js && node ./scripts/release-runtime-probe.js && node ./bin/leerness.js --version && node ./bin/leerness.js selftest && node ./scripts/e2e-core.js && node ./scripts/handoff-readonly-probe.js",
-    "test:commands": "node ./scripts/command-flags-probe.js && node ./scripts/e2e-command-surface.js",
+    "test:commands": "node ./scripts/command-flags-probe.js && node ./scripts/claims-baseline-probe.js && node ./scripts/claims-baseline-concurrency-probe.js && node ./scripts/e2e-command-surface.js",
     "test:installed": "node ./scripts/installed-cleanroom-probe.js",
     "test:handoff": "node ./scripts/handoff-readonly-probe.js",
     "test:fast": "node ./scripts/lint.js && node ./scripts/workspace-dir-source-ratchet.js && node ./scripts/workspace-dir-migration-probe.js && node ./scripts/lock-probe.js && node ./scripts/platform-smoke.js && node ./scripts/release-runtime-probe.js && node ./scripts/smoke.js",

package/scripts/claims-baseline-concurrency-probe.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+'use strict';
+
+// T-0145 multi-session regression: two first-time creators may both observe
+// "absent", but the create-only check inside the file lock must let exactly
+// one policy win and must never overwrite that winner.
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const cp = require('child_process');
+
+const CLI = path.resolve(__dirname, '..', 'bin', 'leerness.js');
+const env = {
+  ...process.env,
+  LEERNESS_OFFLINE: '1',
+  LEERNESS_NO_PROMPT: '1',
+  LEERNESS_NO_AUTOCHCP: '1',
+  LEERNESS_NO_AUTO_ROADMAP: '1',
+  LEERNESS_NO_STALE_CHECK: '1',
+  LEERNESS_INTERNAL: '1',
+};
+
+function run(root, args, timeout = 90000) {
+  return cp.spawnSync(process.execPath, [CLI, ...args, '--path', root], {
+    cwd: root,
+    encoding: 'utf8',
+    timeout,
+    env,
+  });
+}
+
+function spawnRun(root, args) {
+  return new Promise(resolve => {
+    const child = cp.spawn(process.execPath, [CLI, ...args, '--path', root], {
+      cwd: root,
+      env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', chunk => { stdout += chunk; });
+    child.stderr.on('data', chunk => { stderr += chunk; });
+    child.on('error', error => resolve({ status: null, stdout, stderr, error }));
+    child.on('close', status => resolve({ status, stdout, stderr }));
+  });
+}
+
+function json(result) {
+  try { return JSON.parse(result.stdout || ''); } catch { return null; }
+}
+
+function digest(file) {
+  return crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+}
+
+const failures = [];
+function check(label, condition, result) {
+  if (condition) { console.log(`✓ ${label}`); return; }
+  failures.push(label);
+  const detail = result ? `\n  ${JSON.stringify(result).slice(0, 1000)}` : '';
+  console.log(`✗ ${label}${detail}`);
+}
+
+async function main() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-claims-baseline-race-'));
+  try {
+    let result = cp.spawnSync(process.execPath, [CLI, 'init', root, '--yes', '--no-enforce', '--no-stale-check'], {
+      cwd: root, encoding: 'utf8', timeout: 90000, env,
+    });
+    check('concurrency fixture init succeeds', result.status === 0, result);
+
+    result = run(root, ['task', 'add', 'legacy one']);
+    const legacyOne = (result.stdout.match(/T-\d{4,}/) || [])[0];
+    result = run(root, ['task', 'update', legacyOne, '--status', 'done', '--evidence', 'ghost-one.js implemented and tested', '--next', 'legacy']);
+    check('first legacy failure fixture is ready', result.status === 0 && !!legacyOne, result);
+
+    result = run(root, ['task', 'add', 'first boundary']);
+    const boundaryOne = (result.stdout.match(/T-\d{4,}/) || [])[0];
+    result = run(root, ['task', 'add', 'legacy two']);
+    const legacyTwo = (result.stdout.match(/T-\d{4,}/) || [])[0];
+    result = run(root, ['task', 'update', legacyTwo, '--status', 'done', '--evidence', 'ghost-two.js implemented and tested', '--next', 'legacy']);
+    check('second legacy failure fixture is ready', result.status === 0 && !!legacyTwo, result);
+
+    result = run(root, ['task', 'add', 'second boundary']);
+    const boundaryTwo = (result.stdout.match(/T-\d{4,}/) || [])[0];
+    check('two distinct policy boundaries are ready', result.status === 0 && !!boundaryOne && !!boundaryTwo, result);
+
+    const contenders = await Promise.all([
+      spawnRun(root, ['verify-claim', 'baseline', 'create', '--before', boundaryOne, '--yes', '--json']),
+      spawnRun(root, ['verify-claim', 'baseline', 'create', '--before', boundaryTwo, '--yes', '--json']),
+    ]);
+    const winners = contenders.filter(item => item.status === 0 && json(item)?.ok === true);
+    const losers = contenders.filter(item => item.status === 1 && json(item)?.code === 'baseline_exists');
+    check('two concurrent creators produce exactly one winner and one baseline_exists loser',
+      winners.length === 1 && losers.length === 1,
+      contenders);
+
+    const baselineFile = path.join(root, '.leerness', 'claims-baseline.json');
+    const stored = fs.existsSync(baselineFile) ? JSON.parse(fs.readFileSync(baselineFile, 'utf8')) : null;
+    const winner = json(winners[0] || {});
+    check('stored policy is exactly the reported winner, never a mixed or overwritten document',
+      stored && winner && stored.beforeTaskId === winner.beforeTaskId
+        && stored.integrity === winner.integrity && stored.entries.length === winner.baselined,
+      { stored, winner });
+
+    const winnerHash = fs.existsSync(baselineFile) ? digest(baselineFile) : null;
+    result = run(root, ['verify-claim', 'baseline', 'create', '--before', boundaryTwo, '--yes', '--json']);
+    check('later retries remain create-only and preserve the winning bytes',
+      result.status === 1 && json(result)?.code === 'baseline_exists'
+        && winnerHash && digest(baselineFile) === winnerHash,
+      result);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+
+  if (failures.length) {
+    console.log(`CLAIMS_BASELINE_CONCURRENCY_PROBE_FAILED: ${failures.join('; ')}`);
+    process.exitCode = 1;
+  } else {
+    console.log('claims baseline concurrency probe passed');
+  }
+}
+
+main().catch(error => {
+  console.error(error && error.stack || error);
+  process.exitCode = 1;
+});

package/scripts/claims-baseline-probe.js

@@ -0,0 +1,263 @@
+#!/usr/bin/env node
+'use strict';
+
+// T-0145 regression probe: a reviewed legacy debt boundary unblocks only exact
+// historical failures. Raw/per-task audits, changed rows, new failures, invalid
+// input, and corrupt stores must all remain fail-closed.
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const cp = require('child_process');
+const claimsBaseline = require('../lib/claims-baseline');
+
+const CLI = path.resolve(__dirname, '..', 'bin', 'leerness.js');
+const env = {
+  ...process.env,
+  LEERNESS_OFFLINE: '1',
+  LEERNESS_NO_PROMPT: '1',
+  LEERNESS_NO_AUTOCHCP: '1',
+  LEERNESS_NO_AUTO_ROADMAP: '1',
+  LEERNESS_NO_STALE_CHECK: '1',
+  LEERNESS_INTERNAL: '1',
+};
+
+function run(root, args, timeout = 60000) {
+  return cp.spawnSync(process.execPath, [CLI, ...args, '--path', root], {
+    cwd: root,
+    encoding: 'utf8',
+    timeout,
+    env,
+  });
+}
+
+function json(result) {
+  try { return JSON.parse(result.stdout || ''); } catch { return null; }
+}
+
+function digest(file) {
+  return crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+}
+
+function canonical(value) {
+  if (Array.isArray(value)) return '[' + value.map(canonical).join(',') + ']';
+  if (value && typeof value === 'object') {
+    return '{' + Object.keys(value).sort().map(key => JSON.stringify(key) + ':' + canonical(value[key])).join(',') + '}';
+  }
+  return JSON.stringify(value);
+}
+
+function withIntegrity(doc) {
+  const unsigned = { ...doc };
+  delete unsigned.integrity;
+  return {
+    ...unsigned,
+    integrity: 'sha256:' + crypto.createHash('sha256').update(canonical(unsigned)).digest('hex'),
+  };
+}
+
+const failures = [];
+function check(label, condition, result) {
+  if (condition) { console.log(`✓ ${label}`); return; }
+  failures.push(label);
+  const detail = result ? `\n  exit=${result.status}\n  stdout=${String(result.stdout || '').slice(0, 800)}\n  stderr=${String(result.stderr || '').slice(0, 400)}` : '';
+  console.log(`✗ ${label}${detail}`);
+}
+
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-claims-baseline-'));
+try {
+  let result = cp.spawnSync(process.execPath, [CLI, 'init', root, '--yes', '--no-enforce', '--no-stale-check'], {
+    cwd: root, encoding: 'utf8', timeout: 90000, env,
+  });
+  check('fixture init succeeds', result.status === 0, result);
+
+  fs.writeFileSync(path.join(root, 'calc.js'), 'function add(a,b){return a+b}\nmodule.exports={add}\n', 'utf8');
+  fs.mkdirSync(path.join(root, 'tests'), { recursive: true });
+  fs.writeFileSync(path.join(root, 'tests', 'calc.test.js'), 'const {add}=require("../calc.js");\ntest("a",()=>{if(add(1,2)!==3)throw 0});\n', 'utf8');
+
+  result = run(root, ['task', 'add', 'legacy calc claim']);
+  const legacyId = (result.stdout.match(/T-\d{4,}/) || [])[0];
+  result = run(root, ['task', 'update', legacyId, '--status', 'done', '--evidence', 'calc.js + tests/calc.test.js 테스트 50개 통과', '--next', 'legacy next']);
+  check('legacy false claim fixture is created', result.status === 0 && !!legacyId, result);
+  result = run(root, ['task', 'add', 'new work boundary']);
+  const boundaryId = (result.stdout.match(/T-\d{4,}/) || [])[0];
+  check('explicit non-done boundary fixture is created', result.status === 0 && !!boundaryId, result);
+
+  // Keep the five heuristic gate checks clean so --claims is the only failing dimension.
+  fs.writeFileSync(path.join(root, '.leerness', 'session-handoff.md'), '# Handoff\nLast generated: 2026-08-26T00:00:00Z\n\n## Completed\n- calc.js add() 구현 + 테스트\n\n## Next Exact Step\n- migration\n', 'utf8');
+  fs.writeFileSync(path.join(root, '.leerness', 'review-evidence.md'), '# Evidence\n## Test run\n- npm test: 1/1 passing\n', 'utf8');
+
+  const tracker = path.join(root, '.leerness', 'progress-tracker.md');
+  const trackerText = fs.readFileSync(tracker, 'utf8');
+  const trackerHash = digest(tracker);
+  const baselineFile = path.join(root, '.leerness', 'claims-baseline.json');
+
+  const beforeGate = run(root, ['gate', '.', '--claims', '--json'], 120000);
+  const beforeGateJson = json(beforeGate);
+  const beforeClaimCheck = beforeGateJson?.checks?.find(row => row.name === 'verify-claims');
+  check('gate --claims reproduces the legacy-only failure before migration',
+    beforeGate.status === 1 && beforeClaimCheck?.ok === false && beforeClaimCheck?.rawFailed === 1,
+    beforeGate);
+
+  result = run(root, ['verify-claim', 'baseline', 'create', '--before', boundaryId, '--json']);
+  check('baseline creation requires explicit --yes and writes nothing on refusal',
+    result.status === 1 && json(result)?.code === 'confirmation_required' && !fs.existsSync(baselineFile),
+    result);
+
+  result = run(root, ['verify-claim', 'baseline', 'create', '--before', 'T-9999', '--yes', '--json']);
+  check('unknown boundary fails before writing a baseline',
+    result.status === 1 && json(result)?.code === 'boundary_not_found' && !fs.existsSync(baselineFile),
+    result);
+
+  result = run(root, ['verify-claim', 'baseline', 'create', '--before', boundaryId, '--yes', '--json']);
+  const created = json(result);
+  check('baseline creation isolates only the failed row before the explicit boundary',
+    result.status === 0 && created?.ok === true && created?.baselined === 1
+      && created?.beforeTaskId === boundaryId && created?.historicalEvidenceModified === false
+      && fs.existsSync(baselineFile),
+    result);
+  check('baseline creation does not rewrite tracker rows or historical evidence',
+    digest(tracker) === trackerHash && fs.readFileSync(tracker, 'utf8') === trackerText);
+  const stored = JSON.parse(fs.readFileSync(baselineFile, 'utf8'));
+  check('baseline stores fingerprints/reasons, not replacement evidence',
+    stored.entries?.length === 1 && stored.entries[0].id === legacyId
+      && /^[a-f0-9]{64}$/.test(stored.entries[0].fingerprint)
+      && !JSON.stringify(stored).includes('테스트 50개'));
+
+  const casRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-claims-baseline-cas-'));
+  try {
+    let winnerHash = null;
+    let raceCode = null;
+    try {
+      claimsBaseline.saveBaseline(casRoot, stored, (target, write) => {
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        fs.writeFileSync(target, 'concurrent-winner\n', 'utf8');
+        winnerHash = digest(target);
+        return write();
+      });
+    } catch (error) { raceCode = error && error.code; }
+    const target = claimsBaseline.baselinePath(casRoot);
+    check('create-only CAS rechecks destination absence inside the acquired lock',
+      raceCode === 'E_CLAIMS_BASELINE_EXISTS' && digest(target) === winnerHash);
+  } finally {
+    fs.rmSync(casRoot, { recursive: true, force: true });
+  }
+
+  result = run(root, ['verify-claim', '--all', '--json']);
+  const applied = json(result);
+  check('default aggregate verification applies exact legacy debt and exposes raw counts',
+    result.status === 0 && applied?.ok === true && applied?.rawFailed === 1
+      && applied?.baselined === 1 && applied?.failed === 0
+      && applied?.results?.find(row => row.id === legacyId)?.baselineAccepted === true,
+    result);
+
+  result = run(root, ['verify-claim', '--all', '--raw', '--json']);
+  const raw = json(result);
+  check('--raw preserves the original failing verdict',
+    result.status === 1 && raw?.ok === false && raw?.failed === 1
+      && raw?.baselined === 0 && raw?.baseline?.state === 'ignored',
+    result);
+
+  result = run(root, ['verify-claim', legacyId, '--json']);
+  check('per-task verification always remains raw',
+    result.status === 1 && json(result)?.ok === false && !json(result)?.baselineAccepted,
+    result);
+
+  const afterGate = run(root, ['gate', '.', '--claims', '--json'], 120000);
+  const afterGateJson = json(afterGate);
+  const afterClaimCheck = afterGateJson?.checks?.find(row => row.name === 'verify-claims');
+  check('gate --claims is unblocked only through visible legacy-debt accounting',
+    afterGate.status === 0 && afterGateJson?.ok === true && afterClaimCheck?.ok === true
+      && afterClaimCheck?.rawFailed === 1 && afterClaimCheck?.baselined === 1 && afterClaimCheck?.failed === 0,
+    afterGate);
+
+  result = run(root, ['verify-claim', 'baseline', 'show', '--json']);
+  check('baseline show returns the integrity-bound policy document',
+    result.status === 0 && json(result)?.state === 'valid'
+      && json(result)?.baseline?.beforeTaskId === boundaryId,
+    result);
+
+  const changedTracker = trackerText.replace('| legacy next |', '| changed metadata |');
+  fs.writeFileSync(tracker, changedTracker, 'utf8');
+  result = run(root, ['verify-claim', '--all', '--json']);
+  const changed = json(result);
+  check('any historical tracker-row change invalidates that exemption',
+    result.status === 1 && changed?.baselined === 0 && changed?.failed === 1
+      && changed?.baseline?.mismatched?.includes(legacyId),
+    result);
+  const baselineHashBeforeRetry = digest(baselineFile);
+  result = run(root, ['verify-claim', 'baseline', 'create', '--before', boundaryId, '--yes', '--json']);
+  check('baseline create cannot relaunder a changed historical row by overwriting policy',
+    result.status === 1 && json(result)?.code === 'baseline_exists'
+      && digest(baselineFile) === baselineHashBeforeRetry,
+    result);
+  result = run(root, ['verify-claim', '--all', '--json']);
+  check('a refused baseline recreation leaves the changed row blocked',
+    result.status === 1 && json(result)?.baseline?.mismatched?.includes(legacyId),
+    result);
+  result = run(root, ['gate', '.', '--claims', '--json'], 120000);
+  const changedGateCheck = json(result)?.checks?.find(row => row.name === 'verify-claims');
+  check('gate JSON preserves baseline mismatch diagnostics',
+    result.status === 1 && changedGateCheck?.baseline?.mismatched?.includes(legacyId),
+    result);
+  fs.writeFileSync(tracker, trackerText, 'utf8');
+
+  result = run(root, ['task', 'add', 'new false claim']);
+  const newId = (result.stdout.match(/T-\d{4,}/) || [])[0];
+  result = run(root, ['task', 'update', newId, '--status', 'done', '--evidence', 'ghost.js implemented and tested', '--next', 'none']);
+  check('post-boundary false claim fixture is created', result.status === 0 && !!newId, result);
+  result = run(root, ['verify-claim', '--all', '--json']);
+  const withNew = json(result);
+  check('new failures still block while the unchanged legacy row stays isolated',
+    result.status === 1 && withNew?.rawFailed === 2 && withNew?.baselined === 1
+      && withNew?.failed === 1 && withNew?.baseline?.newFailures?.includes(newId),
+    result);
+  result = run(root, ['gate', '.', '--claims', '--json'], 120000);
+  const newFailureGateCheck = json(result)?.checks?.find(row => row.name === 'verify-claims');
+  check('gate JSON preserves new-failure identifiers',
+    result.status === 1 && newFailureGateCheck?.baseline?.newFailures?.includes(newId),
+    result);
+
+  const corrupt = { ...stored, integrity: 'sha256:' + '0'.repeat(64) };
+  fs.writeFileSync(baselineFile, JSON.stringify(corrupt, null, 2) + '\n', 'utf8');
+  result = run(root, ['verify-claim', '--all', '--json']);
+  check('corrupt baseline fails closed with a distinct machine-readable error',
+    result.status === 1 && json(result)?.ok === false
+      && json(result)?.errors?.includes('baseline-invalid')
+      && json(result)?.baseline?.problems?.includes('integrity-mismatch'),
+    result);
+  result = run(root, ['gate', '.', '--claims', '--json'], 120000);
+  const corruptGateCheck = json(result)?.checks?.find(row => row.name === 'verify-claims');
+  check('gate JSON preserves corrupt-baseline problems',
+    result.status === 1 && corruptGateCheck?.errors?.includes('baseline-invalid')
+      && corruptGateCheck?.baseline?.problems?.includes('integrity-mismatch'),
+    result);
+  result = run(root, ['verify-claim', '--all', '--raw', '--json']);
+  check('raw audit remains available even when the baseline store is corrupt',
+    result.status === 1 && json(result)?.baseline?.state === 'ignored'
+      && json(result)?.errors?.length === 0 && json(result)?.rawFailed === 2,
+    result);
+  result = run(root, ['verify-claim', 'baseline', 'show', '--json']);
+  check('baseline show reports corruption instead of silently treating it as absent',
+    result.status === 1 && json(result)?.code === 'baseline_invalid',
+    result);
+
+  const nonCanonical = withIntegrity({
+    ...stored,
+    entries: stored.entries.map(entry => ({ ...entry, reasons: [...entry.reasons, entry.reasons[0]] })),
+  });
+  fs.writeFileSync(baselineFile, JSON.stringify(nonCanonical, null, 2) + '\n', 'utf8');
+  result = run(root, ['verify-claim', '--all', '--json']);
+  check('non-canonical reasons fail closed even with a recomputed document integrity hash',
+    result.status === 1 && json(result)?.baseline?.problems?.includes('invalid-entry-reasons'),
+    result);
+} finally {
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+if (failures.length) {
+  console.log(`CLAIMS_BASELINE_PROBE_FAILED: ${failures.join('; ')}`);
+  process.exitCode = 1;
+} else {
+  console.log('claims baseline probe passed');
+}

package/scripts/command-flags-probe.js

@@ -270,6 +270,26 @@ try {
   check('verify-claim retains its supported --test-cmd contract',
     claimOwnsTestCommand.status === 1 && json(claimOwnsTestCommand)?.code !== 'unknown_flag',
     claimOwnsTestCommand);
+
+  const claimRaw = run(['verify-claim', '--all', '--raw', '--path', emptyProject, '--json']);
+  check('verify-claim --all retains its supported raw-audit contract',
+    claimRaw.status === 0 && json(claimRaw)?.baseline?.state === 'ignored',
+    claimRaw);
+
+  const claimForeignBoundary = run(['verify-claim', 'T-NOT-FOUND', '--before', 'T-0002', '--path', emptyProject, '--json']);
+  check('per-task verify-claim rejects the baseline-only --before flag',
+    claimForeignBoundary.status === 1 && json(claimForeignBoundary)?.code === 'unknown_flag',
+    claimForeignBoundary);
+
+  const baselineForeignRun = run(['verify-claim', 'baseline', 'show', '--run-tests', '--path', emptyProject, '--json']);
+  check('claims baseline show rejects verification-only mutation flags',
+    baselineForeignRun.status === 1 && json(baselineForeignRun)?.code === 'unknown_flag',
+    baselineForeignRun);
+
+  const gateForeignRaw = run(['gate', emptyProject, '--raw', '--json']);
+  check('gate rejects --raw because raw audit belongs to verify-claim --all',
+    gateForeignRaw.status === 1 && json(gateForeignRaw)?.code === 'unknown_flag',
+    gateForeignRaw);
 } finally {
   fs.rmSync(emptyProject, { recursive: true, force: true });
 }