@things-factory/headless-twin 10.0.3 → 10.0.5

package/test/kpi-fold.test.ts

@@ -0,0 +1,447 @@
+/*
+ * 업무 KPI 폴드 검증 — 저널을 접어 시간창 지표를 만드는 규칙을 고정한다.
+ *
+ * 무엇을 지키는가:
+ *  ① **성과는 완료 시점으로 센다** — 시작 시점으로 세면 진행 중인 것이 섞여 처리량이 부풀려진다.
+ *  ② **셈에서 빠진 것을 밝힌다**(unpaired) — 시작 이벤트를 못 찾은 완료를 조용히 버리면 평균이 거짓이 된다.
+ *  ③ **없는 것을 0 으로 꾸미지 않는다** — 저널이 비었으면 eventsSeen 0 으로 그 사실이 보인다.
+ *  ④ 시간축은 eventTime 차분 — sim 클록 오프셋이 있어도 차분은 정확하다.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { crossGroups, deltaP50, foldKpi, foldKpiBuckets, shiftWindow, type KpiEvent } from '../server/engine/kpi-fold.ts'
+
+const T0 = Date.parse('2026-07-30T00:00:00Z')
+const at = (sec: number) => new Date(T0 + sec * 1000).toISOString()
+
+/** task.status 전이 한 줄. */
+const task = (taskId: string, status: string, sec: number, resourceRef?: string): KpiEvent => ({
+  eventType: 'task.status',
+  eventTime: at(sec),
+  payload: { data: { taskId, status, resourceRef } }
+})
+
+/** 축을 가진 전이 한 줄 — kind·orderId·toNode 까지(실제 TaskStatusDelta 모양). */
+const taskAt = (taskId: string, status: string, sec: number, facets: Record<string, unknown>): KpiEvent => ({
+  eventType: 'task.status',
+  eventTime: at(sec),
+  payload: { data: { taskId, status, ...facets } }
+})
+
+const order = (orderId: string, status: string, sec: number): KpiEvent => ({
+  eventType: 'order.status',
+  eventTime: at(sec),
+  payload: { data: { orderId, status } }
+})
+
+const WINDOW = { fromMs: T0, toMs: T0 + 3600 * 1000 } // 1시간
+
+test('처리량: 창 안에 완료된 작업만 센다(진행 중은 세지 않는다)', () => {
+  const r = foldKpi(
+    [
+      task('t1', 'created', 0),
+      task('t1', 'in-progress', 10),
+      task('t1', 'completed', 30),
+      task('t2', 'created', 20),
+      task('t2', 'in-progress', 25) // 완료 없음 — 진행 중
+    ],
+    WINDOW
+  )
+  assert.equal(r.throughput.tasks, 1)
+})
+
+test('처리량: 창 밖에 완료된 것은 세지 않는다 — 창 경계는 완료 시각으로 판정', () => {
+  const r = foldKpi(
+    [task('t1', 'created', -100), task('t1', 'in-progress', -90), task('t1', 'completed', -10)],
+    WINDOW
+  )
+  assert.equal(r.throughput.tasks, 0)
+})
+
+test('리드타임·작업시간·대기시간을 각각 낸다 — 셋은 다른 질문에 답한다', () => {
+  /* 생성 0s → 착수 10s → 완료 40s : 리드 40s, 작업 30s, 대기 10s */
+  const r = foldKpi([task('t1', 'created', 0), task('t1', 'in-progress', 10), task('t1', 'completed', 40)], WINDOW)
+  assert.equal(r.leadTime.avgMs, 40000)
+  assert.equal(r.workTime.avgMs, 30000)
+  assert.equal(r.waitTime.avgMs, 10000)
+})
+
+test('분위수: p50·p90 을 낸다(작은 표본에서 과장하지 않는다)', () => {
+  const events: KpiEvent[] = []
+  /* 완료 소요를 1..10초로 열 건 */
+  for (let i = 1; i <= 10; i++) {
+    events.push(task(`t${i}`, 'created', 100 + i * 20))
+    events.push(task(`t${i}`, 'in-progress', 100 + i * 20))
+    events.push(task(`t${i}`, 'completed', 100 + i * 20 + i))
+  }
+  const r = foldKpi(events, WINDOW)
+  assert.equal(r.workTime.count, 10)
+  assert.equal(r.workTime.p50Ms, 6000)
+  assert.equal(r.workTime.p90Ms, 10000)
+})
+
+test('시작 이벤트를 못 찾은 완료는 unpaired 로 밝힌다 — 평균에서 조용히 빠지지 않게', () => {
+  const r = foldKpi([task('t1', 'completed', 30)], WINDOW)
+  assert.equal(r.throughput.tasks, 1, '완료는 센다')
+  assert.equal(r.leadTime.count, 0, '리드타임은 계산할 수 없다')
+  assert.equal(r.unpaired.leadTime, 1)
+  assert.equal(r.unpaired.workTime, 1)
+})
+
+test('창보다 앞선 시작도 짝지어진다 — 호출부가 앞 구간을 넉넉히 넘기면 리드타임이 살아난다', () => {
+  const r = foldKpi([task('t1', 'created', -600), task('t1', 'in-progress', -300), task('t1', 'completed', 60)], WINDOW)
+  assert.equal(r.leadTime.avgMs, 660000)
+  assert.equal(r.unpaired.leadTime, 0)
+})
+
+test('자원 점유: 작업에 붙어 있던 시간의 합과 창 대비 비율', () => {
+  const r = foldKpi(
+    [
+      task('t1', 'created', 0),
+      task('t1', 'in-progress', 0, 'fk-1'),
+      task('t1', 'completed', 1800, 'fk-1'), // 30분
+      task('t2', 'created', 0),
+      task('t2', 'in-progress', 0, 'fk-2'),
+      task('t2', 'completed', 900, 'fk-2') // 15분
+    ],
+    WINDOW
+  )
+  assert.deepEqual(
+    r.utilization.map(u => [u.resourceId, u.busyMs]),
+    [
+      ['fk-1', 1800000],
+      ['fk-2', 900000]
+    ],
+    '점유가 큰 자원부터'
+  )
+  assert.equal(Math.round(r.utilization[0].ratio * 100), 50, '1시간 창에서 30분 = 50%')
+})
+
+test('오더 완료: 도메인 어휘를 넓게 받는다(completed/fulfilled/done)', () => {
+  const r = foldKpi([order('o1', 'completed', 10), order('o2', 'fulfilled', 20), order('o3', 'in-progress', 30)], WINDOW)
+  assert.equal(r.throughput.orders, 2)
+})
+
+test('저널이 비면 0 이 아니라 "본 이벤트 없음" 으로 드러난다', () => {
+  const r = foldKpi([], WINDOW)
+  assert.equal(r.eventsSeen, 0)
+  assert.equal(r.eventsInWindow, 0)
+  assert.equal(r.throughput.tasks, 0)
+  assert.equal(r.leadTime.count, 0)
+})
+
+test('시각이 없거나 깨진 줄은 버린다 — 0 으로 세지 않는다', () => {
+  const r = foldKpi(
+    [
+      { eventType: 'task.status', payload: { data: { taskId: 'x', status: 'completed' } } },
+      { eventType: 'task.status', eventTime: 'not-a-date', payload: { data: { taskId: 'y', status: 'completed' } } }
+    ],
+    WINDOW
+  )
+  assert.equal(r.eventsSeen, 0)
+  assert.equal(r.throughput.tasks, 0)
+})
+
+test('payload 가 envelope 없이 델타만 와도 읽는다 — 저장 형태 차이에 걸리지 않게', () => {
+  const r = foldKpi(
+    [
+      { eventType: 'task.status', eventTime: at(0), payload: { taskId: 't1', status: 'in-progress' } },
+      { eventType: 'task.status', eventTime: at(20), payload: { taskId: 't1', status: 'completed' } }
+    ],
+    WINDOW
+  )
+  assert.equal(r.workTime.avgMs, 20000)
+})
+
+test('같은 전이가 두 번 와도 착수는 처음 것, 생성은 마지막 것 — 재시도에 흔들리지 않게', () => {
+  const r = foldKpi(
+    [
+      task('t1', 'created', 0),
+      task('t1', 'in-progress', 10),
+      task('t1', 'in-progress', 15), // 재전송
+      task('t1', 'completed', 40)
+    ],
+    WINDOW
+  )
+  assert.equal(r.workTime.avgMs, 30000, '처음 착수(10s) 기준')
+})
+
+/* ── 구간 쪼개기(추세) ─────────────────────────────────────────────────────
+ * 화면의 추세선이 여기서 나온다. 조회는 한 번이고 창만 바꿔 다시 접는다.
+ */
+test('구간 쪼개기: N 등분해 구간별 처리량을 낸다', () => {
+  /* 1시간 창을 4등분(15분씩). 각 구간에 한 건씩 완료되게 놓는다. */
+  const events: KpiEvent[] = []
+  for (let i = 0; i < 4; i++) {
+    const sec = i * 900 + 100 // 100s, 1000s, 1900s, 2800s
+    events.push(task(`t${i}`, 'created', sec - 30), task(`t${i}`, 'in-progress', sec - 20), task(`t${i}`, 'completed', sec))
+  }
+  const buckets = foldKpiBuckets(events, WINDOW, 4)
+  assert.equal(buckets.length, 4)
+  assert.deepEqual(buckets.map(b => b.tasks), [1, 1, 1, 1])
+})
+
+test('구간 쪼개기: 구간 합이 전체 창의 처리량과 같다 — 경계에서 새거나 겹치지 않는다', () => {
+  const events: KpiEvent[] = []
+  for (let i = 0; i < 20; i++) {
+    const sec = 50 + i * 170
+    events.push(task(`t${i}`, 'created', sec - 10), task(`t${i}`, 'in-progress', sec - 5), task(`t${i}`, 'completed', sec))
+  }
+  const whole = foldKpi(events, WINDOW)
+  const buckets = foldKpiBuckets(events, WINDOW, 6)
+  const sum = buckets.reduce((a, b) => a + b.tasks, 0)
+  assert.equal(sum, whole.throughput.tasks)
+})
+
+test('구간 쪼개기: 마지막 구간이 창의 끝까지 덮는다 — 나눗셈 오차로 마지막 완료가 빠지지 않게', () => {
+  /* 3등분(나누어떨어지지 않는 창) + 창의 마지막 순간에 완료 */
+  const win = { fromMs: WINDOW.fromMs, toMs: WINDOW.fromMs + 1000 * 1000 } // 1000초
+  const events = [task('t1', 'created', 0), task('t1', 'in-progress', 10), task('t1', 'completed', 1000)]
+  const buckets = foldKpiBuckets(events, win, 3)
+  assert.equal(buckets[buckets.length - 1].toMs, win.toMs)
+  assert.equal(buckets.reduce((a, b) => a + b.tasks, 0), 1)
+})
+
+test('구간 쪼개기: 1 이하면 쪼개지 않는다(추세 없음)', () => {
+  assert.deepEqual(foldKpiBuckets([], WINDOW, 1), [])
+  assert.deepEqual(foldKpiBuckets([], WINDOW, 0), [])
+})
+
+test('구간 쪼개기: 구간별 작업시간 중앙값을 낸다 — "느려지고 있는가" 를 본다', () => {
+  const events: KpiEvent[] = [
+    /* 앞 구간: 10초 작업 */
+    task('a', 'created', 100), task('a', 'in-progress', 100), task('a', 'completed', 110),
+    /* 뒤 구간: 40초 작업 */
+    task('b', 'created', 2000), task('b', 'in-progress', 2000), task('b', 'completed', 2040)
+  ]
+  const buckets = foldKpiBuckets(events, WINDOW, 2)
+  assert.equal(buckets[0].workP50Ms, 10000)
+  assert.equal(buckets[1].workP50Ms, 40000)
+})
+
+/* ── 관점 축(groupBy) ───────────────────────────────────────────────────────
+ * 왜 계산 층에 있는가: 고정된 한 렌즈만 낼 수 있으면 "구역별로는?" 이라는 질문에 화면도 AI 도 답할 수
+ * 없다. **사실 계산이 다각도를 못 내면 AI 도 못 낸다** — 그래서 축은 폴드의 능력이어야 한다.
+ */
+const three = (id: string, sec: number, facets: Record<string, unknown>): KpiEvent[] => [
+  taskAt(id, 'created', sec - 20, facets),
+  taskAt(id, 'in-progress', sec - 10, facets),
+  taskAt(id, 'completed', sec, facets)
+]
+
+test('축 없이는 groups 를 내지 않는다 — 묻지 않은 것을 실어 보내지 않는다', () => {
+  const r = foldKpi(three('t1', 100, { kind: 'move' }), WINDOW)
+  assert.equal(r.groups, undefined)
+})
+
+test('작업 종류별로 쪼갠다 — 전체 통계와 같은 규칙으로', () => {
+  const events = [
+    ...three('a', 100, { kind: 'move' }),
+    ...three('b', 200, { kind: 'move' }),
+    ...three('c', 300, { kind: 'pick' })
+  ]
+  const r = foldKpi(events, WINDOW, { groupBy: 'taskKind' })
+  assert.equal(r.groups?.by, 'taskKind')
+  assert.deepEqual(
+    r.groups?.items.map(g => [g.key, g.tasks]),
+    [
+      ['move', 2],
+      ['pick', 1]
+    ],
+    '건수 큰 축부터'
+  )
+  const move = r.groups!.items[0]
+  assert.equal(move.workTime.avgMs, 10000, '착수→완료 10초')
+  assert.equal(move.leadTime.avgMs, 20000, '생성→완료 20초')
+  assert.equal(move.busyMs, 20000, '두 건 × 10초')
+})
+
+test('축의 합이 전체 처리량과 같다 — 어느 축에서도 건이 새지 않는다', () => {
+  const events = [
+    ...three('a', 100, { kind: 'move', orderId: 'o1', toNode: 'dock-1', resourceRef: 'fk-1' }),
+    ...three('b', 200, { kind: 'pick', orderId: 'o1', toNode: 'rack-1', resourceRef: 'fk-2' }),
+    ...three('c', 300, { kind: 'pick', orderId: 'o2', toNode: 'rack-1' })
+  ]
+  const whole = foldKpi(events, WINDOW)
+  for (const by of ['resource', 'taskKind', 'node', 'order'] as const) {
+    const r = foldKpi(events, WINDOW, { groupBy: by })
+    const sum = r.groups!.items.reduce((a, g) => a + g.tasks, 0)
+    assert.equal(sum, whole.throughput.tasks, `${by} 축의 합`)
+  }
+})
+
+test('축의 값이 없던 건은 unknown 으로 모인다 — 조용히 버리지 않는다', () => {
+  const events = [...three('a', 100, { kind: 'move', resourceRef: 'fk-1' }), ...three('b', 200, { kind: 'move' })]
+  const r = foldKpi(events, WINDOW, { groupBy: 'resource' })
+  assert.deepEqual(r.groups?.items.map(g => g.key).sort(), ['fk-1', 'unknown'])
+})
+
+test('축의 값은 다른 전이에서 와도 읽는다 — 완료 이벤트에 kind 가 없어도 축이 비지 않는다', () => {
+  /* 생성에만 kind 가 실리는 구현이 실제로 있다. 완료 줄만 보면 축이 통째로 unknown 이 된다. */
+  const events = [
+    taskAt('a', 'created', 80, { kind: 'putaway', orderId: 'o9' }),
+    taskAt('a', 'in-progress', 90, {}),
+    taskAt('a', 'completed', 100, {})
+  ]
+  const r = foldKpi(events, WINDOW, { groupBy: 'taskKind' })
+  assert.deepEqual(r.groups?.items.map(g => g.key), ['putaway'])
+  const byOrder = foldKpi(events, WINDOW, { groupBy: 'order' })
+  assert.deepEqual(byOrder.groups?.items.map(g => g.key), ['o9'])
+})
+
+test('노드 축은 가장 최근 도착지 — 진행에 따라 바뀌는 값은 마지막 것이 사실', () => {
+  const events = [
+    taskAt('a', 'created', 80, { toNode: 'dock-1' }),
+    taskAt('a', 'in-progress', 90, { fromNode: 'dock-1', toNode: 'rack-7' }),
+    taskAt('a', 'completed', 100, { fromNode: 'dock-1', toNode: 'rack-7' })
+  ]
+  const r = foldKpi(events, WINDOW, { groupBy: 'node' })
+  assert.deepEqual(r.groups?.items.map(g => g.key), ['rack-7'])
+})
+
+test('구역 축은 노드→구역 지도를 받아야 낸다 — 지도가 없으면 노드 id 로 대체하지 않는다', () => {
+  const events = [...three('a', 100, { toNode: 'rack-1' }), ...three('b', 200, { toNode: 'rack-2' })]
+  const blind = foldKpi(events, WINDOW, { groupBy: 'area' })
+  assert.deepEqual(blind.groups?.items.map(g => [g.key, g.tasks]), [['unknown', 2]], '지도 없으면 unknown 하나')
+
+  const mapped = foldKpi(events, WINDOW, { groupBy: 'area', nodeArea: { 'rack-1': 'zone-a', 'rack-2': 'zone-a' } })
+  assert.deepEqual(mapped.groups?.items.map(g => [g.key, g.tasks]), [['zone-a', 2]], '두 노드가 한 구역으로 모인다')
+})
+
+test('축이 많으면 잘라내고 잘린 축의 수와 그 안의 건수를 함께 알린다 — 조용한 절단 금지', () => {
+  /* 축마다 건수를 다르게 둔다: 축의 수만 알리면 "그 외 20개" 가 20건인지 60건인지 알 수 없다. */
+  const events: KpiEvent[] = []
+  let t = 0
+  for (let i = 0; i < 25; i++) {
+    const n = i < 5 ? 3 : 1 // 앞 5개 축은 3건씩, 나머지 20개 축은 1건씩
+    for (let k = 0; k < n; k++) events.push(...three(`t${t++}`, 100 + t * 10, { orderId: `o${i}` }))
+  }
+  const r = foldKpi(events, WINDOW, { groupBy: 'order', groupLimit: 5 })
+  assert.equal(r.groups?.items.length, 5)
+  assert.equal(r.groups?.truncated, 20, '잘린 축의 수')
+  assert.equal(r.groups?.truncatedTasks, 20, '잘린 축들이 안고 있던 건수')
+  const whole = foldKpi(events, WINDOW)
+  assert.equal(
+    r.groups!.items.reduce((a, g) => a + g.tasks, 0) + r.groups!.truncatedTasks!,
+    whole.throughput.tasks,
+    '보여준 건수 + 잘린 건수 = 전체(축의 수가 아니라 건수로 맞는다)'
+  )
+})
+
+test('짝을 못 찾은 건도 축에서 센다 — 건수는 세고 소요만 비운다', () => {
+  const r = foldKpi([taskAt('a', 'completed', 100, { kind: 'move' })], WINDOW, { groupBy: 'taskKind' })
+  const g = r.groups!.items[0]
+  assert.equal(g.tasks, 1)
+  assert.equal(g.workTime.count, 0)
+  assert.equal(g.busyMs, 0)
+})
+
+/* ── 시간 비교 ──────────────────────────────────────────────────────────────
+ * "29초" 만으로는 좋아졌는지 나빠졌는지 알 수 없다. 창을 옮겨 한 번 더 접는 규칙을 고정한다.
+ */
+test('직전 구간: 같은 길이로 바로 앞 — 경계가 맞물린다(겹치거나 벌어지지 않게)', () => {
+  const w = shiftWindow(WINDOW.fromMs, WINDOW.toMs, 'previous')
+  assert.equal(w.toMs, WINDOW.fromMs, '앞 구간의 끝 = 현재 구간의 시작')
+  assert.equal(w.toMs - w.fromMs, WINDOW.toMs - WINDOW.fromMs, '길이가 같다')
+})
+
+test('어제 같은 시간: 정확히 24시간 전 같은 자리', () => {
+  const w = shiftWindow(WINDOW.fromMs, WINDOW.toMs, 'yesterday')
+  assert.equal(WINDOW.fromMs - w.fromMs, 24 * 60 * 60 * 1000)
+  assert.equal(w.toMs - w.fromMs, WINDOW.toMs - WINDOW.fromMs)
+})
+
+test('중앙값 차이: 현재 − 비교구간', () => {
+  const now = { count: 5, p50Ms: 40000, p90Ms: 0, avgMs: 0 }
+  const prev = { count: 5, p50Ms: 30000, p90Ms: 0, avgMs: 0 }
+  assert.equal(deltaP50(now, prev), 10000, '10초 느려졌다')
+  assert.equal(deltaP50(prev, now), -10000, '부호로 방향을 말한다(좋고 나쁨은 판단하지 않는다)')
+})
+
+test('중앙값 차이: 한쪽이 결측이면 차이는 없다 — 0 으로 내면 "변화 없음" 이라는 거짓이 된다', () => {
+  const measured = { count: 5, p50Ms: 40000, p90Ms: 0, avgMs: 0 }
+  const missing = { count: 0, p50Ms: 0, p90Ms: 0, avgMs: 0 }
+  assert.equal(deltaP50(measured, missing), undefined)
+  assert.equal(deltaP50(missing, measured), undefined)
+})
+
+test('비교: 옮긴 창으로 접으면 앞 구간의 성과가 나온다 — 같은 폴드, 창만 다르다', () => {
+  /* 현재 구간에 2건, 직전 구간에 1건. */
+  const events = [
+    ...three('now-1', 100, { kind: 'move' }),
+    ...three('now-2', 200, { kind: 'move' }),
+    ...three('prev-1', -1800, { kind: 'move' })
+  ]
+  const now = foldKpi(events, WINDOW)
+  const prev = foldKpi(events, shiftWindow(WINDOW.fromMs, WINDOW.toMs, 'previous'))
+  assert.equal(now.throughput.tasks, 2)
+  assert.equal(prev.throughput.tasks, 1)
+  assert.equal(now.throughput.tasks - prev.throughput.tasks, 1, '처리량이 1건 늘었다')
+})
+
+test('창 앞 구간만 읽었으면 "측정된 기록 있음" 이 아니다 — lookback 을 성과로 착각하지 않게', () => {
+  /* 호출부는 창보다 앞까지 읽어 넘긴다(완료 작업의 시작이 창 밖일 수 있어서). 그 앞 구간 기록만
+   * 있는데 eventsSeen 으로 판단하면 "0건 처리" 라고 말하게 된다 — 실제로 가능했던 오류다. */
+  const before = [task('t1', 'created', -1200), task('t1', 'in-progress', -1100), task('t1', 'completed', -1000)]
+  const r = foldKpi(before, WINDOW)
+  assert.equal(r.eventsSeen, 3, '넘겨받은 것은 3줄')
+  assert.equal(r.eventsInWindow, 0, '창 안에는 아무것도 없다 → "기록 없음"')
+  assert.equal(r.throughput.tasks, 0)
+})
+
+test('창 안 기록만 센다 — 앞 구간이 섞여도 창 안 개수는 정확하다', () => {
+  const events = [
+    task('old', 'completed', -500), // 창 밖(앞)
+    ...three('in-1', 100, { kind: 'move' }), // 창 안 3줄
+    task('late', 'completed', 4000) // 창 밖(뒤)
+  ]
+  const r = foldKpi(events, WINDOW)
+  assert.equal(r.eventsSeen, 5)
+  assert.equal(r.eventsInWindow, 3)
+})
+
+/* ── 관점 × 비교 교차 ───────────────────────────────────────────────────────
+ * 전체는 비슷한데 **한 구역만 나빠진** 경우를 전체 숫자로는 절대 못 본다. 그 교차가 운영에서 가장
+ * 값 있는 질문이다.
+ */
+const g = (key: string, tasks: number, workMs = 10000) => {
+  const events = []
+  for (let i = 0; i < tasks; i++) {
+    const sec = 100 + i * 30
+    events.push(
+      taskAt(`${key}-${i}`, 'created', sec - 20, { kind: key }),
+      taskAt(`${key}-${i}`, 'in-progress', sec, { kind: key }),
+      taskAt(`${key}-${i}`, 'completed', sec + workMs / 1000, { kind: key })
+    )
+  }
+  return foldKpi(events, WINDOW, { groupBy: 'taskKind' }).groups!.items[0]
+}
+
+test('교차: 두 구간에 모두 있는 축은 delta 를 낸다', () => {
+  const c = crossGroups([g('pick', 10, 20000)], [g('pick', 7, 10000)])
+  const it = c.items[0]
+  assert.equal(it.prevTasks, 7)
+  assert.equal(it.deltaTasks, 3)
+  assert.equal(it.deltaWorkP50Ms, 10000, '작업시간이 10초 늘었다')
+  assert.deepEqual(c.disappeared, [])
+})
+
+test('교차: 지금만 있는 축은 isNew — delta 를 건수와 같게 적으면 "늘었다" 로 오독된다', () => {
+  const c = crossGroups([g('putaway', 5)], [g('pick', 5)])
+  const nw = c.items.find(x => x.key === 'putaway')!
+  assert.equal(nw.isNew, true)
+  assert.equal(nw.deltaTasks, undefined)
+  assert.equal(nw.prevTasks, undefined)
+})
+
+test('교차: 사라진 축을 따로 알린다 — 멈춘 구역이 표에서 조용히 빠지지 않게', () => {
+  const c = crossGroups([g('pick', 5)], [g('pick', 5), g('putaway', 12)])
+  assert.deepEqual(c.disappeared, [{ key: 'putaway', tasks: 12 }])
+})
+
+test('교차: 비교 구간이 비면 전부 isNew 로 — 없던 것과 줄어든 것을 섞지 않는다', () => {
+  const c = crossGroups([g('pick', 3), g('putaway', 4)], [])
+  assert.equal(c.items.every(x => x.isNew === true), true)
+  assert.deepEqual(c.disappeared, [])
+})