@things-factory/figure-service 10.1.63 → 10.1.65

package/server/service/figure/figure-propose.test.ts

@@ -1,719 +0,0 @@
-/**
- * figure-propose — AI 가 낸 것을 무엇으로 거르나.
- *
- * 이 파일이 지키는 것은 하나다. **형식을 어긴 후보는 사람에게 가지 않는다.**
- *
- * AI 생성이 3D 에서 대개 잘 안 되는 이유는 「틀렸는지 기계가 판정할 수 없어서」인데,
- * 여기는 판정기가 있다. 그 판정기를 실제로 통과시키는지, 틀렸을 때 사유를 모델에
- * 돌려주고 다시 시키는지, 끝내 못 만들면 **못 만들었다고 말하는지**를 본다.
- *
- * 모델은 부르지 않는다. 부르면 시험이 느리고 답이 매번 다르다 — 여기서 볼 것은
- * 모델의 솜씨가 아니라 **우리 거름망**이다.
- */
-import {
-  ANCHOR_RULES,
-  DETAIL_LEVELS,
-  CAPABILITY_NEEDS,
-  CHANNEL_PATHS,
-  FIGURE_CAPABILITIES,
-  FIGURE_PLACEMENTS,
-  INTERPOLATIONS,
-  LABEL_WHENS,
-  LIMITS,
-  MATERIAL_SLOTS,
-  PART_LIMIT,
-  PART_ROLES,
-  PRIMITIVE_KINDS,
-  REPEAT_LIMIT,
-  SEGMENT_PRESETS,
-  SIZING_RULES
-} from '@hatiolab/figure-model'
-import { setDefaultAIClient } from '@things-factory/ai-client-base'
-import type { AIClient } from '@things-factory/ai-client-base'
-
-import { readFileSync } from 'fs'
-
-import * as model from '@hatiolab/figure-model'
-
-import { ProposeFailure, inspect, proposeFigure, rulesPrompt } from './figure-propose'
-
-
-/**
- * 형식이 선언한 칸 이름을 **형식 소스에서** 읽는다.
- *
- * 손으로 옮겨 적으면 형식이 자라도 이 파일은 그대로 있고, 그러면 이 시험이 지키려는 것을
- * 스스로 어긴다. 타입은 런타임에 안 남으므로 선언을 읽는다.
- */
-function declaredFields(name: string): string[] {
-  const path = require.resolve('@hatiolab/figure-model/package.json')
-  const root = path.replace(/package\.json$/, '')
-  const source = readFileSync(`${root}dist/types.d.ts`, 'utf8')
-  const body = source.match(new RegExp(`interface ${name} \\{([\\s\\S]*?)\\n\\}`))
-  if (!body) throw new Error(`형식에서 ${name} 을 못 찾았다 — 이름이 바뀌었으면 시험도 따라가야 한다`)
-  return [...body[1].matchAll(/^\s{4}([a-zA-Z]+)\??:/gm)].map(m => m[1]!)
-}
-
-const PALETTE = ['palette.primary', 'palette.accent', 'palette.neutral']
-
-/** 온전한 후보. 시험할 곳만 덮어쓴다. */
-function candidate(over: Record<string, unknown> = {}) {
-  return {
-    version: 2,
-    type: 'MIXER',
-    base: { x: 300, y: 500, z: 300 },
-    detailLevel: 'M',
-    parts: [
-      {
-        name: 'body',
-        primitive: 'cylinder',
-        segments: 12,
-        transform: { position: { x: 0, y: 250, z: 0 }, size: { x: 300, y: 400, z: 300 } },
-        material: { token: 'palette.primary' }
-      }
-    ],
-    ...over
-  }
-}
-
-/**
- * 정해 둔 답을 차례로 내놓는 가짜 모델.
- *
- * **받은 말을 적어 둔다.** 프롬프트에 실려 나가는 지시 중에 지켜져야 할 것이 있어서다 —
- * 고치는 요청에서 「부품 이름을 바꾸지 말라」가 빠지면 AI 가 이름을 갈아 버리고, 그러면
- * 이미 배치된 도면의 바인딩이 끊긴다. 답만 보는 모형으로는 그것이 나갔는지 알 수 없다.
- */
-function stubClient(answers: unknown[]): AIClient & { calls: number; sent: any[][]; options: any[]; system?: string } {
-  const client = {
-    id: 'stub',
-    calls: 0,
-    sent: [] as any[][],
-    options: [] as any[],
-    system: undefined as string | undefined,
-    async chat() {
-      return ''
-    },
-    async generateJSON(messages: any[], options?: { systemPrompt?: string; maxTokens?: number }) {
-      client.sent.push(JSON.parse(JSON.stringify(messages)))
-      client.options.push(options)
-      client.system = options?.systemPrompt
-      const answer = answers[client.calls]
-      client.calls++
-      if (answer instanceof Error) throw answer
-      return answer
-    }
-  }
-  return client as unknown as AIClient & { calls: number; sent: any[][]; options: any[]; system?: string }
-}
-
-/** 첫 요청에 실려 나간 사람 쪽 말. 이어 붙인 것까지 한 덩어리로 본다. */
-function firstAsk(client: { sent: any[][] }): string {
-  const content = client.sent[0]![0]!.content
-  return typeof content === 'string' ? content : JSON.stringify(content)
-}
-
-afterEach(() => setDefaultAIClient(undefined))
-
-describe('규칙을 프롬프트로 옮길 때', () => {
-  it('값을 손으로 적지 않고 figure-model 에서 가져온다', () => {
-    const prompt = rulesPrompt(PALETTE)
-
-    for (const kind of PRIMITIVE_KINDS) {
-      expect(prompt).toContain(kind)
-    }
-    for (const preset of SEGMENT_PRESETS) {
-      expect(prompt).toContain(String(preset))
-    }
-    expect(prompt).toContain(`<= ${LIMITS.materialGroups}`)
-    expect(prompt).toContain(`M=${PART_LIMIT.M}`)
-  })
-
-  it('쓸 수 있는 팔레트 토큰만 알려 준다', () => {
-    const prompt = rulesPrompt(PALETTE)
-
-    expect(prompt).toContain('palette.primary | palette.accent | palette.neutral')
-  })
-})
-
-/*
- * ── Every authorable feature has to reach the model ──────────────────────────
- *
- * The prompt is the only place the model learns what a figure may contain. Until 2026-09-16 it
- * taught `{ type, base, placement, detailLevel, parts }` and one stray line naming the animation
- * paths, so anchors, repeats, capabilities, labels, lamps, hollows and movement were unreachable:
- * the model was told there is a limit of two animated parts without ever being told where an
- * animation goes. What came back was coloured boxes.
- *
- * These check per feature rather than per word, because a vocabulary list the model cannot place
- * in the JSON is worse than no mention at all — it produces confident, invalid output.
- */
-/*
- * ── The format is the only vocabulary, and the prompt must follow it ─────────
- *
- * Checking feature by feature does not hold: a list of features has to be extended by hand every
- * time the format grows, which is the failure it is supposed to prevent. Until 2026-09-16 the
- * prompt taught five fields out of thirteen and a single stray line naming the animation paths,
- * and nothing failed — because nothing compared the prompt against the format.
- *
- * So these walk `@hatiolab/figure-model` itself. Every enum it exports is either something an
- * author writes into a FigureSource, in which case the model has to be taught all of its values,
- * or it is not, in which case it is named below with the reason. Adding an enum to the format
- * forces that decision instead of letting it be forgotten.
- */
-describe('프롬프트는 형식을 따라간다 — 손으로 적은 목록이 아니라', () => {
-  /*
-    저작자가 FigureSource 에 적는 값이 아닌 열거. 여기 없는 새 열거가 형식에 생기면 아래 시험이
-    깨지고, 가르칠지 말지를 그때 정하게 된다.
-  */
-  const NOT_AUTHORED: Record<string, string> = {
-    ERROR_CODES: '검증 결과다 — 저작자가 적는 값이 아니다',
-    VIOLATION_CODES: '같다',
-    RELEASE_BLOCKING_VIOLATIONS: '위반 코드의 부분집합이다 — 어느 것이 발행을 막나는 관문이 알 일이지 저작자가 적는 값이 아니다',
-    AXES: "'x'·'y'·'z' 는 축 이름이고 값이 아니다 — 쓰는 자리에서 anchor.<axis> 로 가르친다",
-    SURFACE_KINDS: 'material.surface 는 things-scene 에 소비처가 0건이다 — 그릴 수 없는 것을 시키지 않는다',
-    /*
-      V3 커널의 연산자 이름이다. 제안기는 아직 V2 FigureSource 를 쓰므로 저작자가 적는 값이 아니다.
-      제안기가 V3 자산을 쓰게 되는 날 이 세 줄을 지우고 프롬프트가 연산자를 가르쳐야 한다(ADR-0087).
-    */
-    V3_OPERATORS: 'V3 커널 연산자 이름이다 — 제안기가 V2 정본을 쓰는 동안은 저작자가 적는 값이 아니다',
-    V3_NON_AFFINE_OPERATORS: '위 목록의 부분집합이다 — 어느 연산이 다중선형을 안 나르나는 관문이 알 일이다',
-    V3_STATE_NON_AFFINE_OPERATORS: '같다',
-    V3_BUDGET_KEYS: 'V3 등급이 재는 예산의 이름이다 — 채점 결과이지 저작자가 적는 값이 아니다'
-  }
-
-  it('저작에 쓰이는 열거는 값 하나도 빠짐없이 프롬프트에 있다', () => {
-    const prompt = rulesPrompt(PALETTE)
-    const missing: string[] = []
-
-    for (const [name, value] of Object.entries(model as Record<string, unknown>)) {
-      if (!Array.isArray(value) || value.some(v => typeof v !== 'string')) continue
-      if (name in NOT_AUTHORED) continue
-      for (const member of value as string[]) {
-        if (!prompt.includes(member)) missing.push(`${name}.${member}`)
-      }
-    }
-
-    expect(missing).toEqual([])
-  })
-
-  it('저작에 안 쓰이는 열거는 이유가 적혀 있다 — 조용히 빠지지 않는다', () => {
-    const enums = Object.entries(model as Record<string, unknown>)
-      .filter(([, v]) => Array.isArray(v) && v.length > 0 && v.every(x => typeof x === 'string'))
-      .map(([k]) => k)
-
-    /* 형식에 열거가 늘면 가르치거나 NOT_AUTHORED 에 이유와 함께 적어야 한다. */
-    const prompt = rulesPrompt(PALETTE)
-    const unclassified = enums.filter(
-      name => !(name in NOT_AUTHORED) && !(model as any)[name].every((m: string) => prompt.includes(m))
-    )
-
-    expect(unclassified).toEqual([])
-  })
-
-  it('한도는 형식의 값을 그대로 인용한다 — 프롬프트에 숫자를 적어 두지 않는다', () => {
-    const prompt = rulesPrompt(PALETTE)
-
-    for (const [key, limit] of Object.entries(LIMITS)) {
-      if (typeof limit !== 'number') continue
-      /* 한도를 안 가르치는 것은 괜찮다. 다른 수를 가르치는 것은 안 된다. */
-      const wrong = new RegExp(`${key}[^\\n]*<=\\s*(?!${limit}\\b)\\d+`, 'i')
-      expect(prompt).not.toMatch(wrong)
-    }
-    expect(prompt).toContain(String(REPEAT_LIMIT))
-    for (const level of DETAIL_LEVELS) expect(prompt).toContain(`${level}=${PART_LIMIT[level]}`)
-  })
-
-  /*
-    가르치지 않는 칸. 열거와 같은 규율이다 — 여기 없는 새 칸이 형식에 생기면 아래가 깨지고,
-    그때 가르칠지 말지를 정하게 된다. 「아직 안 가르쳤다」가 조용히 남지 않는다.
-  */
-  const NOT_TAUGHT: Record<string, Record<string, string>> = {
-    FigureSource: {
-      type: '요청에서 온다 — 모델이 지어내면 거절한다',
-      parts: '모양 첫 줄에 이미 있다',
-      styleKit: '읽는 쪽이 0건이다 — 그릴 수 없는 것을 시키면 무동작 설정이 된다'
-    },
-    FigurePart: {
-      name: '모양 첫 줄에 있다',
-      primitive: '같다',
-      transform: '같다',
-      material: '같다'
-    },
-    PartMaterial: {
-      token: '모양 첫 줄에 있다',
-      preset: '같다',
-      surface: 'things-scene 에 소비처가 0건이다 — 그릴 수 없는 것을 시키지 않는다'
-    }
-  }
-
-  for (const iface of ['FigureSource', 'FigurePart', 'PartMaterial']) {
-    it(`${iface} 의 칸은 가르치거나 이유를 적었거나 둘 중 하나다`, () => {
-      const prompt = rulesPrompt(PALETTE)
-      const silent = declaredFields(iface).filter(
-        field => !(field in NOT_TAUGHT[iface]!) && !prompt.includes(field)
-      )
-
-      expect(silent).toEqual([])
-    })
-
-    it(`${iface} 의 제외 목록에 죽은 이름이 없다`, () => {
-      /* 형식에서 없어진 칸을 제외 목록이 계속 들고 있으면, 그 목록이 형식을 안 따라간 것이다. */
-      const declared = new Set(declaredFields(iface))
-      const stale = Object.keys(NOT_TAUGHT[iface]!).filter(field => !declared.has(field))
-
-      expect(stale).toEqual([])
-    })
-  }
-})
-
-describe('joints (ADR-0066)', () => {
-  it('teaches the joint shape with the type vocabulary, and a joint channel with no path and a number per key', () => {
-    const prompt = rulesPrompt(PALETTE)
-    expect(prompt).toContain(`type: ${(model as any).JOINT_TYPES.join(' | ')}`)
-    expect(prompt).toMatch(/NO path, NO pivot/)
-    expect(prompt).toMatch(/limits must include 0/)
-    expect(prompt).toMatch(/ONLY place a parent is written/)
-  })
-})
-
-describe('고치라는 요청일 때', () => {
-  it('편집 후보에는 JSON 완결에 충분한 출력 한도를 준다', async () => {
-    const client = stubClient([candidate()])
-    setDefaultAIClient(client as any)
-
-    await proposeFigure({ prompt: '색을 바꿔 줘', base: candidate() as any, palette: PALETTE })
-
-    expect((client as any).options?.[0]?.maxTokens).toBe(16384)
-  })
-
-  it('새 Figure 후보에도 같은 출력 한도를 준다', async () => {
-    const client = stubClient([candidate()])
-    setDefaultAIClient(client as any)
-
-    await proposeFigure({ prompt: '교반기', type: 'MIXER', palette: PALETTE })
-
-    expect((client as any).options?.[0]?.maxTokens).toBe(16384)
-  })
-
-  it('요청이 안 건드린 것을 그대로 실으라고 못 박는다', async () => {
-    /*
-      이 문장이 없으면 애니메이션이 있는 도형을 「색만 바꿔 줘」로 고쳤을 때 모델이 clip 을
-      안 실어 보내고, 그것이 오류 없이 통과해 조용히 사라진다.
-    */
-    const client = stubClient([candidate()])
-    setDefaultAIClient(client as any)
-    await proposeFigure({ prompt: '색을 바꿔 줘', base: candidate() as any, palette: PALETTE })
-
-    const sent = firstAsk(client)
-    expect(sent).toMatch(/Carry over everything the request did not ask you to change/)
-    expect(sent).toMatch(/dropping one is silent/)
-
-    /* 잃기 쉬운 칸은 이름으로 짚어 준다 — 「전부 지켜라」만으로는 모델이 빠뜨린다. */
-    for (const field of ['animations', 'parameters', 'joints', 'capabilities', 'parent', 'anchor', 'repeat', 'label', 'materialSlot']) {
-      expect(sent).toContain(field)
-    }
-  })
-})
-
-describe('후보를 받아 볼 때', () => {
-  it('온전하면 통과시킨다', () => {
-    const looked = inspect(candidate(), PALETTE)
-
-    expect(looked.source).toBeDefined()
-    expect(looked.reasons).toEqual([])
-  })
-
-  it('형식을 어기면 어디가 왜 틀렸는지 말한다', () => {
-    const looked = inspect(candidate({ parts: [] }), PALETTE)
-
-    expect(looked.source).toBeUndefined()
-    expect(looked.reasons.length).toBeGreaterThan(0)
-    expect(looked.reasons[0]).toContain('parts')
-  })
-
-  it('JSON 이 아니면 통과시키지 않는다', () => {
-    const looked = inspect('그럼요, 만들어 드릴게요', PALETTE)
-
-    expect(looked.source).toBeUndefined()
-    expect(looked.reasons.length).toBeGreaterThan(0)
-  })
-
-  /*
-    토큰은 형식상 자유 문자열이라 validate 를 지난다. 막지 않으면 저장까지 되고
-    화면에서 resolveToken 이 던진다 — 가장 늦게 드러나는 자리다.
-  */
-  it('팔레트에 없는 색을 지어내면 막는다', () => {
-    const bad = candidate()
-    bad.parts[0].material = { token: 'palette.brand' }
-
-    const looked = inspect(bad, PALETTE)
-
-    expect(looked.source).toBeUndefined()
-    expect(looked.reasons[0]).toContain('palette.brand')
-    expect(looked.reasons[0]).toContain('palette.primary')
-  })
-
-  it('요청한 저장 식별자와 다른 type을 지어내면 막는다', () => {
-    const looked = inspect(candidate({ type: 'FORKLIFT' }), PALETTE, 'MIXER')
-
-    expect(looked.source).toBeUndefined()
-    expect(looked.reasons).toEqual([expect.stringContaining('"MIXER"')])
-    expect(looked.reasons[0]).toContain('"FORKLIFT"')
-  })
-})
-
-describe('후보를 만들 때', () => {
-  it('한 번에 되면 점수와 무게를 함께 낸다', async () => {
-    setDefaultAIClient(stubClient([candidate()]))
-
-    const result = await proposeFigure({ prompt: '교반기', palette: PALETTE, type: 'MIXER' })
-
-    expect(result.attempts).toBe(1)
-    expect(result.source.parts).toHaveLength(1)
-    expect(result.score.grade).toMatch(/^[ABCD]$/)
-    expect(result.cost.triangles).toBeGreaterThan(0)
-    expect(result.quality.status).toMatch(/^(ready|review)$/)
-  })
-
-  it('요청하면 측정된 품질 근거를 다음 후보 개선에 돌려준다', async () => {
-    const generic = candidate({ parts: [
-      { name: 'part-1', primitive: 'cube', transform: { position: { x: -100, y: 250, z: 0 }, size: { x: 100, y: 100, z: 100 } }, material: { token: 'palette.primary' } },
-      { name: 'part-2', primitive: 'cube', transform: { position: { x: 0, y: 250, z: 0 }, size: { x: 100, y: 100, z: 100 } }, material: { token: 'palette.primary' } },
-      { name: 'part-3', primitive: 'cube', transform: { position: { x: 100, y: 250, z: 0 }, size: { x: 100, y: 100, z: 100 } }, material: { token: 'palette.primary' } },
-      { name: 'part-4', primitive: 'cube', transform: { position: { x: 150, y: 250, z: 0 }, size: { x: 50, y: 100, z: 100 } }, material: { token: 'palette.primary' } }
-    ] })
-    const refined = candidate({ parts: [{
-      name: 'vessel', primitive: 'cylinder', segments: 12,
-      transform: { position: { x: 0, y: 250, z: 0 }, size: { x: 280, y: 400, z: 280 } }, material: { token: 'palette.primary' }
-    }] })
-    const client = stubClient([generic, refined])
-    setDefaultAIClient(client)
-
-    const result = await proposeFigure({ prompt: '교반기', palette: PALETTE, type: 'MIXER', refine: true })
-
-    expect(result.attempts).toBe(2)
-    expect(result.source.parts[0]!.name).toBe('vessel')
-    expect(client.sent[1]![2]!.content).toContain('evidence-grounded refinement')
-  })
-
-  it('명시적 세션 피드백은 제한된 참고 데이터로 다음 후보 요청에 들어간다', async () => {
-    const client = stubClient([candidate()])
-    setDefaultAIClient(client)
-
-    await proposeFigure({
-      prompt: '포트가 더 눈에 띄게',
-      palette: PALETTE,
-      type: 'MIXER',
-      feedback: [
-        {
-          outcome: 'discarded', selectedChanges: 0, totalChanges: 4,
-          note: '실루엣은 유지하고 포트만 더 잘 보이게',
-          quality: { status: 'review', findingCodes: ['generic-part-name', 'bad code!'] }
-        }
-      ]
-    })
-
-    const ask = firstAsk(client)
-    expect(ask).toContain('session-only author feedback')
-    expect(ask).toContain('실루엣은 유지하고 포트만 더 잘 보이게')
-    expect(ask).toContain('generic-part-name')
-    expect(ask).not.toContain('bad code!')
-  })
-
-  it('틀리면 사유를 돌려주고 다시 시킨다', async () => {
-    const client = stubClient([candidate({ parts: [] }), candidate()])
-    setDefaultAIClient(client)
-
-    const result = await proposeFigure({ prompt: '교반기', palette: PALETTE, type: 'MIXER' })
-
-    expect(result.attempts).toBe(2)
-    expect(client.calls).toBe(2)
-  })
-
-  it('다른 type을 낸 후보도 다시 시킨다 — Figure 행과 source가 갈라지지 않게', async () => {
-    const client = stubClient([candidate({ type: 'FORKLIFT' }), candidate()])
-    setDefaultAIClient(client)
-
-    const result = await proposeFigure({ prompt: '교반기', palette: PALETTE, type: 'MIXER' })
-
-    expect(result.attempts).toBe(2)
-    expect(result.source.type).toBe('MIXER')
-    expect(client.sent[1]![2]!.content).toContain('The figure type must remain "MIXER"')
-  })
-
-  it('수정 후보는 원래 type을 바꿀 수 없다', async () => {
-    const client = stubClient([candidate({ type: 'FORKLIFT' }), candidate({ type: 'MIXER' })])
-    setDefaultAIClient(client)
-
-    const result = await proposeFigure({ prompt: '재질을 줄여줘', palette: PALETTE, base: candidate() as never })
-
-    expect(result.attempts).toBe(2)
-    expect(result.source.type).toBe('MIXER')
-  })
-
-  it('끝내 못 만들면 못 만들었다고 말한다 — 반쯤 만든 것을 내밀지 않는다', async () => {
-    setDefaultAIClient(stubClient([candidate({ parts: [] }), candidate({ parts: [] }), candidate({ parts: [] })]))
-
-    await expect(proposeFigure({ prompt: '교반기', palette: PALETTE, type: 'MIXER' })).rejects.toThrow(ProposeFailure)
-  })
-
-  it('못 만들었을 때 마지막 사유를 함께 낸다', async () => {
-    setDefaultAIClient(stubClient([candidate({ parts: [] }), candidate({ parts: [] }), candidate({ parts: [] })]))
-
-    await proposeFigure({ prompt: '교반기', palette: PALETTE, type: 'MIXER' }).catch((e: ProposeFailure) => {
-      expect(e.reasons.length).toBeGreaterThan(0)
-      expect(e.attempts).toBe(3)
-    })
-  })
-
-  it('모델이 없으면 있는 척하지 않는다', async () => {
-    setDefaultAIClient(undefined)
-
-    await expect(proposeFigure({ prompt: '교반기', palette: PALETTE, type: 'MIXER' })).rejects.toThrow(
-      /설정돼 있지 않습니다/
-    )
-  })
-})
-
-describe('무엇을 시키는지가 프롬프트에 실린다', () => {
-  /*
-    고치는 요청에서 이 지시가 빠지면 AI 가 부품 이름을 갈아 버린다. 부품 이름은 **저장되는
-    식별자**라서, 이미 배치된 도면의 바인딩·애니메이션이 그 이름을 가리키고 있다. 조용히
-    끊기고, 끊긴 것은 그 도면을 열어 봐야 드러난다.
-  */
-  it('고치는 요청이면 지금 정본과 「이름을 바꾸지 말라」가 함께 나간다', async () => {
-    const client = stubClient([candidate()])
-    setDefaultAIClient(client)
-
-    const base = candidate({ type: 'MIXER' }) as never
-    await proposeFigure({ prompt: '재질을 줄여줘', palette: PALETTE, base })
-
-    const ask = firstAsk(client)
-    expect(ask).toContain('Revise this existing figure')
-    expect(ask).toMatch(/renaming a part breaks bindings/)
-    expect(ask).toContain('Measured evidence for the existing figure')
-    expect(ask).toContain('top-view readability')
-    // 지금 정본이 실제로 실려 나가야 한다 — 없으면 모델이 처음부터 만든다.
-    expect(ask).toContain('"name":"body"')
-  })
-
-  /*
-    타입 이름을 안 주면 `FIGURE` 로 나간다. **조용히 지어지는 값**이라 못 박아 둔다 — 저작면이
-    타입을 늘 주므로 이 자리는 평소 안 보이지만, 안 주는 부르는 쪽이 생기면 모델이 만든 것이
-    전부 `FIGURE` 라는 이름을 갖게 된다. 타입 이름은 저장되는 식별자다.
-  */
-  it('타입을 안 주면 FIGURE 로 나간다 — 조용히 빈 이름을 보내지 않는다', async () => {
-    const client = stubClient([candidate()])
-    setDefaultAIClient(client)
-
-    await proposeFigure({ prompt: '무언가', palette: PALETTE })
-
-    expect(firstAsk(client)).toContain('type "FIGURE"')
-  })
-
-  it('새로 만드는 요청이면 타입 이름이 나가고 고치라는 말은 안 나간다', async () => {
-    const client = stubClient([candidate()])
-    setDefaultAIClient(client)
-
-    await proposeFigure({ prompt: '교반기', palette: PALETTE, type: 'MIXER' })
-
-    const ask = firstAsk(client)
-    expect(ask).toContain('type "MIXER"')
-    expect(ask).not.toContain('Revise this existing figure')
-  })
-
-  /*
-    그림은 **비례를 보라고** 주는 것이지 표면 무늬를 베끼라고 주는 것이 아니다. 그 말이 빠지면
-    모델이 사진의 로고·녹·글자까지 부품으로 만들려 들고, 로우폴리에서 그것은 부품 낭비다.
-  */
-  it('그림을 주면 비례를 보라는 말과 함께 나간다', async () => {
-    const client = stubClient([candidate()])
-    setDefaultAIClient(client)
-
-    await proposeFigure({
-      prompt: '이 설비',
-      palette: PALETTE,
-      type: 'MIXER',
-      image: { data: Buffer.from('89504e47', 'hex'), mediaType: 'image/png' }
-    })
-
-    const ask = firstAsk(client)
-    expect(ask).toMatch(/proportions and masses, not for surface detail/)
-    // 그림 자체도 실려야 한다 — 말만 나가고 그림이 빠지면 모델이 볼 것이 없다.
-    expect(ask).toContain('"type":"image"')
-  })
-})
-
-describe('모델이 JSON 을 못 낼 때', () => {
-  /*
-    어댑터가 던지는 경우다. 그것도 사유이므로 **돌려주고 다시 시킨다** — 던져 버리면 저작자는
-    「안 됐다」만 보고, 무엇이 문제였는지도 모델이 고칠 기회도 없다.
-  */
-  it('던진 사유를 돌려주고 다시 시킨다', async () => {
-    const client = stubClient([new Error('unterminated string'), candidate()])
-    setDefaultAIClient(client)
-
-    const result = await proposeFigure({ prompt: '교반기', palette: PALETTE, type: 'MIXER' })
-
-    expect(result.attempts).toBe(2)
-    expect(client.calls).toBe(2)
-
-    // 두 번째 요청에 그 사유가 실려야 한다.
-    const retry = JSON.stringify(client.sent[1])
-    expect(retry).toContain('unterminated string')
-    expect(retry).toMatch(/Answer with the JSON object only/)
-  })
-
-  it('세 번 다 던지면 못 만들었다고 말한다', async () => {
-    setDefaultAIClient(stubClient([new Error('a'), new Error('b'), new Error('c')]))
-
-    await expect(proposeFigure({ prompt: '교반기', palette: PALETTE, type: 'MIXER' })).rejects.toThrow(ProposeFailure)
-  })
-})
-
-describe('정책을 넘은 후보는 막지 않고 알린다', () => {
-  /*
-    형식의 두 갈래를 그대로 지킨다 — `errors` 는 막고 `violations` 는 알린다. 정책 위반으로
-    후보를 버리면 저작자가 판단할 기회가 없어진다. 랜드마크 설비 하나는 정교해도 되고, 그
-    대가가 숫자로 보이면 된다.
-  */
-  it('등급 한도를 넘겨도 후보로 오고 위반이 함께 온다', async () => {
-    const many = Array.from({ length: PART_LIMIT.S + 1 }, (_, at) => ({
-      name: `part-${at}`,
-      primitive: PRIMITIVE_KINDS[0],
-      transform: { position: { x: at * 10, y: 250, z: 0 }, size: { x: 20, y: 20, z: 20 } },
-      material: { token: PALETTE[0] }
-    }))
-    setDefaultAIClient(stubClient([candidate({ detailLevel: 'S', parts: many })]))
-
-    const result = await proposeFigure({ prompt: '단순한 것', palette: PALETTE, type: 'MIXER' })
-
-    expect(result.source.parts).toHaveLength(PART_LIMIT.S + 1)
-    expect(result.violations.map(one => one.code)).toContain('too-many-parts')
-  })
-})
-
-/*
- * `parameters` — the one field that answers "expose a value an instance can be given".
- *
- * A user asked for a hoist that lowers and raises, with the travel exposed as a variable. The
- * model answered with `sizing`/`anchor` on the figure's own height and invented
- * `capabilities: ["hoist"]`, which threw at render. It had not declined; it had gone looking and
- * not found -- because the door was hidden inside animations as `drive: 'hold'`, and the prompt
- * described that as a playback mode ("hold plays once and stays") when what it actually said was
- * WHO SUPPLIES THE VALUE.
- *
- * ADR-0051 moved it into its own field with a declared physical range, which is what makes the
- * value nameable: an instance gives 1200mm, not 0.67.
- *
- * These guard the wording, because the wording is the defect. A prompt that hides the one door
- * leaves the model to invent a door.
- */
-/*
- * The capability vocabulary, which the prompt used to leave open.
- *
- * It said "as plain names the scene knows" -- an instruction to guess. The model guessed
- * `capabilities: ['hoist']`, and because the list lived only in things-scene, figure-model's
- * validate could not refuse it: the asset passed validation, passed publication, and threw at
- * render. ADR-0051 (4) moved the list into the format, so the prompt can now state it.
- */
-describe('능력 이름을 형식에서 받아 적는다 — 「씬이 아는 이름」은 지어내라는 말이다', () => {
-  const prompt = () => rulesPrompt(PALETTE)
-
-  it('닫힌 목록이라고 못 박는다', () => {
-    const text = prompt()
-    expect(text).toMatch(/capabilities \(top level\)[\s\S]*CLOSED LIST/)
-    expect(text).not.toMatch(/plain names the scene knows/)
-  })
-
-  it('목록을 형식에서 읽는다 — 손으로 적지 않는다', () => {
-    /* 이름 하나를 여기 적어 두면 형식에 능력이 늘 때 이 시험이 조용히 통과한다. */
-    const text = prompt()
-    for (const name of FIGURE_CAPABILITIES) {
-      expect(text).toContain(name)
-    }
-  })
-
-  it('혼자 못 서는 능력도 함께 적는다 — 그것도 형식의 선언이다', () => {
-    const text = prompt()
-    for (const [name, needs] of Object.entries(CAPABILITY_NEEDS)) {
-      expect(text).toContain(`${name} cannot stand alone`)
-      for (const one of needs) expect(text).toContain(one)
-    }
-  })
-
-  it('움직임을 능력으로 답하지 말라고 한다 — 실제로 나왔던 답이다', () => {
-    expect(prompt()).toMatch(/Do NOT answer it with a capability/)
-  })
-})
-
-describe('값이 만드는 자세를 parameters 로 가르친다', () => {
-  const prompt = () => rulesPrompt(PALETTE)
-
-  it('재생 방식으로 적지 않는다', () => {
-    expect(prompt()).not.toMatch(/plays once|repeats forever/i)
-    expect(prompt()).toMatch(/Nothing is played back/)
-  })
-
-  it('두 갈래를 갈라서 적는다 — 어느 쪽이 무엇을 받는지까지', () => {
-    const text = prompt()
-    expect(text).toMatch(/TWO kinds and they are different fields/)
-    expect(text).toMatch(/animations\s+TIME RUNS\. The instance supplies a SPEED/)
-    expect(text).toMatch(/parameters\s+A VALUE MAKES THE POSE/)
-  })
-
-  it('인스턴스가 받는 값을 물으면 parameters 라고 못 박는다', () => {
-    /* 이 문장이 없으면 모델이 크기 반응 쪽으로 간다 — 실제로 갔다. */
-    expect(prompt()).toMatch(/USE parameters WHENEVER THE REQUEST ASKS FOR A VALUE THE INSTANCE IS GIVEN/)
-    expect(prompt()).toMatch(/EXPOSE something AS A VARIABLE/)
-  })
-
-  it('세 가지 잘못된 답을 각각 막는다 — 크기 반응 · 애니메이션 · 능력', () => {
-    const text = prompt()
-    expect(text).toMatch(/Do NOT answer that request with sizing or anchor/)
-    expect(text).toMatch(/Do NOT answer it with animations either/)
-    /* `capabilities: ['hoist']` 가 실제로 나왔던 답이다. */
-    expect(text).toMatch(/Do NOT answer it with a capability/)
-  })
-
-  it('범위를 사람이 말하는 단위로 적으라고 한다 — 0~1 이 아니라', () => {
-    /*
-      곡선의 값 축은 0~1 이지만 그것은 런타임의 말이다. 저작자와 인스턴스가 주고받는 것은
-      mm 이고, 그 선언이 없으면 「길이값을 변수로 노출」이 성립하지 않는다.
-    */
-    const text = prompt()
-    expect(text).toMatch(/range: \{ unit, min, max \}/)
-    expect(text).toMatch(/not 0 to 1/)
-  })
-
-  /*
-    Source edition 2 measures y up from the bottom face of the base box (ADR-0065). The prompt taught
-    the box-centre origin before; a model following that would write sources whose parts sit half a
-    box too low and that the release gate refuses.
-  */
-  it('teaches y from the bottom face of the base box and asks for version 2', () => {
-    const text = prompt()
-    expect(text).toMatch(/y is measured UP from its bottom face/)
-    expect(text).toMatch(/floor: the lowest part reaches\s+y = 0; ceiling: the highest reaches y = base\.y/)
-    expect(text).toMatch(/\{ version: 2, type, base/)
-    expect(text).not.toMatch(/-base\.y ?\/ ?2/)
-    expect(text).not.toMatch(/origin \(0,0,0\) is the centre of the base box/)
-  })
-
-  it('tells the model a parameter key sits on the value span', () => {
-    /*
-      Keys sit on the 0..1 value span and the format refuses a key above 1 (ADR-0051); the transition
-      time is clip.duration. The prompt once taught that the last at doubles as seconds, which led the
-      model to write keys in seconds and produce sources the format refuses.
-    */
-    const text = prompt()
-    expect(text).toMatch(/it is the\s+value span, 0 to 1/)
-    expect(text).toMatch(/An `at` above 1 is refused/)
-    expect(text).toMatch(/clip: \{ duration\?, channels/)
-    expect(text).toMatch(/Leave it\s+out and a new value takes effect at once/)
-    expect(text).not.toMatch(/doubles as the seconds/)
-  })
-
-  it('두 목록이 이름을 나눠 쓴다고 말한다 — 겹치면 형식이 막는다', () => {
-    expect(prompt()).toMatch(/may not be called the same thing/)
-  })
-})