@things-factory/figure-service 10.1.245 → 10.1.246

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-service",
-  "version": "10.1.245",
+  "version": "10.1.246",
   "publishConfig": {
     "access": "public",
     "@things-factory:registry": "https://registry.npmjs.org"
@@ -25,18 +25,18 @@
     "test:templates": "node --test scripts/templates.test.mts"
   },
   "dependencies": {
-    "@hatiolab/figure-model": "^0.12.1",
+    "@hatiolab/figure-model": "^0.12.2",
     "@operato/typeorm-history": "^10.0.0",
-    "@things-factory/ai-client-base": "^10.1.245",
-    "@things-factory/attachment-base": "^10.1.245",
-    "@things-factory/auth-base": "^10.1.245",
+    "@things-factory/ai-client-base": "^10.1.246",
+    "@things-factory/attachment-base": "^10.1.246",
+    "@things-factory/auth-base": "^10.1.246",
     "@things-factory/env": "^10.1.149",
-    "@things-factory/setting-base": "^10.1.245",
-    "@things-factory/shell": "^10.1.245",
+    "@things-factory/setting-base": "^10.1.246",
+    "@things-factory/shell": "^10.1.246",
     "graphql-scalars": "^1.22.4",
     "graphql-upload": "^15.0.2",
     "jszip": "^3.10.1",
     "koa-router": "^7.4.0"
   },
-  "gitHead": "f7479631094a1c70b486485b556885b069025f88"
+  "gitHead": "46c0d3c93edf765cc1f13040b1f9d03fd1d9e60b"
 }

package/scripts/figure-ai-scenarios-agent.cjs

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+/**
+ * AI 모델링 시나리오를 도메인의 AI 에이전트로 돌린다 (2026-11-03, 사용자 「에이전트 키로」).
+ *
+ * 앱 폴더에서 실행한다. 그 앱의 설정(데이터 암호 키·DB)을 읽고, 그 DB 의 도메인에 설정된 AI 에이전트를 사람이 쓰는 것과
+ * 같은 문(`aiClientFor`)으로 받아, figure-ai-scenarios.ts 의 요청마다 피규어를 만들거나 고치게 한다. 키는 셸에도 저장소에도
+ * 두지 않고, 사용량은 그 도메인의 AI 사용 기록에 남는다.
+ *
+ *   cd <앱 폴더, 예 operato-application/packages/operato-office>
+ *   NODE_ENV=development node <things-factory>/packages/figure-service/scripts/figure-ai-scenarios-agent.cjs --domain hatiolab
+ *
+ * 선택: --agent <에이전트 id> (없으면 도메인 기본) · --scenarios pipeline-run,hopper · --repeat 3 · --reports <폴더>
+ *
+ * DB 는 그대로 쓴다: 표를 만들거나 고치지 않는다(synchronize·migration 을 끈다). sqlite 가 아닌 DB 는 --allow-database 를
+ * 줄 때만 붙는다 -- 개발 설정이 운영 DB 로 가는 앱(:3300 의 figure)이 있기 때문이다. 운영 모드(NODE_ENV=production)는 받지
+ * 않는다. 먼저 figure-service 를 빌드한다: yarn workspace @things-factory/figure-service build:server
+ */
+'use strict'
+
+const path = require('path')
+const { createRequire } = require('module')
+
+/* things-factory's own packages, whatever the app folder has installed: the entities and the door are the ones built here. */
+const here = createRequire(path.join(__dirname, '..', 'package.json'))
+
+function argsOf(argv) {
+  const out = { scenarios: [], repeat: 1 }
+  for (let i = 0; i < argv.length; i++) {
+    const [key, next] = [argv[i], argv[i + 1]]
+    if (key === '--domain') (out.domain = next), i++
+    else if (key === '--agent') (out.agent = next), i++
+    else if (key === '--scenarios') (out.scenarios = next.split(',').map(s => s.trim()).filter(Boolean)), i++
+    else if (key === '--repeat') (out.repeat = Math.max(1, Number(next) || 1)), i++
+    else if (key === '--reports') (out.reports = path.resolve(next)), i++
+    else if (key === '--allow-database') out.allowDatabase = true
+    else throw new Error(`unknown argument: ${key}`)
+  }
+  if (!out.domain) throw new Error('--domain <subdomain> is required: the domain whose AI agent answers')
+  return out
+}
+
+async function main() {
+  const args = argsOf(process.argv.slice(2))
+  if (process.env.NODE_ENV === 'production') throw new Error('not in production mode: run it against a development database')
+
+  const { config } = here('@things-factory/env')
+  const { DataSource } = here('typeorm')
+  const shell = here('@things-factory/shell')
+  const ai = here('@things-factory/ai-client-base')
+  const entities = [...shell.entities, ...here('@things-factory/auth-base').entities, ...here('@things-factory/setting-base').entities, ...ai.entities]
+
+  /* The app's database as its configuration names it; the package default is sqlite db.sqlite in the app folder. */
+  const configured = config.get('ormconfig', {}) || {}
+  const database = { type: 'sqlite', database: 'db.sqlite', ...configured }
+  if (database.type !== 'sqlite' && !args.allowDatabase)
+    throw new Error(`the app's database is ${database.type}${database.host ? ` at ${database.host}:${database.port}` : ''}: pass --allow-database to use it`)
+  const source = new DataSource({
+    ...database,
+    ...(database.type === 'sqlite' ? { database: path.resolve(database.database) } : {}),
+    entities,
+    migrations: [],
+    subscribers: [],
+    synchronize: false,
+    migrationsRun: false,
+    logging: false,
+    namingStrategy: new (here('@things-factory/shell/dist-server/initializers/naming-strategy.js').NamingStrategy)()
+  })
+  await source.initialize()
+  shell.addDataSource('default', source)
+  try {
+    const domain = await source.getRepository(shell.Domain).findOne({ where: { subdomain: args.domain } })
+    if (!domain) throw new Error(`no domain ${args.domain} in ${database.database ?? database.host}`)
+    const client = await ai.aiClientFor({ domain, agentId: args.agent ?? null })
+
+    const run = here('./dist-server/service/figure/figure-ai-scenarios-run.js')
+    const scenarios = run.scenariosNamed(args.scenarios)
+    const runs = []
+    for (const scenario of scenarios)
+      for (let round = 1; round <= args.repeat; round++) {
+        const one = await run.runFigureAIScenario(client, scenario, round)
+        runs.push(one)
+        console.log(`${one.passed ? '✔' : '✖'} ${scenario.id}${args.repeat > 1 ? ` #${round}` : ''} (${one.seconds.toFixed(1)}s)${one.passed ? '' : ` — ${one.misses.slice(0, 2).join('; ')}`}`)
+      }
+    const folder = args.reports ?? path.join(__dirname, '..', 'logs', 'figure-ai-scenarios')
+    const { lines, report } = run.writeFigureAIScenarioReport(folder, { by: `agent:${args.domain}/${client.agent.name}`, model: `${client.agent.provider}-${client.agent.model}` }, scenarios, runs, args.repeat)
+    console.log(lines.join('\n'))
+    process.exitCode = report.passed === report.total ? 0 : 1
+  } finally {
+    /* The last calls' usage rows are written after their answers: closed before them, they would be lost. */
+    await ai.aiUsageRecorded()
+    await source.destroy()
+  }
+}
+
+main().catch(e => {
+  console.error(e instanceof Error ? e.message : String(e))
+  process.exit(2)
+})

package/server/routers/figure-thumbnail-router.ts

@@ -9,7 +9,8 @@ import { readFileSync } from 'fs'
 import { Figure } from '../service/figure/figure.js'
 import { thumbnailAttachmentOf, thumbnailFiles, type ThumbnailFiles } from '../service/figure/figure-thumbnail-store.js'
 import { recipeTemplates } from '../service/figure-recipe/figure-recipe-templates.js'
-import { readableFigure } from '../service/figure/figure-public.js'
+import { foreignPublic, readableFigure } from '../service/figure/figure-public.js'
+import { FigureHistory } from '../service/figure/figure-history.js'
 
 /**
  * 썸네일을 **그림으로** 내보내는 길.
@@ -66,6 +67,16 @@ figureThumbnailRouter.get('/figure-thumbnail/:id', async (context, next) => {
   await sendFigureThumbnail(context, next, context.params.id, domain)
 })
 
+/** A public figure's picture as its latest release keeps it, on the figure's domain. */
+async function releasedPictureOf(row: Figure): Promise<Pick<Figure, 'thumbnailHash' | 'thumbnailUpdatedAt' | 'domain'> | null> {
+  const release = await getRepository(FigureHistory).findOne({
+    where: { originalId: row.id },
+    order: { version: 'DESC' },
+    select: { id: true, thumbnailHash: true, updatedAt: true }
+  })
+  return release && { thumbnailHash: release.thumbnailHash, thumbnailUpdatedAt: release.updatedAt, domain: row.domain }
+}
+
 /**
  * The picture of a figure the caller may read, by its hash (ADR-0104 decision 6). Exported for tests, which give
  * their own `files`.
@@ -82,7 +93,12 @@ export async function sendFigureThumbnail(
     그림만 404 를 내면, 화면은 「그림이 아직 없다」고 거짓말하게 된다.
   */
   /* Another domain's public figure is read too (G2): its card is what a reader chooses it by. */
-  const found = await readableFigure(domain, id, { id: true, thumbnailHash: true, thumbnailUpdatedAt: true, public: true, domain: { id: true } })
+  const row = await readableFigure(domain, id, { id: true, thumbnailHash: true, thumbnailUpdatedAt: true, public: true, domain: { id: true } })
+  /*
+    Another domain is shown the picture of the latest release, as its list is (2026-11-03 audit 1): the row's picture
+    may be of a draft not released.
+  */
+  const found = row && foreignPublic(domain, row) ? await releasedPictureOf(row) : row
   if (!found?.thumbnailHash) {
     context.status = 404
     return

package/server/service/figure/figure-ai-scenarios-run.ts

@@ -0,0 +1,127 @@
+/**
+ * AI 모델링 시나리오를 실제 모델로 돌리고 보고서를 남긴다 — figure-ai-scenarios.ts 의 요청마다 피규어를 만들거나 고치게
+ * 하고, 결과를 시나리오의 판정으로 잰다.
+ *
+ * 모델은 부르는 쪽이 준다: 도메인의 AI 에이전트(`aiClientFor`, scripts/figure-ai-scenarios-agent.cjs) -- 사람이 쓰는
+ * 것과 같은 모델·설정·키로, 사용량은 그 도메인에 남는다 -- 또는 공급자 키(figure-ai-scenarios.live.test.ts). 보고서는
+ * 같은 모델의 지난 보고서와 견주어 나빠진 것과 나아진 것을 말하고, 실패한 답을 남겨 비용 없이 다시 볼 수 있게 한다.
+ */
+import { mkdirSync, readdirSync, readFileSync, writeFileSync } from 'fs'
+import { join } from 'path'
+
+import type { AIClient } from '@things-factory/ai-client-base'
+import { createFigureAsset, inspectFigureAsset } from '@hatiolab/figure-model'
+
+import { FIGURE_AI_SCENARIOS, type FigureAIScenario } from './figure-ai-scenarios'
+import { ProposeFigureFailure, proposeFigureSteps } from './figure-propose-steps'
+
+export interface FigureAIScenarioRun {
+  id: string
+  title: string
+  round: number
+  passed: boolean
+  /** What the figure missed, or why none was made. */
+  misses: string[]
+  attempts?: number
+  steps?: number
+  seconds: number
+  /** The steps the model answered -- the last one refused when none was taken -- to look at again without asking it. */
+  answer?: unknown[]
+}
+
+export interface FigureAIScenarioReport {
+  at: string
+  /** Who answered: `agent:<domain>/<name>` or the provider, and its model. */
+  by: string
+  model: string
+  rounds: number
+  passed: number
+  total: number
+  comparedWith?: string
+  worse: string[]
+  better: string[]
+  runs: FigureAIScenarioRun[]
+}
+
+/** The scenarios a run asks: all, or those named. */
+export const scenariosNamed = (names: readonly string[]) => (names.length ? FIGURE_AI_SCENARIOS.filter(s => names.includes(s.id)) : FIGURE_AI_SCENARIOS)
+
+/** One scenario asked once: the figure made, judged by its check and the gate; a failure to make one said as it failed. */
+export async function runFigureAIScenario(client: AIClient, scenario: FigureAIScenario, round = 1): Promise<FigureAIScenarioRun> {
+  const started = Date.now()
+  const base = scenario.base?.()
+  const at = { id: scenario.id, title: scenario.title, round }
+  try {
+    const made = await proposeFigureSteps({ client, prompt: scenario.prompt, ...(base ? { base } : { name: scenario.name ?? 'Figure' }) })
+    const gate = inspectFigureAsset(made.source).violations.map(v => `gate: ${(v as { code?: string }).code ?? JSON.stringify(v)}`)
+    const misses = [...gate, ...scenario.check(made.source, base ?? createFigureAsset(scenario.name ?? 'Figure'))]
+    return { ...at, passed: !misses.length, misses, attempts: made.attempts, steps: made.steps.length, seconds: (Date.now() - started) / 1000, answer: made.steps }
+  } catch (e) {
+    const reasons = e instanceof ProposeFigureFailure ? [e.message, ...e.reasons] : [e instanceof Error ? e.message : String(e)]
+    const refused = e instanceof ProposeFigureFailure ? (e.lastAnswer as { steps?: unknown[] } | undefined)?.steps : undefined
+    return { ...at, passed: false, misses: [`not made: ${reasons.join(' / ')}`], seconds: (Date.now() - started) / 1000, ...(refused ? { answer: refused } : {}) }
+  }
+}
+
+const fileSafe = (text: string) => text.replace(/[^a-zA-Z0-9.-]/g, '_')
+
+/** The last report written by the same answerer and model in `folder`. */
+function lastReport(folder: string, suffix: string): { file: string; runs: FigureAIScenarioRun[] } | undefined {
+  try {
+    const file = readdirSync(folder)
+      .filter(f => f.endsWith(suffix))
+      .sort()
+      .at(-1)
+    return file ? { file, runs: JSON.parse(readFileSync(join(folder, file), 'utf8')).runs } : undefined
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * The report of a run, written to `folder` beside the earlier ones and compared with the last of the same answerer and
+ * model: a scenario that passed less often is worse, more often better. Returns the report and the lines that say it.
+ */
+export function writeFigureAIScenarioReport(
+  folder: string,
+  who: { by: string; model: string },
+  scenarios: readonly FigureAIScenario[],
+  runs: readonly FigureAIScenarioRun[],
+  rounds: number
+): { report: FigureAIScenarioReport; file: string; lines: string[] } {
+  const suffix = `-${fileSafe(who.by)}-${fileSafe(who.model)}.json`
+  const before = lastReport(folder, suffix)
+  const rate = (id: string, list: readonly FigureAIScenarioRun[]) => {
+    const mine = list.filter(r => r.id === id)
+    return mine.length ? mine.filter(r => r.passed).length / mine.length : undefined
+  }
+  const compared = scenarios.map(s => ({ id: s.id, now: rate(s.id, runs), was: before ? rate(s.id, before.runs) : undefined }))
+  const worse = compared.filter(c => c.was !== undefined && c.now !== undefined && c.now < c.was).map(c => c.id)
+  const better = compared.filter(c => c.was !== undefined && c.now !== undefined && c.now > c.was).map(c => c.id)
+  const report: FigureAIScenarioReport = {
+    at: new Date().toISOString(),
+    ...who,
+    rounds,
+    passed: runs.filter(r => r.passed).length,
+    total: runs.length,
+    ...(before ? { comparedWith: before.file } : {}),
+    worse,
+    better,
+    runs: [...runs]
+  }
+  mkdirSync(folder, { recursive: true })
+  const file = join(folder, `${report.at.replace(/[:.]/g, '-')}${suffix}`)
+  writeFileSync(file, JSON.stringify(report, null, 2))
+  const lines = [
+    `AI 모델링 시나리오 ${report.passed}/${report.total} 통과 — ${who.by} ${who.model}${rounds > 1 ? ` × ${rounds}` : ''}`,
+    ...scenarios.map(s => {
+      const mine = runs.filter(r => r.id === s.id)
+      const ok = mine.filter(r => r.passed).length
+      const miss = mine.find(r => !r.passed)?.misses.slice(0, 2).join('; ')
+      return `  ${ok === mine.length ? '✔' : '✖'} ${s.id} ${ok}/${mine.length}${miss ? ` — ${miss}` : ''}`
+    }),
+    ...(before ? [`  지난 보고서 ${before.file} 대비 — 나빠짐: ${worse.join(', ') || '없음'} · 나아짐: ${better.join(', ') || '없음'}`] : []),
+    `  보고서: ${file}`
+  ]
+  return { report, file, lines }
+}

package/server/service/figure/figure-ai-scenarios.live.test.ts

@@ -0,0 +1,59 @@
+/**
+ * AI 모델링 시나리오를 공급자 키로 (기본 비활성). 도메인의 AI 에이전트로 돌리는 것은 scripts/figure-ai-scenarios-agent.cjs 다.
+ *
+ * 실행:
+ *   ANTHROPIC_API_KEY=... yarn test:figure-ai-scenarios
+ * 선택: FIGURE_LLM_PROVIDER=anthropic|gemini|openai · FIGURE_LLM_MODEL=<model id>
+ *       FIGURE_LLM_PROVIDER=reference -- 모델 대신 시나리오의 모범 답을 돌려준다: 키 없이 실행기와 보고서를 점검한다
+ *       FIGURE_AI_SCENARIOS=pipeline-run,hopper (몇 개만) · FIGURE_AI_REPEAT=3 (같은 요청을 여러 번: 흔들림을 본다)
+ * 보고서는 `packages/figure-service/logs/figure-ai-scenarios/` 에 남는다(figure-ai-scenarios-run.ts).
+ */
+import { join } from 'path'
+
+import { createAIClient, type AIClient } from '@things-factory/ai-client-base'
+
+import type { FigureAIScenario } from './figure-ai-scenarios'
+import { runFigureAIScenario, scenariosNamed, writeFigureAIScenarioReport, type FigureAIScenarioRun } from './figure-ai-scenarios-run'
+import { figureLLMProvider } from './figure-llm-provider'
+
+// Provider modules register themselves on import.
+import '@things-factory/ai-client-base'
+
+/* `reference`: each scenario answered by its own reference -- the runner and its report checked without a provider. */
+const dry = process.env.FIGURE_LLM_PROVIDER === 'reference'
+const picked = process.env.RUN_FIGURE_AI_SCENARIOS !== '1' ? undefined : dry ? { provider: 'reference', apiKey: '', model: 'reference' } : figureLLMProvider()
+const describeIf = picked ? describe : describe.skip
+
+const chosen = scenariosNamed((process.env.FIGURE_AI_SCENARIOS ?? '').split(',').map(s => s.trim()).filter(Boolean))
+const rounds = Math.max(1, Number(process.env.FIGURE_AI_REPEAT ?? 1) || 1)
+const REPORTS = join(__dirname, '..', '..', '..', 'logs', 'figure-ai-scenarios')
+
+/** A client that answers the scenario's reference, as a model would answer JSON. */
+const referenceClient = (scenario: FigureAIScenario) => ({ id: 'reference', chat: async () => '', generateJSON: async () => ({ steps: scenario.reference }) }) as unknown as AIClient
+
+describeIf('AI 모델링 시나리오 — 공급자 키', () => {
+  let client: AIClient
+  const runs: FigureAIScenarioRun[] = []
+
+  beforeAll(() => {
+    if (!dry) client = createAIClient(picked as never)
+  })
+
+  afterAll(() => {
+    const { lines } = writeFigureAIScenarioReport(REPORTS, { by: picked!.provider, model: picked!.model ?? 'default' }, chosen, runs, rounds)
+    // eslint-disable-next-line no-console
+    console.log(lines.join('\n'))
+  })
+
+  for (const scenario of chosen)
+    for (let round = 1; round <= rounds; round++)
+      test(
+        `${scenario.id}${rounds > 1 ? ` #${round}` : ''}: ${scenario.title}`,
+        async () => {
+          const run = await runFigureAIScenario(dry ? referenceClient(scenario) : client, scenario, round)
+          runs.push(run)
+          expect(run.misses).toEqual([])
+        },
+        240_000
+      )
+})

package/server/service/figure/figure-ai-scenarios.test.ts

@@ -0,0 +1,77 @@
+/**
+ * AI 모델링 시나리오의 판정이 맞는지 — 모델 없이 (figure-ai-scenarios.ts).
+ *
+ * 시나리오마다 판정이 모범 답은 통과시키고, 커널은 받지만 요청을 놓친 답은 떨어뜨리는지 본다. 그래야 실제 모델을 돌린
+ * 결과(figure-ai-scenarios.live.test.ts)의 통과·실패를 믿을 수 있다. 커널이나 문법이 바뀌어 모범 답이 더는 받아지지
+ * 않으면 여기서 먼저 깨진다.
+ */
+import { createFigureAsset, inspectFigureAsset } from '@hatiolab/figure-model'
+
+import { FIGURE_AI_SCENARIOS } from './figure-ai-scenarios'
+import { judgeFigureAnswer } from './figure-propose-steps'
+
+const made = (scenario: (typeof FIGURE_AI_SCENARIOS)[number], answer: unknown[]) => {
+  const base = scenario.base?.() ?? createFigureAsset(scenario.name ?? 'Figure')
+  const judged = judgeFigureAnswer(base, { steps: answer }, !!scenario.base)
+  if (!judged.source) throw new Error(`${scenario.id}: the kernel refused the answer: ${judged.reasons.join(' / ')}`)
+  return { base, source: judged.source }
+}
+
+describe('AI 모델링 시나리오', () => {
+  it('each has an id of its own, what it covers, and a request', () => {
+    const ids = FIGURE_AI_SCENARIOS.map(s => s.id)
+    expect(new Set(ids).size).toBe(ids.length)
+    for (const s of FIGURE_AI_SCENARIOS) {
+      expect(s.covers.length).toBeGreaterThan(0)
+      expect(s.prompt.length).toBeGreaterThan(10)
+    }
+  })
+
+  it('they reach the shapes and relations the kernel has: pipes, tapers, joints, rows, clips, data, the figure\'s size', () => {
+    const covered = FIGURE_AI_SCENARIOS.flatMap(s => s.covers).join(' ')
+    for (const word of ['pipe', 'tapered', 'set-joint', 'make-repeat', 'set-driver', 'set-data-binding', 'follow-size', 'mirror-part', 'set-cavity', 'set-section']) expect(covered).toContain(word)
+    expect(FIGURE_AI_SCENARIOS.filter(s => s.base).length).toBeGreaterThanOrEqual(5)
+  })
+
+  it('roll-press: one roller repeated in a row of two, in a colour the frame does not have, is two rollers', () => {
+    const scenario = FIGURE_AI_SCENARIOS.find(s => s.id === 'roll-press')!
+    const row = (colour: string) => [
+      { kind: 'add-part', part: { id: 'base', kind: 'box', dimensions: { width: 1000, height: 80, depth: 500 } } },
+      { kind: 'add-part', part: { id: 'roller', kind: 'cylinder', dimensions: { radius: 80, length: 400 } } },
+      { kind: 'attach', part: 'base', to: { plane: 'mounting-plane' } },
+      { kind: 'attach', part: 'roller', to: { part: 'base', face: 'top' } },
+      { kind: 'make-repeat', part: 'roller', axis: 'x', pitch: 300, count: 2 },
+      { kind: 'set-material', target: 'roller', material: { token: 'palette.accent' }, palette: { 'palette.accent': colour } }
+    ]
+    const { base, source } = made(scenario, row('#d08a2c'))
+    expect(scenario.check(source, base)).toEqual([])
+    const plain = made(scenario, row('#d08a2c').slice(0, 4))
+    expect(scenario.check(plain.source, plain.base)).toContainEqual(expect.stringMatching(/1 round bodies drawn/))
+  })
+
+  /* Outside review 2026-11-03: a run of 30 passed a request for 300. */
+  it('pipe-extend: the bend and the run added are the ones asked, 90° and 300 mm', () => {
+    const scenario = FIGURE_AI_SCENARIOS.find(s => s.id === 'pipe-extend')!
+    const answer = JSON.parse(JSON.stringify(scenario.reference))
+    answer[0].path.at(-1).line = 30
+    const short = made(scenario, answer)
+    expect(scenario.check(short.source, short.base)).toEqual([expect.stringMatching(/a 300 mm run asked/)])
+    answer[0].path.at(-1).line = 300
+    answer[0].path.at(-2).bend.angle = 60
+    const shallow = made(scenario, answer)
+    expect(scenario.check(shallow.source, shallow.base)).toContainEqual(expect.stringMatching(/a 90° bend asked/))
+  })
+
+  describe.each(FIGURE_AI_SCENARIOS.map(s => [s.id, s] as const))('%s', (_, scenario) => {
+    it('its reference answer is taken by the kernel and the gate, and passes its check', () => {
+      const { base, source } = made(scenario, scenario.reference)
+      expect(inspectFigureAsset(source).violations).toEqual([])
+      expect(scenario.check(source, base)).toEqual([])
+    })
+
+    it('its wrong answer is taken by the kernel, and its check says what it misses', () => {
+      const { base, source } = made(scenario, scenario.wrong)
+      expect(scenario.check(source, base).length).toBeGreaterThan(0)
+    })
+  })
+})