@things-factory/headless-twin 10.0.15 → 10.0.18

package/dist-server/engine/twin-engine.js

@@ -10,12 +10,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TwinEngine = void 0;
 const log_js_1 = require("./log.js");
+const read_time_js_1 = require("./read-time.js");
 const shell_1 = require("@things-factory/shell");
 /* 저널을 자를 조건은 SQL 이 안다 — 관용구만 쓴다(원시 SQL 은 5개 드라이버에서 갈라진다). */
 const typeorm_1 = require("typeorm");
 const cache_service_1 = require("@things-factory/cache-service");
 const twin_event_js_1 = require("../service/twin-event/twin-event.js");
 const twin_event_keys_js_1 = require("../service/twin-event/twin-event-keys.js");
+const twin_subject_writer_js_1 = require("../service/twin-subject/twin-subject-writer.js");
+const item_resolver_js_1 = require("../service/twin-subject/item-resolver.js");
 const warm_start_js_1 = require("./warm-start.js");
 const local_declarations_js_1 = require("./local-declarations.js");
 const runtime_key_js_1 = require("./runtime-key.js");
@@ -50,9 +53,11 @@ const live_attentions_js_1 = require("./live-attentions.js");
 const attention_digest_js_1 = require("./attention-digest.js");
 const live_feed_registry_js_1 = require("./live-feed-registry.js");
 const ingest_health_js_1 = require("./ingest-health.js");
-const twin_kernel_1 = require("@operato/twin-kernel");
+const ingest_dedupe_js_1 = require("./ingest-dedupe.js");
+const ops_contract_1 = require("@operato/ops-contract");
 /* 커널 런타임 로드 — CJS 번들(dist-cjs). 타입은 위 import type 로. replay = 이벤트열→상태 재구성(복구·시간여행). */
-const { WmsKernel, YmsKernel, MesKernel, EmsKernel, TwinRuntime, StateProjector, replay, replayFrom, replayWithCheckpoint, replaySegments, readBoardLocations, readBoardEquipment, DOMAIN_CATALOG, OP_EVENT, validateScenario } = require('@operato/twin-kernel');
+const { WmsKernel, YmsKernel, MesKernel, EmsKernel, TwinRuntime, StateProjector, replay, replayFrom, replayWithCheckpoint, replaySegments } = require('@operato/twin-kernel');
+const { readBoardLocations, readBoardEquipment, DOMAIN_CATALOG, OP_EVENT, validateScenario } = require('@operato/ops-contract');
 const KERNELS = { wms: WmsKernel, yms: YmsKernel, mes: MesKernel, ems: EmsKernel };
 /**
  * 시각축을 구할 때 한 번에 띄우는 트윈 수.
@@ -95,11 +100,11 @@ function parseTime(v) {
  * 종류 문자열 → 커널. **모르는 값이면 오류를 낸다.**
  *
  * 예전에는 표를 찾고 없으면 WmsKernel 로 떨어졌다. `kind` 는 검증 없는 자유 문자열(`@Arg('kind') kind: string`)
- * 이라 오타 하나·대소문자 하나로 야드/생산 트윈이 **조용히 창고 커널로 돌았다.** 오류가 없으니 화면에는
+ * 이라 오타 하나·대소문자 하나로 야드/생산 트윈이 **오류 없이 창고 커널로 돌았다.** 오류가 없으니 화면에는
  * 트윈이 정상으로 보이고, 안에서 도는 규칙만 다른 도메인의 것이다. 예측 경로가 가장 나쁘다 —
  * 야드의 미래를 창고 규칙으로 실행해 놓고 숫자만 뜬다.
  *
- * 틀린 공장을 조용히 띄우는 것보다 뜨지 않는 편이 낫다.
+ * 틀린 공장을 알리지 않고 띄우는 것보다 뜨지 않는 편이 낫다.
  */
 function kernelFor(kind) {
     const K = KERNELS[kind];
@@ -113,16 +118,34 @@ let observeUnavailableWarned = false;
  * **이 커널의 진실이 원본에서 온다고 선언한다** — 그리고 선언이 닿지 않았으면 말한다.
  *
  * ── 무엇이 틀렸나 (2026-08-21) ──────────────────────────────────────────────
- * 예전에는 `kernel.observe?.()` 였다. 옵셔널 호출이라 **메서드가 없으면 조용히 아무것도 하지 않는다.**
+ * 예전에는 `kernel.observe?.()` 였다. 옵셔널 호출이라 **메서드가 없으면 알리지 않고 아무것도 하지 않는다.**
  * 설치된 커널 0.7.39 에는 그 메서드가 없으므로, 지금 배포본에서는 미러가 관측 구동으로 선언되지
  * 않는다 — 그런데 코드를 읽으면 선언한 것처럼 보인다.
  *
  * 그 차이가 실제 거동을 가른다: 관측 구동은 원본의 빈틈을 받아들이고 세지만, 시뮬로 오인된 미러는
- * **멈춘다.** 즉 「관용이 켜진 줄 알았는데 안 켜져 있다」가 조용히 지나가고, 장애가 났을 때 원인이
+ * **멈춘다.** 즉 「관용이 켜진 줄 알았는데 안 켜져 있다」가 알리지 않고 지나가고, 장애가 났을 때 원인이
  * 커널에 있는 것처럼 보인다 — 원인은 버전이다.
  *
  * 그래서 옵셔널 호출을 없애고, 없으면 **한 번 경고한다.** 커널이 배포되면 이 경고는 사라진다.
  */
+/**
+ * 저장된 기록을 **도는 동안과 같은 코드로** 처리하게 한다 (2026-08-27).
+ *
+ * ── 무엇이 틀렸나 ───────────────────────────────────────────────────────────
+ * 도는 동안 사건을 처리하는 것은 도메인 커널이다(`startLive` 가 `new Kernel(...)` 을 세운다). 그런데
+ * 저장된 기록으로 과거 시점 상태를 만드는 경로는 커널 종류를 넘기지 않아서 도메인 규칙 없이
+ * 처리했다. 그 결과 「어제 오후 3시에 이 발전소가 어땠나」를 물으면 발전량과 계량이 늘 비어 있었다 —
+ * 받아서 저장까지 해 둔 값인데 읽는 쪽이 건너뛴 것이다.
+ *
+ * 종류는 모델에 없다(등록부가 든다). 그래서 호스트가 말해 준다.
+ */
+function replayOptions(reg, domainId) {
+    return {
+        kind: reg?.kind,
+        productionSpec: reg?.model?.productionSpec,
+        tenantId: domainId
+    };
+}
 function declareObserved(kernel, what) {
     if (typeof kernel?.observe === 'function') {
         kernel.observe();
@@ -158,7 +181,7 @@ class TwinEngine {
      *
      * 판정을 예산(500ms)이 아니라 **굶김 문턱**으로 따로 둔다: 조금 느린 트윈은 계기판이 말하게 두고
      * (경고), 호스트를 굶기는 트윈만 멈춘다. 한 번으로 멈추지 않는다 — 웜스타트 직후의 첫 틱은 원래
-     * 무겁다(복구한 상태를 처음 접는다). **연속**으로 이어질 때가 구조적으로 느린 것이다.
+     * 무겁다(복구한 상태를 처음 계산한다). **연속**으로 이어질 때가 구조적으로 느린 것이다.
      */
     /*
      * ── 틱을 **한 순간에 몰지 않는다** (2026-08-21 실측) ────────────────────────
@@ -176,7 +199,7 @@ class TwinEngine {
     /**
      * 흩어진 첫 발화 뒤 주기 틱. **핸들은 항상 진짜 타이머**다 — 정지하는 쪽이 `clearInterval(inst.timer)`
      * 하나로 끝내야 하므로, 첫 발화 전에는 그 `setTimeout` 을, 이후에는 `setInterval` 을 같은 자리에 둔다
-     * (감싼 객체를 주면 `clearInterval` 이 아무 일도 하지 않고 트윈이 멈추지 않는다 — 조용한 결함이 된다).
+     * (감싼 객체를 주면 `clearInterval` 이 아무 일도 하지 않고 트윈이 멈추지 않는다 — 들어온 것이 없는 결함이 된다).
      */
     static startTickTimer(fn, hold) {
         const spread = Math.max(1, Math.round(this.TICK_MS / 20));
@@ -207,7 +230,7 @@ class TwinEngine {
      * 저널은 그대로 진실(시간여행/history replay 무변경) — 캐시는 display-only 웜스타트 최적화. */
     static { this.SNAPSHOT_CACHE_ID = 'twin-snapshot'; }
     /*
-     * ── 재개점 **사슬** — 과거를 물었을 때 목표 직전에서 접기 위해 (2026-08-18) ──
+     * ── 재개점 **사슬** — 과거를 물었을 때 목표 직전에서 계산 위해 (2026-08-18) ──
      *
      * 최신 재개점 하나로는 시간여행을 도울 수 없다: 그것은 언제나 목표보다 **뒤**에 있다. 그래서 지점을
      * 여러 개 남긴다. 다만 그것들은 각각 상태 전체를 들고 있어 무겁다 — 한 행에 몰아 넣으면 거대한
@@ -215,13 +238,20 @@ class TwinEngine {
      *
      * 간격은 리비전 눈금으로 잡는다(`CHAIN_STRIDE`): 눈금을 넘을 때만 한 지점을 남기므로, 저널이 빠르게
      * 자라는 트윈에서도 지점 수가 폭발하지 않는다. 오래된 것부터 버리고 최근 `CHAIN_KEEP` 개만 든다 —
-     * 과거로 깊이 갈수록 지점이 없어 0부터 접는 것은 **알려진 한계**다(무한 보관보다 정직하다).
+     * 과거로 깊이 갈수록 지점이 없어 0부터 계산하는 것은 **알려진 한계**다(무한 보관보다 정직하다).
      */
     static { this.CHAIN_CACHE_ID = 'twin-fold-chain'; }
     static { this.CHAIN_INDEX_CACHE_ID = 'twin-fold-chain-index'; }
     static { this.CHAIN_STRIDE = 5000; } // 리비전 눈금 — 이 간격을 넘을 때만 한 지점을 남긴다
-    static { this.CHAIN_KEEP = 5; } // 최근 몇 지점을 들고 있나(그보다 과거는 0부터 접는다)
+    static { this.CHAIN_KEEP = 5; } // 최근 몇 지점을 들고 있나(그보다 과거는 0부터 계산한다)
     static { this.SNAPSHOT_TTL_S = 7 * 24 * 3600; } // 7일 — 정상 다운타임 생존, 만료 시 저널 replay 폴백
+    /**
+     * 멈춘 트윈의 마지막 상태를 두는 기간 — 사실상 만료 없음 (2026-08-27).
+     *
+     * 캐시 계층에 「만료 없음」을 뜻하는 값이 없어서 큰 수를 쓴다(`ICacheService` 는 초 단위 TTL 하나만
+     * 받는다). 100년이면 이 시스템의 수명보다 길다.
+     */
+    static { this.SNAPSHOT_KEEP_S = 100 * 365 * 24 * 3600; }
     static { this.CHECKPOINT_MS = 20000; } // 체크포인트 주기(핫 브로드캐스트 경로와 분리, O(state) 스로틀)
     /**
      * **저널 보존 — 지우는 것은 선언이 있을 때만 한다.**
@@ -234,28 +264,39 @@ class TwinEngine {
      * ── 그런데 저널을 지우는 것은 사실을 잃는 일이다 ──────────────────────────
      * 그래서 세 규율을 지킨다.
      *
-     *  ① **선언이 없으면 아무것도 지우지 않는다.** 기본값은 없음이다 — 조용히 지우는 편이 조용히 쌓는
+     *  ① **선언이 없으면 아무것도 지우지 않는다.** 기본값은 없음이다 — 알리지 않고 지우는 편이 알리지 않고 쌓는
      *     것보다 나쁘다. 지우는 것은 사람이 정한다.
      *  ② **체크포인트가 대신할 수 있는 만큼만.** 스냅샷이 없거나 그 리비전을 넘는 자리는 건드리지 않는다.
      *     주석이 「만료 시 저널 replay 폴백」이라고 적어 둔 그대로 — 스냅샷이 사라지면 저널이 **유일한**
      *     복구 수단이므로, 둘을 함께 잃으면 그 트윈의 상태는 되돌릴 수 없다.
-     *  ③ **지운 것을 말한다.** 몇 건을 어느 시각까지 지웠는지 로그에 남긴다. 조용히 줄어든 저널은
+     *  ③ **지운 것을 말한다.** 몇 건을 어느 시각까지 지웠는지 로그에 남긴다. 알리지 않고 줄어든 저널은
      *     「없었던 일」과 구별되지 않는다.
      *
      * 그리고 보존 기간은 **스냅샷 TTL(7일)보다 짧을 수 없다.** 더 짧으면 스냅샷이 살아 있는데 그것이
-     * 가리키는 앞쪽 저널이 없는 구간이 생기고, 시간여행·계보 추적이 그 구간에서 조용히 빈다.
+     * 가리키는 앞쪽 저널이 없는 구간이 생기고, 시간여행·계보 추적이 그 구간에서 알리지 않고 빈다.
      */
     static { this.JOURNAL_RETENTION_DAYS = undefined; }
     static { this.RETENTION_SWEEP_MS = 10 * 60 * 1000; } // 10분마다 한 번 — 지우는 일은 급하지 않다
     /** 최신 스냅샷을 cache-service 에 체크포인트(도메인+instanceId 키). display-only·비차단·오류흡수. */
-    static async persistSnapshot(domainId, instanceId) {
+    static async persistSnapshot(domainId, instanceId, 
+    /**
+     * 만료를 두지 않는다 — **트윈을 멈출 때만** 참이다 (2026-08-27).
+     *
+     * 도는 트윈은 주기적으로 다시 쓰므로 7일 만료가 걸리지 않는다. 멈춘 트윈은 아무도 쓰지 않아서
+     * 7일 뒤 만료되고, 그러면 그 트윈의 마지막 상태를 아는 것이 아무것도 없다. 멈추는 순간이 그
+     * 상태가 메모리에 있는 마지막 순간이므로 그때 만료 없이 적는다.
+     *
+     * 만료된 뒤에도 그 트윈은 보관된 구간에서 다시 세워진다(보관 기간만큼이므로 유한하다). 다만 그
+     * 구간 앞의 상태는 알 수 없다. 멈추는 순간에 적어 두면 그 손실이 없다.
+     */
+    keepForever = false) {
         const inst = this.instances[(0, runtime_key_js_1.runtimeKey)(domainId, instanceId)];
         if (!inst)
             return;
         /*
          * **봉투가 아니라 상태를 저장한다.** `snapshot()` 은 시뮬에서 `runtime.resync()` 봉투를 주는데,
          * 그것을 다시 `{revision, state}` 로 감싸 넣어 왔다 → 꺼낸 값에 축이 하나도 없어 웜스타트가
-         * 조용히 넘어갔다(저널에 수천 건이 있어도 트윈이 빈 채로 떴다).
+         * 알리지 않고 넘어갔다(저널에 수천 건이 있어도 트윈이 빈 채로 떴다).
          */
         const state = (0, warm_start_js_1.unwrapState)(this.snapshot(domainId, instanceId));
         if (!state)
@@ -278,7 +319,7 @@ class TwinEngine {
          *
          * 원본이 실제로 「다 비었다」고 말한 경우는 막지 않는다 — 그때는 유입이 있었으므로 이 문을 지난다.
          *
-         * 그리고 **거절을 말한다**: 조용히 거절하면 왜 체크포인트가 낡아 가는지 아무도 모른다.
+         * 그리고 **거절을 말한다**: 알리지 않고 거절하면 왜 체크포인트가 낡아 가는지 아무도 모른다.
          */
         if (!(inst.metrics?.ingestedTotal > 0)) {
             const observed = (s) => (s?.items?.length ?? 0) + (s?.orders?.length ?? 0) + (s?.tasks?.length ?? 0);
@@ -297,52 +338,52 @@ class TwinEngine {
         /* 구조 리비전도 함께 — 읽는 쪽이 "이 상태가 지금의 공장인가" 를 가릴 수 있어야 한다. */
         const { structureRev } = await this.tipOf(domainId, instanceId).catch(() => ({ structureRev: null }));
         /*
-         * ── **이어 접을 씨앗을 함께 적는다** (2026-08-24) ──────────────────────────
+         * ── **이어 계산할 씨앗을 함께 적는다** (2026-08-24) ──────────────────────────
          *
          * 이 함수는 오랫동안 `{revision, state, structureRev}` 만 적었다. 그래서 **재개점을 읽는 쪽은 다
-         * 있는데 쓰는 쪽이 없었다**: 조회 경로(`recover`)는 `fold` 가 있으면 꼬리만 접고, 없으면 저널을
-         * 0부터 접는다. 실측으로 저장된 스냅샷 34건 전부 `fold` 가 비어 있었고, 저널은 2,960만 줄이었다 —
-         * 그래서 재기동·조회마다 처음부터 다시 접었다. 규모 기준(엔티티 10만·품목 100만)에서 이것은
+         * 있는데 쓰는 쪽이 없었다**: 조회 경로(`recover`)는 `fold` 가 있으면 꼬리만 계산하고, 없으면 저널을
+         * 0부터 계산한다. 실측으로 저장된 스냅샷 34건 전부 `fold` 가 비어 있었고, 저널은 2,960만 줄이었다 —
+         * 그래서 재기동·조회마다 처음부터 다시 계산했다. 규모 기준(엔티티 10만·품목 100만)에서 이것은
          * 느린 것이 아니라 **못 하는 것**이다.
          *
          * 씨앗은 상태가 대신할 수 없다: 리듀서는 소비처가 보는 값 말고도 든다(부모를 기다리는 담김·집계
-         * 중인 수량·담을 줄 몰라 세어 둔 사건). 상태만 되돌리고 뒤를 접으면 0부터 접은 결과와 **조용히**
+         * 중인 수량·담을 줄 몰라 세어 둔 사건). 상태만 되돌리고 뒤를 계산하면 0부터 계산한 결과와 **알리지 않고**
          * 달라진다. 그 동치는 커널 시험이 증명한다(`observed-checkpoint.test.ts`).
          *
          * 관측 구동이 아니면 씨앗이 없다 — 시뮬은 리듀서를 갖지 않고, 그 상태의 권위는 커널 자신이다.
-         * 그때는 `fold` 를 **넣지 않는다**(빈 씨앗을 넣으면 읽는 쪽이 「이어 접을 수 있다」고 잘못 본다).
+         * 그때는 `fold` 를 **넣지 않는다**(빈 씨앗을 넣으면 읽는 쪽이 「이어 계산할 수 있다」고 잘못 본다).
          */
         const reducer = inst.kernel?.observedCheckpoint?.();
         const fold = reducer && inst.oee ? { reducer, oee: inst.oee.serialize() } : undefined;
-        await cache_service_1.cacheService.setInCache(this.SNAPSHOT_CACHE_ID, { domainId, instanceId }, { revision, state, structureRev, ...(fold ? { fold } : {}) }, this.SNAPSHOT_TTL_S);
+        await cache_service_1.cacheService.setInCache(this.SNAPSHOT_CACHE_ID, { domainId, instanceId }, { revision, state, structureRev, ...(fold ? { fold } : {}) }, keepForever ? this.SNAPSHOT_KEEP_S : this.SNAPSHOT_TTL_S);
     }
     /**
-     * 접기의 **재개점** — 리듀서 내부 상태 전부 + 가동 누적기.
+     * 계산의 **재개점** — 리듀서 내부 상태 전부 + 가동 누적기.
      *
-     * 스냅샷(`state`)은 소비처가 보는 값이라 이어 접기의 씨앗이 되지 못한다(보류된 담김·집합·반영 못 한
-     * 사건 집계가 없다 — 그 상태로 뒤를 접으면 0부터 접은 결과와 조용히 달라진다). 그래서 씨앗은 따로 든다.
+     * 스냅샷(`state`)은 소비처가 보는 값이라 이어 계산의 씨앗이 되지 못한다(보류된 담김·집합·반영 못 한
+     * 사건 집계가 없다 — 그 상태로 뒤를 계산하면 0부터 계산한 결과와 오류 없이 달라진다). 그래서 씨앗은 따로 든다.
      */
     static { this.FOLD_NOTE = 'reducer + oee checkpoint — the seed for folding only the tail'; }
     /**
-     * 재기동에 쓸 **웜스타트 씨앗**을 만든다 — 상태 + 이어 접을 재개점.
+     * 재기동에 쓸 **웜스타트 씨앗**을 만든다 — 상태 + 이어 계산할 재개점.
      *
      * ── 왜 이 자리가 생겼나 (2026-08-24) ──────────────────────────────────────
      * 두 호출부가 같은 일을 조금씩 다르게 하고 있었고(겹포장을 한쪽만 벗겼다), 둘 다 **재개점을 버리고**
      * 상태만 들고 갔다. 그래서 저장된 재개점을 읽는 쪽이 다 있는데도 재기동은 매번 저널을 처음부터
-     * 접었다(실측: 저널 2,960만 줄).
+     * 계산했다(실측: 저널 2,960만 줄).
      *
      * 여기서 하는 일 셋:
      *  ① 겹포장을 벗긴다 — 옛 형식으로 저장된 값이 한 번은 반드시 나온다
      *  ② **그 공장이 아직 그 공장인지** 심판한다 — 아니면 씨앗을 버린다(아래)
-     *  ③ 씨앗이 저널 끝보다 앞서 있으면 **그 꼬리만 접어** 끝까지 밀어 둔다
+     *  ③ 씨앗이 저널 끝보다 앞서 있으면 **그 꼬리만 계산해** 끝까지 밀어 둔다
      *
      * ②가 필요한 이유: 재개점은 그때의 보드 위에서 만들어진 것이다. 그 뒤 구조가 바뀌었다면(자리가
      * 빠졌다·설비가 옮겨졌다) 되세운 리듀서는 **지금 없는 자리와 설비를 든다** — 없는 냉장실이 화면에
      * 나오고 그 자리의 판정이 계속 돌아간다. 오류 없이 틀리므로 눈에 띄지 않는다.
      *
      * ③이 필요한 이유: 스냅샷은 체크포인트 주기로 쓰이므로 마지막 주기 이후의 사실은 저널에만 있다.
-     * 그것을 빼고 되세우면 그만큼이 조용히 사라진다 — 「모름」을 「없음」으로 적는 것과 같은 부류다.
-     * 접는 구간은 **그 틈뿐**이고(저널 전체가 아니다), `recover` 가 그 자리에서 새 재개점을 남겨 준다.
+     * 그것을 빼고 되세우면 그만큼이 오류 없이 사라진다 — 「모름」을 「없음」으로 적는 것과 같은 부류다.
+     * 계산하는 구간은 **그 틈뿐**이고(저널 전체가 아니다), `recover` 가 그 자리에서 새 재개점을 남겨 준다.
      */
     static async warmSeedFor(domainId, instanceId) {
         let cached = await this.loadSnapshot(domainId, instanceId).catch(() => null);
@@ -357,18 +398,43 @@ class TwinEngine {
                 `at ${tip.structureRev} — starting without it (the journal is folded from the beginning instead).`);
             return { revision: cached.revision, state: (0, warm_start_js_1.unwrapState)(cached.state) };
         }
-        if (tip && (cached.revision ?? 0) < tip.revision) {
+        /*
+         * ── **묻지 못했으면 그 사실을 말한다** (2026-08-28) ─────────────────────────
+         *
+         * 여기가 `if (tip && …)` 이었다. 위에서 `tipOf` 가 실패하면 `null` 이 되고, 그러면 이 갈래가
+         * **아무 말 없이 건너뛴다** — 저장본 뒤의 사건을 반영하지 못한 채 뜨고, 로그에 아무 흔적이 없다.
+         * 실측(2026-08-28 10:34): 저장본 3,372,228 · 저널 머리 3,374,894 인데 계산했다는 줄도, 못 했다는
+         * 줄도 없었다.
+         */
+        if (!tip) {
+            (0, log_js_1.twinWarn)(`[twin-engine] "${instanceId}": could not read the journal tip — starting from the stored seed at revision ` +
+                `${cached.revision ?? 0} without folding what came after it. Some recent facts may be missing from state.`);
+            return { revision: cached.revision, ...seedOf(cached), state: (0, warm_start_js_1.unwrapState)(cached.state) };
+        }
+        if ((cached.revision ?? 0) < tip.revision) {
             /*
-             * 틈을 접는다 — `recover` 가 이 씨앗으로 **꼬리만** 접고, 끝 지점의 새 재개점을 남긴다.
+             * 틈을 계산한다 — `recover` 가 이 씨앗으로 **꼬리만** 계산하고, 끝 지점의 새 재개점을 남긴다.
              * 아직 이 트윈의 런타임이 없으므로 `recover` 는 메모리 대신 저널 경로를 탄다(그것이 여기의 전제다).
              */
             const gap = tip.revision - (cached.revision ?? 0);
-            await this.recover(domainId, instanceId).catch(err => (0, log_js_1.twinWarn)(`[twin-engine] "${instanceId}": could not fold the ${gap} event(s) after the checkpoint — ${err?.message ?? err}`));
+            let failed;
+            await this.recover(domainId, instanceId).catch(err => {
+                failed = err?.message ?? String(err);
+                (0, log_js_1.twinWarn)(`[twin-engine] "${instanceId}": could not fold the ${gap} event(s) after the checkpoint — ${failed}`);
+            });
             const advanced = await this.loadSnapshot(domainId, instanceId).catch(() => null);
             if (advanced?.state && (advanced.revision ?? 0) > (cached.revision ?? 0)) {
                 (0, log_js_1.twinLog)(`[twin-engine] "${instanceId}": folded ${gap} event(s) after the checkpoint → revision ${advanced.revision}.`);
                 cached = advanced;
             }
+            else if (!failed) {
+                /*
+                 * **아무 일도 하지 않은 것을 말한다.** 계산이 오류 없이 끝났는데 재개점이 나아가지 않았다는 뜻이고,
+                 * 그러면 그 사건들의 결과가 상태에 없다. 예전에는 이 갈래가 조건에 걸리지 않아 침묵했다.
+                 */
+                (0, log_js_1.twinWarn)(`[twin-engine] "${instanceId}": folding the ${gap} event(s) after the checkpoint left the seed at revision ` +
+                    `${cached.revision ?? 0} — state starts without those facts. The screens may show them as absent.`);
+            }
         }
         return { revision: cached.revision, state: (0, warm_start_js_1.unwrapState)(cached.state), ...seedOf(cached) };
     }
@@ -378,10 +444,10 @@ class TwinEngine {
         return entry?.value ?? null;
     }
     /**
-     * 접은 상태를 스냅샷으로 남긴다 — **라이브가 아니어도.**
+     * 계산한 상태를 스냅샷으로 남긴다 — **라이브가 아니어도.**
      *
      * `persistSnapshot` 은 기동 중인 인스턴스에서만 뜬다(메모리가 진실이므로 옳다). 그런데 **멈춘**
-     * 트윈을 조회할 때마다 저널을 전량 다시 접고 있었다(23,731건짜리 트윈에서 4.6초). 그 폴드의 결과를
+     * 트윈을 조회할 때마다 저널을 전량 다시 계산하고 있었다(23,731건짜리 트윈에서 4.6초). 그 폴드의 결과를
      * 남겨 두면 **처음 한 번만 느리다.**
      *
      * `structureRev` 를 함께 적는다: 이벤트가 하나도 안 늘어도 구조를 갈아치우면(재프로비저닝) 그
@@ -401,11 +467,11 @@ class TwinEngine {
         return Array.isArray(revs) ? revs.filter((r) => Number.isFinite(r)).sort((a, b) => a - b) : [];
     }
     /**
-     * 목표 이전의 **가장 가까운 지점**을 고른다 — 없으면 `null`(0부터 접는다).
+     * 목표 이전의 **가장 가까운 지점**을 고른다 — 없으면 `null`(0부터 계산한다).
      *
      * 시각으로 물었으면 그 지점의 마지막 사실 시각이 목표 이내여야 한다(리비전만 보면 목표보다 뒤의
      * 사실이 씨앗에 섞인다). 구조가 바뀐 트윈에서는 쓰지 않는다 — 마디를 건너뛴 씨앗은 그 경계의
-     * 판정을 잃는다(그 경우는 0부터 접는 것이 옳다).
+     * 판정을 잃는다(그 경우는 0부터 계산하는 것이 옳다).
      */
     static async chainSeedFor(domainId, instanceId, target) {
         const revs = await this.chainIndex(domainId, instanceId);
@@ -456,19 +522,49 @@ class TwinEngine {
     }
     /** 이 트윈 저널의 끝 리비전 · 최신 구조 리비전 — 스냅샷이 지금의 사실인지 가리는 두 값. */
     static async tipOf(domainId, instanceId) {
+        /*
+         * ── **관계로 묻지 않는다** (2026-08-28) ─────────────────────────────────────
+         *
+         * `findOne({ where: { domain: { id } } })` 는 관계를 가진 엔티티에서 두 단계 질의가 되고 **안쪽에
+         * 상한이 없다** — 조건에 맞는 행을 전부 만들어 놓고 밖에서 한 줄을 고른다. 이 파일이 같은 것을
+         * 실측해 적어 두었다(§`twinEvents`: 0.024초 대 12초, 저널 375만 행).
+         *
+         * 이 함수는 **부팅마다 트윈마다** 불린다. 승화푸드 저널이 337만 행이므로 그 한 번이 부팅을
+         * 붙잡는다. 관계를 컬럼으로 물으면 감싸지 않고 색인(`domain, instance, revision`)의 첫 줄로 끝난다.
+         */
         const [tip, newest] = await Promise.all([
-            (0, shell_1.getRepository)(twin_event_js_1.TwinEvent).findOne({ where: { domain: { id: domainId }, instanceId }, order: { revision: 'DESC' } }),
-            (0, shell_1.getRepository)(twin_structure_js_1.TwinStructure).findOne({ where: { domain: { id: domainId }, instanceId }, order: { rev: 'DESC' } })
+            (0, shell_1.getRepository)(twin_event_js_1.TwinEvent)
+                .createQueryBuilder('e')
+                .select('e.revision', 'revision')
+                .where('e.domain = :domainId', { domainId })
+                .andWhere('e.instanceId = :instanceId', { instanceId })
+                .orderBy('e.revision', 'DESC')
+                .limit(1)
+                .getRawOne(),
+            (0, shell_1.getRepository)(twin_structure_js_1.TwinStructure)
+                .createQueryBuilder('s')
+                .select('s.rev', 'rev')
+                .where('s.domain = :domainId', { domainId })
+                .andWhere('s.instanceId = :instanceId', { instanceId })
+                .orderBy('s.rev', 'DESC')
+                .limit(1)
+                .getRawOne()
         ]);
-        return { revision: tip?.revision ?? 0, structureRev: newest?.rev ?? null };
+        const revision = Number(tip?.revision);
+        const structureRev = Number(newest?.rev);
+        return {
+            revision: Number.isFinite(revision) ? revision : 0,
+            structureRev: Number.isFinite(structureRev) ? structureRev : null
+        };
     }
     /**
-     * **저널을 보존 기간까지만 둔다** — 체크포인트가 대신할 수 있는 만큼만 지운다.
+     * **저널을 보존 기간까지만 둔다.**
      *
-     * 한 인스턴스에서 지우는 조건은 **둘 다** 만족해야 한다.
+     * 지우는 조건은 하나다 — `createdAt` 이 보존 기간보다 오래됐다(**행이 쓰인 실제 시각**이 기준이다).
      *
-     *  · `createdAt` 이 보존 기간보다 오래됐다 — **행이 쓰인 실제 시각**이 기준이다
-     *  · `revision` 이 **체크포인트 리비전 이하**다 — 그 앞은 스냅샷이 대신한다
+     * **도는 트윈**에서만 조건이 하나 더 붙는다: `revision` 이 체크포인트 리비전 이하여야 한다. 도는
+     * 트윈은 메모리에서 이어 집계하므로, 체크포인트가 아직 반영하지 못한 사건을 지우면 그 구간이
+     * 어디에도 없어진다. 멈춘 트윈에는 이어 집계할 메모리가 없어서 이 조건이 없다.
      *
      * ── 왜 `eventTime` 이 아니라 `createdAt` 인가 (2026-08-22 실측으로 고침) ────
      * 처음에 `eventTime` 으로 적었다. 그것은 **트윈의 시계**다 — 시뮬레이션은 자기 시계로 사건을 찍고,
@@ -483,9 +579,17 @@ class TwinEngine {
      * `createdAt` 은 그 행이 DB 에 쓰인 시각이고 1,599만 행 전부 채워져 있다(확인함). 도메인 시각을
      * 정책에 쓰지 않는다 — 그 둘을 섞으면 시뮬과 미러에서 같은 설정이 다르게 동작한다.
      *
-     * 스냅샷이 없으면 **그 인스턴스는 건드리지 않는다.** 저널이 유일한 복구 수단인 상태이므로, 지우면
-     * 그 트윈의 상태를 되돌릴 수 없다. 「지울 수 없었다」는 사실도 함께 센다 — 조용히 넘기면 「보존이
-     * 도는데 왜 안 줄어드나」가 된다.
+     * ── 왜 체크포인트를 전제 조건으로 두지 않나 (2026-08-27) ───────────────────
+     * 예전에는 체크포인트가 없으면 그 트윈을 건드리지 않았다. 「저널이 유일한 복구 수단」이라는 전제
+     * 때문이었고, 그 전제가 틀렸다. 트윈이 자기 저널과 어떤 관계인지는 `restartPolicy` 가 선언한다 —
+     * `resync` 는 연결된 시스템에서 다시 읽고, `reset` 은 씨앗부터 돌리고, `resume` 은 보관된 구간에서
+     * 세운다. 셋 다 보관 기간 밖의 사건을 요구하지 않는다.
+     *
+     * 보존 기간을 7일로 선언한 것이 곧 「7일 전 상태로는 세우지 않는다」는 뜻이다. 그 전제를 지키느라
+     * 지우지 않으면, 멈춘 트윈의 저널이 영구히 남는다 — 실측으로 세 트윈에 2,900만 행이 그렇게 남았다.
+     *
+     * 「지울 수 없었다」는 사실은 그대로 센다(도는데 체크포인트가 아직 없는 경우) — 알리지 않고 넘기면
+     * 「보존이 도는데 왜 안 줄어드나」가 된다.
      *
      * `createdAt` 이 빈 옛 행은 **지우지 않는다**(시각을 모르는 것을 「오래됐다」로 읽지 않는다).
      *
@@ -496,52 +600,193 @@ class TwinEngine {
         const perDomain = this.retentionDaysOf ? await this.retentionDaysOf(domainId).catch(() => undefined) : undefined;
         const days = perDomain ?? this.JOURNAL_RETENTION_DAYS;
         if (!days || days <= 0)
-            return { deleted: 0, instances: 0, skipped: [] };
-        /* 보존 기간은 스냅샷 TTL 보다 짧을 수 없다 — 짧으면 스냅샷이 가리키는 앞쪽이 비는 구간이 생긴다. */
-        const minDays = this.SNAPSHOT_TTL_S / 86400;
-        const effectiveDays = Math.max(days, minDays);
-        if (effectiveDays !== days) {
-            (0, log_js_1.twinWarn)(`[twin-engine] journal retention ${days}일은 스냅샷 TTL(${minDays}일)보다 짧다 — ${effectiveDays}일로 올린다 ` +
-                '(더 짧으면 스냅샷이 살아 있는데 그것이 가리키는 앞쪽 저널이 없는 구간이 생긴다)');
-        }
+            return { deleted: 0, instances: 0 };
+        /*
+         * ── 보존 기간을 스냅샷 TTL 로 올리지 않는다 (2026-08-27) ────────────────────
+         *
+         * 여기가 `max(보존 기간, 스냅샷 TTL)` 이었다. 둘 다 7일이라 상향은 없었지만, 그 식은 두 값을
+         * 묶어 놓아서 하나를 줄이면 다른 하나가 따라오게 만든다. 두 값은 다른 것을 정한다.
+         *
+         *   보존 기간      이력을 며칠 두나
+         *   스냅샷 TTL     빠르게 세우기 위한 저장본이 며칠 사나
+         *
+         * 저장본이 만료되어도 트윈은 보관된 구간에서 세워진다. 그래서 보존 기간이 더 짧아도 성립한다.
+         */
+        const effectiveDays = days;
         const cutoff = new Date(Date.now() - effectiveDays * 86400 * 1000);
         const rows = await (0, shell_1.getRepository)(twin_instance_js_1.TwinInstance).find({ where: { domain: { id: domainId } } });
         let deleted = 0;
         let instances = 0;
-        const skipped = [];
         for (const r of rows) {
+            /*
+             * ── 체크포인트는 **상한**이지 전제 조건이 아니다 (2026-08-27 사용자 지시로 고침) ──
+             *
+             * 여기가 체크포인트가 없으면 건너뛰었다. 그 규칙은 「저널이 유일한 복구 수단」이라는 전제에서
+             * 나왔는데, 그 전제가 틀렸다. 트윈이 자기 저널과 어떤 관계인지는 `restartPolicy` 가 선언한다.
+             *
+             *   resync   연결된 시스템에서 다시 읽는다   저널은 복구 수단이 아니다
+             *   reset    씨앗부터 다시 돌린다            저널은 복구 수단이 아니다
+             *   resume   저널을 이어 세운다              보관된 구간에서 세운다
+             *
+             * 셋 다 보관 기간 밖의 사건을 요구하지 않는다. 보관 기간 7일이라는 선언이 곧 「7일 전 상태로는
+             * 세우지 않는다」는 뜻이다. 그래서 정리는 체크포인트 없이도 지운다.
+             *
+             * 체크포인트가 하는 일은 하나 남는다. 체크포인트가 **있으면** 그 리비전을 상한으로 쓴다 — 다음
+             * 기동이 그 지점에서 이어 집계하므로, 그 뒤의 사건을 지우면 그 구간이 어디에도 없어진다.
+             *
+             * **없으면 상한도 없다.** 이어 집계할 지점이 없으니 지킬 것도 없고, 보관 기간 조건만으로 지운다.
+             * 없다는 이유로 건너뛰면 멈춘 트윈은 영구히 줄지 않는다(실측: 세 트윈에 2,900만 행).
+             */
             const snap = await this.loadSnapshot(domainId, r.instanceId).catch(() => null);
-            const upTo = Number(snap?.revision ?? 0);
-            if (!upTo) {
-                /* 스냅샷이 없다 — 저널이 유일한 복구 수단이므로 손대지 않는다. */
-                skipped.push(r.instanceId);
-                continue;
+            const at = Number(snap?.revision ?? 0);
+            const upTo = at > 0 ? at : Number.MAX_SAFE_INTEGER;
+            /*
+             * ── 나눠서 지운다 (2026-08-25 실측으로 고침) ────────────────────────────────
+             *
+             * 여기가 **한 문장으로 통째** 지웠다. 지울 것이 며칠치면 그 한 문장이 수백만 행이 되고, sqlite 는
+             * 쓰기가 하나이므로 그동안 호스트가 아무 일도 못 한다. 실측: 한 번의 지우기가 74초·79초였고,
+             * 그 뒤에 한 줄짜리 `domains` 조회가 67초로 찍혔다 — 그 질의의 문제가 아니라 줄을 선 값이다.
+             * 개발 환경에서 보관 기간 7일에 13일치가 쌓여 있었고, 그 밀린 몫이 한 번에 나왔다.
+             *
+             * 그래서 **한 번에 지우는 수를 묶고**, 배치 사이에 루프를 비워 준다. 그리고 한 창에서 쓰는
+             * 시간에도 상한을 둔다 — 남은 것은 다음 창이 이어서 지운다. 지우는 총량은 같고, 그 사이에
+             * 사람의 요청이 처리된다.
+             *
+             * `DELETE … LIMIT` 은 드라이버마다 다르므로 쓰지 않는다(sqlite 는 기본 빌드에서 지원하지 않는다).
+             * 대신 **경계 리비전을 먼저 찾아** 그 아래만 지운다 — 다섯 드라이버에서 같은 뜻이 되는 방법이다.
+             */
+            let n = 0;
+            const startedMs = Date.now();
+            for (;;) {
+                /*
+                 * ── 경계를 **시각**으로 찾는다 (2026-08-27 실측으로 고침) ──────────────────
+                 *
+                 * 여기가 `ORDER BY revision` 이었다. 그러면 계획기가 리비전 색인을 고르고, 지울 대상인지는
+                 * 행마다 `created_at` 을 열어 확인한다. 지울 것이 적으면 그 트윈의 저널을 끝까지 걸어야
+                 * 「한 배치를 못 채웠다」를 알 수 있다 — 1,029만 행에서 그것이 2초 예산을 다 썼고 44건만
+                 * 지우고 멈췄다.
+                 *
+                 * 시각순으로 물으면 `(domain, instance, created_at)` 색인을 그대로 쓴다. 실측 계획:
+                 *
+                 *   ORDER BY revision      SEARCH USING INDEX ix_twin_event_0   ← created_at 을 행마다 확인
+                 *   ORDER BY createdAt     SEARCH USING COVERING INDEX ix_twin_event_8  ← 테이블을 열지 않는다
+                 *
+                 * 지우기는 정렬이 없어 색인만 있으면 바로 그것을 쓴다(실측 확인).
+                 */
+                const edge = await (0, shell_1.getRepository)(twin_event_js_1.TwinEvent)
+                    .createQueryBuilder('e')
+                    .select('e.createdAt', 'createdAt')
+                    .where('e.domain = :domainId', { domainId })
+                    .andWhere('e.instanceId = :instanceId', { instanceId: r.instanceId })
+                    .andWhere('e.createdAt IS NOT NULL')
+                    .andWhere('e.createdAt < :cutoff', { cutoff })
+                    .orderBy('e.createdAt', 'ASC')
+                    .offset(this.JOURNAL_PRUNE_BATCH - 1)
+                    .limit(1)
+                    .getRawOne();
+                /*
+                 * 경계가 없으면 남은 것이 한 배치 안이다 — 그때는 보관 기간 경계까지 지우고 끝난다.
+                 *
+                 * 경계가 있으면 그 시각 **이하**까지 지운다(`<=`). 같은 시각의 행이 여럿이면 한 배치가 조금
+                 * 커지지만, `<` 로 두면 그 시각의 행들이 남아 다음 배치가 같은 경계를 다시 찾는다(제자리걸음).
+                 */
+                /*
+                 * 원시 결과의 컬럼 값은 **드라이버에게 해석시킨다**(§`hydratedDate`). sqlite 가 주는 값에는
+                 * 시간대가 없어서 그대로 `new Date()` 로 읽으면 지역 시간으로 해석된다 — 경계가 그만큼 이르게
+                 * 밀리고, 그러면 **한 건도 지우지 못해 정리가 그대로 멈춘다**(0건이면 반복을 끝낸다).
+                 */
+                const batchCutoff = (0, read_time_js_1.hydratedDate)((0, shell_1.getRepository)(twin_event_js_1.TwinEvent), 'createdAt', edge?.createdAt);
+                const del = (0, shell_1.getRepository)(twin_event_js_1.TwinEvent)
+                    .createQueryBuilder()
+                    .delete()
+                    .from(twin_event_js_1.TwinEvent)
+                    .where('domain_id = :domainId', { domainId })
+                    .andWhere('instance_id = :instanceId', { instanceId: r.instanceId })
+                    /* 체크포인트가 아직 반영하지 못한 사건은 지우지 않는다(도는 트윈에서만 상한이 걸린다). */
+                    .andWhere('revision <= :upTo', { upTo })
+                    .andWhere('created_at IS NOT NULL');
+                const res = await (batchCutoff
+                    ? del.andWhere('created_at <= :batchCutoff', { batchCutoff })
+                    : del.andWhere('created_at < :cutoff', { cutoff })).execute();
+                const batch = res.affected ?? 0;
+                n += batch;
+                if (!batch)
+                    break;
+                if (Date.now() - startedMs >= this.JOURNAL_PRUNE_BUDGET_MS) {
+                    (0, log_js_1.twinLog)(`[twin-engine] journal prune paused "${r.instanceId}" — 이번 창에서 ${n}건까지 지웠다. ` +
+                        '남은 것은 다음 창이 이어서 지운다(호스트가 그 사이에 요청을 처리한다).');
+                    break;
+                }
+                /* 루프를 비워 준다 — 이 한 줄이 없으면 배치로 나눈 뜻이 없다(같은 틱에서 계속 지운다). */
+                await new Promise(resolve => setImmediate(resolve));
             }
-            const res = await (0, shell_1.getRepository)(twin_event_js_1.TwinEvent)
-                .createQueryBuilder()
-                .delete()
-                .from(twin_event_js_1.TwinEvent)
-                .where('domain_id = :domainId', { domainId })
-                .andWhere('instance_id = :instanceId', { instanceId: r.instanceId })
-                .andWhere('revision <= :upTo', { upTo })
-                .andWhere('created_at IS NOT NULL')
-                .andWhere('created_at < :cutoff', { cutoff })
-                .execute();
-            const n = res.affected ?? 0;
             if (n > 0) {
                 deleted += n;
                 instances++;
-                /* **지운 것을 말한다** — 조용히 줄어든 저널은 「없었던 일」과 구별되지 않는다. */
-                (0, log_js_1.twinLog)(`[twin-engine] journal pruned "${r.instanceId}" — ${n}건 (revision ≤ ${upTo} · ${cutoff.toISOString()} 이전). ` +
-                    '그 앞은 체크포인트가 대신한다.');
+                /* **지운 것을 말한다** — 알리지 않고 줄어든 저널은 「없었던 일」과 구별되지 않는다. */
+                (0, log_js_1.twinLog)(`[twin-engine] journal pruned "${r.instanceId}" — ${n}건 (${cutoff.toISOString()} 이전` +
+                    `${upTo < Number.MAX_SAFE_INTEGER ? ` · revision ≤ ${upTo} 까지만, 그 뒤는 체크포인트가 대신하지 못한다` : ''}).`);
+            }
+            /*
+             * ── 조회용 파생 표도 같은 창에서 줄인다 (2026-08-27) ────────────────────────
+             *
+             * 이 표는 **버릴 수 있는 값**이다(사건에서 파생된 것이므로). 지우면 그 구간의 이력 조회가 저널로
+             * 넘어가 느려지고, 사실은 사라지지 않는다.
+             *
+             * 그래서 체크포인트 상한을 보지 않는다 — 그 상한은 「사실을 잃지 않기 위한 것」이고 여기에는 잃을
+             * 사실이 없다. 보관 기간만 본다.
+             */
+            const subjectPruned = await (0, twin_subject_writer_js_1.pruneSubjectRows)(domainId, r.instanceId, cutoff, this.JOURNAL_PRUNE_BUDGET_MS, this.JOURNAL_PRUNE_BATCH).catch(() => 0);
+            if (subjectPruned > 0) {
+                (0, log_js_1.twinLog)(`[twin-subject] pruned "${r.instanceId}" — ${subjectPruned}줄 (${cutoff.toISOString()} 이전).`);
             }
         }
-        if (skipped.length) {
-            (0, log_js_1.twinLog)(`[twin-engine] journal prune skipped ${skipped.length} instance(s) with no checkpoint — ` +
-                `저널이 유일한 복구 수단이라 손대지 않았다: ${skipped.slice(0, 5).join(', ')}${skipped.length > 5 ? ' …' : ''}`);
-        }
-        return { deleted, instances, skipped };
+        return { deleted, instances };
     }
+    /**
+     * 한 번의 지우기가 다루는 행 수 — 쓰기 잠금을 이 만큼만 잡는다.
+     *
+     * ── 20,000 이 왜 컸나 (2026-08-28 실측) ────────────────────────────────────
+     * 앞 판은 20,000 이었고 근거는 「한 문장으로 수백만 행을 지우면 74초였다」였다. 그것은 **더 나쁜
+     * 쪽과 견준 수**이고, 20,000 자체를 잰 것이 아니었다. 실제로 재 보니 이렇다(서버 기록):
+     *
+     *   hatio-mx1   20,123줄   5.6초
+     *   hatio-mx2   20,130줄   5.2초
+     *   hatio-us    20,139줄   4.2초
+     *   한 창의 합계 약 15초
+     *
+     * sqlite 는 연결이 하나다. 그래서 그 4~5초 동안 **화면의 모든 질의가 줄을 선다** — 실측으로 첫
+     * 화면 조회가 12.2초였다(정상 상태에서는 40밀리초다).
+     *
+     * 그리고 예산(`JOURNAL_PRUNE_BUDGET_MS` = 2초)이 **문장이 끝난 뒤에** 검사되므로, 한 문장이 예산을
+     * 2~3배 넘긴다. 배치를 나눈 뜻이 그만큼 없어진다.
+     *
+     * ── 2,000 의 근거 ──────────────────────────────────────────────────────────
+     * 위 실측이 줄당 약 0.26밀리초다(5.2초 / 20,130줄). 2,000줄이면 **한 문장이 약 0.5초**다. 화면이
+     * 한 번 멈추는 길이가 5초에서 0.5초로 줄고, 예산 검사도 뜻을 갖는다(한 창에 문장 넷).
+     *
+     * 총량은 같고 나눠서 치른다 — 창마다 지우는 수가 줄지만 지우는 일은 급하지 않다(창이 10분마다 온다).
+     *
+     * 값을 바꾸려면 다시 재고 이 문장을 고칠 것.
+     */
+    static { this.JOURNAL_PRUNE_BATCH = 2_000; }
+    /**
+     * 한 창에서 지우는 데 쓰는 시간 상한(ms) — 남은 것은 다음 창이 이어서 지운다.
+     *
+     * 밀린 몫이 며칠치면 한 창에서 다 지울 수 없다. 다 지우려 들면 그동안 호스트가 멈추고, 그것이 바로
+     * 고치려는 증상이다. 총량은 같고 나눠서 치른다.
+     *
+     * ── 2초에서 5초로 올린 이유 (2026-08-28) ───────────────────────────────────
+     * 배치를 20,000 → 2,000 으로 줄였다(§`JOURNAL_PRUNE_BATCH`). 예산을 그대로 두면 **창마다 지우는
+     * 양이 2.5배 줄어** 밀린 몫이 빠지지 않는다.
+     *
+     * 예산을 5초로 두면 한 창에 문장 열 개(각 0.5초)가 돌아 **지우는 양은 전과 같고**, 잠금은 열 번
+     * 나뉘어 그 사이에 화면 질의가 처리된다. 고치려던 것은 총 시간이 아니라 **한 번에 멈추는 길이**다.
+     *
+     *   전   한 문장 5.2초 · 그동안 모든 조회가 줄을 선다
+     *   후   문장 열 개 × 0.5초 · 사이마다 루프를 비워 준다
+     */
+    static { this.JOURNAL_PRUNE_BUDGET_MS = 5_000; }
     /** 보존 정리 주기 기동(1회) — 선언이 없으면 아무것도 하지 않는다. */
     static startRetentionLoop(domainId) {
         if (this.retentionTimer)
@@ -641,7 +886,7 @@ class TwinEngine {
      * `bootstrap()` 은 상태만 되찾아 `recovered` 에 담았고, 커널을 세우는 것은 **명시 mutation 뿐**이었다
      * (이 파일 위쪽 주석이 「향후」라고 적어 둔 그 자리다). 그래서 서버를 한 번 재기동하면 등록부는
      * `running` 이라 말하는데 **아무 커널도 돌지 않았다** — 화면은 도는 트윈을, 실제로는 멈춘 트윈을.
-     * 미러 트윈에서는 더 나쁘다: 계측이 조용히 끊기고, 사람은 「값이 안 변하네」로 알게 된다.
+     * 미러 트윈에서는 더 나쁘다: 계측이 알리지 않고 끊기고, 사람은 「값이 안 변하네」로 알게 된다.
      *
      * ── 모드를 지어내지 않는다 ──────────────────────────────────────────────────
      * 미러였던 트윈을 시뮬로 되살리면 **없던 움직임을 만들어 낸다**(관측 트윈이 스스로 물건을 옮긴다).
@@ -752,7 +997,7 @@ class TwinEngine {
             ...(plan.attentionSinceCount ? [`${plan.attentionSinceCount} attention start time(s)`] : [])
         ].join(', ');
         (0, log_js_1.twinLog)(`[twin-engine] warm-started "${id}" — restored ${restored}.`);
-        /* 뺀 것은 조용히 넘기지 않는다 — 지어내지 않았다는 사실 자체를 말해야 화면의 빈칸이 읽힌다. */
+        /* 뺀 것은 알리지 않고 넘기지 않는다 — 지어내지 않았다는 사실 자체를 말해야 화면의 빈칸이 읽힌다. */
         if (plan.ordersWithoutDemand > 0) {
             (0, log_js_1.twinWarn)(`[twin-engine] "${id}": ${plan.ordersWithoutDemand} order(s) could not be restored — they carry progress only, ` +
                 'with no requested/fulfilled counts, so the remaining demand is unknown. They are left out rather than guessed.');
@@ -765,7 +1010,7 @@ class TwinEngine {
      * `model.operations`(마스터 인제스트가 통과시킨 ISA-95 OperationsSegment 명세)를 커널이 소비한다.
      * 없으면 커널 기본 상수로 굴러가고, 커널 `specCoverage()` 가 무엇을 기본값으로 썼는지 보고한다.
      *
-     * 커널이 아직 이 API 를 갖지 않은 버전이면(발행 이전) **조용히 넘어가지 않고 경고한다** — 명세를
+     * 커널이 아직 이 API 를 갖지 않은 버전이면(발행 이전) **알리지 않고 넘어가지 않고 경고한다** — 명세를
      * 선언했는데 반영되지 않는 상태를 모르고 지나가면, 예측이 상수로 돌아간 것을 아무도 알 수 없다.
      */
     static applyOperations(kernel, model, id) {
@@ -787,7 +1032,7 @@ class TwinEngine {
                     kernel.declareDurations(declared);
                 }
                 catch (err) {
-                    /* 커널이 거절한 값은 조용히 넘기지 않는다 — 화면은 「넣었습니다」라고 말한 값이다. */
+                    /* 커널이 거절한 값은 알리지 않고 넘기지 않는다 — 화면은 「넣었습니다」라고 말한 값이다. */
                     (0, log_js_1.twinWarn)(`[twin-engine] "${id}": declared operation duration rejected by the kernel — ${err?.message ?? err}`);
                 }
             }
@@ -827,7 +1072,7 @@ class TwinEngine {
      * 둘 다 못 만들면 주입하지 않는다 — 커널이 명세·상수로 굴러가고 `specCoverage()` 가 그 사실을 남긴다.
      *
      * 실측은 DB 조회라 비동기다. 그래서 이 함수는 **await 하지 않는 쪽에서도 안전**하도록 실패를 삼키되,
-     * 무엇을 왜 못 넣었는지는 로그로 남긴다(조용한 무효화 금지).
+     * 무엇을 왜 못 넣었는지는 로그로 남긴다(들어온 것이 없는 무효화 금지).
      */
     static async installEstimators(kernel, domainId, instanceId, model) {
         if (!kernel || typeof kernel !== 'object')
@@ -845,7 +1090,7 @@ class TwinEngine {
         /*
          * **양품률도 이력에서 배운다** (2026-08-19) — 소요와 같은 자리에서 붙인다.
          *
-         * 커널이 그 시임을 갖지 않은 버전이면(발행 이전) 조용히 넘어가지 않고 말한다: 수율이 상수로 남은
+         * 커널이 그 시임을 갖지 않은 버전이면(발행 이전) 알리지 않고 넘어가지 않고 말한다: 수율이 상수로 남은
          * 이유를 모르고 지나가면, 화면의 불량 판정이 그 현장의 사실이 아니라 우리 상수의 결과다.
          */
         const yields = await this.measuredYield(domainId, instanceId);
@@ -874,7 +1119,7 @@ class TwinEngine {
             `${travel.estimator ? `, travel from distance (speeds: ${Object.keys(travel.speedsByKind).join(',')})` : `, travel not derived (${travel.reasons.join('; ')})`}`);
     }
     /**
-     * 실측 추정기 — **예측 요청마다 저널을 다시 접지 않는다.**
+     * 실측 추정기 — **예측 요청마다 저널을 다시 계산하지 않는다.**
      *
      * 예측 커널은 요청마다 새로 세워지고(미러 예측·백테스트), 화면은 시각을 긁으면 계속 재예측한다.
      * 거기에 KPI 조회를 그대로 달면 요청당 저널 스캔이 하나씩 붙는다 — 실측은 분 단위로 바뀌지 않으므로
@@ -893,10 +1138,10 @@ class TwinEngine {
      * 다시 넣으므로). 버리는 것이 손해가 아닌 이유: 이 값은 캐시이고, 없으면 다시 계산한다.
      *
      * 수를 크게 잡는다 — 트윈 규모는 늘 크고, 항목 하나는 작업 종류별 소요 몇 줄이다. 상한이 작으면
-     * 정상 규모에서 서로 밀어내며 캐시가 무의미해진다(그게 더 나쁘다: 조용히 느려진다).
+     * 정상 규모에서 서로 밀어내며 캐시가 무의미해진다(그게 더 나쁘다: 알리지 않고 느려진다).
      */
     static { this.MEASURED_MAX = 5_000; }
-    /** 이 트윈이 이력에서 배운 양품률 — 소요와 **같은 폴드·같은 캐시**에서 온다(저널을 두 번 접지 않는다). */
+    /** 이 트윈이 이력에서 배운 양품률 — 소요와 **같은 폴드·같은 캐시**에서 온다(저널을 두 번 계산하지 않는다). */
     static async measuredYield(domainId, instanceId) {
         await this.measuredEstimator(domainId, instanceId);
         return this.measuredCache.get((0, runtime_key_js_1.runtimeKey)(domainId, instanceId))?.yields;
@@ -913,7 +1158,7 @@ class TwinEngine {
             /* 작업 종류별 실측 — 창은 넉넉히(하루) 두고 표본이 모자란 종류는 추정기가 스스로 뺀다. */
             const kpi = await (0, kpi_query_js_1.computeTwinKpi)({ domainId, instanceId, windowMinutes: 24 * 60, groupBy: 'taskKind' });
             value = (0, measured_estimator_js_1.buildMeasuredEstimator)(kpi?.groups?.items, {});
-            /* 같은 그룹에서 양품률도 배운다 — 한 번 접은 저널을 둘이 나눠 쓴다. */
+            /* 같은 그룹에서 양품률도 배운다 — 한 번 계산한 저널을 둘이 나눠 쓴다. */
             yields = (0, measured_yield_js_1.buildYieldEstimator)(kpi?.groups?.items, {});
         }
         catch (err) {
@@ -955,7 +1200,7 @@ class TwinEngine {
         }
         const plan = (0, declared_stimulus_js_1.planStimulus)(config, { hasScenarioEngine: !!inst.runtime?.scenario, mode: inst.mode }, validateScenario);
         if (plan.action === 'skip') {
-            /* 선언이 없는 것은 정상이므로 조용히 지난다. 나머지 셋은 **말한다** — 선언했는데 안 실린 상태다. */
+            /* 선언이 없는 것은 정상이므로 알리지 않고 지난다. 나머지 셋은 **말한다** — 선언했는데 안 실린 상태다. */
             if (plan.reason !== 'none') {
                 (0, log_js_1.twinWarn)(`[twin-engine] "${instanceId}": a stimulus is declared on its source but was not loaded (${plan.reason}${plan.detail ? `: ${plan.detail}` : ''}).` +
                     (plan.reason === 'observed' ? ' This twin runs on observation — we do not manufacture arrivals for it.' : ''));
@@ -1002,7 +1247,7 @@ class TwinEngine {
      * 보여야 하는 화면이 정작 그때 아무 말도 못 한다.
      *
      * 그 빈칸을 이력로 메운다: 저널에서 배운 종류는 **추정기가 이미 답할 수 있는 종류**이므로, 지어내는
-     * 것이 아니라 있는 사실을 꺼내는 것이다. 같은 캐시(60초)를 쓰므로 조회마다 저널을 다시 접지 않는다.
+     * 것이 아니라 있는 사실을 꺼내는 것이다. 같은 캐시(60초)를 쓰므로 조회마다 저널을 다시 계산하지 않는다.
      */
     static async measuredOperationKinds(domainId, instanceId) {
         const measured = await this.measuredEstimator(domainId, instanceId);
@@ -1030,7 +1275,7 @@ class TwinEngine {
      *
      * 계산은 커널이 자기 상태에서 한다(`kernel.capacity`). 여기서 하는 일은 **기준 주를 정해 주는
      * 것**뿐이다: 공휴일이 없는 평상주여야 한다 — 공휴일은 연간 가용량을 따로 깎지, 이 공장의 평상시
-     * 상한을 정하지 않는다. 커널이 임의로 고르게 두면 그 주에 공휴일이 끼었을 때 상한이 조용히 낮아진다.
+     * 상한을 정하지 않는다. 커널이 임의로 고르게 두면 그 주에 공휴일이 끼었을 때 상한이 알리지 않고 낮아진다.
      *
      * 트윈이 기동 중이 아니면 `undefined` 다 — 0 이 아니다. 기동하지 않은 트윈의 상한을 0 이라고 답하면 화면은
      * "이 공장은 아무것도 못 만든다" 고 말한다.
@@ -1085,7 +1330,7 @@ class TwinEngine {
         });
     }
     /**
-     * 미러 기동의 연속성 씨앗 — 이어받은 것은 **말한다**(조용히 잇지 않는다).
+     * 미러 기동의 연속성 씨앗 — 이어받은 것은 **말한다**(알리지 않고 잇지 않는다).
      *
      * 커널이 그 문을 열어 두지 않았으면 그 사실도 말한다: 그 트윈은 재기동마다 열린 구간을 잃는다.
      */
@@ -1122,6 +1367,7 @@ class TwinEngine {
             return this.instances[key];
         const Kernel = kernelFor(kind);
         const kernel = new Kernel(domainId, undefined, this.productionSpecOf(model));
+        kernel.scopeId = id;
         kernel.loadTwinModel(model); // 구조만. 상태는 아래 웜스타트가 주입한다.
         this.applyOperations(kernel, model, id); // 시간·수율 명세(있으면) — 없으면 커널 기본값
         /* 추정기는 DB 조회를 포함해 비동기 — 기동을 막지 않고 붙는다(붙기 전 작업은 명세·상수로 산출). */
@@ -1173,6 +1419,7 @@ class TwinEngine {
             /* 정책은 부르는 쪽이 선언한다 — 여기서 고르면 같은 트윈이 부르는 자리에 따라 다르게 재기동한다. */
             restartPolicy: (0, restart_policy_js_1.readRestartPolicy)(restartPolicy, `start("${id}")`),
             spaceId: model?.spaceId,
+            model,
             /*
              * **시뮬도 계기를 든다** (2026-08-20).
              *
@@ -1213,7 +1460,7 @@ class TwinEngine {
                  * 것은 시뮬만 옆문으로 들어오기 때문"* 이라 예고한 그 자리다.
                  *
                  * **리비전은 커널의 것을 그대로 든다**(라이브는 flush 때 호스트가 부여한다). 시뮬의 저널은
-                 * 커널 리비전으로 접히므로 여기서 다시 번호를 매기면 시간여행이 어긋난다.
+                 * 커널 리비전으로 번호가 정해지므로 여기서 다시 번호를 매기면 시간여행이 어긋난다.
                  */
                 ;
                 (inst.pendingJournal ?? (inst.pendingJournal = [])).push({ event: msg.event, revision: msg.revision });
@@ -1251,7 +1498,7 @@ class TwinEngine {
      * 줄줄이 생겼다: 예측하려면 임시 커널을 세워야 했고(`buildForecastKernel`), 주목 신호를 호스트가
      * 덧붙여야 했고(`withLiveAttentions`), AI 예측 도구는 미러에서 "찾을 수 없다" 로 끝났다.
      *
-     * 이제 라이브 인스턴스도 **커널이다.** 같은 규칙(`ObservedReducer`)으로 이벤트를 접고, 주목 신호를
+     * 이제 라이브 인스턴스도 **커널이다.** 같은 규칙(`ObservedReducer`)으로 이벤트를 계산하고, 주목 신호를
      * 스스로 내고, 그 자리에서 `fork` 해 예측한다. 구동만 다르다 — sim 은 `tick`, live 는 `apply`.
      *
      * 실 이벤트원 = reference 어댑터 openLiveFeed → face2-adapter.ingest → CanonicalEnvelope → ingestLive().
@@ -1273,7 +1520,7 @@ class TwinEngine {
      * 이름이 그대로 굳은 것), 일반 기제에 한 시스템 이름이 붙어 있었기 때문에 창고 트윈이 이 자리를
      * 쓰지 못했다. 별명으로 남겨 두면 그 혼동이 계속되므로 하나로 통일했다.
      *
-     * 옛 이름만 가진 모델이 있으면 **조용히 생산 선언을 잃는 대신 분명히 멈춘다** — 그 트윈은 공정이
+     * 옛 이름만 가진 모델이 있으면 **알리지 않고 생산 선언을 잃는 대신 분명히 멈춘다** — 그 트윈은 공정이
      * 없는 채로 돌게 되고(라인이 서 있는 창고), 원인을 찾기 어렵다.
      */
     static productionSpecOf(model) {
@@ -1314,6 +1561,7 @@ class TwinEngine {
             return this.instances[key];
         const Kernel = kernelFor(kind);
         const kernel = new Kernel(domainId, undefined, this.productionSpecOf(model));
+        kernel.scopeId = id;
         kernel.loadTwinModel(model);
         /* **세우는 쪽이 아는 사실은 세울 때 말한다.** 예전에는 첫 이벤트가 도착해야 커널이 스스로를
            관측 구동으로 여겼고, 그래서 아직 아무것도 못 받은 미러는 시뮬레이션 취급을 받았다. */
@@ -1322,11 +1570,11 @@ class TwinEngine {
         /* `projector` 필드는 옛 이름으로 남긴다 — 소비처가 `snapshot()` 을 부르므로 얇은 어댑터로 잇는다.
          * (P3 에서 소비처를 커널 어휘로 바꾸면 사라진다.) */
         const projector = { apply: (e) => kernel.apply(e), snapshot: () => kernel.getSnapshot() };
-        const inst = { id, domainId, mode: 'live', restartPolicy: 'resync', kernel, projector, oee: new oee_accumulator_js_1.OeeAccumulator(), spaceId: model?.spaceId, unsub: () => { } };
+        const inst = { id, domainId, mode: 'live', restartPolicy: 'resync', kernel, projector, oee: new oee_accumulator_js_1.OeeAccumulator(), spaceId: model?.spaceId, model, unsub: () => { } };
         /*
          * ── 커널이 **판정으로 낸 사실**도 저널에 남는다 (2026-08-14 실측으로 잡음) ────
          *
-         * 라이브는 인입 봉투만 저널에 적고 있었다(`ingestLive`). 그런데 커널은 관측을 접다가 **자기 사실**을
+         * 라이브는 인입 봉투만 저널에 적고 있었다(`ingestLive`). 그런데 커널은 관측을 계산하다가 **자기 사실**을
          * 낸다 — 에너지의 수요 구간 마감·피크 경신·감축 제안이 그렇다(`emitOp`). 그것을 구독하는 곳이
          * 없어서 그 사실들이 **커널 안에서 사라졌다**: 표본 48건이 저널에 쌓였는데 구간 마감은 0건이었고,
          * 저널을 읽는 성과 화면의 전력 타일은 영원히 나오지 않았다.
@@ -1353,7 +1601,7 @@ class TwinEngine {
         this.installEstimators(kernel, domainId, id, model).catch(err => (0, log_js_1.twinWarn)('[twin-engine] estimator install failed', err?.message));
         inst.metrics = this.newMetrics();
         this.instances[key] = inst;
-        /* 미러에도 부른다 — 선언이 있으면 「미러에는 싣지 않는다」고 말해야 한다(조용한 무시 금지). */
+        /* 미러에도 부른다 — 선언이 있으면 「미러에는 싣지 않는다」고 말해야 한다(들어온 것이 없는 무시 금지). */
         this.installStimulus(domainId, id, inst).catch(err => (0, log_js_1.twinWarn)(`[twin-engine] "${id}": stimulus check failed — ${err?.message ?? err}`));
         /*
          * **원천이 되풀어 주지 않는 것만 잇는다** (2026-08-18 실측으로 붙임).
@@ -1374,11 +1622,11 @@ class TwinEngine {
          * 정정이 오지 않는다: 커서가 따라잡힌 뒤 원본이 변하지 않으면 미러는 영구히 빈 채로 남는다.
          * 그리고 그 빈 채로 화면이 「이상 없음」을 보였다 — 사실이 사라지는 동안 화면이 안심시킨 것이다.
          *
-         * 되돌리는 것은 **상태가 아니라 재개점**이다. 상태만 심으면 그 뒤를 이어 접은 결과가 0부터 접은
-         * 결과와 조용히 달라진다(리듀서는 보류된 담김·집계 중인 수량도 든다). 그 동치는 커널 시험이
-         * 증명한다(`observed-checkpoint.test.ts` — 재개점 + 꼬리 == 0부터 접기).
+         * 되돌리는 것은 **상태가 아니라 재개점**이다. 상태만 심으면 그 뒤를 이어 계산한 결과가 0부터 계산한
+         * 결과와 오류 없이 달라진다(리듀서는 보류된 담김·집계 중인 수량도 든다). 그 동치는 커널 시험이
+         * 증명한다(`observed-checkpoint.test.ts` — 재개점 + 꼬리 == 0부터 계산하기).
          *
-         * 씨앗은 **그 공장이 아직 그 공장일 때만** 오고, 마지막 체크포인트 이후의 사실은 이미 접혀 들어
+         * 씨앗은 **그 공장이 아직 그 공장일 때만** 오고, 마지막 체크포인트 이후의 사실은 이미 계산되어 들어
          * 있다(`warmSeedFor`). 씨앗이 없으면 전과 같이 빈 채로 시작한다 — 지어내지 않는다.
          */
         const seed = this.recovered[key]?.fold?.reducer;
@@ -1428,10 +1676,19 @@ class TwinEngine {
          * 비동기라 그 사이에 이벤트가 몇 건 들어와 있을 수 있는데, 그때 뒤로 되돌리는 것은 커널이 거절한다
          * (겹치는 번호를 막는 그 판정이다). 거절은 삼키지 않고 남긴다.
          */
+        /*
+         * 관계로 묻지 않는다 — `findOne({ where: { domain: { id } } })` 은 두 단계 질의가 되고 안쪽에
+         * 상한이 없어 그 트윈의 저널을 **전부 만든 뒤** 한 줄을 고른다(§`tipOf` 의 실측). 여기는 부팅
+         * 경로이므로 그 비용이 기동을 붙잡는다. 색인의 끝 한 줄만 읽는다.
+         */
         (0, shell_1.getRepository)(twin_event_js_1.TwinEvent)
-            .findOne({ where: { domain: { id: domainId }, instanceId: id }, order: { revision: 'DESC' } })
+            .createQueryBuilder('e')
+            .select('MAX(e.revision)', 'max')
+            .where('e.domain = :domainId', { domainId })
+            .andWhere('e.instanceId = :instanceId', { instanceId: id })
+            .getRawOne()
             .then(top => {
-            const head = top?.revision ?? 0;
+            const head = Number(top?.max) || 0;
             inst.revision = head;
             if (!head || typeof kernel.resumeRevision !== 'function')
                 return;
@@ -1455,18 +1712,107 @@ class TwinEngine {
      *
      * ── 넣은 수를 **답한다** (2026-08-20) ────────────────────────────────────────
      * 트윈이 라이브로 돌지 않으면 여기서 봉투를 버린다. 그것 자체는 맞다(넣을 커널이 없다). 문제는
-     * **조용히** 버린 것이었다: 트윈이 멈춘 뒤에도 피드는 남아 레코드를 나르고, 유입 장부는 그것을
+     * **알리지 않고** 버린 것이었다: 트윈이 멈춘 뒤에도 피드는 남아 레코드를 나르고, 유입 장부는 그것을
      * 「통과」로 셌다. 화면은 멈춘 트윈 옆에 「150 통과 · 100%」라고 적었다 — 사실이 사라지는 동안
      * 화면이 안심시킨 것이다.
      *
      * 그래서 **넣은 수를 돌려준다.** 부르는 쪽이 제시 수와 견주어 버려진 수를 장부에 적는다. 반환을
      * 무시하는 호출부는 그대로 동작한다(전과 같다).
      */
-    static ingestLive(domainId, id, envelopes) {
+    /**
+     * 유입 결과를 수로 낸다 — 받은 수 · 중복으로 버린 수 · 보낸 수.
+     *
+     * `ingestLive` 는 받은 수만 돌려주는데, 웹훅으로 받을 때는 **몇 건이 중복이었는지도 답해야** 한다.
+     * 밀어 주는 쪽이 그 수를 보고 자기가 되풀이 보내고 있다는 것을 알 수 있어야 하고, 그것을 모르면
+     * 우리 응답이 「전부 새 것이었다」로 읽힌다.
+     */
+    static ingestLiveResult(domainId, id, envelopes, source = 'poll') {
+        const before = this.ingestLedgers[(0, runtime_key_js_1.runtimeKey)(domainId, id)]?.duplicates ?? 0;
+        const offered = envelopes.length;
+        const applied = this.ingestLive(domainId, id, envelopes, source);
+        const after = this.ingestLedgers[(0, runtime_key_js_1.runtimeKey)(domainId, id)]?.duplicates ?? 0;
+        return { offered, applied, duplicates: Math.max(0, after - before) };
+    }
+    /**
+     * **마스터데이터를 받는다** — 변하지 않는 속성을 상태에 세운다. 저널에 적지 않는다.
+     *
+     * ── 왜 저널에 적지 않나 ────────────────────────────────────────────────────
+     * 유통기한·로트번호 같은 값은 그 물건의 생애 동안 같다. 그래서 「그때는 얼마였나」라는 물음이
+     * 성립하지 않는다 — 시각축이 없는 값이므로 사건이 아니다. 되세울 근거는 중간 저장본이 든다
+     * (리듀서가 그 값을 저장본에 담는다).
+     *
+     * ── 이 문이 없어서 무엇이 났나 (2026-08-28 실측) ───────────────────────────
+     * 표준은 그 값을 `ObjectEvent(action=ADD)` 에만 실을 수 있게 한다. 그래서 전량을 읽는 원본이
+     * 재고를 다시 말할 때마다 **들어오지 않은 것을 「들어왔다」** 고 했고, 사건 단위 값이라 자리별로
+     * 묶을 수도 없어 낱개로 나갔다 — 재기동 한 번에 2,665건이 「읽은 시각」으로 쌓였다.
+     *
+     * 돌려주는 수는 **상태에 반영된 건수**다. 라이브로 돌지 않는 트윈은 0 을 낸다 — 그 차이를 부르는
+     * 쪽이 알아야 한다(버려진 것을 통과로 세면 멈춘 트윈이 정상으로 보인다).
+     *
+     * 설계: `operato-twin/design/plans/master-data.md`
+     */
+    static applyMasterData(domainId, id, elements) {
+        if (!elements.length)
+            return 0;
+        const inst = this.instances[(0, runtime_key_js_1.runtimeKey)(domainId, id)];
+        if (inst?.mode !== 'live' || !inst.kernel)
+            return 0;
+        const kernel = inst.kernel;
+        if (typeof kernel.applyMasterData !== 'function') {
+            (0, log_js_1.twinWarn)(`[twin-engine] kernel for "${id}" cannot take master data (no applyMasterData) — ` +
+                'lot attributes such as expiry will stay empty for this twin.');
+            return 0;
+        }
+        const n = kernel.applyMasterData(elements);
+        /*
+         * **돌았다는 것을 로그로 남긴다** (2026-08-28).
+         *
+         * 이 값은 지난 기록에 적히지 않으므로(시각축이 없다) 세지 않으면 이 통로가 돌았는지 아무 데도
+         * 남지 않는다. 처음에는 유입 장부에 수를 더했는데 **그것이 편법이었다**: 유입 장부는 「원본에서
+         * 사실이 얼마나 들어오고 거부되고 버려지나」를 답하는 자리이고, 마스터데이터는 사실의 흐름이 아니라
+         * 선언의 동기다. 그리고 그 수를 읽는 화면이 없었다 — 내가 확인하려고 만든 값이었다.
+         *
+         * 확인은 **로그의 일**이다. 정상 상태에서는 이 줄이 안 나오는 것이 맞다 — 값이 그대로면 원본이
+         * 다시 말하지 않는다. 나오면 그때가 무언가 바뀐 때다.
+         */
+        if (n > 0)
+            (0, log_js_1.twinLog)(`[twin-engine] "${id}": 마스터데이터 ${n}건을 상태에 세웠다(지난 기록에는 적지 않는다).`);
+        /* 상태가 바뀌었으니 다음 창에서 화면으로 흘러야 한다 — 관측 반영과 같은 규율이다. */
+        inst.dirty = true;
+        this.ensureBroadcastCoalescer();
+        return n;
+    }
+    static ingestLive(domainId, id, envelopes, source = 'poll') {
         const inst = this.instances[(0, runtime_key_js_1.runtimeKey)(domainId, id)];
         if (inst?.mode !== 'live' || !inst.projector)
             return 0;
         const tIngest = performance.now();
+        /*
+         * ── 같은 사실을 두 번 받으면 한 번만 반영한다 (2026-08-26) ─────────────────
+         *
+         * 이 자리가 유입 경계다 — 커넥터가 물어서 받은 것 · 시나리오가 넣는 것 · 부하 도구가 넣는 것이
+         * 모두 여기를 지난다(웹훅으로 받는 길이 생기면 그것도 여기로 온다). 그래서 중복을 여기서 한 번
+         * 거른다.
+         *
+         * 지금까지는 커넥터마다 각자 막고 있었다. 그래서 잊으면 트윈이 그대로 두 번 셌다 — 태양광
+         * 커넥터가 한 주기에 76건을 되풀이 보냈고, 커넥터를 고쳐서 2건이 됐다. 다음 커넥터가 같은 것을
+         * 잊으면 또 난다.
+         *
+         * 절대값으로 말하는 사실은 두 번 반영해도 결과가 같지만(잔량 · 상태 · 적산), 세는 값은 아니다:
+         * 구간의 표본 수 · 평균 부하 · OEE 카운터 · 유입 계수. 그리고 지난 기록에 같은 사실이 두 줄로
+         * 남으면, 나중에 그 기록으로 다시 계산할 때 또 두 번 센다.
+         *
+         * **정확히 같은 것만 버린다.** 늦게 도착한 옛 사실은 버리지 않는다 — 그것이 왔다는 것도 사실이고,
+         * 상태에 반영하지 않는 판단은 커널이 이미 한다.
+         */
+        const { fresh, duplicates } = (inst.deduper ??= new ingest_dedupe_js_1.FactDeduper()).filter(envelopes);
+        envelopes = fresh;
+        const ledgerKey = (0, runtime_key_js_1.runtimeKey)(domainId, id);
+        const ledger = this.ingestLedgers[ledgerKey] ?? (this.ingestLedgers[ledgerKey] = (0, ingest_health_js_1.newIngestLedger)());
+        if (duplicates)
+            (0, ingest_health_js_1.recordDuplicates)(ledger, duplicates, Date.now());
+        if (envelopes.length)
+            (0, ingest_health_js_1.recordIngestSource)(ledger, source, envelopes.length, Date.now());
         /* 인입 봉투를 표시해 두고 넣는다 — 커널이 그것을 재방출해도 저널에 두 번 적히지 않게(위 구독 주석). */
         for (const e of envelopes) {
             if (e && typeof e === 'object')
@@ -1491,20 +1837,41 @@ class TwinEngine {
      * 구간 성과 브로드캐스팅은 **없앴다**(2026-08-06). 카드가 `twinKpi` 를 직접 묻는다.
      *
      * 왜: 카드를 여러 단계(공간·트윈·구역·자리·설비)에 붙이려면 브로드캐스팅으로는 태그가 트윈당 1,200개가 되고,
-     * **모델에 카드를 하나도 안 놓아도** 30초마다 트윈마다 저널을 접었다. 질의로 바꾸니 보고 있는 카드
+     * **모델에 카드를 하나도 안 놓아도** 30초마다 트윈마다 저널을 계산했다. 질의로 바꾸니 보고 있는 카드
      * 수만큼만 들고, 같은 (대상·창·축) 은 클라이언트가 하나로 합친다.
      *
      * 덤으로 질의만 할 수 있는 것이 둘 생겼다 — **과거 시각**(`toTime`)과 **공간 단위 합산**(여러 트윈을
-     * 한 번에 접기). 브로드캐스팅 루프는 트윈별이라 둘 다 못 했다.
+     * 한 번에 계산). 브로드캐스팅 루프는 트윈별이라 둘 다 못 했다.
      *
      * 축을 나눠도 폴드 비용이 같다는 실측이 근거다(`test/kpi-query-bench.test.ts`).
      */
     /**
      * 몇 창마다 한 번은 **전부** 만드나 — 사건 없이 값이 바뀌는 자리에 대한 그물.
      *
-     * 25 창이면 기본 주기에서 5초다. 보장이 아니라 그물이다(위 `publishEntityData` 주석).
+     * 보장이 아니라 그물이다(위 `publishEntityData` 주석). **세는 단위는 창이지만 뜻은 시간**이므로,
+     * 기본 주기를 200밀리초에서 1초로 늘린 날 이 수도 함께 줄였다(25창 → 5창). 그러지 않으면 그물이
+     * 5초에서 25초로 벌어져, 시각만으로 바뀌는 값(유효 기간 만료 같은 것)이 그만큼 늦게 보인다.
+     */
+    static { this.FULL_BROADCAST_EVERY = 5; }
+    /**
+     * **한 실행 차례에 발행할 수 있는 건수** — 이만큼 발행하면 루프를 비워 준다 (2026-08-27).
+     *
+     * ── 왜 상한이 필요한가 (실측으로 서버가 두 번 죽었다) ──────────────────────
+     * 구독의 대기열에는 버퍼가 없다(`pubsub.subscribe` 가 `new Repeater(fn)` 을 버퍼 없이 만든다).
+     * 발행하는 순간에 「다음 값을 달라」는 요청이 이미 걸려 있어야 바로 전달되고, 아니면 대기열에
+     * 쌓인다. 상한은 1024 이고 넘으면 예외가 난다(`@repeaterjs/repeater` 의 `MAX_QUEUE_LENGTH`).
+     *
+     * 값을 꺼내는 쪽은 비동기다. 그래서 **동기 반복문이 도는 중에는 한 건도 꺼내지 못한다.** 라이브러리로
+     * 직접 재 본 값이다 — 소비자를 붙여 두고 2,000건을 동기로 발행하면 소비자가 꺼낸 것은 1건이었고
+     * 나머지가 쌓여 예외가 났다.
+     *
+     * 그 예외는 `publish()` 호출자에게 오지 않는다. `EventTarget` 이 리스너 예외를 uncaughtException 으로
+     * 보내므로 try/catch 로는 잡을 수 없다(2026-08-14 에 그 가드를 붙였는데 그래서 무력했다). 막는 방법은
+     * **한 차례에 상한을 넘기지 않는 것** 하나다.
+     *
+     * 1024 보다 넉넉히 작게 둔다 — 소비자가 한 청크를 다 꺼내지 못해도 다음 청크까지 여유가 남는다.
      */
-    static { this.FULL_BROADCAST_EVERY = 25; }
+    static { this.PUBLISH_CHUNK = 200; }
     /** 전부 만든 횟수 — 범위를 좁히지 못한 창이 얼마나 되는지 값으로 남는다. */
     static { this.broadcastFullPasses = 0; }
     /**
@@ -1540,7 +1907,21 @@ class TwinEngine {
         }
     }
     /** 브로드캐스팅 병합 주기(ms) — 브로드캐스팅률 상한. 인제스트가 아무리 빨라도 이 주기로만 브로드캐스팅. */
-    static { this.BROADCAST_COALESCE_MS = 200; }
+    /*
+     * ── 200 → 1000 (2026-08-25 · 사용자 결정) ──────────────────────────────────
+     * 트윈 **둘**에서 이미 주기를 스스로 늘리고 있었다(한 번 보내는 데 270밀리초). 200밀리초는 상태가
+     * 작을 때의 값이고, 지금 승화푸드 하나가 엔티티 17,600개다(물품 6,494 · 오더 4,794 · 작업 6,353).
+     *
+     * 한 번 보내는 값은 상태 크기에 비례하므로 주기를 늘리는 것으로 그 값이 줄지는 않는다. 대신 **단위
+     * 시간에 그 값을 치르는 횟수**가 5분의 1이 된다. 그 사이 호스트가 HTTP·구독을 처리한다.
+     *
+     * 화면이 늦게 갱신되는 것은 최대 1초다. 최신-상태 채널이라 밀린 것을 쌓아 보내지 않고 마지막 하나만
+     * 가므로, 늦어질 뿐 내용은 같다.
+     *
+     * **비용을 줄인 것이 아니다.** 줄이는 것은 변경분만 만드는 일이고(바뀐 것만 다시 만드는 일) 그것은 별
+     * 작업이다 — 계획: `design/plans/live-broadcast-cost.md`.
+     */
+    static { this.BROADCAST_COALESCE_MS = 1000; }
     /**
      * ── 브로드캐스팅 주기는 **재 본 비용에 맞춘다** (2026-08-21 실측) ────────────────────
      * 한 번의 브로드캐스팅은 상태 크기에 비례한다(실측: 물품 2,400 개인 트윈 하나가 4.5ms — 상태 투영 1.7ms,
@@ -1554,12 +1935,13 @@ class TwinEngine {
      * 이것은 브로드캐스팅 비용을 **줄이는 것이 아니다** — 비용을 줄이는 것은 변경분만 만드는 일이고 그것은 별
      * 작업이다. 여기서는 그때까지 호스트가 굶지 않게 상한을 둔다.
      */
-    static { this.BROADCAST_MAX_COALESCE_MS = 1000; }
+    /* 기본이 1초가 되었으므로 늘릴 여지를 함께 올린다 — 상한이 기본과 같으면 늘릴 곳이 없다. */
+    static { this.BROADCAST_MAX_COALESCE_MS = 2000; }
     /** 주기의 몇 몫까지 브로드캐스팅에 써도 되는가 — 넘으면 주기를 늘린다(절반이면 나머지 절반은 남긴다). */
     static { this.BROADCAST_LOAD_RATIO = 0.3; }
     /** 지금 쓰고 있는 주기(ms) — 계기판이 이 값을 읽는다. 늘어난 채로 있으면 그것이 사실이다. */
     static { this.broadcastPeriodMs = 200; }
-    /** 주기를 늘린 횟수 — 조용히 늦추지 않는다. */
+    /** 주기를 늘린 횟수 — 알리지 않고 늦추지 않는다. */
     static { this.broadcastBackoffs = 0; }
     /** live 브로드캐스팅 coalescer — dirty 인 live 인스턴스만 주기적으로 1회 브로드캐스팅(entitySigs 로 변경 엔티티만). */
     static ensureBroadcastCoalescer() {
@@ -1606,7 +1988,31 @@ class TwinEngine {
      * 한 tick 에서 수백 번 반복되며 이벤트 루프를 막았다(위 `start()` 주석의 35초 틱). 브로드캐스팅을 모으는
      * 규율은 모드의 성질이 아니라 **채널의 성질**이다 — 최신-상태 채널이면 중간 상태는 보낼 값이 없다.
      */
+    /**
+     * 브로드캐스팅 한 창 — **겹쳐 돌지 않는다** (2026-08-27).
+     *
+     * 발행이 청크로 나뉘어 사이에 루프를 비워 주므로 한 창이 주기를 넘길 수 있다. 그때 다음 타이머가
+     * 겹쳐 들어오면 같은 태그가 두 순서로 나가고 시그니처 표가 엉킨다. 그래서 앞 창이 끝날 때까지
+     * 다음 타이머는 그대로 돌아간다 — **창을 버리는 것이 아니다.** 다음 타이머가 이어서 한다.
+     *
+     * 겹친 횟수를 센다. 계속 겹치면 주기보다 한 창이 오래 걸리고 있다는 뜻이고, 그것은
+     * `adjustBroadcastPeriod` 가 주기를 올려 스스로 풀어야 하는 사실이다.
+     */
+    static { this.flushInFlight = false; }
+    static { this.flushOverruns = 0; }
     static flushLiveBroadcasts() {
+        if (this.flushInFlight) {
+            this.flushOverruns++;
+            return;
+        }
+        this.flushInFlight = true;
+        void this.flushBroadcastWindow()
+            .catch(err => (0, log_js_1.twinError)('[twin-engine] broadcast window failed', err?.message ?? err))
+            .finally(() => {
+            this.flushInFlight = false;
+        });
+    }
+    static async flushBroadcastWindow() {
         const now = Date.now();
         const flushStart = performance.now();
         for (const inst of Object.values(this.instances)) {
@@ -1645,7 +2051,7 @@ class TwinEngine {
                 inst.fullBroadcastCountdown = left;
             }
             // ① 엔티티 data(tag) 브로드캐스팅 — 보드 컴포넌트 라이브 렌더.
-            this.publishEntityData(inst);
+            await this.publishEntityData(inst);
             if (m) {
                 m.broadcastTotal++;
                 m._accBroadcast++;
@@ -1693,7 +2099,7 @@ class TwinEngine {
             correlationId: e?.correlationId,
             revision,
             /* **이 사실이 일어난 공장**을 함께 찍는다 — 이것이 없으면 나중에 구조가 바뀌었을 때 이 행을
-               새 공장에 대고 접게 되고, 그때 없던 설비에서 일이 있었던 것처럼 보인다. */
+               새 공장에 대고 계산하게 되고, 그때 없던 설비에서 일이 있었던 것처럼 보인다. */
             ...(structureRev === undefined ? {} : { structureRev }),
             /* 커널은 ISO 문자열을 준다. 컬럼은 날짜다 — **여기서 옮긴다.** 문자열을 그대로 넣으면
                드라이버가 제 형식으로 정규화하지 않아, 나중에 날짜로 거는 질의에 안 걸린다. */
@@ -1731,12 +2137,12 @@ class TwinEngine {
      * 모아 둔 저널을 **한 번에** 쓴다 — 두 구동이 같은 문을 쓴다 (§7.1).
      *
      * ── 왜 한 함수인가 ─────────────────────────────────────────────────────────
-     * 쓰는 자리가 둘이면(주기 flush · 정지) 한쪽만 고쳐지고, 그 어긋남은 **사실이 조용히 사라지는**
+     * 쓰는 자리가 둘이면(주기 flush · 정지) 한쪽만 고쳐지고, 그 어긋남은 **사실이 오류 없이 사라지는**
      * 모양으로 나타난다. 그래서 흘리는 규칙을 여기 한 곳에 둔다.
      *
      * ── 리비전을 누가 매기나 ───────────────────────────────────────────────────
      *  · 라이브 — 원천은 리비전을 주지 않으므로 **호스트가** 이어 붙인다(저널 high-water 에서 시드).
-     *  · 시뮬 — **커널의 리비전**이 실려 온다(저널이 그것으로 접히고 시간여행이 그것을 딛는다).
+     *  · 시뮬 — **커널의 리비전**이 실려 온다(저널이 그 번호로 정렬되고 시간여행이 그것을 딛는다).
      * 그래서 버퍼는 두 모양을 함께 든다: 봉투만 있으면 라이브, `{ event, revision }` 이면 시뮬이다.
      */
     static flushJournal(inst) {
@@ -1761,9 +2167,20 @@ class TwinEngine {
         if (carried.length)
             jobs.push(this.persistCarried(inst.domainId, inst.id, carried));
         if (plain.length && inst.revision != null) {
+            /*
+             * ── 마감된 구간 사실은 한 번만 적는다 (2026-08-30) ───────────────────────
+             *
+             * 이미 있는 것을 걸러낸 뒤에 번호를 매긴다. 걸러내기 전에 매기면 **쓰지 않은 번호가 비고**,
+             * 그 구멍이 저널의 리비전 연속성을 끊는다.
+             */
+            /*
+             * 번호는 **먼저 잡는다**(동기). 걸러낸 뒤에 잡으면 두 flush 가 겹칠 때 같은 번호를 두 번 쓴다.
+             * 걸러진 만큼 번호가 비지만, 그 구멍은 해롭지 않다 — 리비전은 같은 시각을 가리는 데만 쓰고
+             * 이어짐을 요구하지 않는다(저널 머리는 최대값이다).
+             */
             const start = inst.revision;
             inst.revision = start + plain.length;
-            jobs.push(this.persistBatch(inst.domainId, inst.id, plain, start));
+            jobs.push(this.dropAlreadyWritten(inst.domainId, inst.id, plain).then(fresh => fresh.length ? this.persistBatch(inst.domainId, inst.id, fresh, start) : undefined));
         }
         if (!jobs.length)
             return Promise.resolve();
@@ -1790,11 +2207,100 @@ class TwinEngine {
      * 예전에는 이 경로가 **델타마다 한 행씩** 저장했다(그리고 행마다 구조 리비전을 물었다). 규모에서 그것이
      * 호스트를 먹었다(§7.1 실측). 여기서 구조 리비전은 **한 번만** 묻는다.
      */
+    /**
+     * **마감된 구간 사실은 한 번만 적는다** — 같은 사실이 두 번 오면 한 사실이다 (2026-08-30).
+     *
+     * ── 왜 쓰는 자리에서 막나 ──────────────────────────────────────────────────
+     * 커널이 그 사실들의 정체성을 내용에서 만든다(종류·대상·시작·끝). 그런데 저널의 기본키는 새로
+     * 만드는 uuid 라, **id 가 글자 하나까지 같아도 행이 따로 쌓였다.**
+     *
+     * 실측(2026-08-30): 발전 단가가 행 7개·서로 다른 id 4개였다. 8월 27일 단가가 세 벌 있었고,
+     * 그 구간의 수익이 세 번 세어진다.
+     *
+     * 커넥터가 커서로 막는 것이 첫 방어선이고 그쪽도 고쳤다. 그런데 **커넥터가 한 번 실수하면 저널이
+     * 부풀고 그 위의 모든 합이 틀린다.** 정체성은 커널이 선언한 사실이므로, 어느 문으로 들어오든
+     * 지켜져야 한다 — 채우기 경로에만 있으면 그 보증은 「어느 문으로 왔느냐」에 걸린다.
+     *
+     * ── 값이 싼 이유 ───────────────────────────────────────────────────────────
+     * 마감된 구간 사실만 본다(시점의 관측은 그대로 지난다 — 반복이 뜻을 가진다). 그것들은 드물어서
+     * (한 시간에 한 줄) 한 묶음에 몇 개뿐이고, 그 구간의 그 종류만 색인으로 읽는다.
+     */
+    static { this.PERIOD_FACT_TYPES = new Set([
+        'energy.usage.period',
+        'energy.generation.period',
+        'energy.generation.price',
+        'energy.tariff.basis',
+        'energy.bill'
+    ]); }
+    static async dropAlreadyWritten(domainId, instanceId, envelopes) {
+        const periodFacts = envelopes.filter(e => this.PERIOD_FACT_TYPES.has(String(e?.eventType)) && typeof e?.eventId === 'string');
+        if (!periodFacts.length)
+            return envelopes;
+        const times = periodFacts.map(e => Date.parse(String(e.eventTime))).filter(n => Number.isFinite(n));
+        if (!times.length)
+            return envelopes;
+        const types = [...new Set(periodFacts.map(e => String(e.eventType)))];
+        const existing = await (0, shell_1.getRepository)(twin_event_js_1.TwinEvent)
+            .createQueryBuilder('e')
+            .select(['e.payload AS "payload"'])
+            .where('e.domain = :domainId', { domainId })
+            .andWhere('e.instanceId = :instanceId', { instanceId })
+            .andWhere('e.eventType IN (:...types)', { types })
+            .andWhere('e.eventTime BETWEEN :fromAt AND :toAt', { fromAt: new Date(Math.min(...times)), toAt: new Date(Math.max(...times)) })
+            .getRawMany()
+            .catch(() => []);
+        const seen = new Set();
+        for (const row of existing) {
+            let p = row.payload;
+            if (typeof p === 'string') {
+                try {
+                    p = JSON.parse(p);
+                }
+                catch {
+                    p = undefined;
+                }
+            }
+            if (typeof p?.eventId === 'string' && p.eventId)
+                seen.add(p.eventId);
+        }
+        /* 한 묶음 안에 같은 것이 둘 있어도 하나만 적는다. */
+        const kept = [];
+        for (const e of envelopes) {
+            if (!this.PERIOD_FACT_TYPES.has(String(e?.eventType)) || typeof e?.eventId !== 'string') {
+                kept.push(e);
+                continue;
+            }
+            if (seen.has(e.eventId))
+                continue;
+            seen.add(e.eventId);
+            kept.push(e);
+        }
+        return kept;
+    }
     static async persistCarried(domainId, instanceId, items) {
         const repo = (0, shell_1.getRepository)(twin_event_js_1.TwinEvent);
         const structureRev = await this.structureRevOf(domainId, instanceId);
         const rows = items.map(it => this.journalRow(repo, domainId, instanceId, it.event, it.revision, structureRev));
         await this.insertRows(repo, rows);
+        await this.writeSubjects(domainId, instanceId, items.map(it => ({ envelope: it.event, revision: it.revision })));
+    }
+    /**
+     * **대상별 사건 목록에 함께 적는다** — 조회용 파생 표 (2026-08-27).
+     *
+     * 저널을 쓰는 두 문(`persistBatch` · `persistCarried`) 뒤에서 부른다. 다른 자리에서 나중에 적으면
+     * 「저널에는 있고 그 표에는 없는 사건」이 생기고, 그것은 화면에서 오류 없이 빠진 사건이 된다.
+     *
+     * **저널이 먼저다.** 이 표에 적다가 실패해도 저널 쓰기를 되돌리지 않는다 — 사실의 원본은 저널이고
+     * 이 표는 다시 만들 수 있다. 실패는 세어 남긴다(§`subjectWriteFailures`).
+     *
+     * 설계: `operato-twin/design/plans/read-models.md`
+     */
+    static async writeSubjects(domainId, instanceId, entries) {
+        if (!entries.length)
+            return;
+        const reg = this.instances[(0, runtime_key_js_1.runtimeKey)(domainId, instanceId)];
+        const itemOf = (0, item_resolver_js_1.itemResolverFor)(domainId, instanceId, reg?.model);
+        await (0, twin_subject_writer_js_1.writeSubjectRows)(domainId, instanceId, entries, itemOf).catch(err => (0, log_js_1.twinWarn)(`[twin-subject] "${instanceId}" 대상 목록 쓰기 실패 — ${err?.message ?? err}`));
     }
     /**
      * 저널 행을 넣는다 — **넣기만 한다**(2026-08-20).
@@ -1837,6 +2343,7 @@ class TwinEngine {
         const structureRev = await this.structureRevOf(domainId, instanceId);
         const rows = envelopes.map((e, i) => this.journalRow(repo, domainId, instanceId, e, startRevision + i + 1, structureRev));
         await this.insertRows(repo, rows);
+        await this.writeSubjects(domainId, instanceId, envelopes.map((e, i) => ({ envelope: e, revision: startRevision + i + 1 })));
     }
     /** 레지스트리 upsert(도메인+instanceId 유니크). status 인자로 provision(stopped)/start(running) 공용. */
     static async register(domainId, instanceId, kind, model, status = 'running', restartPolicy, origin, 
@@ -1859,7 +2366,7 @@ class TwinEngine {
             areaId: model?.areaId ?? existing?.areaId,
             /* 재기동 정책(ADR-0029 §2) — 명시값 우선, 없으면 기존값 보존(재프로비전이 선언을 지우지 않게).
                **둘 다 없으면 오류를 낸다**: 예전에는 여기서 기본값을 각인했는데, 그 기본값이 「저널 초기화」라서
-               선언을 빠뜨린 프로비저닝이 조용히 이력을 지우는 트윈을 만들었다. 선언은 부르는 쪽의 몫이다. */
+               선언을 빠뜨린 프로비저닝이 알리지 않고 이력을 지우는 트윈을 만들었다. 선언은 부르는 쪽의 몫이다. */
             restartPolicy: restartPolicy ??
                 (0, restart_policy_js_1.readRestartPolicy)(existing?.restartPolicy, `register("${instanceId}") did not declare a restart policy and the stored row has none`),
             /* 용도도 각인한다. 벤치로 뒤집는 것은 `setPurpose` 하나뿐이므로 기존값을 반드시 보존한다
@@ -1878,6 +2385,23 @@ class TwinEngine {
         }));
     }
     /**
+     * ── **트윈은 설비의 마스터가 아니다** (사용자 결정 2026-08-30) ─────────────
+     *
+     * 인원·설비·자산의 마스터는 `@things-factory/ops-master` 다. 트윈은 그것을 **당겨 와** 모델에
+     * 반영하고, 여기 남는 것은 그 결과의 캐시다.
+     *
+     * 그래서 이 함수가 하는 일에 선이 있다.
+     *
+     *   트윈 안에서 사람이 더한 설비   가정·시뮬레이션의 사실이다 — 트윈이 든다 (지금 이 함수)
+     *   현장에 실제로 있는 설비        마스터의 사실이다 — 트윈이 만들지 않는다
+     *
+     * 이 함수는 **트윈 제어 명령**(`resource.add`) 뒤에만 불린다. 관측에서 설비가 생기는 경로가 아니다.
+     * 관측으로 모르는 설비가 들어오면 그것은 **마스터에 없는 것**이고, 트윈이 조용히 만들어 주면 두
+     * 곳이 서로 다른 설비 목록을 갖게 된다. 그때는 만들지 말고 「모르는 설비가 왔다」로 세어야 한다.
+     *
+     * 당겨 오는 길이 붙으면 이 주석의 위쪽 절반만 남는다.
+     *
+     * ── 원래 설명 ─────────────────────────────────────────────────────────────
      * 라이브 구조 변이(resource.add 등)를 저장된 model 에 반영 — 런타임 커널의 무버를 registry model.equipment 에 동기.
      * 이게 없으면 런타임엔 추가돼도(상태·저널엔 반영) 저장 model 는 원본이라 프로비저닝 편집기·재기동(loadTwinModel)이
      * 추가분을 잃는다. 기존 model.equipment 항목은 보존(homeLocation 유지)하고 새 id 만 append(추가 시점 location=homeLocation).
@@ -1912,7 +2436,7 @@ class TwinEngine {
     /**
      * 실행 중이면 구조를 교체하지 않는다 — **판정 문장을 한 곳에 둔다.**
      *
-     * 인제스트는 전량 교체라, 이벤트를 접고 있는 커널 밑에서 바닥을 바꾸는 셈이 된다. 지금은 거절이
+     * 인제스트는 전량 교체라, 이벤트를 계산하고 있는 커널 밑에서 바닥을 바꾸는 셈이 된다. 지금은 거절이
      * 유일한 답이지만 최종형은 아니다(`adoptStructure` 배선). 두 곳에서 같은 문장으로 거절해야
      * 나중에 이 규칙을 걷어낼 때 걷어낼 것이 하나로 보인다.
      */
@@ -1943,7 +2467,7 @@ class TwinEngine {
      * 세 가지가 **함께** 일어나야 한다. 하나라도 빠지면 층이 어긋난다:
      *  ① 리비전 — 이 시점 이후의 이벤트가 새 번호를 달고 다닌다(재생이 마디를 나눌 수 있게)
      *  ② 저장 model·구조 행 — 조회가 새 구조를 본다
-     *  ③ 커널 — 지금 접히는 이벤트가 새 구조 위에서 접힌다
+     *  ③ 커널 — 지금 계산에 들어가는 이벤트가 새 구조 위에서 계산된다
      */
     static async adoptStructure(domainId, instanceId, model, comment, origin) {
         const inst = this.instances[(0, runtime_key_js_1.runtimeKey)(domainId, instanceId)];
@@ -1956,7 +2480,7 @@ class TwinEngine {
             throw new Error(`instance "${instanceId}" is running but not registered — refusing to adopt into an unknown twin`);
         const rev = await this.recordStructure(domainId, instanceId, model, comment);
         await this.register(domainId, instanceId, reg.kind, model, 'running', undefined, origin);
-        /* 커널을 **마지막에** 전환한다 — 저장이 실패하면 메모리만 새 구조가 되어, 재기동하면 조용히
+        /* 커널을 **마지막에** 전환한다 — 저장이 실패하면 메모리만 새 구조가 되어, 재기동하면 알리지 않고
            옛 구조로 돌아간다(고치기 어려운 어긋남이다). */
         const shift = inst.kernel.adoptStructure(model);
         /*
@@ -1973,14 +2497,14 @@ class TwinEngine {
          * 준다**(넣은 값이 화면에서 보이지 않는다). 구조가 바뀐 순간이 곧 캐시를 다시 그릴 순간이다.
          *
          * 실패는 흡수한다: 투영이 막혀도(예: 모델에 중복 id) 커널은 이미 새 구조로 돌고 있으므로 그 사실을
-         * 되돌리지 않는다 — 다만 조용히 넘기지 않고 말한다.
+         * 되돌리지 않는다 — 다만 알리지 않고 넘기지 않고 말한다.
          */
         await (0, project_structure_js_1.projectStructure)(domainId, instanceId, model, instanceId).catch((err) => (0, log_js_1.twinWarn)(`[twin-engine] "${instanceId}" adopted a new structure but its projected rows were not refreshed — ${err?.message ?? err}`));
         /*
          * **구조가 바뀐 순간이 상태가 바뀐 순간이다** — 그러니 브로드캐스팅한다.
          *
          * ── 무엇이 났나 (2026-08-18) ────────────────────────────────────────────
-         * 구조 전환은 커널만 갈고 조용히 끝났다. 그런데 화면이 보는 것 상당수가 구조에서 파생된다 —
+         * 구조 전환은 커널만 갈고 알리지 않고 끝났다. 그런데 화면이 보는 것 상당수가 구조에서 파생된다 —
          * 계약 대비 판정, 주목 신호, 자리 색. 현장이 계약을 고쳐 선언한 순간 조건이 성립하는데도, 상태
          * 브로드캐스팅이 없어서 지도 레일은 **다음 계측 표본이 올 때까지** 옛 화면을 들고 있었다(그 사이 헤더
          * 배지는 4초 폴링으로 먼저 알아, 「배지엔 있고 목록엔 없는」 어긋난 화면이 실제로 보였다).
@@ -1999,7 +2523,7 @@ class TwinEngine {
      * **재기동 정책은 생성 시점의 선언이다**(ADR-0029 §2) — 트윈은 정책 없이 존재할 수 없다.
      *
      * 예전에는 이 자리가 없었고 `register` 가 기본값(`sim-experiment` = 저널 초기화)을 각인했다. 그래서
-     * 선언을 빠뜨린 프로비저닝이 **재기동마다 이력을 지우는 트윈**을 조용히 만들었다. 이제 만드는 쪽이
+     * 선언을 빠뜨린 프로비저닝이 **재기동마다 이력을 지우는 트윈**을 알리지 않고 만들었다. 이제 만드는 쪽이
      * 말해야 한다: 이 트윈이 자기 과거를 어떻게 대하는지는 만드는 사람이 아는 사실이다.
      */
     restartPolicy, comment, origin, 
@@ -2015,12 +2539,12 @@ class TwinEngine {
          * **구조가 바뀌어도 역사를 지우지 않는다.**
          *
          * 예전에는 서명이 다르면 그 트윈의 저널을 통째로 지웠다. 안 지우면 옛 이벤트를 새 공장에 대고
-         * 접게 되어 이력이 거짓말을 했기 때문이다 — 부스가 둘이던 시절의 사실을 여섯 개짜리 공장에
-         * 접으면 그때 없던 부스에서 일이 있었던 것처럼 보인다. 선택지가 **역사를 잃거나 거짓말을
+         * 계산하게 되어 이력이 거짓말을 했기 때문이다 — 부스가 둘이던 시절의 사실을 여섯 개짜리 공장에
+         * 계산하면 그때 없던 부스에서 일이 있었던 것처럼 보인다. 선택지가 **역사를 잃거나 거짓말을
          * 하거나** 둘뿐이었고, 그래서 공장을 고칠 때마다 이력을 버려야 했다.
          *
          * 이제 셋째 길로 간다: 바뀐 구조를 **새 리비전**으로 남기고, 앞으로 쓰이는 이벤트가 그 번호를
-         * 달고 다닌다. 재생은 구조가 바뀌는 지점에서 전환한 뒤 이어 접는다(`replaySegments`).
+         * 달고 다닌다. 재생은 구조가 바뀌는 지점에서 전환한 뒤 이어서 계산한다(`replaySegments`).
          */
         await this.recordStructure(domainId, instanceId, model, comment);
         await this.register(domainId, instanceId, kind, model, existing?.status === 'running' ? 'stopped' : existing?.status ?? 'stopped', restartPolicy, origin, meta);
@@ -2172,7 +2696,7 @@ class TwinEngine {
          * 웜스타트 재료를 **여기서 확실히 확보한다.**
          * `start()` 는 동기라 스스로 캐시를 읽을 수 없어서 `recovered` 에 미리 담겨 있기를 기대하는데,
          * 그건 `bootstrap()` 이 먼저 돌았을 때만 참이다. 부팅 순서에 기대면 어떤 날은 재고가 살아나고
-         * 어떤 날은 조용히 빈 채로 뜬다 — 재현되지 않는 결함이 가장 나쁘다.
+         * 어떤 날은 알리지 않고 빈 채로 뜬다 — 재현되지 않는 결함이 가장 나쁘다.
          * 체크포인트 캐시 우선(O(1) + 라이브 파생상태 보존), 없으면 저널 replay 폴백(부팅과 같은 순서).
          */
         if (!this.recovered[key] && reg.purpose !== 'bench') {
@@ -2201,9 +2725,9 @@ class TwinEngine {
             .getRawOne();
         return this.start(instanceId, domainId, 
         /* 커널 종류·현실 선언은 레지스트리에 반드시 있다(둘 다 NOT NULL). 예전에는 `?? 'wms'` 로
-           메웠는데, 그건 YMS/MES 트윈을 **조용히 WMS 로 부팅**시키는 길이었다 — 오류 없이 다른 공장이 뜬다. */
+           메웠는데, 그건 YMS/MES 트윈을 **알리지 않고 WMS 로 부팅**시키는 길이었다 — 오류 없이 다른 공장이 뜬다. */
         reg.kind, reg.model, 
-        /* 저장된 값은 위에서 **엄격히** 읽었다 — 모르는 값을 기본값으로 메우면 그 트윈이 조용히 다르게 재기동한다. */
+        /* 저장된 값은 위에서 **엄격히** 읽었다 — 모르는 값을 기본값으로 메우면 그 트윈이 알리지 않고 다르게 재기동한다. */
         policy, reg.purpose, Number(last?.max ?? 0) || 0);
     }
     /**
@@ -2230,7 +2754,7 @@ class TwinEngine {
              * 있는데 아무 일도 일어나지 않는」 상태가 됐다.
              *
              * 이것은 `start` 가 이미 배운 교훈과 같은 자리다: 부팅 순서에 기대면 어떤 날은 상태가 살아나고
-             * 어떤 날은 조용히 빈 채로 뜬다 — **재현되지 않는 결함이 가장 나쁘다.** 그래서 순서에 기대지 않고
+             * 어떤 날은 알리지 않고 빈 채로 뜬다 — **재현되지 않는 결함이 가장 나쁘다.** 그래서 순서에 기대지 않고
              * 이 자리에서 확보한다(이미 담겨 있으면 그것을 쓴다).
              */
             const key = (0, runtime_key_js_1.runtimeKey)(domainId, instanceId);
@@ -2430,7 +2954,7 @@ class TwinEngine {
         const agg = new Map();
         for (const r of insts) {
             /* 벤치 제외는 **선언으로만** 판단한다. 예전에는 spaceId 이름(`bench-`·`loadtest*`)으로도 추측했는데,
-               그러면 그렇게 이름 지은 진짜 운영 공간이 목록에서 조용히 사라진다. purpose 가 정본이다. */
+               그러면 그렇게 이름 지은 진짜 운영 공간이 목록에서 오류 없이 사라진다. purpose 가 정본이다. */
             if (!r.spaceId || r.purpose === 'bench')
                 continue;
             const model = r.model ?? {};
@@ -2516,7 +3040,7 @@ class TwinEngine {
          * 다시 그리면 그대로 사라진다 — 금액이 사라지고, 사용자는 자기가 넣은 값이 어디로 갔는지 알 수 없다.
          * 그래서 겹으로 보관한 선언을 매번 다시 얹는다(`engine/local-declarations`).
          *
-         * 대상이 사라졌으면(구조가 바뀌었다) 그 사실을 경고로 낸다 — 갈 곳 없는 선언을 조용히 버리지 않는다.
+         * 대상이 사라졌으면(구조가 바뀌었다) 그 사실을 경고로 낸다 — 갈 곳 없는 선언을 알리지 않고 버리지 않는다.
          */
         const prior = await (0, shell_1.getRepository)(twin_instance_js_1.TwinInstance).findOne({ where: { domain: { id: domainId }, instanceId: master.source } });
         /*
@@ -2553,7 +3077,7 @@ class TwinEngine {
             }
         }
         const repo = (0, shell_1.getRepository)(twin_space_js_1.TwinSpace);
-        /* 합칠 공간을 골랐으면 **있는지 먼저 확인한다** — 없는 곳에 조용히 새 공간을 만들면 사용자는
+        /* 합칠 공간을 골랐으면 **있는지 먼저 확인한다** — 없는 곳에 알리지 않고 새 공간을 만들면 사용자는
            합쳤다고 믿고 화면은 따로 논다. 판정 함수가 그 경우 거절한다. */
         const wanted = (into?.spaceId ?? '').trim();
         const wantedExists = wanted
@@ -2564,7 +3088,7 @@ class TwinEngine {
         model.spaceId = spaceId; // 보드(커널 소비)도 같은 공간을 가리켜야 한다
         const existing = await repo.findOne({ where: { domain: { id: domainId }, spaceId } });
         if (choice.joined) {
-            /* 같은 id 의 구역·랜드마크는 합집합으로 접힌다 — 구분할 수 없는 것을 고르지 않고 무엇이
+            /* 같은 id 의 구역·랜드마크는 합집합으로 합쳐진다 — 구분할 수 없는 것을 고르지 않고 무엇이
                합쳐졌는지 말한다(정당한 경우가 많으므로 막지 않는다). */
         }
         /*
@@ -2589,7 +3113,7 @@ class TwinEngine {
              * 대표 표현 포인터는 **표현을 저장한 뒤** 실제 행 id 로 채운다(아래). 여기서 마스터의 논리
              * id(`r-map` 따위)를 넣으면 표현 행은 생성 uuid 를 받으므로 포인터가 **처음부터 허공을
              * 가리킨다** — 실제로 13개 현장이 그 상태였고 정합성 점검이 잡았다(2026-08-13). 화면은
-             * 행의 `isPrimary` 로 ★를 그려서 증상이 보이지 않았다(사실이 두 벌이면 이렇게 조용하다).
+             * 행의 `isPrimary` 로 ★를 그려서 증상이 보이지 않았다(사실이 두 벌이면 이렇게 들어온 것이 없다).
              */
             primaryRepresentationId: existing?.primaryRepresentationId ?? null
         }));
@@ -2650,7 +3174,7 @@ class TwinEngine {
         }
         if (running) {
             /* 실행 중인 미러 — 멈추지 않고 전환한다. 무엇이 사라졌는지는 **경고로 말한다**
-               (멈췄다 세우는 마디가 없으므로, 말하지 않으면 자리 하나가 조용히 없어진다). */
+               (멈췄다 세우는 마디가 없으므로, 말하지 않으면 자리 하나가 알리지 않고 없어진다). */
             const shift = await this.adoptStructure(domainId, master.source, model, undefined, master.origin);
             warnings.push((0, reference_master_js_3.structureAdopted)(shift.rev, shift));
         }
@@ -2667,7 +3191,7 @@ class TwinEngine {
          *
          * 인제스트가 유일한 쓰기 경로다. 여기서 실패해도 인제스트 자체는 성공으로 둔다 —
          * 행은 **원본에서 언제든 다시 그릴 수 있는 캐시**이고, 트윈 자체는 model 로 이미 동작한다.
-         * 다만 **조용히 넘기지 않는다**: 못 이은 참조는 인제스트 경고로 올라간다.
+         * 다만 **알리지 않고 넘기지 않는다**: 못 이은 참조는 인제스트 경고로 올라간다.
          */
         try {
             const projected = await (0, project_structure_js_1.projectStructure)(domainId, master.source, model, master.source);
@@ -2681,7 +3205,7 @@ class TwinEngine {
              */
             if (model?.utcOffsetMinutes === undefined) {
                 for (const e of (model?.equipment ?? [])) {
-                    const hasProfile = (e?.properties ?? []).some(p => String(p?.id) === twin_kernel_1.EMS_PROPERTY.genDailyProfile && String(p?.value ?? '').trim());
+                    const hasProfile = (e?.properties ?? []).some(p => String(p?.id) === ops_contract_1.EMS_PROPERTY.genDailyProfile && String(p?.value ?? '').trim());
                     if (hasProfile)
                         warnings.push((0, reference_master_js_3.generationWithoutTimeZone)(String(model?.spaceId ?? ''), String(e.id)));
                 }
@@ -2728,6 +3252,19 @@ class TwinEngine {
      * 못 보낸 것은 **사실로 남긴다**(횟수를 세고 창마다 한 줄 남긴다). 삼키면 「보냈는데 화면이 낡았다」가
      * 되고, 그건 가장 찾기 어려운 부류다.
      */
+    /**
+     * 브로드캐스팅 한 건 — **이 가드가 대기열 넘침을 막지는 못한다** (2026-08-27 측정으로 바로잡음).
+     *
+     * 2026-08-14 에 이 함수를 「방송이 호스트를 죽이지 못하게」라는 이름으로 붙였다. 그것이 사실이 아니다.
+     * 대기열이 넘칠 때 나는 예외는 `EventTarget` 이 부른 리스너 안에서 난다. 런타임은 리스너 예외를
+     * 호출자에게 주지 않고 uncaughtException 으로 보낸다. 그래서 이 try/catch 에는 잡을 것이 없다.
+     * 실제로 그 뒤 3주 동안 막힌 줄 알고 있었고, 2026-08-27 10:24 에 같은 예외로 다시 죽었다.
+     *
+     * 넘침을 막는 것은 **한 실행 차례에 발행하는 수를 상한 아래로 두는 것**이다(§`PUBLISH_CHUNK`).
+     *
+     * 그래도 이 가드를 남기는 이유는 둘이다. `publish` 가 직접 던지는 경우(직렬화 실패 등)를 잡고,
+     * 못 보낸 태그의 시그니처를 되돌린다 — 남겨 두면 그 태그가 오류 없이 영원히 낡은 값을 보인다.
+     */
     static publishGuarded(channel, payload, what) {
         try {
             shell_1.pubsub.publish(channel, payload);
@@ -2745,7 +3282,7 @@ class TwinEngine {
             return false;
         }
     }
-    static publishEntityData(inst) {
+    static async publishEntityData(inst) {
         const domain = inst.domain;
         if (!domain)
             return;
@@ -2778,7 +3315,7 @@ class TwinEngine {
          * 문자열로 바꾼 뒤 「같다」를 확인하고 버렸다.
          *
          * 범위는 이 창에 들어온 사건에서 모았다(`touchedItemKeys`). **말할 수 없는 사건이 하나라도 있으면
-         * 범위는 없고 전부 만든다** — 낯선 어휘가 오면 조용히 빠뜨리는 대신 비싸게 안전한 쪽으로 떨어진다.
+         * 범위는 없고 전부 만든다** — 낯선 어휘가 오면 알리지 않고 빠뜨리는 대신 비싸게 안전한 쪽으로 떨어진다.
          *
          * 그리고 주기마다 한 번은 **무조건 전부** 만든다(`FULL_BROADCAST_EVERY`). 커널이 사건 없이 물품을
          * 바꾸는 자리가 생기면 그 값이 화면에 남을 수 있는데, 그 창을 몇 초로 묶는 그물이다. **보장이 아니라
@@ -2794,6 +3331,22 @@ class TwinEngine {
         inst.fullBroadcastDue = false;
         (0, load_meter_js_1.recordPhase)(load, 'deltas', performance.now() - tDelta);
         const tPub = performance.now();
+        /*
+         * ── **한 실행 차례에 상한까지만 발행한다** (2026-08-27 실측으로 고침) ────────
+         *
+         * 이 반복문이 동기였다. 구독의 대기열에는 버퍼가 없고, 발행하는 순간에 「다음 값을 달라」는 요청이
+         * 걸려 있지 않으면 쌓인다. 값을 꺼내는 쪽은 비동기라서 **동기 반복문이 도는 중에는 한 건도 꺼내지
+         * 못한다.** 그래서 N 건을 발행하면 첫 건만 전달되고 나머지가 쌓였고, 1024 를 넘는 순간 예외가 나서
+         * 프로세스가 내려갔다(2026-08-27 10:24 · 2026-08-14 에도 같은 예외).
+         *
+         * `PUBLISH_CHUNK` 마다 루프를 비워 준다. 그 틈에 소비자가 대기열을 꺼내 간다.
+         *
+         * **건너뛰지 않는다.** 이 창의 발행은 끝까지 한다 — 중간에 그만두면 그 태그가 낡은 값으로 남는다.
+         * 이 함수가 주기보다 오래 걸리면 다음 타이머는 그대로 돌아가고(§`flushLiveBroadcasts`),
+         * `adjustBroadcastPeriod` 가 주기를 올린다.
+         */
+        let published = 0;
+        let sinceYield = 0;
         for (const { tag, data } of deltas) {
             seen.add(tag);
             const sig = JSON.stringify(data);
@@ -2806,8 +3359,26 @@ class TwinEngine {
              */
             if (!this.publishGuarded('data', { data: { domain, tag, data } }, `data:${inst.id}`))
                 sigs.delete(tag);
+            published++;
+            if (++sinceYield >= this.PUBLISH_CHUNK) {
+                sinceYield = 0;
+                await new Promise(resolve => setImmediate(resolve));
+            }
         }
         (0, load_meter_js_1.recordPhase)(load, 'publish', performance.now() - tPub);
+        /*
+         * ── **몇 건을 발행했는지 남긴다** (2026-08-27) ──────────────────────────────
+         *
+         * 10:24 에 서버가 죽었을 때 그 창이 몇 건을 발행했는지 알 수 없었다. 그 수가 없으면 「대기열이
+         * 넘쳤다」는 사실만 있고 무엇이 넘겼는지 판단할 수 없어, 원인을 추측으로 고르게 된다.
+         *
+         * 상한을 넘긴 창만 남긴다 — 매 창을 남기면 로그가 그 자체로 부하가 된다.
+         */
+        inst.publishedTotal = (inst.publishedTotal ?? 0) + published;
+        if (published >= this.PUBLISH_CHUNK) {
+            (0, log_js_1.twinLog)(`[twin-engine] "${inst.id}" 이번 창에서 ${published}건 발행 ` +
+                `(전체 ${deltas.length}건 중 · ${full ? '전량' : '좁힘'} · 청크 ${this.PUBLISH_CHUNK})`);
+        }
         /*
          * 사라진 엔티티의 시그니처 정리(맵 무한 성장 방지) — **전부 만든 창에서만.**
          * 범위를 좁힌 창의 `seen` 에는 만들지 않은 엔티티가 없으므로, 그때 정리하면 살아 있는 태그의
@@ -2846,18 +3417,18 @@ class TwinEngine {
                 return this.snapshot(domainId, instanceId);
         }
         /*
-         * **끝에 있는 스냅샷이면 접지 않는다.**
+         * **끝에 있는 스냅샷이면 계산하지 않는다.**
          *
-         * 멈춘 트윈을 조회할 때마다 저널을 전량 접고 있었다 — 트윈을 하나도 안 돌려도 모델 조회가
+         * 멈춘 트윈을 조회할 때마다 저널을 전량 계산하고 있었다 — 트윈을 하나도 안 돌려도 모델 조회가
          * 4.6~7.7초였던 이유다(crew-probe 23,731건). 스냅샷은 같은 폴드의 결과이므로, 그 뒤로 이벤트도
-         * 구조 변경도 없다면 **다시 접어 봐야 같은 값**이다.
+         * 구조 변경도 없다면 **다시 계산해 봐야 같은 값**이다.
          *
-         * 쓰지 않는 조건을 좁게 잡는다: 지금을 물었을 때만(시간여행은 그 시점까지 접어야 한다), 리비전이
-         * 끝과 같을 때만, 구조 리비전까지 같을 때만. 하나라도 어긋나면 접는다 — 캐시가 사실을 이기지 않는다.
+         * 쓰지 않는 조건을 좁게 잡는다: 지금을 물었을 때만(시간여행은 그 시점까지 계산해야 한다), 리비전이
+         * 끝과 같을 때만, 구조 리비전까지 같을 때만. 하나라도 어긋나면 계산한다 — 캐시가 사실을 이기지 않는다.
          */
         const asOfNowRead = untilRevision == null && untilTime == null;
         const tip = asOfNowRead ? await this.tipOf(domainId, instanceId).catch(() => null) : null;
-        /* 한 번만 읽는다 — 끝에 있으면 그대로 쓰고, 아니면 아래에서 **이어 접는 씨앗**으로 쓴다. */
+        /* 한 번만 읽는다 — 끝에 있으면 그대로 쓰고, 아니면 아래에서 **이어 계산하는 씨앗**으로 쓴다. */
         const cachedForResume = asOfNowRead && tip ? await this.loadSnapshot(domainId, instanceId).catch(() => null) : null;
         if (cachedForResume) {
             const state = (0, warm_start_js_1.unwrapState)(cachedForResume.state);
@@ -2868,22 +3439,22 @@ class TwinEngine {
         if (!reg?.model)
             throw new Error(`twin instance "${instanceId}" not registered (no model to replay)`);
         /*
-         * ── 재개점에서 **이어 접는다** (2026-08-18) ────────────────────────────
+         * ── 재개점에서 **이어서 계산한다** (2026-08-18) ────────────────────────────
          *
-         * 우리는 이미 접은 결과를 남기고 있다(`saveFoldedSnapshot`). 그 지점의 **재개점**(리듀서 내부 상태
-         * 전부 + 가동 누적기)이 함께 있으면, 그 뒤에 일어난 것만 접어도 같은 답이 나온다 — 그 동치는
-         * 커널 시험이 증명한다(0부터 접기 == 재개점 + 꼬리).
+         * 우리는 이미 계산한 결과를 남기고 있다(`saveFoldedSnapshot`). 그 지점의 **재개점**(리듀서 내부 상태
+         * 전부 + 가동 누적기)이 함께 있으면, 그 뒤에 일어난 것만 계산해도 같은 답이 나온다 — 그 동치는
+         * 커널 시험이 증명한다(0부터 계산하기 == 재개점 + 꼬리).
          *
          * 쓰는 조건을 좁게 잡는다: **지금을 물었을 때만**(시간여행은 목표 이전 재개점이 필요한데 지금은
          * 최신 하나만 남긴다 — 사슬은 다음 단계다), 구조가 그대로일 때만(구조가 바뀌면 그 경계에서 갈라
-         * 접어야 한다), 재개점이 저널 끝보다 앞설 때만. 하나라도 어긋나면 0부터 접는다 — **캐시가 사실을
+         * 계산해야 한다), 재개점이 저널 끝보다 앞설 때만. 하나라도 어긋나면 0부터 계산한다 — **캐시가 사실을
          * 이기지 않는다.**
          */
         /*
          * 씨앗은 둘 중 하나다: **지금**을 물으면 최신 재개점, **과거**를 물으면 사슬에서 목표 직전 지점.
          *
-         * 과거 씨앗은 구조가 한 번도 바뀌지 않은 트윈에서만 쓴다 — 구조가 갈린 저널은 마디마다 갈아 접어야
-         * 하고, 마디를 건너뛴 씨앗은 그 경계의 판정을 잃는다(그때는 0부터 접는 것이 옳다).
+         * 과거 씨앗은 구조가 한 번도 바뀌지 않은 트윈에서만 쓴다 — 구조가 갈린 저널은 마디마다 갈아 계산해야
+         * 하고, 마디를 건너뛴 씨앗은 그 경계의 판정을 잃는다(그때는 0부터 계산하는 것이 옳다).
          */
         const structureCount = asOfNowRead
             ? 0
@@ -2911,10 +3482,10 @@ class TwinEngine {
         const cutoffMs = untilTime != null ? Date.parse(untilTime) : NaN;
         const useTime = untilTime != null && !Number.isNaN(cutoffMs);
         const baseWhere = { domain: { id: domainId }, instanceId };
-        /* 이어 접을 때는 **그 뒤만** 읽는다 — 재개점까지의 사실은 이미 씨앗 안에 있다. */
+        /* 이어 계산할 때는 **그 뒤만** 읽는다 — 재개점까지의 사실은 이미 씨앗 안에 있다. */
         const from = resume ? (resume.revision ?? 0) : undefined;
         /*
-         * journal-fold: 재생은 사실을 하나씩 접는 것이므로 그 구간의 행이 필요하다. 커서(`from`)와 시각
+         * journal-fold: 재생은 사실을 하나씩 계산하는 것이므로 그 구간의 행이 필요하다. 커서(`from`)와 시각
          * 상한이 구간을 자르고, 체크포인트가 앞쪽을 씨앗으로 대신한다 — 표 전체를 읽지 않는다.
          */
         const rows = await (0, shell_1.getRepository)(twin_event_js_1.TwinEvent).find({
@@ -2940,14 +3511,14 @@ class TwinEngine {
         });
         const wanted = rows;
         /*
-         * **그때의 공장으로 접는다.**
+         * **그때의 공장으로 계산한다.**
          *
-         * 예전에는 모든 이벤트를 지금 등록된 보드 하나로 접었다. 구조가 바뀐 적 없으면 맞지만, 바뀐
-         * 뒤에는 옛 사실을 새 공장에 대고 접게 되어 — 그때 없던 설비에서 일이 있었던 것처럼 보인다.
+         * 예전에는 모든 이벤트를 지금 등록된 보드 하나로 계산했다. 구조가 바뀐 적 없으면 맞지만, 바뀐
+         * 뒤에는 옛 사실을 새 공장에 대고 계산하게 되어 — 그때 없던 설비에서 일이 있었던 것처럼 보인다.
          * (그래서 예전 프로비저닝은 구조가 바뀌면 저널을 아예 지웠다. 역사를 잃거나 거짓말을 하거나.)
          *
-         * 이제 이벤트가 자기 구조를 달고 오므로, 리비전이 바뀌는 지점에서 구조를 갈아타며 이어 접는다.
-         * 리비전이 하나뿐이거나(대다수) 아예 없으면(구조 이력 이전) 예전과 똑같이 한 번에 접는다.
+         * 이제 이벤트가 자기 구조를 달고 오므로, 리비전이 바뀌는 지점에서 구조를 갈아타며 이어서 계산한다.
+         * 리비전이 하나뿐이거나(대다수) 아예 없으면(구조 이력 이전) 예전과 똑같이 한 번에 계산한다.
          */
         const structures = await (0, shell_1.getRepository)(twin_structure_js_1.TwinStructure).find({
             where: { domain: { id: domainId }, instanceId },
@@ -2973,7 +3544,7 @@ class TwinEngine {
          * **가장 새 구조가 지금의 공장이다** — 그 아래에서 아직 아무 일도 없었더라도.
          *
          * 재프로비저닝 직후가 정확히 그 상태다: 부스를 넷 늘렸는데 새 이벤트는 아직 하나도 없다. 이때
-         * 마지막 이벤트의 구조로만 접으면 화면은 **옛 공장**을 보여준다 — 방금 늘린 것이 안 보인다.
+         * 마지막 이벤트의 구조로만 계산하면 화면은 **옛 공장**을 보여준다 — 방금 늘린 것이 안 보인다.
          * 그래서 마디의 끝에 지금 구조를 한 번 더 얹는다(이벤트 없는 마디).
          *
          * **다만 "지금" 을 물었을 때만이다.** 과거 시점을 물었는데 최신 구조를 얹으면, 그 시점에 없던
@@ -2984,9 +3555,9 @@ class TwinEngine {
         if (asOfNow && newest && segments[segments.length - 1]?.model !== newest)
             segments.push({ model: newest, events: [] });
         /*
-         * 접은 상태에 **주의 신호와 시각을 채운다.**
+         * 계산한 상태에 **주의 신호와 시각을 채운다.**
          *
-         * 라이브·시뮬은 커널이 신호를 스스로 내지만, 저널을 접는 이 경로는 프로젝터 상태만 낸다 — 신호도
+         * 라이브·시뮬은 커널이 신호를 스스로 내지만, 저널을 계산하는 이 경로는 프로젝터 상태만 낸다 — 신호도
          * `nowTime` 도 없다. 그래서 **과거를 다시 계산하면 주의 레일이 텅 비었고**(지도는 `snap.attentions` 를
          * 읽는다), 기동돼 있지 않은 트윈을 보는 화면도 같았다. 신호는 상태에서 계산되는 것이므로
          * 여기서 같은 공식(`deriveAttentions`)으로 채우면 된다 — 두 벌을 두지 않는다.
@@ -3000,7 +3571,7 @@ class TwinEngine {
          * **가동 이력도 되살린다** — 다시 계산한 화면에 설비 계측이 비어 있던 것.
          *
          * OEE 는 원 시스템이 누적을 보내 주지 않아 호스트가 상태 전이를 적분해 만든다(그래서 커널이 아니라
-         * 여기 있다). 그런데 그 누적기는 **라이브에서만** 돌았고, 저널을 접는 경로는 그 계산을 하지 않았다 —
+         * 여기 있다). 그런데 그 누적기는 **라이브에서만** 돌았고, 저널을 계산하는 경로는 그 계산을 하지 않았다 —
          * 과거를 다시 계산하면 모든 설비가 "가동 이력이 전혀 없음" 으로 보였다.
          *
          * 없는 것은 데이터가 아니라 계산이다: 입력(`equipment.status` 전이·`quality.output`)은 저널에 다
@@ -3010,7 +3581,7 @@ class TwinEngine {
          * 가동 이력이 나온다(그 뒤에 일어난 고장이 과거 화면에 섞이지 않는다).
          */
         const oee = new oee_accumulator_js_1.OeeAccumulator();
-        /* 재개점이 있으면 그 위에 꼬리만 얹는다 — 없으면 꼬리분만 세어 가용률이 조용히 작아진다. */
+        /* 재개점이 있으면 그 위에 꼬리만 얹는다 — 없으면 꼬리분만 세어 가용률이 알리지 않고 작아진다. */
         if (resume?.fold?.oee)
             oee.restore(resume.fold.oee);
         for (const r of wanted) {
@@ -3031,20 +3602,20 @@ class TwinEngine {
             const withMetrics = (0, oee_accumulator_js_1.withLiveOee)(based, oee, Number.isFinite(nowMs) ? nowMs : undefined);
             return (0, live_attentions_js_1.withLiveAttentions)(withMetrics);
         };
-        /* 접은 결과를 남긴다 — **지금을 물었을 때만**(시간여행 결과를 "지금" 으로 저장하면 거짓이 된다). */
+        /* 계산한 결과를 남긴다 — **지금을 물었을 때만**(시간여행 결과를 "지금" 으로 저장하면 거짓이 된다). */
         /*
-         * 접은 지점의 리비전 — 사슬에 적을 이름이다. 꼬리를 접었으면 그 꼬리의 끝, 아무것도 안 읽었으면
+         * 계산한 지점의 리비전 — 사슬에 적을 이름이다. 꼬리를 계산했으면 그 꼬리의 끝, 아무것도 안 읽었으면
          * 씨앗의 자리 그대로다(모르면 0).
          */
         const foldedTo = rows.length ? (rows[rows.length - 1]?.revision ?? 0) : (from ?? 0);
         const keep = (st, fold) => {
-            /* 재개점을 함께 남긴다 — 상태만 남기면 다음 번에 또 0부터 접어야 한다(그것이 이 작업의 요점이다).
+            /* 재개점을 함께 남긴다 — 상태만 남기면 다음 번에 또 0부터 계산해야 한다(그것이 이 작업의 요점이다).
                **구조가 갈린 폴드에는 재개점을 붙이지 않는다**: 마디를 건너뛴 씨앗은 그 경계의 판정을 잃는다. */
             if (asOfNowRead && tip && st) {
                 void this.saveFoldedSnapshot(domainId, instanceId, { revision: tip.revision, state: st, structureRev: tip.structureRev, fold });
             }
             /*
-             * 사슬에는 **과거를 접었을 때도** 한 지점을 남긴다 (2026-08-18 실측으로 고침).
+             * 사슬에는 **과거를 계산했을 때도** 한 지점을 남긴다 (2026-08-18 실측으로 고침).
              *
              * 처음에는 「지금 읽기」에서만 남겼다. 그런데 도는 트윈의 지금 읽기는 커널 스냅샷으로 즉시 답하고
              * 폴드에 닿지 않는다 — 그래서 사슬이 **영원히 비어 있었다**(실측: 지점 0개, 시간여행 3.7s 그대로).
@@ -3065,26 +3636,26 @@ class TwinEngine {
             return st;
         };
         /*
-         * 씨앗이 있으면 **이어 접는다** — 한 구조 안에서만(구조가 갈리면 아래 마디 경로가 맡는다).
-         * 새 재개점도 함께 남긴다: 다음 번에 또 꼬리만 접을 수 있어야 이 지름길이 계속 산다.
+         * 씨앗이 있으면 **이어서 계산한다** — 한 구조 안에서만(구조가 갈리면 아래 마디 경로가 맡는다).
+         * 새 재개점도 함께 남긴다: 다음 번에 또 꼬리만 계산할 수 있어야 이 지름길이 계속 산다.
          */
         if (resume?.fold?.reducer && segments.length <= 1) {
             const model = (segments[0]?.model ?? (asOfNow && newest) ?? reg.model);
-            const out = replayFrom(model, resume.fold.reducer, segments[0]?.events ?? []);
+            const out = replayFrom(model, resume.fold.reducer, segments[0]?.events ?? [], replayOptions(reg, domainId));
             return keep(withNow(out.state), { reducer: out.checkpoint, oee: oee.serialize() });
         }
         if (!segments.length) {
             const model = ((asOfNow && newest) || reg.model);
-            const out = replayWithCheckpoint(model, []);
+            const out = replayWithCheckpoint(model, [], replayOptions(reg, domainId));
             return keep(withNow(out.state), { reducer: out.checkpoint, oee: oee.serialize() });
         }
         if (segments.length === 1) {
-            const out = replayWithCheckpoint(segments[0].model, segments[0].events);
+            const out = replayWithCheckpoint(segments[0].model, segments[0].events, replayOptions(reg, domainId));
             return keep(withNow(out.state), { reducer: out.checkpoint, oee: oee.serialize() });
         }
         /* 커널 계약도 `model` 이다(0.6.14) — 경계에서 어휘를 되돌려 담던 브릿지가 사라졌다. */
-        const { state, shifts } = replaySegments(segments);
-        /* 경계에서 사라진 것을 조용히 넘기지 않는다 — 수가 줄어든 이유를 어딘가에는 남겨야 한다. */
+        const { state, shifts } = replaySegments(segments, replayOptions(reg, domainId));
+        /* 경계에서 사라진 것을 알리지 않고 넘기지 않는다 — 수가 줄어든 이유를 어딘가에는 남겨야 한다. */
         for (const sh of shifts)
             if (sh.equipmentDropped || sh.locationsDropped || sh.personsDropped || sh.assetsDropped)
                 console.info(`[twin-engine] "${instanceId}" replay crossed a structure change — dropped ${sh.equipmentDropped} equipment, ${sh.locationsDropped} locations, ${sh.personsDropped} persons, ${sh.assetsDropped} assets that no longer exist.`);
@@ -3172,10 +3743,10 @@ class TwinEngine {
             /*
              * **끄기 전에 남긴다** — 지금이 메모리가 진실인 마지막 순간이다.
              *
-             * 남기지 않으면 다음 조회가 저널을 전량 다시 접는다(그 값은 어차피 방금 메모리에 있던 것이다).
-             * 체크포인트 루프가 20초마다 뜨지만 그 사이에 멈추면 그 구간이 통째로 다시 접힌다.
+             * 남기지 않으면 다음 조회가 저널을 전량 다시 계산한다(그 값은 어차피 방금 메모리에 있던 것이다).
+             * 체크포인트 루프가 20초마다 뜨지만 그 사이에 멈추면 그 구간이 통째로 다시 계산된다.
              */
-            await this.persistSnapshot(domainId, id).catch(err => (0, log_js_1.twinError)(`[twin-engine] snapshot on stop fail "${id}"`, err?.message ?? err));
+            await this.persistSnapshot(domainId, id, true).catch(err => (0, log_js_1.twinError)(`[twin-engine] snapshot on stop fail "${id}"`, err?.message ?? err));
             /*
              * **모아 둔 저널도 지금 흘린다** — 주기 flush 사이(최대 `BROADCAST_COALESCE_MS`)에 멈추면 그 구간의
              * 사실이 사라진다. 스냅샷만 남기면 상태는 살아도 **왜 그렇게 됐는지**가 빈다(저널이 답하는 것이다).
@@ -3204,7 +3775,7 @@ class TwinEngine {
      * 선언이 모든 테넌트를 멈춘 셈이다. 문 앞에서 막는 것이 1차 방벽이고(`validateScenario`),
      * 이것이 2차 방벽이다.
      *
-     * **조용히 삼키지 않는다.** 실행을 멈추고 그 사실을 남긴다 — 예외를 무시하고 계속 tick 하면
+     * **알리지 않고 삼키지 않는다.** 실행을 멈추고 그 사실을 남긴다 — 예외를 무시하고 계속 tick 하면
      * 같은 오류가 매 주기 쏟아지고, 그 트윈은 "도는 것처럼 보이면서" 아무것도 진행하지 않는다.
      */
     /**
@@ -3334,7 +3905,7 @@ class TwinEngine {
          * 미러 — 관측 커널로 보내고, **커맨드가 낸 사실을 저널 큐에 실어** 코얼레서가 번호를 부여하게 한다.
          * 미러에는 State 구독 배관이 없어(시뮬은 그 경로로 저널링) 커널 방출이 아무 데도 닿지 않는다.
          * 여기서 DB 를 따로 읽어 번호를 매기면 인메모리 카운터와 어긋나 리비전이 겹친다(겹침은 오류를
-         * 내지 않고 재생 순서만 조용히 뒤섞는다).
+         * 내지 않고 재생 순서만 알리지 않고 뒤섞는다).
          */
         const kernel = inst.kernel;
         const emitted = [];
@@ -3419,7 +3990,7 @@ class TwinEngine {
             const snap = kernel?.getSnapshot?.() ?? this.snapshot(domainId, id);
             return { instanceId: id, attentions: snap?.attentions ?? [] };
         });
-        /* 모으는 규칙(태깅·급한 순서·자리 색)은 순수 함수가 들고 있다 — 여기서 손으로 접지 않는다. */
+        /* 모으는 규칙(태깅·급한 순서·자리 색)은 순수 함수가 들고 있다 — 여기서 손으로 계산하지 않는다. */
         return (0, attention_digest_js_1.mergeLensAttentions)(lenses, limit);
     }
     /** 라이브 커널(ForecastTwin) — forecast/divergence 예측 연산용. */
@@ -3533,6 +4104,51 @@ class TwinEngine {
      * `offered` 는 **제시된 레코드 수**다(거부 여부 무관). 통과율을 서로 다른 두 계수기에서 나눠 계산하면
      * 분모와 분자가 다른 것을 세게 되므로, 한자리에서 본 수를 그대로 넘긴다.
      */
+    /**
+     * 이 트윈의 저널이 지금 몇 번까지 적혔나 — **접근자로 낸다.**
+     *
+     * 레지스트리를 밖에서 직접 색인하지 않게 하는 것이 이 저장소의 규율이다(§`engine-registry-access`).
+     * 지난 기록을 채우는 길이 다음 번호를 알아야 해서 열었다.
+     *
+     * 트윈이 도는 중이 아니면 0 이다 — 그때는 저널만 있고 이어 붙일 번호를 커널이 들고 있지 않다.
+     */
+    /**
+     * 마감된 구간 사실의 **이름을 지을 때 쓸 범위와 선언** — 유입 문에 넘긴다.
+     *
+     * ── 왜 호스트가 주나 (2026-08-30) ────────────────────────────────────────
+     * 커널은 `new Kernel(domainId, …)` 으로 서므로 **자기가 어느 트윈인지 모른다.** 그런데 설비 번호는
+     * 트윈 안에서만 통하는 이름표라, 한 도메인에 현장이 둘이면 서로 다른 설비의 같은 날이 한 사실이
+     * 된다. 실측으로 그 일이 났다 — 두 발전소의 `002` 가 겹쳐, 여러 현장을 함께 계산하는 성과 화면에서
+     * 한쪽 발전량이 사라진다.
+     *
+     * 선언된 정체성은 **커널이 답한다**(§`FlowEngine.equipmentIdentity`) — 판정을 두 곳에 두지 않는다.
+     * 트윈이 돌고 있지 않으면 선언을 물을 곳이 없으므로 범위만 넘긴다(그때도 겹치지는 않는다).
+     */
+    static factScope(domainId, instanceId) {
+        const inst = this.instances[(0, runtime_key_js_1.runtimeKey)(domainId, instanceId)];
+        const kernel = inst?.kernel;
+        if (typeof kernel?.equipmentIdentity !== 'function')
+            return { scopeId: instanceId };
+        return {
+            scopeId: instanceId,
+            identityOf: (kind, localId) => (kind === 'equipment' ? kernel.equipmentIdentity(localId) : undefined)
+        };
+    }
+    static journalHead(domainId, instanceId) {
+        const inst = this.instances[(0, runtime_key_js_1.runtimeKey)(domainId, instanceId)];
+        return Number(inst?.revision ?? 0);
+    }
+    /**
+     * 저널에 그만큼 적었으니 번호를 밀어 준다.
+     *
+     * 밀어 주지 않으면 다음에 라이브가 **같은 번호를 다시 쓴다** — 같은 시각의 두 사실을 가릴 수 없게 된다.
+     */
+    static advanceJournalHead(domainId, instanceId, by) {
+        const inst = this.instances[(0, runtime_key_js_1.runtimeKey)(domainId, instanceId)];
+        if (!inst || !(by > 0))
+            return;
+        inst.revision = Number(inst.revision ?? 0) + by;
+    }
     static recordIngestResult(domainId, instanceId, offered, rejected, nowMs = Date.now(), 
     /**
      * 매핑은 통과했는데 **커널이 받지 않은** 수(`ingestLive` 의 반환과 견주어 얻는다).
@@ -3548,22 +4164,32 @@ class TwinEngine {
      * **원본에 닿지 못했다**를 적는다 — 「받은 것이 없다」와 가른다(§`recordReadFailure`).
      *
      * 이 문이 없던 동안 실 원본이 끊겨도 트윈의 조회 가능한 상태에 그 사실이 없었다. 화면이 볼 수 있는
-     * 것은 「새 사실이 없다」뿐이었고 그것은 「원본이 조용하다」와 구별되지 않는다 — 실증 중에 원본이
+     * 것은 「새 사실이 없다」뿐이었고 그것은 「연결된 시스템에서 들어온 것이 없다」와 구별되지 않는다 — 실증 중에 원본이
      * 끊기면 사용자가 원인을 찾을 수 없다.
      *
      * 로그로는 말하고 있었다(어댑터가 재시도를 경고한다). 그러나 **로그는 사람이 볼 때만 값이 있다** —
      * 화면이 말하려면 상태에 있어야 한다.
      */
-    static recordIngestReadFailure(domainId, instanceId, reason, nowMs = Date.now(), stream) {
+    static recordIngestReadFailure(domainId, instanceId, reason, nowMs = Date.now(), stream, nextRetryMs) {
+        const key = (0, runtime_key_js_1.runtimeKey)(domainId, instanceId);
+        const ledger = this.ingestLedgers[key] ?? (this.ingestLedgers[key] = (0, ingest_health_js_1.newIngestLedger)());
+        (0, ingest_health_js_1.recordReadFailure)(ledger, reason, nowMs, stream, nextRetryMs);
+    }
+    /**
+     * **끊겼다가 돌아왔다** — 실패 기록을 지우고 그 사실을 남긴다 (2026-08-27).
+     *
+     * `clearIngestReadFailure` 와 나누어 둔다: 지우기만 하면 「끊긴 적이 있었다」가 화면에서 사라진다.
+     */
+    static recordIngestRecovered(domainId, instanceId, afterFailures, downMs, nowMs = Date.now()) {
         const key = (0, runtime_key_js_1.runtimeKey)(domainId, instanceId);
         const ledger = this.ingestLedgers[key] ?? (this.ingestLedgers[key] = (0, ingest_health_js_1.newIngestLedger)());
-        (0, ingest_health_js_1.recordReadFailure)(ledger, reason, nowMs, stream);
+        (0, ingest_health_js_1.recordRecovered)(ledger, afterFailures, downMs, nowMs);
     }
     /**
      * 읽기가 성공했다 — 단절 기록을 지운다.
      *
      * **빈 읽기도 성공이다.** 원본이 「새 것이 없다」고 답한 것은 닿았다는 뜻이므로, 그때도 부른다.
-     * 그 둘을 같게 두면 조용한 원본이 끊긴 원본으로 보인다.
+     * 그 둘을 같게 두면 들어온 것이 없는 연결이 끊긴 원본으로 보인다.
      */
     static clearIngestReadFailure(domainId, instanceId) {
         const ledger = this.ingestLedgers[(0, runtime_key_js_1.runtimeKey)(domainId, instanceId)];
@@ -3588,7 +4214,7 @@ class TwinEngine {
      * **원본에 있는데 세우지 않은 것을 적는다** — 이유와 수(§`IngestLedger.withheld`).
      *
      * 어댑터가 주기마다 불러도 된다: 장부가 이유로 묶어 **마지막 수로 덮는다**(누적하지 않는다).
-     * `count: 0` 은 「그 이유가 풀렸다」로 그 줄을 지운다 — 조용히 그치면 낡은 수가 남는다.
+     * `count: 0` 은 「그 이유가 풀렸다」로 그 줄을 지운다 — 알리지 않고 그치면 낡은 수가 남는다.
      */
     static recordIngestWithheld(domainId, instanceId, reason, count, nowMs = Date.now()) {
         const key = (0, runtime_key_js_1.runtimeKey)(domainId, instanceId);
@@ -3693,7 +4319,7 @@ class TwinEngine {
     /**
      * 도는 인스턴스 전체의 계측(모니터 대시보드용) — **시뮬과 미러를 함께**.
      *
-     * 예전에는 시뮬에 계기가 없어 이 목록에서 조용히 빠졌다(계기가 `null` 이라 걸러졌다). 도는 트윈
+     * 예전에는 시뮬에 계기가 없어 이 목록에서 알리지 않고 빠졌다(계기가 `null` 이라 걸러졌다). 도는 트윈
      * 대부분이 시뮬인 서버에서 그 목록은 「부하가 거의 없다」로 보였다.
      */
     static async allMetrics(domainId) {
@@ -3750,10 +4376,10 @@ class TwinEngine {
             return null;
         const cutoff = untilTime != null ? Date.parse(untilTime) : Infinity;
         /*
-         * journal-fold: 오더의 마지막 상태는 그 오더에 일어난 사실들을 접어야 나온다.
+         * journal-fold: 오더의 마지막 상태는 그 오더에 일어난 사실들을 계산해야 나온다.
          *
          * **없어질 조건** — 지금 이 읽기에는 상한이 없고 `eventType` 에 인덱스도 없다. 그래서 저널이 큰
-         * 트윈에서는 이 한 번이 그 트윈의 저널 전체 주사다. 오더 상태를 따로 접어 둔 표(투영)를 두거나,
+         * 트윈에서는 이 한 번이 그 트윈의 저널 전체 주사다. 오더 상태를 따로 계산해 둔 표(투영)를 두거나,
          * `(domain, instanceId, eventType, revision)` 인덱스를 붙이고 커서를 넣으면 이 예외는 사라진다.
          * 시각 상한(`cutoff`)을 SQL 로 내려도 절반은 준다.
          */