leerness 1.9.334 → 1.9.336

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## 1.9.336 — 2026-06-05 — UR-0025(심층): anti-laziness 서브시스템 분리 (Codex 위임·검증)
+
+**🤖 anti-laziness(거짓완료 탐지) 서브시스템의 핵심(claim-vs-code 패턴 catalog + 순수 탐지/신뢰도 로직)을 Codex CLI(gpt-5.5)에 위임 분리하고 하네스가 독립 검증까지 완료.** (사용자 "일부 Codex 위임" 지시 — 1.9.334 위임·1.9.335 자체 구현에 이은 교대)
+
+### 배경 (위임 결정)
+constraints(1.9.333)·intent-도메인(1.9.334)·LSP(1.9.335)에 이은 동형 추출 4번째. 프로젝트 핵심인 anti-lazy-work 탐지 로직이라 신중을 기해 blast radius(harness 내 외부 호출 3곳, 교차 참조 0)를 사전 확정 후 정밀 명세로 Codex 에 위임. 위임 ≠ 무검증: 결과를 하네스가 독립 검증(범위·금지파일·구문·중복·호출처·동작·end-to-end) 후 릴리스.
+
+### 구현 (Codex 수행)
+1. **`OPTIMISM_PATTERNS`**(10종 외부작용 claim-vs-code 패턴: API/DB/Email/Webhook/Payment/FileIO/Queue/Cache/Notify/Storage) → `lib/catalogs.js`.
+2. **`_extractUrlClaims`/`_verifyUrlClaim`/`_detectOptimism(patterns, …)`/`_computeConfidence(patterns, …)`**(순수 탐지·신뢰도 로직, patterns 주입) → `lib/pure-utils.js`. harness 는 alias import(`_puDetectOptimism`/`_puComputeConfidence`) + 박막 wrapper(`_detectOptimism(evidence, codeText)` = `_puDetectOptimism(OPTIMISM_PATTERNS, …)`)로 호출처 3곳 시그니처 0변경. fs 의존 `_scanCodeForPatterns` 는 harness 유지.
+
+### 검증 (하네스 독립)
+- **변경 범위**: bin/harness.js + lib/catalogs.js + lib/pure-utils.js 만 (VERSION/e2e/README/CHANGELOG/package.json 미변경 — 명세 금지사항 준수).
+- **무결성**: node -c ×3 통과 · selftest 84/84 PASS · **E2E 281/281 PASS** (회귀 0).
+- **동작 실측**: catalog 10종 · `_detectOptimism`(API claim+코드無 → API/high + URL/medium) · `_computeConfidence` 0.25 · 무claim=1.0 · null guard([]/1.0) · `_extractUrlClaims`/`_verifyUrlClaim` 정상.
+- **end-to-end 동치**: `optimism-check T-9999`(harness wrapper 경로) → suspects [API,URL]·confidence 0.25 — 순수 함수 직접 호출과 완전 일치.
+
+## 1.9.335 — 2026-06-05 — UR-0025(심층): LSP 서브시스템 핵심 분리
+
+**🧩 LSP 정규식 fallback 서브시스템의 핵심(언어별 심볼 패턴 catalog + 순수 언어감지 + 순수 심볼 매처)을 모듈로 분리 — 1.9.333~334 패턴 동일 적용.** (UR-0025 심층)
+
+### 배경
+constraints(1.9.333)·intent-도메인(1.9.334)에 이어 동형(同型) 추출의 세 번째 적용. 검증된 "데이터 catalog → lib/catalogs.js, 순수 매처(catalog 주입) → lib/pure-utils.js, harness 는 박막 wrapper" 패턴을 그대로 반복(결정매트릭스: 기존 패턴 유지·안정성 우선). 직전 라운드 Codex 위임에 이어 이번은 직접 구현(사용자 "일부" 위임 지시 — 적합한 독립 청크 시 재위임).
+
+### 구현 (UR-0025 심층)
+1. **`_LSP_LANG_PATTERNS`**(6언어 JS/TS·Python·Go·Rust·Java 심볼 패턴 catalog) → `lib/catalogs.js`.
+2. **`_detectLspLang(file)`**(순수: 파일 확장자 → 언어) → `lib/pure-utils.js`.
+3. **`_matchLspSymbols(catalog, content, lang)`**(순수 매처: catalog 주입, 라인별 정규식 매칭 + 키워드 false-positive 필터) → `lib/pure-utils.js`. harness `_lspRegexSymbols(content, lang)` = `_matchLspSymbols(_LSP_LANG_PATTERNS, content, lang)` 박막.
+4. selftest 82→83 · e2e 279→280.
+
+### 검증
+- **selftest 83/83 PASS** · **E2E 280/280 PASS** (회귀 0).
+- 실측: catalog 5언어 키 · `_detectLspLang` .py→python/.go→go/.rs→rust/.ts·.md→javascript · `_matchLspSymbols` JS(alpha/fn,Beta/class)·PY(foo/fn,Bar/class)·null guard=[] · `lsp symbols` 명령 end-to-end(helloWorld/MyClass, lang 감지) 정상.
+
 ## 1.9.334 — 2026-06-05 — UR-0025(심층): intent-도메인 서브시스템 분리 (Codex 위임·검증)
 
 **🤖 남은 백로그 일부를 Codex CLI(gpt-5.5)에 위임하고 독립 검증까지 완료 — intent-도메인 서브시스템의 핵심(데이터 catalog + 순수 매처)을 1.9.333 constraints 패턴 그대로 모듈로 분리.** (사용자 지시: "남은 백로그 일부는 codex cli를 호출해서 업무 할당하고 검증까지 진행")

package/README.md

@@ -3,7 +3,7 @@
 > **AI 코딩 에이전트의 거짓 완료·중복·망각·충돌을 막아주는 검수·기억·협업 CLI 하네스.**
 > **A CLI harness that stops AI coding agents from faking completion, duplicating work, forgetting context, and colliding.**
 
-[![npm](https://img.shields.io/badge/npm-leerness-blue)](https://www.npmjs.com/package/leerness) [![version](https://img.shields.io/badge/version-1.9.334-green)]() [![tests](https://img.shields.io/badge/e2e-279%2F279-success)]() [![selftest](https://img.shields.io/badge/selftest-82-success)]() [![mcp](https://img.shields.io/badge/MCP--tools-83-brightgreen)]() [![providers](https://img.shields.io/badge/AI_providers-10-brightgreen)]() [![license](https://img.shields.io/badge/license-MIT-lightgrey)]()
+[![npm](https://img.shields.io/badge/npm-leerness-blue)](https://www.npmjs.com/package/leerness) [![version](https://img.shields.io/badge/version-1.9.336-green)]() [![tests](https://img.shields.io/badge/e2e-281%2F281-success)]() [![selftest](https://img.shields.io/badge/selftest-84-success)]() [![mcp](https://img.shields.io/badge/MCP--tools-83-brightgreen)]() [![providers](https://img.shields.io/badge/AI_providers-10-brightgreen)]() [![license](https://img.shields.io/badge/license-MIT-lightgrey)]()
 
 ```
   ╔══════════════════════════════════════════════════════════════╗
@@ -471,7 +471,7 @@ MIT — © leerness contributors
 <!-- leerness:project-readme:start -->
 ## Leerness Project Harness
 
-이 프로젝트는 Leerness v1.9.334 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
+이 프로젝트는 Leerness v1.9.336 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
 
 ### 정체성 — AI 에이전트 운영 레이어 (UR-0030)
 
@@ -525,7 +525,7 @@ leerness memory restore decision <date|title>
 
 ### MCP server (외부 AI 통합)
 
-Leerness v1.9.334는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **83개 도구**를 노출:
+Leerness v1.9.336는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **83개 도구**를 노출:
 
 ```jsonc
 // 카테고리별
@@ -546,7 +546,7 @@ Leerness v1.9.334는 stdio JSON-RPC MCP server를 내장합니다 — Claude Cod
 `<<autonomous-loop-dynamic>>` 신호만 보내면 AI가:
 1) 다음 라운드 후보 선정 → 2) 코드 변경 → 3) stress-v* 신규 작성 + 누적 회귀 → 4) e2e 219/219 → 5) npm pack + git tag + GitHub release → 6) main 자동 push (1.9.140+) → 7) session close → 8) 다음 라운드 예약.
 
-현재 누적: **70 라운드 (1.9.40 → 1.9.334)** · 매 라운드 GitHub release/태그 생성 · _reports/는 비공개 보존.
+현재 누적: **70 라운드 (1.9.40 → 1.9.336)** · 매 라운드 GitHub release/태그 생성 · _reports/는 비공개 보존.
 
 ### 성능 가이드 (1.9.140 측정)
 
@@ -584,6 +584,6 @@ leerness release pack --close --auto-main-push
 - `.harness/session-handoff.md`: 다음 세션 인수인계 (자동 작성)
 - `.harness/lessons.md` / `decisions.md` / `rules.md`: 영구 메모리 (5 surface)
 
-Last synced by Leerness v1.9.334: 2026-06-05
+Last synced by Leerness v1.9.336: 2026-06-05
 <!-- leerness:project-readme:end -->
 

package/bin/harness.js

@@ -16,13 +16,15 @@ const { _isSecretKey, compareVer, parseHarnessVersion, _classifyCJK, _riskLabel,
   _roadmapMapStatus, _roadmapParseMilestones, _roadmapParseTokens,
   _BRIEF_FIELDS, _briefFilled,
   BRIEF_START, BRIEF_END, _briefReadmeBlock, _briefBlueprint,
-  _parseLessonEntries, _matchConstraints, _matchDomain } = require('../lib/pure-utils');  // 1.9.318~333 (UR-0025): 순수 유틸 모듈 분리
+  _parseLessonEntries, _matchConstraints, _matchDomain,
+  _detectLspLang, _matchLspSymbols,
+  _detectOptimism: _puDetectOptimism, _computeConfidence: _puComputeConfidence } = require('../lib/pure-utils');  // 1.9.318~335 (UR-0025): 순수 유틸 모듈 분리
 // 1.9.304 (UR-0025): 순수 분석/검증 함수 모듈 분리.
 const { _evidenceQuality, _parseEvidenceStats, _shellGuardAnalyze, _claimFileInGit, _epistemicHonestyCheck } = require('../lib/analyzers');
 // 1.9.295 (UR-0025 4단계): 정적 데이터 카탈로그 모듈 분리 (비파괴, require-based).
-const { CAPABILITY_SURFACE, POWERFUL_COMMANDS, ADAPTERS, REUSE_CATEGORIES, REUSE_CHECKLIST, _DEFAULT_PLATFORM_CONSTRAINTS, _DEFAULT_DOMAIN_CATALOG } = require('../lib/catalogs');  // 1.9.333 (UR-0025): constraints catalog 분리
+const { CAPABILITY_SURFACE, POWERFUL_COMMANDS, ADAPTERS, REUSE_CATEGORIES, REUSE_CHECKLIST, _DEFAULT_PLATFORM_CONSTRAINTS, _DEFAULT_DOMAIN_CATALOG, _LSP_LANG_PATTERNS, OPTIMISM_PATTERNS } = require('../lib/catalogs');  // 1.9.335 (UR-0025): LSP 패턴 catalog 분리
 
-const VERSION = '1.9.334';
+const VERSION = '1.9.336';
 
 // 1.9.290 (UR-0037, Codex gpt-5.5 #4 수렴): CLI 전용 부작용은 require 시 실행하지 않는다.
 //   이전: warning listener 제거 / NODE_OPTIONS 변경 / chcp IIFE 가 top-level 즉시 실행 → require('harness') 시 호스트 프로세스 오염.
@@ -3079,6 +3081,8 @@ function _selfTestCases() {
     { name: 'lib/pure-utils: lessons.md 파서 분리(_parseLessonEntries) + 인라인 제거 (UR-0025 1.9.332)', run: () => { const m = require('../lib/pure-utils'); const r = m._parseLessonEntries('### 2026-06-05\n- Lesson: A\n- Tag: t\n\n### 2026-06-04\n- Lesson: B'); const work = r.length === 2 && r[0].text === 'A' && r[0].tag === 't' && r[1].tag === null && r[0].date === '2026-06-05'; const src = read(__filename); const moved = m._parseLessonEntries === _parseLessonEntries && !/^function _parseLessonEntries\(/m.test(src) && src.includes('for (const lesson of _parseLessonEntries(text))'); return work && moved; } },
     { name: 'UR-0025 심층: constraints catalog→lib/catalogs + _matchConstraints→pure-utils 분리 (1.9.333)', run: () => { const c = require('../lib/catalogs'); const m = require('../lib/pure-utils'); const catOk = c._DEFAULT_PLATFORM_CONSTRAINTS && Object.keys(c._DEFAULT_PLATFORM_CONSTRAINTS.platforms).length === 6 && !!c._DEFAULT_PLATFORM_CONSTRAINTS.platforms.stripe; const r = m._matchConstraints(c._DEFAULT_PLATFORM_CONSTRAINTS, 'stripe 결제'); const work = r.matched.length === 1 && r.matched[0].platform === 'stripe' && r.totalPlatforms === 6 && m._matchConstraints(null, 'x').matched.length === 0; const src = read(__filename); const moved = _DEFAULT_PLATFORM_CONSTRAINTS === c._DEFAULT_PLATFORM_CONSTRAINTS && _matchConstraints === m._matchConstraints && !/const _DEFAULT_PLATFORM_CONSTRAINTS = \{/.test(src) && src.includes('_matchConstraints(_loadPlatformConstraints(root), text)'); return catOk && work && moved; } },
     { name: 'UR-0025 심층(Codex 위임·검증): intent domain catalog→lib/catalogs + _matchDomain→pure-utils 분리 (1.9.334)', run: () => { const c = require('../lib/catalogs'); const m = require('../lib/pure-utils'); const catOk = c._DEFAULT_DOMAIN_CATALOG && Object.keys(c._DEFAULT_DOMAIN_CATALOG.domains).length === 5 && !!c._DEFAULT_DOMAIN_CATALOG.domains.game; const r = m._matchDomain(c._DEFAULT_DOMAIN_CATALOG, 'unity 게임'); const work = r.domain === 'game' && Array.isArray(r.components) && m._matchDomain(c._DEFAULT_DOMAIN_CATALOG, 'zzz없음').domain === null && m._matchDomain(null, 'x').domain === null; const src = read(__filename); const moved = _DEFAULT_DOMAIN_CATALOG === c._DEFAULT_DOMAIN_CATALOG && _matchDomain === m._matchDomain && !/const _DEFAULT_DOMAIN_CATALOG = \{/.test(src) && src.includes('_matchDomain(_loadDomainCatalog(root), text)'); return catOk && work && moved; } },
+    { name: 'UR-0025 심층: LSP catalog→lib/catalogs(_LSP_LANG_PATTERNS) + _detectLspLang/_matchLspSymbols→pure-utils 분리 (1.9.335)', run: () => { const c = require('../lib/catalogs'); const m = require('../lib/pure-utils'); const catOk = c._LSP_LANG_PATTERNS && Object.keys(c._LSP_LANG_PATTERNS).length === 5 && Array.isArray(c._LSP_LANG_PATTERNS.javascript); const langOk = m._detectLspLang('a.py') === 'python' && m._detectLspLang('b.go') === 'go' && m._detectLspLang('c.md') === 'javascript'; const sy = m._matchLspSymbols(c._LSP_LANG_PATTERNS, 'function alpha(){}\nclass Beta{}', 'javascript'); const work = sy.length === 2 && sy[0].name === 'alpha' && sy[0].kind === 'function' && sy[1].kind === 'class' && m._matchLspSymbols(null, 'x', 'javascript').length === 0; const src = read(__filename); const moved = _LSP_LANG_PATTERNS === c._LSP_LANG_PATTERNS && _detectLspLang === m._detectLspLang && _matchLspSymbols === m._matchLspSymbols && !/const _LSP_LANG_PATTERNS = \{/.test(src) && !/function _detectLspLang\(/.test(src); return catOk && langOk && work && moved; } },
+    { name: 'UR-0025 심층(Codex 위임·검증): anti-laziness catalog→lib/catalogs(OPTIMISM_PATTERNS) + optimism 순수로직→pure-utils 분리 (1.9.336)', run: () => { const c = require('../lib/catalogs'); const m = require('../lib/pure-utils'); const catOk = Array.isArray(c.OPTIMISM_PATTERNS) && c.OPTIMISM_PATTERNS.length === 10 && c.OPTIMISM_PATTERNS[0].kind === 'API'; const ev = 'API 호출 완료, POST /users'; const sus = m._detectOptimism(c.OPTIMISM_PATTERNS, ev, 'function x(){}'); const conf = m._computeConfidence(c.OPTIMISM_PATTERNS, ev, 'function x(){}'); const work = sus.some(s => s.kind === 'API' && s.severity === 'high') && conf < 0.5 && m._computeConfidence(c.OPTIMISM_PATTERNS, '정리함', 'x') === 1 && m._detectOptimism(null, ev, 'x').length === 0 && m._extractUrlClaims('POST /a').length === 1 && m._verifyUrlClaim({ path: '/a' }, 'has /a') === true; const src = read(__filename); const moved = OPTIMISM_PATTERNS === c.OPTIMISM_PATTERNS && _puDetectOptimism === m._detectOptimism && !/const OPTIMISM_PATTERNS = \[/.test(src) && !/function _extractUrlClaims\(/.test(src); return catOk && work && moved; } },
     { name: 'VERSION 형식 (x.y.z)', run: () => /^\d+\.\d+\.\d+$/.test(VERSION) }
   ];
 }
@@ -9994,59 +9998,10 @@ function depsImpactCmd(root, targetCapability) {
 //   evidence에 "DB 저장" / "insert N건" / "DB에" → db.*/pg.*/mysql.*/mongoose.*/prisma.* 없으면 의심
 //   evidence에 "이메일 발송" / "메일 전송" → sendMail/nodemailer/smtp 없으면 의심
 // 1.9.27: 패턴 카탈로그 확장 (5 → 10) + URL/메서드 단위 매핑 추가
-const OPTIMISM_PATTERNS = [
-  { kind: 'API',     evidenceRe: /(API\s*호출|HTTP\s*\d{3}|POST\s*\/|GET\s*\/|PUT\s*\/|DELETE\s*\/|fetch|REST 응답|응답 확인|endpoint|엔드포인트)/i,
-    codeRe: /\b(fetch\s*\(|http\.request|https\.request|axios\.|got\.|undici|node-fetch)/i,
-    label: 'API/HTTP 호출' },
-  { kind: 'DB',      evidenceRe: /(DB에?\s*저장|insert\s+\d+|데이터베이스|SQL\s*(INSERT|UPDATE|DELETE)|migration|마이그레이션 적용)/i,
-    codeRe: /\b(db\.|pg\.|pool\.|mysql\.|mongoose\.|prisma\.|sequelize|knex|sqlite3|MongoClient|createConnection)/i,
-    label: 'DB 호출' },
-  { kind: 'Email',   evidenceRe: /(이메일[^.\n]{0,30}(발송|전송|보냈|보냄|완료)|메일[^.\n]{0,30}(발송|전송|보냈|보냄)|sendMail|smtp\s*(전송|발송))/i,
-    codeRe: /\b(sendMail|nodemailer|smtp|@sendgrid|mailgun|aws-sdk\/ses|resend\.)/i,
-    label: '이메일 전송' },
-  { kind: 'Webhook', evidenceRe: /(웹훅\s*(호출|전송|발송)|webhook\s+(sent|posted|triggered))/i,
-    codeRe: /\b(fetch\s*\(|http\.request|axios\.)/i,
-    label: '웹훅' },
-  { kind: 'Payment', evidenceRe: /(결제\s*(완료|성공|승인|취소)|payment\s+(processed|charged)|stripe 결제|toss\s*결제|카카오페이|네이버페이|kakaopay|nicepay|iamport 결제|페이팔|paypal)/i,
-    codeRe: /\b(stripe|toss|@stripe|tosspayments|iamport|kakao|nicepay|naverpay|paypal-rest-sdk|@paypal)/i,
-    label: '결제' },
-  // 1.9.27 신규 카테고리
-  { kind: 'FileIO',  evidenceRe: /(파일[^.\n]{0,20}(생성|저장|작성|기록)|\d+개[^.\n]{0,20}파일|디스크[^.\n]{0,20}저장|로그 파일 작성)/i,
-    codeRe: /\b(fs\.write|fs\.appendFile|writeFileSync|appendFileSync|fs\/promises|fs\.createWriteStream)/i,
-    label: '파일 I/O 쓰기' },
-  { kind: 'Queue',   evidenceRe: /(메시지\s*큐|발행\s*완료|publish\s*(완료|성공)|RabbitMQ|Kafka|SQS|Redis Pub|이벤트 발행)/i,
-    codeRe: /\b(amqp|kafkajs|rabbit|redis\.(publish|xadd)|@aws-sdk\/client-sqs|bull|bullmq)/i,
-    label: '메시지 큐 발행' },
-  { kind: 'Cache',   evidenceRe: /(Redis[^.\n]{0,20}(저장|set|get)|캐시[^.\n]{0,20}(저장|기록|적중)|memcache)/i,
-    codeRe: /\b(redis\.|ioredis|memcached|node-cache|@upstash\/redis|connect-redis)/i,
-    label: '캐시 저장' },
-  { kind: 'Notify',  evidenceRe: /(슬랙\s*(알림|발송|전송)|Slack\s+(notification|sent|posted)|Discord\s+(알림|발송|webhook)|푸시 알림 전송)/i,
-    codeRe: /\b(@slack\/web-api|slack-webhook|discord\.js|discord-webhook|@discordjs|firebase\/messaging|expo-notifications)/i,
-    label: '슬랙/Discord 알림' },
-  { kind: 'Storage', evidenceRe: /(S3\s*(업로드|저장)|GCS\s*업로드|Azure Blob|클라우드 스토리지 업로드|object storage 저장)/i,
-    codeRe: /\b(@aws-sdk\/client-s3|aws-sdk[^a-z]|@google-cloud\/storage|@azure\/storage-blob|aws-s3)/i,
-    label: '클라우드 스토리지' }
-];
+// OPTIMISM_PATTERNS moved to lib/catalogs.js (UR-0057).
 
 // 1.9.27: URL/메서드 단위 매핑 — evidence에서 "POST /users" 같은 구체 경로를 추출하고 코드에 같은 경로 존재 확인
-function _extractUrlClaims(evidence) {
-  const claims = [];
-  // "POST /users" / "GET /api/v1/items" 등
-  const re = /\b(GET|POST|PUT|DELETE|PATCH)\s+(\/[\w\-\/]*)/gi;
-  let m;
-  while ((m = re.exec(evidence)) !== null) {
-    claims.push({ method: m[1].toUpperCase(), path: m[2] });
-  }
-  return claims;
-}
-function _verifyUrlClaim(claim, codeText) {
-  // claim.path 가 코드에 등장해야 함 (fetch('https://.../users') 또는 라우트 정의 'POST /users')
-  if (!claim.path || claim.path.length < 2) return true;
-  // path를 그대로 검색 (URL 또는 라우트 정의)
-  const escaped = claim.path.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  const re = new RegExp(escaped, 'i');
-  return re.test(codeText);
-}
+// _extractUrlClaims/_verifyUrlClaim moved to lib/pure-utils.js (UR-0057).
 
 function _scanCodeForPatterns(root) {
   // src/, bin/, lib/, scripts/ 의 .js/.ts/.gd/.py 파일 본문 통합
@@ -10070,46 +10025,13 @@ function _scanCodeForPatterns(root) {
 }
 
 function _detectOptimism(evidence, codeText) {
-  // 각 패턴 검사: evidence에 주장 있고 코드에 흔적 없으면 의심
-  const suspects = [];
-  for (const p of OPTIMISM_PATTERNS) {
-    if (p.evidenceRe.test(evidence) && !p.codeRe.test(codeText)) {
-      suspects.push({ kind: p.kind, label: p.label, severity: 'high' });
-    }
-  }
-  // 1.9.27: URL/메서드 단위 매핑 — API 패턴에선 통과해도 구체 경로가 코드에 없으면 추가 의심
-  const urlClaims = _extractUrlClaims(evidence);
-  for (const claim of urlClaims) {
-    if (!_verifyUrlClaim(claim, codeText)) {
-      suspects.push({
-        kind: 'URL',
-        label: `구체 경로 "${claim.method} ${claim.path}" 코드에 미발견`,
-        severity: 'medium',
-        claim
-      });
-    }
-  }
-  return suspects;
+  return _puDetectOptimism(OPTIMISM_PATTERNS, evidence, codeText);
 }
 
 // 1.9.27: 신뢰도 점수 (0=완전 의심, 1=신뢰)
 // 1.9.28: high suspect 단일 케이스 floor 0.15 — 단일 의심도 정량 차등 가능하게
 function _computeConfidence(evidence, codeText) {
-  const suspects = _detectOptimism(evidence, codeText);
-  const high = suspects.filter(s => s.severity === 'high').length;
-  const medium = suspects.filter(s => s.severity === 'medium').length;
-  // 가중치: high 1.0 / medium 0.5
-  const totalPenalty = high * 1.0 + medium * 0.5;
-  // 패턴 검사로 발견된 evidence 주장이 많을수록 신뢰도 산정 base 변경
-  const evidenceClaims = OPTIMISM_PATTERNS.filter(p => p.evidenceRe.test(evidence)).length + _extractUrlClaims(evidence).length;
-  if (evidenceClaims === 0) return 1.0; // 외부 작용 주장 자체가 없으면 신뢰 1.0
-  let confidence = Math.max(0, 1 - totalPenalty / evidenceClaims);
-  // 1.9.28: single high suspect에서 confidence 0.0이 일률적 → severity 기반 floor 적용
-  if (suspects.length > 0 && high > 0 && confidence < 0.15) {
-    // 의심 발견은 명확하지만 0보다는 명시적 신호로
-    confidence = 0.15;
-  }
-  return Math.round(confidence * 100) / 100;
+  return _puComputeConfidence(OPTIMISM_PATTERNS, evidence, codeText);
 }
 
 // 1.9.305 (사용자 명시): AI 인식론적 정직성 점검 — 모르는 걸 아는 척 / 정보 미수집 / 미검증 섣부른 판단.
@@ -20604,70 +20526,13 @@ function _tryLoadLSP() {
 
 // 1.9.173: 다국어 확장 — Python/Go/Rust/Java 패턴 추가 (regex fallback)
 //   파일 확장자 기반 자동 라우팅. TypeScript Compiler API 미설치 시에도 5개 언어 지원.
-const _LSP_LANG_PATTERNS = {
-  javascript: [
-    { re: /^\s*(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)\s*\(/, kind: 'function' },
-    { re: /^\s*(?:export\s+)?class\s+([A-Za-z_$][\w$]*)/, kind: 'class' },
-    { re: /^\s*(?:export\s+)?interface\s+([A-Za-z_$][\w$]*)/, kind: 'interface' },
-    { re: /^\s*(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s+)?(?:function|\()/, kind: 'function' },
-    { re: /^\s*(?:export\s+)?type\s+([A-Za-z_$][\w$]*)\s*=/, kind: 'type' },
-    { re: /^\s*(?:export\s+)?enum\s+([A-Za-z_$][\w$]*)/, kind: 'enum' }
-  ],
-  python: [
-    { re: /^\s*async\s+def\s+([A-Za-z_][\w]*)\s*\(/, kind: 'function' },
-    { re: /^\s*def\s+([A-Za-z_][\w]*)\s*\(/, kind: 'function' },
-    { re: /^\s*class\s+([A-Za-z_][\w]*)\s*[(:]/, kind: 'class' }
-  ],
-  go: [
-    { re: /^\s*func\s+(?:\([^)]*\)\s+)?([A-Za-z_][\w]*)\s*\(/, kind: 'function' },
-    { re: /^\s*type\s+([A-Za-z_][\w]*)\s+struct\b/, kind: 'struct' },
-    { re: /^\s*type\s+([A-Za-z_][\w]*)\s+interface\b/, kind: 'interface' },
-    { re: /^\s*type\s+([A-Za-z_][\w]*)\s+[A-Za-z]/, kind: 'type' }
-  ],
-  rust: [
-    { re: /^\s*(?:pub(?:\([^)]+\))?\s+)?(?:async\s+)?fn\s+([A-Za-z_][\w]*)/, kind: 'function' },
-    { re: /^\s*(?:pub(?:\([^)]+\))?\s+)?struct\s+([A-Za-z_][\w]*)/, kind: 'struct' },
-    { re: /^\s*(?:pub(?:\([^)]+\))?\s+)?enum\s+([A-Za-z_][\w]*)/, kind: 'enum' },
-    { re: /^\s*(?:pub(?:\([^)]+\))?\s+)?trait\s+([A-Za-z_][\w]*)/, kind: 'trait' },
-    { re: /^\s*impl\s+(?:[^{]+\s+for\s+)?([A-Za-z_][\w]*)/, kind: 'impl' },
-    { re: /^\s*(?:pub(?:\([^)]+\))?\s+)?type\s+([A-Za-z_][\w]*)\s*=/, kind: 'type' }
-  ],
-  java: [
-    { re: /^\s*(?:public|private|protected)?\s*(?:final\s+)?(?:abstract\s+)?class\s+([A-Za-z_][\w]*)/, kind: 'class' },
-    { re: /^\s*(?:public|private|protected)?\s*(?:abstract\s+)?interface\s+([A-Za-z_][\w]*)/, kind: 'interface' },
-    { re: /^\s*(?:public|private|protected)?\s*(?:static\s+)?(?:final\s+)?enum\s+([A-Za-z_][\w]*)/, kind: 'enum' },
-    // method: visibility + return type + name(  (heuristic — 첫 번째 ( 매칭, 키워드 필터)
-    { re: /^\s*(?:public|private|protected)\s+(?:static\s+)?(?:final\s+)?(?:[A-Za-z_<>,\s\[\]]+\s+)?([A-Za-z_][\w]*)\s*\(/, kind: 'method' }
-  ]
-};
+// 1.9.335 (UR-0025 심층): _LSP_LANG_PATTERNS (6언어 심볼 패턴 catalog) 는 lib/catalogs.js 로 이전 (import).
+// 1.9.335 (UR-0025 심층): _detectLspLang 는 lib/pure-utils.js 로 이전 (순수 언어감지).
 
-function _detectLspLang(file) {
-  const ext = (file.match(/\.[a-zA-Z0-9]+$/) || [''])[0].toLowerCase();
-  if (/^\.(py|pyw|pyi)$/.test(ext)) return 'python';
-  if (ext === '.go') return 'go';
-  if (ext === '.rs') return 'rust';
-  if (/^\.(java|kt|scala)$/.test(ext)) return 'java';
-  if (/^\.(ts|tsx|js|jsx|mjs|cjs)$/.test(ext)) return 'javascript';
-  return 'javascript';  // default — 기본 JS 패턴 (.txt/.md 등 미지원 확장자)
-}
-
-// 정규식 fallback — 5개 언어 (JS/TS/Python/Go/Rust/Java) symbol 추출 (LSP 없이도 동작)
-// 1.9.173: lang 인자 추가 — 미지정 시 javascript 패턴 (1.9.167 호환).
+// 정규식 fallback — 6개 언어 (JS/TS/Python/Go/Rust/Java) symbol 추출 (LSP 없이도 동작)
+// 1.9.335 (UR-0025 심층): 순수 매처 _matchLspSymbols(catalog, content, lang) 로 분리 — 여기는 catalog 주입 박막.
 function _lspRegexSymbols(content, lang) {
-  const symbols = [];
-  const lines = content.split(/\r?\n/);
-  const patterns = _LSP_LANG_PATTERNS[lang || 'javascript'] || _LSP_LANG_PATTERNS.javascript;
-  lines.forEach((line, idx) => {
-    for (const p of patterns) {
-      const m = line.match(p.re);
-      // 키워드 false-positive 제거 (예: java method 정규식이 `if(`, `for(` 등에 매치되는 경우)
-      if (m && !/^(if|for|while|switch|catch|return|throw|new)$/.test(m[1])) {
-        symbols.push({ name: m[1], kind: p.kind, line: idx + 1 });
-        break;
-      }
-    }
-  });
-  return symbols;
+  return _matchLspSymbols(_LSP_LANG_PATTERNS, content, lang);
 }
 
 // TypeScript Compiler API 기반 symbol 추출 (정확)

package/lib/catalogs.js

@@ -185,4 +185,85 @@ const _DEFAULT_DOMAIN_CATALOG = {
   }
 };
 
-module.exports = { CAPABILITY_SURFACE, POWERFUL_COMMANDS, ADAPTERS, REUSE_CATEGORIES, REUSE_CHECKLIST, _DEFAULT_PLATFORM_CONSTRAINTS, _DEFAULT_DOMAIN_CATALOG };
+// 1.9.335 (UR-0025 심층): LSP 정규식 fallback 언어별 심볼 패턴 catalog (harness 에서 분리)
+// 6개 언어 (JS/TS / Python / Go / Rust / Java) — LSP 미설치 시 regex 심볼 추출에 사용.
+const _LSP_LANG_PATTERNS = {
+  javascript: [
+    { re: /^\s*(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)\s*\(/, kind: 'function' },
+    { re: /^\s*(?:export\s+)?class\s+([A-Za-z_$][\w$]*)/, kind: 'class' },
+    { re: /^\s*(?:export\s+)?interface\s+([A-Za-z_$][\w$]*)/, kind: 'interface' },
+    { re: /^\s*(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s+)?(?:function|\()/, kind: 'function' },
+    { re: /^\s*(?:export\s+)?type\s+([A-Za-z_$][\w$]*)\s*=/, kind: 'type' },
+    { re: /^\s*(?:export\s+)?enum\s+([A-Za-z_$][\w$]*)/, kind: 'enum' }
+  ],
+  python: [
+    { re: /^\s*async\s+def\s+([A-Za-z_][\w]*)\s*\(/, kind: 'function' },
+    { re: /^\s*def\s+([A-Za-z_][\w]*)\s*\(/, kind: 'function' },
+    { re: /^\s*class\s+([A-Za-z_][\w]*)\s*[(:]/, kind: 'class' }
+  ],
+  go: [
+    { re: /^\s*func\s+(?:\([^)]*\)\s+)?([A-Za-z_][\w]*)\s*\(/, kind: 'function' },
+    { re: /^\s*type\s+([A-Za-z_][\w]*)\s+struct\b/, kind: 'struct' },
+    { re: /^\s*type\s+([A-Za-z_][\w]*)\s+interface\b/, kind: 'interface' },
+    { re: /^\s*type\s+([A-Za-z_][\w]*)\s+[A-Za-z]/, kind: 'type' }
+  ],
+  rust: [
+    { re: /^\s*(?:pub(?:\([^)]+\))?\s+)?(?:async\s+)?fn\s+([A-Za-z_][\w]*)/, kind: 'function' },
+    { re: /^\s*(?:pub(?:\([^)]+\))?\s+)?struct\s+([A-Za-z_][\w]*)/, kind: 'struct' },
+    { re: /^\s*(?:pub(?:\([^)]+\))?\s+)?enum\s+([A-Za-z_][\w]*)/, kind: 'enum' },
+    { re: /^\s*(?:pub(?:\([^)]+\))?\s+)?trait\s+([A-Za-z_][\w]*)/, kind: 'trait' },
+    { re: /^\s*impl\s+(?:[^{]+\s+for\s+)?([A-Za-z_][\w]*)/, kind: 'impl' },
+    { re: /^\s*(?:pub(?:\([^)]+\))?\s+)?type\s+([A-Za-z_][\w]*)\s*=/, kind: 'type' }
+  ],
+  java: [
+    { re: /^\s*(?:public|private|protected)?\s*(?:final\s+)?(?:abstract\s+)?class\s+([A-Za-z_][\w]*)/, kind: 'class' },
+    { re: /^\s*(?:public|private|protected)?\s*(?:abstract\s+)?interface\s+([A-Za-z_][\w]*)/, kind: 'interface' },
+    { re: /^\s*(?:public|private|protected)?\s*(?:static\s+)?(?:final\s+)?enum\s+([A-Za-z_][\w]*)/, kind: 'enum' },
+    // method: visibility + return type + name(  (heuristic — 첫 번째 ( 매칭, 키워드 필터)
+    { re: /^\s*(?:public|private|protected)\s+(?:static\s+)?(?:final\s+)?(?:[A-Za-z_<>,\s\[\]]+\s+)?([A-Za-z_][\w]*)\s*\(/, kind: 'method' }
+  ]
+};
+
+// 1.9.26: optimism-check — evidence의 외부 동작 주장 vs 실제 코드 호출 흔적 불일치 감지
+// 사용자 요청 (1.9.26): "API 연동/작업 요청 시 실제로 일어나지 않았는데 일어난 것처럼 표시하는 낙관적 결과 방지"
+//
+// 패턴 (한국어 + 영어):
+//   evidence에 "API 호출" / "HTTP 200|201" / "POST /" / "응답 확인" → 코드에 fetch/http.request/axios 흔적 없으면 의심
+//   evidence에 "DB 저장" / "insert N건" / "DB에" → db.*/pg.*/mysql.*/mongoose.*/prisma.* 없으면 의심
+//   evidence에 "이메일 발송" / "메일 전송" → sendMail/nodemailer/smtp 없으면 의심
+// 1.9.27: 패턴 카탈로그 확장 (5 → 10) + URL/메서드 단위 매핑 추가
+const OPTIMISM_PATTERNS = [
+  { kind: 'API',     evidenceRe: /(API\s*호출|HTTP\s*\d{3}|POST\s*\/|GET\s*\/|PUT\s*\/|DELETE\s*\/|fetch|REST 응답|응답 확인|endpoint|엔드포인트)/i,
+    codeRe: /\b(fetch\s*\(|http\.request|https\.request|axios\.|got\.|undici|node-fetch)/i,
+    label: 'API/HTTP 호출' },
+  { kind: 'DB',      evidenceRe: /(DB에?\s*저장|insert\s+\d+|데이터베이스|SQL\s*(INSERT|UPDATE|DELETE)|migration|마이그레이션 적용)/i,
+    codeRe: /\b(db\.|pg\.|pool\.|mysql\.|mongoose\.|prisma\.|sequelize|knex|sqlite3|MongoClient|createConnection)/i,
+    label: 'DB 호출' },
+  { kind: 'Email',   evidenceRe: /(이메일[^.\n]{0,30}(발송|전송|보냈|보냄|완료)|메일[^.\n]{0,30}(발송|전송|보냈|보냄)|sendMail|smtp\s*(전송|발송))/i,
+    codeRe: /\b(sendMail|nodemailer|smtp|@sendgrid|mailgun|aws-sdk\/ses|resend\.)/i,
+    label: '이메일 전송' },
+  { kind: 'Webhook', evidenceRe: /(웹훅\s*(호출|전송|발송)|webhook\s+(sent|posted|triggered))/i,
+    codeRe: /\b(fetch\s*\(|http\.request|axios\.)/i,
+    label: '웹훅' },
+  { kind: 'Payment', evidenceRe: /(결제\s*(완료|성공|승인|취소)|payment\s+(processed|charged)|stripe 결제|toss\s*결제|카카오페이|네이버페이|kakaopay|nicepay|iamport 결제|페이팔|paypal)/i,
+    codeRe: /\b(stripe|toss|@stripe|tosspayments|iamport|kakao|nicepay|naverpay|paypal-rest-sdk|@paypal)/i,
+    label: '결제' },
+  // 1.9.27 신규 카테고리
+  { kind: 'FileIO',  evidenceRe: /(파일[^.\n]{0,20}(생성|저장|작성|기록)|\d+개[^.\n]{0,20}파일|디스크[^.\n]{0,20}저장|로그 파일 작성)/i,
+    codeRe: /\b(fs\.write|fs\.appendFile|writeFileSync|appendFileSync|fs\/promises|fs\.createWriteStream)/i,
+    label: '파일 I/O 쓰기' },
+  { kind: 'Queue',   evidenceRe: /(메시지\s*큐|발행\s*완료|publish\s*(완료|성공)|RabbitMQ|Kafka|SQS|Redis Pub|이벤트 발행)/i,
+    codeRe: /\b(amqp|kafkajs|rabbit|redis\.(publish|xadd)|@aws-sdk\/client-sqs|bull|bullmq)/i,
+    label: '메시지 큐 발행' },
+  { kind: 'Cache',   evidenceRe: /(Redis[^.\n]{0,20}(저장|set|get)|캐시[^.\n]{0,20}(저장|기록|적중)|memcache)/i,
+    codeRe: /\b(redis\.|ioredis|memcached|node-cache|@upstash\/redis|connect-redis)/i,
+    label: '캐시 저장' },
+  { kind: 'Notify',  evidenceRe: /(슬랙\s*(알림|발송|전송)|Slack\s+(notification|sent|posted)|Discord\s+(알림|발송|webhook)|푸시 알림 전송)/i,
+    codeRe: /\b(@slack\/web-api|slack-webhook|discord\.js|discord-webhook|@discordjs|firebase\/messaging|expo-notifications)/i,
+    label: '슬랙/Discord 알림' },
+  { kind: 'Storage', evidenceRe: /(S3\s*(업로드|저장)|GCS\s*업로드|Azure Blob|클라우드 스토리지 업로드|object storage 저장)/i,
+    codeRe: /\b(@aws-sdk\/client-s3|aws-sdk[^a-z]|@google-cloud\/storage|@azure\/storage-blob|aws-s3)/i,
+    label: '클라우드 스토리지' }
+];
+
+module.exports = { CAPABILITY_SURFACE, POWERFUL_COMMANDS, ADAPTERS, REUSE_CATEGORIES, REUSE_CHECKLIST, _DEFAULT_PLATFORM_CONSTRAINTS, _DEFAULT_DOMAIN_CATALOG, _LSP_LANG_PATTERNS, OPTIMISM_PATTERNS };

package/lib/pure-utils.js

@@ -407,6 +407,102 @@ function _matchDomain(catalog, text) {
   return { domain: null, alias: null };
 }
 
+// 1.9.335 (UR-0025 심층): LSP 서브시스템 — 순수 언어 감지 (파일 확장자 → 언어)
+function _detectLspLang(file) {
+  const ext = ((file || '').match(/\.[a-zA-Z0-9]+$/) || [''])[0].toLowerCase();
+  if (/^\.(py|pyw|pyi)$/.test(ext)) return 'python';
+  if (ext === '.go') return 'go';
+  if (ext === '.rs') return 'rust';
+  if (/^\.(java|kt|scala)$/.test(ext)) return 'java';
+  if (/^\.(ts|tsx|js|jsx|mjs|cjs)$/.test(ext)) return 'javascript';
+  return 'javascript';  // default — 기본 JS 패턴 (.txt/.md 등 미지원 확장자)
+}
+
+// 1.9.335 (UR-0025 심층): LSP 서브시스템 — 순수 정규식 심볼 매처 (catalog 주입, constraints/domain 패턴 동일)
+// catalog: { <lang>: [{ re, kind }, ...] } · content: 소스 텍스트 · lang: 언어 키
+function _matchLspSymbols(catalog, content, lang) {
+  const symbols = [];
+  if (!catalog || typeof content !== 'string') return symbols;
+  const lines = content.split(/\r?\n/);
+  const patterns = catalog[lang || 'javascript'] || catalog.javascript || [];
+  lines.forEach((line, idx) => {
+    for (const p of patterns) {
+      const m = line.match(p.re);
+      // 키워드 false-positive 제거 (예: java method 정규식이 if(/for( 등에 매치되는 경우)
+      if (m && !/^(if|for|while|switch|catch|return|throw|new)$/.test(m[1])) {
+        symbols.push({ name: m[1], kind: p.kind, line: idx + 1 });
+        break;
+      }
+    }
+  });
+  return symbols;
+}
+
+// 1.9.27: URL/메서드 단위 매핑 — evidence에서 "POST /users" 같은 구체 경로를 추출하고 코드에 같은 경로 존재 확인
+function _extractUrlClaims(evidence) {
+  const claims = [];
+  // "POST /users" / "GET /api/v1/items" 등
+  const re = /\b(GET|POST|PUT|DELETE|PATCH)\s+(\/[\w\-\/]*)/gi;
+  let m;
+  while ((m = re.exec(evidence)) !== null) {
+    claims.push({ method: m[1].toUpperCase(), path: m[2] });
+  }
+  return claims;
+}
+function _verifyUrlClaim(claim, codeText) {
+  // claim.path 가 코드에 등장해야 함 (fetch('https://.../users') 또는 라우트 정의 'POST /users')
+  if (!claim.path || claim.path.length < 2) return true;
+  // path를 그대로 검색 (URL 또는 라우트 정의)
+  const escaped = claim.path.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const re = new RegExp(escaped, 'i');
+  return re.test(codeText);
+}
+
+function _detectOptimism(patterns, evidence, codeText) {
+  // 각 패턴 검사: evidence에 주장 있고 코드에 흔적 없으면 의심
+  const suspects = [];
+  if (!Array.isArray(patterns)) return suspects;
+  for (const p of patterns) {
+    if (p.evidenceRe.test(evidence) && !p.codeRe.test(codeText)) {
+      suspects.push({ kind: p.kind, label: p.label, severity: 'high' });
+    }
+  }
+  // 1.9.27: URL/메서드 단위 매핑 — API 패턴에선 통과해도 구체 경로가 코드에 없으면 추가 의심
+  const urlClaims = _extractUrlClaims(evidence);
+  for (const claim of urlClaims) {
+    if (!_verifyUrlClaim(claim, codeText)) {
+      suspects.push({
+        kind: 'URL',
+        label: `구체 경로 "${claim.method} ${claim.path}" 코드에 미발견`,
+        severity: 'medium',
+        claim
+      });
+    }
+  }
+  return suspects;
+}
+
+// 1.9.27: 신뢰도 점수 (0=완전 의심, 1=신뢰)
+// 1.9.28: high suspect 단일 케이스 floor 0.15 — 단일 의심도 정량 차등 가능하게
+function _computeConfidence(patterns, evidence, codeText) {
+  if (!Array.isArray(patterns)) return 1.0;
+  const suspects = _detectOptimism(patterns, evidence, codeText);
+  const high = suspects.filter(s => s.severity === 'high').length;
+  const medium = suspects.filter(s => s.severity === 'medium').length;
+  // 가중치: high 1.0 / medium 0.5
+  const totalPenalty = high * 1.0 + medium * 0.5;
+  // 패턴 검사로 발견된 evidence 주장이 많을수록 신뢰도 산정 base 변경
+  const evidenceClaims = patterns.filter(p => p.evidenceRe.test(evidence)).length + _extractUrlClaims(evidence).length;
+  if (evidenceClaims === 0) return 1.0; // 외부 작용 주장 자체가 없으면 신뢰 1.0
+  let confidence = Math.max(0, 1 - totalPenalty / evidenceClaims);
+  // 1.9.28: single high suspect에서 confidence 0.0이 일률적 → severity 기반 floor 적용
+  if (suspects.length > 0 && high > 0 && confidence < 0.15) {
+    // 의심 발견은 명확하지만 0보다는 명시적 신호로
+    confidence = 0.15;
+  }
+  return Math.round(confidence * 100) / 100;
+}
+
 module.exports = {
   _isSecretKey, compareVer, parseHarnessVersion,
   _classifyCJK, _riskLabel, _detectSystemLang, _parseSlashFromHelp,
@@ -435,5 +531,9 @@ module.exports = {
   // 1.9.333 (UR-0025 심층): 순수 플랫폼 제약 매칭
   _matchConstraints,
   // 1.9.333 패턴 적용: 순수 도메인 매칭
-  _matchDomain
+  _matchDomain,
+  // 1.9.335 (UR-0025 심층): LSP 서브시스템 — 순수 언어감지 + 정규식 심볼 매처
+  _detectLspLang, _matchLspSymbols,
+  // anti-laziness optimism-check 순수 로직
+  _extractUrlClaims, _verifyUrlClaim, _detectOptimism, _computeConfidence
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leerness",
-  "version": "1.9.334",
+  "version": "1.9.336",
   "description": "Leerness: 비파괴 마이그레이션, 자동 버전 감지·업데이트, 계획/진행/핸드오프 자동화, 게으름·시크릿·인코딩 자동 가드, Claude Code 슬래시 통합을 갖춘 한국어 우선 AI 개발 하네스.",
   "keywords": [
     "leerness",

package/scripts/e2e.js

@@ -4160,5 +4160,66 @@ total++;
   if (!ok) failed++;
 }
 
+// 1.9.335 회귀 (UR-0025 심층): LSP catalog→lib/catalogs + _detectLspLang/_matchLspSymbols→pure-utils + lsp symbols 회귀
+total++;
+{
+  let ok = false;
+  try {
+    const c = require(path.resolve(__dirname, '..', 'lib', 'catalogs.js'));
+    const m = require(path.resolve(__dirname, '..', 'lib', 'pure-utils.js'));
+    const catOk = c._LSP_LANG_PATTERNS && Object.keys(c._LSP_LANG_PATTERNS).length === 5 && Array.isArray(c._LSP_LANG_PATTERNS.python);
+    const langOk = m._detectLspLang('x.py') === 'python' && m._detectLspLang('y.rs') === 'rust' && m._detectLspLang('z.txt') === 'javascript';
+    const sy = m._matchLspSymbols(c._LSP_LANG_PATTERNS, 'def foo():\n    pass\nclass Bar:\n    pass', 'python');
+    const work = catOk && langOk && typeof m._matchLspSymbols === 'function' && sy.length === 2 && sy[0].name === 'foo' && sy[0].kind === 'function' && sy[1].name === 'Bar' && m._matchLspSymbols(null, 'x', 'javascript').length === 0;
+    const harnessSrc = fs.readFileSync(path.resolve(__dirname, '..', 'bin', 'harness.js'), 'utf8');
+    const _catImp = (harnessSrc.match(/const \{[\s\S]*?\} = require\('\.\.\/lib\/catalogs'\)/) || [''])[0];  // import 순서/추가 비의존
+    const _puImp = (harnessSrc.match(/const \{[\s\S]*?\} = require\('\.\.\/lib\/pure-utils'\)/) || [''])[0];
+    const movedOut = !/const _LSP_LANG_PATTERNS = \{/.test(harnessSrc) && !/function _detectLspLang\(/.test(harnessSrc)
+      && _catImp.includes('_LSP_LANG_PATTERNS') && _puImp.includes('_matchLspSymbols') && _puImp.includes('_detectLspLang');
+    // 소비 명령 회귀: lsp symbols (정규식 fallback, _detectLspLang + _matchLspSymbols 경로)
+    const lf = path.join(os.tmpdir(), 'leerness-lsp-' + total + '.js');
+    fs.writeFileSync(lf, 'function helloWorld(){}\nclass MyClass{}\n', 'utf8');
+    const lr = cp.spawnSync(process.execPath, [CLI, 'lsp', 'symbols', lf], { encoding: 'utf8', timeout: 20000 });
+    const cmdOk = /helloWorld/.test(lr.stdout || '') && /MyClass/.test(lr.stdout || '') && /javascript/.test(lr.stdout || '');
+    ok = work && movedOut && cmdOk;
+    fs.rmSync(lf, { force: true });
+  } catch {}
+  console.log(ok ? '✓ B(1.9.335) UR-0025 심층: LSP catalog/_detectLspLang/_matchLspSymbols 분리 + lsp symbols 회귀 (UR-0025)' : '✗ LSP 서브시스템 분리 실패');
+  if (!ok) failed++;
+}
+
+// 1.9.336 회귀 (UR-0025 심층, Codex 위임·검증): anti-laziness OPTIMISM_PATTERNS→lib/catalogs + optimism 순수로직→pure-utils + optimism-check 회귀
+total++;
+{
+  let ok = false;
+  try {
+    const c = require(path.resolve(__dirname, '..', 'lib', 'catalogs.js'));
+    const m = require(path.resolve(__dirname, '..', 'lib', 'pure-utils.js'));
+    const catOk = Array.isArray(c.OPTIMISM_PATTERNS) && c.OPTIMISM_PATTERNS.length === 10 && c.OPTIMISM_PATTERNS[0].kind === 'API';
+    const ev = 'API 호출 완료, POST /users 처리함';
+    const sus = m._detectOptimism(c.OPTIMISM_PATTERNS, ev, 'function x(){ return 1; }');
+    const conf = m._computeConfidence(c.OPTIMISM_PATTERNS, ev, 'function x(){ return 1; }');
+    const work = catOk && typeof m._detectOptimism === 'function' && sus.some(s => s.kind === 'API' && s.severity === 'high') && conf < 0.5
+      && m._computeConfidence(c.OPTIMISM_PATTERNS, '그냥 정리함', 'x') === 1 && m._detectOptimism(null, ev, 'x').length === 0
+      && m._extractUrlClaims('POST /a/b').length === 1 && m._verifyUrlClaim({ path: '/a/b' }, 'has /a/b') === true;
+    const harnessSrc = fs.readFileSync(path.resolve(__dirname, '..', 'bin', 'harness.js'), 'utf8');
+    const _catImp = (harnessSrc.match(/const \{[\s\S]*?\} = require\('\.\.\/lib\/catalogs'\)/) || [''])[0];  // import 순서/추가 비의존
+    const _puImp = (harnessSrc.match(/const \{[\s\S]*?\} = require\('\.\.\/lib\/pure-utils'\)/) || [''])[0];
+    const movedOut = !/const OPTIMISM_PATTERNS = \[/.test(harnessSrc) && !/function _extractUrlClaims\(/.test(harnessSrc)
+      && _catImp.includes('OPTIMISM_PATTERNS') && _puImp.includes('_puDetectOptimism') && _puImp.includes('_puComputeConfidence');
+    // 소비 명령 회귀: optimism-check (harness wrapper → _puDetectOptimism(OPTIMISM_PATTERNS, ...) 경로)
+    const od = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-opt-'));
+    cp.spawnSync(process.execPath, [CLI, 'init', od, '--yes', '--language', 'ko', '--skills', 'recommended'], { encoding: 'utf8', timeout: 30000 });
+    fs.appendFileSync(path.join(od, '.harness', 'progress-tracker.md'), '| T-9999 | done | API 통합 | API 호출 완료, POST /users 처리함 | M-1 | 2026-06-05 |\n');
+    const or = cp.spawnSync(process.execPath, [CLI, 'optimism-check', 'T-9999', '--path', od, '--json'], { encoding: 'utf8', timeout: 20000 });
+    let cmdOk = false;
+    try { const j = JSON.parse(or.stdout); cmdOk = Array.isArray(j.suspects) && j.suspects.some(s => s.kind === 'API') && typeof j.confidence === 'number' && j.confidence < 0.5; } catch {}
+    ok = work && movedOut && cmdOk;
+    fs.rmSync(od, { recursive: true, force: true });
+  } catch {}
+  console.log(ok ? '✓ B(1.9.336) UR-0025 심층(Codex 위임·검증): OPTIMISM_PATTERNS/optimism 순수로직 분리 + optimism-check 회귀 (UR-0025)' : '✗ anti-laziness 서브시스템 분리 실패');
+  if (!ok) failed++;
+}
+
 console.log(`\nE2E result: ${total - failed}/${total} passed · ${((Date.now() - _e2eStart) / 1000).toFixed(0)}s`);
 if (failed > 0) process.exit(1);