@things-factory/figure-service 10.1.29 → 10.1.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-service",
-  "version": "10.1.29",
+  "version": "10.1.31",
   "publishConfig": {
     "access": "public",
     "@things-factory:registry": "https://registry.npmjs.org"
@@ -25,13 +25,13 @@
   "dependencies": {
     "@hatiolab/figure-model": "^0.1.27",
     "@operato/typeorm-history": "^10.0.0",
-    "@things-factory/ai-client-base": "^10.1.29",
-    "@things-factory/auth-base": "^10.1.29",
+    "@things-factory/ai-client-base": "^10.1.31",
+    "@things-factory/auth-base": "^10.1.31",
     "@things-factory/env": "^10.1.20",
-    "@things-factory/shell": "^10.1.29",
+    "@things-factory/shell": "^10.1.31",
     "graphql-scalars": "^1.22.4",
     "graphql-upload": "^15.0.2",
     "koa-router": "^7.4.0"
   },
-  "gitHead": "e6bf9dec003fe5e794746aaeb5852b3b50478232"
+  "gitHead": "5213e6f9913b40ea2618a2111d9884b792dbaa01"
 }

package/server/service/figure/figure-blueprint-query.test.ts

@@ -40,6 +40,12 @@ const sampleSource = JSON.stringify({
   ]
 })
 
+/** The same box under a different type and part name, so a test can tell the sources apart. */
+const boxNamed = (type: string, part: string) => {
+  const parsed = JSON.parse(sampleSource)
+  return JSON.stringify({ ...parsed, type, parts: [{ ...parsed.parts[0], name: part }] })
+}
+
 beforeAll(async () => {
   Figure = loadCompiled('service/figure/figure').Figure
   FigureHistory = loadCompiled('service/figure/figure-history').FigureHistory
@@ -176,13 +182,227 @@ describe('figureBlueprint 질의 — 소비처(board, twin, things-scene)를 위
     expect(result.groups[0].members[0].transform.size.x).toBe(100)
   })
 
+  /*
+    The test above proves a release is reached through history, with one history row. It cannot tell
+    `version: 'DESC'` from `'ASC'`, nor from no ordering at all — with a single row every one of them
+    answers the same. Consumers are promised the LATEST release, so the ordering is the claim, and it
+    needs more than one row to be a claim at all. The rows go in out of order because an ordering bug
+    that reads insertion order would otherwise pass.
+  */
+  it('answers the highest released version when a type has several', async () => {
+    const repo = dataSource!.getRepository(Figure)
+    const historyRepo = dataSource!.getRepository(FigureHistory)
+
+    const figure = await repo.save({
+      domain: testDomain,
+      type: 'MULTI',
+      name: 'in authoring',
+      state: 'draft',
+      source: boxNamed('MULTI', 'unreleased-draft'),
+      version: 3
+    })
+
+    for (const version of [1, 3, 2]) {
+      await historyRepo.save({
+        domain: testDomain,
+        originalId: figure.id,
+        type: 'MULTI',
+        name: `v${version}`,
+        state: 'released',
+        version,
+        source: boxNamed('MULTI', `v${version}`)
+      })
+    }
+
+    const result = await new FigureQuery().figureBlueprint('MULTI', makeContext())
+
+    expect(result).not.toBeNull()
+    expect(result.groups[0].members[0].name).toBe('v3')
+  })
+
+  /*
+    Every edit to a released figure writes a history row, and those rows are not all releases. A
+    draft row sitting at a higher version than the last release is the ordinary state of a figure
+    being worked on, so reading the newest row rather than the newest RELEASED row would hand
+    consumers unreleased work — the leak the whole door exists to stop.
+  */
+  it('skips a draft history that sits above the last release', async () => {
+    const repo = dataSource!.getRepository(Figure)
+    const historyRepo = dataSource!.getRepository(FigureHistory)
+
+    const figure = await repo.save({
+      domain: testDomain,
+      type: 'WIP',
+      name: 'in authoring',
+      state: 'draft',
+      source: boxNamed('WIP', 'unreleased-draft'),
+      version: 5
+    })
+
+    await historyRepo.save({
+      domain: testDomain,
+      originalId: figure.id,
+      type: 'WIP',
+      name: 'v2',
+      state: 'released',
+      version: 2,
+      source: boxNamed('WIP', 'released-v2')
+    })
+    await historyRepo.save({
+      domain: testDomain,
+      originalId: figure.id,
+      type: 'WIP',
+      name: 'v5',
+      state: 'draft',
+      version: 5,
+      source: boxNamed('WIP', 'draft-v5')
+    })
+
+    const result = await new FigureQuery().figureBlueprint('WIP', makeContext())
+
+    expect(result).not.toBeNull()
+    expect(result.groups[0].members[0].name).toBe('released-v2')
+  })
+
+  /*
+    History rows are looked up by originalId, which is a figure id and so already unique. That makes
+    the domain in the same where-clause look redundant, and redundant-looking filters get deleted.
+    It is not redundant: it is the tenant boundary on a door that consumers call, so a test holds it.
+  */
+  it('does not reach a history row that belongs to another domain', async () => {
+    const domainRepo = dataSource!.getRepository(shell.Domain)
+    const other = await domainRepo.save({ name: 'other-domain', subdomain: 'other-domain' })
+
+    const repo = dataSource!.getRepository(Figure)
+    const historyRepo = dataSource!.getRepository(FigureHistory)
+
+    const figure = await repo.save({
+      domain: testDomain,
+      type: 'LEAKY',
+      name: 'never released here',
+      state: 'draft',
+      source: boxNamed('LEAKY', 'unreleased-draft'),
+      version: 0
+    })
+
+    await historyRepo.save({
+      domain: other,
+      originalId: figure.id,
+      type: 'LEAKY',
+      name: 'released elsewhere',
+      state: 'released',
+      version: 1,
+      source: boxNamed('LEAKY', 'other-domain-release')
+    })
+
+    const result = await new FigureQuery().figureBlueprint('LEAKY', makeContext())
+
+    expect(result).toBeNull()
+  })
+
+  /*
+    This used to answer null, and that was the defect. Null says one thing on this door — nobody
+    published this type — and the board reads it that way: it draws the stand-in of ADR-0063 결정 1 and
+    the scene opens. A released figure whose stored source no longer compiles is a different fact. The
+    author published it, the catalogue says released, and with null the only trace was a console line
+    on the server, so the author saw "my figure does not show on the board" and nothing more. That is
+    the silence ADR-0053 refuses (chief architect, ADR-0063 결정 2 보탬).
+
+    So it refuses with a name, and the name carries what someone needs to find the figure: the type,
+    its id, and the edition that does not compile. The sentence is built where the request's language
+    is known, which is why the gate throws no sentence of its own (ADR-0054).
+  */
+  it('refuses with a named refusal when the stored source cannot be compiled', async () => {
+    const repo = dataSource!.getRepository(Figure)
+    const saved = await repo.save({
+      domain: testDomain,
+      type: 'BROKEN',
+      name: 'corrupted',
+      state: 'released',
+      source: '{ this is not json',
+      version: 4
+    })
+
+    const query = new FigureQuery()
+    const spy = jest.spyOn(console, 'error').mockImplementation(() => {})
+    try {
+      await expect(query.figureBlueprint('BROKEN', makeContext())).rejects.toMatchObject({
+        name: 'Refusal',
+        code: 'figure-release-does-not-compile',
+        params: { type: 'BROKEN', figureId: saved.id, version: 4 }
+      })
+    } finally {
+      spy.mockRestore()
+    }
+  })
+
+  /*
+    The edition named in that refusal is the one the board was handed, which is not the row's own
+    version once the author starts editing again: the row moves on to the next draft while the board
+    keeps drawing the last release. Naming the draft would send someone to look at a source that is
+    not the one failing.
+  */
+  it('the refusal names the released edition, not the draft being edited', async () => {
+    const repo = dataSource!.getRepository(Figure)
+    const historyRepo = dataSource!.getRepository(FigureHistory)
+
+    const figure = await repo.save({
+      domain: testDomain,
+      type: 'BROKEN_HISTORY',
+      name: 'in authoring again',
+      state: 'draft',
+      source: boxNamed('BROKEN_HISTORY', 'healthy-draft'),
+      version: 9
+    })
+    await historyRepo.save({
+      domain: testDomain,
+      originalId: figure.id,
+      type: 'BROKEN_HISTORY',
+      name: 'v2',
+      state: 'released',
+      version: 2,
+      source: '{ this is not json'
+    })
+
+    const spy = jest.spyOn(console, 'error').mockImplementation(() => {})
+    try {
+      await expect(new FigureQuery().figureBlueprint('BROKEN_HISTORY', makeContext())).rejects.toMatchObject({
+        code: 'figure-release-does-not-compile',
+        params: { version: 2 }
+      })
+    } finally {
+      spy.mockRestore()
+    }
+  })
+
+  /*
+    A refusal only becomes a sentence in the caller's language by passing through `SpeakRefusals`,
+    which the class declares and which a direct call like the ones above never runs. Without that
+    declaration this refusal reaches the board as Apollo's INTERNAL_SERVER_ERROR carrying the English
+    fallback, and `extensions.refusal` — the thing that tells a client the server refused on purpose —
+    is absent. The tests above stay green either way, so the declaration is read from the source.
+  */
+  it('declares SpeakRefusals on the class, or the refusal arrives as a server error', () => {
+    const { readFileSync } = require('fs')
+    const { join } = require('path')
+    const source = readFileSync(join(__dirname, 'figure-query.ts'), 'utf-8')
+
+    const at = source.indexOf('export class FigureQuery')
+    expect(at).toBeGreaterThan(-1)
+    expect(source.slice(0, at)).toContain('@UseMiddleware(SpeakRefusals)')
+  })
+
   describe('a child domain shadows its parent only with a released version', () => {
     const boxOf = (type: string, part: string) =>
       JSON.stringify({ ...JSON.parse(sampleSource), type, parts: [{ ...JSON.parse(sampleSource).parts[0], name: part }] })
 
+    let childSeq = 0
+
     async function childOf(parent: any) {
       const repo = dataSource!.getRepository(shell.Domain)
-      const saved = await repo.save({ name: 'child-domain', subdomain: 'child-domain', parent })
+      /* A chain needs a distinct subdomain per level; the column is unique. */
+      const name = `child-domain-${++childSeq}`
+      const saved = await repo.save({ name, subdomain: name, parent })
       return repo.findOne({ where: { id: saved.id } })
     }
 
@@ -213,6 +433,54 @@ describe('figureBlueprint 질의 — 소비처(board, twin, things-scene)를 위
 
       expect(result.groups[0].members[0].name).toBe('tenant')
     })
+
+    /*
+      The two cases above give the child a row whose own state decides the answer. This is the case
+      between them: the child released once and is editing again, so its row says draft while a
+      release of its own exists. The fallback must not read "the child row is a draft" as "the child
+      has nothing" — a tenant that starts a second edit would then see the standard figure come back
+      in place of the one it published.
+    */
+    it('uses the child own release when the child row is a draft again', async () => {
+      const child = await childOf(testDomain)
+
+      const repo = dataSource!.getRepository(Figure)
+      const historyRepo = dataSource!.getRepository(FigureHistory)
+
+      await repo.save({ domain: testDomain, type: 'CONVEYOR', name: '표준', state: 'released', source: boxOf('CONVEYOR', 'standard'), version: 1 })
+      const tenant = await repo.save({ domain: child, type: 'CONVEYOR', name: '테넌트', state: 'draft', source: boxOf('CONVEYOR', 'tenant-wip'), version: 1 })
+      await historyRepo.save({
+        domain: child,
+        originalId: tenant.id,
+        type: 'CONVEYOR',
+        name: '테넌트 v1',
+        state: 'released',
+        version: 1,
+        source: boxOf('CONVEYOR', 'tenant-v1')
+      })
+
+      const result = await new FigureQuery().figureBlueprint('CONVEYOR', contextIn(child))
+
+      expect(result).not.toBeNull()
+      expect(result.groups[0].members[0].name).toBe('tenant-v1')
+    })
+
+    /*
+      The lookup consults the caller's domain and its parent, and stops there. A grandchild therefore
+      does not inherit, which is the current rule rather than an oversight — pinning it here means
+      the day someone needs deeper inheritance they change this test on purpose and take the ruling
+      with them, instead of finding the depth by accident in a scene that renders nothing.
+    */
+    it('does not climb past the immediate parent', async () => {
+      const mid = await childOf(testDomain)
+      const leaf = await childOf(mid)
+      expect(leaf.parentId).toBe(mid.id)
+
+      const repo = dataSource!.getRepository(Figure)
+      await repo.save({ domain: testDomain, type: 'CONVEYOR', name: '표준', state: 'released', source: boxOf('CONVEYOR', 'standard'), version: 1 })
+
+      expect(await new FigureQuery().figureBlueprint('CONVEYOR', contextIn(leaf))).toBeNull()
+    })
   })
 
   /*

package/server/service/figure/figure-e2e-smoke.test.ts

@@ -62,7 +62,7 @@ describeIf('AI 로 만든 figure 가 발행까지 가나', () => {
   test('움직이는 것을 만든다 — 문', async () => {
     const { made, gate } = await walk(
       '자동문',
-      'a двух-panel automatic door in a frame. add an animation clip that opens both panels together by sliding them apart.',
+      'a two-panel automatic door in a frame. add an animation clip that opens both panels together by sliding them apart.',
       'AUTO_DOOR_E2E'
     )
     expect(gate.blocked).toBe(false)

package/server/service/figure/figure-query.ts

@@ -1,9 +1,16 @@
 import { In } from 'typeorm'
-import { Args, Arg, Ctx, Directive, Query, Resolver } from 'type-graphql'
+import { Args, Arg, Ctx, Directive, Query, Resolver, UseMiddleware } from 'type-graphql'
 import { GraphQLJSON } from 'graphql-scalars'
 import { compile } from '@hatiolab/figure-model'
 
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+import {
+  Domain,
+  getQueryBuilderFromListParams,
+  getRepository,
+  ListParam,
+  Refusal,
+  SpeakRefusals
+} from '@things-factory/shell'
 
 import { Figure } from './figure.js'
 import { FigureHistory } from './figure-history.js'
@@ -11,6 +18,7 @@ import { inspectSource } from './figure-gate.js'
 import { FigureInspection, FigureList } from './figure-type.js'
 
 @Resolver(Figure)
+@UseMiddleware(SpeakRefusals)
 export class FigureQuery {
   @Directive('@privilege(category: "figure", privilege: "query", domainOwnerGranted: true)')
   @Query(returns => Figure, { nullable: true, description: 'Finds a single figure by its ID.' })
@@ -194,14 +202,28 @@ export class FigureQuery {
       return null
     }
 
-    const { figure, source: sourceToCompile } = found
+    const { figure, source: sourceToCompile, version } = found
 
     try {
       const parsed = typeof sourceToCompile === 'string' ? JSON.parse(sourceToCompile) : sourceToCompile
       return compile(parsed)
     } catch (err) {
       console.error(`[figureBlueprint] 타입 '${type}' (figure id: ${figure.id}) 청사진 컴파일 실패:`, err)
-      return null
+
+      /*
+        Null says one thing here: nobody published this type (ADR-0063 결정 2 보탬). A released figure
+        whose stored source no longer compiles is a different fact, and answering null for it makes the
+        board draw a stand-in with the reason nowhere on screen — the author published, the catalogue
+        says released, and the only trace is the line above. That is the silence ADR-0053 refuses.
+
+        The board asks per type inside a Promise.all and collects a rejection into `failed`, so this
+        refusal costs that one figure its drawing and the scene still opens.
+      */
+      throw new Refusal(
+        'figure-release-does-not-compile',
+        { type, figureId: figure.id, version },
+        'the released source of {type} does not compile. open it in the modeller and release it again.'
+      )
     }
   }
 }
@@ -212,12 +234,15 @@ export class FigureQuery {
  * A released row gives its own source; a draft row gives the source of its latest released history.
  * A figure that was never released gives null, because drafts never reach consumers.
  */
-async function releasedSourceOf(domainId: string, type: string): Promise<{ figure: Figure; source: string } | null> {
+async function releasedSourceOf(
+  domainId: string,
+  type: string
+): Promise<{ figure: Figure; source: string; version: number } | null> {
   const figure = await getRepository(Figure).findOne({ where: { domain: { id: domainId }, type } })
   if (!figure) return null
 
   if (figure.state === 'released' && figure.source) {
-    return { figure, source: figure.source }
+    return { figure, source: figure.source, version: figure.version }
   }
 
   const latestReleased = await getRepository(FigureHistory).findOne({
@@ -225,5 +250,9 @@ async function releasedSourceOf(domainId: string, type: string): Promise<{ figur
     order: { version: 'DESC' }
   })
 
-  return latestReleased?.source ? { figure, source: latestReleased.source } : null
+  /* The version travels with the source: a refusal names the edition that does not compile, and the
+     row's own version is the draft being edited, not the one the board was handed. */
+  return latestReleased?.source
+    ? { figure, source: latestReleased.source, version: latestReleased.version }
+    : null
 }

package/server/service/figure/figure-tool-doors.test.ts

@@ -1,9 +1,9 @@
 /*
- * figure 도구가 지나는 문 — ADR-0072 결정 2.
+ * figure 도구가 지나는 문 — ADR-0072 결정 2, ADR-0071 결정 2 보탬(2026-09-18).
  *
- * 선언만 해 두고 아무도 읽지 않으면 그 선언은 다음 사람이 지우거나 바꿔도 아무 일이 없다. 여기서는
- * 실제로 등록된 명세를 등록기에 넣고, 등록기가 무엇도 문제 삼지 않는지 묻는다. 도구 목록이 늘면
- * 이 시험이 먼저 문다.
+ * 선언만 해 두고 아무도 읽지 않으면 그 선언은 다음 사람이 지우거나 바꿔도 아무 일이 없다. 이제는
+ * 읽는 쪽이 생겼다 — 관문이 이 목록으로 도구를 내보낼지 정한다. 그래서 여기서 묻는 것이 둘이다:
+ * 도구가 문을 적었는가, 그리고 **그 문이 무엇인가를 지키는가.**
  */
 import { readdirSync, readFileSync } from 'fs'
 import { join } from 'path'
@@ -27,31 +27,23 @@ describe('figure tools — declared doors', () => {
     expect(undeclared).toEqual([])
   })
 
-  it('★ a door a tool reaches comes with the privilege that guards it', () => {
-    const unguarded = getAllToolSpecs()
-      .filter(spec => ((spec as any).doors ?? []).length > 0 && !(spec as any).privilege)
-      .map(spec => spec.name)
-
-    expect(unguarded).toEqual([])
-  })
-
   it('the registry itself finds nothing to report about these specs', () => {
     expect(getToolRegistryWarnings().map(w => `${w.code}:${w.params.tool ?? ''}`)).toEqual([])
   })
 })
 
 /*
- * 베낀 권한이 문의 지시자와 같은가 — ADR-0072 결정 5 (b).
+ * 도구가 가리키는 문이 무엇인가를 지키는가 — 관문이 딛고 선 사실.
  *
- * 권한은 문의 지시자에서 나와야 하는데(ADR-0071 결정 2) 지금은 읽을 자리가 없다: 지시자가 남기는
- * 것은 (category, privilege) 쌍 목록뿐이고 필드별 지도가 없다. 그래서 도구 명세가 권한을 베껴
- * 적는다. 베낀 값은 **문이 바뀌어도 안 따라간다** — 문에 권한을 붙이거나 떼거나 이름을 고치면
- * 도구 명세만 옛 값을 들고 남고, 그때 게이트는 문이 안 묻는 것을 묻거나 문이 묻는 것을 안 묻는다.
+ * 2026-09-18 까지 도구 명세가 권한을 베껴 적었고 이 자리가 그 사본을 문과 견줬다. 사본은 없어졌다
+ * (ADR-0071 결정 2 보탬) — 관문이 AUTH 의 필드 표에서 문의 선언을 직접 읽는다. 그래서 견줄 두 값도
+ * 없다.
  *
- * 여기서는 리졸버 원문의 지시자를 읽어 도구가 적은 것과 견준다. AUTH 에 청한 필드별 지도가 서면
- * 이 시험과 베끼기가 함께 없어진다.
+ * 대신 관문이 **딛고 선 사실**이 남았다: 이 네 도구가 가리키는 문에 지시자가 붙어 있다는 것. 누가
+ * `Query.figures` 에서 `@privilege` 를 떼면 그 문은 테넌트 안에서 열리고, 도구도 같이 열린다 —
+ * 그 자리가 이제 아무 데서도 안 드러난다. 여기서 문다.
  */
-describe('figure tools — the copied privilege matches the door', () => {
+describe('figure tools — the doors they reach are guarded', () => {
   beforeEach(() => {
     clearToolRegistry()
     registerFigureToolCategories()
@@ -112,26 +104,18 @@ describe('figure tools — the copied privilege matches the door', () => {
     return found
   }
 
-  it('★ 도구가 적은 권한이 그 문의 지시자와 한 글자도 다르지 않다', () => {
+  it('★ 도구가 가리키는 문마다 그 문을 지키는 지시자가 있다', () => {
     const doors = doorPrivileges()
 
-    const mismatched = getAllToolSpecs().flatMap(spec =>
-      ((spec as any).doors ?? []).map((door: string) => {
-        const declared = doors.get(door)
-        const copied = (spec as any).privilege
-        if (!declared) return `${spec.name} → ${door}: 그런 문이 없거나 그 문이 권한을 선언하지 않는다`
-        if (
-          declared.category !== copied?.category ||
-          declared.privilege !== copied?.privilege ||
-          declared.owner !== (copied?.owner ?? false)
-        ) {
-          return `${spec.name} → ${door}: 문은 ${JSON.stringify(declared)} 인데 도구는 ${JSON.stringify(copied)}`
-        }
-        return undefined
-      })
-    ).filter(Boolean)
+    const unguarded = getAllToolSpecs()
+      .flatMap(spec =>
+        ((spec as any).doors ?? []).map((door: string) =>
+          doors.has(door) ? undefined : `${spec.name} → ${door}: 그런 문이 없거나 그 문이 권한을 선언하지 않는다`
+        )
+      )
+      .filter(Boolean)
 
-    expect(mismatched).toEqual([])
+    expect(unguarded).toEqual([])
   })
 
   it('견줄 문을 실제로 찾아 읽었다 — 0 건이면 위 시험은 언제나 초록이다', () => {

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

@@ -129,6 +129,72 @@ test('실제 registryAssistantChat 경계가 열린 모델 문맥을 Figure 도
   expect(JSON.stringify(seen[1])).not.toContain('FIGURE_TARGET_REQUIRED')
 })
 
+/*
+  등록된 범주에 도구 넷이 있다는 것과, 넷이 **모델에게 건네졌다**는 것은 다른 사실이다. 그 사이에
+  관문이 하나 있다 — `resolveToolScope` 가 도구마다 `doors` 를 부르는 사람의 권한에 물어 통과한 것만
+  싣는다(ADR-0071 결정 2). 그래서 등록은 넷인데 대화에 실리는 것은 셋일 수 있고, 그때 화면은 아무
+  오류도 내지 않는다 — 모델이 그 도구를 안 부르니 「후보를 만들었습니다」로 끝난다.
+
+  위의 배선 시험은 도구 하나(`getFigureSource`)가 오간 것으로 그 줄을 확인한다. 나머지 셋이 실렸는지는
+  보지 않는다. 그래서 건네진 목록 자체를 여기서 읽는다.
+*/
+describe('모델에게 건네지는 목록', () => {
+  /** `chatWithTools(messages, toolDefs, options)` 의 둘째 인자를 그대로 잡는다. */
+  async function offeredWith(access: (door: string) => Promise<boolean>) {
+    const offered: string[][] = []
+
+    await registryAssistantChat({
+      client: {
+        chatWithTools: async (_messages: any[], toolDefs: any[]) => {
+          offered.push((toolDefs ?? []).map(one => one.name ?? one.function?.name))
+          return { text: '네.', toolCalls: [], stopReason: 'end_turn' }
+        }
+      } as any,
+      messages: [{ role: 'user', content: '무엇을 할 수 있나' }],
+      systemPrompt: 'Author figures.',
+      toolCategories: ['figure-authoring'],
+      state: { domain: MINE },
+      hostContext: { figureId: 'fig-1', draftSource: SOURCE },
+      toolAccess: access
+    } as any)
+
+    expect(offered).toHaveLength(1)
+    return offered[0]!.sort()
+  }
+
+  it('★ 도구 넷이 다 건네진다 — 문을 다 가진 사람에게', async () => {
+    expect(await offeredWith(async () => true)).toEqual([
+      'getFigureSource',
+      'inspectFigure',
+      'listFigures',
+      'proposeFigureCandidate'
+    ])
+  })
+
+  /*
+    넷이 문 넷을 하나씩 나눠 가지므로, 문 하나를 닫으면 도구 하나만 빠져야 한다. 이 갈래가 없으면
+    위 시험은 「관문이 아무것도 안 걸러도」 초록이다.
+
+    후보를 내는 도구를 닫힌 쪽으로 골랐다. 읽기 권한만 가진 사람이 저작 대화를 열면 목록과 정본과
+    검사는 되고 후보 생성은 안 되는 것이 그 사람에게 맞는 모양이다.
+  */
+  it('★ 문이 닫힌 도구 하나만 빠진다 — 나머지 셋은 그대로다', async () => {
+    const offered = await offeredWith(async door => door !== 'Mutation.proposeFigure')
+
+    expect(offered).toEqual(['getFigureSource', 'inspectFigure', 'listFigures'])
+  })
+
+  /*
+    권한을 물어볼 길이 없으면 문에 닿는 도구는 전부 닫힌다(`resolveToolScope`: `if (!access) return false`).
+    figure 의 넷은 전부 문에 닿으므로 하나도 남지 않는다 — 부분만 열리는 일이 없다는 뜻이다.
+  */
+  it('물어볼 길이 없으면 하나도 건네지지 않는다', async () => {
+    const offered = await offeredWith(undefined as any)
+
+    expect(offered).toEqual([])
+  })
+})
+
 describe('범주가 등록된다', () => {
   it('figure-authoring 이 도구 넷과 함께 올라온다', () => {
     const category = getToolCategories().find((one: any) => one.name === 'figure-authoring')!

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

@@ -18,6 +18,12 @@
  * `ai-assistant:mutation` 이 지킨다 — 서로 다른 질문이라 서로 다른 권한이 지킨다. figure 가 board
  * 의 권한을 빌리지 않는다.
  *
+ * ── 권한은 적지 않는다. 문에 적힌 것을 관문이 읽는다 ────────────────────────
+ * 2026-09-18 까지 도구마다 `privilege: { category: 'figure', ... }` 를 적어 두었다. 문의 지시자와
+ * 같은 값이라 그때는 맞았고, 문이 선언을 바꾸는 날 어긋난다 — 어긋나면 느슨한 쪽이 이긴다. 이제
+ * 관문이 `doors` 에 적힌 문의 선언을 AUTH 의 표에서 읽어 묻는다(ADR-0071 결정 2 보탬). 여기 남길
+ * 것은 **닿는 문**뿐이다.
+ *
  * ── 규율을 도구와 함께 보낸다 ───────────────────────────────────────────────
  * 도구 목록만으로는 「언제 반드시 불러야 하는지」를 모른다. twin 이 그 공백에서 사고를 냈다 —
  * 조치 요청에 도구를 부르지 않고 「제안해 두었습니다」라고만 답해, 사용자에게 **없는 버튼을 누르라고
@@ -249,7 +255,6 @@ function figureToolSpecs(): ToolSpec[] {
       name: 'listFigures',
       /* 이 도메인의 도형 목록 — 저장소를 직접 읽지만 같은 일을 하는 문은 이것이다. */
       doors: ['Query.figures'],
-      privilege: { category: 'figure', privilege: 'query', owner: true },
       description:
         'Lists the figures in this tenant with their type names, states and part counts. ' +
         'Call it before naming a type — type names are stored identifiers and must not be invented.',
@@ -280,7 +285,6 @@ function figureToolSpecs(): ToolSpec[] {
       /* 저장된 도형의 원본. **저장 전 초안**을 물으면 저장소에 갈 것이 없어 화면이 보낸 것을 그대로 돌려준다 —
        * 그 갈래에는 닿는 문이 없지만 `doors: []` 로 적지 않는다. 그러면 저장된 도형을 읽는 권한 검사가 선언에서 사라진다. */
       doors: ['Query.figure'],
-      privilege: { category: 'figure', privilege: 'query', owner: true },
       description:
         'Returns the canonical FigureSource of one figure, with its measured cost ' +
         '(triangles, part groups, and how many of it hold 60fps on one screen). Call it before proposing a revision — ' +
@@ -318,7 +322,6 @@ function figureToolSpecs(): ToolSpec[] {
       name: 'inspectFigure',
       /* 검사 결과 — 같은 일을 하는 문. */
       doors: ['Query.inspectFigure'],
-      privilege: { category: 'figure', privilege: 'query', owner: true },
       description:
         'Says whether a figure may be released and, when it may not, what is wrong — each finding ' +
         'carries why it is a problem and what to change. Call it when asked about releasing, or ' +
@@ -340,7 +343,6 @@ function figureToolSpecs(): ToolSpec[] {
       name: 'proposeFigureCandidate',
       /* 후보 생성 — 저장은 하지 않지만 같은 문의 권한을 쓴다. */
       doors: ['Mutation.proposeFigure'],
-      privilege: { category: 'figure', privilege: 'mutation', owner: true },
       description:
         'Asks for a figure candidate from a description, optionally revising an existing one. ' +
         'Returns the candidate with its score and cost. NOTHING IS SAVED — the author accepts or ' +

package/translations/en.json

@@ -0,0 +1,3 @@
+{
+  "error.figure-release-does-not-compile": "the released source of {type} (version {version}) does not compile. open it in the modeller, fix it and release it again before it draws on a board."
+}

package/translations/ko.json

@@ -0,0 +1,3 @@
+{
+  "error.figure-release-does-not-compile": "{type} 의 발행판({version})이 지금 컴파일되지 않습니다. 저작 화면에서 열어 고친 뒤 다시 발행해야 보드에 나옵니다."
+}