@things-factory/headless-twin 10.1.278 → 10.1.279

package/test/first-envelope.test.ts

@@ -1,153 +0,0 @@
-/*
- * 첫 봉투가 몇 번부터 시작했는지 남기는가.
- *
- * ── 무엇이 있었나 (2026-09-06 실측, 인티그레이션 레인이 찾음) ────────────────
- * plant 아웃박스의 1~20 이 400 으로 거절돼 그 연결에 커서가 없었다. 다음에 온 21번이 첫 봉투로
- * 앉으며 커서가 21 로 뛰었다.
- *
- * 커서가 0 이었다면 같은 21이 구멍이었다. 둘의 차이가 그 결함의 전부다. 스무 건이 구멍으로도 안
- * 세어지고, 경고도 없고, backfill 대상도 아니었다 — backfill 은 커서부터 묻는다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { firstSeqOf, seqOf, takeInSequence, withSeq } from '../server/service/reference/hook-contract.js'
-
-const item = (seq: number) => ({ seq, record: { at: '2026-09-06T00:00:00.000Z' } })
-
-test('★ 커서가 없는 연결에 21번이 오면 그 앞 20건을 못 봤다고 말한다', () => {
-  const got = takeInSequence({ items: [item(21)], scope: 'EVENTS', lastSeq: undefined })
-
-  assert.equal(got.firstUnseenBefore, 20, '못 본 개수를 안 말하면 그 사실이 아무 데도 안 남는다')
-  assert.equal(got.advancedSeq, 21)
-  assert.equal(got.gap, undefined, '첫 봉투를 구멍으로 만들지 않는다 — 거절할 근거가 없다')
-})
-
-test('★ 커서가 0 이면 같은 21번이 구멍이다 — 둘의 차이가 이 결함의 전부다', () => {
-  const got = takeInSequence({ items: [item(21)], scope: 'EVENTS', lastSeq: 0 })
-
-  assert.equal(got.gap?.expectedSeq, 1)
-  assert.equal(got.firstUnseenBefore, undefined, '구멍은 첫 봉투가 아니다')
-})
-
-test('1번부터 시작한 연결은 못 본 것이 없다 — 그 칸을 내지 않는다', () => {
-  const got = takeInSequence({ items: [item(1)], scope: 'EVENTS', lastSeq: undefined })
-
-  assert.equal(got.firstUnseenBefore, undefined, '0 을 내면 화면이 말할 것 없는 줄을 그린다')
-  assert.equal(got.advancedSeq, 1)
-})
-
-test('늦게 붙은 연결도 수만 말한다 — 손실이라고 하지 않는다', () => {
-  /*
-   * 원본이 오래 돌고 있는데 트윈을 나중에 붙이면 seq 4,712 부터 받는 것이 정상이고, 그 아래
-   * 4,711 개는 애초에 안 받기로 한 것이다. 계약은 둘을 구별할 수 없으므로 수만 낸다.
-   */
-  const got = takeInSequence({ items: [item(4712)], scope: 'EVENTS', lastSeq: undefined })
-  assert.equal(got.firstUnseenBefore, 4711)
-  assert.equal(got.advancedSeq, 4712, '늦게 붙은 것을 거절하지 않는다')
-})
-
-test('이어받는 봉투에는 그 칸이 없다', () => {
-  const got = takeInSequence({ items: [item(49)], scope: 'EVENTS', lastSeq: 48 })
-  assert.equal(got.firstUnseenBefore, undefined)
-  assert.equal(got.advancedSeq, 49)
-})
-
-test('★ 이 테스트가 실제로 무언가를 잰다 — 견준 것이 0이면 빨강', () => {
-  const first = takeInSequence({ items: [item(21)], scope: 'EVENTS', lastSeq: undefined })
-  const cont = takeInSequence({ items: [item(21)], scope: 'EVENTS', lastSeq: 20 })
-  assert.notEqual(first.firstUnseenBefore, cont.firstUnseenBefore, '첫 봉투와 이어받은 봉투가 같아졌다')
-})
-
-/* ── 몇 번부터 받기 시작했나를 커서에 적는다 ────────────────────────────────── */
-
-test('★ 첫 봉투의 번호를 커서에 적는다 — 「앞이 비었나」를 나중에 답하려면 이 값이 있어야 한다', () => {
-  const got = takeInSequence({ items: [item(21)], scope: 'EVENTS', lastSeq: undefined })
-  assert.equal(got.firstSeq, 21)
-
-  const cursor = withSeq({}, 'mes-line-a::EVENTS', got.advancedSeq!, got.firstSeq)
-  assert.equal(firstSeqOf(cursor, 'mes-line-a::EVENTS'), 21)
-  assert.equal(seqOf(cursor, 'mes-line-a::EVENTS'), 21)
-})
-
-test('★ 한 번 적힌 firstSeq 는 안 바뀐다 — 덮으면 「앞이 비었나」를 다시 못 묻는다', () => {
-  /*
-   * 커서가 나아간 뒤에 이 값을 만들면 그 번호는 첫 번호가 아니라 그때 마침 온 번호다.
-   */
-  let cursor = withSeq({}, 'S', 21, 21)
-  cursor = withSeq(cursor, 'S', 22, 22)
-  cursor = withSeq(cursor, 'S', 48, 48)
-
-  assert.equal(firstSeqOf(cursor, 'S'), 21, 'firstSeq 가 덮였다')
-  assert.equal(seqOf(cursor, 'S'), 48)
-})
-
-test('★ 적힌 적이 없으면 모른다고 말한다 — 0 으로 답하면 1번부터 다 받은 것으로 읽힌다', () => {
-  const old = withSeq({}, 'S', 48)
-  assert.equal(firstSeqOf(old, 'S'), undefined)
-  assert.equal(seqOf(old, 'S'), 48, '옛 커서의 번호는 그대로 읽힌다')
-})
-
-test('이어받는 봉투는 firstSeq 를 안 낸다 — 그 값을 만들 근거가 없다', () => {
-  const got = takeInSequence({ items: [item(49)], scope: 'EVENTS', lastSeq: 48 })
-  assert.equal(got.firstSeq, undefined)
-})
-
-test('1번부터 시작한 연결도 firstSeq 를 적는다 — 못 본 것이 없다는 사실도 사실이다', () => {
-  const got = takeInSequence({ items: [item(1)], scope: 'EVENTS', lastSeq: undefined })
-  assert.equal(got.firstSeq, 1)
-  assert.equal(got.firstUnseenBefore, undefined, '못 본 것이 0이면 그 칸은 안 낸다')
-})
-
-test('★ 밑에서부터 다시 받으면 그 번호가 firstSeq 가 된다 — from: 0 은 first 판정이 아니다', () => {
-  /*
-   * 실제로 났다(2026-09-06). `fillTwinScope(from: 0)` 으로 잃은 구간을 되찾았는데 커서에
-   * `firstSeq` 가 안 적혔다. 커서가 0 이라 seq 1 이 `next` 판정이었고 `first` 가 아니었기 때문이다.
-   *
-   * 그런데 우리는 실제로 1번부터 갖게 됐다. `lowestSeq` 가 그 사실을 낸다.
-   */
-  const got = takeInSequence({ items: [item(1), item(2), item(3)], scope: 'EVENTS', lastSeq: 0 })
-
-  assert.equal(got.firstSeq, undefined, '커서가 있었으므로 첫 봉투가 아니다')
-  assert.equal(got.lowestSeq, 1, '받아들인 것 중 가장 낮은 번호')
-  assert.equal(got.advancedSeq, 3)
-})
-
-test('가장 낮은 번호는 하나도 못 받으면 없다', () => {
-  const got = takeInSequence({ items: [item(9)], scope: 'EVENTS', lastSeq: 4 })
-  assert.equal(got.lowestSeq, undefined, '구멍이라 아무것도 안 받았다')
-  assert.equal(got.gap?.expectedSeq, 5)
-})
-
-/* ── 봉투의 시각 ────────────────────────────────────────────────────────────── */
-
-test('★ 시각을 안 싣는 레코드에 봉투의 시각을 얹는다 — 안 얹으면 다시 받을 때마다 새 사실이 된다', () => {
-  /*
-   * [측정함 2026-09-06] `fillTwinScope(from: 0)` 을 두 번 돌렸더니 mes-line-a 저널이 40 → 69건이
-   * 되고 중복이 27가지 생겼다. 시각을 안 싣는 레코드는 ingest 시각으로 떨어지는데 그 값이 실행할
-   * 때마다 달라서 fact identity 가 매번 바뀐다. 시각을 말하는 12건만 되풀이로 걸러졌다.
-   *
-   * plant 아웃박스는 그 시각을 봉투에 실어 보내고 있었다. 갈 자리가 없어서 버려지던 값이다.
-   */
-  const got = takeInSequence({
-    items: [{ seq: 1, record: { subjectId: 'L', decision: 'scrap' }, at: '2026-09-01T00:00:00.000Z' }],
-    scope: 'EVENTS',
-    lastSeq: 0
-  })
-  assert.equal((got.records[0] as any).at, '2026-09-01T00:00:00.000Z')
-})
-
-test('★ 레코드가 자기 시각을 말하면 그것이 이긴다 — 봉투는 「언제 보냈나」에 가깝다', () => {
-  const got = takeInSequence({
-    items: [{ seq: 1, record: { subjectId: 'L', decision: 'scrap', at: '2026-08-30T00:00:00.000Z' }, at: '2026-09-01T00:00:00.000Z' }],
-    scope: 'EVENTS',
-    lastSeq: 0
-  })
-  assert.equal((got.records[0] as any).at, '2026-08-30T00:00:00.000Z')
-})
-
-test('봉투가 시각을 안 말하면 레코드를 그대로 둔다 — 없는 값을 만들지 않는다', () => {
-  const rec = { subjectId: 'L', decision: 'scrap' }
-  const got = takeInSequence({ items: [{ seq: 1, record: rec }], scope: 'EVENTS', lastSeq: 0 })
-  assert.equal(got.records[0], rec, '새 객체를 만들 이유가 없다')
-})

package/test/fold-gap-speaks.test.ts

@@ -1,53 +0,0 @@
-/*
- * ★ 저장본 뒤의 사건 — 계산했든 못 했든 **말한다**.
- *
- * ── 무엇이 침묵했나 (2026-08-28 실측) ───────────────────────────────────────
- * 미러는 저장본에서 상태를 되세우고 그 뒤의 사건만 따라 계산한다. 그 자리가 이랬다.
- *
- *   10:34:37  found cached state → revision 3372228
- *   10:34:37  resumed from the stored fold seed at revision 3372228 — items 2665 · orders 4794
- *
- * 그 시각 저널의 머리는 3,374,894였다. 2,666건이 저장본보다 앞서 있었는데 **계산했다는 줄도, 못
- * 했다는 줄도 없었다.** 갈래가 셋인데 말하는 갈래가 하나뿐이었기 때문이다.
- *
- *   ① 계산해서 나아갔다        → 말한다
- *   ② 계산이 오류로 실패했다    → 말한다
- *   ③ 오류 없이 끝났는데 그대로  → **아무 말도 없었다** ← 여기
- *   ④ 저널 머리를 못 읽었다     → **아무 말도 없었다** ← 여기
- *
- * ③④에서 트윈은 그 사건들의 결과 없이 뜨고, 화면은 그것을 「없는 사실」로 그린다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { join } from 'node:path'
-
-const engine = readFileSync(join(import.meta.dirname, '..', 'server', 'engine', 'twin-engine.ts'), 'utf8')
-
-test('★ 저널 머리를 못 읽었으면 그 사실을 말하고 그대로 뜬다', () => {
-  assert.match(engine, /if \(!tip\) \{/, '못 읽은 갈래가 있어야 한다')
-  assert.match(engine, /could not read the journal tip/, '무엇을 못 했는지 말해야 한다')
-  assert.match(engine, /without folding what came after it/, '무엇을 잃는지 말해야 한다')
-})
-
-test('★ 계산이 아무 일도 하지 않았으면 그것도 말한다', () => {
-  assert.match(engine, /\} else if \(!failed\) \{/, '오류가 아닌데 나아가지 않은 갈래가 있어야 한다')
-  assert.match(engine, /left the seed at revision/)
-  /* 오류로 실패한 것을 두 번 말하지 않는다 — 이미 위에서 말했다. */
-  assert.match(engine, /let failed: string \| undefined/)
-})
-
-test('★ 부팅마다 부르는 질의를 관계로 묻지 않는다 — 이 파일이 스스로 금지한 모양이다', () => {
-  /*
-   * `findOne({ where: { domain: { id } } })` 는 안쪽에 상한이 없는 두 단계 질의가 된다(실측 12초,
-   * 저널 375만 행). `tipOf` 는 부팅마다 트윈마다 불리므로 그 한 번이 부팅을 붙잡는다.
-   */
-  const from = engine.indexOf('private static async tipOf')
-  assert.ok(from > 0, 'tipOf 가 있어야 한다')
-  const tipOf = engine.slice(from, from + 2600)
-  /* 주석에 인용된 나쁜 모양과 헷갈리지 않게, 실제 코드 모양만 본다. */
-  assert.doesNotMatch(tipOf, /findOne\(\{ where: \{ domain: \{ id: domainId \}/, '관계로 묻는 모양이 남아 있다')
-  assert.match(tipOf, /createQueryBuilder\('e'\)/)
-  assert.match(tipOf, /orderBy\('e\.revision', 'DESC'\)/)
-  assert.match(tipOf, /\.limit\(1\)/)
-})

package/test/fold-shift-dst.test.ts

@@ -1,110 +0,0 @@
-/*
- * Folding a span that crosses a daylight-saving transition.
- *
- * ── Why this is worth a test ───────────────────────────────────────────────
- * `utcOffsetMinutes` on the model is one number, resolved when the host starts the twin.
- * Folding walks a past span, so a year of facts gets read with whatever offset happened to
- * be current at start — and a year holds two transitions. Facts after one land an hour off
- * and are counted into the neighbouring shift. Nothing errors; shift performance is simply
- * wrong, and plausible.
- *
- * `America/Tijuana` is already in this deployment's data (PST -480 / PDT -420), so this is
- * not a hypothetical.
- */
-import test from 'node:test'
-import assert from 'node:assert/strict'
-
-import { foldKpi } from '../server/engine/kpi-fold.js'
-
-/* Two shifts that between them cover the day, so a misread hour lands in the other one. */
-const SHIFTS = [
-  { id: 'day', fromTime: '06:00', toTime: '18:00' },
-  { id: 'night', fromDayOffset: 0, fromTime: '18:00', toDayOffset: 1, toTime: '06:00' }
-] as any[]
-
-/* Tijuana: PDT (-420) in July, PST (-480) in December. */
-const SUMMER = Date.UTC(2026, 6, 15, 13, 30) //  06:30 local under -420 → day shift
-const WINTER = Date.UTC(2026, 11, 15, 13, 30) // 05:30 local under -480 → night shift
-
-/*
- * The same rule the host uses (`utcOffsetOf`), written out here because that function lives
- * beside code the test runner cannot load. Kept small and checked by its own test below, so a
- * drift in it does not quietly turn the rest of this file green.
- */
-function offsetAt(atMs: number): number | undefined {
-  const name = new Intl.DateTimeFormat('en-US', { timeZone: 'America/Tijuana', timeZoneName: 'longOffset' })
-    .formatToParts(new Date(atMs))
-    .find(p => p.type === 'timeZoneName')?.value
-
-  const m = /^GMT([+-])(\d{1,2}):(\d{2})$/.exec(name ?? '')
-
-  return m ? (m[1] === '-' ? -1 : 1) * (Number(m[2]) * 60 + Number(m[3])) : undefined
-}
-
-/*
- * A completed task is a transition, not one row — the fold counts throughput at completion
- * and needs the earlier states to have a lead time to measure.
- */
-const doneAt = (ms: number, id: string): any[] =>
-  ['created', 'in-progress', 'completed'].map((status, i) => ({
-    eventType: 'task.status',
-    eventTime: new Date(ms - (2 - i) * 30_000).toISOString(),
-    payload: { data: { taskId: id, status } }
-  }))
-
-function shiftsOf(events: any[], options: any) {
-  const out = foldKpi(events, { fromMs: Date.UTC(2026, 0, 1), toMs: Date.UTC(2027, 0, 1) } as any, {
-    groupBy: 'shift',
-    shifts: SHIFTS,
-    ...options
-  } as any)
-
-  return (out as any)?.groups?.items?.map((g: any) => g.key) ?? []
-}
-
-test('the probe itself reads Tijuana as -420 in July and -480 in December', () => {
-  /* If this drifts, the rest of the file is measuring nothing. */
-  assert.equal(offsetAt(SUMMER), -420)
-  assert.equal(offsetAt(WINTER), -480)
-})
-
-test('a fixed offset puts a December fact in the wrong shift — the defect', () => {
-  /*
-   * Both facts are 13:30 UTC. Read with the summer offset the December one looks like
-   * 06:30 local and lands on the day shift, when locally it was 05:30 and belongs to the
-   * night shift.
-   */
-  const keys = shiftsOf([...doneAt(WINTER, 'w')], { utcOffsetMinutes: -420 })
-
-  assert.deepEqual(keys, ['day'])
-})
-
-test('offsetAt resolves per fact, so the December fact lands on the night shift', () => {
-  const keys = shiftsOf([...doneAt(WINTER, 'w')], { utcOffsetMinutes: -420, offsetAt })
-
-  assert.deepEqual(keys, ['night'])
-})
-
-test('the same span read per instant splits across both shifts, not one', () => {
-  const keys = shiftsOf([...doneAt(SUMMER, 's'), ...doneAt(WINTER, 'w')], { utcOffsetMinutes: -420, offsetAt }).sort()
-
-  assert.deepEqual(keys, ['day', 'night'])
-})
-
-test('offsetAt returning undefined falls back to the number rather than to UTC', () => {
-  /*
-   * Not knowing the offset for an instant is not the same as the instant being UTC.
-   * Falling through to the declared number keeps the previous behaviour instead of
-   * silently asserting Greenwich.
-   */
-  const keys = shiftsOf([...doneAt(WINTER, 'w')], { utcOffsetMinutes: -420, offsetAt: () => undefined })
-
-  assert.deepEqual(keys, ['day'])
-})
-
-test('no offset at all still folds, reading times as UTC as the contract states', () => {
-  const keys = shiftsOf([...doneAt(WINTER, 'w')], {})
-
-  /* 13:30 UTC is inside 06:00-18:00. */
-  assert.deepEqual(keys, ['day'])
-})

package/test/forecast-metrics.test.ts

@@ -1,157 +0,0 @@
-/*
- * 예측 지표 — **스냅샷에서 무엇을 세는가.**
- *
- * 여기서 틀리면 예측 그래프가 알리지 않고 다른 것을 그린다(오류 없이 곡선이 나온다). 특히 에너지 지표는
- * 「없음」과 「0」이 같은 그림이 되기 쉬워서, 그 경계를 명시로 잡아 둔다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { FORECAST_METRICS, metricsForKind } from '../server/service/twin-forecast/forecast-metrics.ts'
-
-test('물류 지표 — 기존 여섯은 그대로 센다', () => {
-  const s = {
-    items: [1, 2, 3],
-    locations: [{ occupancy: 2 }, { occupancy: 5 }],
-    tasks: [{}, {}],
-    orders: [{ status: 'shipped' }, { status: 'picking' }, { status: 'cancelled' }]
-  }
-  assert.equal(FORECAST_METRICS.items(s), 3)
-  assert.equal(FORECAST_METRICS.occupancy(s), 7)
-  assert.equal(FORECAST_METRICS.tasks(s), 2)
-  assert.equal(FORECAST_METRICS.orders(s), 3)
-  assert.equal(FORECAST_METRICS.shipped(s), 1)
-  /* 취소는 백로그가 아니다 — 대기와 취소를 같이 세면 「안 빠지는 일감」이 부풀려진다. */
-  assert.equal(FORECAST_METRICS.backlog(s), 1)
-})
-
-/*
- * ── 받는 오더는 흐름 지표에서 빠진다 (2026-09-19, ADR-0076 보탬 ⑥) ──────────
- *
- * 입고 · 반품 입고는 도착이 세우고 도착이 이행한다. 세면 「나간 것」이 받을 때마다 늘고 백로그는
- * 영영 안 줄어든다 — 그래프가 있지도 않은 일을 그린다.
- */
-test('★ 입고 · 반품 입고는 세지 않는다 — 그 오더는 나가지 않는다', () => {
-  const s = {
-    orders: [
-      { kind: 'outbound', status: 'shipped' },
-      { kind: 'outbound', status: 'picking' },
-      { kind: 'inbound', status: 'received', requested: 10, fulfilled: 10 },
-      { kind: 'return', status: 'received', requested: 3, fulfilled: 3 }
-    ]
-  }
-  assert.equal(FORECAST_METRICS.orders(s), 2, '흐름 오더 둘만 센다')
-  assert.equal(FORECAST_METRICS.shipped(s), 1)
-  assert.equal(FORECAST_METRICS.backlog(s), 1, '받은 오더가 백로그에 남으면 곡선이 안 내려간다')
-})
-
-/*
- * ── 백로그는 「종결인가」로 묻는다 ──────────────────────────────────────────
- *
- * 낱말 둘로 물을 때 원본이 `completed` 를 쓰는 미러에서 끝난 오더가 영영 백로그에 남았다. `status` 는
- * 열린 축이고 실 시스템은 자기 낱말을 쓴다 — 이 셈은 낱말이 아니라 양을 1차 근거로 본다.
- */
-test('★ 원본의 낱말로 끝난 오더도 백로그에서 빠진다', () => {
-  const s = {
-    orders: [
-      { kind: 'outbound', status: 'completed', requested: 5, fulfilled: 5 },
-      { kind: 'outbound', status: 'FINISHED', requested: 2, fulfilled: 2 },
-      { kind: 'outbound', status: 'picking', requested: 4, fulfilled: 1 }
-    ]
-  }
-  assert.equal(FORECAST_METRICS.backlog(s), 1, '아직 안 끝난 하나만 백로그다')
-})
-
-test('낱말을 말하지 않은 오더는 그대로 센다 — 지금까지의 거동이다', () => {
-  const s = { orders: [{ status: 'picking' }, { status: 'shipped' }] }
-  assert.equal(FORECAST_METRICS.orders(s), 2)
-  assert.equal(FORECAST_METRICS.shipped(s), 1)
-})
-
-test('에너지 지표 — 커널이 낸 값을 그대로 읽는다(다시 계산하지 않는다)', () => {
-  const s = {
-    energy: {
-      peakSince: { kW: 812 },
-      open: { meanKW: 300, projectedKW: 455, projectionBasis: 'mean-so-far' },
-      closed: [{ overContract: true }, { overContract: false }, { overContract: true }]
-    }
-  }
-  assert.equal(FORECAST_METRICS.peakKW(s), 812)
-  assert.equal(FORECAST_METRICS.projectedKW(s), 455)
-  assert.equal(FORECAST_METRICS.overWindows(s), 2)
-})
-
-test('투영이 아직 없으면 지금까지의 평균으로 — 0 으로 떨어뜨리지 않는다', () => {
-  assert.equal(FORECAST_METRICS.projectedKW({ energy: { open: { meanKW: 120 } } }), 120)
-})
-
-test('에너지가 없는 스냅샷 — 세 지표 모두 0(그리지 않을 값이지, 관측한 0 이 아니다)', () => {
-  assert.equal(FORECAST_METRICS.peakKW({ items: [] }), 0)
-  assert.equal(FORECAST_METRICS.projectedKW({ items: [] }), 0)
-  assert.equal(FORECAST_METRICS.overWindows({ items: [] }), 0)
-})
-
-test('계약을 모르면 초과 구간은 0 — overContract 가 없는 구간을 초과로 세지 않는다', () => {
-  const s = { energy: { closed: [{ maxKW: 900 }, { maxKW: 1200 }] } }
-  assert.equal(FORECAST_METRICS.overWindows(s), 0)
-})
-
-test('종류별 지표 목록 — 에너지 트윈에는 물류 지표가 섞이지 않는다', () => {
-  const ems = metricsForKind('ems')
-  assert.deepEqual(ems, ['projectedKW', 'peakKW', 'overWindows'])
-  assert.equal(ems.includes('items' as any), false)
-  assert.equal(metricsForKind('wms').includes('items'), true)
-  /* 종류를 모르면 물류로 — 기존 트윈(kind 미선언)이 지표를 잃지 않는다. */
-  assert.equal(metricsForKind(undefined).includes('items'), true)
-})
-
-test('목록의 모든 키가 실제로 계산 가능하다 — 화면에 뜨는데 서버가 모르는 지표는 없다', () => {
-  for (const kind of ['ems', 'wms', 'mes', 'yms']) {
-    for (const key of metricsForKind(kind)) {
-      assert.equal(typeof (FORECAST_METRICS as any)[key], 'function', `${kind}:${key}`)
-    }
-  }
-})
-
-/*
- * ★ Folding does not move the count (ADR-0092 decision 3, ruling 2026-09-24).
- * A twin folds finished orders out of its hot list and keeps kind × status counts. Counting the hot list
- * alone dropped orders/shipped at every fold, and made the gap trend's actual increase negative.
- */
-const hot = (orders: any[], foldedOrders?: any) => ({ orders, ...(foldedOrders ? { foldedOrders } : {}) })
-
-test('folding the finished orders leaves orders and shipped where they were', () => {
-  const before = hot([
-    { id: 'o1', kind: 'outbound', status: 'shipped' },
-    { id: 'o2', kind: 'outbound', status: 'cancelled' },
-    { id: 'o3', kind: 'outbound', status: 'picking' },
-    { id: 'r1', kind: 'inbound', status: 'completed' }
-  ])
-  const after = hot([{ id: 'o3', kind: 'outbound', status: 'picking' }], {
-    counts: { outbound: { shipped: 1, cancelled: 1 }, inbound: { completed: 1 } },
-    boundaryMs: 1
-  })
-  for (const m of ['orders', 'shipped', 'backlog'] as const) assert.equal(FORECAST_METRICS[m](after), FORECAST_METRICS[m](before), m)
-  assert.equal(FORECAST_METRICS.orders(after), 3, 'receiving orders are not counted, folded or not')
-})
-
-test('a fold between T and T+h keeps the actual increase from going negative', () => {
-  const atT = hot([{ kind: 'outbound', status: 'shipped' }, { kind: 'outbound', status: 'shipped' }, { kind: 'outbound', status: 'picking' }])
-  /* by T+h: one more shipped, and the three shipped have been folded */
-  const atTh = hot([{ kind: 'outbound', status: 'picking' }], { counts: { outbound: { shipped: 3 } }, boundaryMs: 2 })
-  assert.equal(FORECAST_METRICS.shipped(atTh) - FORECAST_METRICS.shipped(atT), 1)
-  assert.ok(FORECAST_METRICS.orders(atTh) - FORECAST_METRICS.orders(atT) >= 0)
-})
-
-test('a twin with nothing folded counts as before', () => {
-  const s = hot([{ kind: 'outbound', status: 'shipped' }, { status: 'picking' }])
-  assert.equal(FORECAST_METRICS.orders(s), 2)
-  assert.equal(FORECAST_METRICS.shipped(s), 1)
-})
-
-test('a folded order with no kind is a flow order, as it is in the hot list', () => {
-  const folded = hot([], { counts: { '': { shipped: 2 } }, boundaryMs: 1 })
-  const unfolded = hot([{ status: 'shipped' }, { status: 'shipped' }])
-  assert.equal(FORECAST_METRICS.orders(folded), FORECAST_METRICS.orders(unfolded))
-  assert.equal(FORECAST_METRICS.shipped(folded), FORECAST_METRICS.shipped(unfolded))
-})

package/test/forecast-tuning.test.ts

@@ -1,42 +0,0 @@
-/*
- * 예측 틱 크기 — **지평선이 정하고, 양끝은 묶인다.**
- *
- * 이 규칙이 틀리면 예측이 알리지 않고 비싸지거나(1초 고정 시절 9,000틱·28.5초) 알리지 않고 성글어진다
- * (짧은 작업이 한 틱에 삼켜진다). 둘 다 화면에는 그럴듯한 숫자로 나오므로 시험이 지킨다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { forecastStepMs, TARGET_TICKS_PER_RUN, MAX_STEP_MS, MIN_STEP_MS } from '../dist-server/service/twin-forecast/forecast-tuning.js'
-
-test('기본 지평선(5분)은 5초 단위 — 실측으로 1초와 답이 같고 5배 싸다', () => {
-  assert.equal(forecastStepMs(300_000), 5_000)
-})
-
-test('짧은 지평선은 더 잘게 — 1분이면 1초', () => {
-  assert.equal(forecastStepMs(60_000), 1_000)
-})
-
-test('아주 짧아도 커널 시각 단위 아래로 내려가지 않는다', () => {
-  assert.equal(forecastStepMs(5_000), MIN_STEP_MS)
-  assert.equal(forecastStepMs(0), MIN_STEP_MS)
-  assert.equal(forecastStepMs(Number.NaN), MIN_STEP_MS)
-})
-
-test('아무리 길어도 상한을 넘지 않는다 — 짧은 작업이 한 틱에 삼켜진다', () => {
-  assert.equal(forecastStepMs(2 * 60 * 60_000), MAX_STEP_MS)
-  assert.equal(forecastStepMs(24 * 60 * 60_000), MAX_STEP_MS)
-})
-
-test('틱 크기는 초 단위로 떨어진다 — 3,333ms 는 사람도 화면도 설명할 수 없다', () => {
-  for (const h of [100_000, 200_000, 333_000, 777_000]) {
-    assert.equal(forecastStepMs(h) % 1000, 0, `${h}ms`)
-  }
-})
-
-test('상한에 걸리지 않는 구간에서는 목표 틱 수 근처로 돈다', () => {
-  for (const h of [60_000, 120_000, 300_000, 600_000]) {
-    const ticks = h / forecastStepMs(h)
-    assert.ok(ticks >= TARGET_TICKS_PER_RUN * 0.8 && ticks <= TARGET_TICKS_PER_RUN * 1.25, `${h}ms → ${ticks}틱`)
-  }
-})

package/test/gap-analytics.test.ts

@@ -1,113 +0,0 @@
-/*
- * 예측 정확도 진단(gap-analytics) — SPC 두 축(안정성·편향)·정확도·보정의 canonical 계산을 서버에서 단언.
- * 클라에서 이전한 순수 함수라 DB 무의존, 결정적.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { computeSpc, gapMetrics, learnedCalibration, aggregatePoints } from '../server/service/twin-forecast/gap-analytics.ts'
-
-const pt = (error: number, actual = 100, inBand = true) => ({
-  t: 0, p50: actual - error, min: 0, max: 0, actual, error, inBand,
-  naiveAbsError: Math.abs(error) + 1, modelAbsError: Math.abs(error)
-})
-
-test('computeSpc — 표본 부족(n<4)은 insufficient', () => {
-  assert.equal(computeSpc([1, 2, 3]).insufficient, true)
-})
-
-test('computeSpc — 안정적·무편향: 0 주변 교대 오차', () => {
-  const spc = computeSpc([1, -1, 1, -1, 1, -1, 1, -1])
-  assert.equal(spc.stable, true, '이탈·추세 없음 → 안정')
-  assert.equal(spc.biased, false, '평균 0 → 무편향')
-})
-
-test('computeSpc — 안정적이지만 편향: 계속 +6 (안정성과 편향은 별개 축)', () => {
-  const spc = computeSpc([6, 6, 6, 6, 6, 6])
-  assert.equal(spc.stable, true, '오차 폭 일정 → 안정')
-  assert.equal(spc.biased, true, '평균이 0 에서 크게 벗어남 → 편향')
-  assert.equal(spc.biasSign, 'under', 'CL>0 = 실제>예측 = 과소예측')
-})
-
-test('computeSpc — 급변(3σ 이탈)은 shift', () => {
-  const spc = computeSpc([0.1, -0.1, 0.1, -0.1, 0.1, -0.1, 10])
-  assert.equal(spc.instability, 'shift')
-  assert.equal(spc.stable, false)
-})
-
-test('gapMetrics — 정확도=1−WMAPE, 커버리지·FVA', () => {
-  const m = gapMetrics([pt(1, 10, true), pt(-1, 10, false)])
-  assert.equal(m.accuracy, 90, '오차합2/실제합20=10% → 90%')
-  assert.equal(m.inBandCount, 1)
-  assert.equal(m.total, 2)
-  assert.equal(m.fva, 2, 'Σ(naiveAbs−modelAbs) = (2−1)+(2−1)')
-  assert.equal(m.fvaPct, 50, 'naive 오차 4 → 모델 2 → 50% 감소(예측 가치)')
-})
-
-test('learnedCalibration — biasShift=평균오차, 편향 제거로 정확도 개선', () => {
-  const pts = [pt(6, 100), pt(6, 100), pt(6, 100)]
-  const learn = learnedCalibration(pts, gapMetrics(pts))
-  assert.equal(learn.biasShift, 6, '학습된 편향 = 평균 오차')
-  assert.ok(learn.accAfter >= learn.accBefore, '편향 제거 → 정확도 유지·개선')
-  assert.equal(learn.accAfter, 100, '일정 편향을 완전 제거 → 잔차 0 → 100%')
-})
-
-/*
- * ★ Nothing to divide by is not 100% (2026-09-24). With every actual at 0 the card read
- * "100% accurate" beside "0 of 6 in band, mean error −20" — the installed build gave exactly that.
- */
-test('gapMetrics — a window with no actual says the percentages are not measured, and keeps what is', () => {
-  const idle = Array.from({ length: 6 }, () => ({ t: 0, p50: 20, min: 15, max: 25, actual: 0, error: -20, inBand: false, naiveAbsError: 0, modelAbsError: 20 }))
-  const m = gapMetrics(idle)
-  assert.equal(m.accuracy, null, 'WMAPE has no denominator — not 100%')
-  assert.equal(m.fvaPct, null, 'the naive error is 0 — "adds nothing" would be invented')
-  /* Measured in that window, so they stay. */
-  assert.equal(m.mpe, -20)
-  assert.equal(m.inBandCount, 0)
-  assert.equal(m.total, 6)
-  assert.equal(m.fva, -120)
-})
-
-test('learnedCalibration — the bias is still learned with no actual; only the percentages are not', () => {
-  const idle = Array.from({ length: 4 }, () => pt(-20, 0, false))
-  const learn = learnedCalibration(idle, gapMetrics(idle))
-  assert.equal(learn.biasShift, -20, 'forecasting 20 over a standing line is a bias worth removing')
-  assert.equal(learn.accBefore, null)
-  assert.equal(learn.accAfter, null, 'no denominator was made up (it used to be `|| 1`)')
-})
-
-/* 같은 격자 위의 점 — vantage 를 명시한다(예전 헬퍼는 t 를 늘 0 으로 두어 시간축을 전혀 시험하지 않았다). */
-const at = (t: number, error: number, actual = 100) => ({ ...pt(error, actual), t })
-
-test('aggregatePoints — 공동배치 합산(공장 총량)', () => {
-  const a = [at(10, 2, 30), at(20, 4, 30)]
-  const b = [at(10, 1, 20), at(20, 2, 20)]
-  const { points, droppedVantages } = aggregatePoints([a, b])
-  assert.equal(points.length, 2)
-  assert.equal(droppedVantages, 0)
-  assert.equal(points[0].actual, 50, '실제 30+20')
-  assert.equal(points[0].t, 10, '합산점의 시각은 그 vantage 다')
-  assert.equal(points[0].error, points[0].actual - points[0].p50, 'error = 실제−예측(합산 후 재계산)')
-})
-
-test('한 트윈이 못 잰 vantage 는 통째로 뺀다 — 빠진 트윈을 0 으로 세지 않는다', () => {
-  /*
-   * 예전에는 `max` 길이로 돌며 있는 것만 더했다. 그래서 이 경우 t=20 의 공장 총량이 20(b 뿐)으로
-   * 나왔다 — a 가 그 시각에 아무것도 안 했다는 뜻이 아니라, **못 쟀다**는 뜻인데도.
-   * 공장 합계 곡선이 꼬리에서 아래로 꺾이고, 그 곡선으로 예측 정확도를 판정했다.
-   */
-  const a = [at(10, 2, 30), null]
-  const b = [at(10, 1, 20), at(20, 2, 20)]
-  const { points, droppedVantages } = aggregatePoints([a as any, b])
-  assert.equal(points.length, 1, '모두가 값을 가진 vantage 만 남는다')
-  assert.equal(points[0].t, 10)
-  assert.equal(droppedVantages, 1, '뺀 개수를 돌려줘야 화면이 "2점 중 1점" 이라고 말할 수 있다')
-})
-
-test('길이가 다르면 뒤쪽은 뺀다 — 남은 트윈만의 합을 공장 총량이라 부르지 않는다', () => {
-  const a = [at(10, 2, 30)]
-  const b = [at(10, 1, 20), at(20, 2, 20)]
-  const { points, droppedVantages } = aggregatePoints([a, b])
-  assert.equal(points.length, 1)
-  assert.equal(droppedVantages, 1)
-})