@things-factory/figure-service 10.1.167 → 10.1.168

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

@@ -12,7 +12,7 @@
  *
  * 실제 모델은 부르지 않는다. 여기서 볼 것은 모델의 솜씨가 아니라 **우리 배선**이다.
  */
-import { clearToolRegistry, getToolCategories, registryAssistantChat, setAIClientForTesting } from '@things-factory/ai-client-base'
+import { clearToolRegistry, getToolCategories, registryAssistantChat, setAIClientForTesting, toolCallContextFixture } from '@things-factory/ai-client-base'
 
 import { __setFigureToolDepsForTest, registerFigureToolCategories } from './figure-tools'
 
@@ -24,8 +24,17 @@ function stubRepository(rows: any[]) {
         rows.find(row => row.id === where.id && row.domain?.id === where.domain?.id) ?? null
       )
     },
-    async find({ where }: any) {
-      return rows.filter(row => row.domain?.id === where.domain?.id)
+    /* A where list is OR'ed, as typeorm does; an ILike operator is a case-blind pattern with `%` for anything. */
+    async find({ where, take }: any) {
+      const matches = (value: any, wanted: any) => {
+        if (wanted === undefined) return true
+        if (wanted?._type === 'ilike') return new RegExp(`^${String(wanted._value).split('%').map(escape).join('.*')}$`, 'i').test(String(value ?? ''))
+        return value === wanted
+      }
+      const escape = (text: string) => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+      const one = (row: any, w: any) => row.domain?.id === w.domain?.id && matches(row.name, w.name) && matches(row.type, w.type)
+      const found = rows.filter(row => (Array.isArray(where) ? where.some(w => one(row, w)) : one(row, where)))
+      return take === undefined ? found : found.slice(0, take)
     }
   }
 }
@@ -47,6 +56,13 @@ const ROWS = [
   { id: 'fig-other', type: 'SECRET', name: '남의 것', state: 'draft', domain: THEIRS, source: JSON.stringify(SOURCE) }
 ]
 
+/** A request translator for one locale, read from this package's translations as i18next reads them. */
+function translatorOf(locale: string) {
+  const words = require(`../../../translations/${locale}.json`)
+  return (key: string, params: Record<string, any> = {}) =>
+    String(words[key] ?? params.defaultValue ?? key).replace(/\{(\w+)\}/g, (whole, name) => (name in params ? String(params[name]) : whole))
+}
+
 /** 부른 것을 적어 두는 가짜 제안기. */
 const proposed: any[] = []
 
@@ -86,9 +102,9 @@ function toolNamed(name: string) {
   return spec as any
 }
 
-const ctx = (host: any = { figureId: 'fig-1', palette: ['palette.primary'] }) => ({
-  state: { domain: MINE }, host
-})
+/* The shape the door hands a tool (A3) - translator and checked attachments included - built by the door's own fixture. */
+const ctx = (host: any = { figureId: 'fig-1', palette: ['palette.primary'] }, extra: { t?: any; attachments?: any[] } = {}) =>
+  toolCallContextFixture({ domainId: MINE.id, host, ...extra })
 
 beforeEach(() => {
   clearToolRegistry()
@@ -222,22 +238,50 @@ describe('규율이 도구와 함께 나간다', () => {
 
     expect(category.guidance).toBeTruthy()
     expect(category.guidance).toContain('proposeFigureCandidate')
-    expect(category.guidance).toMatch(/거짓/)
-    expect(category.guidance).toMatch(/도구 호출 결과에서만/)
+    expect(category.guidance).toMatch(/\*\*false\*\*/)
+    expect(category.guidance).toMatch(/exists only as the result of that call/)
   })
 
   it('고치기 전에 정본을 읽으라고 말한다 — 이름이 갈리면 배치된 보드가 끊긴다', () => {
     const category = getToolCategories().find((one: any) => one.name === 'figure-authoring')!
 
     expect(category.guidance).toContain('getFigureSource')
-    expect(category.guidance).toMatch(/바인딩이 끊긴다/)
+    expect(category.guidance).toMatch(/breaks the bindings/)
   })
 
   it('타입 이름을 지어내지 말라고 말한다 — 저장되는 식별자다', () => {
     const category = getToolCategories().find((one: any) => one.name === 'figure-authoring')!
 
     expect(category.guidance).toContain('listFigures')
-    expect(category.guidance).toMatch(/저장되는 식별자/)
+    expect(category.guidance).toMatch(/stored identifier/)
+  })
+})
+
+/*
+  What the model reads is written in English (ADR-0061 Figure AI follow-up 5): the category's description and rules,
+  each tool's description and argument descriptions, and the control messages a tool returns. The answer's language is
+  the request's; a person's own words, figure names and attachments are not translated.
+*/
+describe('모델이 읽는 글은 영어다', () => {
+  const hangul = /[\u3131-\u318e\uac00-\ud7a3]/
+
+  it('범주의 설명과 규율, 도구와 인자의 설명', () => {
+    const category = getToolCategories().find((one: any) => one.name === 'figure-authoring')!
+    const texts = [
+      category.description,
+      category.guidance,
+      ...category.specs.flatMap((spec: any) => [spec.description, ...Object.values(spec.schema?.properties ?? {}).map((one: any) => one.description)])
+    ]
+    for (const text of texts) expect(text).not.toMatch(hangul)
+  })
+
+  it('도구가 돌려주는 제어 메시지', async () => {
+    const missing = await toolNamed('getFigureSource').builder({}, ctx({}))
+    const notOpen = await toolNamed('proposeFigureCandidate').builder({ prompt: 'fix it', figureId: 'fig-blank' }, ctx(modeller()))
+    for (const result of [missing, notOpen]) {
+      expect(result.error).toBeTruthy()
+      expect(JSON.stringify(result)).not.toMatch(hangul)
+    }
   })
 })
 
@@ -303,11 +347,53 @@ describe('모델이 넘긴 id 를 믿지 않는다', () => {
     expect(result.figures.map((one: any) => one.id)).toEqual(['fig-1', 'fig-blank'])
   })
 
+  it('도구 설명이 저장 전 도형은 모델러에 열린 것만 읽는다고 말한다', () => {
+    const description = toolNamed('getFigureSource').schema.properties.figureId.description
+    expect(description).not.toMatch(/never saved is not open/)
+    expect(description).toMatch(/not saved yet/)
+  })
+
   it('도메인 문맥이 없으면 아무것도 읽지 않는다', async () => {
     await expect(toolNamed('listFigures').builder({}, { state: {} })).rejects.toThrow(/domain context is missing/)
   })
 })
 
+/*
+  The list stops at the most recently changed ones. A figure past that point used to be absent with nothing said - the
+  model took the cut list for the whole one and told the person the figure did not exist.
+*/
+describe('목록이 잘릴 때', () => {
+  const many = [
+    ...Array.from({ length: 205 }, (_, i) => ({ id: `fig-n${i}`, type: `NEW_${i}`, name: `새 것 ${i}`, state: 'draft', domain: MINE, source: null })),
+    { id: 'fig-old', type: 'OLD_PRESS', name: 'Roll press', state: 'released', domain: MINE, source: null }
+  ]
+  beforeEach(() => {
+    const model = require('@hatiolab/figure-model')
+    __setFigureToolDepsForTest({ getRepository: () => stubRepository(many), Figure: class {}, figureCostOf: model.figureCostOf, figureScoreOf: model.figureScoreOf })
+  })
+
+  it('잘렸다고 말한다', async () => {
+    const result = await toolNamed('listFigures').builder({}, ctx({}))
+    expect(result.figures).toHaveLength(200)
+    expect(result.truncated).toBe(true)
+    expect(result.note).toMatch(/search/)
+  })
+
+  it('이름이나 타입의 일부로 찾으면 잘린 뒤의 도형도 나온다 — 대소문자 없이', async () => {
+    const byName = await toolNamed('listFigures').builder({ search: 'roll PRESS' }, ctx({}))
+    const byType = await toolNamed('listFigures').builder({ search: 'old_press' }, ctx({}))
+    expect(byName.figures.map((one: any) => one.id)).toEqual(['fig-old'])
+    expect(byType.figures.map((one: any) => one.id)).toEqual(['fig-old'])
+    expect(byName.truncated).toBeUndefined()
+  })
+
+  it('찾는 말도 자기 도메인 안에서만 찾는다', async () => {
+    __setFigureToolDepsForTest({ getRepository: () => stubRepository(ROWS), Figure: class {} })
+    const result = await toolNamed('listFigures').builder({ search: 'secret' }, ctx({}))
+    expect(result.figures).toEqual([])
+  })
+})
+
 /*
   제안은 모델러의 명령 목록이다(ADR-0094). 고치는 제안은 모델러가 모델이 본 판 위에 한 단계로 적용하므로, 고칠 수
   있는 것은 모델러에 열린 도형뿐이고 그 판(context · revision)을 문맥이 싣고 와야 한다.
@@ -379,7 +465,7 @@ describe('제안을 요청할 때', () => {
     ).rejects.toThrow(/not found in this tenant/)
   })
 
-  it('세 번 거절된 끝의 사유가 도구 경계를 넘어간다 — 「만들지 못했습니다」만 남지 않게', async () => {
+  it('세 번 거절된 끝의 사유가 도구 경계를 넘어간다 — 실패 한 줄만 남지 않게', async () => {
     const { ProposeFigureFailure } = require('./figure-propose-steps')
     const model = require('@hatiolab/figure-model')
     __setFigureToolDepsForTest({
@@ -387,13 +473,13 @@ describe('제안을 요청할 때', () => {
       Figure: class {},
       parseSource: require('./figure-format').parseSource,
       proposeFigureSteps: async () => {
-        throw new ProposeFigureFailure('만들지 못했습니다.', ['ATTACH_FACE: steps[4]: attach: faces along x'], 3)
+        throw new ProposeFigureFailure('The figure could not be made.', ['ATTACH_FACE: steps[4]: attach: faces along x'], 3)
       },
       figureCostOf: model.figureCostOf,
       figureScoreOf: model.figureScoreOf
     })
     await expect(toolNamed('proposeFigureCandidate').builder({ prompt: '고쳐줘' }, ctx(modeller()))).rejects.toThrow(
-      /만들지 못했습니다\.\nATTACH_FACE: steps\[4\]/
+      /The figure could not be made\.\nATTACH_FACE: steps\[4\]/
     )
   })
 })
@@ -410,19 +496,92 @@ describe('제안이 카드가 된다', () => {
     expect(out.steps).toEqual([{ kind: 'rename', name: 'Mixer' }])
   })
 
-  it('카드에 그릴 두 줄이 잰 값으로 온다', async () => {
-    const out = await toolNamed('proposeFigureCandidate').builder({ prompt: '교반기', create: true, name: 'Mixer' }, ctx({}))
+  /*
+    The card's two lines are sentences a person reads, so the tool writes them with the request's translator
+    (ADR-0061, 2026-10-16 decision 1). They were Korean strings in the code: an English screen read Korean.
+  */
+  it('★ 카드에 그릴 두 줄이 요청 로케일로, 잰 값으로 온다', async () => {
+    const out = await toolNamed('proposeFigureCandidate').builder({ prompt: '교반기', create: true, name: 'Mixer' }, ctx({}, { t: translatorOf('ko') }))
     expect(out.label).toBe('Mixer 만들기')
-    expect(out.reason).toMatch(/명령 1개/)
-    expect(out.reason).toMatch(/등급 B/)
-    expect(out.reason).toMatch(/삼각형 12/)
+    expect(out.reason).toBe('명령 1개 · 등급 B · 삼각형 12 · 1번에 만들었다')
+  })
+
+  it('★ 같은 제안이 영어 화면에는 영어로 온다 — 글은 코드에 박히지 않는다', async () => {
+    const out = await toolNamed('proposeFigureCandidate').builder({ prompt: 'mixer', create: true, name: 'Mixer' }, ctx({}, { t: translatorOf('en') }))
+    expect(out.label).toBe('Make Mixer')
+    expect(out.reason).toBe('1 commands · grade B · 12 triangles · made in 1 tries')
+  })
+
+  it('번역기에 이 글이 없어도 영어 기본값을 쓴다 — 키가 화면에 뜨지 않게', async () => {
+    const out = await toolNamed('proposeFigureCandidate').builder({ prompt: 'mixer', create: true, name: 'Mixer' }, ctx({}))
+    expect(out.label).toBe('Make Mixer')
+    expect(out.reason).toBe('1 commands · grade B · 12 triangles · made in 1 tries')
   })
 
   it('고치는 것과 만드는 것을 이름으로 가른다', async () => {
-    const revise = await toolNamed('proposeFigureCandidate').builder({ prompt: '고쳐줘' }, ctx(modeller()))
-    const create = await toolNamed('proposeFigureCandidate').builder({ prompt: '만들어줘', create: true }, ctx({}))
-    expect(revise.label).toMatch(/고치기/)
-    expect(create.label).toMatch(/만들기/)
+    const revise = await toolNamed('proposeFigureCandidate').builder({ prompt: '고쳐줘' }, ctx(modeller(), { t: translatorOf('ko') }))
+    const create = await toolNamed('proposeFigureCandidate').builder({ prompt: '만들어줘', create: true }, ctx({}, { t: translatorOf('ko') }))
+    expect(revise.label).toBe('Probe 고치기')
+    expect(create.label).toBe('Figure 만들기')
+  })
+
+  it('카드의 글은 여섯 언어 모두에 있다', () => {
+    for (const locale of ['en', 'ko', 'ja', 'zh', 'es', 'ms']) {
+      const words = require(`../../../translations/${locale}.json`)
+      for (const key of ['figure.proposal.label-create', 'figure.proposal.label-revise', 'figure.proposal.reason']) {
+        expect([locale, key, typeof words[key]]).toEqual([locale, key, 'string'])
+      }
+    }
+  })
+})
+
+/*
+  A picture the person attached reaches the step generator (ADR-0061, 2026-10-16 decision 2). The dock uploads files by
+  attachmentIds and never fills hostContext.image, so the tool reads the server-checked attachments, every image of them.
+*/
+describe('사람이 붙인 그림', () => {
+  const FRONT = { id: 'att-1', name: 'front.png', kind: 'image', mediaType: 'image/png', size: 4, data: Buffer.from([1, 2, 3, 4]) }
+  const NOTES = { id: 'att-2', name: 'notes.txt', kind: 'text', mediaType: 'text/plain', size: 5, text: 'tall', truncated: false }
+  const SIDE = { id: 'att-3', name: 'side.jpg', kind: 'image', mediaType: 'image/jpeg', size: 3, data: Buffer.from([9, 9, 9]) }
+
+  it('★ 서버가 확인한 첨부의 그림이 모두, 붙인 순서로 제안기에 간다', async () => {
+    await toolNamed('proposeFigureCandidate').builder({ prompt: '이 그림처럼', create: true }, ctx({}, { attachments: [FRONT, NOTES, SIDE] }))
+    expect(proposed[0].images).toEqual([
+      { data: FRONT.data, mediaType: 'image/png' },
+      { data: SIDE.data, mediaType: 'image/jpeg' }
+    ])
+  })
+
+  it('★ 화면이 hostContext 에 실은 그림은 제안기에 가지 않는다 — 서버가 확인한 것이 아니다', async () => {
+    const host = { image: { data: 'AQIDBA==', mediaType: 'image/png' }, attachments: [{ mediaType: 'image/png', data: 'AQIDBA==' }] }
+    await toolNamed('proposeFigureCandidate').builder({ prompt: '이 그림처럼', create: true }, ctx(host))
+    expect(proposed[0].images).toBeUndefined()
+  })
+
+  it('그림이 없으면 그림 없이 묻는다', async () => {
+    await toolNamed('proposeFigureCandidate').builder({ prompt: '믹서', create: true }, ctx({}, { attachments: [NOTES] }))
+    expect(proposed[0].images).toBeUndefined()
+  })
+
+  it('★ 문이 받은 첨부가 도구를 지나 제안기까지 간다 — registryAssistantChat 경계 그대로', async () => {
+    let turn = 0
+    await registryAssistantChat({
+      client: {
+        chatWithTools: async () =>
+          turn++ === 0
+            ? { toolCalls: [{ id: 'p-1', name: 'proposeFigureCandidate', arguments: { prompt: '이 그림처럼 만들어줘', create: true }, type: 'tool_use' }], stopReason: 'tool_use' }
+            : { text: '후보를 냈습니다.', toolCalls: [], stopReason: 'end_turn' }
+      } as any,
+      messages: [{ role: 'user', content: '이 그림처럼 만들어줘' }],
+      systemPrompt: 'Author figures.',
+      toolCategories: ['figure-authoring'],
+      state: { domain: MINE },
+      hostContext: {},
+      attachments: [FRONT] as any,
+      toolAccess: async () => true
+    })
+    expect(proposed).toHaveLength(1)
+    expect(proposed[0].images).toEqual([{ data: FRONT.data, mediaType: 'image/png' }])
   })
 })
 
@@ -435,8 +594,209 @@ describe('도형이 모델러에 열려 있을 때', () => {
     expect(got.score.grade).toBe('A')
   })
 
+  /*
+    "This part", "the selected one", "the value I am trying": the screen sends what it has in view with the version it was
+    seen on (ADR-0097 §5.6 item 5). The model hears it only through a read tool (ADR-0061 decision 3), so a tool that
+    drops it leaves the model guessing which part was meant.
+  */
+  it('선택한 부품과 시험 중인 값을 같은 판에서 본 것일 때 함께 읽는다', async () => {
+    const host = modeller({
+      selection: { part: 'body', context: 'ctx-7', revision: 4 },
+      trying: { clips: { lift: 0.5 }, controls: { height: 300 }, context: 'ctx-7', revision: 4 }
+    })
+    const got = await toolNamed('getFigureSource').builder({}, ctx(host))
+    expect(got.selection).toEqual({ part: 'body' })
+    expect(got.trying).toEqual({ clips: { lift: 0.5 }, controls: { height: 300 } })
+  })
+
+  it('다른 판에서 본 선택이나 초안에 없는 부품은 말하지 않는다 — 없는 부품을 가리키지 않게', async () => {
+    const stale = await toolNamed('getFigureSource').builder({}, ctx(modeller({ selection: { part: 'body', context: 'ctx-7', revision: 3 } })))
+    const missing = await toolNamed('getFigureSource').builder({}, ctx(modeller({ selection: { part: 'arm', context: 'ctx-7', revision: 4 } })))
+    expect(stale.selection).toBeUndefined()
+    expect(missing.selection).toBeUndefined()
+  })
+
+  it('시험 값은 수만 싣는다 — 화면이 보낸 것은 믿지 않는 자료다', async () => {
+    const got = await toolNamed('getFigureSource').builder(
+      {},
+      ctx(modeller({ trying: { clips: { lift: 'drop table', open: 1 }, controls: { height: Infinity }, context: 'ctx-7', revision: 4 } }))
+    )
+    expect(got.trying).toEqual({ clips: { open: 1 } })
+  })
+
+  it('저장된 정본을 읽을 때는 화면의 선택을 붙이지 않는다 — 다른 도형의 선택일 수 있다', async () => {
+    const got = await toolNamed('getFigureSource').builder({ figureId: 'fig-1' }, ctx({ selection: { part: 'body', context: 'c', revision: 1 }, context: 'c', revision: 1 }))
+    expect(got.draft).toBe(false)
+    expect(got.selection).toBeUndefined()
+  })
+
+  it('고치는 제안에는 선택한 부품이 제안기까지 간다', async () => {
+    await toolNamed('proposeFigureCandidate').builder({ prompt: '이것을 더 크게' }, ctx(modeller({ selection: { part: 'body', context: 'ctx-7', revision: 4 } })))
+    expect(proposed[0].focus).toEqual({ selection: { part: 'body' } })
+  })
+
   it('형식을 어긴 초안은 저장 문의 말로 거절한다', async () => {
     const broken = { ...figureDraft(), appearance: [] }
     await expect(toolNamed('getFigureSource').builder({}, ctx({ figureId: 'fig-1', draftSource: broken }))).rejects.toThrow(/unsaved draft is invalid/)
   })
 })
+
+/*
+  A figure the kernel keeps (1 MiB) can be larger than the model is shown in one read (ADR-0061 2026-10-16 decision 4).
+  Until then the tools refused any draft over 100,000 characters: a figure that opened and saved got no read, no
+  inspection and no proposal, and saving again did not help. Now it is read as an outline and the parts asked for.
+*/
+describe('도형이 한 번에 보일 만큼보다 클 때', () => {
+  const { FIGURE_CONTEXT_BUDGET } = require('./figure-context')
+  const model = require('@hatiolab/figure-model')
+  let under: any
+  let over: any
+  beforeAll(() => {
+    let rack = model.createFigureAsset('Rack')
+    for (let i = 0; ; i++) {
+      const next = model.applyFigureProposal(rack, [
+        { kind: 'add-part', part: { id: `shelf-${i}`, kind: 'box', dimensions: { width: 1200, height: 40, depth: 600 } } },
+        i === 0
+          ? { kind: 'attach', part: 'shelf-0', face: 'bottom', to: { plane: 'mounting-plane' } }
+          : { kind: 'attach', part: `shelf-${i}`, face: 'bottom', to: { part: `shelf-${i - 1}`, face: 'top' }, gap: 300 }
+      ])
+      if (JSON.stringify(next).length > FIGURE_CONTEXT_BUDGET) {
+        under = rack
+        over = next
+        return
+      }
+      rack = next
+    }
+  })
+
+  it('바로 아래는 원본 전체를 읽는다', async () => {
+    const got = await toolNamed('getFigureSource').builder({}, ctx(modeller({ draftSource: under })))
+    expect(got.source).toEqual(under)
+    expect(got.outline).toBeUndefined()
+  })
+
+  it('바로 위도 거절하지 않는다 — 개요와 고른 부품을 읽고, 잰 값은 전체에서 잰다', async () => {
+    const got = await toolNamed('getFigureSource').builder({ parts: ['shelf-3'] }, ctx(modeller({ draftSource: over })))
+    expect(got.source).toBeUndefined()
+    expect(got.outline.parts).toHaveLength(over.appearance.length)
+    expect(Object.keys(got.partSources)).toEqual(['shelf-3'])
+    expect(JSON.stringify(got.outline).length).toBeLessThan(FIGURE_CONTEXT_BUDGET)
+    expect(got.note).toMatch(/parts/)
+    expect(got.cost).toEqual(model.figureCostOf(over))
+    expect(JSON.stringify(got).length).toBeLessThan(FIGURE_CONTEXT_BUDGET + 2_000)
+  })
+
+  it('절은 포인터로 읽는다', async () => {
+    const got = await toolNamed('getFigureSource').builder({ sections: ['/palette'] }, ctx(modeller({ draftSource: over })))
+    expect(got.sectionSources).toEqual({ '/palette': over.palette })
+  })
+
+  it('고른 부품이 없으면 선택한 부품을 읽는다', async () => {
+    const got = await toolNamed('getFigureSource').builder({}, ctx(modeller({ draftSource: over, selection: { part: 'shelf-6', context: 'ctx-7', revision: 4 } })))
+    expect(Object.keys(got.partSources)).toEqual(['shelf-6'])
+  })
+
+  it('저장된 원본도 같은 예산으로 읽는다', async () => {
+    __setFigureToolDepsForTest({
+      getRepository: () => stubRepository([{ id: 'fig-big', type: 'RACK', name: 'Rack', state: 'draft', domain: MINE, source: JSON.stringify(over) }]),
+      Figure: class {},
+      figureCostOf: model.figureCostOf,
+      figureScoreOf: model.figureScoreOf
+    })
+    const got = await toolNamed('getFigureSource').builder({ figureId: 'fig-big' }, ctx({}))
+    expect(got.source).toBeUndefined()
+    expect(got.outline.chars).toBe(JSON.stringify(over).length)
+  })
+
+  it('검사는 전체 원본으로 하고, 거절하지 않는다', async () => {
+    const seen: string[] = []
+    __setFigureToolDepsForTest({
+      getRepository: () => stubRepository(ROWS),
+      Figure: class {},
+      parseSource: require('./figure-format').parseSource,
+      inspectSource: (json: string) => {
+        seen.push(json)
+        return { blocked: false, findings: [] }
+      }
+    })
+    const got = await toolNamed('inspectFigure').builder({}, ctx(modeller({ draftSource: over })))
+    expect(got.blocked).toBe(false)
+    expect(seen[0].length).toBe(JSON.stringify(over).length)
+  })
+
+  it('검사 결과가 예산을 넘으면 앞에서부터 싣고 몇 개 중 몇 개인지 말한다', async () => {
+    const findings = Array.from({ length: 2_000 }, (_, i) => ({ code: 'part-outside-room', message: `shelf-${i} stands outside the room declared for the figure`, at: `shelf-${i}`, blocking: true }))
+    __setFigureToolDepsForTest({
+      getRepository: () => stubRepository(ROWS),
+      Figure: class {},
+      parseSource: require('./figure-format').parseSource,
+      inspectSource: () => ({ blocked: true, findings })
+    })
+    const got = await toolNamed('inspectFigure').builder({}, ctx(modeller({ draftSource: over })))
+    expect(JSON.stringify(got).length).toBeLessThanOrEqual(FIGURE_CONTEXT_BUDGET)
+    expect(got.truncated).toEqual({ shown: got.findings.length, total: 2_000 })
+    expect(got.findings[0]).toEqual(findings[0])
+  })
+
+  it('고치는 제안에 고른 부품이 제안기까지 가고, 판은 그대로 돌아온다', async () => {
+    const out = await toolNamed('proposeFigureCandidate').builder(
+      { prompt: '3단을 빨갛게', parts: ['shelf-3'], sections: ['/palette', 7] },
+      ctx(modeller({ draftSource: over }))
+    )
+    expect(proposed[0].base).toEqual(over)
+    expect(proposed[0].read).toEqual({ parts: ['shelf-3'], sections: ['/palette'] })
+    expect(out.revision).toBe(4)
+  })
+})
+
+/*
+  A figure not saved yet is a subject too (ADR-0061 decision 3). The modeller names it by its creation id - the id its
+  first save inserts the row under (ADR-0072 decision 6) - so before that save there is no row: the tools read the draft
+  the screen sent, through the same door a save goes through. Only the figure open on that screen: an id the model passes
+  that has no row and is not the open one is still not found.
+*/
+describe('저장 전 도형', () => {
+  const CREATION = '33333333-3333-4333-8333-333333333333'
+  const unsaved = (over: any = {}) => modeller({ figureId: CREATION, editorMode: 'new', ...over })
+
+  it('★ 화면이 보낸 초안을 읽고 잰다 — 행이 없어도', async () => {
+    const got = await toolNamed('getFigureSource').builder({}, ctx(unsaved()))
+    expect(got).toMatchObject({ id: CREATION, name: 'Probe', draft: true })
+    expect(got.source.version).toBe('figure-asset-1')
+    expect(got.cost.triangles).toBe(12)
+  })
+
+  it('선택한 부품도 함께 읽는다 — 「이 부품」이 무엇인지', async () => {
+    const got = await toolNamed('getFigureSource').builder({}, ctx(unsaved({ selection: { part: 'body', context: 'ctx-7', revision: 4 } })))
+    expect(got.selection).toEqual({ part: 'body' })
+  })
+
+  it('발행 판정도 초안으로 한다', async () => {
+    const got = await toolNamed('inspectFigure').builder({}, ctx(unsaved()))
+    expect(got).toMatchObject({ blocked: false, draft: true })
+  })
+
+  it('★ 고치는 제안은 그 초안 위에, 모델러가 적용할 판과 함께 낸다', async () => {
+    const out = await toolNamed('proposeFigureCandidate').builder({ prompt: '이 부품을 더 크게' }, ctx(unsaved({ selection: { part: 'body', context: 'ctx-7', revision: 4 } })))
+    expect(proposed[0].base.name).toBe('Probe')
+    expect(proposed[0].focus).toEqual({ selection: { part: 'body' } })
+    expect(out).toMatchObject({ create: false, figureId: CREATION, context: 'ctx-7', revision: 4 })
+  })
+
+  it('형식을 어긴 초안은 저장 문의 말로 거절한다', async () => {
+    const broken = { ...figureDraft(), appearance: [] }
+    await expect(toolNamed('getFigureSource').builder({}, ctx(unsaved({ draftSource: broken })))).rejects.toThrow(/unsaved draft is invalid/)
+  })
+
+  it('★ 열려 있지 않은 id 는 행이 없으면 못 찾았다고 한다', async () => {
+    await expect(toolNamed('getFigureSource').builder({ figureId: CREATION }, ctx(modeller()))).rejects.toThrow(/not found in this tenant/)
+  })
+
+  it('초안을 보내지 않은 화면에서는 못 찾았다고 한다', async () => {
+    await expect(toolNamed('getFigureSource').builder({}, ctx({ figureId: CREATION, editorMode: 'new' }))).rejects.toThrow(/not found in this tenant/)
+  })
+
+  it('생성 식별자 꼴이 아닌 이름은 저장 전 도형으로 읽지 않는다', async () => {
+    await expect(toolNamed('getFigureSource').builder({}, ctx(unsaved({ figureId: 'fig-unknown' })))).rejects.toThrow(/not found in this tenant/)
+  })
+})