@things-factory/headless-twin 10.1.278 → 10.1.280

package/test/live-mirror-parity.test.ts

@@ -1,286 +0,0 @@
-/*
- * ★ 라이브 미러 시임 — projector→payload vs 커널→payload (sim↔live).
- * P0(live-모드 런타임, face2-inbound-live) 디리스크. 같은 이벤트를 두 드라이버에 넣고 data(tag) payload 를 비교.
- *
- * 결론(검증됨):
- *  - 핵심 관측 상태(점유·용량·위치·아이템 = "사진에 찍힌 것")는 이벤트만으로 재구성 → sim↔live **완전 일치**.
- *  - 파생 지표(설비 OEE·location status = "계산해서 만든 통계")는 이벤트에 없음 → live 미러엔 **부재**.
- *    이는 라우팅 결함이 아니라(통로는 온전), live 에서 파생 지표를 **누가 생산하나**의 데이터원 결정 사항.
- *    (실 텔레메트리 / projector 계산 / 별도 분석 층 — face2-inbound-live §6, reference-management P3.)
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { WmsKernel, StateProjector, deriveAttentions } from '@operato/twin-kernel'
-/* OEE 공식은 계약에 있다 — 시뮬·미러·MES 셋이 같은 것을 부른다. */
-import { computeOee } from '@operato/ops-contract'
-import { masterToTwin } from '../server/service/reference/reference-master.ts'
-import { buildEntityDeltas } from '../shared/entity-delta.ts'
-import { withLiveAttentions } from '../server/engine/live-attentions.ts'
-
-const GTIN = 'urn:epc:idpat:sgtin:0614141.099999.*'
-
-const master = () => ({
-  source: 'mirror',
-  system: 'wms' as const,
-  siteName: 'M',
-  /* 이 픽스처가 식별자를 만드는 이름공간 — **픽스처마다 다르게** 둔다(같은 접두 아래에서 서로 다른
-     시험의 번호가 부딪치면 표준의 유일성 요구를 깬다, CBV 2.0 §8.2.4). 커널은 선언 없이 팔레트·문서를
-     만들지 않는다(0.7.45 에서 날조 프리픽스를 지웠다). */
-  identity: { namespaces: ['https://twin.test/live-mirror-parity'] },
-  space: { width: 90, depth: 40, unit: 'm' },
-  locations: [
-    { id: 'a-dc', type: 'warehouse', role: 'area' as const, name: '창고' },
-    { id: 'dock-recv', type: 'dock', role: 'location' as const, capacity: 100 },
-    { id: 'rack-1', type: 'storage', role: 'location' as const, capacity: 60 },
-    { id: 'rack-2', type: 'storage', role: 'location' as const, capacity: 60 },
-    { id: 'staging', type: 'staging', role: 'location' as const, capacity: 80 },
-    { id: 'dock-ship', type: 'dock-ship', role: 'location' as const, capacity: 100 }
-  ],
-  equipment: [{ id: 'fk-1', kind: 'forklift', homeLocationId: 'dock-recv' }]
-})
-
-/** 커널 sim 구동 + 방출 이벤트 수집(커널 face2 테스트 패턴). */
-function runSim() {
-  const model = masterToTwin(master()).model
-  const kernel = new WmsKernel('t')
-  const events: any[] = []
-  kernel.onEvent((e: any) => events.push(e))
-  kernel.loadTwinModel(model)
-  kernel.scenario.load({ seed: 42, generators: [{ kind: 'inbound-arrival', rate: { distribution: 'constant', meanPerHour: 120 }, content: { skuMix: [{ gtin: GTIN, weight: 1 }], qtyPerLine: { min: 1, max: 1 } } }] })
-  kernel.scenario.start()
-  for (let i = 0; i < 300; i++) kernel.tick(1000)
-  kernel.scenario.pause()
-  for (let i = 0; i < 60; i++) kernel.tick(1000)
-  return { model, kernel, events }
-}
-
-const sortByTag = (arr: any[]) => [...arr].sort((a, b) => (a.tag < b.tag ? -1 : a.tag > b.tag ? 1 : 0))
-
-/** 파생/sim-계산 필드 제거 → "핵심 관측 상태"만 남긴다.
- *  location.status = 커널 기본값(파생), equipment.oee = 커널 계산 지표(파생). 이벤트에 없어 live 미러 부재. */
-/**
- * 설계상 두 구동이 다른 자리만 걷어낸다 — **여기 없는 차이는 결함이다.**
- *
- * 엔티티 마커가 `kind` → `entity` 로 바뀌었을 때(도메인 kind 를 마커가 덮어쓰던 문제) 이 필터가
- * 따라가지 못해 **아무것도 걸러내지 못하고 있었다.** 그래서 실패가 "정합성 결함" 처럼 보였다.
- *
- * 지금 남는 차이는 하나뿐이다:
- *  · `oee` — 시뮬은 자기가 계측하고, 라이브는 **호스트**가 이벤트를 적분해 채운다(withLiveOee).
- *    커널 층에서만 비대칭이고 호스트가 닫는다(커널 적합성 하네스도 같은 예외를 선언한다).
- *  · `__orders__.finished` — 「최근 T 완료」 창의 오른쪽 끝은 그 구동의 「지금」이다(ADR-0092). 시뮬은 시계,
- *    호스트의 미러는 관측 모드 커널이 마지막으로 들은 시각을 싣는다. 이 시험의 `StateProjector` 는 저널 재생용이라
- *    「지금」이 없고, 그래서 창을 싣지 않는다 — 0 으로 메우지 않는 것이 설계다. 창 수의 정합은 order-fold-host 시험이 본다.
- * (`location.status` 는 예외였다가 해소됐다 — 저장값이 아니라 포화도 파생이라 두 구동이 같은 값을 낸다.)
- */
-const coreOnly = (d: any) => {
-  const c = { ...d }
-  if (c.entity === 'equipment') delete c.oee
-  if (c.entity === 'orders') delete c.finished
-  return c
-}
-
-/** sim(커널) · live(projector 재투영) payload 를 태그로 정렬해 나란히. */
-function bothPayloads() {
-  const { model, kernel, events } = runSim()
-  assert.ok(events.length > 0, 'sim 이벤트 생성됨')
-  const proj = new StateProjector(model)
-  for (const env of events) proj.apply(env)
-  return {
-    sim: sortByTag(buildEntityDeltas(kernel.getSnapshot(), 't1')),
-    live: sortByTag(buildEntityDeltas(proj.snapshot(), 't1'))
-  }
-}
-
-test('라이브 미러: 엔티티 태그 집합 sim↔live 동일(모든 엔티티 미러)', () => {
-  const { sim, live } = bothPayloads()
-  assert.deepEqual(live.map(d => d.tag), sim.map(d => d.tag), '태그 집합 동일')
-})
-
-test('★ 라이브 미러: 핵심 관측 상태(점유·용량·위치·아이템) sim↔live 완전 일치', () => {
-  const { sim, live } = bothPayloads()
-  const simCore = sim.map(d => ({ tag: d.tag, data: coreOnly(d.data) }))
-  const liveCore = live.map(d => ({ tag: d.tag, data: coreOnly(d.data) }))
-  // 통로(라우팅)는 온전 — 이벤트로 재구성되는 관측 상태는 두 드라이버가 동일 → 모델이 동일 렌더.
-  assert.deepEqual(liveCore, simCore, 'occupancy/capacity/location/item 등 핵심 관측 상태 일치')
-})
-
-/* 고장 주입(mtbf) + 소용량 랙(병목) + 고부하 — 파생 층(attentions·oee·motion·clock)을 최대 노출. 드레인 안 함. */
-function runSimRich() {
-  const m = {
-    source: 'rich', system: 'wms' as const, siteName: 'R',
-    /* 같은 파일이라도 픽스처가 다르면 이름공간도 다르다 — 두 픽스처의 번호가 한 공간에서 겹치지 않게. */
-    identity: { namespaces: ['https://twin.test/live-mirror-parity/rich'] },
-    space: { width: 90, depth: 40, unit: 'm' },
-    locations: [
-      { id: 'a', type: 'warehouse', role: 'area' as const, name: '창고' },
-      { id: 'dock-recv', type: 'dock', role: 'location' as const, capacity: 100 },
-      { id: 'rack-1', type: 'storage', role: 'location' as const, capacity: 6 }, // 소용량 → 병목
-      { id: 'staging', type: 'staging', role: 'location' as const, capacity: 80 },
-      { id: 'dock-ship', type: 'dock-ship', role: 'location' as const, capacity: 100 }
-    ],
-    equipment: [
-      { id: 'fk-1', kind: 'forklift', homeLocationId: 'dock-recv', mtbfMs: 5000, mttrMs: 8000 }, // 고장
-      { id: 'fk-2', kind: 'forklift', homeLocationId: 'dock-recv' }
-    ]
-  }
-  const model = masterToTwin(m).model
-  const kernel = new WmsKernel('t')
-  const events: any[] = []
-  kernel.onEvent((e: any) => events.push(e))
-  kernel.loadTwinModel(model)
-  kernel.scenario.load({ seed: 7, generators: [{ kind: 'inbound-arrival', rate: { distribution: 'constant', meanPerHour: 600 }, content: { skuMix: [{ gtin: GTIN, weight: 1 }], qtyPerLine: { min: 1, max: 1 } } }] })
-  kernel.scenario.start()
-  for (let i = 0; i < 120; i++) kernel.tick(1000) // 이동중·고장·병목이 살아있는 시점
-  const proj = new StateProjector(model)
-  for (const env of events) proj.apply(env)
-  return { sim: kernel.getSnapshot() as any, live: proj.snapshot() as any }
-}
-
-/*
- * ★ 명시(완전 목록): sim 이 "계산"하는 모든 파생 층은 live 미러에 부재/부분 — 라우팅 결함 아님(관측은 미러됨).
- * live 모드는 projector(관측) + 커널 derive 함수(계산 층) 로 이 층을 복원해야 한다(P0). face2-inbound-live §6.
- */
-test('명시: 파생 층(attentions·OEE·motion·clock)은 live 미러 부재/부분 — live derive 층 필요', () => {
-  const { sim, live } = runSimRich()
-
-  // 1) attentions(주목/알람) — 모니터링 핵심. projector 미계산 → live 부재. (현재 상태 순수함수라 재계산 가능.)
-  assert.ok((sim.attentions?.length ?? 0) > 0, 'sim: attentions 계산됨(예: breakdown)')
-  assert.equal(sim.attentions.length > 0 && (live.attentions?.length ?? 0), 0, 'live: attentions 부재 — computeAttentions 를 미러 State 에 재적용해야 복원')
-
-  // 2) OEE(계산 지표) — 시간 누적. live 부재.
-  const simFk = sim.equipment.find((x: any) => x.id === 'fk-1')
-  const liveFk = live.equipment.find((x: any) => x.id === 'fk-1')
-  assert.ok(simFk?.oee, 'sim: 설비 OEE 계산됨')
-  assert.equal(liveFk?.oee, undefined, 'live: OEE 부재(시간 누적 지표)')
-
-  // 3) simClockMs(sim 클럭) — live 는 실시간이 클럭원.
-  assert.equal(typeof sim.simClockMs, 'number', 'sim: simClockMs 있음')
-  assert.equal(live.simClockMs, undefined, 'live: sim 클럭 없음(실시간이 클럭원)')
-
-  // 4) 관측 status 는 일치(이벤트 기반) — 라우팅/통로가 온전함의 재확인.
-  assert.equal(simFk?.status, liveFk?.status, 'operable status 는 sim↔live 일치(관측)')
-  // (motion 은 부분 재구성 — move 이벤트로 일부만. 완전 보간은 live derive 층 몫.)
-})
-
-/*
- * ★ derive 층 복원: sim/live 가 계산 층(deriveAttentions)을 공유 — 커널 함수를 projector 미러 State 에 재적용해
- * live 에 없던 관측기반 attentions(breakdown·bottleneck·hold)를 복원. (OEE 등 metric 층은 별도.)
- * → face2-inbound-live §1.1 "live = projector(관측) + derive 층(계산)" 을 attentions 로 실증.
- */
-test('★ derive 층: computeAttentions 를 projector 미러에 재적용 → 관측기반 attentions 복원', () => {
-  const { sim, live } = runSimRich()
-
-  // (a) 순수 함수가 커널 자체 attentions 를 재현 — 추출 정확성(sim state 로 호출 == 커널 계산 관측기반).
-  const simDerivedKinds = new Set(deriveAttentions({ equipment: sim.equipment, locations: sim.locations, orders: sim.orders }).map(a => a.kind))
-  for (const a of sim.attentions ?? []) {
-    if (['breakdown', 'bottleneck', 'hold'].includes(a.kind)) {
-      assert.ok(simDerivedKinds.has(a.kind), `순수 함수가 sim 관측기반 attention '${a.kind}' 재현`)
-    }
-  }
-
-  // (b) ★ projector 미러 State 에 재적용 → live 원본엔 없던 attentions 복원.
-  assert.equal(live.attentions?.length ?? 0, 0, 'live projector 원본엔 attentions 없음(계산 안 함)')
-  const liveKinds = new Set(deriveAttentions({ equipment: live.equipment, locations: live.locations, orders: live.orders }).map(a => a.kind))
-  assert.ok(liveKinds.has('breakdown') || liveKinds.has('bottleneck'),
-    'derive 재적용 → live 에 관측기반 attention(breakdown/bottleneck) 복원')
-})
-
-test('★ withLiveAttentions: projector 미러 스냅샷에 attentions 보강 (attention 질의 live 결선)', () => {
-  const { live } = runSimRich()
-  // 원 갭: projector 미러 스냅샷엔 attentions 없음.
-  assert.equal(live.attentions?.length ?? 0, 0, 'projector 미러엔 attentions 부재')
-  // 보강 → 스냅샷에 attentions(관측기반) 포함 → TwinEngine.snapshot(live) 이 이걸 질의에 노출.
-  const enriched = withLiveAttentions(live)
-  const kinds = new Set((enriched.attentions ?? []).map((a: any) => a.kind))
-  assert.ok(kinds.has('breakdown') || kinds.has('bottleneck'), 'withLiveAttentions → 스냅샷 attentions 보강(sim 동형)')
-})
-
-/*
- * ★ OEE derive: attentions 와 달리 OEE 입력(누적 카운터)은 관측 State·이벤트에 없다 → 미러만으론 재계산 불가.
- * 그러나 **공식 computeOee 는 sim/live 공유** — live 가 카운터(실 텔레메트리 또는 이벤트 누적기)를 공급하면 재생산.
- * 이 테스트는 공식이 공급된 카운터로 sim OEE 를 재생산함을 증명(= 입력원만 결정하면 live OEE 성립).
- */
-test('★ OEE derive: 공유 공식 computeOee 가 공급된 카운터로 OEE 재생산 (live=텔레메트리/누적기 카운터 + 공식)', () => {
-  const { sim } = runSimRich()
-  const m = sim.equipment.find((x: any) => x.oee && (x.oee.runMs > 0 || x.oee.downMs > 0)) ?? sim.equipment.find((x: any) => x.oee)
-  assert.ok(m?.oee, 'sim 무버 oee 존재')
-  const o = m.oee
-
-  /*
-   * live 텔레메트리/누적기가 공급할 카운터 + **계측 창** 으로 공식 재적용.
-   *
-   * 창을 명시한다(`metricsSinceMs: 0` 부터 `planned` 까지). 예전 이 검사는 창을 넘기지 않고 공식이
-   * 그것을 epoch(0)로 메우는 것에 **기대고** 있었다 — 그 메움이 화면에 56,000년 유휴를 세운 결함이라
-   * 없앴다. 이제 창을 모르면 잰 시간이 없으므로, 재생산에는 창이 함께 와야 한다. 라이브 공급자가
-   * 실제로 하는 일이 그것이다(누적기는 첫 이벤트 시각을 창으로 낸다).
-   */
-  const planned = o.runMs + o.setupMs + o.downMs + o.delayMs
-  const derived = computeOee(
-    { runMs: o.runMs, setupMs: o.setupMs, downMs: o.downMs, goodCount: o.goodCount, nonconformingCount: o.nonconformingCount, metricsSinceMs: 0 },
-    planned
-  )
-  /* 세 비율은 근거가 없으면 없다 — 양쪽 다 없는 것도 재생산이다(계약 0.5.0). */
-  const near = (a?: number, b?: number) => (a == null && b == null) || (a != null && b != null && Math.abs(a - b) < 1e-6)
-  assert.ok(near(derived.availability, o.availability), `availability 재생산 (${derived.availability} vs ${o.availability})`)
-  assert.ok(near(derived.performance, o.performance), 'performance 재생산')
-  assert.ok(near(derived.quality, o.quality), 'quality 재생산')
-  assert.ok(near(derived.overall, o.overall), 'overall 재생산')
-})
-
-/*
- * ── 배선 감시: 라이브가 커널에 **모든 채널을 넘기는가** ──────────────────────
- *
- * 규칙(deriveAttentions)은 커널 테스트가 지킨다. 지켜지지 않던 것은 **배선**이다 —
- * `withLiveAttentions` 가 채널 하나를 안 넘기면 같은 공장이 시뮬에서는 막혔다고 하고 라이브에서는
- * 멀쩡하다고 답한다. 규칙은 멀쩡하니 규칙 테스트는 통과하고, 어긋남은 아무 데서도 안 잡힌다.
- * (`tasks` 를 새로 넣을 때 실제로 그럴 뻔했다.)
- *
- * 그래서 채널마다 신호가 하나씩 나오는 상태를 만들고, **넷이 다 나오는지** 본다. 앞으로 채널이
- * 하나 더 늘고 라이브 배선만 빠지면 여기서 깨진다.
- */
-test('★ withLiveAttentions 는 채널을 하나도 떨어뜨리지 않는다(설비·자리·오더·작업)', () => {
-  const state = {
-    nowTime: '2026-03-02T12:00:00.000Z',
-    equipment: [{ id: 'rbt-1', status: 'down', location: 'wc-1' }],
-    locations: [{ id: 'wc-1', capacity: 2, occupancy: 2 }],
-    orders: [{ id: 'ord-1', held: true, status: 'released' }],
-    tasks: Array.from({ length: 8 }, (_, i) => ({ id: `t${i}`, kind: 'paint', status: 'created' }))
-  }
-  const kinds = new Set((withLiveAttentions(state as any).attentions ?? []).map((a: any) => a.kind))
-  for (const expected of ['breakdown', 'bottleneck', 'hold', 'work-backlog'])
-    assert.ok(kinds.has(expected), `라이브 배선이 '${expected}' 채널을 떨어뜨렸다 — 넘긴 것: ${[...kinds].join(', ') || '없음'}`)
-})
-
-/*
- * ── 되짚은 상태에도 신호가 있어야 한다 (2026-08-05) ────────────────────────
- * 라이브·시뮬은 커널이 신호를 스스로 내지만, 저널을 계산하는 경로는 프로젝터 상태만 낸다 — 신호 키가
- * 아예 없었다. 지도는 `snap.attentions` 를 읽으므로 **과거를 되짚으면 주의 레일이 텅 비었고**,
- * 기동돼 있지 않은 트윈을 보는 화면도 같았다. 실 저널로 재 보니 `rosarito-wms` 는 246건이 비어 있었다.
- *
- * 신호는 상태에서 계산되는 것이므로 같은 공식으로 채우면 된다(두 벌을 두지 않는다). 다만 "늦었나"
- * 판정이 `nowTime` 을 보므로 그 값이 먼저다 — 되짚은 시점의 정직한 "지금" 은 물어본 시각이고,
- * 벽시계를 끼워 넣으면 과거 화면이 "지금 기준으로 늦었다" 고 말한다.
- */
-test('★ 프로젝터 폴드 상태에는 신호 키가 없다 — 보강이 필요한 이유', () => {
-  const { model, events } = runSim()
-  const proj = new StateProjector(model)
-  for (const env of events) proj.apply(env)
-  const raw: any = proj.snapshot()
-  assert.equal(raw.attentions, undefined, '계산한 상태는 신호를 스스로 내지 않는다(커널이 아니다)')
-})
-
-test('★ 보강하면 다시 계산한 상태에도 신호가 있다 — 지도의 주의 레일이 비지 않게', () => {
-  /* 용량 1 자리를 채워 병목이 스스로 성립하게 만든다(신호를 손으로 넣지 않는다). */
-  const st: any = {
-    revision: 3,
-    nowTime: '2026-08-05T00:00:00.000Z',
-    locations: [{ id: 'bin-tight', type: 'storage', capacity: 1, occupancy: 1 }],
-    equipment: [],
-    orders: [],
-    tasks: []
-  }
-  const out = withLiveAttentions(st)
-  assert.ok((out.attentions ?? []).length > 0, '계산한 상태에서도 규칙이 신호를 낸다')
-  assert.equal(out.attentions![0].kind, 'bottleneck')
-})

package/test/load-meter.test.ts

@@ -1,328 +0,0 @@
-/*
- * 부하 계기판 — **어떤 작업이 루프를 얼마나 쓰는지.**
- *
- * 지키는 것: ① 작업별로 따로 쌓인다 ② 무거운 것부터 나온다 ③ 몫이 합계와 맞는다 ④ 잰 적이 없으면
- * `null`(0 이 아니다) ⑤ 예산 초과를 세되 경고는 쿨다운을 둔다 ⑥ 경고 문구가 **무엇이 느린지** 말한다.
- *
- * ④가 특히 중요하다. 재지 않은 것을 0 으로 채우면 "0ms 다"(= 아주 빠르다)로 읽혀 **재지 않았다는 사실과
- * 정반대의 뜻**이 된다. 이 세션에서 같은 종류의 착각을 여러 번 겪었다 — 포트가 열렸다고 서버가 응답하는
- * 줄 알았던 것도 그것이다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { LOAD_PHASES, fleetLoad, newCpuSampler, sampleCpu, judgeCycle, loadSummary, newLoadMeter, recordFork, recordPhase, rollWindow, slowTickMessage, TICK_BUDGET_RATIO, WARN_COOLDOWN_MS, WINDOW_MS } from '../server/engine/load-meter.ts'
-
-const TICK = 1000
-
-test('작업별로 따로 쌓이고, 무거운 것부터 나온다', () => {
-  const m = newLoadMeter()
-  recordPhase(m, 'tick', 300)
-  recordPhase(m, 'tick', 500)
-  recordPhase(m, 'snapshot', 100)
-  recordPhase(m, 'publish', 20)
-
-  const s = loadSummary(m, TICK)!.total!
-  assert.deepEqual(s.phases.map(p => p.phase), ['tick', 'snapshot', 'publish'], '총 시간 순')
-
-  const tick = s.phases[0]
-  assert.equal(tick.count, 2)
-  assert.equal(tick.lastMs, 500)
-  assert.equal(tick.maxMs, 500)
-  assert.equal(tick.avgMs, 400)
-  assert.equal(tick.totalMs, 800)
-})
-
-test('몫이 잰 작업들의 합과 맞는다 — 어디를 고칠지 이 값이 정한다', () => {
-  const m = newLoadMeter()
-  recordPhase(m, 'tick', 750)
-  recordPhase(m, 'snapshot', 250)
-
-  const s = loadSummary(m, TICK)!.total!
-  assert.equal(s.measuredTotalMs, 1000)
-  assert.equal(s.phases.find(p => p.phase === 'tick')!.share, 0.75)
-  assert.equal(s.phases.find(p => p.phase === 'snapshot')!.share, 0.25)
-  assert.equal(
-    +s.phases.reduce((a, p) => a + p.share, 0).toFixed(2),
-    1,
-    '몫의 합은 1 — 다만 재지 않은 작업은 분모에 없다'
-  )
-})
-
-test('잰 적이 없으면 null 이다 — 0 으로 채우면 "빠르다" 로 읽힌다', () => {
-  assert.equal(loadSummary(undefined, TICK), null, '계기판 자체가 없을 때')
-  assert.equal(loadSummary(newLoadMeter(), TICK), null, '있지만 한 번도 안 쟀을 때')
-
-  const m = newLoadMeter()
-  recordPhase(m, 'publish', 5)
-  assert.equal(loadSummary(m, TICK)!.loadRatio, null, '틱을 안 쟀으면 루프 점유율도 없다 — 0 이 아니다')
-})
-
-test('음수·NaN 은 기록하지 않는다 — 시계가 뒤로 가도 평균이 거짓이 되지 않게', () => {
-  const m = newLoadMeter()
-  recordPhase(m, 'tick', -5)
-  recordPhase(m, 'tick', NaN)
-  recordPhase(m, 'tick', Infinity)
-
-  assert.equal(loadSummary(m, TICK), null, '아무것도 안 쌓였다')
-})
-
-test('예산은 간격의 절반 — 넘으면 센다', () => {
-  const m = newLoadMeter()
-  const under = judgeCycle(m, TICK * TICK_BUDGET_RATIO - 1, TICK, 0)
-  assert.equal(under.over, false)
-  assert.equal(m.overBudget, 0)
-
-  const over = judgeCycle(m, TICK * TICK_BUDGET_RATIO + 1, TICK, 0)
-  assert.equal(over.over, true)
-  assert.equal(over.budgetMs, 500)
-  assert.equal(m.overBudget, 1)
-})
-
-test('경고는 쿨다운을 둔다 — 느린 트윈이 매 틱 경고하면 로그가 원인을 덮는다', () => {
-  const m = newLoadMeter()
-  const slow = 900
-
-  assert.equal(judgeCycle(m, slow, TICK, 1000).warn, true, '처음엔 말한다')
-  assert.equal(judgeCycle(m, slow, TICK, 2000).warn, false, '쿨다운 안에는 알리지 않고')
-  assert.equal(judgeCycle(m, slow, TICK, 1000 + WARN_COOLDOWN_MS).warn, true, '쿨다운이 지나면 다시')
-
-  assert.equal(m.overBudget, 3, '말하지 않아도 세기는 한다')
-})
-
-test('경고 문구가 무엇이 느린지 알린다 — "틱 800ms" 만으로는 볼 곳을 모른다', () => {
-  const m = newLoadMeter()
-  recordPhase(m, 'tick', 800)
-  recordPhase(m, 'snapshot', 600)
-  recordPhase(m, 'publish', 100)
-
-  const msg = slowTickMessage('wms-1', 800, 500, m)
-  assert.match(msg, /wms-1/)
-  assert.match(msg, /800ms/)
-  assert.match(msg, /예산 500ms/)
-  assert.match(msg, /tick .*%/, '가장 무거운 작업과 몫')
-  assert.match(msg, /snapshot/, '두 번째로 무거운 것까지')
-  assert.match(msg, /메인 이벤트 루프/, '왜 문제인지도 말한다')
-})
-
-test('실시간(최근 창)과 누적을 따로 낸다 — 지금 아픈 것과 오래 쌓인 것은 다르다', () => {
-  const m = newLoadMeter()
-  recordPhase(m, 'tick', 100, 0)          // 첫 창 시작
-  recordPhase(m, 'tick', 100, 1000)
-  recordPhase(m, 'tick', 700, WINDOW_MS + 1) // 창이 닫히고 새 창에 쌓인다
-
-  const s = loadSummary(m, TICK)!
-  assert.equal(s.total!.phases[0].totalMs, 900, '누적은 전부')
-  assert.equal(s.recent!.measuredTotalMs, 200, '최근은 닫힌 창만 — 채우는 중인 창은 과소 집계라 안 쓴다')
-  assert.equal(s.recent!.spanMs, WINDOW_MS + 1)
-  assert.equal(s.recent!.busyRatio, 0.02, '창의 2%를 썼다')
-})
-
-test('창이 하나도 안 닫혔으면 최근은 null — 채우는 중인 값을 실시간이라 하지 않는다', () => {
-  const m = newLoadMeter()
-  recordPhase(m, 'tick', 300, 0)
-  recordPhase(m, 'tick', 300, 500)
-
-  const s = loadSummary(m, TICK)!
-  assert.equal(s.recent, null)
-  assert.equal(s.total!.measuredTotalMs, 600)
-  assert.equal(s.total!.spanMs, null, '누적은 구간을 모른다')
-  assert.equal(s.total!.busyRatio, null, '구간을 모르면 비율도 없다 — 0 이 아니다')
-})
-
-test('fork 수를 센다 — 예측 한 번이 수십 개를 만든다', () => {
-  const m = newLoadMeter()
-  recordFork(m, 30)
-  recordFork(m)
-
-  assert.equal(loadSummary(m, TICK)!.forksCreated, 31, '아무 작업도 안 쟀어도 fork 수는 보인다')
-})
-
-test('전체 한눈에 — 최근 부하가 큰 순서로, 대수와 fork 총수까지', () => {
-  const mk = (busy: number, forks = 0) => {
-    const m = newLoadMeter()
-    recordPhase(m, 'tick', busy, 0)
-    recordFork(m, forks)
-    rollWindow(m, WINDOW_MS)  // 창을 닫아 '최근' 으로 만든다
-    return m
-  }
-
-  const f = fleetLoad(
-    [
-      { instanceId: 'idle-1', mode: 'sim', meter: mk(10) },
-      { instanceId: 'hot-1', mode: 'sim', meter: mk(4000, 30) },
-      { instanceId: 'live-1', mode: 'live', meter: mk(50) },
-      { instanceId: 'fresh-1', mode: 'sim' } // 아직 아무것도 안 쟀다
-    ],
-    TICK
-  )
-
-  assert.equal(f.instances, 4)
-  assert.deepEqual(f.byMode, { sim: 3, live: 1 })
-  assert.equal(f.forksCreated, 30)
-  assert.equal(f.slowest[0].instanceId, 'hot-1', '지금 아픈 것이 맨 위')
-  assert.equal(f.slowest[0].topPhase, 'tick')
-  assert.equal(f.slowest.at(-1)!.instanceId, 'fresh-1', '안 잰 것은 0 으로 맨 아래')
-  assert.equal(f.recentBusyMs, 4060)
-  assert.equal(f.recentSpanMs, WINDOW_MS)
-  assert.equal(f.fleetBusyRatio, 0.406, '창의 40.6% — 1 을 넘으면 한 틱 안에 다 못 끝낸다')
-})
-
-test('전체 뷰: 닫힌 창이 하나도 없으면 비율을 지어내지 않는다', () => {
-  const f = fleetLoad([{ instanceId: 'a', mode: 'sim', meter: newLoadMeter() }], TICK)
-
-  assert.equal(f.recentSpanMs, null)
-  assert.equal(f.fleetBusyRatio, null)
-  assert.equal(f.recentBusyMs, 0)
-})
-
-test('아주 작은 비율이 0 으로 사라지지 않는다 — 재서 나온 값과 없는 값은 다르다', () => {
-  const m = newLoadMeter()
-  recordPhase(m, 'tick', 24, 0)
-  rollWindow(m, 11_000)
-
-  const r = loadSummary(m, TICK)!.recent!
-  assert.ok(r.busyRatio! > 0, `0 이 되면 "안 쓴다" 로 읽힌다 — 실제 ${r.busyRatio}`)
-  assert.equal(r.busyRatio, 0.0022)
-})
-
-test('도메인별 점유 — 어느 테넌트가 루프를 먹나', () => {
-  const mk = (busy: number) => {
-    const m = newLoadMeter()
-    recordPhase(m, 'tick', busy, 0)
-    rollWindow(m, WINDOW_MS)
-    return m
-  }
-
-  const f = fleetLoad(
-    [
-      { instanceId: 'a1', mode: 'sim', domainId: 'D1', domainLabel: 'acme', meter: mk(300) },
-      { instanceId: 'a2', mode: 'sim', domainId: 'D1', domainLabel: 'acme', meter: mk(500) },
-      { instanceId: 'b1', mode: 'live', domainId: 'D2', meter: mk(200) },
-      { instanceId: 'c1', mode: 'sim' } // 도메인도 계측도 없다
-    ],
-    TICK
-  )
-
-  assert.deepEqual(
-    f.byDomain.map(d => `${d.label} ${d.instances} ${d.recentBusyMs}ms ${Math.round(d.share * 100)}%`),
-    ['acme 2 800ms 80%', 'D2 1 200ms 20%', '(unknown) 1 0ms 0%'],
-    '무거운 순 · 이름을 모르면 id 를 그대로 쓴다(지어내지 않는다)'
-  )
-  assert.equal(
-    +f.byDomain.reduce((a, d) => a + d.share, 0).toFixed(2),
-    1,
-    '몫의 합은 1 — 잰 트윈들 사이의 비율이다'
-  )
-})
-
-test('도메인별 점유: 아무도 안 쟀으면 몫이 0 이고 비율을 지어내지 않는다', () => {
-  const f = fleetLoad([{ instanceId: 'a', mode: 'sim', domainId: 'D1' }], TICK)
-
-  assert.equal(f.byDomain.length, 1)
-  assert.equal(f.byDomain[0].share, 0)
-  assert.equal(f.fleetBusyRatio, null)
-})
-
-test('보이는 부분의 합이 보이는 합계와 맞는다 — 도메인 = 그 도메인 트윈들의 합', () => {
-  /* 실제로 어긋났던 값: 잎마다 따로 반올림해서 도메인 0.08ms 인데 트윈 둘은 0.08+0.01=0.09ms 였다. */
-  const mk = (busy: number) => {
-    const m = newLoadMeter()
-    recordPhase(m, 'tick', busy, 0)
-    rollWindow(m, WINDOW_MS)
-    return m
-  }
-
-  const f = fleetLoad(
-    [
-      { instanceId: 'big', mode: 'sim', domainId: 'D1', domainLabel: 'hatiolab', meter: mk(39.114) },
-      { instanceId: 's1', mode: 'sim', domainId: 'D2', domainLabel: 'system', meter: mk(0.084) },
-      { instanceId: 's2', mode: 'sim', domainId: 'D2', domainLabel: 'system', meter: mk(0.014) }
-    ],
-    TICK
-  )
-
-  for (const d of f.byDomain) {
-    const mine = f.slowest.filter(s => s.domainId === d.domainId)
-    assert.equal(
-      d.recentBusyMs,
-      +mine.reduce((a, s) => a + s.recentBusyMs, 0).toFixed(2),
-      `${d.label} 의 합계가 그 트윈들의 합과 다르다`
-    )
-  }
-
-  assert.equal(
-    f.recentBusyMs,
-    +f.byDomain.reduce((a, d) => a + d.recentBusyMs, 0).toFixed(2),
-    '전체 합계가 도메인들의 합과 다르다'
-  )
-})
-
-test('도메인 몫의 합은 1 이다 — 백분율로 읽어 100% 가 된다', () => {
-  const mk = (busy: number) => {
-    const m = newLoadMeter()
-    recordPhase(m, 'tick', busy, 0)
-    rollWindow(m, WINDOW_MS)
-    return m
-  }
-
-  const f = fleetLoad(
-    [
-      { instanceId: 'a', mode: 'sim', domainId: 'D1', meter: mk(39.11) },
-      { instanceId: 'b', mode: 'sim', domainId: 'D2', meter: mk(0.08) },
-      { instanceId: 'c', mode: 'sim', domainId: 'D3', meter: mk(0.01) }
-    ],
-    TICK
-  )
-
-  assert.equal(+f.byDomain.reduce((a, d) => a + d.share, 0).toFixed(3), 1)
-})
-
-test('프로세스 CPU 는 첫 표본에서 null 이다 — 잰 구간이 없으면 0 이 아니다', () => {
-  const s = newCpuSampler()
-  assert.equal(sampleCpu(s, 1_000_000, 1000), null, '비교할 앞 표본이 없다')
-})
-
-test('프로세스 CPU 는 두 표본 사이의 점유율이다 — 코어를 여럿 쓰면 1 을 넘는다', () => {
-  const s = newCpuSampler()
-  sampleCpu(s, 1_000_000, 0)
-
-  assert.deepEqual(sampleCpu(s, 1_500_000, 1000), { ratio: 0.5, spanMs: 1000 }, '1초에 0.5초 = 50%')
-  assert.deepEqual(sampleCpu(s, 2_600_000, 2000), { ratio: 1.1, spanMs: 1000 }, '1초에 1.1초 = 110%, 코어 여러 개')
-})
-
-test('시계가 뒤로 가거나 구간이 0 이면 비율을 지어내지 않는다', () => {
-  const s = newCpuSampler()
-  sampleCpu(s, 1_000_000, 1000)
-
-  assert.equal(sampleCpu(s, 1_200_000, 1000), null, '구간 0')
-  assert.equal(sampleCpu(newCpuSampler(), 5, 5), null)
-})
-
-/*
- * ── 부팅 구간도 재는 이름을 갖는다 (2026-08-22) ─────────────────────────────
- * 실측으로 부팅이 620~717초였고 트윈 하나를 세우는 데 15~93초였는데, **어느 작업이 그 시간을 쓰는지
- * 답할 이름이 없었다** — 재는 이름이 도는 중의 작업뿐이었다. 그래서 짐작으로 원인을 적을 수밖에
- * 없었고, 그것은 이 프로젝트가 금하는 일이다.
- */
-test('부팅 구간을 재는 이름이 있다 — 웜스타트와 자극 시작', () => {
-  assert.ok(LOAD_PHASES.includes('warmStart' as any), '상태 심기를 재는 이름이 있어야 한다')
-  assert.ok(LOAD_PHASES.includes('stimulus' as any), '자극 시작을 재는 이름이 있어야 한다')
-
-  /* 계기가 그 값을 실제로 들고 답한다 — 이름만 있고 담기지 않으면 화면이 빈칸을 보인다. */
-  const m = newLoadMeter()
-  recordPhase(m, 'warmStart', 93_000, 1_000)
-  recordPhase(m, 'stimulus', 72_000, 1_000)
-  assert.equal(m.phases.warmStart?.maxMs, 93_000)
-  assert.equal(m.phases.stimulus?.maxMs, 72_000)
-})
-
-test('부팅 구간은 틱 예산으로 판정하지 않는다 — 한 번뿐인 일이다', () => {
-  /*
-   * 웜스타트는 트윈을 세울 때 한 번이고 몇십 초가 정상일 수 있다. 그것을 틱 예산(간격의 절반)으로
-   * 재면 부팅마다 「느린 주기」가 쏟아진다 — 거짓 경보는 참 경보를 죽인다. 판정은 틱만 받는다.
-   */
-  const m = newLoadMeter()
-  recordPhase(m, 'warmStart', 93_000, 1_000)
-  assert.equal(m.overBudget, 0, '기록만으로는 판정하지 않는다')
-})