deel-local-cli 1.20.12 → 2.0.0

package/src/agent/outschema.js

@@ -48,8 +48,8 @@ import { readFileSync } from 'node:fs';
 /** 우리가 실제로 재는 열쇠들. 여기 없는 것은 안 재고, 안 쟀다고 말한다. */
 export const 아는열쇠 = Object.freeze([
   'type', 'enum', 'const',
-  'properties', 'required', 'additionalProperties',
-  'items', 'minItems', 'maxItems',
+  'properties', 'required', 'additionalProperties', 'patternProperties',
+  'items', 'prefixItems', 'minItems', 'maxItems',
   'minLength', 'maxLength', 'pattern',
   'minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum', 'multipleOf',
   'anyOf', 'oneOf', 'allOf', 'not',
@@ -60,7 +60,8 @@ export const 아는열쇠 = Object.freeze([
 
 const 아는것 = new Set(아는열쇠);
 // 그 아래 열쇠가 규격 낱말이 아니라 '사람이 지은 칸 이름' 인 자리.
-const 이름칸 = new Set(['properties', '$defs', 'definitions']);
+// patternProperties 아래 열쇠는 칸 이름을 가르는 **무늬**다 — 그것도 규격 낱말이 아니다.
+const 이름칸 = new Set(['properties', 'patternProperties', '$defs', 'definitions']);
 
 /**
  * 이 스키마에서 우리가 안 보는 열쇠들.
@@ -83,7 +84,9 @@ export function 모르는열쇠(스키마, 본것 = new Set()) {
        * 진짜로 안 재는 낱말(format 같은 것)이 그 속에 묻힌다.
        */
       if (이름칸.has(k)) { for (const x of Object.values(v)) 훑기(x); }
-      else 훑기(v);
+      // `default`·`examples` 아래는 **데이터**다(2.0.0 6회차 모양6 O2). 거기 적힌 `host`·`port` 를
+      // 「안 재는 열쇠」 로 세면 이 경고가 또 소음이 된다. 칸 이름이 `enum` 인 것은 위 갈래로 간다.
+      else if (!값칸.has(k)) 훑기(v);
     }
   };
   훑기(스키마);
@@ -103,6 +106,14 @@ export function 스키마읽기(경로) {
   let 글;
   try { 글 = readFileSync(경로, 'utf8'); }
   catch (err) { return { ok: false, 왜: `스키마 파일을 못 읽었습니다: ${경로}\n  ${err?.message ?? err}` }; }
+  /*
+   * 맨 앞의 BOM 을 뗀다 (사냥5 B5-05).
+   *
+   * 윈도우 메모장과 PowerShell 5 의 Out-File 은 UTF-8 에 BOM 을 붙여 저장한다. JSON.parse 는
+   * 그 한 글자에서 멈추고, 화면은 「스키마가 JSON 이 아닙니다」 — 눈으로 보면 멀쩡한
+   * 파일인데. 윈도우에서 스키마를 처음 적는 사람이 첫 판에 밟는 자리다.
+   */
+  if (글.startsWith(BOM)) 글 = 글.slice(BOM.length);
   let s;
   try { s = JSON.parse(글); }
   catch (err) { return { ok: false, 왜: `스키마가 JSON 이 아닙니다: ${경로}\n  ${err?.message ?? err}` }; }
@@ -119,9 +130,85 @@ export function 스키마읽기(경로) {
         + '  같은 파일 안(#/$defs/...)으로 바꿔 주세요.',
     };
   }
+  /*
+   * 값을 한 칸도 파고들지 않고 제자리로 돌아오는 참조는 **읽는 자리에서** 막는다 (사냥5 L5-3).
+   *
+   * `{"$ref":"#"}` · a→b→a · `{"allOf":[{"$ref":"#"}]}` 는 같은 값을 같은 스키마로 끝없이
+   * 재게 한다. 여기서 안 막았더니 모델을 한 번 부른 **뒤에** 재는 자리에서 호출 스택이
+   * 넘쳤고, 그 오류가 표준출력에 맨 글로 찍혔다. 사람이 적은 스키마의 실수라 모델을
+   * 부르기 전에 7 로 서야 한다. 나무처럼 **값을 파고들며** 되부르는 참조(items·properties
+   * 아래)는 끝이 있으므로 막지 않는다.
+   */
+  const 도는곳 = 제자리참조찾기(s);
+  if (도는곳) {
+    return {
+      ok: false,
+      왜: `스키마의 $ref 가 제자리를 돕니다: ${도는곳}\n`
+        + '  값을 한 칸도 파고들지 않고 같은 자리로 돌아오면 끝없이 잽니다. 참조 고리를 끊어 주세요.',
+    };
+  }
   return { ok: true, 스키마: s, 모른것: 모르는열쇠(s) };
 }
 
+// 윈도우 편집기가 파일 맨 앞에 붙이는 표시 한 글자 (스키마읽기 의 BOM 머리말).
+const BOM = String.fromCharCode(0xfeff);
+
+// 스키마가 아니라 **값**이 적히는 칸. 그 안의 `$ref` 는 글자일 뿐이라 따라가지 않는다.
+const 값칸 = new Set(['enum', 'const', 'default', 'examples']);
+
+/*
+ * 같은 값을 그대로 들고 옮겨 가는 길($ref · allOf · anyOf · oneOf · not)만 따라가서
+ * 제자리로 돌아오는 고리를 찾는다. 찾으면 사람이 읽을 길 한 줄, 없으면 null.
+ *
+ * properties·items 아래로 내려가는 길은 값도 한 칸 파고들므로 고리가 되지 않는다 —
+ * 그래서 그 길은 「고리 찾기」 에 안 넣고, 「어디서 시작할 수 있나」 에만 쓴다.
+ */
+function 제자리참조찾기(뿌리) {
+  const 끝남 = new Set();
+  const 가는중 = new Set();
+  const 같은값길 = (n) => {
+    const out = [];
+    if (typeof n.$ref === 'string') {
+      const t = ref따라가기(뿌리, n.$ref);
+      // 참/거짓 스키마는 더 갈 곳이 없어 고리가 못 된다 — 길에 안 올린다.
+      if (t && typeof t === 'object') out.push([t, n.$ref]);
+    }
+    for (const k of ['allOf', 'anyOf', 'oneOf']) {
+      if (Array.isArray(n[k])) for (const x of n[k]) if (x && typeof x === 'object') out.push([x, k]);
+    }
+    if (n.not && typeof n.not === 'object') out.push([n.not, 'not']);
+    return out;
+  };
+  const 돌기 = (n, 길) => {
+    if (끝남.has(n)) return null;
+    if (가는중.has(n)) return 길.join(' → ');
+    가는중.add(n);
+    for (const [다음, 표] of 같은값길(n)) {
+      const 찾음 = 돌기(다음, [...길, 표]);
+      if (찾음) return 찾음;
+    }
+    가는중.delete(n);
+    끝남.add(n);
+    return null;
+  };
+  const 본것 = new Set();
+  const 훑기 = (x) => {
+    if (!x || typeof x !== 'object' || 본것.has(x)) return null;
+    본것.add(x);
+    if (!Array.isArray(x)) {
+      const 찾음 = 돌기(x, ['#']);
+      if (찾음) return 찾음;
+    }
+    for (const [k, v] of Object.entries(x)) {
+      if (!Array.isArray(x) && 값칸.has(k)) continue;
+      const 찾음 = 훑기(v);
+      if (찾음) return 찾음;
+    }
+    return null;
+  };
+  return 훑기(뿌리);
+}
+
 /** 같은 파일 안(`#`으로 시작)이 아닌 `$ref` 를 다 찾는다. */
 export function 바깥ref찾기(스키마, 본것 = new Set()) {
   const out = [];
@@ -130,23 +217,54 @@ export function 바깥ref찾기(스키마, 본것 = new Set()) {
     본것.add(s);
     if (Array.isArray(s)) { for (const x of s) 훑기(x); return; }
     if (typeof s.$ref === 'string' && !s.$ref.startsWith('#')) out.push(s.$ref);
-    for (const v of Object.values(s)) if (v && typeof v === 'object') 훑기(v);
+    /*
+     * 값 칸(`default`·`const`·`examples`·`enum`) 속은 스키마가 아니라 데이터라 안 들어간다
+     * (2.0.0 6회차 모양6 O1). 예시 값에 `{"$ref":"http://…"}` 가 있다고 멀쩡한 스키마를 거절했다.
+     * 칸 이름(`properties` 아래)이 `default` 인 것은 스키마이므로 그 자리는 그대로 훑는다 —
+     * 거기 바깥 주소를 숨기면 아래 거절이 비켜 간다.
+     */
+    for (const [칸, v] of Object.entries(s)) {
+      if (!v || typeof v !== 'object') continue;
+      if (이름칸.has(칸)) { for (const x of Object.values(v)) 훑기(x); }
+      else if (!값칸.has(칸)) 훑기(v);
+    }
   };
   훑기(스키마);
   return [...new Set(out)];
 }
 
-/** `#/$defs/이름` 같은 자리를 뿌리에서 따라간다. 못 찾으면 null. */
+/**
+ * `#/$defs/이름` 같은 자리를 뿌리에서 따라간다. 못 찾으면 undefined.
+ *
+ * 스키마는 객체일 수도, 참/거짓 그 자체일 수도 있다. 그래서 「없다」 를 null 이 아니라
+ * undefined 로 말한다 — `false` 를 「없다」 로 되돌리면 부르는 쪽이 못 가른다.
+ */
 function ref따라가기(뿌리, ref) {
-  if (typeof ref !== 'string' || !ref.startsWith('#')) return null;
-  const 길 = ref.slice(1).split('/').filter(Boolean)
-    .map((x) => decodeURIComponent(x.replace(/~1/g, '/').replace(/~0/g, '~')));
+  if (typeof ref !== 'string' || !ref.startsWith('#')) return undefined;
+  /*
+   * 퍼센트를 먼저 풀고 `~1`·`~0` 을 푼다 (RFC 6901 §6 의 차례). 날 `%` 가 섞인 조각은
+   * decodeURIComponent 가 URIError 를 던져 **스키마 읽기와 재기가 통째로 던졌다**
+   * (2.0.0 6회차 모양6 O5) — 그런 조각은 적힌 글자 그대로 찾는다.
+   */
+  const 조각들 = ref.slice(1).split('/');
+  /*
+   * 맨 앞 하나만 떼고 **빈 조각은 남긴다** (2.0.0 8회차 스키마). 포인터 `/` 의 조각은
+   * 「이름이 빈 칸」 하나지 조각 없음이 아니다 (RFC 6901 §3). 빈 것을 다 지웠더니
+   * `#/` 가 뿌리로 돌아가 엉뚱한 자리를 재고, 그 탈이 사람에게는 스키마가 틀린 것으로 보였다.
+   */
+  if (조각들[0] === '') 조각들.shift();
+  const 길 = 조각들.map((x) => {
+    let 풀린 = x;
+    try { 풀린 = decodeURIComponent(x); } catch { /* 적힌 그대로 */ }
+    return 풀린.replace(/~1/g, '/').replace(/~0/g, '~');
+  });
   let 여기 = 뿌리;
   for (const 조각 of 길) {
-    if (!여기 || typeof 여기 !== 'object') return null;
+    if (!여기 || typeof 여기 !== 'object') return undefined;
     여기 = 여기[조각];
   }
-  return 여기 && typeof 여기 === 'object' ? 여기 : null;
+  if (typeof 여기 === 'boolean') return 여기;
+  return 여기 && typeof 여기 === 'object' ? 여기 : undefined;
 }
 
 const 갈래 = (v) => {
@@ -165,6 +283,30 @@ const 갈래맞나 = (v, t) => {
   return typeof v === t;
 };
 
+/*
+ * JSON 값이 같은가 — 객체는 **키 순서를 안 본다** (2.0.0 6회차 모양6뒤). JSON.stringify 로 견줬더니
+ * `{"b":2,"a":1}` 이 `const: {"a":1,"b":2}` 에 「여야 합니다」 로 걸렸다. 모델은 키 순서를 안 지킨다.
+ */
+function 같은값(a, b) {
+  if (a === b) return true;
+  if (!a || !b || typeof a !== 'object' || typeof b !== 'object') return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  if (Array.isArray(a)) return a.length === b.length && a.every((x, i) => 같은값(x, b[i]));
+  const 앞열쇠 = Object.keys(a);
+  return 앞열쇠.length === Object.keys(b).length
+    && 앞열쇠.every((k) => Object.prototype.hasOwnProperty.call(b, k) && 같은값(a[k], b[k]));
+}
+
+/*
+ * 스키마의 무늬를 정규식으로 — **유니코드 꼴로 먼저** 짓는다 (2.0.0 6회차 모양6뒤). JSON 스키마의 정규식은
+ * ECMA-262 유니코드 꼴이라 글자 갈래 무늬(p 뒤 중괄호)를 쓴다. u 없이 지었더니 그게 글자 p 로 읽혀
+ * 맞는 글을 거절했다. u 로 안 지어지는 옛 꼴(쓸데없는 이스케이프)은 u 없이 한 번 더. 둘 다 안 되면 null.
+ */
+function 정규식짓기(무늬) {
+  try { return new RegExp(무늬, 'u'); } catch { /* 옛 꼴일 수 있다 */ }
+  try { return new RegExp(무늬); } catch { return null; }
+}
+
 /**
  * 값이 스키마에 맞나.
  *
@@ -174,17 +316,69 @@ const 갈래맞나 = (v, t) => {
  *
  * @returns {{ok: boolean, 탈: string[]}}
  */
-export function 맞나(값, 스키마, { 뿌리 = 스키마, 자리 = '' } = {}) {
+export function 맞나(값, 스키마, 옵션 = {}) {
+  /*
+   * ── 같은 값을 같은 스키마로 **또** 재려 하면 거기서 끊는다 (사냥5 L5-3) ─────────
+   *
+   * `{"$ref":"#"}` 나 a→b→a 는 값을 한 칸도 안 파고들고 제자리로 돈다. 여기가 그걸 몰라
+   * 호출 스택이 넘쳤고, 한 방 실행은 그 RangeError 를 표준출력에 찍었다.
+   *
+   * 지금 재는 길 위에 (스키마, 값) 짝이 이미 있으면 고리다. 값을 파고들면 값이 바뀌고,
+   * JSON 에는 제 몸을 품는 값이 없으므로 끝이 있는 재귀(나무 모양 스키마)는 여기에 안
+   * 걸린다. 읽는 자리(스키마읽기)가 먼저 막지만, 이 함수를 곧장 부르는 쪽도 터지면 안 된다.
+   * 부르는 자리를 하나하나 고치지 않고 이름 하나로 감싼 것은, 안쪽 재귀가 전부 이 이름을
+   * 거쳐 가기 때문이다 — 새 열쇠를 재는 줄이 늘어도 울타리가 따라간다.
+   */
+  const 여기 = 옵션?.자리 || '(뿌리)';
+  if (재는길.some(([a, b]) => a === 스키마 && Object.is(b, 값))) {
+    return { ok: false, 탈: [`${여기}: 스키마가 제자리를 돕니다 — 같은 값을 같은 자리로 또 재려 합니다`] };
+  }
+  재는길.push([스키마, 값]);
+  try { return 맞나속(값, 스키마, 옵션); } finally { 재는길.pop(); }
+}
+
+// 지금 재고 있는 (스키마, 값) 짝들 — 맞나 의 고리 울타리.
+const 재는길 = [];
+
+function 맞나속(값, 스키마, { 뿌리 = 스키마, 자리 = '' } = {}) {
   const 탈 = [];
   const 여기 = 자리 || '(뿌리)';
   const s = 스키마;
+  /*
+   * ── 참/거짓 그 자체가 스키마다 ──────────────────────────────────────────
+   *
+   * 바로 아래 줄이 「true/false 스키마와 $ref 를 먼저 푼다」 고 적어 두고는
+   * 정작 참·거짓은 안 풀고 있었다. 객체가 아니면 그대로 통과였다.
+   *
+   * 그래서 `false` — 규격이 「무엇도 안 된다」 고 못 박는 자리 — 가 **무엇이든
+   * 통과**였고, 그 열쇠는 아는열쇠 안에 있으니 「안 잰 열쇠」 목록에도 안 떴다.
+   * 화면은 다 쟀다고 하고, 아무것도 안 쟀다. 이 파일 머리말이 제일 나쁘다고
+   * 적어 둔 모양이 바로 그것이다.
+   */
+  if (s === true) return { ok: true, 탈 };
+  if (s === false) return { ok: false, 탈: [`${여기}: 여기에는 아무 값도 올 수 없습니다`] };
   if (!s || typeof s !== 'object') return { ok: true, 탈 };
 
-  // true/false 스키마와 $ref 를 먼저 푼다.
+  /*
+   * `$ref` 옆의 형제 열쇠도 잰다.
+   *
+   * 여태는 가리킨 곳을 재고 **그 자리에서 돌아섰다.** 그러면
+   *
+   *     { "$ref": "#/$defs/아이디", "minLength": 8 }
+   *
+   * 에서 minLength 가 한 번도 안 걸린다. 규격을 좁히려고 덧붙인 줄인데,
+   * 덧붙이면 덧붙인 만큼 조용히 사라진 셈이다. 가리킨 곳을 재고 **이어서**
+   * 형제도 잰다 — 탈은 원래 다 모아서 주는 자리라 합치기만 하면 된다.
+   */
   if (typeof s.$ref === 'string') {
     const 간것 = ref따라가기(뿌리, s.$ref);
-    if (!간것) return { ok: false, 탈: [`${여기}: 스키마 안에 ${s.$ref} 가 없습니다`] };
-    return 맞나(값, 간것, { 뿌리, 자리 });
+    /*
+     * 가리킨 곳이 `false` 여도 「없습니다」 라고 하면 안 된다 (2.0.0 8회차 스키마). 그 자리는
+     * 규격이 「무엇도 올 수 없다」 고 못 박은 자리라 있는 것이고, 사람은 스키마에 없는 오타를
+     * 찾으러 간다. 위에서 참/거짓 스키마를 푸니 그대로 넘기면 제 말이 나온다.
+     */
+    if (간것 === undefined) return { ok: false, 탈: [`${여기}: 스키마 안에 ${s.$ref} 가 없습니다`] };
+    탈.push(...맞나(값, 간것, { 뿌리, 자리 }).탈);
   }
 
   if (Array.isArray(s.type) ? !s.type.some((t) => 갈래맞나(값, t)) : (s.type && !갈래맞나(값, s.type))) {
@@ -193,10 +387,10 @@ export function 맞나(값, 스키마, { 뿌리 = 스키마, 자리 = '' } = {})
     return { ok: false, 탈 };
   }
 
-  if (Array.isArray(s.enum) && !s.enum.some((x) => JSON.stringify(x) === JSON.stringify(값))) {
+  if (Array.isArray(s.enum) && !s.enum.some((x) => 같은값(x, 값))) {
     탈.push(`${여기}: ${s.enum.map((x) => JSON.stringify(x)).join(' · ')} 중 하나여야 합니다`);
   }
-  if ('const' in s && JSON.stringify(s.const) !== JSON.stringify(값)) {
+  if ('const' in s && !같은값(s.const, 값)) {
     탈.push(`${여기}: ${JSON.stringify(s.const)} 여야 합니다`);
   }
 
@@ -206,8 +400,9 @@ export function 맞나(값, 스키마, { 뿌리 = 스키마, 자리 = '' } = {})
     if (typeof s.pattern === 'string') {
       // 스키마를 적은 사람의 정규식이 잘못됐을 수 있다. 그것도 탈로 말한다 —
       // 조용히 통과시키면 안 재고 있는 규칙이 하나 생긴다.
-      try { if (!new RegExp(s.pattern).test(값)) 탈.push(`${여기}: ${s.pattern} 모양이어야 합니다`); }
-      catch { 탈.push(`${여기}: 스키마의 pattern 이 잘못된 정규식입니다 (${s.pattern})`); }
+      const 무늬 = 정규식짓기(s.pattern);
+      if (!무늬) 탈.push(`${여기}: 스키마의 pattern 이 잘못된 정규식입니다 (${s.pattern})`);
+      else if (!무늬.test(값)) 탈.push(`${여기}: ${s.pattern} 모양이어야 합니다`);
     }
   }
 
@@ -225,8 +420,38 @@ export function 맞나(값, 스키마, { 뿌리 = 스키마, 자리 = '' } = {})
   if (Array.isArray(값)) {
     if (Number.isFinite(s.minItems) && 값.length < s.minItems) 탈.push(`${여기}: ${s.minItems}개 이상이어야 합니다`);
     if (Number.isFinite(s.maxItems) && 값.length > s.maxItems) 탈.push(`${여기}: ${s.maxItems}개 이하여야 합니다`);
-    if (s.items && typeof s.items === 'object' && !Array.isArray(s.items)) {
-      값.forEach((v, i) => 탈.push(...맞나(v, s.items, { 뿌리, 자리: `${여기}[${i}]` }).탈));
+    /*
+     * `items` 는 두 모양으로 온다.
+     *
+     * 하나는 「원소가 다 이 모양」 (스키마 하나). 여태 이것만 쟀다. 다른 하나는
+     * Draft-07 의 **자리별 모양** —
+     *
+     *     "items": [{"type":"string"}, {"type":"number"}]      ← [이름, 나이]
+     *
+     * 배열이면 위 `!Array.isArray` 에 걸려 통째로 안 쟀다. 그런데 'items' 는
+     * 아는열쇠 안에 있어서 「안 잰 열쇠」 에도 안 올랐다 — 안 재면서 잰다고
+     * 말한 자리다. 첫 칸에 숫자가 와도 그냥 나갔고, 그 값을 파이프 뒤의 jq 가
+     * 문자열로 알고 받았다.
+     *
+     * 자리별로 재고, 튜플보다 뒤에 오는 원소는 안 잰다 — 그건 additionalItems
+     * 가 정하는 것이고 우리는 그 열쇠를 모른다. 모르는 것은 모르는열쇠() 가 센다.
+     */
+    /*
+     * 2020-12 는 자리별 모양을 `prefixItems` 로 적고, 그때 `items` 는 **그 뒤** 원소들의 모양이다
+     * (2.0.0 6회차 모양6뒤). prefixItems 를 몰라서 `items` 를 0번부터 씌웠다 — `["a", 1]` 이
+     * 「[0]: number 이어야」 로 거절됐다.
+     */
+    const 자리별 = Array.isArray(s.prefixItems) ? s.prefixItems : (Array.isArray(s.items) ? s.items : null);
+    if (자리별) {
+      자리별.forEach((칸, i) => {
+        if (i < 값.length) 탈.push(...맞나(값[i], 칸, { 뿌리, 자리: `${여기}[${i}]` }).탈);
+      });
+    }
+    const 뒤모양 = Array.isArray(s.prefixItems) ? s.items : (Array.isArray(s.items) ? undefined : s.items);
+    if (뒤모양 === true || 뒤모양 === false || (뒤모양 && typeof 뒤모양 === 'object' && !Array.isArray(뒤모양))) {
+      for (let i = Array.isArray(s.prefixItems) ? s.prefixItems.length : 0; i < 값.length; i += 1) {
+        탈.push(...맞나(값[i], 뒤모양, { 뿌리, 자리: `${여기}[${i}]` }).탈);
+      }
     }
   }
 
@@ -235,13 +460,30 @@ export function 맞나(값, 스키마, { 뿌리 = 스키마, 자리 = '' } = {})
       if (!Object.prototype.hasOwnProperty.call(값, k)) 탈.push(`${여기}: ${k} 칸이 없습니다`);
     }
     const 칸들 = s.properties && typeof s.properties === 'object' ? s.properties : {};
+    /*
+     * `patternProperties` — 이름이 무늬에 맞는 칸의 모양 (2.0.0 6회차 모양6뒤). 몰라서 그런 칸이
+     * `additionalProperties: false` 에 「적으면 안 되는 칸」 으로 걸렸고, 무늬까지 안 재는 열쇠로 셌다.
+     * properties 와 무늬는 **둘 다** 씌운다(규격). 어느 쪽에도 안 걸린 칸만 additionalProperties 가 본다.
+     */
+    const 무늬들 = [];
+    if (s.patternProperties && typeof s.patternProperties === 'object') {
+      for (const [p, 칸] of Object.entries(s.patternProperties)) {
+        const re = 정규식짓기(p);
+        if (re) 무늬들.push([re, 칸]);
+        else 탈.push(`${여기}: 스키마의 patternProperties 무늬가 잘못된 정규식입니다 (${p})`);
+      }
+    }
     for (const [k, v] of Object.entries(값)) {
-      if (Object.prototype.hasOwnProperty.call(칸들, k)) {
-        탈.push(...맞나(v, 칸들[k], { 뿌리, 자리: 여기 === '(뿌리)' ? k : `${여기}.${k}` }).탈);
-      } else if (s.additionalProperties === false) {
+      const 칸자리 = 여기 === '(뿌리)' ? k : `${여기}.${k}`;
+      const 이름있음 = Object.prototype.hasOwnProperty.call(칸들, k);
+      if (이름있음) 탈.push(...맞나(v, 칸들[k], { 뿌리, 자리: 칸자리 }).탈);
+      const 맞은무늬 = 무늬들.filter(([re]) => re.test(k));
+      for (const [, 칸] of 맞은무늬) 탈.push(...맞나(v, 칸, { 뿌리, 자리: 칸자리 }).탈);
+      if (이름있음 || 맞은무늬.length) continue;
+      if (s.additionalProperties === false) {
         탈.push(`${여기}: ${k} 는 적으면 안 되는 칸입니다`);
       } else if (s.additionalProperties && typeof s.additionalProperties === 'object') {
-        탈.push(...맞나(v, s.additionalProperties, { 뿌리, 자리: 여기 === '(뿌리)' ? k : `${여기}.${k}` }).탈);
+        탈.push(...맞나(v, s.additionalProperties, { 뿌리, 자리: 칸자리 }).탈);
       }
     }
   }
@@ -254,7 +496,13 @@ export function 맞나(값, 스키마, { 뿌리 = 스키마, 자리 = '' } = {})
     const 맞은수 = s.oneOf.filter((x) => 맞나(값, x, { 뿌리, 자리 }).ok).length;
     if (맞은수 !== 1) 탈.push(`${여기}: oneOf 중 정확히 하나에 맞아야 하는데 ${맞은수}개에 맞습니다`);
   }
-  if (s.not && typeof s.not === 'object' && 맞나(값, s.not, { 뿌리, 자리 }).ok) {
+  /*
+   * `{"not": true}` 는 「무엇도 안 된다」 는 뜻이다 — false 스키마를 돌려 적은
+   * 꼴이고, 스키마를 만들어 주는 도구들이 실제로 그렇게 뱉는다. 여기가 객체만
+   * 보고 있어서 그 한 줄은 통째로 통과였다. 참·거짓도 스키마니 그대로 재 준다.
+   */
+  const not잴것 = s.not === true || s.not === false || (s.not && typeof s.not === 'object');
+  if (not잴것 && 맞나(값, s.not, { 뿌리, 자리 }).ok) {
     탈.push(`${여기}: not 에 걸립니다`);
   }
 
@@ -271,7 +519,7 @@ export function 맞나(값, 스키마, { 뿌리 = 스키마, 자리 = '' } = {})
  *
  * @returns {{ok: true, 값: any, 군말: boolean} | {ok: false, 왜: string}}
  */
-export function 답에서JSON뽑기(글) {
+export function 답에서JSON뽑기(글, { 스키마 = null } = {}) {
   const s = String(글 ?? '').trim();
   if (!s) return { ok: false, 왜: '답이 비었습니다' };
 
@@ -280,42 +528,119 @@ export function 답에서JSON뽑기(글) {
   const 그대로 = 해보기(s);
   if (그대로) return { ...그대로, 군말: false };
 
-  // ```json … ``` 울타리
-  const 울타리 = /```(?:json|jsonc)?\s*\n([\s\S]*?)\n?```/i.exec(s);
-  if (울타리) {
-    const r = 해보기(울타리[1].trim());
-    if (r) return { ...r, 군말: true };
+  /*
+   * ── 후보를 **다** 모은 뒤에 고른다 (사냥5 B5-06 · L5-4) ───────────────────────
+   *
+   * 여기는 첫 울타리 하나, 첫 `{`·`[` 하나만 보고 거기서 안 되면 포기했다. 그래서
+   *   · 「See [docs] below. {"a":"x"}」 · 「- [x] done」 · 「Use {placeholder}」 처럼 JSON 앞에
+   *     괄호 낀 산문이 있으면 뒤의 멀쩡한 JSON 을 못 찾아 7 로 섰고,
+   *   · 울타리가 둘인데 앞의 것이 예시면 **예시**를 답으로 냈다 — 예시가 모양에 맞으면
+   *     7 도 안 나고 지어낸 값이 파이프 뒤로 흘렀다.
+   *
+   * 고르는 규칙.
+   *   1) 울타리 안에서 읽힌 것이 하나라도 있으면 그것들만 본다. 「이것이 JSON 이다」 라고
+   *      모델이 표시한 자리라, 산문 속 `[1]` 같은 우연한 JSON 보다 믿을 만하다.
+   *   2) 없으면 맨글에서 짝이 맞는 괄호 덩이들을 앞에서부터 모은다(읽힌 덩이 안쪽은 건너뛴다).
+   *   3) 그중 스키마에 맞는 **마지막** 것 → 없으면 스키마 뿌리 갈래가 같은 마지막 것 →
+   *      그것도 없으면 그냥 마지막 것. 모델은 예시·되풀이를 앞에, 답을 끝에 둔다 — 시킬말도
+   *      「마지막 답은 JSON 하나」 라고 적는다. 스키마로 고르는 것은 그 규칙이 틀리는 날의
+   *      두 번째 그물이다. 맞는 것이 없을 때도 갈래가 같은 쪽을 골라야 되묻는 탈 목록이
+   *      엉뚱한 `[1]` 이야기가 아니라 진짜 답 이야기가 된다.
+   */
+  const 울타리후보 = [];
+  for (const m of s.matchAll(/```(?:jsonc?)?[ \t]*\r?\n?([\s\S]*?)```/gi)) {
+    const r = 해보기(m[1].trim());
+    if (r) 울타리후보.push(r);
   }
 
   /*
-   * 앞뒤에 말이 붙은 경우. 첫 `{`(또는 `[`)부터 짝이 맞는 자리까지 잘라 본다.
+   * 울타리 안 것이 **하나도 스키마에 안 맞으면** 맨글도 본다 (2.0.0 6회차 · Gemini 백엔드5역).
    *
-   * 따옴표 안의 괄호를 안 세는 것이 중요하다 — `{"글": "}"}` 를 깊이로만
-   * 세면 첫 `}` 에서 끊긴다.
+   * 1) 을 그대로 두면 「예시는 이렇습니다: ```json {…} ``` 실제 답: {…}」 에서 울타리 안 예시만 보고
+   * 그걸 답으로 냈다 — 스키마를 같이 받아 놓고도 울타리 밖의 맞는 답을 못 봤다. 맨글에서도 스키마에
+   * **맞는** 것만 고르므로(아래 밖맞는것) 산문 속 우연한 `[1]` 은 여전히 안 뽑힌다.
    */
-  const 시작 = Math.min(...['{', '['].map((ch) => { const i = s.indexOf(ch); return i < 0 ? Infinity : i; }));
-  if (Number.isFinite(시작)) {
-    const 열림 = s[시작];
-    const 닫힘 = 열림 === '{' ? '}' : ']';
-    let 깊이 = 0;
-    let 글속 = false;
-    for (let i = 시작; i < s.length; i++) {
-      const ch = s[i];
-      if (글속) {
-        if (ch === '\\') { i++; continue; }
-        if (ch === '"') 글속 = false;
-        continue;
-      }
-      if (ch === '"') { 글속 = true; continue; }
-      if (ch === 열림) 깊이++;
-      else if (ch === 닫힘 && --깊이 === 0) {
-        const r = 해보기(s.slice(시작, i + 1));
-        if (r) return { ...r, 군말: true };
-        break;
-      }
+  const 스키마있나 = 스키마 !== null && 스키마 !== undefined;
+  const 맞음 = (r) => { try { return 맞나(r.값, 스키마).ok; } catch { return false; } };
+  const 울타리맞음 = 스키마있나 && 울타리후보.some(맞음);
+  const 맨글후보 = [];
+  if (!울타리후보.length || (스키마있나 && !울타리맞음)) {
+    let i = 0;
+    /*
+     * 괄호가 수천 개 박힌 긴 답에서 끝없이 돌지 않게 묶는다 — **시작 자리 수가 아니라 훑은 글자 수**로
+     * (2.0.0 6회차 모양6좁).
+     *
+     * 시작 자리 256번으로 묶었더니 「item[0] item[1] … 최종 답: {"a":1}」 처럼 앞 산문의 작은 괄호
+     * 하나하나가 멀쩡한 JSON 이라 한 번씩을 다 쓰고, 끝의 진짜 답에 닿기 전에 멈춰 `[255]` 를 냈다.
+     * 로그·코드 조각을 앞에 붙인 긴 답에서 그대로 생긴다. 비싼 것은 짝이 없는 괄호에서 글 끝까지
+     * 훑는 쪽이라, 그 글자 수를 세어 글 길이의 64배(작은 글은 최소 64KB)를 넘으면 멈춘다.
+     */
+    const 훑기예산 = Math.max(64 * s.length, 64 * 1024);
+    let 훑은 = 0;
+    while (i < s.length && 훑은 <= 훑기예산) {
+      const 다음 = 괄호찾기(s, i);
+      if (다음 < 0) break;
+      const 끝 = 짝찾기(s, 다음);
+      훑은 += (끝 >= 0 ? 끝 + 1 : s.length) - 다음;
+      const r = 끝 >= 0 ? 해보기(s.slice(다음, 끝 + 1)) : null;
+      if (r) { 맨글후보.push(r); i = 끝 + 1; } else i = 다음 + 1;
+    }
+  }
+
+  const 후보들 = 울타리후보.length ? 울타리후보 : 맨글후보;
+  if (!후보들.length) return { ok: false, 왜: '답에서 JSON 을 못 찾았습니다' };
+  let 고른것 = 후보들.at(-1);
+  if (스키마있나) {
+    const 맞는것 = 후보들.filter(맞음);
+    // 울타리 안에 맞는 것이 없을 때만 — 울타리 밖에서 스키마에 맞는 것 (위 6회차 머리말).
+    const 밖맞는것 = 울타리후보.length && !맞는것.length ? 맨글후보.filter(맞음) : [];
+    const 갈래들 = 스키마 && typeof 스키마 === 'object'
+      ? (Array.isArray(스키마.type) ? 스키마.type : (typeof 스키마.type === 'string' ? [스키마.type] : null))
+      : null;
+    const 같은갈래 = 갈래들 ? 후보들.filter((r) => 갈래들.some((t) => 갈래맞나(r.값, t))) : [];
+    // 울타리 안에 맞는 것도 같은 갈래도 없을 때 — 울타리 밖의 같은 갈래 (2.0.0 6회차 모양6좁).
+    // 이게 없으면 「예시: ```json [1,2]``` 답: {"a":1}」 에서 {"a":1} 을 두고 갈래도 다른 예시를 냈다.
+    // 맞는 것이 없으니 되묻기로 가는 길이지만, 그 탈 목록이 진짜 답 이야기여야 모델이 고친다.
+    const 밖같은갈래 = 갈래들 && 울타리후보.length && !맞는것.length && !같은갈래.length
+      ? 맨글후보.filter((r) => 갈래들.some((t) => 갈래맞나(r.값, t)))
+      : [];
+    고른것 = 맞는것.at(-1) ?? 밖맞는것.at(-1) ?? 같은갈래.at(-1) ?? 밖같은갈래.at(-1) ?? 고른것;
+  }
+  return { ...고른것, 군말: true };
+}
+
+// i 자리부터 처음 나오는 `{` 또는 `[` 의 자리. 없으면 -1.
+function 괄호찾기(s, i) {
+  const a = s.indexOf('{', i);
+  const b = s.indexOf('[', i);
+  if (a < 0) return b;
+  if (b < 0) return a;
+  return Math.min(a, b);
+}
+
+/*
+ * 시작 괄호와 짝이 맞는 닫는 괄호의 자리. 없으면 -1.
+ *
+ * 따옴표 안의 괄호를 안 세는 것이 중요하다 — `{"글": "}"}` 를 깊이로만 세면 첫 `}`
+ * 에서 끊긴다. 따옴표는 **시작 괄호부터** 센다 — 그 앞 산문의 따옴표는 JSON 이 아니다.
+ */
+function 짝찾기(s, 시작) {
+  const 열림 = s[시작];
+  const 닫힘 = 열림 === '{' ? '}' : ']';
+  let 깊이 = 0;
+  let 글속 = false;
+  for (let i = 시작; i < s.length; i++) {
+    const ch = s[i];
+    if (글속) {
+      if (ch === '\\') { i++; continue; }
+      if (ch === '"') 글속 = false;
+      continue;
     }
+    if (ch === '"') { 글속 = true; continue; }
+    if (ch === 열림) 깊이++;
+    else if (ch === 닫힘 && --깊이 === 0) return i;
   }
-  return { ok: false, 왜: '답에서 JSON 을 못 찾았습니다' };
+  return -1;
 }
 
 /**

package/src/agent/pins.js

@@ -61,7 +61,26 @@ export class 못박기 {
       return { ok: false, why: `못 박을 수 있는 것은 ${최대개수}개까지입니다 — 매 턴 실리는 글이라 상한을 둡니다.` };
     }
     this.것들.push(s);
-    return { ok: true, 번호: this.것들.length };
+    /*
+     * ── 받은 것은 실려야 한다 (2.0.0 6회차 · Gemini 못박기6u W3) ─────────────
+     *
+     * 개수만 보고 받았다. 그런데 프롬프트에 싣는 쪽(#고른것)은 토큰 상한에서
+     * 끊는다 — 영어 200자 핀 12개가 다 ok 로 박히고 실린 것은 3개, 한글은 180자
+     * 한 줄이면 혼자서도 안 실렸다. /pin 추가 화면은 「접거나 요약해도 안
+     * 지워집니다」 만 찍으니, 사람은 말해 두었다고 믿는데 모델은 그 말을 못
+     * 받는다. 이 파일이 막으려던 바로 그 꼴이다. 안 실릴 것이면 받지 않는다.
+     */
+    if (this.#고른것(최대토큰).개수 < this.것들.length) {
+      this.것들.pop();
+      return { ok: false, why: `프롬프트에 실을 자리(${최대토큰}토큰 상한)가 모자라 이 말은 매 턴 실리지 못합니다 — 더 짧게 줄이거나 /pin 지우기 로 자리를 비우세요.` };
+    }
+    /*
+     * 박힌 말과 잘렸는지를 같이 돌려준다 (2.0.0 6회차 · Gemini 스레드6). 한줄최대 를 넘긴 말은
+     * 다듬기() 가 뒤를 자르는데, 화면은 사람이 친 원문을 박았다고 보여 줬다 — 「운영 DB 는 … 단
+     * 읽기는 된다」 의 뒤쪽 조건이 빠진 채 박힌 줄 모른다. 화면은 이 말을 보여 줘야 한다.
+     */
+    const 잘렸나 = String(말 ?? '').replace(/\s+/g, ' ').trim().length > s.length;
+    return { ok: true, 번호: this.것들.length, 말: s, 잘렸나 };
   }
 
   /**
@@ -136,5 +155,17 @@ export class 못박기 {
 
 function 다듬기(말) {
   const s = String(말 ?? '').replace(/\s+/g, ' ').trim();
-  return s ? s.slice(0, 한줄최대) : '';
+  if (!s) return '';
+  let t = s.slice(0, 한줄최대);
+  /*
+   * ── 반쪽 글자를 안 남긴다 (2.0.0 6회차 · Gemini 못박기6u W2) ─────────────
+   *
+   * slice 는 UTF-16 칸으로 자른다. 200번째 칸에 이모지 앞쪽 반이 걸리면 짝 없는
+   * 서로게이트 하나가 남는다. 이 글은 **매 턴** 시스템 프롬프트에 실리므로, 그런
+   * 글자를 JSON 에서 거절하는 서버라면 사람이 핀을 뺄 때까지 모든 턴이 깨진다.
+   * 되살릴 때도 여기를 지나므로 옛 기록에 남은 반쪽도 같이 떨어진다.
+   */
+  const 끝 = t.charCodeAt(t.length - 1);
+  if (끝 >= 0xd800 && 끝 <= 0xdbff) t = t.slice(0, -1);
+  return t;
 }