@things-factory/headless-twin 10.0.14 → 10.0.17

package/test/journal-retention.test.ts

@@ -1,27 +1,26 @@
 /*
- * ★ 저널 보존 — **지우는 것은 선언이 있을 때만, 체크포인트가 대신할 수 있는 만큼만.**
+ * ★ 저널 보존 — **선언이 있을 때만 지운다. 그리고 도는 트윈에서만 체크포인트를 상한으로 본다.**
  *
  * ── 왜 필요한가 (2026-08-22 실측) ───────────────────────────────────────────
  * 개발 저널이 시간당 **581,794행 · 0.85GB**(하루 20GB)로 자랐다. 데모 MES 트윈 셋이 전체의 **97%** 를
- * 만들고 지우는 것이 없었다. 같은 날 고친 질의들은 「그 크기에서도 빠르게」였고 **크기 자체를 줄이는
- * 것은 없었다** — 그러면 며칠마다 같은 자리로 돌아온다.
+ * 만들고 지우는 것이 없었다.
  *
- * ── 그런데 저널을 지우는 것은 사실을 잃는 일이다 ────────────────────────────
- * 그래서 이 시험이 세 규율을 고정한다. 규율이 깨지면 잃는 것이 조용하다 — 지워진 저널은 「없었던 일」과
- * 구별되지 않는다.
+ * ── 체크포인트를 전제 조건으로 두었던 것이 결함이었다 (2026-08-27) ──────────
+ * 예전 규율은 「체크포인트가 없는 인스턴스는 건드리지 않는다」였다. 근거는 「그때 저널이 유일한 복구
+ * 수단이다」였고, 그 근거가 틀렸다. 트윈이 자기 저널과 어떤 관계인지는 `restartPolicy` 가 선언한다.
  *
- *  ① **선언이 없으면 아무것도 지우지 않는다.** 기본값은 없음이다.
- *  ② **체크포인트가 없는 인스턴스는 건드리지 않는다.** 그때 저널은 **유일한** 복구 수단이다
- *     (엔진 주석: 「만료 시 저널 replay 폴백」). 둘을 함께 잃으면 그 트윈의 상태는 되돌릴 수 없다.
- *  ③ **체크포인트 리비전보다 뒤는 지우지 않는다.** 그 뒤는 스냅샷이 대신하지 못한다.
+ *   resync   연결된 시스템에서 다시 읽는다   저널은 복구 수단이 아니다
+ *   reset    씨앗부터 다시 돌린다            저널은 복구 수단이 아니다
+ *   resume   저널을 이어 세운다              보관된 구간에서 세운다
  *
- * 그리고 보존 기간은 **스냅샷 TTL 보다 짧을 수 없다** — 짧으면 스냅샷이 살아 있는데 그것이 가리키는
- * 앞쪽 저널이 없는 구간이 생기고, 시간여행·계보가 그 구간에서 조용히 빈다.
+ * 셋 다 보관 기간 밖의 사건을 요구하지 않는다. 보존 기간을 7일로 선언한 것이 곧 「7일 전 상태로는
+ * 세우지 않는다」는 뜻이다. 그 전제 때문에 멈춘 트윈 셋에 2,900만 행이 영구히 남았다.
  *
- * ── 이 시험이 무엇을 재는가 ─────────────────────────────────────────────────
- * DB 를 띄우지 않는다. 이 규율은 **조건을 어떻게 세우나**에 있고, 그것은 순수하게 확인할 수 있다 —
- * 소스에서 그 조건 넷이 함께 있는지, 그리고 계약의 기본값이 무엇인지 본다. DB 위의 거동은 실서버에서
- * 로그로 확인한다(지운 건수를 말하므로 볼 수 있다).
+ * 체크포인트가 남는 일은 하나다. **도는 트윈**은 메모리에서 이어 집계하므로, 체크포인트가 아직 반영하지
+ * 못한 사건을 지우면 그 구간이 어디에도 없어진다. 그래서 도는 트윈에서만 그 리비전을 상한으로 쓴다.
+ *
+ * ── 이 테스트가 무엇을 재는가 ───────────────────────────────────────────────
+ * DB 를 띄우지 않는다. 이 규율은 **조건을 어떻게 세우나**에 있고 그것은 순수하게 확인할 수 있다.
  */
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
@@ -45,18 +44,27 @@ test('선언이 없으면 아무것도 지우지 않는다 — 기본값은 없
   assert.match(
     src,
     /static JOURNAL_RETENTION_DAYS\?: number = undefined/,
-    '보존 기간의 기본값은 undefined 여야 한다(조용히 지우는 것보다 조용히 쌓는 편이 낫다)'
+    '보존 기간의 기본값은 undefined 여야 한다(알리지 않고 지우는 것보다 알리지 않고 쌓는 편이 낫다)'
   )
   /* 그리고 그 값이 없으면 즉시 돌아간다. */
   assert.match(pruneBody(), /if \(!days \|\| days <= 0\) return/, '선언이 없으면 지우지 않고 돌아간다')
 })
 
-test('체크포인트가 없는 인스턴스는 건드리지 않는다 — 저널이 유일한 복구 수단이다', () => {
+test('★ 체크포인트는 상한이지 전제 조건이 아니다 — 없다는 이유로 건너뛰지 않는다', () => {
   const body = pruneBody()
-  assert.match(body, /loadSnapshot\(/, '스냅샷을 확인해야 한다')
-  assert.match(body, /if \(!upTo\)[\s\S]{0,200}?continue/, '스냅샷이 없으면 그 인스턴스를 건너뛴다')
-  /* 건너뛴 사실을 세고 말한다 — 조용히 넘기면 「보존이 도는데 왜 안 줄어드나」가 된다. */
-  assert.match(body, /skipped\.push/, '건너뛴 것을 센다')
+  /*
+   * 한 줄이 이 규율의 전부다. 있으면 그 리비전이 상한이고, 없으면 상한이 없다.
+   *
+   * 예전에는 없으면 그 트윈을 건너뛰었다. 그래서 멈춘 트윈 셋에 2,900만 행이 영구히 남았다 —
+   * 멈춘 트윈은 체크포인트를 다시 쓸 주체가 없어서 만료된 뒤 영원히 조건을 못 넘긴다.
+   */
+  assert.match(
+    body,
+    /const upTo = at > 0 \? at : Number\.MAX_SAFE_INTEGER/,
+    '체크포인트가 없으면 상한 없이 지운다'
+  )
+  assert.doesNotMatch(body, /if \(!upTo\)[\s\S]{0,200}?continue/, '없다는 이유로 건너뛰지 않는다')
+  assert.doesNotMatch(body, /skipped/, '건너뛰는 갈래가 아예 없다')
 })
 
 test('지우는 조건이 넷 다 있다 — 하나라도 빠지면 지나친 삭제가 된다', () => {
@@ -64,7 +72,7 @@ test('지우는 조건이 넷 다 있다 — 하나라도 빠지면 지나친
   for (const [what, re] of [
     ['도메인', /domain_id = :domainId/],
     ['인스턴스', /instance_id = :instanceId/],
-    ['체크포인트 리비전 이하', /revision <= :upTo/],
+    ['체크포인트 리비전 이하(도는 트윈에서는 상한, 멈춘 트윈에서는 무한)', /revision <= :upTo/],
     ['보존 기간 이전(실제 시계)', /created_at < :cutoff/]
   ] as [string, RegExp][]) {
     assert.match(body, re, `${what} 조건이 있어야 한다`)
@@ -93,14 +101,35 @@ test('도메인의 정책이 프로세스 기본값보다 먼저다 — 그리
   assert.doesNotMatch(src, /from '@things-factory\/setting-base'/, '엔진은 Setting 을 알지 않는다')
 })
 
-test('보존 기간은 스냅샷 TTL 보다 짧아질 수 없다 — 짧으면 앞쪽이 비는 구간이 생긴다', () => {
+test('★ 보존 기간을 스냅샷 TTL 로 올리지 않는다 — 두 값은 다른 것을 정한다', () => {
+  /*
+   * 예전에는 `max(보존 기간, 스냅샷 TTL)` 이었다. 둘 다 7일이라 상향은 없었지만, 그 식은 두 값을 묶어
+   * 놓아서 보존 기간을 줄이면 스냅샷 TTL 이 따라오게 만든다.
+   *
+   *   보존 기간      이력을 며칠 두나
+   *   스냅샷 TTL     빠르게 세우기 위한 저장본이 며칠 사나
+   *
+   * 저장본이 만료되어도 트윈은 보관된 구간에서 세워진다. 그래서 보존 기간이 더 짧아도 성립한다.
+   */
   const body = pruneBody()
-  assert.match(body, /SNAPSHOT_TTL_S \/ 86400/, '스냅샷 TTL 을 하한으로 삼아야 한다')
-  assert.match(body, /Math\.max\(days, minDays\)/, '선언이 그보다 짧으면 올린다')
-  assert.match(body, /twinWarn\(/, '올렸다는 사실을 말한다(조용히 바꾸지 않는다)')
+  assert.doesNotMatch(body, /Math\.max\(days, minDays\)/, '두 값을 묶지 않는다')
+  assert.match(body, /const effectiveDays = days/, '선언한 보존 기간을 그대로 쓴다')
 })
 
-test('지운 것을 말한다 — 조용히 줄어든 저널은 없었던 일과 구별되지 않는다', () => {
+test('★ 멈출 때는 만료 없이 적는다 — 그러지 않으면 7일 뒤 그 상태를 아는 것이 없다', () => {
+  /*
+   * 멈춘 트윈은 아무도 스냅샷을 다시 쓰지 않아서 7일 뒤 만료된다. 멈추는 순간이 그 상태가 메모리에
+   * 있는 마지막 순간이므로 그때 만료 없이 적는다. 그러면 다시 뜰 때 보관된 구간을 계산하지 않아도 된다.
+   */
+  assert.match(src, /static SNAPSHOT_KEEP_S = /, '만료 없이 두는 기간에 이름이 있어야 한다')
+  const at = src.indexOf('static async stop(')
+  assert.ok(at > 0, 'stop 이 있어야 한다')
+  const stopBody = src.slice(at, at + 1600)
+  assert.match(stopBody, /persistSnapshot\(domainId, id, true\)/, '멈출 때는 만료 없이 적는다')
+  assert.match(src, /keepForever \? this\.SNAPSHOT_KEEP_S : this\.SNAPSHOT_TTL_S/, '그 값이 실제로 쓰인다')
+})
+
+test('지운 것을 말한다 — 알리지 않고 줄어든 저널은 없었던 일과 구별되지 않는다', () => {
   const body = pruneBody()
   assert.match(body, /journal pruned/, '지운 건수를 로그에 남긴다')
   assert.match(body, /revision ≤/, '어디까지 지웠는지 함께 남긴다')
@@ -121,7 +150,7 @@ test('선언도 없고 물을 길도 없으면 주기 정리를 걸지 않는다
    * 앱이 답하는 시임(`retentionDaysOf`)이 있고, 그것이 심겨 있으면 기본값이 없어도 걸어야 한다
    * (그 도메인이 자기 값을 가질 수 있다). 반대로 **둘 다 없으면 물을 곳이 없으므로** 걸지 않는다.
    *
-   * 기본값만 보게 두면 시임만 심은 배포에서 정리가 조용히 돌지 않는다 — 「보존을 켰는데 왜 안 줄어드나」.
+   * 기본값만 보게 두면 시임만 심은 배포에서 정리가 알리지 않고 돌지 않는다 — 「보존을 켰는데 왜 안 줄어드나」.
    */
   assert.match(
     body,
@@ -131,3 +160,116 @@ test('선언도 없고 물을 길도 없으면 주기 정리를 걸지 않는다
   /* 타이머가 프로세스를 붙잡지 않게 — 지우는 일이 종료를 막을 이유가 없다. */
   assert.match(body, /unref/, '타이머는 unref 한다')
 })
+
+/*
+ * ★ 나눠서 지운다 — 한 문장으로 통째 지우면 그동안 호스트가 멈춘다.
+ *
+ * 실측(2026-08-25 · 개발 환경 44GB): 보관 기간 7일에 13일치가 쌓여 있었고, 그 밀린 몫이 한 번에
+ * 나왔다. 한 번의 지우기가 74초·79초였고 그 뒤에 한 줄짜리 `domains` 조회가 67초로 찍혔다 — 그
+ * 질의의 문제가 아니라 줄을 선 값이다. sqlite 는 쓰기가 하나다.
+ *
+ * 이 테스트는 소스를 전수 조회해 규율을 지킨다: 배치 경계를 먼저 찾는가 · 한 창의 시간 상한이 있는가 ·
+ * 배치 사이에 루프를 비워 주는가. 실제 지우기는 큰 기록이 있어야 재현되므로 여기서 재지 않는다.
+ */
+test('★ 지우기를 배치로 나눈다 — 쓰기 잠금을 한 번에 오래 잡지 않는다', () => {
+  const src = readFileSync(ENGINE, 'utf8')
+  assert.ok(/JOURNAL_PRUNE_BATCH\s*=\s*[0-9_]+/.test(src), '한 배치의 행 수가 이름을 갖고 있어야 한다')
+  assert.ok(/JOURNAL_PRUNE_BUDGET_MS\s*=\s*[0-9_]+/.test(src), '한 창의 시간 상한이 이름을 갖고 있어야 한다')
+  const prune = src.slice(src.indexOf('static async pruneJournal'))
+  const body = prune.slice(0, prune.indexOf('static startRetentionLoop'))
+  assert.ok(body.includes('JOURNAL_PRUNE_BATCH'), '배치 경계를 찾는 데 그 수를 쓴다')
+  assert.ok(body.includes('JOURNAL_PRUNE_BUDGET_MS'), '한 창의 시간 상한을 본다')
+  assert.ok(/setImmediate/.test(body), '배치 사이에 루프를 비워 준다 — 없으면 나눈 뜻이 없다')
+  /* `DELETE … LIMIT` 은 드라이버마다 다르다 — 경계 `revision` 을 찾아 그 아래만 지운다. */
+  assert.ok(!/delete[\s\S]{0,200}limit\(/i.test(body), 'DELETE 에 LIMIT 을 붙이지 않는다')
+})
+
+/*
+ * ★ 앞부분이 지워진 것을 목록이 말한다.
+ *
+ * 정리가 오래된 사건을 지우면 목록을 아무리 내려가도 어느 지점에서 기록이 끝난다. 화면이 그것을 말하지
+ * 않으면 사람은 「이 트윈은 그때 시작했다」로 읽는다. 없었던 것과 지워진 것은 다른 사실이다.
+ */
+test('★ 남아 있는 가장 오래된 리비전을 목록이 함께 낸다 — 지워진 것을 없었던 것으로 보이지 않게', () => {
+  const type = readFileSync(
+    join(import.meta.dirname, '..', 'server', 'service', 'twin-event', 'twin-event-type.ts'),
+    'utf8'
+  )
+  assert.match(type, /oldestRevision\?: number/, '목록 응답에 그 칸이 있어야 한다')
+  assert.match(type, /retention policy/, '무슨 뜻인지 설명이 있어야 한다(화면이 문구를 만든다)')
+
+  const query = readFileSync(
+    join(import.meta.dirname, '..', 'server', 'service', 'twin-journal', 'twin-journal-query.ts'),
+    'utf8'
+  )
+  /* 저장하지 않고 조회할 때 구한다 — 저장한 값은 실제 데이터와 어긋날 수 있다. */
+  assert.match(query, /orderBy\('e\.revision', 'ASC'\)[\s\S]{0,120}?limit\(1\)/, '가장 작은 리비전 한 행만 읽는다')
+  /* 트윈 하나를 물었을 때만 — 여러 트윈을 합치면 리비전은 트윈마다 따로 세는 번호다. */
+  assert.match(query, /if \(instanceIds\.length === 1\)/, '트윈 하나일 때만 낸다')
+  assert.match(query, /nextCursor, oldestRevision \}/, '응답에 실어 보낸다')
+})
+
+/*
+ * ★ 경계를 시각순으로 찾는다 — 그러지 않으면 색인이 쓰이지 않는다.
+ *
+ * ── 무엇이 났나 (2026-08-27 실측 · 개발 파일 54GB · 3,128만 행) ───────────────
+ * 배치 경계를 `ORDER BY revision` 으로 찾았다. 그러면 계획기가 리비전 색인을 고르고, 지울 대상인지는
+ * 행마다 `created_at` 을 열어 확인한다. 지울 것이 적으면 그 트윈의 저널을 끝까지 걸어야 「한 배치를
+ * 못 채웠다」를 알 수 있다 — 1,029만 행에서 그것이 2초 예산을 다 썼고 44건만 지우고 멈췄다.
+ *
+ * 실측한 질의 계획.
+ *
+ *   ORDER BY revision      SEARCH USING INDEX ix_twin_event_0             ← 행마다 테이블을 연다
+ *   ORDER BY createdAt     SEARCH USING COVERING INDEX ix_twin_event_8    ← 테이블을 열지 않는다
+ *   DELETE (정렬 없음)      SEARCH USING INDEX ix_twin_event_8            ← 색인만으로 이미 고쳐졌다
+ *
+ * 그리고 `created_at` 축 색인을 얹었다(`ix_twin_event_8`). 7일 밖 건수 조회가 208초에서 1.68초가 됐다.
+ */
+test('★ 배치 경계를 createdAt 순으로 찾는다 — revision 순으로 찾으면 색인을 못 쓴다', () => {
+  const body = pruneBody()
+  assert.match(body, /\.orderBy\('e\.createdAt', 'ASC'\)/, '시각순으로 물어야 색인을 쓴다')
+  assert.doesNotMatch(body, /\.orderBy\('e\.revision', 'ASC'\)/, '리비전 순으로 되돌아가지 않는다')
+  /* 같은 시각의 행이 여럿일 수 있으므로 경계는 `<=` 다 — `<` 로 두면 제자리걸음이 된다. */
+  assert.match(body, /created_at <= :batchCutoff/, '경계 시각 이하까지 지운다')
+})
+
+test('★ createdAt 축 색인이 선언돼 있다 — 없으면 정리가 전량 주사한다', () => {
+  const entity = readFileSync(
+    join(import.meta.dirname, '..', 'server', 'service', 'twin-event', 'twin-event.ts'),
+    'utf8'
+  )
+  assert.match(
+    entity,
+    /@Index\('ix_twin_event_8', \(e: TwinEvent\) => \[e\.domain, e\.instanceId, e\.createdAt\]/,
+    '(domain, instanceId, createdAt) 색인이 있어야 한다'
+  )
+  /* 그리고 그것을 만드는 마이그레이션이 배선돼 있어야 한다 — 선언만 있으면 배포에 생기지 않는다. */
+  const list = readFileSync(join(import.meta.dirname, '..', 'server', 'migrations', 'index.ts'), 'utf8')
+  assert.match(list, /IndexEventCreatedAt1786400000000/, '마이그레이션 목록에 있어야 한다')
+})
+
+test('★ 한 문장이 짧아야 화면이 오래 멈추지 않는다 — 실측이 그 수를 정한다', () => {
+  /*
+   * ── 무엇이 났나 (2026-08-28 실측) ──────────────────────────────────────────
+   * 배치가 20,000 이었고, 한 문장이 그만큼 지우는 데 4~5.6초였다(서버 기록: hatio-mx2 20,130줄
+   * 5.2초). sqlite 는 연결이 하나라 그동안 **화면의 모든 질의가 줄을 선다** — 첫 화면 조회가
+   * 12.2초였다(정상 상태 40밀리초).
+   *
+   * 그리고 예산이 **문장이 끝난 뒤에** 검사되므로 한 문장이 2초 예산을 2~3배 넘겼다. 배치를 나눈 뜻이
+   * 그만큼 없어진다.
+   *
+   * 고칠 축은 총 시간이 아니라 **한 번에 멈추는 길이**다. 그래서 배치를 줄이고 예산을 늘렸다 —
+   * 지우는 양은 같고 잠금만 잘게 나뉜다.
+   */
+  const src = readFileSync(ENGINE, 'utf8')
+  const batch = /JOURNAL_PRUNE_BATCH\s*=\s*([0-9_]+)/.exec(src)?.[1]?.replace(/_/g, '')
+  const budget = /JOURNAL_PRUNE_BUDGET_MS\s*=\s*([0-9_]+)/.exec(src)?.[1]?.replace(/_/g, '')
+  assert.ok(batch && budget)
+  /* 줄당 약 0.26밀리초로 재었다 — 한 문장이 1초를 넘지 않아야 한다. */
+  const perStatementMs = Number(batch) * 0.26
+  assert.ok(perStatementMs <= 1000, `한 문장이 ${Math.round(perStatementMs)}밀리초로 추정된다 — 1초를 넘으면 화면이 그만큼 멈춘다`)
+  /* 예산이 문장 여럿을 담아야 나눈 뜻이 있다 — 하나만 담으면 예산 검사가 아무 일도 하지 않는다. */
+  assert.ok(Number(budget) / perStatementMs >= 3, '예산이 한 문장에 삼켜지면 배치를 나눈 뜻이 없다')
+  /* 실측 근거가 코드에 적혀 있어야 한다 — 다음 사람이 다시 재지 않고 바꾸지 않게. */
+  assert.match(src, /20,130줄/, '무엇을 재서 이 수가 나왔는지 적혀 있어야 한다')
+})

package/test/journal-sort-axis.test.ts

@@ -73,7 +73,7 @@ test('저널을 시간으로 거르는 질의는 시간으로 정렬한다 —
 
       /*
        * **상한이 있는 질의만 본다.** 이 결함은 「상한이 정렬 뒤에 걸려 무력해지는 것」이다. 상한이 없는
-       * 질의(재개 시 체크포인트 뒤를 전부 접는 경로)는 어차피 전부 읽어야 하므로 정렬 축을 바꿔도
+       * 질의(재개 시 체크포인트 뒤를 전부 계산하는 경로)는 어차피 전부 읽어야 하므로 정렬 축을 바꿔도
        * 얻는 것이 없다 — 그 자리를 붉히면 **거짓 빨강**이고, 그런 가드는 없는 것보다 나쁘다.
        */
       if (!/\b(take|limit)\s*[:(]/.test(q)) continue

package/test/journal-write-door.test.ts

@@ -17,7 +17,7 @@
  * 배치로 옮기면 주기 사이에 멈출 때 그 구간이 사라진다 — **라이브도 이미 그랬다**(최대 200ms). 그래서
  * 정지 때 남은 것을 흘리는 자리를 함께 만들었다. 상태만 남기고 저널을 잃으면 「왜 그렇게 됐나」가 빈다.
  *
- * 이 시험은 소스로 규율을 지킨다(DB 없이 도는 스위트다). 정량화는 조용한 서버의 `journalRate` 가 답한다.
+ * 이 시험은 소스로 규율을 지킨다(DB 없이 도는 스위트다). 정량화는 들어온 것이 없는 서버의 `journalRate` 가 답한다.
  */
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
@@ -30,7 +30,7 @@ const engine = readFileSync(fileURLToPath(new URL('../server/engine/twin-engine.
  * 메서드 본문만 — 다른 자리의 같은 낱말에 걸리지 않게.
  *
  * **다음 메서드 선언에서 끊는다.** 길이로 자르면 옆 메서드가 딸려 와, 「이 메서드가 몇 번 부르나」를
- * 세는 단정이 조용히 틀린다(실제로 그렇게 2를 세었다).
+ * 세는 단정이 오류 없이 틀린 값을 낸다(실제로 그렇게 2를 세었다).
  */
 function methodOf(src: string, name: string): string {
   const at = src.indexOf(`${name}(`)
@@ -82,7 +82,7 @@ test('멈출 때 남은 것을 흘린다 — 성능을 사려고 사실을 팔
 test('두 구동이 같은 계기를 든다 — 세지 않는 개선은 되돌려도 아무도 모른다', () => {
   /*
    * 계기(`inst.metrics`)가 `startLive` 에만 있었다. 그래서 도는 트윈 22개가 시뮬인 서버에서 「초당 몇 행을
-   * 쓰나」·「밀린 게 있나」를 물을 자리가 없었고, 모니터 목록에서도 시뮬이 조용히 빠졌다(계기가 null 이라
+   * 쓰나」·「밀린 게 있나」를 물을 자리가 없었고, 모니터 목록에서도 시뮬이 알리지 않고 빠졌다(계기가 null 이라
    * 걸러졌다) — 부하가 거의 없는 것처럼 보였다.
    */
   assert.match(engine, /private static newMetrics\(\): TwinMetrics/, '계기 한 벌을 한 곳에서 만든다')

package/test/journal-write-trend.test.ts

@@ -33,7 +33,7 @@ const T0 = 1_700_000_000_000
 
 /* ── ① 유입 없이도 추이가 생긴다 ──────────────────────────────────────────── */
 
-test('받는 것 없이 적기만 하는 트윈도 추이에 남는다 — 시뮬이 조용히 빠지지 않게', () => {
+test('받는 것 없이 적기만 하는 트윈도 추이에 남는다 — 시뮬이 오류 없이 빠지지 않게', () => {
   const l = newIngestLedger()
   const closed: any[] = []
 

package/test/kernel-kind-guard.test.ts

@@ -8,14 +8,14 @@
  *
  * 폴백이 둘 겹쳐 있었다. ①은 컬럼이 비었을 때, ②는 표에 없는 값일 때. 그리고 `kind` 는
  * 검증 없는 자유 문자열이다(`@Arg('kind') kind: string` — enum 도 화이트리스트도 없다).
- * 그래서 오타 하나·대소문자 하나로 **야드/생산 트윈이 조용히 창고 커널로 돌았다.**
+ * 그래서 오타 하나·대소문자 하나로 **야드/생산 트윈이 오류 없이 창고 커널로 돌았다.**
  * 오류가 없으니 화면에는 트윈이 정상으로 보이고, 안에서 도는 규칙만 다른 도메인의 것이다.
  * 예측 경로가 가장 나빴다 — 야드의 미래를 창고 규칙으로 굴려 놓고 숫자만 뜬다.
  *
  * ── 왜 검사로 남기나 ────────────────────────────────────────────────────────
  * 자리를 고치는 것만으로는 부족하다. 커널 종류가 늘 때(다음은 TMS 든 무엇이든) 새 자리가
  * 생기고, `?? WmsKernel` 은 "안전한 기본값" 처럼 보여서 다시 자란다. 실제로 세 자리에
- * 똑같이 자라 있었다. 틀린 공장을 조용히 띄우는 것보다 뜨지 않는 편이 낫다.
+ * 똑같이 자라 있었다. 틀린 공장을 알리지 않고 띄우는 것보다 뜨지 않는 편이 낫다.
  *
  * 이 검사가 막는 것은 **표를 밖에서 직접 색인하는 것**이다. 종류→커널 해소는 `kernelFor`
  * 하나만 한다. 새 자리를 쓸 때 이 검사가 걸리면, 폴백을 붙이지 말고 `kernelFor` 를 부를 것.
@@ -59,7 +59,7 @@ test('종류→커널 해소는 kernelFor 한 곳만 한다', () => {
   assert.deepEqual(indexing, [], 'KERNELS 를 밖에서 색인하고 있다 — kernelFor(kind) 를 쓸 것')
 })
 
-test('kernelFor 는 모르는 종류에 오류를 낸다 — 조용히 고르지 않는다', () => {
+test('kernelFor 는 모르는 종류에 오류를 낸다 — 알리지 않고 고르지 않는다', () => {
   const src = readFileSync(ENGINE, 'utf-8')
   const fn = src.slice(src.indexOf('function kernelFor'))
   assert.match(fn.slice(0, 300), /throw new Error/, 'kernelFor 가 오류를 내지 않으면 이 계약이 무너진다')

package/test/knob-defaults.test.ts

@@ -1,5 +1,5 @@
 /*
- * 노브 기본값 — **조용히 아무것도 안 하는 트윈**이 만들어지지 않게.
+ * 노브 기본값 — **알리지 않고 아무것도 안 하는 트윈**이 만들어지지 않게.
  *
  * 기본값을 아는 곳은 노브 스키마(계약)인데 그것을 적용하는 곳이 위자드뿐이었다. 그래서 화면을 거치지
  * 않는 호출자가 파라미터를 일부만 주면 템플릿 안에서 발생률이 0 이 되고, 이벤트를 하나도 만들지 않는

package/test/kpi-baseline-db.test.ts

@@ -2,7 +2,7 @@
  * ★ 여러 구간 동시 비교 — **실 DB로 배관을 넘어 본다.**
  *
  * 분포 산수는 `kpi-baseline.test.ts`(순수)가 지킨다. 여기서 지키는 것은 **호스트 배관**이다:
- * 창을 하루씩 뒤로 옮겨 **각 창을 따로 읽는가** · 그 창을 같은 규칙으로 접는가 · 지표 값을 정본 표
+ * 창을 하루씩 뒤로 옮겨 **각 창을 따로 읽는가** · 그 창을 같은 규칙으로 계산하는가 · 지표 값을 정본 표
  * (`TWIN_METRIC`)로 꺼내는가 · 기록 없는 날을 결측으로 남기는가.
  *
  * 이 배관은 **경계를 넘어야만** 틀리는 것이 드러난다. 실제로 앱의 시뮬 트윈은 저널이 두 시간 남짓이라
@@ -99,7 +99,7 @@ before(async () => {
   /*
    * 지금 창 20건 · 어제 40건 · 그제 60건 · **3일 전은 기록 없음** · 4일 전 80건.
    * 3일 전을 비워 두는 것이 이 스펙의 요점이다 — 그 날이 결측으로 남고 분포에서 빠지는지 본다
-   * (조용히 빼면 "지난 4일" 이 실제로는 3일이었다는 것을 아무도 모른다).
+   * (알리지 않고 빼면 "지난 4일" 이 실제로는 3일이었다는 것을 아무도 모른다).
    */
   const rows = [
     ...taskRows(0, 20, 30_000, 1000),