elanous 0.2.36 → 0.2.38

package/scripts/land-global-checks.ts

@@ -9,6 +9,9 @@
 // 재는 명령: `bun scripts/land-global-checks.ts` (표) · `bun scripts/land-global-checks.ts <바뀐 파일…>` (끌려오는 시험)
 
 import { spawnSync } from 'node:child_process';
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 
 type LandGlobalCheck = {
   /** 바뀐 파일 경로(저장소 루트 기준 · `/` 구분)에 대는 꼴. */
@@ -19,9 +22,16 @@ type LandGlobalCheck = {
   why: string;
 };
 
+/** 착지 게이트가 실물 판정하는 next.md 경로 꼴 — 이번 착지가 이 꼴을 바꿀 때만 next.md 판정(landNextMdGate)이 돈다. */
+const NEXT_MD_PATTERN = /^release\/next\.md$/;
+
 export const LAND_GLOBAL_CHECKS: readonly LandGlobalCheck[] = [
   { pattern: /^apps\/pwa\/.+\.tsx$/, test: 'test/hook-order-sweep.test.ts', why: 'PWA 컴포넌트 훅 순서(#24719)' },
-  { pattern: /^release\/next\.md$/, test: 'scripts/release-story/draft.test.ts', why: '판 노트 초안·브랜드 규칙(#24688)' },
+  { pattern: NEXT_MD_PATTERN, test: 'scripts/release-story/draft.test.ts', why: '판 노트 초안·브랜드 규칙(#24688)' },
+  // 초안 규칙(draft.test)은 노트 줄에 B11 이 «없음»을 단언하는 길이라 발행 판정과 자가 다르다 — 0.2.24 는
+  //   next.md 의 «신설:» 한 줄로 컷 노드 notes-check 가 두 번 ✗ 났는데(10-12 01:28 · 01:51) 착지에서는 그 줄이 통과했다.
+  //   착지 판정이 실제 next.md 를 발행과 같은 check() 로 보게 `landNextMdGate`(runLandGlobalChecksGate 안)가 판정 자를 맞춘다.
+  { pattern: NEXT_MD_PATTERN, test: 'scripts/announce-loop/check-node.test.ts', why: '발행 노트 한국어 B11(0.2.24 notes-check)' },
   { pattern: /^docs\/ops\/machines\.yaml$/, test: 'test/machines-ledger-data.test.ts', why: '기계 원장 데이터 ↔ 생성 Markdown(#24729)' },
   // 새 CLI 하위 명령은 `src/index.ts` 또는 `src/cli/` 의 등록 모듈에서 생긴다 — 입구 목록 시험(#24661).
   { pattern: /^src\/(?:index|cli\/(?:[^/]+\/)*[^/]+)(?<!\.test)\.ts$/, test: 'src/index.test.ts', why: 'CLI 입구·하위 명령 목록(#24661)' },
@@ -41,6 +51,59 @@ export function landGlobalChecks(changedFiles: readonly string[], table: readonl
 
 export type LandGlobalChecksRun = { status: number | null; output: string; error?: string };
 
+const CHECK_NODE_SCRIPT = join(import.meta.dir, 'announce-loop', 'check-node.ts');
+
+type NextMdFinding = { rule: string; file: string; line: number; text: string };
+
+/** 발행 notes-check 와 같은 check()(scripts/announce-loop/check-node.ts)에 «실제 저장소의» release/next.md 를 넣고
+ * «착지» 범위(--landing)로 돈다 — gh·fetch 없이 B11·B8·공유 줄 규칙만(B1·B10 네트워크 검사는 발행 판정에만 있다). */
+function runNextMdCheck(cwd: string): LandGlobalChecksRun {
+  const dir = mkdtempSync(join(tmpdir(), 'land-next-md-'));
+  const prfaq = join(dir, 'prfaq.md');
+  writeFileSync(prfaq, '');
+  try {
+    const r = spawnSync('bun', [CHECK_NODE_SCRIPT, '--landing', '--prfaq', prfaq, '--files', 'release/next.md'], {
+      cwd, encoding: 'utf8', maxBuffer: 8 * 1024 * 1024, timeout: 60_000,
+    });
+    return { status: r.status, output: `${r.stdout ?? ''}\n${r.stderr ?? ''}`, ...(r.error ? { error: r.error.message } : {}) };
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+/**
+ * 착지 게이트가 실제 release/next.md 를 발행 판정과 같은 check() 로 본다 — 0.2.24 어긋남(착지 통과 · 발행 B11 ✗) 수리.
+ * ⚠️ 파일이 없으면 «해당 없음»으로 통과한다(착지 게이트는 무대의 실물만 본다).
+ * 호출부(runLandGlobalChecksGate)는 이번 착지의 바뀐 파일에 release/next.md 가 있을 때만 부른다 —
+ *   next.md 를 건드리지 않은 PR 은 main 의 next.md 상태에 영향을 받지 않는다.
+ * 판정 범위는 «착지»(--landing) — B11·B8·공유 줄 규칙만. B1(PR 참조)·B10(링크) 네트워크 검사는 발행 판정에만 있다.
+ */
+export function landNextMdGate(cwd: string, io: { log: (message: string) => void; error: (message: string) => void }): boolean {
+  const nextMd = join(cwd, 'release', 'next.md');
+  if (!existsSync(nextMd)) return true;
+  const result = runNextMdCheck(cwd);
+  if (result.error !== undefined || result.status === null) {
+    throw new Error(`release/next.md 발행 노트 검사 러너가 못 돌았다 — ${result.error ?? 'status=null'}`);
+  }
+  if (result.status === 0) {
+    io.log('✓ land-global-checks: 실제 release/next.md 발행 노트 검사(check-node) PASS — 위반 0.');
+    return true;
+  }
+  let findings: NextMdFinding[] = [];
+  const jsonLine = result.output.split(/\r?\n/).find((line) => line.trim().startsWith('{'));
+  if (jsonLine !== undefined) {
+    try { findings = (JSON.parse(jsonLine) as { findings?: NextMdFinding[] }).findings ?? []; } catch { findings = []; }
+  }
+  if (findings.length === 0) {
+    io.error(`✗ land-global-checks: 실제 release/next.md 발행 노트 검사(check-node)가 실패했다(종료 ${result.status}) — ${result.output.trim().split(/\r?\n/).at(-1) ?? ''}`);
+  }
+  for (const f of findings) {
+    io.error(`✗ land-global-checks: 실제 release/next.md — 발행 노트 검사(check-node) 위반 ${f.rule} ${f.file}:${f.line} ${f.text.trim()}`);
+  }
+  io.error('✗ land-global-checks: scripts/land-global-checks.ts blocked pr land — 실제 release/next.md 가 발행 notes-check(check-node) 판정에서 위반했다. 발행 판정과 착지 판정의 B11 자를 맞추려면 노트를 고치고 착지하라.');
+  return false;
+}
+
 type LandGlobalChecksGateIo = {
   changedFiles: readonly string[];
   cwd: string;
@@ -59,9 +122,14 @@ function runDeterministic(tests: readonly string[], cwd: string): LandGlobalChec
 
 /**
  * 반환: true = 해당 없음 또는 끌려온 시험 통과 · false = 끌려온 시험이 실패했다(착지를 막는다).
+ * 실물 next.md 판정(landNextMdGate)은 이번 착지가 release/next.md 를 바꿀 때만 돈다 — 머리 주석의
+ * «바뀐 파일 꼴로 끌어온다» 계약을 따른다. next.md 를 건드리지 않은 PR 은 main 의 next.md 상태를 보지 않는다.
  * ⛔ 러너가 «못 돌았다»(spawn 실패·시간 초과)면 던진다 — 호출부(`gateVerdict`)가 「검사 못 함」으로 말한다.
  */
 export function runLandGlobalChecksGate(io: LandGlobalChecksGateIo): boolean {
+  if (io.changedFiles.some((file) => NEXT_MD_PATTERN.test(file.replace(/\\/g, '/')))) {
+    if (!landNextMdGate(io.cwd, io)) return false;
+  }
   const tests = landGlobalChecks(io.changedFiles);
   if (tests.length === 0) {
     io.log(`[land-global-checks] 해당 없음 — 바뀐 파일 ${io.changedFiles.length}개가 전역 검사 표(${LAND_GLOBAL_CHECKS.length}줄)의 꼴에 안 걸린다.`);

package/scripts/measure-nl-routing-corpus.ts

@@ -74,6 +74,194 @@ export function resolveCorpusRunSafety(
   return { observeOnly, bypassed, exposedMutatingTools };
 }
 
+// ── NL-UTTERANCE-PATTERNS v5 — 경로·복합 처리 채점 입구 ─────────────────────
+//
+// 칸의 판정선은 수가 아니라 «판정선»이다: 가림 예시 누출 0 · 패턴 ≥12 · v5 채점 문항 ≥25.
+// 패턴은 발화 어휘 신호(경로 지정 / 복합 요청)이고, 문항은 그 패턴이 실제로 발화하는지
+// 스스로 증명한다(선언 패턴이 프롬프트에서 안 잡히면 mismatch 로 판정 실패).
+// ⛔ 가림 예시(masking examples)는 «채점되지 않는» 홀드아웃 발화다 — 문항·패턴에 새면 판정선이 무너진다.
+
+export interface NlRoutingToolExpectation {
+  readonly tool: string;
+  readonly minCount?: number;
+}
+
+export interface NlUtterancePattern {
+  readonly id: string;
+  readonly handles: 'path' | 'compound';
+  readonly signal: RegExp;
+}
+
+export const NL_UTTERANCE_PATTERNS: readonly NlUtterancePattern[] = [
+  { id: 'path-single-read', handles: 'path', signal: /(?:읽어\s*줘|열어\s*줘)/u },
+  { id: 'path-relative', handles: 'path', signal: /(?:상대\s*경로|\.\/)/u },
+  { id: 'path-absolute', handles: 'path', signal: /(?:절대\s*경로|\/tmp\/|\/home\/)/u },
+  { id: 'path-home-config', handles: 'path', signal: /(?:~\/\.elanous|홈\s*디렉터리)/u },
+  { id: 'path-directory-scope', handles: 'path', signal: /(?:디렉터리\s*안에서|그\s*폴더\s*안)/u },
+  { id: 'path-symbol-search', handles: 'path', signal: /어디서\s*쓰/u },
+  { id: 'path-file-glob', handles: 'path', signal: /(?:목록|어떤\s*파일들)/u },
+  { id: 'path-nested-file', handles: 'path', signal: /하위\s*디렉터리[\s\S]*파일/u },
+  { id: 'compound-read-then-grep', handles: 'compound', signal: /읽고\s*나서[\s\S]*찾/u },
+  { id: 'compound-grep-then-read', handles: 'compound', signal: /찾아서\s*그\s*파일/u },
+  { id: 'compound-glob-then-read', handles: 'compound', signal: /목록[\s\S]*첫\s*파일/u },
+  { id: 'compound-two-file-compare', handles: 'compound', signal: /두\s*파일[\s\S]*비교/u },
+  { id: 'compound-three-way', handles: 'compound', signal: /읽고[\s\S]*찾고[\s\S]*목록/u },
+  { id: 'compound-search-then-confirm', handles: 'compound', signal: /검색해서[\s\S]*전부\s*확인/u },
+];
+
+export interface NlRoutingV5Question {
+  readonly id: string;
+  readonly pattern: string;
+  readonly prompt: string;
+  readonly expects: readonly NlRoutingToolExpectation[];
+}
+
+const single = (tool: string): readonly NlRoutingToolExpectation[] => [{ tool }];
+
+export const NL_ROUTING_V5_QUESTIONS: readonly NlRoutingV5Question[] = [
+  { id: 'v5-01', pattern: 'path-single-read', prompt: 'src/domains/surface-events.ts 파일 읽어 줘', expects: single('Read') },
+  { id: 'v5-02', pattern: 'path-single-read', prompt: 'scripts/measure-nl-routing-corpus.ts 읽어 줘', expects: single('Read') },
+  { id: 'v5-03', pattern: 'path-relative', prompt: 'src/cli/self-utterances-cli.ts 상대 경로로 열어 줘', expects: single('Read') },
+  { id: 'v5-04', pattern: 'path-relative', prompt: './scripts/lib/nl-routing-screening.ts 상대 경로 파일 보여줘', expects: single('Read') },
+  { id: 'v5-05', pattern: 'path-absolute', prompt: '/home/ubuntu/.elanous/logs 절대 경로 확인해 줘', expects: single('Read') },
+  { id: 'v5-06', pattern: 'path-absolute', prompt: '/tmp/nl-routing/corpus.json 절대 경로 읽어 줘', expects: single('Read') },
+  { id: 'v5-07', pattern: 'path-home-config', prompt: '~/.elanous 아래 설정 파일 읽어 줘', expects: single('Read') },
+  { id: 'v5-08', pattern: 'path-home-config', prompt: '홈 디렉터리의 elanous 설정 읽어 줘', expects: single('Read') },
+  { id: 'v5-09', pattern: 'path-directory-scope', prompt: 'src/domains 디렉터리 안에서 발화 origin 찾아 줘', expects: single('Grep') },
+  { id: 'v5-10', pattern: 'path-directory-scope', prompt: '그 폴더 안에서 querySurfaceUtterances 를 검색해 줘', expects: single('Grep') },
+  { id: 'v5-11', pattern: 'path-symbol-search', prompt: 'recordInboundTurn 이 어디서 쓰이는지 알려 줘', expects: single('Grep') },
+  { id: 'v5-12', pattern: 'path-symbol-search', prompt: 'classifyTier 어디서 쓰는지 찾아 줘', expects: single('Grep') },
+  { id: 'v5-13', pattern: 'path-file-glob', prompt: 'scripts 아래 측정 스크립트 목록 뽑아 줘', expects: single('Glob') },
+  { id: 'v5-14', pattern: 'path-file-glob', prompt: '어떤 파일들 *.test.ts 이 있는지 보여 줘', expects: single('Glob') },
+  { id: 'v5-15', pattern: 'path-nested-file', prompt: 'src/domains 하위 디렉터리의 파일 하나 읽어 줘', expects: single('Read') },
+  { id: 'v5-16', pattern: 'path-nested-file', prompt: 'scripts/lib 하위 디렉터리 파일 읽어 줘', expects: single('Read') },
+  { id: 'v5-17', pattern: 'compound-read-then-grep', prompt: 'src/domains/surface-events.ts 읽고 나서 호출부 찾아 줘', expects: [{ tool: 'Read' }, { tool: 'Grep' }] },
+  { id: 'v5-18', pattern: 'compound-read-then-grep', prompt: 'docs/goal-context README 읽고 나서 참조 찾아 줘', expects: [{ tool: 'Read' }, { tool: 'Grep' }] },
+  { id: 'v5-19', pattern: 'compound-grep-then-read', prompt: 'recordInboundTurn 찾아서 그 파일 읽어 줘', expects: [{ tool: 'Grep' }, { tool: 'Read' }] },
+  { id: 'v5-20', pattern: 'compound-grep-then-read', prompt: 'querySurfaceUtterances 찾아서 그 파일 열어 줘', expects: [{ tool: 'Grep' }, { tool: 'Read' }] },
+  { id: 'v5-21', pattern: 'compound-glob-then-read', prompt: 'src/domains 목록 뽑고 첫 파일 읽어 줘', expects: [{ tool: 'Glob' }, { tool: 'Read' }] },
+  { id: 'v5-22', pattern: 'compound-glob-then-read', prompt: 'scripts/lib 목록 보고 첫 파일 읽어 줘', expects: [{ tool: 'Glob' }, { tool: 'Read' }] },
+  { id: 'v5-23', pattern: 'compound-two-file-compare', prompt: 'surface-events.ts 와 provenance.ts 두 파일 비교해 줘', expects: [{ tool: 'Read', minCount: 2 }] },
+  { id: 'v5-24', pattern: 'compound-two-file-compare', prompt: 'measure-nl-routing-corpus.ts 와 nl-routing-measurement.ts 두 파일 비교해 줘', expects: [{ tool: 'Read', minCount: 2 }] },
+  { id: 'v5-25', pattern: 'compound-three-way', prompt: 'surface-events.ts 읽고 지난 기록 찾고 폴더 목록도 뽑아 줘', expects: [{ tool: 'Read' }, { tool: 'Grep' }, { tool: 'Glob' }] },
+  { id: 'v5-26', pattern: 'compound-three-way', prompt: 'self-utterances-cli.ts 읽고 origin 찾고 scripts 목록도 뽑아 줘', expects: [{ tool: 'Read' }, { tool: 'Grep' }, { tool: 'Glob' }] },
+  { id: 'v5-27', pattern: 'compound-search-then-confirm', prompt: 'origin 표기를 검색해서 관련 파일 전부 확인해 줘', expects: [{ tool: 'Grep' }, { tool: 'Read' }] },
+  { id: 'v5-28', pattern: 'compound-search-then-confirm', prompt: 'v5 문항을 검색해서 전부 확인해 줘', expects: [{ tool: 'Grep' }, { tool: 'Read' }] },
+];
+
+/** 채점에 쓰이지 않는 홀드아웃 발화 — 문항·패턴에 «한 글자도» 새면 안 된다. */
+export const NL_ROUTING_MASKING_EXAMPLES: readonly string[] = [
+  '이 저장소에서 라우팅 규칙이 어디에 적혀 있는지 알려 줘',
+  '방금 만든 스크립트랑 예전 스크립트를 나란히 놓고 틀린 곳만 짚어 줘',
+  '설정 폴더 아래 있는 재정의 항목만 훑어 줘',
+  '테스트가 실제로 도는 파일과 그렇지 않은 파일을 갈라 줘',
+  '복합 요청: 먼저 근거를 모으고 그다음에 요약을 만들어 줘',
+  '이 변경이 어떤 진입점을 타는지 확인해 줘',
+  '오늘 새로 생긴 산출물만 모아서 보여 줘',
+  '지난 실행에서 실패한 문항을 다시 재 보고 싶어',
+];
+
+export const NL_ROUTING_V5_THRESHOLDS = { maskingLeaks: 0, patterns: 12, scored: 25 } as const;
+
+function normalizeUtterance(text: string): string {
+  return text.toLowerCase().replace(/[^\p{L}\p{N}]+/gu, ' ').trim();
+}
+
+/** 발화에서 발화하는 패턴 id 목록(패턴 정의가 장식이 아님을 문항 단위로 확인하는 자). */
+export function matchNlUtterancePatterns(prompt: string): string[] {
+  return NL_UTTERANCE_PATTERNS.filter((pattern) => pattern.signal.test(prompt)).map((pattern) => pattern.id);
+}
+
+/** 가림 예시 누출 검사 — 문항 프롬프트·패턴 id 어디에도 홀드아웃 발화가 겹치면 누출이다. */
+export function maskingExampleLeaks(): string[] {
+  const prompts = NL_ROUTING_V5_QUESTIONS.map((question) => ({ id: question.id, text: normalizeUtterance(question.prompt) }));
+  const patternIds = NL_UTTERANCE_PATTERNS.map((pattern) => normalizeUtterance(pattern.id));
+  const leaks: string[] = [];
+  NL_ROUTING_MASKING_EXAMPLES.forEach((example, index) => {
+    const normalized = normalizeUtterance(example);
+    if (!normalized) return;
+    const hit = prompts.find((prompt) => prompt.text.includes(normalized) || normalized.includes(prompt.text));
+    if (hit) { leaks.push(`example${index + 1}:${hit.id}`); return; }
+    if (patternIds.some((id) => id.includes(normalized))) leaks.push(`example${index + 1}:pattern`);
+  });
+  return leaks;
+}
+
+export interface NlRoutingV5Score {
+  readonly questions: number;
+  readonly pathQuestions: number;
+  readonly compoundQuestions: number;
+  readonly patterns: number;
+  readonly pathPatterns: number;
+  readonly compoundPatterns: number;
+  readonly scored: number;
+  readonly passed: number;
+  readonly failed: readonly string[];
+  readonly failedRuns: number;
+  readonly maskingLeaks: readonly string[];
+  readonly patternMismatches: readonly string[];
+  readonly thresholdsMet: boolean;
+  readonly verdict: 'pass' | 'fail';
+}
+
+function expectationsMet(expects: readonly NlRoutingToolExpectation[], breakdown: Record<string, number>): boolean {
+  return expects.every((expectation) => (breakdown[expectation.tool] ?? 0) >= (expectation.minCount ?? 1));
+}
+
+/** v5 28문항을 «생산 runEvalPrompt seam» 으로 그대로 돌려 경로·복합 처리를 채점한다. */
+export async function scoreNlRoutingV5(opts: {
+  runPrompt: typeof runEvalPrompt;
+  surface: EvalPromptToolSurface;
+  cwd: string;
+  maxTurns?: number;
+}): Promise<NlRoutingV5Score> {
+  const maxTurns = opts.maxTurns ?? 6;
+  const matched = new Set<string>();
+  const failed: string[] = [];
+  const patternMismatches: string[] = [];
+  let scored = 0;
+  let passed = 0;
+  let failedRuns = 0;
+  for (const question of NL_ROUTING_V5_QUESTIONS) {
+    if (!matchNlUtterancePatterns(question.prompt).includes(question.pattern)) {
+      patternMismatches.push(question.id);
+    }
+    try {
+      const result = await opts.runPrompt({ prompt: question.prompt, maxTurns, tools: opts.surface, silent: true, cwd: opts.cwd });
+      scored += 1;
+      if (expectationsMet(question.expects, result.toolBreakdown)) {
+        passed += 1;
+        matched.add(question.pattern);
+      } else failed.push(question.id);
+    } catch {
+      failedRuns += 1;
+    }
+  }
+  const matchedPatterns = NL_UTTERANCE_PATTERNS.filter((pattern) => matched.has(pattern.id));
+  const leaks = maskingExampleLeaks();
+  const thresholdsMet = scored >= NL_ROUTING_V5_THRESHOLDS.scored
+    && passed >= NL_ROUTING_V5_THRESHOLDS.scored
+    && matchedPatterns.length >= NL_ROUTING_V5_THRESHOLDS.patterns
+    && leaks.length <= NL_ROUTING_V5_THRESHOLDS.maskingLeaks
+    && patternMismatches.length === 0;
+  return {
+    questions: NL_ROUTING_V5_QUESTIONS.length,
+    pathQuestions: NL_ROUTING_V5_QUESTIONS.filter((question) => NL_UTTERANCE_PATTERNS.find((pattern) => pattern.id === question.pattern)?.handles === 'path').length,
+    compoundQuestions: NL_ROUTING_V5_QUESTIONS.filter((question) => NL_UTTERANCE_PATTERNS.find((pattern) => pattern.id === question.pattern)?.handles === 'compound').length,
+    patterns: matchedPatterns.length,
+    pathPatterns: matchedPatterns.filter((pattern) => pattern.handles === 'path').length,
+    compoundPatterns: matchedPatterns.filter((pattern) => pattern.handles === 'compound').length,
+    scored,
+    passed,
+    failed,
+    failedRuns,
+    maskingLeaks: leaks,
+    patternMismatches,
+    thresholdsMet,
+    verdict: thresholdsMet ? 'pass' : 'fail',
+  };
+}
+
 function formatMachineLoad(load: MachineLoad): string {
   return `부하 ${load.loadAverage.map((value) => value.toFixed(2)).join('/')}, ${load.coreCount}코어`;
 }
@@ -110,7 +298,7 @@ export async function main(
   const unknownArgs = process.argv.slice(2);
   if (unknownArgs.length) {
     throw new Error(`이 러너는 인자를 받지 않는다 — 모르는 인자 ${unknownArgs.join(' ')}. `
-      + '설정은 환경변수다: CORPUS_CWD=<툴 작업 디렉토리> · CORPUS_PATH=<코퍼스 JSON 경로> · CORPUS_OUT=<원자료 JSON 경로> · CORPUS_TIERS · CORPUS_IDS · CORPUS_REPEATS · CORPUS_BUDGETS · CORPUS_CONCURRENCY');
+      + '설정은 환경변수다: CORPUS_CWD=<툴 작업 디렉토리> · CORPUS_PATH=<코퍼스 JSON 경로> · CORPUS_OUT=<원자료 JSON 경로> · CORPUS_TIERS · CORPUS_IDS · CORPUS_REPEATS · CORPUS_BUDGETS · CORPUS_CONCURRENCY · CORPUS_V5=1 (v5 28문항 경로·복합 처리 채점)');
   }
   const corpusCwd = resolveCorpusCwdFromEnv();
   const requestedSurface = process.env.CORPUS_SURFACE;
@@ -209,13 +397,30 @@ export async function main(
     console.log(`  실패 분류 — ①미발사 ${noFire} · ②툴 오선택 ${wrong} · ③거부툴 선택 ${rejected} (측정 가능 실행 ${measurableRecords.length})\n`);
   }
 
+  // ★ v5 28문항 경로·복합 처리 채점 — 같은 러너·같은 runEvalPrompt seam 으로 채점한다
+  //   (다른 자로 재면 판정선과 비교 불가 · 형태 F3). 임계 미달은 «조용한 0» 이 아니라 거부다.
+  let v5: NlRoutingV5Score | undefined;
+  if (process.env.CORPUS_V5 === '1') {
+    v5 = await scoreNlRoutingV5({ runPrompt, surface, cwd: corpusCwd, maxTurns: budgets[0] });
+    console.log(`[v5] patterns ${v5.patterns} (path ${v5.pathPatterns} · compound ${v5.compoundPatterns}) · 문항 ${v5.questions} (path ${v5.pathQuestions} · compound ${v5.compoundQuestions}) · 채점 ${v5.scored} · 통과 ${v5.passed} · 실패 ${v5.failed.length ? v5.failed.join(',') : '(없음)'} · 실행 실패 ${v5.failedRuns} · masking-leak ${v5.maskingLeaks.length} ${v5.maskingLeaks.length ? v5.maskingLeaks.join(',') : '(없음)'} · pattern-mismatch ${v5.patternMismatches.length ? v5.patternMismatches.join(',') : '(없음)'} · 판정 ${v5.verdict}`);
+    if (!v5.thresholdsMet) {
+      throw new Error(
+        `NL routing v5 entrance stopped: 채점 문항 ${v5.scored} < ${NL_ROUTING_V5_THRESHOLDS.scored}`
+        + ` 또는 올바른 라우팅 ${v5.passed} < ${NL_ROUTING_V5_THRESHOLDS.scored}`
+        + ` 또는 패턴 ${v5.patterns} < ${NL_ROUTING_V5_THRESHOLDS.patterns}`
+        + ` 또는 가림 예시 누출 ${v5.maskingLeaks.length} > ${NL_ROUTING_V5_THRESHOLDS.maskingLeaks}`
+        + ` 또는 패턴 미발화 ${v5.patternMismatches.length}.`,
+      );
+    }
+  }
+
   const errored = jobs.length - records.length;
   if (errored > 0) console.log(`⚠️ 실행 실패 ${errored}건은 측정 가능 표본의 누락 실행이며 관측된 k/n 분모에서 제외했다.`);
   const out = process.env.CORPUS_OUT;
   // ⛔⭐ 최상위 `machineLoad` 는 **런 시작 스냅샷**이고 이름은 그대로 둔다(기존 원자료가 그 뜻으로 쓰였다).
   //    레코드의 실제 부하는 `records[].loadAtStart`·`loadAtEnd` 다(`MEAS-T15` · 타입 주석에 표로 있다).
   //    ⛔ 별칭 필드를 나란히 두지 않는다 — 소비자 없는 중복은 **죽은 공개 필드**다(리뷰 must-fix 수용).
-  if (out) writeFileSync(out, JSON.stringify({ surface, repeats, budgets, machineLoad: load, observeOnly: safety.observeOnly, unsafeBypass: safety.bypassed, exposedMutatingTools: safety.exposedMutatingTools, surfaceToolNames, unmeasurableIds, records }, null, 2));
+  if (out) writeFileSync(out, JSON.stringify({ surface, repeats, budgets, machineLoad: load, observeOnly: safety.observeOnly, unsafeBypass: safety.bypassed, exposedMutatingTools: safety.exposedMutatingTools, surfaceToolNames, unmeasurableIds, ...(v5 ? { v5 } : {}), records }, null, 2));
 }
 
 if (import.meta.main) await main();

package/scripts/provision-export-redactions.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env bun
+import { provisionExportRedactions } from '../src/task-agent/export-redactions-provision.js';
+
+const host = process.argv[2];
+if (!host || process.argv.length !== 3) {
+  console.error('usage: bun scripts/provision-export-redactions.ts <train-host>');
+  process.exit(2);
+}
+try {
+  provisionExportRedactions(host);
+  console.log(`EXPORT_REDACTIONS_PROVISIONED host=${host}`);
+} catch (error) {
+  console.error(`EXPORT_REDACTIONS_UNMEASURED host=${host}: ${error instanceof Error ? error.message : 'unknown error'}`);
+  process.exitCode = 1;
+}

package/scripts/public-copy-lint.ts

@@ -0,0 +1,122 @@
+#!/usr/bin/env bun
+/** Warning-only public-copy shadow scan. It never edits source or exposes private candidate text. */
+import { existsSync, readFileSync } from 'node:fs';
+import { extname, normalize, relative, resolve, sep } from 'node:path';
+import { PatentLedger } from '../src/patents/ledger.js';
+import { checkBrandText } from './brand/check.js';
+
+export type PublicCopyInput = { label: string; text: string };
+export type PublicCopyFinding = { source: string; line: number; rule: string };
+export type PatentLineMatcher = (text: string) => number[];
+export type PublicCopyScan = {
+  findings: PublicCopyFinding[];
+  excludedSources: Array<{ source: string; reason: 'internal-goal-document' }>;
+  brandRulesAvailable: boolean;
+  patentLedgerAvailable: boolean;
+};
+
+function normalizedLabel(label: string): string | undefined {
+  const slashed = label.replaceAll('\\', '/');
+  if (slashed.startsWith('/')) return undefined;
+  const normalized = normalize(slashed).replaceAll('\\', '/').replace(/^\.\//, '');
+  if (normalized === '..' || normalized.startsWith('../')) return undefined;
+  return normalized;
+}
+
+function allowedNormalizedLabel(normalized: string | undefined): boolean {
+  if (!normalized) return false;
+  if (normalized === 'PR-BODY') return true;
+  if (normalized.split('/').some((part) => part === '..' || part === '')) return false;
+  if (!['.md', '.mdx', '.txt', '.html', '.htm'].includes(extname(normalized).toLowerCase())) return false;
+  return ['docs/', 'release/public/docs/', 'blog/', 'posts/', 'content/blog/', 'content/posts/']
+    .some((root) => normalized.startsWith(root));
+}
+
+/** Brand rule messages intentionally omit matched text; patent matches are private too. */
+export function scanPublicCopy(inputs: readonly PublicCopyInput[], matchPrivateCandidate: PatentLineMatcher, rulesPath?: string): PublicCopyScan {
+  const findings: PublicCopyFinding[] = [];
+  const excludedSources: PublicCopyScan['excludedSources'] = [];
+  let brandRulesAvailable = true;
+  let patentLedgerAvailable = true;
+  for (const input of inputs) {
+    const label = normalizedLabel(input.label);
+    if (!allowedNormalizedLabel(label)) throw new Error(`공개 문면 입력 경로가 허용 목록 밖입니다: ${input.label}`);
+    // Goal specs are internal execution artifacts, not customer-facing copy.
+    // Counting their acceptance criteria as marketing measurements created a
+    // high false-positive rate in the 30-PR audit.
+    if (label?.startsWith('docs/goals/')) {
+      excludedSources.push({ source: input.label, reason: 'internal-goal-document' });
+      continue;
+    }
+    try {
+      const brandFindings = checkBrandText(input.text, input.label, 'public-docs', rulesPath);
+      // Publication-specific promise/measurement rules apply to this explicit
+      // shadow scan without changing the existing generic brand-check scopes.
+      const publicationFindings = checkBrandText(input.text, input.label, 'release-notes', rulesPath)
+        .filter((hit) => hit.id === 'BRAND-SOON' || hit.id === 'B4-NUMBER-SOURCE');
+      for (const hit of [...brandFindings, ...publicationFindings]) {
+        findings.push({ source: input.label, line: hit.line, rule: hit.id });
+      }
+    } catch { brandRulesAvailable = false; }
+    try { for (const line of matchPrivateCandidate(input.text)) findings.push({ source: input.label, line, rule: 'PRIVATE-PATENT-CANDIDATE' }); }
+    catch { patentLedgerAvailable = false; }
+  }
+  if (inputs.length === 0 || excludedSources.length === inputs.length) {
+    // No scanner ran, so availability must not claim a successful measurement.
+    brandRulesAvailable = false;
+    patentLedgerAvailable = false;
+  }
+  return {
+    findings: findings.sort((a, b) => a.source.localeCompare(b.source) || a.line - b.line || a.rule.localeCompare(b.rule)),
+    excludedSources,
+    brandRulesAvailable, patentLedgerAvailable,
+  };
+}
+
+export function lintPublicCopy(inputs: readonly PublicCopyInput[], matchPrivateCandidate: PatentLineMatcher): PublicCopyFinding[] {
+  return scanPublicCopy(inputs, matchPrivateCandidate).findings;
+}
+
+export function run(argv: readonly string[], root = process.cwd(), ledger = new PatentLedger()): number {
+  const files: string[] = [];
+  let bodyFile: string | undefined;
+  let bodyLabel = 'PR-BODY';
+  let json = false;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]!;
+    if (arg === '--json') json = true;
+    else if (arg === '--files') {
+      while (argv[i + 1] && !argv[i + 1]!.startsWith('--')) files.push(argv[++i]!);
+      if (!files.length) throw new Error('--files 에 문면 경로가 필요합니다');
+    } else if (arg === '--pr-body-file') {
+      bodyFile = argv[++i];
+      if (!bodyFile || bodyFile.startsWith('--')) throw new Error('--pr-body-file 에 본문 파일이 필요합니다');
+    } else if (arg === '--pr-body-label') {
+      bodyLabel = argv[++i] ?? '';
+      if (!bodyLabel || bodyLabel.startsWith('--')) throw new Error('--pr-body-label 에 라벨이 필요합니다');
+    } else throw new Error(`알 수 없는 옵션: ${arg}`);
+  }
+  if (!files.length && !bodyFile) throw new Error('usage: bun scripts/public-copy-lint.ts [--files <docs...>] [--pr-body-file <file> [--pr-body-label <repo-relative-label>]] [--json]');
+  const inputs: PublicCopyInput[] = files.map((file) => ({
+    label: relative(root, resolve(root, file)).split(sep).join('/'), text: readFileSync(resolve(root, file), 'utf8'),
+  }));
+  if (bodyFile) inputs.push({ label: bodyLabel, text: readFileSync(resolve(root, bodyFile), 'utf8') });
+  const matchPrivateCandidate: PatentLineMatcher = (text) => {
+    return ledger.unapprovedCandidateLineNumbers(text);
+  };
+  const scan = scanPublicCopy(inputs, matchPrivateCandidate);
+  if (json) console.log(JSON.stringify({ mode: 'warning-only', ...scan }));
+  else {
+    for (const finding of scan.findings) console.log(`${finding.source}:${finding.line}:WARN:${finding.rule}`);
+    for (const excluded of scan.excludedSources) console.log(`${excluded.source}:SKIP:${excluded.reason}`);
+    if (!scan.brandRulesAvailable) console.log('WARN:BRAND-RULES-UNMEASURED');
+    if (!scan.patentLedgerAvailable) console.log('WARN:PRIVATE-PATENT-LEDGER-UNMEASURED');
+    console.log(`public-copy-lint warning-only documents=${inputs.length - scan.excludedSources.length} excluded=${scan.excludedSources.length} findings=${scan.findings.length} brand-rules=${scan.brandRulesAvailable ? 'measured' : 'unmeasured'} patent-ledger=${scan.patentLedgerAvailable ? 'measured' : 'unmeasured'}`);
+  }
+  return 0;
+}
+
+if (import.meta.main) {
+  try { process.exitCode = run(process.argv.slice(2)); }
+  catch (error) { console.error(error instanceof Error ? error.message : String(error)); process.exitCode = 2; }
+}

package/scripts/public-export.ts

@@ -101,14 +101,74 @@ function redactionPattern(from: string): RegExp {
   const post = /[A-Za-z0-9]$/.test(from) ? '(?![A-Za-z0-9])' : '';
   return new RegExp(`${pre}${escapeRegExp(from)}${post}`, 'gu');
 }
+const CODE_FILE = /\.(?:ts|tsx|mts|cts|js|jsx|mjs|cjs)$/iu;
+type RedactionProblem = { marker: 'private-redaction-identifier' | 'private-redaction-syntax' | 'private-source-syntax'; file: string; line: number; text: string };
+class PrivateRedactionError extends Error {
+  constructor(message: string, readonly hits: readonly RedactionProblem[]) { super(message); }
+}
+
+function codeIdentifierRanges(file: string, text: string): Array<{ start: number; end: number; name: string }> {
+  if (!CODE_FILE.test(file)) return [];
+  const scanner = ts.createScanner(ts.ScriptTarget.Latest, false,
+    /\.(?:tsx|jsx)$/iu.test(file) ? ts.LanguageVariant.JSX : ts.LanguageVariant.Standard, text);
+  const ranges: Array<{ start: number; end: number; name: string }> = [];
+  for (let token = scanner.scan(); token !== ts.SyntaxKind.EndOfFileToken; token = scanner.scan()) {
+    if (token === ts.SyntaxKind.Identifier || token === ts.SyntaxKind.PrivateIdentifier
+      || token >= ts.SyntaxKind.FirstKeyword && token <= ts.SyntaxKind.LastKeyword) {
+      ranges.push({ start: scanner.getTokenPos(), end: scanner.getTextPos(), name: scanner.getTokenText() });
+    }
+  }
+  return ranges;
+}
+
+function assertRedactionsAvoidIdentifiers(file: string, text: string, redactions: readonly PrivateRedaction[]): void {
+  if (!CODE_FILE.test(file) || !redactions.some((redaction) => text.includes(redaction.from))) return;
+  const identifiers = codeIdentifierRanges(file, text);
+  if (!identifiers.length) return;
+  const hits: RedactionProblem[] = [];
+  for (const redaction of redactions) {
+    for (const match of text.matchAll(redactionPattern(redaction.from))) {
+      const start = match.index;
+      const token = identifiers.find((entry) => start < entry.end && start + match[0].length > entry.start);
+      if (!token) continue;
+      const line = text.slice(0, token.start).split('\n').length;
+      hits.push({ marker: 'private-redaction-identifier', file, line, text: token.name });
+    }
+  }
+  const unique = [...new Map(hits.map((hit) => [`${hit.file}:${hit.line}:${hit.text}`, hit])).values()];
+  if (unique.length) throw new PrivateRedactionError(`private redaction would change code identifiers: ${unique.slice(0, 12).map((hit) => `${hit.file}:${hit.line} ${hit.text}`).join(', ')}${unique.length > 12 ? ` (+${unique.length - 12} more)` : ''}`, unique);
+}
+
+function firstCodeParseError(file: string, text: string): { line: number; message: string } | null {
+  if (!CODE_FILE.test(file)) return null;
+  const kind = /\.(?:tsx|jsx)$/iu.test(file) ? ts.ScriptKind.TSX
+    : /\.(?:js|mjs|cjs)$/iu.test(file) ? ts.ScriptKind.JS : ts.ScriptKind.TS;
+  const parsed = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, false, kind) as ts.SourceFile & { parseDiagnostics: readonly ts.Diagnostic[] };
+  const first = parsed.parseDiagnostics[0];
+  return first ? { line: parsed.getLineAndCharacterOfPosition(first.start ?? 0).line + 1,
+    message: ts.flattenDiagnosticMessageText(first.messageText, ' ') } : null;
+}
+
+function assertRedactedCodeParses(file: string, before: string, after: string): void {
+  const failure = firstCodeParseError(file, after);
+  if (!failure) return;
+  const baseline = firstCodeParseError(file, before);
+  const issue = baseline ?? failure;
+  const marker = baseline ? 'private-source-syntax' : 'private-redaction-syntax';
+  const label = baseline ? 'source code was already invalid before redaction' : 'private redaction produced invalid code';
+  throw new PrivateRedactionError(`${label} at ${file}:${issue.line}: ${issue.message}`,
+    [{ marker, file, line: issue.line, text: issue.message }]);
+}
+
 export function applyPrivateRedactions(contents: ReadonlyMap<string, string>, redactions: readonly PrivateRedaction[]): { contents: Map<string, string>; files: number; places: number } {
   const result = new Map(contents);
   let files = 0; let places = 0;
   for (const [file, text] of result) {
     if (text.includes('\u0000')) continue;
+    assertRedactionsAvoidIdentifiers(file, text, redactions);
     let out = text; let changed = 0;
     for (const r of redactions) out = out.replace(redactionPattern(r.from), () => { changed++; return r.to; });
-    if (changed) { result.set(file, out); files++; places += changed; }
+    if (changed) { assertRedactedCodeParses(file, text, out); result.set(file, out); files++; places += changed; }
   }
   return { contents: result, files, places };
 }
@@ -461,7 +521,14 @@ export function run(argv: readonly string[], root = resolve(import.meta.dir, '..
     // ⭐ 개인 치환표(저장소 밖) — 규칙 변환 «뒤»에 건다. 없으면 «못 봤다»로 막는다.
     const redactions = loadPrivateRedactions();
     const noPrivateList = argv.includes('--no-private-list');
-    const redacted = redactions ? applyPrivateRedactions(transformedByRules.contents, redactions) : { contents: transformedByRules.contents, files: 0, places: 0 };
+    let redacted: ReturnType<typeof applyPrivateRedactions>;
+    try { redacted = redactions ? applyPrivateRedactions(transformedByRules.contents, redactions) : { contents: transformedByRules.contents, files: 0, places: 0 }; }
+    catch (error) {
+      console.error(`⛔ ${error instanceof Error ? error.message : String(error)}`);
+      if (json && error instanceof PrivateRedactionError) console.log(JSON.stringify({ files: scanned.length,
+        leaks: error.hits.length, hits: error.hits }));
+      return 1;
+    }
     const transformed = { contents: redacted.contents, counts: transformedByRules.counts };
     const privateRedactions = { table: privateRedactionsPath(), loaded: redactions !== null, entries: redactions?.length ?? 0, files: redacted.files, places: redacted.places };
     if (redactions) console.error(`private redactions: ${redacted.files} files · ${redacted.places} places (${redactions.length} entries · ${privateRedactionsPath()})`);