@things-factory/figure-service 10.1.79 → 10.1.82

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-service",
-  "version": "10.1.79",
+  "version": "10.1.82",
   "publishConfig": {
     "access": "public",
     "@things-factory:registry": "https://registry.npmjs.org"
@@ -25,9 +25,9 @@
     "test:templates": "node --test scripts/templates.test.mts"
   },
   "dependencies": {
-    "@hatiolab/figure-model": "^0.1.93",
+    "@hatiolab/figure-model": "^0.1.94",
     "@operato/typeorm-history": "^10.0.0",
-    "@things-factory/ai-client-base": "^10.1.53",
+    "@things-factory/ai-client-base": "^10.1.81",
     "@things-factory/auth-base": "^10.1.79",
     "@things-factory/env": "^10.1.20",
     "@things-factory/shell": "^10.1.79",
@@ -35,5 +35,5 @@
     "graphql-upload": "^15.0.2",
     "koa-router": "^7.4.0"
   },
-  "gitHead": "94cde9ba17dfdddb0a16139b71e5a7e370977e4a"
+  "gitHead": "263d0247111fbffb02d7122864df0b61bda99461"
 }

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

@@ -267,9 +267,10 @@ export function inspectSource(
     const states = inspection.coverage.states
     findings.push({
       code: 'state-range-sampled',
-      message: say('figure.gate.state-range-sampled.message', { states }, `The whole range of motion could not be proven, so ${states} poses were checked.`),
-      why: say('figure.gate.state-range-sampled.why', {}, 'Between the poses that were checked, a part may still go past the declared space.'),
-      how: say('figure.gate.state-range-sampled.how', {}, 'Re-author the motion that could not be proven, and the whole range can be proven.'),
+      /* Sizes as well as motion: the instance size range is swept for every figure (figure-model, designer 2026-09-27). */
+      message: say('figure.gate.state-range-sampled.message', { states }, `The whole range of sizes and motion could not be proven, so ${states} combinations of size and pose were checked.`),
+      why: say('figure.gate.state-range-sampled.why', {}, 'Between the combinations that were checked, a part may still go past the declared space.'),
+      how: say('figure.gate.state-range-sampled.how', {}, 'To cover the whole range, re-author what could not be proven.'),
       /*
         Which motions stopped the proof, by the name a person gave them: the kernel reports each operation it could
         not prove (`j2-shoulder.chain: compose@1 turns …`), and the screen showed that English list as it was. The

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

@@ -6,7 +6,10 @@ import { getRepository } from '@things-factory/shell'
 
 import { Figure } from './figure.js'
 import { FigureHistory } from './figure-history.js'
-import { FigurePatch, FigureSaveResult, NewFigure } from './figure-type.js'
+import { FigurePatch, FigureRevertResult, FigureSaveResult, NewFigure } from './figure-type.js'
+import { FigureReplacedDraft } from './figure-replaced-draft.js'
+import { revertKeepingDraft, undoRevert } from './figure-revert.js'
+import { recordProposals } from './figure-proposal.js'
 import { FigureProposal, ProposeRequest } from './figure-propose-type.js'
 import { inspectSource } from './figure-format.js'
 import { renameDraftType, renameFacts } from './figure-rename.js'
@@ -27,6 +30,25 @@ export class FigureMutation {
     @Arg('creationId', { nullable: true }) creationId?: string,
     @Arg('thumbnail', { nullable: true }) thumbnail?: string,
     @Arg('type', { nullable: true, description: 'The type name a new figure is created under. Ignored for an existing one.' })
+    type?: string,
+    @Arg('proposalKeys', type => [String], {
+      nullable: true,
+      description: "Keys of the AI proposals whose steps this source holds: recorded with the save, in its transaction."
+    })
+    proposalKeys?: string[]
+  ): Promise<Figure> {
+    const saved = await this.writeSource(context, source, id, expectedSource, creationId, thumbnail, type)
+    await recordProposals(context.state.tx, context.state.domain, saved.id!, proposalKeys)
+    return saved
+  }
+
+  private async writeSource(
+    context: ResolverContext,
+    source: string,
+    id?: string,
+    expectedSource?: string,
+    creationId?: string,
+    thumbnail?: string,
     type?: string
   ): Promise<Figure> {
     const { domain, user, tx } = context.state
@@ -336,53 +358,37 @@ export class FigureMutation {
    */
   @Directive('@transaction')
   @Directive('@privilege(category: "figure", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => FigureSaveResult, { description: 'Reverts a figure to one of its released versions. It comes back as a draft.' })
+  @Mutation(returns => FigureRevertResult, {
+    description:
+      'Reverts a figure to one of its released versions, keeping the draft it writes over. It comes back as a draft. ' +
+      'The same requestId again answers with the same revert.'
+  })
   async revertFigureVersion(
     @Arg('id') id: string,
     @Arg('version') version: number,
+    @Arg('requestId', { description: 'A UUID for this revert: a retry sends the same one.' }) requestId: string,
+    @Arg('expectedSource', { description: "The figure's source as the reverter saw it; the revert goes on only while it holds." }) expectedSource: string,
     @Ctx() context: ResolverContext
-  ): Promise<FigureSaveResult> {
+  ): Promise<FigureRevertResult> {
+    /* Kept and written over in this transaction, or neither (ADR-0097 §5.6). */
     const { domain, user, tx } = context.state
-    const repository = tx.getRepository(Figure)
-    const historyRepository = tx.getRepository(FigureHistory)
-
-    const figure = await repository.findOne({
-      where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, id }
-    })
-    if (!figure) {
-      throw new Error(`Figure ${id} 를 찾을 수 없다`)
-    }
-
-    const history = await historyRepository.findOne({
-      where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, originalId: id, version }
-    })
-    if (!history) {
-      throw new Error(`Figure '${figure.type}' 에 ${version} 판이 없다`)
-    }
-
-    /* 형식 검사도 다시 받는다 — 옛 판이 오늘의 형식을 어길 수 있고, 그것을 조용히 들이지 않는다. */
-    const { source, derived, violations } = parseSource(history.source)
-
-    const saved = await repository.save({
-      /*
-        `domain` 을 명시로 넣는다 — 읽어 온 엔티티에는 관계가 안 실려 있다.
-
-        판본 스냅샷은 넘겨받은 엔티티를 베끼므로, 여기서 빠지면 판본의 도메인이 비고 그 판은
-        도메인으로 거르는 조회에 **한 줄도 안 걸린다**(실제로 그랬다). board 의 저장들도 같은
-        자리에서 domain 을 함께 넣는다.
-      */
-      domain,
-      ...figure,
-      source,
-      ...derived,
-      properties: history.properties,
-      thumbnail: history.thumbnail,
-      thumbnailUpdatedAt: history.thumbnail === figure.thumbnail ? figure.thumbnailUpdatedAt : new Date(),
-      state: 'draft',
-      updater: user
-    })
+    const { figure, violations, kept } = await revertKeepingDraft(tx, domain, user, { id, version, requestId, expectedSource })
+    return { figure, violations, kept }
+  }
 
-    return { figure: saved, violations }
+  @Directive('@transaction')
+  @Directive('@privilege(category: "figure", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => FigureRevertResult, {
+    description: "Brings back a draft a revert kept -- only while the figure still holds what that revert wrote. The same requestId again answers with the same undo."
+  })
+  async undoFigureRevert(
+    @Arg('keptId') keptId: string,
+    @Arg('requestId', { description: 'A UUID for this undo: a retry sends the same one.' }) requestId: string,
+    @Ctx() context: ResolverContext
+  ): Promise<FigureRevertResult> {
+    const { domain, user, tx } = context.state
+    const { figure, kept } = await undoRevert(tx, domain, user, { keptId, requestId })
+    return { figure, violations: [], kept: kept as FigureReplacedDraft }
   }
 
   @Directive('@transaction')

package/server/service/figure/figure-proposal-db.test.ts

@@ -0,0 +1,108 @@
+/**
+ * What became of an AI proposal, on sqlite through the save door itself (ADR-0097 §5.6 item 5; AI lane, 2026-09-27).
+ * A save records the proposals its source holds, in its transaction; the same proposal taken twice never makes two
+ * figures, because a new figure made from it is created under its key.
+ */
+import type { DataSource } from 'typeorm'
+
+const { DataSource: TypeOrmDataSource } = require('typeorm')
+const shell = require('@things-factory/shell')
+const authBase = require('@things-factory/auth-base')
+const { createFigureAsset, addFigureBox, serializeFigureAsset } = require('@hatiolab/figure-model')
+
+let dataSource: DataSource | null = null
+let Figure: any
+let FigureHistory: any
+let FigureProposalRecord: any
+let FigureMutation: any
+let FigureQuery: any
+
+function loadCompiled(modulePath: string): any {
+  const { existsSync } = require('fs')
+  const { join } = require('path')
+  const resolved = join(__dirname, '..', '..', '..', 'dist-server', `${modulePath}.js`)
+  if (!existsSync(resolved))
+    throw new Error(`figure-service 산출물이 없다: ${resolved}\n먼저 빌드할 것:\n  yarn workspace @things-factory/figure-service build:server`)
+  return require(resolved)
+}
+
+beforeAll(async () => {
+  Figure = loadCompiled('service/figure/figure').Figure
+  FigureHistory = loadCompiled('service/figure/figure-history').FigureHistory
+  FigureProposalRecord = loadCompiled('service/figure/figure-proposal-record').FigureProposalRecord
+  FigureMutation = loadCompiled('service/figure/figure-mutation').FigureMutation
+  FigureQuery = loadCompiled('service/figure/figure-query').FigureQuery
+  dataSource = new TypeOrmDataSource({
+    type: 'sqlite',
+    database: ':memory:',
+    synchronize: true,
+    dropSchema: true,
+    namingStrategy: new shell.NamingStrategy(),
+    entities: [...shell.entities, ...authBase.entities, Figure, FigureHistory, FigureProposalRecord],
+    logging: false
+  })
+  await dataSource.initialize()
+})
+
+afterAll(async () => {
+  await dataSource?.destroy()
+  dataSource = null
+})
+
+let DOMAIN: { id: string }
+beforeEach(async () => {
+  await dataSource!.synchronize(true)
+  DOMAIN = { id: (await dataSource!.getRepository(shell.Domain).save({ name: 'proposal-probe', subdomain: 'proposal-probe' })).id }
+})
+
+const text = (name: string, height = 100) =>
+  serializeFigureAsset(addFigureBox(createFigureAsset(name), { id: 'body', size: { x: 100, y: height, z: 100 }, position: { x: 0, y: height / 2, z: 0 } }))
+const uuid = () => require('crypto').randomUUID()
+/* Through the door, in a transaction of its own as `@transaction` gives it. */
+const save = (source: string, { id, expectedSource, creationId, proposalKeys }: { id?: string; expectedSource?: string; creationId?: string; proposalKeys?: string[] }) =>
+  dataSource!.transaction(tx =>
+    new FigureMutation().saveFigure(source, { state: { domain: DOMAIN, user: undefined, tx } }, id, expectedSource, creationId, undefined, undefined, proposalKeys)
+  )
+const outcome = (proposalKey: string) => new FigureQuery().figureProposalOutcome(proposalKey, { state: { domain: DOMAIN, tx: dataSource!.manager } })
+const records = () => dataSource!.getRepository(FigureProposalRecord).count()
+
+describe('a save records the proposals its source holds', () => {
+  it('recorded with the save, once per figure however often it is saved again', async () => {
+    const key = uuid()
+    const first = await save(text('A'), { creationId: uuid(), proposalKeys: [key] })
+    await save(text('A', 200), { id: first.id, expectedSource: first.source, proposalKeys: [key] })
+    const found = await outcome(key)
+    expect(found.map((f: any) => f.figureId)).toEqual([first.id])
+    expect(found[0].name).toBe('A')
+    expect(await records()).toBe(1)
+  })
+
+  it('a save refused records nothing -- the record is in its transaction', async () => {
+    const figure = await save(text('A'), { creationId: uuid() })
+    const key = uuid()
+    await expect(save(text('B'), { id: figure.id, expectedSource: 'stale', proposalKeys: [key] })).rejects.toMatchObject({
+      extensions: { code: 'FIGURE_SOURCE_CONFLICT' }
+    })
+    expect(await outcome(key)).toEqual([])
+  })
+
+  it('a key not of the tool’s making is not recorded; a proposal never saved has no outcome', async () => {
+    await save(text('A'), { creationId: uuid(), proposalKeys: ['not-a-key'] })
+    expect(await records()).toBe(0)
+    expect(await outcome(uuid())).toEqual([])
+  })
+})
+
+describe('the same new-figure proposal taken twice makes one figure', () => {
+  it('created under the proposal key: the second take meets the first figure, never a second one', async () => {
+    const key = uuid()
+    const once = await save(text('From AI'), { creationId: key, proposalKeys: [key] })
+    /* Taken again after a reload, the same steps: the same row answers. */
+    const again = await save(text('From AI'), { creationId: key, proposalKeys: [key] })
+    expect(again.id).toBe(once.id)
+    /* Taken again and changed before saving: refused, not a second figure. */
+    await expect(save(text('From AI, changed', 300), { creationId: key, proposalKeys: [key] })).rejects.toThrow(/이미 다른 내용으로 저장되었습니다/)
+    expect(await dataSource!.getRepository(Figure).count()).toBe(1)
+    expect((await outcome(key)).map((f: any) => f.figureId)).toEqual([key])
+  })
+})

package/server/service/figure/figure-proposal-record.ts

@@ -0,0 +1,38 @@
+import { CreateDateColumn, Column, Entity, Index, ManyToOne, PrimaryGeneratedColumn, RelationId } from 'typeorm'
+import { Field, ID, ObjectType } from 'type-graphql'
+
+import { Domain } from '@things-factory/shell'
+
+/**
+ * An AI proposal saved into a figure (ADR-0097 §5.6 item 5; AI lane, 2026-09-27).
+ *
+ * Written by the save that holds the proposal's step, in the same transaction: a proposal applied and then undone, or
+ * never saved, has none. So "what became of it" is answered from the server -- after a reload too -- and never from
+ * the dock's memory. A proposal saved into the same figure again is one record.
+ */
+@Entity()
+@Index('ix_figure_proposal_record_0', (record: FigureProposalRecord) => [record.domain, record.proposalKey, record.figureId], { unique: true })
+@ObjectType({ description: 'An AI proposal saved into a figure.' })
+export class FigureProposalRecord {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID, { description: 'Unique identifier of the record.' })
+  readonly id?: string
+
+  @ManyToOne(type => Domain)
+  domain?: Domain
+
+  @RelationId((record: FigureProposalRecord) => record.domain)
+  domainId?: string
+
+  @Column()
+  @Field({ description: 'The key the proposal was given when it was made.' })
+  proposalKey?: string
+
+  @Column()
+  @Field({ description: 'The figure it was saved into.' })
+  figureId?: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true, description: 'When the save that held it was made.' })
+  recordedAt?: Date
+}

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

@@ -0,0 +1,39 @@
+import type { EntityManager } from 'typeorm'
+import { In } from 'typeorm'
+
+import { Figure } from './figure.js'
+import { FigureProposalRecord } from './figure-proposal-record.js'
+
+/*
+ * What became of an AI proposal (ADR-0097 §5.6 item 5; AI lane, 2026-09-27): the saves that held its step. The key is the
+ * one `proposeFigureCandidate` gave it; a new figure made from it is created under that key, so the same proposal
+ * taken twice meets the first figure, never a second one.
+ */
+
+const KEY = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
+
+/** Records, in the save's transaction, the proposals its source holds. Keys not of the tool's making are not recorded. */
+export async function recordProposals(tx: EntityManager, domain: { id: string }, figureId: string, keys?: readonly string[]) {
+  const wanted = [...new Set((keys ?? []).filter(key => KEY.test(key)))]
+  if (!wanted.length) return
+  const records = tx.getRepository(FigureProposalRecord)
+  const already = new Set(
+    (await records.find({ where: { domain: { id: domain.id }, figureId, proposalKey: In(wanted) } })).map(record => record.proposalKey)
+  )
+  const fresh = wanted.filter(key => !already.has(key))
+  if (fresh.length) await records.insert(fresh.map(proposalKey => ({ domain: { id: domain.id }, figureId, proposalKey })))
+}
+
+/** The figures a proposal was saved into, with their names as they are now. None: not saved -- or not known here. */
+export async function proposalOutcomeOf(tx: EntityManager, domain: { id: string }, proposalKey: string) {
+  const records = await tx.getRepository(FigureProposalRecord).find({ where: { domain: { id: domain.id }, proposalKey }, order: { recordedAt: 'ASC' } })
+  if (!records.length) return []
+  const figures = await tx.getRepository(Figure).find({ where: { domain: { id: domain.id }, id: In(records.map(r => r.figureId!)) } })
+  const byId = new Map(figures.map(f => [f.id, f]))
+  return records.map(record => ({
+    figureId: record.figureId!,
+    recordedAt: record.recordedAt,
+    type: byId.get(record.figureId!)?.type,
+    name: byId.get(record.figureId!)?.name
+  }))
+}

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

@@ -0,0 +1,73 @@
+/**
+ * figure-propose-steps and clips (designer 2026-09-27): an AI answer that would stop a clip is refused whole, and the
+ * model is told it may not -- never how to agree. An answer that stops none keeps every clip. Consent the model writes
+ * into its answer is read as nothing.
+ */
+import { addFigureBox, applyFigureAuthoring, createFigureAsset, editFigurePart } from '@hatiolab/figure-model'
+import type { FigureAsset } from '@hatiolab/figure-model'
+import { setDefaultAIClient } from '@things-factory/ai-client-base'
+import type { AIClient } from '@things-factory/ai-client-base'
+
+import { ProposeFigureFailure, judgeFigureAnswer, proposeFigureSteps } from './figure-propose-steps'
+
+function stubClient(answers: unknown[]): AIClient & { calls: number; sent: any[][] } {
+  const client = {
+    id: 'stub',
+    calls: 0,
+    sent: [] as any[][],
+    async chat() {
+      return ''
+    },
+    async generateJSON(messages: any[]) {
+      client.sent.push(JSON.parse(JSON.stringify(messages)))
+      return answers[Math.min(client.calls++, answers.length - 1)]
+    }
+  }
+  return client as unknown as AIClient & { calls: number; sent: any[][] }
+}
+
+afterEach(() => setDefaultAIClient(undefined))
+
+function door(): FigureAsset {
+  let a = createFigureAsset('Door')
+  a = addFigureBox(a, { id: 'frame', size: { x: 1000, y: 100, z: 200 }, position: { x: 0, y: 50, z: 0 } })
+  a = addFigureBox(a, { id: 'leaf', size: { x: 900, y: 1800, z: 40 }, position: { x: 0, y: 1000, z: 0 } })
+  a = addFigureBox(a, { id: 'sign', size: { x: 200, y: 100, z: 10 }, position: { x: 0, y: 2200, z: 200 } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'leaf', face: 'bottom', to: { part: 'frame', face: 'top' } })
+  const j = a.joints!.find(k => k.body1.part === 'leaf')!
+  a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { ...j, type: 'revolute', axis: 'Y', state: { id: 'open' } } })
+  return editFigurePart(a, { kind: 'set-driver', state: 'open', clip: 'swing', duration: 2, keys: [{ seconds: 0, value: 0 }, { seconds: 2, value: 80 }] })
+}
+const lossy = { steps: [{ kind: 'rename', name: 'Door by AI' }, { kind: 'remove-part', target: 'leaf' }] }
+
+describe('an AI answer and the clips of the draft it revises', () => {
+  it('an answer that would stop a clip is refused whole, and the model is told it may not -- not how to agree', () => {
+    const base = door()
+    const judged = judgeFigureAnswer(base, lossy, true)
+    expect(judged.source).toBeUndefined()
+    expect(judged.reasons.join('\n')).toMatch(/CLIPS_DROPPED: .*swing.*may never remove a clip; only the person can/)
+    expect(judged.reasons.join('\n')).not.toMatch(/dropClips/)
+    expect(base.drivers?.map(d => d.clip)).toEqual(['swing'])
+  })
+
+  it('asked three times and three times lossy, nothing comes back: no half-made figure to save', async () => {
+    const client = stubClient([lossy])
+    setDefaultAIClient(client)
+    await expect(proposeFigureSteps({ prompt: '문을 없애 줘', base: door() })).rejects.toBeInstanceOf(ProposeFigureFailure)
+    expect(client.calls).toBe(3)
+    expect(JSON.stringify(client.sent)).not.toMatch(/dropClips/)
+  })
+
+  it('consent the model writes into its answer is read as nothing', () => {
+    const judged = judgeFigureAnswer(door(), { ...lossy, dropClips: ['swing/open'], steps: lossy.steps.map(s => ({ ...s, dropClips: ['swing/open'] })) }, true)
+    expect(judged.source).toBeUndefined()
+    expect(judged.reasons.join('\n')).toMatch(/^CLIPS_DROPPED/)
+  })
+
+  it('an answer that stops no clip keeps every clip, a rename of the part it hangs from included', async () => {
+    const base = door()
+    setDefaultAIClient(stubClient([{ steps: [{ kind: 'rename', name: 'Door 2' }, { kind: 'nudge-part', part: 'sign', by: { x: 50 } }, { kind: 'rename-part', target: 'frame', name: 'jamb' }] }]))
+    const made = await proposeFigureSteps({ prompt: '이름을 바꿔 줘', base })
+    expect(made.source.drivers).toEqual(base.drivers)
+  })
+})

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

@@ -114,8 +114,20 @@ export function judgeFigureAnswer(base: FigureAsset, answer: unknown, revising:
 
   let source: FigureAsset
   try {
+    /* Never with consent: only the person may let a clip go (designer 2026-09-27). */
     source = applyFigureProposal(base, steps as FigureProposalStep[])
   } catch (e) {
+    /*
+      The kernel's refusal tells a person how to agree; the model is told it may not, and what to keep instead -- it
+      must not learn to write a consent (designer 2026-09-27).
+    */
+    const clips = (e as { code?: string; clips?: Array<{ clip: string; state: string }> }).code === 'CLIPS_DROPPED' ? (e as { clips: Array<{ clip: string; state: string }> }).clips : undefined
+    if (clips)
+      return {
+        reasons: [
+          `CLIPS_DROPPED: these steps would stop the clips ${clips.map(c => `${c.clip} (plays ${c.state})`).join(', ')}. A proposal may never remove a clip; only the person can. Keep the parts and the motions those clips play as they are.`
+        ]
+      }
     return { reasons: [(e as Error).message] }
   }
 

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

@@ -14,7 +14,10 @@ import {
 import { Figure } from './figure.js'
 import { FigureHistory } from './figure-history.js'
 import { consumablePayloadOf, inspectSource } from './figure-format.js'
-import { FigureInspection, FigureList } from './figure-type.js'
+import { FigureInspection, FigureList, FigureProposalOutcome } from './figure-type.js'
+import { FigureReplacedDraft } from './figure-replaced-draft.js'
+import { replacedDraftsOf } from './figure-revert.js'
+import { proposalOutcomeOf } from './figure-proposal.js'
 
 @Resolver(Figure)
 @UseMiddleware(SpeakRefusals)
@@ -88,6 +91,24 @@ export class FigureQuery {
    * 도형의 현재 정본은 저작 중일 수 있다(초안). 배치된 것이 보는 것은 **마지막으로 발행된 판**이고,
    * 그것을 이 자리가 답한다.
    */
+  /** What became of an AI proposal: the figures a save put it into (ADR-0097 §5.6 item 5). */
+  @Directive('@privilege(category: "figure", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => [FigureProposalOutcome], {
+    description: 'The figures an AI proposal was saved into, oldest first. None: it was not saved, or not in this domain.'
+  })
+  async figureProposalOutcome(@Arg('proposalKey') proposalKey: string, @Ctx() context: ResolverContext): Promise<FigureProposalOutcome[]> {
+    const { domain, tx } = context.state
+    return await proposalOutcomeOf(getRepository(Figure, tx).manager, domain, proposalKey)
+  }
+
+  /** The drafts reverts kept for a figure, newest first -- apart from its released versions (ADR-0097 §5.6). */
+  @Directive('@privilege(category: "figure", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => [FigureReplacedDraft], { description: 'Drafts kept when a revert wrote over them, newest first. Not released versions.' })
+  async figureReplacedDrafts(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<FigureReplacedDraft[]> {
+    const { domain, tx } = context.state
+    return await replacedDraftsOf(getRepository(FigureReplacedDraft, tx).manager, domain, id)
+  }
+
   @Directive('@privilege(category: "figure", privilege: "query", domainOwnerGranted: true)')
   @Query(returns => FigureHistory, { nullable: true, description: 'The most recently released version of a figure.' })
   async figureReleased(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<FigureHistory> {

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

@@ -33,9 +33,10 @@ describe('초안의 type 고치기', () => {
     expect(() => parseFigureAsset(result.source)).not.toThrow()
   })
 
-  it('앞뒤 공백을 뗀다. 대소문자는 저작자가 적은 대로 둔다', () => {
+  it('앞뒤 공백을 뗀다. 모양은 모델러가 묻는 규칙 그대로 — 대문자로 적지 않으면 거절한다(Q-D3, 2026-09-27)', () => {
     expect(renameDraftType(draft(), '  ROBOT_ARM  ', never).type).toBe('ROBOT_ARM')
-    expect(renameDraftType(draft(), 'Robot_Arm', never).type).toBe('Robot_Arm')
+    /* It was kept as written; the modeller always sent it upper-cased, and every stored type already is (56/56). */
+    expect(() => renameDraftType(draft(), 'Robot_Arm', never)).toThrow(expect.objectContaining({ code: 'malformed-type' }))
   })
 
   it('★ 한 번이라도 발행됐으면 거절한다 — 판 번호로', () => {
@@ -104,3 +105,13 @@ describe('문이 이 규칙을 지난다', () => {
     expect(/class FigurePatch \{[\s\S]{0,400}type\?: string/.test(type)).toBe(true)
   })
 })
+
+describe('a type being set keeps the shape the modeller asks for (Q-D3, designer 2026-09-27)', () => {
+  const free = { version: 0, hasHistory: false, takenByAnother: false }
+  it.each(['lower_case', 'X1', 'A'.repeat(33), '1ABC', 'AB-CD', 'AB__CD', '한글'])('refuses %s as malformed', wanted => {
+    expect(() => renameDraftType({ type: 'OLD', source: '{}' }, wanted, free)).toThrow(expect.objectContaining({ code: 'malformed-type' }))
+  })
+  it.each(['FIG_K3F9A2', 'CONVEYOR', 'LIFT_TABLE_2'])('takes %s', wanted => {
+    expect(renameDraftType({ type: 'OLD', source: '{}' }, wanted, free).type).toBe(wanted)
+  })
+})

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

@@ -1,3 +1,4 @@
+import { TYPE_LENGTH, TYPE_PATTERN } from '@hatiolab/figure-model'
 /**
  * 초안의 타입을 고치는 규칙 — ADR-0063 결정 4.
  *
@@ -32,7 +33,7 @@ export interface RenameFacts {
 
 export class FigureRenameRefused extends Error {
   constructor(
-    readonly code: 'empty-type' | 'already-released' | 'type-taken',
+    readonly code: 'empty-type' | 'malformed-type' | 'already-released' | 'type-taken',
     message: string
   ) {
     super(message)
@@ -57,6 +58,17 @@ export function renameDraftType(
     throw new FigureRenameRefused('empty-type', 'type 이 비어 있다 — 도면에 적히는 이름이라 비울 수 없다')
   }
 
+  /*
+    The shape the modeller has always asked for, now asked here too (designer 2026-09-27, Q-D3): only a type being set
+    is held to it -- every type in the development data already keeps it (56 of 56, 2026-09-27), and none is renamed.
+  */
+  if (!TYPE_PATTERN.test(next) || next.length < TYPE_LENGTH.min || next.length > TYPE_LENGTH.max) {
+    throw new FigureRenameRefused(
+      'malformed-type',
+      `type 「${next}」 는 대문자로 시작하고 대문자·숫자·밑줄만 쓰며 ${TYPE_LENGTH.min}~${TYPE_LENGTH.max}자여야 한다`
+    )
+  }
+
   if ((facts.version ?? 0) > 0 || facts.hasHistory) {
     throw new FigureRenameRefused(
       'already-released',

package/server/service/figure/figure-replaced-draft.ts

@@ -0,0 +1,90 @@
+import { Column, CreateDateColumn, Entity, Index, ManyToOne, PrimaryGeneratedColumn, RelationId } from 'typeorm'
+import { Field, ID, Int, ObjectType } from 'type-graphql'
+
+import { User } from '@things-factory/auth-base'
+import { Domain, longTextColumn } from '@things-factory/shell'
+
+/**
+ * A figure's draft as it stood before a revert wrote over it -- kept, so what was saved just before a revert can be
+ * brought back, after a reload too (ADR-0097 §5.6, designer 2026-09-27; table chosen with the chief architect).
+ *
+ * Not a released version: it has no version number of its own, is not listed with the releases, and never changes
+ * what a board uses. Kept in the same transaction as the revert that replaces the draft -- kept, or neither happens.
+ * `requestId` makes a retried revert (its answer lost) the same revert, not a second one.
+ *
+ * An undo of a revert is a revert too (`kind: 'undo'`): it keeps what it replaces the same way.
+ */
+@Entity()
+@Index('ix_figure_replaced_draft_1', (kept: FigureReplacedDraft) => [kept.domain, kept.requestId], { unique: true })
+@Index('ix_figure_replaced_draft_2', (kept: FigureReplacedDraft) => [kept.domain, kept.figureId])
+@ObjectType({ description: 'A figure draft kept when a revert wrote over it. Not a released version.' })
+export class FigureReplacedDraft {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID, { description: 'Unique identifier of the kept draft.' })
+  readonly id?: string
+
+  @ManyToOne(type => Domain)
+  domain?: Domain
+
+  @RelationId((kept: FigureReplacedDraft) => kept.domain)
+  domainId?: string
+
+  @Column()
+  @Field({ description: 'The figure whose draft this was.' })
+  figureId?: string
+
+  @Column({ default: 'revert' })
+  @Field({ description: "What replaced it: 'revert' (a released version written over it) or 'undo' (an undo of a revert)." })
+  kind?: 'revert' | 'undo'
+
+  @Column({ nullable: true, ...longTextColumn() })
+  @Field({ nullable: true, description: 'The figure asset JSON the draft held.' })
+  source?: string
+
+  @Column({ nullable: true, ...longTextColumn() })
+  properties?: string
+
+  @Column({ nullable: true, ...longTextColumn() })
+  thumbnail?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'The state the figure was in.' })
+  state?: string
+
+  @Column({ nullable: true })
+  @Field(type => Int, { nullable: true, description: 'The released version number the figure had then.' })
+  version?: number
+
+  @Column({ nullable: true })
+  @Field(type => Int, { nullable: true, description: 'The released version the revert wrote over it; none for an undo.' })
+  revertedToVersion?: number
+
+  /* What replaced it, whole: an undo proceeds only while the figure still holds exactly this (compare-and-swap). */
+  @Column({ nullable: true, ...longTextColumn() })
+  writtenSource?: string
+
+  /* Its content hash, for finding and retrying without reading the whole text (chief architect, 2026-09-27). */
+  @Column()
+  writtenSourceHash?: string
+
+  @Column()
+  requestId?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'When this draft was brought back by an undo.' })
+  restoredAt?: Date
+
+  @Column({ nullable: true })
+  restoreRequestId?: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true, description: 'When it was kept -- when the revert replaced it.' })
+  createdAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true, description: 'Who reverted.' })
+  creator?: User
+
+  @RelationId((kept: FigureReplacedDraft) => kept.creator)
+  creatorId?: string
+}