@tienne/gestalt 0.77.1 → 0.77.2

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tienne/gestalt",
-  "version": "0.77.1",
+  "version": "0.77.2",
   "description": "TypeScript AI Development Harness - Gestalt psychology-driven requirement clarification",
   "repository": {
     "type": "git",

package/dist/plugin/skills/review/SKILL.md

@@ -517,7 +517,18 @@ ges_execute {
   action: "review_consensus",
   reviewSessionId: "<reviewSessionId>",
   reviewConsensus: {
-    mergedIssues: [...전체 이슈 병합...],
+    mergedIssues: [
+      {
+        id: "...",
+        severity: "critical" | "high" | "warning",
+        category: "...",
+        file: "...",
+        line: 12,              // 선택 — 파일 전반이면 생략
+        message: "...",
+        suggestion: "...",
+        reportedBy: "quality-reviewer"   // 필수. 문자열 하나다
+      }
+    ],
     approvedBy: [...],
     blockedBy: [...],
     summary: "...",
@@ -527,6 +538,8 @@ ges_execute {
 }
 ```
 
+`line`만 선택이고 나머지는 전부 필수입니다. **`reportedBy`는 배열이 아니라 에이전트 이름 문자열 하나**입니다 — 여러 에이전트가 같은 걸 짚었으면 대표 하나만 적습니다.
+
 엔진이 두 심급을 합쳐 판정합니다 — **결함(critical/high)이 없고 `coherent: true`여야 통과**입니다. `continuityVerdict`를 생략하면 결함 심급만으로 판정하는 기존 동작 그대로입니다.
 
 응답 해석:

package/dist/src/mcp/input-guard.d.ts

@@ -0,0 +1,90 @@
+/**
+ * MCP 도구 입력 검증을 부르는 쪽이 고칠 수 있는 형태로 돌려주는 자리.
+ *
+ * MCP SDK는 도구를 부르기 전에 등록된 zod 스키마로 인자를 검증한다. 실패하면
+ * 첫 이슈의 message 한 줄만 뽑아 `Invalid arguments for tool ...`로 던진다. 우리
+ * 핸들러는 그 전에 못 끼어든다. 그래서 고칠 수 있는 자리는 스키마 자체다.
+ *
+ * 심는 방어는 이렇다.
+ * - 객체나 배열을 기대하는 파라미터에 문자열이 오면 `JSON.parse`를 먼저 시도한다.
+ *   호스트가 JSON 문자열을 못 풀고 원본을 그대로 넘기는 일이 있는데, 그때 나오는
+ *   `Expected object, received string`은 진짜 원인(문자열이 깨졌다)을 덮어버린다.
+ * - 파싱이 실패하면 파서의 원본 에러와 깨진 지점 주변을 함께 싣는다. 수만 자짜리
+ *   페이로드에서 위치 숫자만으론 어디가 깨졌는지 못 찾는다.
+ * - 타입이 어긋나면 실제로 받은 값의 샘플과 경로를 메시지에 붙인다. SDK가 첫 이슈
+ *   message만 꺼내가므로 경로까지 message 안에 넣어야 살아남는다.
+ *
+ * **JSON 문자열 관용은 도구 파라미터(최상위 키)에만 걸린다.** `guardShape`가 shape의
+ * 키만 돌기 때문이다. `reviewConsensus`는 문자열로 보내도 풀리지만 그 안의
+ * `mergedIssues`를 문자열로 보내면 여전히 타입 에러로 떨어진다 — 대신 경로와 받은
+ * 값이 붙어 원인은 읽힌다. 중첩까지 넓히려면 배열 요소 스키마를 재구성해야 하는데,
+ * 실제로 문자열이 오는 자리는 최상위 파라미터라 거기까지 가지 않았다.
+ *
+ * **이 파일은 zod v3 내부 구조(`_def`)에 기댄다.** semver 보장 대상이 아니라 마이너
+ * 업그레이드에도 깨질 수 있다. 깨지면 예외 없이 조용히 안 걸린다 — 에러 메시지만 예전으로
+ * 돌아가고 아무도 모른다. 그래서 `tests/unit/mcp/input-guard.test.ts`가 컨테이너 종류마다
+ * 잎을 심어 순회가 그 잎에 닿는지 본다. zod 버전을 올리면 그 테스트를 반드시 다시 돌린다.
+ */
+import { z } from 'zod';
+/** 규칙 표를 테스트가 확인할 수 있게 내보낸다. 런타임 경로는 이 함수를 안 쓴다. */
+export declare function tokenRulesForTest(): ReadonlyArray<readonly [string, number]>;
+/** 패턴 계약을 테스트가 확인할 수 있게 내보낸다. 런타임 경로는 이 함수를 안 쓴다. */
+export declare function secretPatternsForTest(): RegExp[];
+/** 실제로 받은 값을 에러 메시지에 실을 수 있게 줄여 찍는다. */
+export declare function formatReceived(value: unknown): string;
+/**
+ * 깨진 지점 주변만 잘라 보여준다.
+ *
+ * 가리기를 먼저 하고 자른다. 순서를 뒤집으면 윈도우가 접두어를 잘라낸 조각에서 패턴이
+ * 안 걸린다 — 따옴표를 안 닫은 JSON 이 그 자리다. V8 이 보고하는 위치가 문자열 끝이라
+ * 접두어가 윈도우 앞으로 밀려난다.
+ *
+ * 깨진 지점이 자격증명 안이면 그 자리가 별표로 덮여 원인이 안 보인다. 드문 경우이고
+ * 파서 사유와 line, column 은 그대로 남는다 — 노출을 막는 쪽을 택했다.
+ */
+export declare function snippetAround(text: string, position: number, radius?: number): string;
+/** JSON 파싱 실패를 부르는 쪽이 바로 고칠 수 있는 한 줄로 만든다. */
+export declare function describeJsonParseFailure(label: string, raw: string, error: unknown): string;
+/**
+ * 타입이 어긋났을 때 무엇이 왔는지까지 말해주는 errorMap.
+ *
+ * SDK가 첫 이슈의 message만 꺼내 쓰므로 경로(`a.b[0].c`)도 여기 넣는다. 안 넣으면
+ * 어느 필드가 틀렸는지가 통째로 사라진다.
+ */
+export declare const verboseErrorMap: z.ZodErrorMap;
+/**
+ * 스키마 트리 전체에 errorMap을 심는다.
+ *
+ * 제자리에서 고친다. 중첩 배열 요소까지 닿아야 `mergedIssues[0].reportedBy` 같은
+ * 자리의 에러에도 경로와 샘플이 붙는다.
+ *
+ * 가드가 둘이고 하는 일이 다르다.
+ * - `seen`에 있는 스키마 인스턴스는 **노드 전체를 건너뛴다** (자식 순회까지 중단).
+ *   순환 참조와 공유 참조 대비다.
+ * - errorMap이 이미 있는 스키마는 **값 재할당만 건너뛰고** 자식 순회는 계속한다.
+ *   같은 shape에 두 번 걸려도 안쪽이 빠짐없이 덮인다.
+ */
+export declare function attachErrorMap<S extends z.ZodTypeAny>(schema: S, seen?: WeakSet<object>): S;
+/**
+ * 객체나 배열 파라미터에 JSON 문자열을 허용한다.
+ *
+ * 껍질(optional/default)은 벗겼다가 그대로 다시 씌운다. `preprocess`를 바깥에 두면
+ * SDK가 필수 파라미터로 잘못 노출하고 `describe()`도 날아간다.
+ */
+export declare function tolerateJsonString<S extends z.ZodTypeAny>(schema: S, label: string): z.ZodTypeAny;
+/**
+ * 도구 등록에 넘길 raw shape에 방어를 입힌다.
+ *
+ * 두 번 지나도 결과가 같다. 다만 구조가 그대로 남는다는 뜻은 아니다. `attachErrorMap`은
+ * 값이 비었을 때만 대입하므로 손대는 게 없지만 `tolerateJsonString`은 두 번째 통과에서
+ * `preprocess`를 한 겹 더 씌운다. 바깥 겹이 문자열을 풀면 안쪽 겹에는 문자열이 아닌 값이
+ * 와서 그대로 지나간다. 상한 검사와 파싱 실패 문구도 한 번만 실린다.
+ *
+ * `schemas.ts`에서 `guardObject`를 지난 스키마가 `server.ts`의 `guardedTool`에서 한 번
+ * 더 지나는 게 그 경로다. 등록 채널을 하나로 남기는 것이 이 설계의 전제라, 레이어를
+ * 갈라 그 채널을 다시 여는 쪽으로는 안 간다.
+ */
+export declare function guardShape<S extends z.ZodRawShape>(shape: S): S;
+/** 핸들러가 직접 `.parse()`하는 스키마에도 같은 방어를 입힌다. */
+export declare function guardObject<S extends z.AnyZodObject>(schema: S): S;
+//# sourceMappingURL=input-guard.d.ts.map

package/dist/src/mcp/input-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-guard.d.ts","sourceRoot":"","sources":["../../../src/mcp/input-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAwKxB,oDAAoD;AACpD,wBAAgB,iBAAiB,IAAI,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAE5E;AAED,qDAAqD;AACrD,wBAAgB,qBAAqB,IAAI,MAAM,EAAE,CAEhD;AA8CD,wCAAwC;AACxC,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAarD;AAUD;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,SAAiB,GAAG,MAAM,CAQ7F;AAED,8CAA8C;AAC9C,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM,CAe3F;AAED;;;;;GAKG;AACH,eAAO,MAAM,eAAe,EAAE,CAAC,CAAC,WA0B/B,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EACnD,MAAM,EAAE,CAAC,EACT,IAAI,GAAE,OAAO,CAAC,MAAM,CAAiB,GACpC,CAAC,CA4EH;AAiDD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EAAE,MAAM,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,CAAC,UAAU,CAwCjG;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAM/D;AAED,6CAA6C;AAC7C,wBAAgB,WAAW,CAAC,CAAC,SAAS,CAAC,CAAC,YAAY,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAElE"}

package/dist/src/mcp/input-guard.js

@@ -0,0 +1,531 @@
+/**
+ * MCP 도구 입력 검증을 부르는 쪽이 고칠 수 있는 형태로 돌려주는 자리.
+ *
+ * MCP SDK는 도구를 부르기 전에 등록된 zod 스키마로 인자를 검증한다. 실패하면
+ * 첫 이슈의 message 한 줄만 뽑아 `Invalid arguments for tool ...`로 던진다. 우리
+ * 핸들러는 그 전에 못 끼어든다. 그래서 고칠 수 있는 자리는 스키마 자체다.
+ *
+ * 심는 방어는 이렇다.
+ * - 객체나 배열을 기대하는 파라미터에 문자열이 오면 `JSON.parse`를 먼저 시도한다.
+ *   호스트가 JSON 문자열을 못 풀고 원본을 그대로 넘기는 일이 있는데, 그때 나오는
+ *   `Expected object, received string`은 진짜 원인(문자열이 깨졌다)을 덮어버린다.
+ * - 파싱이 실패하면 파서의 원본 에러와 깨진 지점 주변을 함께 싣는다. 수만 자짜리
+ *   페이로드에서 위치 숫자만으론 어디가 깨졌는지 못 찾는다.
+ * - 타입이 어긋나면 실제로 받은 값의 샘플과 경로를 메시지에 붙인다. SDK가 첫 이슈
+ *   message만 꺼내가므로 경로까지 message 안에 넣어야 살아남는다.
+ *
+ * **JSON 문자열 관용은 도구 파라미터(최상위 키)에만 걸린다.** `guardShape`가 shape의
+ * 키만 돌기 때문이다. `reviewConsensus`는 문자열로 보내도 풀리지만 그 안의
+ * `mergedIssues`를 문자열로 보내면 여전히 타입 에러로 떨어진다 — 대신 경로와 받은
+ * 값이 붙어 원인은 읽힌다. 중첩까지 넓히려면 배열 요소 스키마를 재구성해야 하는데,
+ * 실제로 문자열이 오는 자리는 최상위 파라미터라 거기까지 가지 않았다.
+ *
+ * **이 파일은 zod v3 내부 구조(`_def`)에 기댄다.** semver 보장 대상이 아니라 마이너
+ * 업그레이드에도 깨질 수 있다. 깨지면 예외 없이 조용히 안 걸린다 — 에러 메시지만 예전으로
+ * 돌아가고 아무도 모른다. 그래서 `tests/unit/mcp/input-guard.test.ts`가 컨테이너 종류마다
+ * 잎을 심어 순회가 그 잎에 닿는지 본다. zod 버전을 올리면 그 테스트를 반드시 다시 돌린다.
+ */
+import { z } from 'zod';
+const Kind = z.ZodFirstPartyTypeKind;
+/** 깨진 지점 앞뒤로 보여줄 글자 수. */
+const SNIPPET_RADIUS = 40;
+/** 에러 메시지에 실을 값 샘플의 최대 길이. */
+const SAMPLE_LIMIT = 120;
+// 한 줄 메시지에 실을 샘플이라 깊이 2와 앞 몇 개면 어느 필드가 틀렸는지는 읽힌다.
+// 더 들어가도 어차피 SAMPLE_LIMIT 에서 잘린다.
+const SAMPLE_DEPTH = 2;
+const SAMPLE_ARRAY_ITEMS = 5;
+const SAMPLE_OBJECT_KEYS = 10;
+/**
+ * 이보다 긴 문자열은 파싱을 안 해보고 거절한다.
+ *
+ * Node는 싱글 스레드라 거대한 문자열 하나의 `JSON.parse`가 이벤트 루프를 붙잡으면
+ * 같은 서버의 다른 세션 요청까지 멈춘다. 파싱에 실패하는 자리가 아니라 파싱 자체를
+ * 안 하는 자리다.
+ */
+const MAX_JSON_STRING_LENGTH = 1_000_000;
+/** 문자열 대신 구조를 기대하는 스키마 — 여기에만 JSON 문자열을 허용한다. */
+const STRUCTURED_KINDS = new Set([
+    Kind.ZodObject,
+    Kind.ZodArray,
+    Kind.ZodRecord,
+    Kind.ZodTuple,
+]);
+/**
+ * 에러 문구에 실리기 전에 가릴 토큰.
+ *
+ * 이 메시지는 MCP 클라이언트로 내려가 호스트 로그에 남는다. 검증에 실패한 값이
+ * 사용자 콘텐츠를 담는 필드면 거기 섞인 자격증명이 로그에 영구히 남는다. 접두어는
+ * 남겨서 무엇이 가려졌는지는 읽히게 한다.
+ *
+ * **알려진 접두어만 가린다.** 접두어가 없는 값(AWS 시크릿 액세스 키 같은 40자 난수)도,
+ * 접두어가 있는데 아래 표에 없는 값(`glpat-`, `SG.`, `dop_v1_` 같은 것)도 못 잡는다.
+ * 완전히 막는 장치가 아니라 흔한 실수를 줄이는 자리다. 표를 채우는 건 한 줄이다.
+ * 경계 판정이 항목 수만큼 도므로 추가에 드는 비용도 그것뿐이다.
+ *
+ * 끄는 수단은 두지 않았다. 이 값은 에러 문구에 실려 로그로 나가는 데이터라, 가리기를
+ * 끄는 스위치를 두면 그게 노출 경로가 된다.
+ */
+/**
+ * 접두어와 그 뒤 본문의 최소 길이.
+ *
+ * **하한을 접두어마다 따로 잡는다.** 하나로 묶으면 둘 중 하나가 깨진다 — 낮게 잡으면
+ * `npm_package_name` 과 `task-scheduler` 처럼 꼬리가 긴 멀쩡한 식별자가 가려진다.
+ * 높게 잡으면 짧은 토큰을 놓친다. 값은 각 서비스가 발급하는 길이에서 왔다.
+ *
+ * `sk-` 와 `AKIA`, `npm_` 은 영단어 안에 흔히 들어간다. 그쪽 하한이 특히 실제 발급
+ * 길이에 붙어 있어야 `risk-assessment` 가 안 걸린다.
+ */
+const TOKEN_RULES = [
+    // Stripe — API 키 24자 이상, 제한 키와 웹훅 서명 시크릿도 같은 꼴이다. 웹훅 시크릿이
+    // 새면 서명을 위조해 임의 이벤트를 밀어넣을 수 있어 API 키와 위험의 종류가 다르다.
+    ['sk_live_', 20],
+    ['sk_test_', 20],
+    ['rk_live_', 20],
+    ['rk_test_', 20],
+    ['whsec_', 20],
+    // GitHub — PAT 36자, fine-grained 82자. ghu_ 와 ghr_ 은 GitHub App 쪽이다.
+    ['ghp_', 30],
+    ['gho_', 30],
+    ['ghs_', 30],
+    ['ghu_', 30],
+    ['ghr_', 30],
+    ['github_pat_', 30],
+    // Slack — 가변이라 낮게 잡는다. 영단어에 안 나오는 꼴이라 낮아도 안전하다.
+    // xapp- 은 Socket Mode 앱 레벨 토큰이다.
+    ['xox[baprs]-', 10],
+    ['xapp-', 10],
+    // Google API 키 — 35자
+    ['AIza', 30],
+    // 뒤에 공백류뿐 아니라 이스케이프된 개행(`\n` 두 글자)도 받는다. `formatReceived` 는
+    // `JSON.stringify` 를 먼저 거치므로 그 자리에 실제 개행이 안 남는다.
+    //
+    // 하한이 낮다. Bearer 뒤에 오는 토큰은 서비스마다 꼴이 달라 8자짜리 공유 시크릿을
+    // 그대로 보내는 API 도 있다.
+    //
+    // 그 대가로 `Bearer authentication required` 는 `Bearer *** required` 가 된다. 여섯
+    // 자를 넘는 뒷말이면 영어 단어라도 가려진다 — 짧은 말(`Bearer token`)만 살아남는다.
+    // 이 파일이 세운 우선순위(못 가리는 쪽이 잘못 가리는 쪽보다 나쁘다)를 그대로 따른
+    // 값이다.
+    ['Bearer(?:\\s|\\\\n|\\\\r)+', 6],
+    // OpenAI — 48자 안팎. `task-`, `risk-`, `desk-` 한가운데에 걸린다.
+    ['sk-', 20],
+    // AWS — 액세스 키 ID 는 뒤에 16자. ASIA 는 STS 임시 자격증명이라 운영에서 더 흔하다.
+    // `AKIActually` 같은 단어가 하한 밑으로 떨어진다.
+    ['AKIA', 16],
+    ['ASIA', 16],
+    // npm 토큰 — 36자. `npm_config_registry` 류 환경변수 이름이 그 아래로 떨어진다.
+    ['npm_', 30],
+];
+/**
+ * 접두어를 그룹 1 로 캡처한다. 규칙마다 패턴 하나씩 만든다.
+ *
+ * **단어 경계는 두지 않는다.** `(?<![A-Za-z0-9_])` 를 붙이면 `my_ghp_REAL` 이나
+ * `123ghp_REAL` 처럼 접두어 앞에 단어 문자가 붙은 진짜 토큰을 놓친다. 못 가리는 쪽이
+ * 잘못 가리는 쪽보다 나쁘다 — 가리는 게 이 함수의 일이다. 잘못 가리는 건 접두어별
+ * 하한으로 막는다.
+ */
+function tokenPatterns() {
+    return TOKEN_RULES.map(([prefix, minBody]) => {
+        // JWT 는 점으로 세 조각이다. 점을 안 받으면 헤더만 가려지고 payload 와 signature 가
+        // 남는데, 헤더는 추측 가능하니 남은 쪽이 사실상 자격증명 전체다. `Bearer` 뒤에만
+        // 허용하므로 `npm_package_name` 류 하한 보호에는 영향이 없다.
+        const body = prefix.startsWith('Bearer') ? '[A-Za-z0-9_.-]' : '[A-Za-z0-9_-]';
+        return new RegExp(`(${prefix})${body}{${minBody},}`, 'g');
+    });
+}
+/**
+ * 헤더부터 END 마커까지, 없으면 JSON 문자열 경계나 끝까지 삼킨다.
+ *
+ * 본문을 base64 문자 집합으로 좁히면 암호화 PEM 을 못 덮는다 — `Proc-Type: 4,ENCRYPTED`
+ * 와 `DEK-Info: AES-128-CBC,<salt>` 에 든 콜론과 쉼표에서 매칭이 끊긴다. END 가 선택
+ * 그룹이라 그 자리에서 종료되고 본문과 푸터가 그대로 남는다.
+ *
+ * **따옴표를 경계로 쓰지 않는다.** 본문에 따옴표가 있으면 거기서 일찍 끊겨 뒤가 남는다.
+ * `formatReceived` 는 `JSON.stringify` 를 거치므로 값 안의 따옴표가 그 자리에 실제로
+ * 온다. 대신 lazy 라서 END 가 있으면 거기서 멈춘다. 없으면 끝까지 삼킨다 — 헤더가
+ * 보였다는 건 그 값이 키라는 뜻이라 나머지를 보여줄 이유가 없다.
+ */
+const PEM_PATTERN = /(-----BEGIN [A-Z ]*PRIVATE KEY-----)[\s\S]*?(?:-----END [A-Z ]*PRIVATE KEY-----|$)/g;
+/**
+ * 순서가 바꾸는 건 어느 접두어가 남는지뿐이다. 가려지는지 여부와 남는 길이는 안 바뀐다.
+ * `Bearer ghp_…` 처럼 규칙이 겹치는 입력에서 앞 순서는 `Bearer ghp_***`, 역순은
+ * `Bearer ***` 를 낸다 — 둘 다 본문은 덮인다.
+ *
+ * 본문을 base64 집합으로 좁혔던 동안에는 순서가 노출 자체를 갈랐다. 토큰 패턴의 치환
+ * 문자가 PEM 매칭을 끊어 뒤가 통째로 남았다 — 그 클래스를 되돌리면서 사라졌다.
+ */
+const SECRET_PATTERNS = [PEM_PATTERN, ...tokenPatterns()];
+/**
+ * 토큰을 가린다. 접두어는 남겨 무엇이 가려졌는지는 읽히게 한다.
+ *
+ * **모든 패턴이 접두어를 그룹 1 로 캡처한다.** 그룹이 없는 패턴을 섞으면
+ * `String.replace` 가 두 번째 인자로 매치 오프셋(숫자)을 넘겨, 접두어가 숫자로 바뀌고
+ * 치환 길이가 무너진다. 그 계약은 `tests/unit/mcp/input-guard.test.ts` 가 패턴 배열을
+ * 돌며 단언한다.
+ *
+ * **잘라낸 조각에 따로 걸지 않는다.** 접두어와 몸통이 서로 다른 조각에 놓이면 어느 쪽도
+ * 패턴에 안 걸려 토큰이 통째로 남는다. 부르는 쪽은 언제나 원본 전체를 넘긴다.
+ *
+ * `preserveLength` 는 `snippetAround` 만 쓴다. 자리가 밀리면 깨진 지점을 못 짚기 때문이다.
+ * 나머지 자리는 고정 길이로 덮어 별표 개수가 원문 길이를 드러내지 않게 한다.
+ */
+function redactSecrets(text, options = {}) {
+    return SECRET_PATTERNS.reduce((acc, pattern) => acc.replace(pattern, (match, group) => {
+        const prefix = typeof group === 'string' ? group : '';
+        if (!options.preserveLength)
+            return `${prefix}***`;
+        // 하한을 두지 않는다. 본문이 빈 헤더에 별표를 덧붙이면 그만큼 자리가 밀린다.
+        return prefix + '*'.repeat(match.length - prefix.length);
+    }), text);
+}
+/** 규칙 표를 테스트가 확인할 수 있게 내보낸다. 런타임 경로는 이 함수를 안 쓴다. */
+export function tokenRulesForTest() {
+    return TOKEN_RULES;
+}
+/** 패턴 계약을 테스트가 확인할 수 있게 내보낸다. 런타임 경로는 이 함수를 안 쓴다. */
+export function secretPatternsForTest() {
+    return [...SECRET_PATTERNS];
+}
+/** 한 줄 메시지에 실으므로 줄바꿈은 눈에 보이게 바꾼다. */
+function escapeNewlines(text) {
+    return text.replace(/\r/g, '\\r').replace(/\n/g, '\\n');
+}
+function typeNameOf(schema) {
+    return schema._def.typeName;
+}
+function formatPath(path) {
+    return path.reduce((acc, segment) => {
+        if (typeof segment === 'number')
+            return `${acc}[${segment}]`;
+        return acc === '' ? String(segment) : `${acc}.${segment}`;
+    }, '');
+}
+/**
+ * 직렬화 전에 값을 얕게 잘라낸다.
+ *
+ * 메시지에 실리는 건 120자뿐인데 거대한 배열을 통째로 문자열로 만들면 그 비용을 다
+ * 문다. 깊이와 개수를 미리 줄여 직렬화한다.
+ *
+ * **문자열 길이는 여기서 안 줄인다.** 자르기가 가리기보다 먼저 오면 경계에 걸친 토큰이
+ * 패턴에 안 걸린다. 최종 길이는 `formatReceived` 가 가린 뒤에 맞춘다.
+ */
+function shallowSample(value, depth = 0) {
+    if (depth > SAMPLE_DEPTH)
+        return '…';
+    if (Array.isArray(value)) {
+        const head = value.slice(0, SAMPLE_ARRAY_ITEMS).map((item) => shallowSample(item, depth + 1));
+        return value.length > SAMPLE_ARRAY_ITEMS ? [...head, '…'] : head;
+    }
+    if (value !== null && typeof value === 'object') {
+        const out = {};
+        const source = value;
+        for (const key of Object.keys(source).slice(0, SAMPLE_OBJECT_KEYS)) {
+            out[key] = shallowSample(source[key], depth + 1);
+        }
+        return out;
+    }
+    // 문자열은 자르지 않는다. 이유는 위 주석에 있다. 비용은 입력 크기에 선형이다 —
+    // `MAX_JSON_STRING_LENGTH` 는 `tolerateJsonString` 경로만 막으므로 여기까지는 안 온다.
+    return value;
+}
+/** 실제로 받은 값을 에러 메시지에 실을 수 있게 줄여 찍는다. */
+export function formatReceived(value) {
+    if (typeof value === 'function')
+        return 'function';
+    let rendered;
+    try {
+        rendered = JSON.stringify(shallowSample(value)) ?? String(value);
+    }
+    catch {
+        rendered = String(value);
+    }
+    // 가리기를 먼저 하고 자른다. 순서를 뒤집으면 자르는 경계에 걸친 토큰의 뒤 조각이 패턴의
+    // 최소 길이를 못 채워 접두어와 앞 몇 글자가 그대로 남는다. 스니펫에서 겪은 것과 같은
+    // 구조다.
+    const masked = escapeNewlines(redactSecrets(rendered));
+    return masked.length > SAMPLE_LIMIT ? `${masked.slice(0, SAMPLE_LIMIT)}…` : masked;
+}
+/** JSON 파서 에러 문구에서 위치를 뽑는다. 런타임마다 문구가 달라 없을 수도 있다. */
+function extractPosition(reason) {
+    const match = /at position (\d+)/.exec(reason);
+    if (!match)
+        return null;
+    const position = Number(match[1]);
+    return Number.isFinite(position) ? position : null;
+}
+/**
+ * 깨진 지점 주변만 잘라 보여준다.
+ *
+ * 가리기를 먼저 하고 자른다. 순서를 뒤집으면 윈도우가 접두어를 잘라낸 조각에서 패턴이
+ * 안 걸린다 — 따옴표를 안 닫은 JSON 이 그 자리다. V8 이 보고하는 위치가 문자열 끝이라
+ * 접두어가 윈도우 앞으로 밀려난다.
+ *
+ * 깨진 지점이 자격증명 안이면 그 자리가 별표로 덮여 원인이 안 보인다. 드문 경우이고
+ * 파서 사유와 line, column 은 그대로 남는다 — 노출을 막는 쪽을 택했다.
+ */
+export function snippetAround(text, position, radius = SNIPPET_RADIUS) {
+    // 마스킹이 길이를 보존하므로 위치가 그대로 쓰인다. 줄여 쓰면 자리가 밀려 보정이 필요해지고
+    // 그 보정은 근사라서 깨진 지점을 못 짚는다.
+    const masked = redactSecrets(text, { preserveLength: true });
+    const start = Math.max(0, position - radius);
+    const end = Math.min(masked.length, position + radius);
+    const body = escapeNewlines(masked.slice(start, end));
+    return `${start > 0 ? '…' : ''}${body}${end < masked.length ? '…' : ''}`;
+}
+/** JSON 파싱 실패를 부르는 쪽이 바로 고칠 수 있는 한 줄로 만든다. */
+export function describeJsonParseFailure(label, raw, error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    // 파서 문구도 부르는 쪽 바이트에서 나온다. 최신 V8 은 깨진 지점 원문을 그 안에
+    // 인용하므로 가려야 한다.
+    //
+    // **인용이 하한보다 짧으면 안 가려진다.** V8 은 여섯 자쯤만 인용하므로 접두어와 그
+    // 몇 글자가 남는다. 하한을 내려 그걸 잡으려 했더니 `npm_package_name` 같은 멀쩡한
+    // 식별자가 원인 설명에서 지워졌다 — 원인을 알려주자는 목적과 반대로 간다. 조각 여섯
+    // 자로는 키를 복원할 수 없다. 원문 전체를 보는 두 경로(값 샘플과 스니펫)는 정확히
+    // 가려진다. 그쪽을 택했다.
+    const masked = escapeNewlines(redactSecrets(reason));
+    const head = `${label}: 문자열로 왔는데 JSON으로 안 풀립니다 — ${masked}`;
+    const position = extractPosition(reason);
+    if (position === null)
+        return `${head} (길이 ${raw.length}자)`;
+    return `${head}. 깨진 지점 주변: ${snippetAround(raw, position)}`;
+}
+/**
+ * 타입이 어긋났을 때 무엇이 왔는지까지 말해주는 errorMap.
+ *
+ * SDK가 첫 이슈의 message만 꺼내 쓰므로 경로(`a.b[0].c`)도 여기 넣는다. 안 넣으면
+ * 어느 필드가 틀렸는지가 통째로 사라진다.
+ */
+export const verboseErrorMap = (issue, ctx) => {
+    const path = formatPath(issue.path ?? []);
+    const at = path === '' ? '' : ` at ${path}`;
+    if (issue.code === z.ZodIssueCode.invalid_type) {
+        // 값을 아예 안 보낸 경우다. 샘플 대신 무슨 타입이 필요한지를 알려준다.
+        if (issue.received === z.ZodParsedType.undefined) {
+            return { message: `Required${at} (expected: ${issue.expected})` };
+        }
+        return {
+            message: `Expected ${issue.expected}, received ${issue.received}${at} (received: ${formatReceived(ctx.data)})`,
+        };
+    }
+    // 어느 키가 남았는지는 이슈가 이미 들고 있다. 객체 전체를 찍으면 문제와 무관한
+    // 옆 필드 값까지 메시지와 로그에 함께 실린다.
+    // 이 레포 스키마에는 `.strict()` 가 없어 지금은 안 지나간다. 나중에 붙을 자리로 남겨둔다.
+    if (issue.code === z.ZodIssueCode.unrecognized_keys) {
+        return { message: `${ctx.defaultError}${at} (unrecognized: ${issue.keys.join(', ')})` };
+    }
+    // 코드를 가려 뽑지 않는다. 허용 목록으로 두면 나중에 union 이나 date 필드가 붙었을
+    // 때 그 자리만 조용히 샘플을 잃는다. 메시지가 이미 정해진 이슈(`.refine()` 의 커스텀
+    // 문구, 이 파일이 던지는 파싱 실패 문구)는 zod 가 errorMap 을 아예 안 태우므로 여기서
+    // 걸러낼 필요도 없다.
+    return { message: `${ctx.defaultError}${at} (received: ${formatReceived(ctx.data)})` };
+};
+/**
+ * 스키마 트리 전체에 errorMap을 심는다.
+ *
+ * 제자리에서 고친다. 중첩 배열 요소까지 닿아야 `mergedIssues[0].reportedBy` 같은
+ * 자리의 에러에도 경로와 샘플이 붙는다.
+ *
+ * 가드가 둘이고 하는 일이 다르다.
+ * - `seen`에 있는 스키마 인스턴스는 **노드 전체를 건너뛴다** (자식 순회까지 중단).
+ *   순환 참조와 공유 참조 대비다.
+ * - errorMap이 이미 있는 스키마는 **값 재할당만 건너뛰고** 자식 순회는 계속한다.
+ *   같은 shape에 두 번 걸려도 안쪽이 빠짐없이 덮인다.
+ */
+export function attachErrorMap(schema, seen = new WeakSet()) {
+    // 순회가 집는 필드 이름이 어긋나면 undefined 가 온다. 여기서는 조용히 물러난다 —
+    // 스키마 하나 때문에 기동을 세우지 않는다. 그 어긋남은
+    // `tests/unit/mcp/input-guard.test.ts` 가 컨테이너 종류마다 잎을 심어 잡는다.
+    if (schema === undefined || schema === null)
+        return schema;
+    if (seen.has(schema))
+        return schema;
+    seen.add(schema);
+    const def = schema._def;
+    if (def.errorMap === undefined)
+        def.errorMap = verboseErrorMap;
+    const kind = typeNameOf(schema);
+    const raw = schema._def;
+    switch (kind) {
+        case Kind.ZodObject: {
+            const shape = schema.shape;
+            for (const key of Object.keys(shape))
+                attachErrorMap(shape[key], seen);
+            break;
+        }
+        case Kind.ZodArray:
+            attachErrorMap(raw['type'], seen);
+            break;
+        // 자식을 `type` 에 두는 것들. `innerType` 분기에 묶으면 undefined 가 넘어간다.
+        case Kind.ZodSet:
+            attachErrorMap(raw['valueType'], seen);
+            break;
+        case Kind.ZodPromise:
+        case Kind.ZodBranded:
+            attachErrorMap(raw['type'], seen);
+            break;
+        case Kind.ZodOptional:
+        case Kind.ZodNullable:
+        case Kind.ZodDefault:
+        case Kind.ZodCatch:
+        case Kind.ZodReadonly:
+            attachErrorMap(raw['innerType'], seen);
+            break;
+        case Kind.ZodEffects:
+            attachErrorMap(raw['schema'], seen);
+            break;
+        case Kind.ZodUnion:
+        case Kind.ZodDiscriminatedUnion: {
+            const options = raw['options'];
+            const list = Array.isArray(options)
+                ? options
+                : [...options.values()];
+            for (const option of list)
+                attachErrorMap(option, seen);
+            break;
+        }
+        case Kind.ZodIntersection:
+            attachErrorMap(raw['left'], seen);
+            attachErrorMap(raw['right'], seen);
+            break;
+        case Kind.ZodRecord:
+        case Kind.ZodMap:
+            attachErrorMap(raw['keyType'], seen);
+            attachErrorMap(raw['valueType'], seen);
+            break;
+        case Kind.ZodPipeline:
+            attachErrorMap(raw['in'], seen);
+            attachErrorMap(raw['out'], seen);
+            break;
+        case Kind.ZodTuple: {
+            for (const item of raw['items'] ?? [])
+                attachErrorMap(item, seen);
+            const rest = raw['rest'];
+            if (rest)
+                attachErrorMap(rest, seen);
+            break;
+        }
+        // ZodLazy 같은 재귀 스키마는 getter가 부를 때마다 새 인스턴스를 낼 수 있어
+        // `seen`으로 못 막는다. 여기서 안 따라가므로 그 서브트리는 방어 없이 남는다.
+        default:
+            break;
+    }
+    return schema;
+}
+/**
+ * optional, nullable, default 껍질을 벗겨 안쪽 스키마와 껍질 순서를 돌려준다.
+ *
+ * ZodEffects(`.refine()`, `.transform()`)는 안 벗긴다. 그 검사는 JSON을 푼 뒤에 그대로
+ * 돌아야 하므로 preprocess가 그 바깥을 감싼다.
+ */
+function peel(schema) {
+    const wrappers = [];
+    let current = schema;
+    for (;;) {
+        const kind = typeNameOf(current);
+        const raw = current._def;
+        if (kind === Kind.ZodOptional) {
+            wrappers.push({ kind: 'optional' });
+            current = raw['innerType'];
+        }
+        else if (kind === Kind.ZodNullable) {
+            wrappers.push({ kind: 'nullable' });
+            current = raw['innerType'];
+        }
+        else if (kind === Kind.ZodDefault) {
+            wrappers.push({ kind: 'default', factory: raw['defaultValue'] });
+            current = raw['innerType'];
+        }
+        else {
+            return { inner: current, wrappers };
+        }
+    }
+}
+/**
+ * 이 스키마가 결국 구조를 기대하는지 본다.
+ *
+ * `.refine()`이 하나 얹히면 최상위가 ZodEffects가 된다. 그것만 보고 판정하면 그 필드는
+ * JSON 문자열 관용을 조용히 잃는다 — 에러도 안 나서 알아채기 어렵다.
+ */
+function expectsStructured(schema, depth = 0) {
+    if (depth > 10)
+        return false;
+    const kind = typeNameOf(schema);
+    if (kind === Kind.ZodEffects) {
+        return expectsStructured(schema._def.schema, depth + 1);
+    }
+    return STRUCTURED_KINDS.has(kind);
+}
+/**
+ * 객체나 배열 파라미터에 JSON 문자열을 허용한다.
+ *
+ * 껍질(optional/default)은 벗겼다가 그대로 다시 씌운다. `preprocess`를 바깥에 두면
+ * SDK가 필수 파라미터로 잘못 노출하고 `describe()`도 날아간다.
+ */
+export function tolerateJsonString(schema, label) {
+    const { inner, wrappers } = peel(schema);
+    if (!expectsStructured(inner))
+        return schema;
+    let rebuilt = z.preprocess((value, ctx) => {
+        if (typeof value !== 'string')
+            return value;
+        if (value.length > MAX_JSON_STRING_LENGTH) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                fatal: true,
+                message: `${label}: 문자열이 너무 깁니다 (${value.length}자, 상한 ${MAX_JSON_STRING_LENGTH}자). 파싱을 시도하지 않았습니다.`,
+            });
+            return z.NEVER;
+        }
+        try {
+            return JSON.parse(value);
+        }
+        catch (error) {
+            // fatal이 없으면 zod가 뒤 검증을 계속 돌려 `Required at ...` 잡음을 덧붙인다.
+            // 부르는 쪽이 고쳐야 할 건 파싱 하나뿐이다.
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                fatal: true,
+                message: describeJsonParseFailure(label, value, error),
+            });
+            return z.NEVER;
+        }
+    }, inner);
+    for (const wrapper of [...wrappers].reverse()) {
+        if (wrapper.kind === 'optional')
+            rebuilt = rebuilt.optional();
+        else if (wrapper.kind === 'nullable')
+            rebuilt = rebuilt.nullable();
+        // 팩토리를 그대로 넘긴다. 여기서 호출해 결과를 박으면 모든 요청이 같은 객체
+        // 인스턴스를 나눠 쓰게 된다.
+        else
+            rebuilt = rebuilt.default(wrapper.factory);
+    }
+    const description = schema._def.description;
+    return description === undefined ? rebuilt : rebuilt.describe(description);
+}
+/**
+ * 도구 등록에 넘길 raw shape에 방어를 입힌다.
+ *
+ * 두 번 지나도 결과가 같다. 다만 구조가 그대로 남는다는 뜻은 아니다. `attachErrorMap`은
+ * 값이 비었을 때만 대입하므로 손대는 게 없지만 `tolerateJsonString`은 두 번째 통과에서
+ * `preprocess`를 한 겹 더 씌운다. 바깥 겹이 문자열을 풀면 안쪽 겹에는 문자열이 아닌 값이
+ * 와서 그대로 지나간다. 상한 검사와 파싱 실패 문구도 한 번만 실린다.
+ *
+ * `schemas.ts`에서 `guardObject`를 지난 스키마가 `server.ts`의 `guardedTool`에서 한 번
+ * 더 지나는 게 그 경로다. 등록 채널을 하나로 남기는 것이 이 설계의 전제라, 레이어를
+ * 갈라 그 채널을 다시 여는 쪽으로는 안 간다.
+ */
+export function guardShape(shape) {
+    const guarded = {};
+    for (const key of Object.keys(shape)) {
+        guarded[key] = tolerateJsonString(attachErrorMap(shape[key]), key);
+    }
+    return guarded;
+}
+/** 핸들러가 직접 `.parse()`하는 스키마에도 같은 방어를 입힌다. */
+export function guardObject(schema) {
+    return attachErrorMap(schema.extend(guardShape(schema.shape)));
+}
+//# sourceMappingURL=input-guard.js.map