@things-factory/figure-service 10.1.7 → 10.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-service",
-  "version": "10.1.7",
+  "version": "10.1.8",
   "publishConfig": {
     "access": "public",
     "@things-factory:registry": "https://registry.npmjs.org"
@@ -23,14 +23,14 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create ./server/migrations/migration"
   },
   "dependencies": {
-    "@hatiolab/figure-model": "^0.1.15",
+    "@hatiolab/figure-model": "file:../../../figure-model",
     "@operato/typeorm-history": "^10.0.0",
-    "@things-factory/ai-client-base": "^10.1.7",
+    "@things-factory/ai-client-base": "^10.1.8",
     "@things-factory/auth-base": "^10.1.7",
     "@things-factory/env": "^10.1.3",
     "@things-factory/shell": "^10.1.7",
     "graphql-upload": "^15.0.2",
     "koa-router": "^7.4.0"
   },
-  "gitHead": "9a036f83f5751f9e4af9180e9a0018f716a4ba27"
+  "gitHead": "c402982e29aab3b49e56bea4e41948be6a749c7f"
 }

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

@@ -0,0 +1,95 @@
+/**
+ * Figure AI의 결정적 종단 흐름.
+ *
+ * 외부 공급자·DB를 띄우지 않되, 도크 host context → 도구 → 실제 후보 생성/검사 → 후보 카드라는
+ * 경계를 한 번에 지난다. 단위 시험만으로는 피드백이 도구 입력에서 끊기거나, 검증된 후보가 카드
+ * 표시를 잃는 연결 결함을 놓칠 수 있다.
+ */
+import { clearToolRegistry, getToolCategories, setDefaultAIClient } from '@things-factory/ai-client-base'
+import type { AIClient } from '@things-factory/ai-client-base'
+
+import { __setFigureToolDepsForTest, registerFigureToolCategories } from './figure-tools'
+import { proposeFigure } from './figure-propose'
+
+const DOMAIN = { id: 'domain-mine' }
+const SOURCE = {
+  type: 'MIXER', base: { x: 300, y: 500, z: 300 }, detailLevel: 'M',
+  parts: [{
+    name: 'body', primitive: 'cylinder', segments: 12,
+    transform: { position: { x: 0, y: 0, z: 0 }, size: { x: 300, y: 400, z: 300 } },
+    material: { token: 'palette.primary' }
+  }]
+}
+const ROW = { id: 'fig-1', type: 'MIXER', name: '믹서', state: 'draft', domain: DOMAIN, source: JSON.stringify(SOURCE) }
+
+function client(): AIClient & { sent: any[][] } {
+  const fake = {
+    id: 'deterministic-figure-flow',
+    sent: [] as any[][],
+    async chat() { return '' },
+    async generateJSON(messages: any[]) {
+      fake.sent.push(JSON.parse(JSON.stringify(messages)))
+      return SOURCE
+    }
+  }
+  return fake as unknown as AIClient & { sent: any[][] }
+}
+
+beforeEach(() => {
+  clearToolRegistry()
+  const model = require('@hatiolab/figure-model')
+  __setFigureToolDepsForTest({
+    getRepository: () => ({
+      async findOne({ where }: any) { return where.id === ROW.id && where.domain?.id === DOMAIN.id ? ROW : null },
+      async find({ where }: any) { return where.domain?.id === DOMAIN.id ? [ROW] : [] }
+    }),
+    Figure: class {},
+    inspectSource: () => ({ blocked: false, findings: [] }),
+    proposeFigure,
+    compile: model.compile,
+    costOf: model.costOf,
+    scoreOf: model.scoreOf,
+    validate: model.validate
+  })
+  registerFigureToolCategories()
+})
+
+afterEach(() => {
+  clearToolRegistry()
+  setDefaultAIClient(undefined)
+})
+
+test('초안·세션 피드백을 반영한 후보가 검증·품질 근거와 카드 표시를 거쳐 돌아온다', async () => {
+  const fake = client()
+  setDefaultAIClient(fake)
+  const propose = getToolCategories()
+    .find((category: any) => category.name === 'figure-authoring')!
+    .specs.find((spec: any) => spec.name === 'proposeFigureCandidate') as any
+
+  const result = await propose.builder(
+    { prompt: '포트가 더 잘 읽히도록 고쳐줘' },
+    {
+      state: {
+        domain: DOMAIN,
+        host: {
+          figureId: 'fig-1',
+          palette: ['palette.primary'],
+          draftSource: SOURCE,
+          proposalFeedback: [{
+            outcome: 'discarded', selectedChanges: 0, totalChanges: 3,
+            note: '실루엣은 유지하고 포트의 대비를 높여줘',
+            quality: { status: 'review', findingCodes: ['top-view-readability'] }
+          }]
+        }
+      }
+    }
+  )
+
+  expect(fake.sent).toHaveLength(1)
+  expect(fake.sent[0]![0]!.content).toContain('Revise this existing figure')
+  expect(fake.sent[0]![0]!.content).toContain('실루엣은 유지하고 포트의 대비를 높여줘')
+  expect(result.proposed).toBe(true)
+  expect(result.source.type).toBe('MIXER')
+  expect(result.quality).toEqual(expect.objectContaining({ status: expect.stringMatching(/^(ready|review)$/) }))
+  expect(result.cost.triangles).toBeGreaterThan(0)
+})

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

@@ -0,0 +1,32 @@
+import { inspectSource } from './figure-gate'
+
+describe('release-gate repair candidates', () => {
+  it('returns data, not parsed prose, for a measured sizing split', () => {
+    const source = {
+      type: 'STACK',
+      base: { x: 100, y: 200, z: 100 },
+      detailLevel: 'M',
+      parts: [
+        {
+          name: 'foot', primitive: 'cube',
+          transform: { position: { x: 0, y: -50, z: 0 }, size: { x: 100, y: 100, z: 100 } },
+          material: { token: 'palette.primary' }, anchor: { y: 'min' }
+        },
+        {
+          name: 'lamp', primitive: 'cube',
+          transform: { position: { x: 0, y: 10, z: 0 }, size: { x: 60, y: 20, z: 60 } },
+          material: { token: 'palette.accent' }, anchor: { y: 'max' }
+        }
+      ]
+    }
+
+    const inspection = inspectSource(JSON.stringify(source))
+    const split = inspection.findings.find(finding => finding.code === 'sizing-splits')
+
+    expect(inspection.blocked).toBe(true)
+    expect(split?.fixes).toEqual(expect.arrayContaining([
+      expect.objectContaining({ part: expect.any(String), axis: 'y', to: expect.any(String), resolved: expect.any(Number), safe: expect.any(Boolean) })
+    ]))
+    expect(split?.fixes?.every(fix => fix.resolved > 0)).toBe(true)
+  })
+})

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

@@ -1,5 +1,17 @@
 import { compile, sizingReport, validate } from '@hatiolab/figure-model'
-import type { FigureSource } from '@hatiolab/figure-model'
+import type { Axis, FigureSource } from '@hatiolab/figure-model'
+
+/** Service transport shape. It deliberately contains only an explicit, reversible FigureSource edit. */
+export interface GateFix {
+  findingWay: string
+  part: string
+  axis: Axis
+  from?: string
+  to: 'min' | 'center' | 'max' | 'span'
+  resolved: number
+  /** True only when rechecking every sizing case leaves no release-blocking split. */
+  safe: boolean
+}
 
 /**
  * 발행해도 되나 — **서버가 판정한다.**
@@ -43,6 +55,12 @@ export interface GateFinding {
   how?: string
   /** 어디를 가리키나 — 갈라짐은 갈라진 부품 이름들, 형식 위반은 정본 안의 경로. */
   at?: string
+  /**
+   * 실제로 재 본, 되돌릴 수 있는 한 앵커 수정안들. 문장을 파싱해서 고치는 것이 아니라
+   * FigureSource 에 적용할 정확한 값만 내보낸다. 화면은 이것을 후보로만 보여 주고 저작자가
+   * 수락하기 전에는 정본을 바꾸지 않는다.
+   */
+  fixes?: GateFix[]
   blocking: boolean
 }
 
@@ -52,6 +70,54 @@ export interface Inspection {
   blocked: boolean
 }
 
+/**
+ * Figure model publishes the same capability for direct model consumers. Keep the service calculation
+ * here as well because this package is deployed independently and receives a compiled local model package.
+ * Each alternative is remeasured; prose from `how` is never parsed into an edit.
+ */
+function measuredFixes(source: FigureSource, factor: number): GateFix[] {
+  const baseline = sizingReport(compile(source), factor)
+  const baselineCount = baseline.findings.filter(finding => finding.code === 'sizing-splits').length
+  const seen = new Set<string>()
+  const fixes: GateFix[] = []
+
+  for (const finding of baseline.findings) {
+    if (finding.code !== 'sizing-splits' || !finding.way) continue
+    const axes = finding.way.split('-').filter((axis): axis is Axis => ['x', 'y', 'z'].includes(axis))
+    const names = new Set(finding.clumps.flat())
+
+    for (const part of source.parts) {
+      if (!names.has(part.name)) continue
+      for (const axis of axes) {
+        for (const to of ['min', 'center', 'max', 'span'] as const) {
+          if (part.anchor?.[axis] === to) continue
+          const changed: FigureSource = {
+            ...source,
+            parts: source.parts.map(one => one.name === part.name ? { ...one, anchor: { ...(one.anchor ?? {}), [axis]: to } } : one)
+          }
+          const afterCount = sizingReport(compile(changed), factor).findings.filter(one => one.code === 'sizing-splits').length
+          const resolved = baselineCount - afterCount
+          const key = `${finding.way}:${part.name}:${axis}:${to}`
+          if (resolved <= 0 || seen.has(key)) continue
+          seen.add(key)
+          fixes.push({
+            findingWay: finding.way,
+            part: part.name,
+            axis,
+            from: part.anchor?.[axis],
+            to,
+            resolved,
+            /* 한 finding만 없앤 것이 아니라 전수 검사에서 막는 split이 0일 때만 원클릭 후보가 된다. */
+            safe: afterCount === 0
+          })
+        }
+      }
+    }
+  }
+
+  return fixes.sort((a, b) => b.resolved - a.resolved || a.part.localeCompare(b.part)).slice(0, 12)
+}
+
 /**
  * 정본 하나를 판정한다.
  *
@@ -99,7 +165,9 @@ export function inspectSource(sourceJson?: string | null): Inspection {
   }
 
   if (result.errors.length === 0) {
-    const report = sizingReport(compile(parsed as FigureSource))
+    const source = parsed as FigureSource
+    const report = sizingReport(compile(source))
+    const fixes = measuredFixes(source, report.factor)
 
     for (const finding of report.findings) {
       findings.push({
@@ -110,6 +178,7 @@ export function inspectSource(sourceJson?: string | null): Inspection {
         how: finding.how,
         /* 숫자가 아니라 자리를 말한다 — 어느 부품들이 갈라져 나왔나. */
         at: finding.clumps.map(clump => [...clump].sort().join('+')).join(' | ') || undefined,
+        fixes: finding.code === 'sizing-splits' ? fixes.filter(fix => fix.findingWay === finding.way) : undefined,
         blocking: finding.code === 'sizing-splits'
       })
     }

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

@@ -0,0 +1,91 @@
+/**
+ * 실제 LLM Figure 후보 생성 smoke test (기본 비활성).
+ *
+ * 결정적 시험은 프롬프트·도구·검사 배선을 고정하지만, 실제 모델이 FigureSource JSON을 지키는지는
+ * 대신할 수 없다. 이 시험은 `RUN_FIGURE_LLM_SMOKE=1`과 공급자 API 키가 모두 있을 때만 실행한다.
+ * DB·GraphQL·Figure 저장을 건드리지 않고 후보 생성 함수만 호출하므로, 외부 영향은 API 비용뿐이다.
+ *
+ * 실행:
+ *   RUN_FIGURE_LLM_SMOKE=1 OPENAI_API_KEY=... yarn test:figure-llm-smoke
+ * 선택: FIGURE_LLM_PROVIDER=anthropic|gemini|openai, FIGURE_LLM_MODEL=<model id>
+ */
+import { createAIClient, setDefaultAIClient } from '@things-factory/ai-client-base'
+
+import { proposeFigure } from './figure-propose'
+
+// Provider modules register themselves on import. Keep this separate from the deterministic tests.
+import '@things-factory/ai-client-base'
+
+type Provider = 'anthropic' | 'gemini' | 'openai'
+
+function provider(): { provider: Provider; apiKey: string } | undefined {
+  const requested = process.env.FIGURE_LLM_PROVIDER as Provider | undefined
+  const candidates: Array<{ provider: Provider; keys: string[] }> = [
+    { provider: 'anthropic', keys: ['ANTHROPIC_API_KEY'] },
+    { provider: 'gemini', keys: ['GEMINI_API_KEY', 'GOOGLE_API_KEY'] },
+    { provider: 'openai', keys: ['OPENAI_API_KEY'] }
+  ]
+  const usable = requested ? candidates.filter(candidate => candidate.provider === requested) : candidates
+  for (const candidate of usable) {
+    const apiKey = candidate.keys.map(key => process.env[key]).find(Boolean)
+    if (apiKey) return { provider: candidate.provider, apiKey }
+  }
+  return undefined
+}
+
+const picked = process.env.RUN_FIGURE_LLM_SMOKE === '1' ? provider() : undefined
+const describeIf = picked ? describe : describe.skip
+const PALETTE = ['palette.primary', 'palette.accent', 'palette.neutral']
+
+describeIf('Figure 실제 LLM smoke', () => {
+  beforeAll(() => {
+    setDefaultAIClient(createAIClient({ ...picked!, ...(process.env.FIGURE_LLM_MODEL ? { model: process.env.FIGURE_LLM_MODEL } : {}) }))
+    // eslint-disable-next-line no-console
+    console.log(`[figure-llm-smoke] provider=${picked!.provider} model=${process.env.FIGURE_LLM_MODEL ?? '(adapter default)'}`)
+  })
+
+  afterAll(() => setDefaultAIClient(undefined))
+
+  test(
+    '새 Figure 후보는 유효한 어휘·팔레트·품질 근거를 가진다',
+    async () => {
+      const result = await proposeFigure({
+        prompt: 'two cylindrical rollers inside a simple rectangular press frame; make the rollers visually distinct',
+        type: 'ROLL_PRESS_SMOKE',
+        palette: PALETTE,
+        refine: true
+      })
+
+      expect(result.source.type).toBe('ROLL_PRESS_SMOKE')
+      expect(result.source.parts.length).toBeGreaterThan(0)
+      expect(result.source.parts.every(part => PALETTE.includes(part.material.token))).toBe(true)
+      expect(result.quality.status).toMatch(/^(ready|review)$/)
+      expect(result.cost.triangles).toBeGreaterThan(0)
+    },
+    90_000
+  )
+
+  test(
+    '수정 후보는 type을 보존하고 명시적 세션 피드백을 참고한다',
+    async () => {
+      const result = await proposeFigure({
+        prompt: 'make the port more visible from above while keeping the body and port part names',
+        palette: PALETTE,
+        refine: true,
+        base: {
+          type: 'MIXER_SMOKE', base: { x: 300, y: 400, z: 300 }, detailLevel: 'M',
+          parts: [
+            { name: 'body', primitive: 'cylinder', segments: 12, transform: { position: { x: 0, y: 0, z: 0 }, size: { x: 280, y: 320, z: 280 } }, material: { token: 'palette.primary' } },
+            { name: 'port', primitive: 'cube', transform: { position: { x: 0, y: 30, z: -155 }, size: { x: 80, y: 60, z: 30 } }, material: { token: 'palette.accent' } }
+          ]
+        },
+        feedback: [{ outcome: 'discarded', selectedChanges: 0, totalChanges: 2, note: 'the port must read clearly in top view' }]
+      })
+
+      expect(result.source.type).toBe('MIXER_SMOKE')
+      expect(result.source.parts.map(part => part.name)).toEqual(expect.arrayContaining(['body', 'port']))
+      expect(result.quality).toBeDefined()
+    },
+    90_000
+  )
+})

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

@@ -318,6 +318,8 @@ export class FigureMutation {
         base: request.base ? JSON.parse(request.base) : undefined,
         type: request.type,
         palette: request.palette,
+        refine: request.refine,
+        feedback: request.feedback,
         image
       })
 
@@ -327,6 +329,12 @@ export class FigureMutation {
         grade: result.score.grade,
         triangles: result.cost.triangles,
         groups: result.cost.groups,
+        quality: {
+          ...result.quality,
+          visualRegions: result.quality.visual.regions,
+          visualCoverage: result.quality.visual.coverage,
+          visualReadability: result.quality.visual.readability
+        },
         violations: result.violations,
         attempts: result.attempts
       }

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

@@ -4,6 +4,72 @@ import { Field, InputType, Int, ObjectType } from 'type-graphql'
 
 import { FigureFinding } from './figure-type.js'
 
+@ObjectType({ description: 'One explainable consideration from the model-grounded candidate review.' })
+export class FigureQualityFinding {
+  @Field({ description: 'What the consideration concerns: identity, silhouette, palette, performance, or resilience.' })
+  dimension: string
+
+  @Field({ description: 'Stable machine-readable review code.' })
+  code: string
+
+  @Field({ description: 'Human-readable evidence and recommended review.' })
+  message: string
+}
+
+@ObjectType({ description: 'Explainable design review based on Figure-model evidence, not a visual aesthetic claim.' })
+export class FigureQualityReview {
+  @Field({ description: 'ready when measurable checks are clear; review when author attention is recommended.' })
+  status: string
+
+  @Field({ description: 'Compact explanation of this review.' })
+  summary: string
+
+  @Field(type => [FigureQualityFinding], { description: 'Measured considerations for the author and assistant.' })
+  findings: FigureQualityFinding[]
+
+  @Field(type => Int, { description: 'Visible material regions in the reproducible top-view evidence.' })
+  visualRegions: number
+
+  @Field({ description: 'Top-view footprint coverage from 0 to 1.' })
+  visualCoverage: number
+
+  @Field({ description: 'Normalized top-view readability evidence from 0 to 1.' })
+  visualReadability: number
+
+}
+
+/** 제한된 후보 품질 코드. 현재 요청의 참고 데이터이며 어떤 Figure에도 저장되지 않는다. */
+@InputType({ description: 'Measured review summary from an earlier candidate in this authoring session.' })
+export class ProposalFeedbackQualityInput {
+  @Field({ nullable: true })
+  status?: string
+
+  @Field(type => [String], { nullable: true })
+  findingCodes?: string[]
+}
+
+/** 사람이 명시적으로 수락하거나 거절한 후보의 제한된 세션 반응. */
+@InputType({ description: 'Explicit author feedback for the next candidate. Session-only; never persisted.' })
+export class ProposalFeedbackInput {
+  @Field()
+  outcome: string
+
+  @Field(type => Int)
+  selectedChanges: number
+
+  @Field(type => Int)
+  totalChanges: number
+
+  @Field({ nullable: true })
+  note?: string
+
+  @Field({ nullable: true })
+  grade?: string
+
+  @Field(type => ProposalFeedbackQualityInput, { nullable: true })
+  quality?: ProposalFeedbackQualityInput
+}
+
 /**
  * 저작 보조에 넘기는 것.
  *
@@ -39,6 +105,15 @@ export class ProposeRequest {
 
   @Field(type => [String], { description: 'Palette tokens the client can resolve. Anything else is rejected.' })
   palette: string[]
+
+  @Field({ nullable: true, description: 'Ask for one evidence-grounded refinement when the first valid candidate needs review.' })
+  refine?: boolean
+
+  @Field(type => [ProposalFeedbackInput], {
+    nullable: true,
+    description: 'Explicit session-only feedback on earlier candidates. It is constrained again before prompting and never stored.'
+  })
+  feedback?: ProposalFeedbackInput[]
 }
 
 /**
@@ -64,6 +139,11 @@ export class FigureProposal {
   @Field(type => Int, { description: 'Material groups — the draw calls one instance costs' })
   groups: number
 
+  @Field(type => FigureQualityReview, {
+    description: 'Explainable design review. It advises the author and never saves or rejects the candidate.'
+  })
+  quality: FigureQualityReview
+
   @Field(type => [FigureFinding], {
     description: 'Policy violations. These do not block the proposal — the author decides.'
   })

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

@@ -131,6 +131,14 @@ describe('후보를 받아 볼 때', () => {
     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('후보를 만들 때', () => {
@@ -143,6 +151,52 @@ describe('후보를 만들 때', () => {
     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: 0, z: 0 }, size: { x: 100, y: 100, z: 100 } }, material: { token: 'palette.primary' } },
+      { name: 'part-2', primitive: 'cube', transform: { position: { x: 0, y: 0, z: 0 }, size: { x: 100, y: 100, z: 100 } }, material: { token: 'palette.primary' } },
+      { name: 'part-3', primitive: 'cube', transform: { position: { x: 100, y: 0, z: 0 }, size: { x: 100, y: 100, z: 100 } }, material: { token: 'palette.primary' } },
+      { name: 'part-4', primitive: 'cube', transform: { position: { x: 150, y: 0, 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: 0, 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 () => {
@@ -155,6 +209,27 @@ describe('후보를 만들 때', () => {
     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: [] })]))
 
@@ -195,6 +270,8 @@ describe('무엇을 시키는지가 프롬프트에 실린다', () => {
     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"')
   })