@things-factory/headless-twin 10.1.278 → 10.1.280

package/test/mirror-resumes-from-checkpoint.test.ts

@@ -1,192 +0,0 @@
-/*
- * ★ **재기동이 저널을 처음부터 다시 계산하지 않는다** — 미러가 저장된 재개점에서 이어 선다.
- *
- * ── 무엇이 오래 잘못돼 있었나 (2026-08-24 실측) ─────────────────────────────
- * 재개점을 **읽는** 쪽은 다 있었다: `recover` 는 `fold` 가 있으면 꼬리만 계산하고, 없으면 저널을 0부터
- * 계산한다. 그런데 **쓰는 쪽이 없었다** — `persistSnapshot` 은 `{revision, state, structureRev}` 만
- * 적었다. 실측으로 저장된 스냅샷 34건 전부 `fold` 가 비어 있었고, 저널은 2,960만 줄이었다.
- *
- * 그래서 두 가지가 함께 일어났다.
- *
- *   ① 켤 때마다 처음부터 계산했다 — 규모 기준(엔티티 10만·품목 100만)에서 느린 것이 아니라 못 하는 것이다
- *   ② 미러는 되찾은 상태를 **버렸다**(`startLive`). 「다음 계측이 정정한다」는 전제였는데, 원본이 커서
- *      증분으로 말하는 현장에서는 그 정정이 오지 않는다 — 미러가 영구히 빈 채로 남고 화면은 들어온 것이 없었다
- *
- * ── 왜 커널 시험만으로 충분하지 않나 ────────────────────────────────────────
- * 커널은 「재개점 + 꼬리 == 0부터 계산하기」를 증명한다(`observed-checkpoint.test.ts`). 그것이 참이어도
- * 호스트가 재개점을 **적지 않거나 되세우지 않으면** 아무 일도 일어나지 않는다 — 이 저장소가 실제로
- * 넉 달 동안 그 상태였다. 그래서 여기서 DB 를 물고 실제로 걷는다.
- *
- * ── 결정적인 단정 ───────────────────────────────────────────────────────────
- * 재기동 전에 **저널을 지운다.** 그래도 상태가 돌아오면 그것은 저널을 계산해 온 것이 **아니다** —
- * 저장된 재개점에서 온 것이다. 그리고 그 상황은 가정이 아니라 설계된 거동이다: 보존 정책이 체크포인트
- * 리비전 이하의 행을 지운다(「그 앞은 스냅샷이 대신한다」).
- */
-import { test, before, after } from 'node:test'
-import assert from 'node:assert/strict'
-import { createRequire } from 'node:module'
-import type { DataSource } from 'typeorm'
-
-const req = createRequire(import.meta.url)
-const { NamingStrategy, addDataSource, entities: shellEntities, Domain } = req('@things-factory/shell')
-const { entities: authEntities } = req('@things-factory/auth-base')
-const { entities: twinEntities } = req('../dist-server/service/index.js')
-/* 체크포인트는 `cache-service` 표에 앉는다 — 그 엔티티를 빼면 저장이 알리지 않고 실패한다(스냅샷도 씨앗도). */
-const { entities: cacheEntities } = req('@things-factory/cache-service/dist-server/service/index.js')
-const { TwinEngine } = req('../dist-server/engine/index.js')
-const { TwinEvent } = req('../dist-server/service/twin-event/twin-event.js')
-const { DataSource: TypeOrmDataSource } = req('typeorm')
-
-let ds: DataSource
-let domainId: string
-
-const INSTANCE = 'resume-probe'
-
-/** 미러 하나 — 원본이 사실을 말해 주는 트윈이므로 시나리오도 레시피도 필요 없다. */
-const master = (): any => ({
-  source: INSTANCE,
-  system: 'wms',
-  siteName: '재개점 창고',
-  origin: { kind: 'reference' }, // 현실 출처 선언 — 이것이 미러로 뜨는 근거다
-  space: { width: 40, depth: 20, unit: 'm' },
-  locations: [
-    { id: 'dock', type: 'dock', role: 'location', capacity: 100 },
-    { id: 'bin-1', type: 'storage', role: 'location', capacity: 100 }
-  ],
-  equipment: [{ id: 'fk-1', kind: 'forklift', homeLocationId: 'dock' }]
-})
-
-/** 원본이 말한 사실 — 오더와 작업. 미러는 이것을 계산해 상태를 만든다. */
-function facts(n: number): any[] {
-  const out: any[] = []
-  for (let i = 1; i <= n; i++) {
-    out.push({
-      eventId: `o-${i}`,
-      eventType: 'order.status',
-      eventTime: '2026-08-24T01:00:00.000Z',
-      tenantId: domainId,
-      data: { orderId: `WO-${i}`, kind: 'workorder', status: 'in-progress', requested: 10, fulfilled: 3 }
-    })
-    out.push({
-      eventId: `t-${i}`,
-      eventType: 'task.status',
-      eventTime: '2026-08-24T01:00:01.000Z',
-      tenantId: domainId,
-      data: {
-        taskId: `TK-${i}`,
-        kind: 'putaway',
-        status: 'in-progress',
-        orderId: `WO-${i}`,
-        fromNode: 'dock',
-        toNode: 'bin-1',
-        intent: 'transport',
-        durationMs: 60000,
-        remainingMs: 30000
-      }
-    })
-  }
-  return out
-}
-
-const observed = (s: any): number => (s?.items?.length ?? 0) + (s?.orders?.length ?? 0) + (s?.tasks?.length ?? 0)
-
-before(async () => {
-  ds = new TypeOrmDataSource({
-    type: 'sqlite',
-    database: ':memory:',
-    synchronize: true,
-    dropSchema: true,
-    namingStrategy: new NamingStrategy(),
-    entities: [...shellEntities, ...authEntities, ...twinEntities, ...cacheEntities],
-    logging: false
-  })
-  await ds.initialize()
-  addDataSource('default', ds)
-  const d = await ds.getRepository(Domain).save({ name: 'resume-test', subdomain: 'resume-test' } as any)
-  domainId = d.id
-  await TwinEngine.ingestMaster(domainId, master(), 'reset')
-})
-
-after(async () => {
-  await TwinEngine.stop(domainId, INSTANCE).catch(() => {})
-  await ds?.destroy()
-})
-
-test('체크포인트가 **이어 계산할 씨앗을 함께 적는다** — 이 줄이 없어서 넉 달 동안 처음부터 계산했다', async () => {
-  const rt = await TwinEngine.bootDeclared(domainId, INSTANCE, 'resync')
-  assert.equal(rt.mode, 'live', '미러로 떠야 이 검사가 뜻이 있다')
-
-  const applied = TwinEngine.ingestLive(domainId, INSTANCE, facts(5))
-  assert.equal(applied, 10, '원본이 말한 사실이 커널에 들어갔다')
-  const before = TwinEngine.snapshot(domainId, INSTANCE)
-  assert.ok(observed(before) > 0, `상태에 사실이 있어야 이 검사가 뜻이 있다 (실제 ${observed(before)})`)
-
-  await TwinEngine.persistSnapshot(domainId, INSTANCE)
-  const stored = await TwinEngine.loadSnapshot(domainId, INSTANCE)
-  assert.ok(stored, '스냅샷이 저장됐다')
-  assert.ok(stored.fold?.reducer, '★ 재개점이 함께 적혀야 한다 — 없으면 다음 기동이 저널을 0부터 계산한다')
-  assert.ok(stored.fold?.oee, '가동 누적기도 함께 — 상태만 되돌리면 가동률이 부팅 이후로만 잡힌다')
-  /* 씨앗이 실제로 사실을 들었는지 — 빈 껍데기를 적어 두고 초록이 되지 않게. */
-  assert.ok((stored.fold.reducer as any).orders?.length, '씨앗에 오더가 담겨 있다')
-  assert.ok((stored.fold.reducer as any).tasks?.length, '씨앗에 작업이 담겨 있다')
-})
-
-test('★ 저널을 지워도 미러가 상태를 들고 다시 선다 — 그러므로 저널을 계산한 것이 아니다', async () => {
-  /*
-   * 이 단정이 이 축의 전부다. 저널이 없는데 상태가 돌아오면 그 상태는 **저장된 재개점**에서 온 것이다.
-   * 그리고 이 상황은 가정이 아니다 — 보존 정책이 체크포인트 리비전 이하의 행을 실제로 지운다.
-   */
-  const before = observed(TwinEngine.snapshot(domainId, INSTANCE))
-  assert.ok(before > 0, '멈추기 전에 상태가 있어야 이 검사가 뜻이 있다')
-
-  await TwinEngine.stop(domainId, INSTANCE)
-  /* 이 인스턴스의 저널만 — 정확한 소유 표식으로 지운다. */
-  await ds.getRepository(TwinEvent).delete({ domain: { id: domainId } as any, instanceId: INSTANCE } as any)
-  assert.equal(
-    await ds.getRepository(TwinEvent).countBy({ domain: { id: domainId } as any, instanceId: INSTANCE } as any),
-    0,
-    '저널이 비었다 — 이제 계산할 것이 없다'
-  )
-
-  await TwinEngine.bootDeclared(domainId, INSTANCE, 'resync')
-  const after = TwinEngine.snapshot(domainId, INSTANCE)
-  assert.equal(observed(after), before, '★ 사실이 그대로 돌아왔다 — 저널 없이')
-  assert.equal(after.orders.length, 5, '오더 다섯이 그대로다')
-  assert.equal(after.tasks.length, 5, '작업 다섯이 그대로다')
-})
-
-test('되세운 뒤 들어온 사실이 앞의 것을 덮지 않는다 — 더해진다', async () => {
-  /*
-   * 미러는 첫 봉투가 올 때 리듀서를 만든다. 되돌리기가 그보다 먼저 서지 않으면 첫 봉투가 **빈 리듀서**를
-   * 만들고 되세운 것을 덮는다 — 오류 없이 상태가 사라진다.
-   */
-  const before = observed(TwinEngine.snapshot(domainId, INSTANCE))
-  TwinEngine.ingestLive(domainId, INSTANCE, [
-    {
-      eventId: 'o-new',
-      eventType: 'order.status',
-      eventTime: '2026-08-24T02:00:00.000Z',
-      tenantId: domainId,
-      data: { orderId: 'WO-NEW', kind: 'workorder', status: 'in-progress', requested: 1, fulfilled: 0 }
-    } as any
-  ])
-  const after = TwinEngine.snapshot(domainId, INSTANCE)
-  assert.equal(observed(after), before + 1, '앞의 것이 남고 새 것이 더해진다')
-  assert.ok(after.orders.some((o: any) => o.id === 'WO-1'), '되세운 오더가 남아 있다')
-  assert.ok(after.orders.some((o: any) => o.id === 'WO-NEW'), '새 오더도 있다')
-})
-
-test('씨앗이 없으면 지어내지 않는다 — 전과 같이 빈 채로 시작한다', async () => {
-  /*
-   * 처음 뜨는 트윈에는 씨앗이 없다. 여기서 무엇이든 심으면 없던 재고가 생긴다 — 그것은 이 작업이
-   * 고치려던 것보다 나쁘다.
-   */
-  const FRESH = 'resume-probe-fresh'
-  await TwinEngine.ingestMaster(domainId, { ...master(), source: FRESH }, 'reset')
-  try {
-    await TwinEngine.bootDeclared(domainId, FRESH, 'resync')
-    assert.equal(observed(TwinEngine.snapshot(domainId, FRESH)), 0, '아무것도 듣지 못했으므로 비어 있다')
-  } finally {
-    await TwinEngine.stop(domainId, FRESH).catch(() => {})
-  }
-})

package/test/model-basis.test.ts

@@ -1,141 +0,0 @@
-/*
- * 모델 근거 비교 — **배운 모델에만 보정을 적용하기 위한 관문.**
- *
- * 배경: 예측 출력 보정(P3.2)은 "그때 모델이 이만큼 치우쳐 있다" 를 배운다. 소요시간 추정기(실측·거리)
- * 와 공정 명세가 들어오면서 모델 자체가 바뀔 수 있게 됐고, 그러면 옛 편향을 그대로 밀어 주는 **이중
- * 보정**이 생긴다. 근거가 달라졌으면 적용하지 않는다(그리고 그 사실을 응답에 싣는다).
- *
- * 비교를 **상대 허용오차**로 하는 이유: 양자화 지문은 버킷 경계에 걸린 값이 1초 드리프트로도 달라져
- * "작은 드리프트로 학습을 무효화하지 않는다" 는 목적을 경계에서 못 지킨다. 비율은 어디서든 같다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { BASIS_TOLERANCE, describeModelBasis, modelBasisChanged, toleranceOf } from '../server/engine/model-basis.ts'
-
-test('같은 근거면 바뀌지 않았다 — 키 순서에 흔들리지 않는다', () => {
-  assert.equal(
-    modelBasisChanged({ measured: { pick: 22_000, putaway: 47_000 } }, { measured: { putaway: 47_000, pick: 22_000 } }),
-    false
-  )
-})
-
-test('작은 드리프트는 같은 모델 — 경계에서도 성립한다(버킷이 아니라 비율)', () => {
-  /* 47.0 → 47.9 (약 1.9%): 5초 버킷이면 45↔50 으로 갈렸을 값이다. */
-  assert.equal(modelBasisChanged({ measured: { putaway: 47_000 } }, { measured: { putaway: 47_900 } }), false)
-  /* 허용오차 경계 바로 아래·위 */
-  assert.equal(modelBasisChanged({ measured: { p: 100_000 } }, { measured: { p: 105_000 } }), false, '5%')
-  assert.equal(modelBasisChanged({ measured: { p: 100_000 } }, { measured: { p: 130_000 } }), true, '30%')
-})
-
-test('실측이 실제로 달라지면 다른 모델 — 30초 작업이 47초가 되면 옛 보정은 무효', () => {
-  assert.equal(modelBasisChanged({ measured: { putaway: 30_000 } }, { measured: { putaway: 47_000 } }), true)
-})
-
-test('새로 배운 종류·사라진 종류는 다른 모델 — 값이 없다가 생긴 것도 변화다', () => {
-  assert.equal(modelBasisChanged({ measured: { pick: 20_000 } }, { measured: { pick: 20_000, putaway: 47_000 } }), true)
-  assert.equal(modelBasisChanged({ measured: { pick: 20_000, putaway: 47_000 } }, { measured: { pick: 20_000 } }), true)
-})
-
-test('속도가 바뀌면 다른 모델 — 이동시간 모델이 바뀐 것이다', () => {
-  assert.equal(modelBasisChanged({ speeds: { forklift: 2 } }, { speeds: { forklift: 4 } }), true)
-  assert.equal(modelBasisChanged({ speeds: { forklift: 2 } }, { speeds: { forklift: 2.05 } }), false)
-})
-
-test('선언 명세가 바뀌면 다른 모델 — 표기 원문을 그대로 비교한다', () => {
-  assert.equal(
-    modelBasisChanged({ declared: [{ key: 'cut', duration: 'PT25M' }] }, { declared: [{ key: 'cut', duration: 'PT30M' }] }),
-    true
-  )
-  assert.equal(
-    modelBasisChanged({ declared: [{ key: 'cut', duration: 'PT25M' }] }, { declared: [{ key: 'cut', duration: 'PT25M' }] }),
-    false
-  )
-})
-
-test('소요 없는 선언은 모델을 바꾸지 않는다', () => {
-  assert.equal(modelBasisChanged({ declared: [{ key: 'cut' }] }, { declared: [] }), false)
-})
-
-test('뜻 없는 값은 근거가 아니다 — 0·음수·NaN 은 무시한다', () => {
-  assert.equal(modelBasisChanged({ measured: { pick: 0 } }, {}), false)
-  assert.equal(modelBasisChanged({ measured: { pick: NaN } }, { speeds: { f: -1 } }), false)
-})
-
-test('한쪽 근거를 모르면 판정하지 않는다 — 모르는 것을 근거로 학습을 끊지 않는다', () => {
-  assert.equal(modelBasisChanged(undefined, { measured: { pick: 20_000 } }), false)
-  assert.equal(modelBasisChanged({ measured: { pick: 20_000 } }, undefined), false)
-})
-
-test('세 재료가 섞이지 않는다 — 같은 이름이 다른 재료에 있으면 다른 모델', () => {
-  assert.equal(modelBasisChanged({ measured: { x: 10_000 } }, { speeds: { x: 10_000 } }), true)
-})
-
-test('허용오차는 조절 가능하고 기본값이 명시돼 있다', () => {
-  assert.equal(BASIS_TOLERANCE, 0.1)
-  assert.equal(modelBasisChanged({ measured: { p: 100 } }, { measured: { p: 130 } }, 0.5), false, '느슨하게 주면 같은 모델')
-})
-
-test('사람이 읽는 요약을 낸다 — 로그에서 왜 달라졌는지 눈으로 본다', () => {
-  const d = describeModelBasis({ measured: { putaway: 47_000 }, speeds: { forklift: 2 }, declared: [{ key: 'cut', duration: 'PT25M' }] })
-  assert.match(d, /measured\(putaway=47s\)/)
-  assert.match(d, /speed\(forklift=2m\/s\)/)
-  assert.match(d, /declared\(cut=PT25M\)/)
-  assert.equal(describeModelBasis({}), 'kernel defaults only')
-  assert.equal(describeModelBasis(undefined), 'unknown')
-})
-
-/*
- * ★ 허용오차는 **그 공정이 선언한 변동폭에서 나온다.**
- *
- * 단일 10% 잣대는 두 방향으로 틀렸다. 우리 트레일러 템플릿의 용접은 변동폭을 `PT55M~PT1H35M`
- * (선언 소요 `PT1H10M` 기준 −21%~+36%)로 스스로 선언한다 — 10% 관문은 그 공정의 **정상 변동조차**
- * "다른 모델" 로 판정해 보정을 끊는다. 반대로 1% 변동도 치명적인 공정에는 10% 가 너무 느슨하다.
- *
- * 도메인 설정을 새로 만들지 않는다: 얼마나 흔들리는 것이 정상인지는 **현장이 이미 선언했다.**
- */
-const weld = (durationMs: number) => ({
-  measured: { weld: durationMs },
-  declared: [{ key: 'weld', duration: 'PT1H10M', variability: { distribution: 'triangular', min: 'PT55M', max: 'PT1H35M', mode: 'PT1H5M' } }]
-})
-
-test('선언된 변동폭 안의 흔들림은 같은 모델이다 — 10% 잣대는 정상 변동을 끊었다', () => {
-  const base = 70 * 60_000 // PT1H10M
-  /* 반폭 = (95분 − 55분)/2 / 70분 ≈ 28.6%. 20% 흔들림은 그 안이다 — 예전 잣대(10%)로는 끊겼다. */
-  assert.equal(modelBasisChanged(weld(base), weld(base * 1.2)), false, '정상 변동으로 학습이 무효화되면 안 된다')
-  /* 변동폭이 실제로 허용오차로 읽히는지 — 반폭 ≈ 28.6%. 이 값이 안 나오면 위 단언이 우연히 통과한다. */
-  const tol = toleranceOf(weld(base).declared).weld
-  assert.ok(tol > 0.28 && tol < 0.29, `선언에서 읽은 허용오차가 ${tol} 다`)
-})
-
-test('선언된 변동폭을 넘으면 다른 모델이다 — 넓혔다고 아무 변화나 삼키지 않는다', () => {
-  const base = 70 * 60_000
-  assert.equal(modelBasisChanged(weld(base), weld(base * 1.6)), true, '60% 변화는 정상 변동이 아니다')
-})
-
-test('정밀 공정은 더 좁게 판정한다 — 1% 변동이 치명적인 현장이 있다', () => {
-  const precise = (ms: number) => ({
-    measured: { grind: ms },
-    declared: [{ key: 'grind', duration: 'PT10M', variability: { distribution: 'uniform', min: 'PT9M54S', max: 'PT10M6S' } }]
-  })
-  const base = 10 * 60_000
-  /* 반폭 = 6초/10분 = 1%. 5% 흔들림은 이 공정에서 다른 모델이다 — 단일 10% 잣대는 삼켰다. */
-  assert.equal(modelBasisChanged(precise(base), precise(base * 1.05)), true, '느슨한 잣대가 정밀 공정의 변화를 삼켰다')
-  assert.equal(modelBasisChanged(precise(base), precise(base * 1.005)), false, '선언한 변동폭 안은 같은 모델이다')
-})
-
-test('선언이 침묵하면 기본값으로 떨어진다 — 없는 것을 지어내지 않는다', () => {
-  const quiet = (ms: number) => ({ measured: { pack: ms }, declared: [{ key: 'pack', duration: 'PT5M' }] })
-  const base = 5 * 60_000
-  assert.equal(modelBasisChanged(quiet(base), quiet(base * 1.05)), false, '기본 10% 안')
-  assert.equal(modelBasisChanged(quiet(base), quiet(base * 1.3)), true, '기본 10% 밖')
-})
-
-test('변동폭이 바뀌면 다른 모델이다 — 판정의 잣대가 알리지 않고 바뀌지 않게', () => {
-  const a = weld(70 * 60_000)
-  const b = {
-    measured: { weld: 70 * 60_000 },
-    declared: [{ key: 'weld', duration: 'PT1H10M', variability: { distribution: 'triangular', min: 'PT30M', max: 'PT3H', mode: 'PT1H5M' } }]
-  }
-  assert.equal(modelBasisChanged(a, b), true, '변동폭 선언이 바뀌었는데 같은 모델이라고 하면 잣대가 오류 없이 바뀐다')
-})

package/test/model-gap.test.ts

@@ -1,153 +0,0 @@
-/*
- * ★ 「원본이 말한 적 없는 것」을 세는 규율.
- *
- * ── 왜 이것이 필요한가 (2026-08-20 실측) ────────────────────────────────────
- * 동기화 건강 기능을 만들 때 제가 전제를 이렇게 적었다: *「커넥터의 매핑이 한 글자 틀리면 트윈은
- * 빈 공장이 된다」*. 사용자가 그 전제를 검증하게 해서 재 봤더니, 유입 문은 참조 오류를 **거부하지
- * 않았다**:
- *
- *   모르는 로케이션 「오타-99」     → 통과
- *   모르는 bizStep 「PUTAWAY_X17」 → 통과
- *   모르는 계량기 「MMXU-오타-99」  → 통과
- *
- * 즉 그 기능이 잡겠다고 내세운 대표 사례가 `mapping-blocked` 로는 **뜰 수 없었다.** 거부되는 것은
- * 형태 오류뿐이다(시각 형식·숫자 아닌 값·epc 없음).
- *
- * 거부하지 않는 것이 옳다 — 원천이 모델보다 먼저 새 로케이션을 말하는 것은 정상이고, 거부하면 그 선행
- * 계측을 잃는다. 커널은 흡수하고 **표시한다**(`origin: 'observed'`). 빠져 있던 것은 그 표시를
- * 「맞춰지고 있나」를 보는 사람에게 잇는 일이었다.
- *
- * ── 지키는 것 ───────────────────────────────────────────────────────────────
- * ① 마스터가 말한 것과 관측으로 알게 된 것을 섞지 않는다
- * ② 트윈이 안 돌면 `null` — 「없다」와 「세어 보지 못했다」는 다르다
- * ③ 알리지 않고 자르지 않는다 — 상한에서 밀려난 수를 함께 낸다
- * ④ 덮지 못하는 축을 밝힌다 — 계량기는 커널이 표시를 달지 않아 이 화면이 못 찾아 준다
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { GAP_ID_LIMIT, modelGapOf } from '../server/engine/model-gap.ts'
-
-const loc = (id: string, origin: string) => ({ id, origin })
-
-test('마스터가 말한 로케이션은 갭이 아니다 — 선언된 것을 문제로 세지 않는다', () => {
-  const g = modelGapOf({
-    locations: [loc('dock-recv', 'master'), loc('bin-1', 'master')],
-    equipment: [loc('fk-1', 'master')]
-  })
-
-  assert.equal(g!.total, 0)
-  assert.deepEqual(g!.locations.ids, [])
-})
-
-test('관측으로만 알게 된 것을 축마다 센다 — 원천이 우리가 모르는 id 를 보내고 있다', () => {
-  const g = modelGapOf({
-    locations: [loc('dock-recv', 'master'), loc('오타-99', 'observed'), loc('A-77', 'observed')],
-    equipment: [loc('fk-1', 'master'), loc('없는-지게차', 'observed')],
-    persons: [loc('unknown-op', 'observed')]
-  })
-
-  assert.equal(g!.locations.count, 2)
-  assert.equal(g!.locations.unknown, 0, '표시가 다 있으면 모름은 0')
-  assert.deepEqual(g!.locations.ids, ['오타-99', 'A-77'], 'id 를 보여 준다 — 오타는 눈으로 찾는다')
-  assert.equal(g!.equipment.count, 1)
-  assert.equal(g!.persons.count, 1)
-  assert.equal(g!.total, 4, '세 축의 합')
-})
-
-test('트윈이 안 돌면 「없음」이다 — 0 이 아니다', () => {
-  /* 비교할 상대가 없다. 0 으로 답하면 「원천이 우리가 아는 것만 보낸다」는 없는 사실이 생긴다. */
-  assert.equal(modelGapOf(null), null)
-  assert.equal(modelGapOf(undefined), null)
-})
-
-test('돌지만 관측 갭이 없으면 0 이다 — 이건 「없음」과 다르다', () => {
-  const g = modelGapOf({ locations: [] })
-
-  assert.notEqual(g, null, '세어 봤다')
-  assert.equal(g!.total, 0, '세어 보니 없었다')
-})
-
-test('id 를 알리지 않고 자르지 않는다 — 밀려난 수를 함께 낸다', () => {
-  const many = Array.from({ length: GAP_ID_LIMIT + 7 }, (_, i) => loc(`ghost-${i}`, 'observed'))
-  const g = modelGapOf({ locations: many })
-
-  assert.equal(g!.locations.count, GAP_ID_LIMIT + 7, '전부 센다')
-  assert.equal(g!.locations.ids.length, GAP_ID_LIMIT, '보이는 것은 상한까지')
-  assert.equal(g!.locations.more, 7, '밀려난 수를 말한다')
-})
-
-test('커널이 담을 줄 모른 사건을 함께 낸다 — 참조 문제와 다른 사실이다', () => {
-  const at = Date.parse('2026-08-20T01:02:03.000Z')
-  const g = modelGapOf({
-    unhandled: [
-      { eventType: 'epcis.TransformationEvent', count: 12, lastAtMs: at },
-      { eventType: 'aggregation-mixed-classes', count: 3 }
-    ]
-  })
-
-  assert.equal(g!.unhandled.length, 2)
-  assert.equal(g!.unhandled[0].lastAt, '2026-08-20T01:02:03.000Z', '언제까지 났는지 — 멈춘 종류는 고쳐진 것이다')
-  assert.equal(g!.unhandled[1].lastAt, null, '시각이 없으면 지어내지 않는다')
-})
-
-test('모르는 설비의 에너지 보고는 「없음」과 0 을 가른다 — 경로가 `energy` 안이다', () => {
-  /*
-   * 이 값을 **루트에서 읽고 있었다**(2026-08-20에 잡음). 커널은 `EnergyState` 안에 담으므로 루트에서
-   * 읽으면 영원히 `null` 이고, 오류 없이 「에너지 트윈이 아니다」로 읽힌다. 나만 읽는 필드를 잘못된
-   * 경로에서 읽으면 이렇게 오류 없이 사라진다.
-   *
-   * 그리고 커널은 0 이면 그 칸을 만들지 않는다. 그래서 `energy` 자체가 있는지로 「세었고 0」과
-   * 「에너지 트윈이 아님」을 가른다.
-   */
-  assert.equal(modelGapOf({})!.unknownEquipmentReports, null, '에너지 트윈이 아니면 이 수가 없다')
-  assert.equal(modelGapOf({ energy: { points: [] } })!.unknownEquipmentReports, 0, '에너지 트윈이면 세었고 0 이다')
-  assert.equal(modelGapOf({ energy: { unknownEquipment: 41 } })!.unknownEquipmentReports, 41)
-  assert.equal(
-    modelGapOf({ unknownEquipment: 41 } as any)!.unknownEquipmentReports,
-    null,
-    '루트에 있는 값을 집지 않는다 — 그 경로는 커널의 것이 아니다'
-  )
-})
-
-test('계량기도 덮는다 — 이 축이 가장 무겁다', () => {
-  /*
-   * 모르는 `meterId` 는 알리지 않고 새 계량기가 되고 그 kW 가 그 현장의 수요·피크·요금 판정에 더해진다.
-   * 로케이션 오타는 스키매틱이 비는 것으로 드러나지만, 이건 **그럴듯한 숫자**로 나온다.
-   * 커널 0.7.39 가 `MeterPointState.origin` 을 내면서 덮을 수 있게 됐다.
-   */
-  const g = modelGapOf({
-    energy: { points: [loc('main-incoming', 'master'), loc('MMXU-오타-99', 'observed')] }
-  })
-
-  assert.equal(g!.meters.count, 1)
-  assert.deepEqual(g!.meters.ids, ['MMXU-오타-99'])
-  assert.equal(g!.total, 1, '계량기도 합에 든다')
-  assert.deepEqual(g!.notCovered, [], '덮지 못하는 축이 없다')
-})
-
-test('표시가 없는 항목은 「선언됨」이 아니라 「모름」으로 센다', () => {
-  /*
-   * 계량기의 `origin` 은 늦게 생긴 칸이라, 옛 스냅샷에서 이어받은 지점에는 없다(`undefined`).
-   * 마스터로 세면 오타를 놓치고, 관측으로 세면 정상을 문제로 만든다. 둘 다 틀리다.
-   */
-  const g = modelGapOf({
-    energy: { points: [{ id: 'carried-over' }, loc('main', 'master'), loc('ghost', 'observed')] }
-  })
-
-  assert.equal(g!.meters.unknown, 1, '표시 없는 것은 모름')
-  assert.equal(g!.meters.count, 1, '관측 갭에 섞이지 않는다')
-  assert.ok(!g!.meters.ids.includes('carried-over'), '모르는 것을 오타로 지목하지 않는다')
-})
-
-test('`origin` 은 「지금 모델에 있는가」의 답이다 — 채택되면 갭에서 빠진다', () => {
-  /*
-   * 커널이 표본마다 다시 맞춘다. 한 번 찍고 두면 나중에 선언된 계량기가 영원히 `observed` 로 남는다.
-   * 그래서 채택 뒤 스냅샷에서는 같은 id 가 `master` 로 오고, 이 도출은 그것을 그대로 따른다.
-   */
-  const before = modelGapOf({ energy: { points: [loc('new-meter', 'observed')] } })
-  const after = modelGapOf({ energy: { points: [loc('new-meter', 'master')] } })
-
-  assert.equal(before!.meters.count, 1)
-  assert.equal(after!.meters.count, 0, '모델에 들어오면 갭이 아니다')
-})

package/test/model-refusal.test.ts

@@ -1,75 +0,0 @@
-/*
- * ★ A twin model the kernel refuses reaches the reader as a named refusal, not INTERNAL_SERVER_ERROR.
- *
- * 2026-10-10: `twinReplay(miratek)` failed with the MES kernel's English sentence "MES twin requires a
- * production declaration" in the shell's global notice. The kernel now names it
- * (`twin-model-no-production-spec`, with `params`); the engine turns a named kernel error into a shell
- * `Refusal` wherever it loads or replays a model, and the resolvers that reach those places speak it.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { Refusal, speakRefusal } from '@things-factory/shell'
-import { asModelRefusal, refusingModel } from '../server/engine/model-refusal.ts'
-
-/* The shape the kernel throws (`MesKernel.loadTwinModel`, twin-kernel 02f117f). */
-function kernelRefusal(): Error {
-  return Object.assign(new Error('MES twin requires a production declaration (ProductionSpec): …'), {
-    code: 'twin-model-no-production-spec',
-    params: {}
-  })
-}
-
-test('a named kernel error becomes a Refusal that says which twin', () => {
-  const r = asModelRefusal(kernelRefusal(), 'miratek')
-  assert.ok(r instanceof Refusal)
-  assert.equal((r as Refusal).code, 'twin-model-no-production-spec')
-  assert.deepEqual((r as Refusal).params, { instanceId: 'miratek' })
-  assert.match((r as Refusal).message, /requires a production declaration/, 'the English sentence stays as the fallback')
-})
-
-test('an error without a name passes through untouched', () => {
-  const plain = new Error('boom')
-  assert.equal(asModelRefusal(plain, 'x'), plain)
-  const codeOnly = Object.assign(new Error('x'), { code: 'ENOENT' })
-  assert.equal(asModelRefusal(codeOnly, 'x'), codeOnly, 'a code without params is a system error, not a refusal')
-  assert.throws(() => refusingModel('x', () => { throw plain }), e => e === plain)
-})
-
-test('spoken, it is a refusal in the reader language under error.<code>', () => {
-  let askedKey = ''
-  const t = (key: string, opts?: any) => ((askedKey = key), `${opts.instanceId}: no production declaration`)
-  const spoken = speakRefusal(asModelRefusal(kernelRefusal(), 'miratek') as Refusal, { t })
-  assert.equal(askedKey, 'error.twin-model-no-production-spec')
-  assert.equal(spoken.message, 'miratek: no production declaration')
-  assert.equal(spoken.extensions.code, 'BAD_USER_INPUT', 'not INTERNAL_SERVER_ERROR')
-  assert.deepEqual(spoken.extensions.refusal, { code: 'twin-model-no-production-spec', params: { instanceId: 'miratek' } })
-})
-
-const ENGINE = readFileSync(new URL('../server/engine/twin-engine.ts', import.meta.url), 'utf8')
-
-test('every place the engine loads or replays a model goes through refusingModel', () => {
-  const code = ENGINE.split('\n').filter(l => !/^\s*(\*|\/\/|\/\*)/.test(l))
-  const roads = code.filter(l => /\.loadTwinModel\(|\breplay(From|WithCheckpoint|Segments)?\(/.test(l))
-  assert.ok(roads.length >= 3, 'the engine still loads models somewhere')
-  for (const l of roads) {
-    /* a replay call that wraps onto the next line is inside a refusingModel opened on the line above */
-    const i = code.indexOf(l)
-    assert.ok(/refusingModel\(/.test(l) || /refusingModel\([^)]*\(\)\s*=>\s*$/.test(code[i - 1]), `not wrapped: ${l.trim()}`)
-  }
-})
-
-test('the resolvers that reach those places speak refusals', () => {
-  for (const f of [
-    'twin-journal/twin-journal-query.ts',
-    'twin-model/twin-model-query.ts',
-    'twin-model/twin-model-item-query.ts',
-    'twin-lifecycle/twin-lifecycle-mutation.ts',
-    'twin-forecast/twin-forecast-query.ts'
-  ]) {
-    const src = readFileSync(new URL(`../server/service/${f}`, import.meta.url), 'utf8')
-    assert.match(src, /@Resolver\(\)\n@UseMiddleware\(SpeakRefusals\)\nexport class/, f)
-  }
-  const ref = readFileSync(new URL('../server/service/reference/reference-resolver.ts', import.meta.url), 'utf8')
-  assert.match(ref, /e instanceof Refusal \? refusalKey\(e\.code\)/, 'the import result speaks the same key')
-})