@things-factory/headless-twin 10.0.8 → 10.0.10

package/server/engine/twin-engine.ts

@@ -8,11 +8,18 @@
  */
 
 import { pubsub, getRepository, Domain } from '@things-factory/shell'
+/* 저널을 자를 조건은 SQL 이 안다 — 관용구만 쓴다(원시 SQL 은 5개 드라이버에서 갈라진다). */
+import { And, IsNull, LessThanOrEqual, MoreThan } from 'typeorm'
 import { cacheService } from '@things-factory/cache-service'
 
+import type { ReducerCheckpoint } from '@operato/twin-kernel'
+import type { OeeCheckpoint } from './oee-accumulator.js'
 import { TwinEvent } from '../service/twin-event/twin-event.js'
 import { twinEventKeys } from '../service/twin-event/twin-event-keys.js'
-import { planWarmStart } from './warm-start.js'
+import { planLiveContinuity, planWarmStart, unwrapState } from './warm-start.js'
+import { applyDeclarationLayers } from './local-declarations.js'
+import { isOfDomain, parseRuntimeKey, runtimeKey } from './runtime-key.js'
+import { routeCommand } from './command-routing.js'
 import { TwinInstance } from '../service/twin-instance/twin-instance.js'
 import { TwinStructure } from '../service/twin-structure/twin-structure.js'
 import { TwinSpace } from '../service/twin-space/twin-space.js'
@@ -21,22 +28,46 @@ import { TwinSpaceRepresentation } from '../service/twin-space/twin-space-repres
 import { TwinSpaceArea } from '../service/twin-space/twin-space-area.js'
 import { TwinArea } from '../service/twin-space/twin-area.js'
 import { masterToTwin, type ReferenceMaster } from '../service/reference/reference-master.js'
+import { resolveIngestSpace } from '../service/reference/ingest-space.js'
+import { type IngestWarning, describeWarnings, unresolvedReference, projectionFailed, structureAdopted, generationWithoutTimeZone } from '../service/reference/reference-master.js'
+import { projectStructure } from '../service/twin-model/project-structure.js'
 import { buildTravelEstimator, chainEstimators } from './travel-estimator.js'
 import { buildMeasuredEstimator } from './measured-estimator.js'
 import { describeModelBasis, type ModelBasis } from './model-basis.js'
 import { computeTwinKpi } from './kpi-query.js'
 import { createHash } from 'node:crypto'
 
-import { buildEntityDeltas } from './entity-delta.js'
+import { buildEntityDeltas } from '@things-factory/headless-twin/dist-shared/entity-delta.js'
+import { fleetLoad, judgeCycle, loadSummary, newLoadMeter, recordFork, recordPhase, slowTickMessage, type LoadMeter, type LoadPhase } from './load-meter.js'
 import { diffStructures, type StructureDiff } from './structure-diff.js'
 import { OeeAccumulator, withLiveOee } from './oee-accumulator.js'
+import { withLiveAttentions } from './live-attentions.js'
+import { digestAttentions, mergeLensAttentions } from './attention-digest.js'
 
-import type { TwinKernel, BoardDef, SubscriptionMessage, TwinRuntime as TwinRuntimeType, CanonicalEnvelope } from '@operato/twin-kernel'
+import { liveFeedStateOf } from './live-feed-registry.js'
+import { EMS_PROPERTY } from '@operato/twin-kernel'
+import type { TwinKernel, TwinModelDef, StructureShift, SubscriptionMessage, TwinRuntime as TwinRuntimeType, CanonicalEnvelope } from '@operato/twin-kernel'
 
 /* 커널 런타임 로드 — CJS 번들(dist-cjs). 타입은 위 import type 로. replay = 이벤트열→상태 재구성(복구·시간여행). */
-const { WmsKernel, YmsKernel, MesKernel, TwinRuntime, StateProjector, replay, replaySegments, DOMAIN_CATALOG, OP_EVENT } = require('@operato/twin-kernel')
+const { WmsKernel, YmsKernel, MesKernel, EmsKernel, TwinRuntime, StateProjector, replay, replayFrom, replayWithCheckpoint, replaySegments, readBoardLocations, readBoardEquipment, DOMAIN_CATALOG, OP_EVENT } = require('@operato/twin-kernel')
 
-const KERNELS: Record<string, any> = { wms: WmsKernel, yms: YmsKernel, mes: MesKernel }
+const KERNELS: Record<string, any> = { wms: WmsKernel, yms: YmsKernel, mes: MesKernel, ems: EmsKernel }
+
+/**
+ * 종류 문자열 → 커널. **모르는 값이면 던진다.**
+ *
+ * 예전에는 표를 찾고 없으면 WmsKernel 로 떨어졌다. `kind` 는 검증 없는 자유 문자열(`@Arg('kind') kind: string`)
+ * 이라 오타 하나·대소문자 하나로 야드/생산 트윈이 **조용히 창고 커널로 돌았다.** 오류가 없으니 화면에는
+ * 트윈이 정상으로 보이고, 안에서 도는 규칙만 다른 도메인의 것이다. 예측 경로가 가장 나쁘다 —
+ * 야드의 미래를 창고 규칙으로 실행해 놓고 숫자만 뜬다.
+ *
+ * 틀린 공장을 조용히 띄우는 것보다 뜨지 않는 편이 낫다.
+ */
+function kernelFor(kind: string): any {
+  const K = KERNELS[kind]
+  if (!K) throw new Error(`unknown twin kind "${kind}" — expected one of ${Object.keys(KERNELS).join(' | ')}`)
+  return K
+}
 
 /* 라이브 처리량 계측(모니터) — 유입/방송/저널률·백로그. 실 동기 인터페이스 부하를 읽는 일급 지표. */
 interface TwinMetrics {
@@ -64,6 +95,8 @@ export const DEFAULT_REALITY_MODE: RealityMode = 'sim-experiment'
 
 /* 인메모리 라이브 런타임 홀더(영속 엔티티 TwinInstance 와 구분). */
 interface InstanceRuntime {
+  /** 부하 계기판 — 작업별 소요. 시뮬·라이브 모두 붙는다(누가 루프를 점유하는지 보려면 둘 다 필요하다). */
+  load?: LoadMeter
   /** 현실 출처 선언(§0 프레임 ①). 부팅 거동(reset/resume/resync)의 근거. */
   realityMode?: RealityMode
   id: string
@@ -72,6 +105,8 @@ interface InstanceRuntime {
   runtime?: TwinRuntimeType // sim: 커널 런타임(tick/subscribe/dispatch). live 는 projector 사용.
   kernel?: any // sim: ForecastTwin(fork/getSnapshot/tick/scenario). live 미사용.
   mode?: 'sim' | 'live' // 상태 드라이버 — sim=커널 tick / live=projector 미러(face2-inbound-live). 미지정=sim.
+  /** 이 트윈이 선 현장 — 같은 현장의 트윈끼리 서로의 설비 상태를 읽을 수 있게 하는 열쇠. */
+  spaceId?: string
   /**
    * live 의 상태 접근 어댑터 — 이제 **관측 모드 커널**을 가리킨다(`kernel` 과 같은 것).
    * 이름은 소비처 호환으로 남았고, P3 에서 커널 어휘로 정리하면 사라진다.
@@ -79,6 +114,11 @@ interface InstanceRuntime {
   projector?: any
   oee?: OeeAccumulator // live: OEE 계산 층(이벤트 누적 → equipment payload 보강). sim 은 커널이 계산.
   unsub: () => void
+  /**
+   * 방금 인입한 봉투들 — 커널이 그것을 재방출할 때 **저널에 두 번 적지 않기** 위한 표시.
+   * 라이브만 쓴다(sim 은 커널이 스스로 낸 것만 흘린다). 약한 참조라 따로 비울 것이 없다.
+   */
+  applying?: WeakSet<object>
   timer?: any
   /** 엔티티별 마지막 발행 시그니처 — 값이 바뀐 엔티티만 재발행(무변화 반복 push 방지). */
   entitySigs?: Map<string, string>
@@ -92,41 +132,214 @@ interface InstanceRuntime {
   metrics?: TwinMetrics
 }
 
+/**
+ * 트윈이 **스스로 멈춘 이유** — 문장이 아니라 코드다.
+ *
+ * 서버가 만든 영어 문장을 그대로 실으면 한국어·일본어 화면에 그 영어가 뜬다. 이 시스템은 거절 메시지에서
+ * 같은 결론에 이르렀다(코드+파라미터를 내고 화면이 옮긴다). `reason` 만은 원문 그대로다 — 커널·런타임이
+ * 낸 오류 문구는 옮길 수 있는 어휘가 아니고, 옮기려 들면 원인을 잃는다.
+ */
+export interface StopNote {
+  code: 'starved' | 'tick-failed'
+  params: Record<string, string | number>
+}
+
 export class TwinEngine {
+  /*
+   * 기동 중인 런타임 — **키는 `runtimeKey(domainId, instanceId)`** 다(`runtime-key.ts` 에 이유).
+   *
+   * 예전엔 `instanceId` 하나로 키를 잡았다. 그런데 정체성은 `(domain, instanceId)` 이고 DB 유일성도
+   * 그쪽이라, 두 테넌트가 같은 id 를 쓰면(레퍼런스 경로가 소스 이름을 id 로 쓴다) 한 자리를 다퉜다.
+   * **엔진 밖에서 이 맵을 직접 색인하지 않는다** — `owns`·`runtime`·`kernel` 같은 접근자를 쓴다.
+   */
   static instances: Record<string, InstanceRuntime> = {}
   /** 라이브 런타임이 없을 때(복구 후 미기동) 저널에서 재구성한 상태 캐시. */
+  /** 웜스타트 씨앗 — `instances` 와 **같은 키**(겹치면 남의 스냅샷으로 재고가 섞인다). */
   static recovered: Record<string, any> = {}
   static TICK_MS = 1000
 
+  /*
+   * ── 굶김 안전망 (2026-08-14) ──────────────────────────────────────────────
+   * 시뮬 틱은 **메인 이벤트 루프**에서 돈다. 그래서 한 트윈의 틱이 길어지면 그 시간만큼 호스트 전체가
+   * 멈춘다 — HTTP·구독·다른 트윈의 틱까지. 실측으로 `order-check` 의 틱 하나가 34.9초였고, 그 사이
+   * 구독자가 아무것도 빼내지 못해 pubsub 이 넘쳐 프로세스가 죽었다.
+   *
+   * 방송 반복은 걷어냈지만(`flushLiveBroadcasts` 로 병합) **커널 틱 자체는 여전히 메인 루프에 있다.**
+   * 근본 해결은 분산이고 그것은 이연됐다 — 그때까지의 안전망이 이 셋이다.
+   *
+   * 판정을 예산(500ms)이 아니라 **굶김 문턱**으로 따로 둔다: 조금 느린 트윈은 계기판이 말하게 두고
+   * (경고), 호스트를 굶기는 트윈만 멈춘다. 한 번으로 멈추지 않는다 — 웜스타트 직후의 첫 틱은 원래
+   * 무겁다(복구한 상태를 처음 접는다). **연속**으로 이어질 때가 구조적으로 느린 것이다.
+   */
+  /** 굶김 문턱 — 틱 간격의 배수(1초 간격이면 5초). 이 시간만큼 호스트가 멈춘다. */
+  static STARVE_FACTOR = 5
+  /** 연속 몇 번이면 멈추나 — 3번이면 15초를 굶긴 셈이고, 그건 우연이 아니다. */
+  static STARVE_STREAK = 3
+  private static starveStreak = new Map<string, number>()
+  /**
+   * 왜 멈췄나 — **화면이 그대로 말할 수 있게.** 스스로 멈춘 트윈이 이유 없이 「정지」로만 보이면
+   * 사람은 자기가 멈춘 줄 안다. 메모리에만 둔다(재기동하면 사라진다 — 그때는 「모른다」가 사실이다).
+   */
+  private static stopNotes = new Map<string, StopNote>()
+
   /* 최신 스냅샷 영속(warm-start) — 재기동 시 저널 fold-from-0 replay 대신 마지막 라이브 스냅샷으로 복원.
    * 프레임워크 공통 cache-service(@things-factory/cache-service) 재사용(재발명 금지, framework-leverage §4).
    * 저널은 그대로 진실(시간여행/history replay 무변경) — 캐시는 display-only 웜스타트 최적화. */
   static SNAPSHOT_CACHE_ID = 'twin-snapshot'
+  /*
+   * ── 재개점 **사슬** — 과거를 물었을 때 목표 직전에서 접기 위해 (2026-08-18) ──
+   *
+   * 최신 재개점 하나로는 시간여행을 도울 수 없다: 그것은 언제나 목표보다 **뒤**에 있다. 그래서 지점을
+   * 여러 개 남긴다. 다만 그것들은 각각 상태 전체를 들고 있어 무겁다 — 한 행에 몰아 넣으면 거대한
+   * JSON 이 되므로 **지점마다 따로 두고 색인을 둔다**(cache-service 는 해시 키 조회라 열거가 안 된다).
+   *
+   * 간격은 리비전 눈금으로 잡는다(`CHAIN_STRIDE`): 눈금을 넘을 때만 한 지점을 남기므로, 저널이 빠르게
+   * 자라는 트윈에서도 지점 수가 폭발하지 않는다. 오래된 것부터 버리고 최근 `CHAIN_KEEP` 개만 든다 —
+   * 과거로 깊이 갈수록 지점이 없어 0부터 접는 것은 **알려진 한계**다(무한 보관보다 정직하다).
+   */
+  static CHAIN_CACHE_ID = 'twin-fold-chain'
+  static CHAIN_INDEX_CACHE_ID = 'twin-fold-chain-index'
+  static CHAIN_STRIDE = 5000 // 리비전 눈금 — 이 간격을 넘을 때만 한 지점을 남긴다
+  static CHAIN_KEEP = 5 // 최근 몇 지점을 들고 있나(그보다 과거는 0부터 접는다)
   static SNAPSHOT_TTL_S = 7 * 24 * 3600 // 7일 — 정상 다운타임 생존, 만료 시 저널 replay 폴백
   static CHECKPOINT_MS = 20000 // 체크포인트 주기(핫 브로드캐스트 경로와 분리, O(state) 스로틀)
   private static checkpointTimer?: any
 
   /** 최신 스냅샷을 cache-service 에 체크포인트(도메인+instanceId 키). display-only·비차단·오류흡수. */
   static async persistSnapshot(domainId: string, instanceId: string): Promise<void> {
-    const inst = this.instances[instanceId]
+    const inst = this.instances[runtimeKey(domainId, instanceId)]
     if (!inst) return
-    const state = this.snapshot(instanceId)
+    /*
+     * **봉투가 아니라 상태를 저장한다.** `snapshot()` 은 시뮬에서 `runtime.resync()` 봉투를 주는데,
+     * 그것을 다시 `{revision, state}` 로 감싸 넣어 왔다 → 꺼낸 값에 축이 하나도 없어 웜스타트가
+     * 조용히 넘어갔다(저널에 수천 건이 있어도 트윈이 빈 채로 떴다).
+     */
+    const state = unwrapState(this.snapshot(domainId, instanceId))
     if (!state) return
     const revision = inst.revision ?? state.revision ?? 0
-    await cacheService.setInCache(this.SNAPSHOT_CACHE_ID, { domainId, instanceId }, { revision, state }, this.SNAPSHOT_TTL_S)
+    /* 구조 리비전도 함께 — 읽는 쪽이 "이 상태가 지금의 공장인가" 를 가릴 수 있어야 한다. */
+    const { structureRev } = await this.tipOf(domainId, instanceId).catch(() => ({ structureRev: null }) as any)
+    await cacheService.setInCache(this.SNAPSHOT_CACHE_ID, { domainId, instanceId }, { revision, state, structureRev }, this.SNAPSHOT_TTL_S)
   }
 
+  /**
+   * 접기의 **재개점** — 리듀서 내부 상태 전부 + 가동 누적기.
+   *
+   * 스냅샷(`state`)은 소비처가 보는 값이라 이어 접기의 씨앗이 되지 못한다(보류된 담김·집합·반영 못 한
+   * 사건 집계가 없다 — 그 상태로 뒤를 접으면 0부터 접은 결과와 조용히 달라진다). 그래서 씨앗은 따로 든다.
+   */
+  private static readonly FOLD_NOTE = 'reducer + oee checkpoint — the seed for folding only the tail'
+
   /** 체크포인트된 최신 스냅샷 로드(없으면 null). getFromCache 는 CacheStore 엔티티를 반환 → 페이로드는 .value. */
-  static async loadSnapshot(domainId: string, instanceId: string): Promise<{ revision: number; state: any } | null> {
+  static async loadSnapshot(
+    domainId: string,
+    instanceId: string
+  ): Promise<{ revision: number; state: any; structureRev?: number | null; fold?: { reducer: ReducerCheckpoint; oee: OeeCheckpoint } } | null> {
     const entry = await cacheService.getFromCache(this.SNAPSHOT_CACHE_ID, { domainId, instanceId })
     return (entry as any)?.value ?? null
   }
 
+  /**
+   * 접은 상태를 스냅샷으로 남긴다 — **라이브가 아니어도.**
+   *
+   * `persistSnapshot` 은 기동 중인 인스턴스에서만 뜬다(메모리가 진실이므로 옳다). 그런데 **멈춘**
+   * 트윈을 조회할 때마다 저널을 전량 다시 접고 있었다(23,731건짜리 트윈에서 4.6초). 그 폴드의 결과를
+   * 남겨 두면 **처음 한 번만 느리다.**
+   *
+   * `structureRev` 를 함께 적는다: 이벤트가 하나도 안 늘어도 구조를 갈아치우면(재프로비저닝) 그
+   * 상태는 낡은 것이다. 리비전만 보면 새 설비가 없는 옛 상태를 "지금" 으로 내게 된다.
+   */
+  static async saveFoldedSnapshot(
+    domainId: string,
+    instanceId: string,
+    value: { revision: number; state: any; structureRev?: number | null; fold?: { reducer: ReducerCheckpoint; oee: OeeCheckpoint } }
+  ): Promise<void> {
+    if (!value?.state) return
+    await cacheService
+      .setInCache(this.SNAPSHOT_CACHE_ID, { domainId, instanceId }, value, this.SNAPSHOT_TTL_S)
+      .catch((err: any) => console.error(`[twin-engine] snapshot save fail "${instanceId}"`, err?.message ?? err))
+  }
+
+
+  /** 사슬 색인 — 어떤 리비전 지점을 들고 있나(최신순 아님, 오름차순). */
+  private static async chainIndex(domainId: string, instanceId: string): Promise<number[]> {
+    const entry = await cacheService.getFromCache(this.CHAIN_INDEX_CACHE_ID, { domainId, instanceId }).catch(() => null)
+    const revs = (entry as any)?.value?.revisions
+    return Array.isArray(revs) ? revs.filter((r: any) => Number.isFinite(r)).sort((a: number, b: number) => a - b) : []
+  }
+
+  /**
+   * 목표 이전의 **가장 가까운 지점**을 고른다 — 없으면 `null`(0부터 접는다).
+   *
+   * 시각으로 물었으면 그 지점의 마지막 사실 시각이 목표 이내여야 한다(리비전만 보면 목표보다 뒤의
+   * 사실이 씨앗에 섞인다). 구조가 바뀐 트윈에서는 쓰지 않는다 — 마디를 건너뛴 씨앗은 그 경계의
+   * 판정을 잃는다(그 경우는 0부터 접는 것이 옳다).
+   */
+  private static async chainSeedFor(
+    domainId: string,
+    instanceId: string,
+    target: { revision?: number; timeMs?: number }
+  ): Promise<{ revision: number; eventTime?: string; structureRev?: number | null; fold?: { reducer: ReducerCheckpoint; oee: OeeCheckpoint } } | null> {
+    const revs = await this.chainIndex(domainId, instanceId)
+    if (!revs.length) return null
+    for (const revision of [...revs].reverse()) {
+      if (target.revision != null && revision > target.revision) continue
+      const entry = await cacheService.getFromCache(this.CHAIN_CACHE_ID, { domainId, instanceId, revision }).catch(() => null)
+      const value = (entry as any)?.value
+      if (!value?.fold?.reducer) continue
+      if (target.timeMs != null) {
+        const t = value.eventTime ? Date.parse(String(value.eventTime)) : NaN
+        /* 시각을 모르는 지점은 쓰지 않는다 — 목표 이내인지 가릴 수 없다(짐작하지 않는다). */
+        if (!Number.isFinite(t) || t > target.timeMs) continue
+      }
+      return value
+    }
+    return null
+  }
+
+  /** 눈금을 넘었으면 한 지점을 남긴다 — 오래된 것은 버린다(색인도 함께 줄인다). */
+  private static async keepChainPoint(
+    domainId: string,
+    instanceId: string,
+    /*
+     * **보기(state)는 담지 않는다** (2026-08-18 실측으로 고침).
+     *
+     * 처음에는 상태까지 담았더니 지점 하나가 **11.4 MB** 였다(27만 건 트윈). 사슬이 필요한 것은 씨앗
+     * (재개점)뿐이고, 소비처가 보는 값은 그 씨앗에서 다시 만들어진다 — 같은 사실을 두 번 저장하지 않는다.
+     */
+    value: { revision: number; eventTime?: string; structureRev?: number | null; fold: { reducer: ReducerCheckpoint; oee: OeeCheckpoint } }
+  ): Promise<void> {
+    const revs = await this.chainIndex(domainId, instanceId)
+    const newest = revs.length ? revs[revs.length - 1] : -Infinity
+    if (value.revision - newest < this.CHAIN_STRIDE) return // 아직 눈금을 넘지 않았다
+    const next = [...revs, value.revision].slice(-this.CHAIN_KEEP)
+    const dropped = revs.filter(r => !next.includes(r))
+    await cacheService.setInCache(this.CHAIN_CACHE_ID, { domainId, instanceId, revision: value.revision }, value, this.SNAPSHOT_TTL_S)
+    await cacheService.setInCache(this.CHAIN_INDEX_CACHE_ID, { domainId, instanceId }, { revisions: next }, this.SNAPSHOT_TTL_S)
+    /*
+     * 버린 지점은 **색인에서만** 빠진다 — 공용 캐시에 삭제 API 가 없다(`ICacheService` 는 get·set·
+     * clearStaleCache 뿐이다). 그래서 값은 TTL(7일)까지 남는다: 아무도 닿지 못하지만 자리는 차지한다.
+     * 지금 규모에서 감당할 수 있는 낭비이고, 공용 모듈에 삭제를 여는 것은 다른 소비처까지 함께 볼
+     * 일이라 여기서 몰래 하지 않는다 — **알려진 한계로 적어 둔다.**
+     */
+    if (dropped.length) console.info(`[twin-engine] "${instanceId}" fold chain dropped ${dropped.join(', ')} from the index (values expire with the cache TTL).`)
+  }
+
+  /** 이 트윈 저널의 끝 리비전 · 최신 구조 리비전 — 스냅샷이 지금의 사실인지 가리는 두 값. */
+  private static async tipOf(domainId: string, instanceId: string): Promise<{ revision: number; structureRev: number | null }> {
+    const [tip, newest] = await Promise.all([
+      getRepository(TwinEvent).findOne({ where: { domain: { id: domainId }, instanceId }, order: { revision: 'DESC' } }),
+      getRepository(TwinStructure).findOne({ where: { domain: { id: domainId }, instanceId }, order: { rev: 'DESC' } })
+    ])
+    return { revision: tip?.revision ?? 0, structureRev: newest?.rev ?? null }
+  }
+
   /** 체크포인트 루프 기동(1회) — 라이브 인스턴스들의 최신 스냅샷을 주기 영속. */
   static startCheckpointLoop(): void {
     if (this.checkpointTimer) return
     this.checkpointTimer = setInterval(() => {
-      for (const [instanceId, inst] of Object.entries(this.instances)) {
+      for (const [key, inst] of Object.entries(this.instances)) {
+        const { instanceId } = parseRuntimeKey(key)
         this.persistSnapshot(inst.domainId, instanceId).catch(err =>
           console.error(`[twin-engine] snapshot checkpoint fail "${instanceId}"`, err?.message ?? err)
         )
@@ -141,33 +354,7 @@ export class TwinEngine {
    */
   static async bootstrap(): Promise<void> {
     try {
-      // 백필(space #3) — spaceId 컬럼 없는 기존 인스턴스를 board.spaceId 로 채움(1회, 마이그레이션 안전).
       const repo = getRepository(TwinInstance)
-      const missing = (await repo.find()).filter(r => !r.spaceId && (r.board as any)?.spaceId)
-      for (const r of missing) {
-        r.spaceId = (r.board as any).spaceId
-        r.areaId = (r.board as any).areaId ?? r.areaId
-        await repo.save(r)
-      }
-      if (missing.length) console.log(`[twin-engine] backfilled spaceId for ${missing.length} instance(s).`)
-
-      // 백필(area 단일화 P3) — deprecated content.areas → TwinArea 이관(폴백 제거 전 완전성 보장, 1회).
-      const spaceRepo = getRepository(TwinSpace)
-      const twinAreaRepo = getRepository(TwinArea)
-      for (const sp of await spaceRepo.find()) {
-        const cAreas = ((sp.content as any)?.areas ?? []) as any[]
-        for (const a of cAreas) {
-          if (!a?.id) continue
-          const ex = await twinAreaRepo.findOne({ where: { domain: { id: sp.domainId } as any, space: { id: sp.id } as any, areaId: a.id } })
-          if (ex) continue
-          await twinAreaRepo.save(twinAreaRepo.create({
-            domain: { id: sp.domainId } as any, space: { id: sp.id } as any, areaId: a.id,
-            name: a.name ?? a.id, type: a.type, parentId: a.parentId ?? null,
-            layout: a.x != null ? { x: a.x, y: a.y, w: a.w, h: a.h } : null
-          }))
-        }
-      }
-
       const rows = await repo.find({ where: { status: 'running' } })
       for (const row of rows) {
         if (!row.domainId || !row.instanceId) continue
@@ -175,16 +362,27 @@ export class TwinEngine {
         // 없으면 저널 fold-from-0 replay(진실 폴백 — replay 는 라이브 파생상태를 못 담으므로 캐시가 더 충실).
         const cached = await this.loadSnapshot(row.domainId, row.instanceId).catch(() => null)
         if (cached?.state) {
-          this.recovered[row.instanceId] = { revision: cached.revision, state: cached.state }
-          console.log(`[twin-engine] warm-started "${row.instanceId}" from snapshot cache → revision ${cached.revision}.`)
+          /* 예전에 겹포장으로 저장된 값이 남아 있을 수 있다 — 읽는 쪽에서도 벗긴다(한 번은 반드시 만난다). */
+          this.recovered[runtimeKey(row.domainId, row.instanceId)] = { revision: cached.revision, state: unwrapState(cached.state) }
+          /*
+           * **「웜스타트했다」고 말하지 않는다** — 여기서는 상태를 **찾아 둔 것**뿐이다.
+           *
+           * 실제 주입은 기동 때 일어나고(`warmStart` 가 그때 무엇을 심었는지 말한다), 미러(live) 트윈은
+           * 그 씨앗을 아예 쓰지 않는다(`startLive` 가 버린다). 그런데 이 줄이 「warm-started」라고 말해
+           * 로그만 읽으면 심긴 줄 알게 된다 — 실제로 그렇게 읽고 재기동 뒤 지속시간이 사라진 것을
+           * 데이터 문제로 오진할 뻔했다.
+           */
+          console.log(`[twin-engine] found cached state for "${row.instanceId}" → revision ${cached.revision} (seeded at start).`)
           continue
         }
         const state = await this.recover(row.domainId, row.instanceId).catch(() => null)
         if (state) {
-          this.recovered[row.instanceId] = { revision: state.revision, state }
+          this.recovered[runtimeKey(row.domainId, row.instanceId)] = { revision: state.revision, state }
           console.log(`[twin-engine] recovered "${row.instanceId}" from journal → revision ${state.revision}.`)
         }
       }
+      /* 상태만 되찾는 것으로는 **도는 트윈이 되지 않는다** — 런타임까지 되살린다(아래). */
+      for (const row of rows) await this.resumeRow(row)
       this.startCheckpointLoop() // 이후 기동되는 라이브 인스턴스의 최신 스냅샷을 주기 영속
     } catch (err) {
       console.error('[twin-engine] recovery scan failed', err)
@@ -192,28 +390,95 @@ export class TwinEngine {
   }
 
   /**
-   * 웜스타트 — 기동하는 커널에 **직전 관측 상태**를 심는다.
+   * 부팅 때 **도는 트윈을 실제로 되살린다** — 「도는 중」이 사실이 되게.
+   *
+   * ── 무엇이 거짓말이었나 (2026-08-14) ────────────────────────────────────────
+   * `bootstrap()` 은 상태만 되찾아 `recovered` 에 담았고, 커널을 세우는 것은 **명시 mutation 뿐**이었다
+   * (이 파일 위쪽 주석이 「향후」라고 적어 둔 그 자리다). 그래서 서버를 한 번 재기동하면 등록부는
+   * `running` 이라 말하는데 **아무 커널도 돌지 않았다** — 화면은 도는 트윈을, 실제로는 멈춘 트윈을.
+   * 미러 트윈에서는 더 나쁘다: 계측이 조용히 끊기고, 사람은 「값이 안 변하네」로 알게 된다.
+   *
+   * ── 모드를 지어내지 않는다 ──────────────────────────────────────────────────
+   * 미러였던 트윈을 시뮬로 되살리면 **없던 움직임을 만들어 낸다**(관측 트윈이 스스로 물건을 옮긴다).
+   * 그래서 선언된 `realityMode` 그대로 되살린다 — 미러는 관측 구동으로, 시뮬은 시뮬로.
+   *
+   * ── 되살릴 수 없으면 그렇게 적는다 ──────────────────────────────────────────
+   * 실패를 삼키면 등록부가 계속 `running` 이라 말한다 — 우리가 고치려던 그 거짓말이다. 그래서 실패한
+   * 행은 `stopped` 로 적고 이유를 남긴다. 「멈췄다」는 사실이고, 「도는 중」은 사실이 아니었다.
+   */
+  private static async resumeRow(row: TwinInstance): Promise<void> {
+    const { domainId, instanceId } = row
+    if (!domainId || !instanceId) return
+    if (this.instances[runtimeKey(domainId, instanceId)]) return // 이미 세워졌다(데모 시드 등)
+
+    /*
+     * 벤치 사본은 되살리지 않는다 — 그것은 **누군가 지켜보던 실험**이고, 무인으로 되살아나면 호스트를
+     * 그대로 두들긴다(격리 사본의 뜻은 「운영과 섞이지 않는다」이지 「영원히 돈다」가 아니다).
+     * 실험은 재기동을 넘기지 못했으므로 등록부도 그렇게 적는다.
+     */
+    if (row.purpose === 'bench') {
+      await this.markStopped(row, 'bench copy — an experiment does not survive a restart unattended')
+      return
+    }
+
+    try {
+      if (row.realityMode === 'mirror') {
+        if (!row.model) throw new Error('no model')
+        /* 시각 기준은 **공간**이 갖는다 — 교대의 HH:MM 을 어느 기준으로 읽나(라이브 기동과 같은 규칙). */
+        this.startLive(instanceId, domainId, row.kind, await this.withSpaceTimeBase(row.model as TwinModelDef, domainId))
+        /* 계측을 나르는 피드는 커넥터의 것이다 — 레퍼런스 계층이 부팅 훅에서 다시 붙인다
+           (`resumeReferenceLiveFeeds`). 여기서 어댑터를 아는 것은 계층을 거꾸로 잇는 것이다. */
+        console.log(`[twin-engine] resumed mirror "${instanceId}" — feed reattach is the reference layer's job.`)
+      } else {
+        await this.startFromRegistry(domainId, instanceId)
+        console.log(`[twin-engine] resumed ${row.realityMode} "${instanceId}".`)
+      }
+    } catch (err: any) {
+      await this.markStopped(row, err?.message ?? 'resume failed')
+    }
+  }
+
+  /** 되살리지 못한 행을 정직하게 적는다 — 「도는 중」이라 말하는 채로 두지 않는다. */
+  private static async markStopped(row: TwinInstance, why: string): Promise<void> {
+    console.warn(`[twin-engine] "${row.instanceId}" not resumed (${why}) — registry says stopped now.`)
+    try {
+      await getRepository(TwinInstance).update({ id: row.id }, { status: 'stopped' })
+    } catch (e: any) {
+      console.error(`[twin-engine] could not mark "${row.instanceId}" stopped — registry now lies about it.`, e?.message)
+    }
+  }
+
+  /**
+   * 웜스타트 — 기동하는 커널에 **직전 관측 상태**를 주입한다.
    *
    * ── 왜 필요한가 ─────────────────────────────────────────────────────────────
-   * `loadBoard` 는 **구조만** 싣는다(노드·무버). 상태(무엇이 어디에 얼마나)는 없다. 그래서 재기동한
+   * `loadTwinModel` 는 **구조만** 싣는다(자리·설비). 상태(무엇이 어디에 얼마나)는 없다. 그래서 재기동한
    * 트윈은 저널에 입고 540건이 남아 있어도 재고가 0 이었고, 화면은 "보유 중인 것이 없습니다" 라고
    * 말했다 — 있는 재고를 없다고 하는 셈이다(2026-07-31 hatiolab-wms 실측으로 확인).
    * `bootstrap()` 이 이미 체크포인트 캐시(없으면 저널 replay)로 상태를 복구해 `recovered` 에 담아 두는데,
    * 기동 순간 그걸 **버리고** 있었다. 반만 연결돼 있던 장치를 잇는다.
    *
-   * ── 정직한 한계 ─────────────────────────────────────────────────────────────
-   *  · **오더는 복원하지 않는다.** `hydrateObserved` 의 오더 인자는 requested/fulfilled/lines 를 요구하는데
-   *    스냅샷의 `OrderState` 에는 `progress` 밖에 없다. progress 에서 역산하면 없는 숫자를 지어내는 것이라
-   *    넘기지 않는다 — 재고·노드·무버만 복원되고 진행 중 오더는 비어서 시작한다.
-   *  · 진행 중 개별 task 의 내부 상태도 관측만으로는 복원되지 않는다(커널이 명시한 한계, 재계획에 맡김).
-   *  · 근본 해법(상태 영속 계약·revision 이어붙임)은 별도 과제.
+   * ── 반쪽이던 복구를 마무리한다 (2026-08-05) ─────────────────────────────────
+   * 재고는 살아났는데 **진행 중 주문이 통째로 사라진** 화면이 남아 있었다. 씨앗이 자리·물품·설비
+   * 셋만 넘겼기 때문이다. 그 근거는 "스냅샷 오더에 progress 밖에 없다" 였고, 그때는 맞았다 —
+   * 그러나 커널 `OrderState` 가 원값(`requested`·`fulfilled`·`lines`)을 되찾은 뒤에도 이 자리만
+   * 그대로 남았다. 오류를 내지 않는 종류라 오래 버텼다.
+   *
+   * 지금은 **관측 스냅샷 전체**를 넘긴다(오더·작업·사람·자산 포함). 시뮬은 커널 `snapshot()`,
+   * 라이브는 `StateProjector` 가 그 일곱 축을 모두 담는다. 무엇을 심을 수 있는지 판정하는 규칙
+   * (이행 완료 오더 제외·고아 작업 제외)은 커널에 있고, 호스트가 미리 골라내지 않는다.
+   *
+   * ── 남은 한계는 숨기지 않고 센다 ────────────────────────────────────────────
+   *  · 원값이 없는 오더(progress 만 있는 것)는 남은 수량을 알 수 없어 주입하지 않는다. **지어내지 않는
+   *    대신 몇 건인지 말한다** — 세지 않으면 "주문이 없다" 와 "주문을 못 심었다" 가 화면에서 같아진다.
+   *  · 진행 중 개별 작업의 내부 상태는 관측만으로 완전히 복원되지 않는다(커널이 명시한 한계, 재계획에 맡김).
    *
    * ── 벤치는 시드하지 않는다 ──────────────────────────────────────────────────
-   * 부하 벤치는 **새 시작에서 용량을 재는 것**이 목적이라 현재 상태를 심으면 측정이 오염된다.
+   * 부하 벤치는 **새 시작에서 용량을 재는 것**이 목적이라 현재 상태를 주입하면 측정이 오염된다.
    */
-  private static warmStart(id: string, kernel: TwinKernel, purpose?: string): void {
+  private static warmStart(domainId: string, id: string, kernel: TwinKernel, purpose?: string): void {
     const hydrate = (kernel as any).hydrateObserved
-    const plan = planWarmStart(this.recovered[id]?.state, purpose, typeof hydrate === 'function')
+    const plan = planWarmStart(this.recovered[runtimeKey(domainId, id)]?.state, purpose, typeof hydrate === 'function')
 
     if (plan.action === 'skip') {
       if (plan.reason === 'bench') {
@@ -227,27 +492,66 @@ export class TwinEngine {
     }
 
     hydrate.call(kernel, plan.seed)
-    console.log(
-      `[twin-engine] warm-started "${id}" — ${plan.itemCount} item(s), ${plan.equipmentCount} equipment restored. ` +
-        'Open orders are not restored (the snapshot carries no requested/fulfilled counts).'
-    )
+    const restored = [
+      `${plan.itemCount} item(s)`,
+      `${plan.equipmentCount} equipment`,
+      `${plan.orderCount} open order(s)`,
+      `${plan.taskCount} task(s)`,
+      ...(plan.personCount ? [`${plan.personCount} person(s)`] : []),
+      ...(plan.assetCount ? [`${plan.assetCount} asset(s)`] : []),
+      /* 확인해 둔 신호를 이어받았다는 사실도 말한다 — 잃으면 확인 처리가 다시 빨개지는 것으로 보인다. */
+      ...(plan.ackedCount ? [`${plan.ackedCount} acknowledged attention(s)`] : []),
+      /* 「언제부터인가」도 말한다 — 잃으면 지속된 조건이 모두 「방금」으로 보인다. */
+      ...(plan.attentionSinceCount ? [`${plan.attentionSinceCount} attention start time(s)`] : [])
+    ].join(', ')
+    console.log(`[twin-engine] warm-started "${id}" — restored ${restored}.`)
+    /* 뺀 것은 조용히 넘기지 않는다 — 지어내지 않았다는 사실 자체를 말해야 화면의 빈칸이 읽힌다. */
+    if (plan.ordersWithoutDemand > 0) {
+      console.warn(
+        `[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.'
+      )
+    }
   }
 
-  /** 트윈 인스턴스 시작 — 커널 생성 + 보드 로드 + 직전 상태 웜스타트 + State 스트림 브리지 + 워커 tick + 레지스트리 영속. */
+  /** 트윈 인스턴스 시작 — 커널 생성 + 모델 로드 + 직전 상태 웜스타트 + State 스트림 브리지 + 워커 tick + 레지스트리 영속. */
   /**
    * 공정 명세를 커널에 싣는다 — **시뮬레이션의 시간을 데이터가 말하게 하는 마지막 한 칸.**
    *
-   * `board.operations`(마스터 인제스트가 통과시킨 ISA-95 OperationsSegment 명세)를 커널이 소비한다.
+   * `model.operations`(마스터 인제스트가 통과시킨 ISA-95 OperationsSegment 명세)를 커널이 소비한다.
    * 없으면 커널 기본 상수로 굴러가고, 커널 `specCoverage()` 가 무엇을 기본값으로 썼는지 보고한다.
    *
    * 커널이 아직 이 API 를 갖지 않은 버전이면(발행 이전) **조용히 넘어가지 않고 경고한다** — 명세를
    * 선언했는데 반영되지 않는 상태를 모르고 지나가면, 예측이 상수로 돌아간 것을 아무도 알 수 없다.
    */
-  private static applyOperations(kernel: any, board: any, id: string): void {
-    const ops = board?.operations
+  private static applyOperations(kernel: any, model: any, id: string): void {
+    /*
+     * 현장이 정한 공정 시간 — 명세 행과 **따로** 싣는다(`declareDurations`).
+     *
+     * 행이 없는 종류에도 시간을 줄 수 있어야 한다: 실측으로 창고·야드 트윈에는 공정 명세 행이 0개였고,
+     * 그 트윈들의 시간은 전부 커널 상수에서 왔다. 행을 지어 만드는 길은 막았다(`label`·`intent` 를
+     * 지어내면 능력 계산까지 오염된다) — 그래서 시간만 받는 창구가 커널에 있다.
+     */
+    const declared = model?.localDurations as Record<string, string> | undefined
+    if (declared && Object.keys(declared).length) {
+      if (typeof kernel?.declareDurations !== 'function') {
+        console.warn(
+          `[twin-engine] "${id}": this facility declared ${Object.keys(declared).length} operation duration(s) but the kernel cannot consume them ` +
+            '(declareDurations missing — kernel needs publishing). The simulation keeps running on built-in constants, and specCoverage() will keep reporting "default".'
+        )
+      } else {
+        try {
+          kernel.declareDurations(declared)
+        } catch (err: any) {
+          /* 커널이 거절한 값은 조용히 넘기지 않는다 — 화면은 「넣었습니다」라고 말한 값이다. */
+          console.warn(`[twin-engine] "${id}": declared operation duration rejected by the kernel — ${err?.message ?? err}`)
+        }
+      }
+    }
+    const ops = model?.operations
     if (!ops?.length) return
     if (typeof kernel?.loadOperations !== 'function') {
-      console.warn(`[twin-engine] "${id}": board declares ${ops.length} operation spec(s) but the kernel cannot consume them (loadOperations missing — kernel needs publishing). Simulation will use built-in default durations.`)
+      console.warn(`[twin-engine] "${id}": model declares ${ops.length} operation spec(s) but the kernel cannot consume them (loadOperations missing — kernel needs publishing). Simulation will use built-in default durations.`)
       return
     }
     kernel.loadOperations(ops)
@@ -258,16 +562,16 @@ export class TwinEngine {
    *
    * 커널 `durationOf` 의 우선순위는 추정기 > 명세 > 상수다. 그 추정기 자리에 두 가지를 사슬로 넣는다:
    *  ① **실측**(저널의 작업 종류별 작업시간 p50) — 그 현장에서 실제로 얼마 걸렸나. 가장 강한 근거.
-   *  ② **거리 × 속도**(board.layout + 설비 속도 속성) — 이동은 거리에 비례한다. 커널은 좌표를 모르므로
+   *  ② **거리 × 속도**(model.layout + 설비 속도 속성) — 이동은 거리에 비례한다. 커널은 좌표를 모르므로
    *     호스트가 계산해 넣는다.
    * 둘 다 못 만들면 주입하지 않는다 — 커널이 명세·상수로 굴러가고 `specCoverage()` 가 그 사실을 남긴다.
    *
    * 실측은 DB 조회라 비동기다. 그래서 이 함수는 **await 하지 않는 쪽에서도 안전**하도록 실패를 삼키되,
    * 무엇을 왜 못 넣었는지는 로그로 남긴다(조용한 무효화 금지).
    */
-  static async installEstimators(kernel: any, domainId: string, instanceId: string, board: any): Promise<void> {
+  static async installEstimators(kernel: any, domainId: string, instanceId: string, model: any): Promise<void> {
     if (!kernel || typeof kernel !== 'object') return
-    const travel = buildTravelEstimator({ layout: board?.layout, equipment: board?.equipment, unit: board?.unit })
+    const travel = buildTravelEstimator({ layout: model?.layout, equipment: model?.equipment, unit: model?.unit })
     const measured = await this.measuredEstimator(domainId, instanceId)
     const chained = chainEstimators([measured?.estimator, travel.estimator])
     if (!chained) {
@@ -294,9 +598,24 @@ export class TwinEngine {
    */
   private static measuredCache = new Map<string, { at: number; value: ReturnType<typeof buildMeasuredEstimator> | undefined }>()
   private static readonly MEASURED_TTL_MS = 60_000
+  /**
+   * 캐시 항목 상한 — **라이프사이클이 놓친 것까지 막는 두 번째 방어.**
+   *
+   * 지움은 `forgetInstance` 가 한다(그것이 첫 번째 방어이고 정확한 쪽이다). 그런데 트윈이 우리 API 를
+   * 지나지 않고 사라지는 길이 있다: 도메인(테넌트)째로 지워지거나 DB 를 직접 손대는 경우다. 그때
+   * 남은 항목을 지울 주인이 없으므로 상한이 필요하다.
+   *
+   * 넘치면 **가장 오래 손대지 않은 것**부터 버린다(Map 의 삽입 순서가 곧 그 순서다 — 값을 쓸 때마다
+   * 다시 넣으므로). 버리는 것이 손해가 아닌 이유: 이 값은 캐시이고, 없으면 다시 계산한다.
+   *
+   * 수를 크게 잡는다 — 트윈 규모는 늘 크고, 항목 하나는 작업 종류별 소요 몇 줄이다. 상한이 작으면
+   * 정상 규모에서 서로 밀어내며 캐시가 무의미해진다(그게 더 나쁘다: 조용히 느려진다).
+   */
+  private static readonly MEASURED_MAX = 5_000
 
   private static async measuredEstimator(domainId: string, instanceId: string) {
-    const key = `${domainId}:${instanceId}`
+    /* 키는 `runtimeKey` 하나로 — 손으로 조립하면 지우는 쪽과 어긋나 못 지우는 항목이 생긴다. */
+    const key = runtimeKey(domainId, instanceId)
     const hit = this.measuredCache.get(key)
     if (hit && Date.now() - hit.at < this.MEASURED_TTL_MS) return hit.value
     let value: ReturnType<typeof buildMeasuredEstimator> | undefined
@@ -307,10 +626,32 @@ export class TwinEngine {
     } catch (err) {
       console.warn(`[twin-engine] "${instanceId}": measured duration lookup failed — falling back to declared/default durations.`, (err as any)?.message)
     }
+    /* 다시 넣어 **최근 쓴 것**으로 만든다 — 삽입 순서가 곧 버릴 순서이므로 이 한 줄이 LRU 를 만든다. */
+    this.measuredCache.delete(key)
     this.measuredCache.set(key, { at: Date.now(), value })
+    if (this.measuredCache.size > this.MEASURED_MAX) {
+      const oldest = this.measuredCache.keys().next()
+      if (!oldest.done) this.measuredCache.delete(oldest.value)
+    }
     return value
   }
 
+  /**
+   * 이 트윈이 **이력에서 시간을 배운 작업 종류들** — 재기동에도 남는 근거.
+   *
+   * ── 왜 필요한가 (2026-08-18 실측) ────────────────────────────────────────
+   * 커널의 자기보고(`specCoverage()`)는 **작업이 새로 생길 때** 채워진다. 그래서 재기동 직후에는 이력이
+   * 풍부한 트윈에서도 목록이 비고, 「이 트윈이 무슨 공정을 돌리나」 화면이 빈칸이 된다 — 값을 채울 곳을
+   * 보여야 하는 화면이 정작 그때 아무 말도 못 한다.
+   *
+   * 그 빈칸을 이력로 메운다: 저널에서 배운 종류는 **추정기가 이미 답할 수 있는 종류**이므로, 지어내는
+   * 것이 아니라 있는 사실을 꺼내는 것이다. 같은 캐시(60초)를 쓰므로 조회마다 저널을 다시 접지 않는다.
+   */
+  static async measuredOperationKinds(domainId: string, instanceId: string): Promise<string[]> {
+    const measured = await this.measuredEstimator(domainId, instanceId)
+    return Object.keys((measured as any)?.learned ?? {})
+  }
+
   /**
    * 지금 이 트윈이 어떤 모델로 굴러가는가 — 예측 출력 보정이 **자기가 배운 모델**에만 적용되도록
    * 비교하는 지문. 재료는 호스트가 아는 것(실측·속도·선언 명세)이라 커널 발행 상태와 무관하다.
@@ -319,23 +660,23 @@ export class TwinEngine {
   static async modelBasis(domainId: string, instanceId: string): Promise<ModelBasis | undefined> {
     try {
       const reg = await getRepository(TwinInstance).findOne({ where: { domain: { id: domainId }, instanceId } })
-      const board: any = reg?.board
+      const model: any = reg?.model
       const measured = await this.measuredEstimator(domainId, instanceId)
-      const travel = buildTravelEstimator({ layout: board?.layout, equipment: board?.equipment, unit: board?.unit })
-      return { measured: measured?.learned, speeds: travel.speedsByKind, declared: board?.operations }
+      const travel = buildTravelEstimator({ layout: model?.layout, equipment: model?.equipment, unit: model?.unit })
+      return { measured: measured?.learned, speeds: travel.speedsByKind, declared: model?.operations }
     } catch {
       return undefined
     }
   }
 
   /**
-   * **이 트윈이 하루 몇 대를 낼 수 있는가** — 굴려 보지 않고 답한다.
+   * **이 트윈이 하루 몇 대를 낼 수 있는가** — 실행해 보지 않고 답한다.
    *
    * 계산은 커널이 자기 상태에서 한다(`kernel.capacity`). 여기서 하는 일은 **기준 주를 정해 주는
    * 것**뿐이다: 공휴일이 없는 평상주여야 한다 — 공휴일은 연간 가용량을 따로 깎지, 이 공장의 평상시
-   * 천장을 정하지 않는다. 커널이 임의로 고르게 두면 그 주에 공휴일이 끼었을 때 천장이 조용히 낮아진다.
+   * 상한을 정하지 않는다. 커널이 임의로 고르게 두면 그 주에 공휴일이 끼었을 때 상한이 조용히 낮아진다.
    *
-   * 트윈이 안 떠 있으면 `undefined` 다 — 0 이 아니다. 안 뜬 트윈의 천장을 0 이라고 답하면 화면은
+   * 트윈이 기동 중이 아니면 `undefined` 다 — 0 이 아니다. 기동하지 않은 트윈의 상한을 0 이라고 답하면 화면은
    * "이 공장은 아무것도 못 만든다" 고 말한다.
    */
   static async capacity(
@@ -344,7 +685,7 @@ export class TwinEngine {
     unitsPerDay: number,
     sampleWeekStartMs: number
   ): Promise<{ instanceId: string; kind?: string; analysis?: any; reason?: 'not-running' | 'no-operations' }[]> {
-    /* 대상은 **등록부**가 정한다 — 떠 있는 런타임만 훑으면 "안 떠 있어서 안 보이는 것" 과 "없는 것" 이
+    /* 대상은 **등록부**가 정한다 — 기동 중인 런타임만 훑으면 "안 떠 있어서 안 보이는 것" 과 "없는 것" 이
        구별되지 않는다. 화면은 그 둘을 다르게 말해야 한다. */
     const where: any = { domain: { id: domainId } }
     if (target.instanceId) where.instanceId = target.instanceId
@@ -352,8 +693,8 @@ export class TwinEngine {
     const registered = await getRepository(TwinInstance).find({ where })
 
     return registered.map(reg => {
-      const rt = this.instances[reg.instanceId]
-      const kernel: any = rt?.domainId === domainId ? rt.kernel : undefined
+      const rt = this.instances[runtimeKey(domainId, reg.instanceId)]
+      const kernel: any = rt?.kernel // 키에 도메인이 있으므로 남의 런타임을 집을 수 없다
       if (typeof kernel?.capacity !== 'function') return { instanceId: reg.instanceId, kind: reg.kind, reason: 'not-running' as const }
 
       const analysis = kernel.capacity({ unitsPerDay, sampleWeekStartMs })
@@ -364,16 +705,81 @@ export class TwinEngine {
     })
   }
 
-  static start(id: string, domainId: string, kind: string, board: BoardDef, realityMode?: RealityMode, purpose?: string, resumeFrom?: number): InstanceRuntime {
-    if (this.instances[id]) return this.instances[id]
+  /**
+   * **생산 능력 보고서** — ISA-95 Part 4 `OperationsCapability`. 구간의 양을 종류로 구분한다
+   * (약정·가용·달성불가). 용량(`capacity`)은 비율을 내고 이것은 **구간의 양**을 낸다.
+   *
+   * 대상 선정·거절 사유는 `capacity` 와 **같은 규율**이다: 등록부가 대상을 정하고(안 기동 중인 것과
+   * 없는 것을 구별한다), 공정을 선언하지 않은 트윈은 판정 대상이 아니라고 말한다(0 으로 채우면
+   * "야드가 병목" 이라는 없는 사실이 생긴다).
+   */
+  static async operationsCapability(
+    domainId: string,
+    target: { instanceId?: string; spaceId?: string },
+    unitsPerDay: number,
+    sampleWeekStartMs: number,
+    window: { fromTime: string; toTime: string }
+  ): Promise<{ instanceId: string; kind?: string; report?: any; reason?: 'not-running' | 'no-operations' }[]> {
+    const where: any = { domain: { id: domainId } }
+    if (target.instanceId) where.instanceId = target.instanceId
+    else where.spaceId = target.spaceId
+    const registered = await getRepository(TwinInstance).find({ where })
+
+    return registered.map(reg => {
+      const rt = this.instances[runtimeKey(domainId, reg.instanceId)]
+      const kernel: any = rt?.kernel
+      if (typeof kernel?.operationsCapability !== 'function') {
+        return { instanceId: reg.instanceId, kind: reg.kind, reason: 'not-running' as const }
+      }
+      const report = kernel.operationsCapability({ unitsPerDay, sampleWeekStartMs, window })
+      if (!report?.perOperation?.length) return { instanceId: reg.instanceId, kind: reg.kind, reason: 'no-operations' as const }
+      return { instanceId: reg.instanceId, kind: reg.kind, report }
+    })
+  }
+
+  /**
+   * 미러 기동의 연속성 씨앗 — 이어받은 것은 **말한다**(조용히 잇지 않는다).
+   *
+   * 커널이 그 문을 열어 두지 않았으면 그 사실도 말한다: 그 트윈은 재기동마다 열린 구간을 잃는다.
+   */
+  private static seedLiveContinuity(domainId: string, id: string, kernel: any): void {
+    const cached = this.recovered[runtimeKey(domainId, id)]?.state
+    if (!cached) return
+    const plan = planLiveContinuity(cached)
+    if (!plan.ackedCount && !plan.attentionSinceCount && !plan.energy) return
+    if (typeof kernel.hydrateContinuity !== 'function') {
+      console.warn(
+        `[twin-engine] kernel for "${id}" cannot carry continuity (no hydrateContinuity) — the open demand window, ` +
+          'its peak and the attention start times are lost on every restart.'
+      )
+      return
+    }
+    try {
+      kernel.hydrateContinuity(plan.seed)
+    } catch (err: any) {
+      /* 이어받기가 실패해도 미러는 돌아야 한다 — 다만 무엇을 잃었는지 말한다. */
+      console.warn(`[twin-engine] continuity seed failed for "${id}" — starting without it: ${err?.message ?? err}`)
+      return
+    }
+    const carried = [
+      ...(plan.energy ? ['energy accumulation (open window, totalizer baselines, peak)'] : []),
+      ...(plan.ackedCount ? [`${plan.ackedCount} acknowledged attention(s)`] : []),
+      ...(plan.attentionSinceCount ? [`${plan.attentionSinceCount} attention start time(s)`] : [])
+    ].join(', ')
+    console.log(`[twin-engine] mirror "${id}" carried over ${carried} — observation axes come from the source.`)
+  }
+
+  static start(id: string, domainId: string, kind: string, model: TwinModelDef, realityMode?: RealityMode, purpose?: string, resumeFrom?: number): InstanceRuntime {
+    const key = runtimeKey(domainId, id)
+    if (this.instances[key]) return this.instances[key]
 
-    const Kernel = KERNELS[kind] ?? WmsKernel
-    const kernel: TwinKernel = new Kernel(domainId, undefined, this.mesSpecOf(board))
-    kernel.loadBoard(board) // 구조만. 상태는 아래 웜스타트가 심는다.
-    this.applyOperations(kernel, board, id) // 시간·수율 명세(있으면) — 없으면 커널 기본값
+    const Kernel = kernelFor(kind)
+    const kernel: TwinKernel = new Kernel(domainId, undefined, this.productionSpecOf(model))
+    kernel.loadTwinModel(model) // 구조만. 상태는 아래 웜스타트가 주입한다.
+    this.applyOperations(kernel, model, id) // 시간·수율 명세(있으면) — 없으면 커널 기본값
     /* 추정기는 DB 조회를 포함해 비동기 — 기동을 막지 않고 붙는다(붙기 전 작업은 명세·상수로 산출). */
-    this.installEstimators(kernel, domainId, id, board).catch(err => console.warn('[twin-engine] estimator install failed', err?.message))
-    this.warmStart(id, kernel, purpose)
+    this.installEstimators(kernel, domainId, id, model).catch(err => console.warn('[twin-engine] estimator install failed', err?.message))
+    this.warmStart(domainId, id, kernel, purpose)
     /*
      * **번호를 이어 센다** — 저널에 이미 있는 번호와 겹치지 않게.
      *
@@ -381,34 +787,69 @@ export class TwinEngine {
      * 리비전이 둘 생기고, 재생 순서가 뒤섞이며, 시간여행이 엉뚱한 시점을 답한다 — 오류는 안 난다.
      */
     if (resumeFrom && typeof (kernel as any).resumeRevision === 'function') (kernel as any).resumeRevision(resumeFrom)
+    /*
+     * ── 이 트윈의 시계를 **지금**에 맞춘다 (2026-08-15) ────────────────────────
+     * 커널의 기본 기준점은 상수(2026-01-01)다. 그대로 두면 시뮬 트윈의 저널 시각이 **재기동마다
+     * 되감겨** 며칠 치 사건이 전부 같은 분에 몰린다 — 「언제 있었던 일인가」를 되짚을 수 없고,
+     * 실 시각으로 창을 자르는 성과·이력 질의에는 그 트윈이 아예 보이지 않는다.
+     *
+     * 재기동하면 그만큼 시계가 앞으로 뛰는데, 그것이 사실이다: 그 사이 이 트윈은 돌지 않았고
+     * 저널의 빈 구간이 그 사실을 말한다.
+     */
+    kernel.setClockOrigin?.(Date.now())
     const runtime: TwinRuntimeType = new TwinRuntime(kernel)
 
     /* subscribe 는 RuntimeSubscription({ unsubscribe() }) 반환 → () => void 로 감쌈. */
-    const inst: InstanceRuntime = { id, domainId, runtime, kernel, realityMode: realityMode ?? DEFAULT_REALITY_MODE, unsub: () => {} }
-    this.instances[id] = inst
-    delete this.recovered[id] // 웜스타트로 커널에 옮겨 심었다 — 이제 라이브가 진실이다.
+    /*
+     * **모드를 적어 둔다** (2026-08-18 실측으로 고침).
+     *
+     * 시뮬 경로는 `mode` 를 비워 두었고(「미지정=sim」이라는 규약에 기대), 라이브만 적었다. 그래서
+     * `modeOf()` 가 **도는 시뮬레이션에 undefined** 를 답했고, 선언·철회의 답이 「저장했다」로 나갔다 —
+     * 실제로는 도는 커널이 옛 수를 그대로 쓰고 재기동 때 받는데, 그 사실이 답에서 사라진 것이다.
+     * 규약에 기대는 대신 사실을 적는다: 「돌고 있나」를 묻는 쪽이 그 답을 받아야 한다.
+     */
+    const inst: InstanceRuntime = { id, domainId, mode: 'sim', runtime, kernel, realityMode: realityMode ?? DEFAULT_REALITY_MODE, spaceId: (model as any)?.spaceId, unsub: () => {} }
+    this.instances[key] = inst
+    /* 다시 세웠으므로 지난 정지 이유는 사실이 아니다 — 남겨 두면 도는 트윈이 「굶겨서 멈췄다」고 말한다. */
+    this.stopNotes.delete(key)
+    delete this.recovered[key] // 웜스타트로 커널에 옮겨 심었다 — 이제 라이브가 진실이다.
 
     /* 라이브 바인딩(P3): data 채널 필터가 subdomain 을 보므로 Domain 객체를 1회 해석해 둔다. */
     getRepository(Domain).findOne({ where: { id: domainId } }).then(d => (inst.domain = d)).catch(() => {})
 
     /* State 채널: runtime.subscribe(snapshot→delta→clock) → pubsub 방송(구독 리졸버가 instanceId 필터). */
     const sub = runtime.subscribe((msg: SubscriptionMessage) => {
-      pubsub.publish('twin-state', {
-        twinState: { instanceId: id, kind: msg.kind, revision: (msg as any).revision, payload: msg }
-      })
+      this.publishGuarded(
+        'twin-state',
+        { twinState: { instanceId: id, kind: msg.kind, revision: (msg as any).revision, payload: msg } },
+        `twin-state:${id}`
+      )
       /* 영속 + 라이브 바인딩 브리지: delta 마다 저널 저장 + 엔티티별 data(tag:) publish → 보드 컴포넌트 라이브. */
       if (msg.kind === 'delta') {
         this.persist(domainId, id, msg).catch(err => console.error('twin persist fail', err))
-        this.publishEntityData(inst)
+        /*
+         * ── 방송은 **모아서** 한 번 (2026-08-14 실측으로 잡음) ────────────────────
+         * 여기서 곧바로 방송하고 있었다. 그런데 커널은 한 번의 tick 에서 사실을 **여러 개** 낸다
+         * (예약·배치·완료…). 그래서 tick 하나가 전 상태 투영을 수백 번 반복했다 — `order-check`
+         * 트윈에서 **틱 하나가 35초**를 먹고(단계 합은 32ms 였다: 시간은 반복 횟수에 있었다) 그
+         * 35초 동안 이벤트 루프가 막혀 구독자가 아무것도 빼내지 못했다. 밀린 push 가 1024를 넘는
+         * 순간 pubsub 이 던지고, 그 예외가 타이머 콜백을 타고 올라와 **호스트가 죽었다.**
+         *
+         * 라이브는 이미 dirty 표시 + 주기 flush 로 이 문제를 풀어 두었다(BROADCAST_COALESCE_MS).
+         * 시뮬만 그 규율 밖에 있었다 — 같은 규율로 들인다(최신-상태 채널이라 중간 상태를 모두
+         * 보낼 이유가 없다: 200ms 마다 마지막 것 하나면 화면은 같다).
+         */
+        inst.dirty = true
+        this.ensureBroadcastCoalescer()
       }
     })
     inst.unsub = () => sub.unsubscribe()
 
-    /* 복구 앵커: 레지스트리에 board/kind/status/realityMode 영속(재부팅 시 이게 있어야 replay·선언 거동 가능). */
-    this.register(domainId, id, kind, board, 'running', inst.realityMode).catch(err => console.error('twin register fail', err))
+    /* 복구 앵커: 레지스트리에 model/kind/status/realityMode 영속(재부팅 시 이게 있어야 replay·선언 거동 가능). */
+    this.register(domainId, id, kind, model, 'running', inst.realityMode).catch(err => console.error('twin register fail', err))
 
     /* 워커 tick — 스켈레톤은 setInterval(메인 루프). 긴 시뮬 오프-루프(worker thread)는 스케일 하드닝(향후, §host 경계). */
-    inst.timer = setInterval(() => runtime.tick(this.TICK_MS), this.TICK_MS)
+    inst.timer = setInterval(() => this.tickGuarded(domainId, id, runtime), this.TICK_MS)
     return inst
   }
 
@@ -425,57 +866,113 @@ export class TwinEngine {
    * 실 이벤트원 = reference 어댑터 openLiveFeed → face2-adapter.ingest → CanonicalEnvelope → ingestLive().
    */
   /**
-   * 보드가 실은 **생산 정의**(레시피·라우트·바인딩)를 꺼낸다 — 커널의 정의-구동 모드 입구.
+   * 모델이 실은 **생산 정의**(레시피·라우트·바인딩)를 꺼낸다 — 커널의 정의-구동 모드 입구.
    *
    * ── 없을 때 무엇이 일어났나 ──────────────────────────────────────────────
    * 커널에는 정의-구동 MES 경로가 있는데 **호스트가 그것을 한 번도 넘기지 않았다.** 그래서 모든 MES
    * 트윈이 **하드코딩된 레거시 흐름**으로 돌았다 — 현장 레시피를 아무리 정성껏 적어도 커널은 그것을
    * 보지 못하고 토이 부품으로 토이 제품을 만들었다. 선언과 실행이 갈라져 있던 자리다.
    *
-   * 보드에 없으면 `undefined` — 레거시 경로 그대로다(기존 트윈의 거동을 바꾸지 않는다).
+   * 모델에 없으면 `undefined` — 레거시 경로 그대로다(기존 트윈의 거동을 바꾸지 않는다).
    */
-  private static mesSpecOf(board: BoardDef | undefined): any {
-    return (board as any)?.mesSpec
+  /**
+   * 생산 선언을 꺼낸다 — 커널 생성자에 넘긴다.
+   *
+   * **옛 이름(`mesSpec`)은 읽지 않는다.** 그것은 계약에 선언조차 없던 필드였고(MES 커널 생성자 인자
+   * 이름이 그대로 굳은 것), 일반 기제에 한 시스템 이름이 붙어 있었기 때문에 창고 트윈이 이 자리를
+   * 쓰지 못했다. 별명으로 남겨 두면 그 혼동이 계속되므로 하나로 통일했다.
+   *
+   * 옛 이름만 가진 모델이 있으면 **조용히 생산 선언을 잃는 대신 분명히 멈춘다** — 그 트윈은 공정이
+   * 없는 채로 돌게 되고(라인이 서 있는 창고), 원인을 찾기 어렵다.
+   */
+  private static productionSpecOf(model: TwinModelDef | undefined): any {
+    const legacy = (model as any)?.mesSpec
+    if (legacy && !(model as any)?.productionSpec) {
+      throw new Error(
+        'the twin model carries the retired `mesSpec` field — rename it to `productionSpec` ' +
+          '(same shape; the name was tied to one kernel while the declaration is ISA-95 operations + BOM)'
+      )
+    }
+    return (model as any)?.productionSpec
   }
 
   /**
-   * 현장(공간)의 **시각 기준**을 보드에 얹는다 — 커널이 교대의 `HH:MM` 을 읽을 기준.
+   * 현장(공간)의 **시각 기준**을 모델에 얹는다 — 커널이 교대의 `HH:MM` 을 읽을 기준.
    *
    * **테넌트가 아니라 공간이 권위다.** 한 테넌트가 Rosarito(태평양)와 한국 공장을 함께 가질 수 있고,
-   * 테넌트 단위(`Domain.timezone`)로 두면 둘 중 하나는 반드시 틀린다. 그래서 인스턴스가 묶인 공간의
+   * 테넌트 단위(`Domain.timezone`)로 두면 둘 중 하나는 반드시 틀린다. 그래서 인스턴스가 연결된 공간의
    * `timezone` 을 읽는다. 공간이 말하지 않으면 **테넌트로 내려가지 않는다** — 잘못된 입자로 답하는 것이
    * 모르는 것보다 나쁘다(그때는 커널이 UTC 로 읽고, 그 기본값은 계약에 밝혀져 있다).
    *
    * 커널은 zero-dep 이라 시간대 데이터베이스를 갖지 않으므로 **분 오프셋**으로 풀어 넘긴다. 그 값은
    * 지금 계절의 것이다(일광절약시간) — 계절을 넘는 긴 예측은 한 시간 어긋난다(계약에 명시).
    */
-  static async withSpaceTimeBase(board: BoardDef, domainId: string, spaceId?: string): Promise<BoardDef> {
-    const sid = spaceId ?? (board as any)?.spaceId
-    if (!sid) return board
+  static async withSpaceTimeBase(model: TwinModelDef, domainId: string, spaceId?: string): Promise<TwinModelDef> {
+    const sid = spaceId ?? (model as any)?.spaceId
+    if (!sid) return model
     const space = await getRepository(TwinSpace).findOne({ where: { domain: { id: domainId }, spaceId: sid } }).catch(() => null)
     const offset = utcOffsetOf(space?.timezone)
     if (offset === undefined) {
       if (space?.timezone) console.warn(`[twin-engine] space "${sid}" declares time zone "${space.timezone}" but it is not a known IANA zone — times will be read as UTC.`)
-      return board
+      return model
     }
-    return { ...board, utcOffsetMinutes: offset }
+    return { ...model, utcOffsetMinutes: offset }
   }
 
-  static startLive(id: string, domainId: string, kind: string, board: BoardDef): InstanceRuntime {
-    if (this.instances[id]) return this.instances[id]
-    const Kernel = KERNELS[kind] ?? WmsKernel
-    const kernel: any = new Kernel(domainId, undefined, this.mesSpecOf(board))
-    kernel.loadBoard(board)
-    this.applyOperations(kernel, board, id) // 명세는 라이브에도 실린다(예측 자격이 sim 과 같아진다)
+  static startLive(id: string, domainId: string, kind: string, model: TwinModelDef): InstanceRuntime {
+    const key = runtimeKey(domainId, id)
+    if (this.instances[key]) return this.instances[key]
+    const Kernel = kernelFor(kind)
+    const kernel: any = new Kernel(domainId, undefined, this.productionSpecOf(model))
+    kernel.loadTwinModel(model)
+    /* **세우는 쪽이 아는 사실은 세울 때 말한다.** 예전에는 첫 이벤트가 도착해야 커널이 스스로를
+       관측 구동으로 여겼고, 그래서 아직 아무것도 못 받은 미러는 시뮬레이션 취급을 받았다. */
+    kernel.observe?.()
+    this.applyOperations(kernel, model, id) // 명세는 라이브에도 실린다(예측 자격이 sim 과 같아진다)
     /* `projector` 필드는 옛 이름으로 남긴다 — 소비처가 `snapshot()` 을 부르므로 얇은 어댑터로 잇는다.
      * (P3 에서 소비처를 커널 어휘로 바꾸면 사라진다.) */
     const projector = { apply: (e: CanonicalEnvelope) => kernel.apply(e), snapshot: () => kernel.getSnapshot() }
-    const inst: InstanceRuntime = { id, domainId, mode: 'live', realityMode: 'mirror', kernel, projector, oee: new OeeAccumulator(), unsub: () => {} }
-    /* 추정기(실측·거리)도 라이브에 붙인다 — 예측이 상수로 돌지 않게. 기동을 막지 않는다. */
-    this.installEstimators(kernel, domainId, id, board).catch(err => console.warn('[twin-engine] estimator install failed', err?.message))
+    const inst: InstanceRuntime = { id, domainId, mode: 'live', realityMode: 'mirror', kernel, projector, oee: new OeeAccumulator(), spaceId: (model as any)?.spaceId, unsub: () => {} }
+    /*
+     * ── 커널이 **판정으로 낸 사실**도 저널에 남는다 (2026-08-14 실측으로 잡음) ────
+     *
+     * 라이브는 인입 봉투만 저널에 적고 있었다(`ingestLive`). 그런데 커널은 관측을 접다가 **자기 사실**을
+     * 낸다 — 에너지의 수요 구간 마감·피크 경신·감축 제안이 그렇다(`emitOp`). 그것을 구독하는 곳이
+     * 없어서 그 사실들이 **커널 안에서 사라졌다**: 표본 48건이 저널에 쌓였는데 구간 마감은 0건이었고,
+     * 저널을 읽는 성과 화면의 전력 타일은 영원히 나오지 않았다.
+     *
+     * sim 은 `runtime.subscribe` 로 같은 일을 한다 — 라이브에만 그 배선이 없었다.
+     *
+     * **인입의 재방출은 걸러낸다**: `apply()` 는 받은 봉투를 구독자에게 그대로 흘린다(호스트가 두 모드에서
+     * 같은 배선을 쓰게 하려고). 그것까지 적으면 인입이 저널에 두 번 들어간다 — 그래서 방금 넣은 것과
+     * **같은 객체**인지 보고 건너뛴다(id 비교는 어댑터가 id 를 어떻게 만드는지에 기대게 되어 약하다).
+     */
+    const applying = new WeakSet<object>()
+    inst.applying = applying
+    inst.unsub = kernel.onEvent?.((e: CanonicalEnvelope) => {
+      if (e && typeof e === 'object' && applying.has(e as object)) return // 인입의 재방출 — 저널은 인입에서 한 번만
+      ;(inst.pendingJournal ?? (inst.pendingJournal = [])).push(e)
+      /* 커널이 낸 사실도 상태를 바꾼다(피크·마감) — 다음 방송 주기에 실린다. */
+      inst.dirty = true
+      this.ensureBroadcastCoalescer()
+    }) ?? (() => {})
+    /* 추정기(실측·거리)도 라이브에 붙인다 — 예측이 상수로 계산되지 않게. 기동을 막지 않는다. */
+    this.installEstimators(kernel, domainId, id, model).catch(err => console.warn('[twin-engine] estimator install failed', err?.message))
     inst.metrics = { ingestedTotal: 0, broadcastTotal: 0, journaledTotal: 0, ingestRate: 0, broadcastRate: 0, journalRate: 0, backlog: 0, _accIngest: 0, _accBroadcast: 0, _accJournal: 0, _windowStartMs: Date.now() }
-    this.instances[id] = inst
-    delete this.recovered[id]
+    this.instances[key] = inst
+    /*
+     * **원천이 되풀어 주지 않는 것만 잇는다** (2026-08-18 실측으로 붙임).
+     *
+     * 미러는 오랫동안 아무것도 이어받지 않았다 — 진실이 원천에 있으니 옳은 판단이었지만, 원천이 **애초에
+     * 다시 말해 주지 않는 축**까지 함께 버렸다: 열린 15분 구간의 누적·적산 기준점·관측 이후 최대, 그리고
+     * 확인해 둔 신호와 조건이 언제부터인지. 그래서 재기동하면 오류 없이 값이 작아졌다(그 구간의 전력량과
+     * 피크가 부팅 이후로만 잡히고, 세 시간째 지속된 경보가 「0초째」가 됐다 — 요금이 걸린 수다).
+     *
+     * 관측 축(재고·위치·설비)은 **여전히 심지 않는다** — 다음 계측이 정정하고, 심으면 떠난 물건이
+     * 되살아난다. 무엇을 넘길지는 `planLiveContinuity` 가 고르고, 어떻게 흡수할지는 커널이 정한다.
+     */
+    this.seedLiveContinuity(domainId, id, kernel)
+    delete this.recovered[key]
     /* 라이브 바인딩(data 채널) subdomain 필터용 Domain 1회 해석(sim 과 동일). */
     getRepository(Domain).findOne({ where: { id: domainId } }).then(d => (inst.domain = d)).catch(() => {})
     /* 저널 revision 카운터 시드 — 기존 저널 최대치에서 이어붙임(재기동 시 revision 충돌 방지). 이후 인메모리 증가. */
@@ -483,7 +980,7 @@ export class TwinEngine {
       .findOne({ where: { domain: { id: domainId }, instanceId: id }, order: { revision: 'DESC' } })
       .then(top => (inst.revision = top?.revision ?? 0))
       .catch(() => (inst.revision = 0))
-    this.register(domainId, id, kind, board, 'running', 'mirror').catch(err => console.error('twin register fail', err))
+    this.register(domainId, id, kind, model, 'running', 'mirror').catch(err => console.error('twin register fail', err))
     return inst
   }
 
@@ -492,10 +989,17 @@ export class TwinEngine {
    * reference 어댑터가 낸 records → 커널 face2-adapter.ingest → CanonicalEnvelope 를 여기로 밀어넣는다.
    * (State 채널 델타/저널 결선은 후속 — 스켈레톤은 data(tag) 미러 중심.)
    */
-  static ingestLive(id: string, envelopes: CanonicalEnvelope[]): void {
-    const inst = this.instances[id]
+  static ingestLive(domainId: string, id: string, envelopes: CanonicalEnvelope[]): void {
+    const inst = this.instances[runtimeKey(domainId, id)]
     if (inst?.mode !== 'live' || !inst.projector) return
-    for (const e of envelopes) { inst.projector.apply(e); inst.oee?.apply(e) } // 관측(projector) + 계산(OEE 누적)
+    const tIngest = performance.now()
+    /* 인입 봉투를 표시해 두고 넣는다 — 커널이 그것을 재방출해도 저널에 두 번 적히지 않게(위 구독 주석). */
+    for (const e of envelopes) {
+      if (e && typeof e === 'object') inst.applying?.add(e as object)
+      inst.projector.apply(e)
+      inst.oee?.apply(e) // 관측(projector) + 계산(OEE 누적)
+    }
+    recordPhase(inst.load ?? (inst.load = newLoadMeter()), 'ingest', performance.now() - tIngest)
     // 저널 결선(라이브도 sim 처럼 이벤트 영속) — 단 이벤트마다 DB write 하면 부하폭발이라 모아뒀다가
     // coalescer tick 에서 배치 기록(방송과 동일 주기). 히스토리 노브·타임라인·비즈니스 원장이 이 저널을 읽는다.
     ;(inst.pendingJournal ?? (inst.pendingJournal = [])).push(...envelopes)
@@ -506,6 +1010,18 @@ export class TwinEngine {
     this.ensureBroadcastCoalescer()
   }
 
+  /**
+   * 구간 성과 방송은 **없앴다**(2026-08-06). 카드가 `twinKpi` 를 직접 묻는다.
+   *
+   * 왜: 카드를 여러 단계(공간·트윈·구역·자리·설비)에 붙이려면 방송으로는 태그가 트윈당 1,200개가 되고,
+   * **모델에 카드를 하나도 안 놓아도** 30초마다 트윈마다 저널을 접었다. 질의로 바꾸니 보고 있는 카드
+   * 수만큼만 들고, 같은 (대상·창·축) 은 클라이언트가 하나로 합친다.
+   *
+   * 덤으로 질의만 할 수 있는 것이 둘 생겼다 — **과거 시각**(`toTime`)과 **공간 단위 합산**(여러 트윈을
+   * 한 번에 접기). 방송 루프는 트윈별이라 둘 다 못 했다.
+   *
+   * 축을 나눠도 폴드 비용이 같다는 실측이 근거다(`test/kpi-query-bench.test.ts`).
+   */
   /** 방송 병합 주기(ms) — 방송률 상한. 인제스트가 아무리 빨라도 이 주기로만 방송. */
   static BROADCAST_COALESCE_MS = 200
   private static broadcastTimer?: any
@@ -517,15 +1033,19 @@ export class TwinEngine {
     if (typeof this.broadcastTimer.unref === 'function') this.broadcastTimer.unref() // 종료 비차단
   }
 
-  /** dirty live 인스턴스 방송 flush(주기 tick 또는 명시 호출). 테스트/즉시 방송용으로 public. */
+  /**
+   * dirty 인스턴스 방송 flush(주기 tick 또는 명시 호출) — **시뮬과 라이브 둘 다.**
+   *
+   * 예전에는 라이브만 봤다(`mode !== 'live'` 면 건너뜀). 시뮬은 delta 마다 곧바로 방송했고, 그것이
+   * 한 tick 에서 수백 번 반복되며 이벤트 루프를 막았다(위 `start()` 주석의 35초 틱). 방송을 모으는
+   * 규율은 모드의 성질이 아니라 **채널의 성질**이다 — 최신-상태 채널이면 중간 상태는 보낼 값이 없다.
+   */
   static flushLiveBroadcasts(): void {
-    let anyLive = false
     const now = Date.now()
     for (const inst of Object.values(this.instances)) {
-      if (inst.mode !== 'live') continue
-      anyLive = true
+      const isLive = inst.mode === 'live'
       // 처리량 계측(④-1) — 창(≥1s)마다 유입/방송/저널률 갱신. dirty 무관(유휴면 0으로 수렴). 부하를 읽는 신호.
-      const m = inst.metrics
+      const m = isLive ? inst.metrics : undefined
       if (m) {
         const dt = (now - m._windowStartMs) / 1000
         if (dt >= 1) {
@@ -540,6 +1060,9 @@ export class TwinEngine {
       // ① 엔티티 data(tag) 방송 — 보드 컴포넌트 라이브 렌더.
       this.publishEntityData(inst)
       if (m) { m.broadcastTotal++; m._accBroadcast++ }
+      /* 시뮬의 저널·state 채널은 자기 콜백이 delta 마다 처리한다(사실은 하나도 빠뜨리지 않는다).
+         여기서 모으는 것은 **엔티티 방송**뿐이다 — 화면이 읽는 최신-상태 채널. */
+      if (!isLive) continue
       // ③ 저널 배치 기록 — 모아둔 이벤트에 revision 부여해 벌크 저장(이벤트마다 write 아님).
       //    revision 카운터는 인메모리(startLive 에서 저널 high-water 로 1회 시드) → tick 마다 DB 질의 없음.
       const batch = inst.pendingJournal
@@ -548,16 +1071,26 @@ export class TwinEngine {
         const start = inst.revision
         inst.revision = start + batch.length
         if (m) { m.journaledTotal += batch.length; m._accJournal += batch.length; m.backlog = batch.length }
-        this.persistBatch(inst.domainId, inst.id, batch, start).catch(err => console.error('twin live journal fail', err))
+        const tJournal = performance.now()
+        this.persistBatch(inst.domainId, inst.id, batch, start)
+          .then(() => recordPhase(inst.load ?? (inst.load = newLoadMeter()), 'journal', performance.now() - tJournal))
+          .catch(err => console.error('twin live journal fail', err))
       }
       // ② State 채널 방송 — "바뀌었다"는 가벼운 신호만(kind+revision). 맵 구독(subscribeTwinState)은 이 신호에
       //    scheduleRefresh(250ms 디바운스)→pollLive 로 되물어봄. 스냅샷(O(state))은 보는 사람이 물을 때만 1회 계산.
       //    (여기서 payload 로 스냅샷을 실으면 아무도 안 읽는데 tick 마다 통째로 떠서 순수 낭비 — 신호만 보낸다.)
-      pubsub.publish('twin-state', {
-        twinState: { instanceId: inst.id, kind: 'delta', revision: inst.revision ?? 0 }
-      })
+      this.publishGuarded(
+        'twin-state',
+        { twinState: { instanceId: inst.id, kind: 'delta', revision: inst.revision ?? 0 } },
+        `twin-state:${inst.id}`
+      )
+    }
+    /* 돌고 있는 인스턴스가 하나도 없으면 tick 을 멈춘다(예전엔 「라이브가 없으면」이었는데, 이제
+       시뮬도 이 flush 에 기대므로 그 조건이면 시뮬 방송이 멈춘 채 남는다). */
+    if (!Object.keys(this.instances).length && this.broadcastTimer) {
+      clearInterval(this.broadcastTimer)
+      this.broadcastTimer = undefined
     }
-    if (!anyLive && this.broadcastTimer) { clearInterval(this.broadcastTimer); this.broadcastTimer = undefined } // live 없으면 tick 정지
   }
 
   /**
@@ -565,17 +1098,27 @@ export class TwinEngine {
    * 두 곳에 각자 적으면 승격 검색 키가 한쪽에만 채워지고, 반쯤 빈 색인은 "저널에는 있는데
    * 검색으로는 안 나오는 이벤트" 를 만든다 — 저널에서 가장 나쁜 종류의 결함이다.
    */
+  /** 저널의 시각 축은 날짜다 — 못 읽는 값은 비운다(0 이나 지금으로 위장하지 않는다). */
+  private static toEventTimeValue(v: any): Date | undefined {
+    if (v instanceof Date) return v
+    const t = typeof v === 'string' ? Date.parse(v) : NaN
+    return Number.isNaN(t) ? undefined : new Date(t)
+  }
+
   private static journalRow(repo: any, domainId: string, instanceId: string, e: any, revision: number, structureRev?: number) {
     return repo.create({
       domain: { id: domainId } as any,
       instanceId,
-      tenantId: e?.tenantId,
       eventType: e?.eventType,
+      /* 커널이 커맨드에서 이어 준 값 — 이것이 감사 기록과 저널을 잇는 다리다. */
+      correlationId: e?.correlationId,
       revision,
       /* **이 사실이 일어난 공장**을 함께 찍는다 — 이것이 없으면 나중에 구조가 바뀌었을 때 이 행을
          새 공장에 대고 접게 되고, 그때 없던 설비에서 일이 있었던 것처럼 보인다. */
       ...(structureRev === undefined ? {} : { structureRev }),
-      eventTime: e?.eventTime,
+      /* 커널은 ISO 문자열을 준다. 컬럼은 날짜다 — **여기서 옮긴다.** 문자열을 그대로 넣으면
+         드라이버가 제 형식으로 정규화하지 않아, 나중에 날짜로 거는 질의에 안 걸린다. */
+      eventTime: this.toEventTimeValue(e?.eventTime),
       ...twinEventKeys(e),
       payload: e
     })
@@ -589,7 +1132,7 @@ export class TwinEngine {
    */
   private static structureRevCache: Record<string, number> = {}
   static async structureRevOf(domainId: string, instanceId: string): Promise<number | undefined> {
-    const key = `${domainId}:${instanceId}`
+    const key = runtimeKey(domainId, instanceId)
     const cached = this.structureRevCache[key]
     if (cached !== undefined) return cached
     const latest = await getRepository(TwinStructure).findOne({ where: { domain: { id: domainId }, instanceId }, order: { rev: 'DESC' } })
@@ -610,9 +1153,16 @@ export class TwinEngine {
     domainId: string,
     instanceId: string,
     kind: string,
-    board: BoardDef,
+    model: TwinModelDef,
     status: 'running' | 'stopped' = 'running',
-    realityMode?: RealityMode
+    realityMode?: RealityMode,
+    origin?: any,
+    /*
+     * 사람이 부르는 이름과 **누가 했나** — 업무키를 나눠 둔 대가로 이름을 함께 실어야 한다.
+     * 사람 없는 경로(부팅 자동 프로비저닝·복구)는 `actor` 를 주지 않는다 — 아무 사용자를 적으면
+     * 감사 기록이 거짓이 된다.
+     */
+    meta?: { name?: string; description?: string; actor?: { id: string } }
   ): Promise<void> {
     const repo = getRepository(TwinInstance)
     const existing = await repo.findOne({ where: { domain: { id: domainId }, instanceId } })
@@ -622,49 +1172,170 @@ export class TwinEngine {
         domain: { id: domainId } as any,
         instanceId,
         kind,
-        board,
-        // 인스턴스↔공간 1급 링크(space #3) — board.spaceId/areaId 를 컬럼으로 승격(dual-write). board JSON 도 유지(커널·복구용).
-        spaceId: (board as any)?.spaceId ?? existing?.spaceId,
-        areaId: (board as any)?.areaId ?? existing?.areaId,
-        // 현실 출처 선언(§0 ①) — 명시값 우선, 없으면 기존값 보존(재프로비전이 선언을 지우지 않게).
-        realityMode: realityMode ?? existing?.realityMode ?? undefined,
+        model,
+        // 인스턴스↔공간 1급 링크(space #3) — model.spaceId/areaId 를 컬럼으로 승격(dual-write). model JSON 도 유지(커널·복구용).
+        spaceId: (model as any)?.spaceId ?? existing?.spaceId,
+        areaId: (model as any)?.areaId ?? existing?.areaId,
+        /* 현실 출처 선언(§0 ①) — 명시값 우선, 없으면 기존값 보존(재프로비전이 선언을 지우지 않게).
+           둘 다 없으면 여기서 **각인한다**. 컬럼을 비워 두면 읽는 자리마다 기본값을 고르게 되고,
+           그러면 같은 트윈이 부르는 곳에 따라 다르게 재기동한다. 선언은 저장소에서 항상 명시적이다. */
+        realityMode: realityMode ?? existing?.realityMode ?? DEFAULT_REALITY_MODE,
+        /* 용도도 각인한다. 벤치로 뒤집는 것은 `setPurpose` 하나뿐이므로 기존값을 반드시 보존한다
+           — 여기서 덮으면 재프로비전이 벤치 사본을 운영 트윈으로 되돌린다. */
+        purpose: existing?.purpose ?? 'operational',
+        /* **다시 읽는 방법**을 각인한다. 명시값 우선, 없으면 기존값 보존 — 원천을 모르는 호출이
+           한 번 지나가면서 이미 알던 것을 지워 버리면, 그 트윈은 다시 읽을 수 없는 트윈이 된다. */
+        origin: origin ?? existing?.origin ?? null,
+        /* 이름은 **덮지 않고 채운다** — 사용자가 고친 이름을 재프로비전이 되돌리면 안 된다. */
+        name: existing?.name ?? meta?.name ?? null,
+        description: existing?.description ?? meta?.description ?? null,
+        /* 만든 사람은 처음 한 번만. 고친 사람은 사람이 한 경우에만 갱신한다. */
+        ...(existing ? {} : meta?.actor ? { creator: { id: meta.actor.id } as any } : {}),
+        ...(meta?.actor ? { updater: { id: meta.actor.id } as any } : {}),
         status
       })
     )
   }
 
   /**
-   * 라이브 구조 변이(resource.add 등)를 저장된 board 에 반영 — 런타임 커널의 무버를 registry board.equipment 에 동기.
-   * 이게 없으면 런타임엔 추가돼도(상태·저널엔 반영) 저장 board 는 원본이라 프로비저닝 편집기·재기동(loadBoard)이
-   * 추가분을 잃는다. 기존 board.equipment 항목은 보존(homeLocation 유지)하고 새 id 만 append(추가 시점 location=homeLocation).
+   * 라이브 구조 변이(resource.add 등)를 저장된 model 에 반영 — 런타임 커널의 무버를 registry model.equipment 에 동기.
+   * 이게 없으면 런타임엔 추가돼도(상태·저널엔 반영) 저장 model 는 원본이라 프로비저닝 편집기·재기동(loadTwinModel)이
+   * 추가분을 잃는다. 기존 model.equipment 항목은 보존(homeLocation 유지)하고 새 id 만 append(추가 시점 location=homeLocation).
    * 좌표(layout)만 다루는 register 와 달리 equipment 집합을 갱신하나, 재프로비전(purge)이 아니라 in-place 갱신이라
    * 저널은 보존된다(추가는 이미 equipment 델타로 저널됨 → replay 는 id-keyed upsert 라 이중계산 없음).
    */
   static async syncBoardEquipment(domainId: string, instanceId: string): Promise<void> {
-    const inst = this.instances[instanceId]
+    const inst = this.instances[runtimeKey(domainId, instanceId)]
     const snap = inst?.kernel?.getSnapshot?.()
     if (!snap?.equipment) return
     const repo = getRepository(TwinInstance)
     const reg = await repo.findOne({ where: { domain: { id: domainId }, instanceId } })
-    if (!reg?.board) return
-    const board = reg.board as BoardDef
-    const known = new Set((board.equipment ?? []).map(m => m.id))
+    if (!reg?.model) return
+    const model = reg.model as TwinModelDef
+    const known = new Set((model.equipment ?? []).map(m => m.id))
     const added = snap.equipment
       .filter((m: any) => !known.has(m.id))
       .map((m: any) => ({ id: m.id, kind: m.kind, homeLocation: m.location }))
     if (!added.length) return
-    board.equipment = [...(board.equipment ?? []), ...added]
-    reg.board = board
+    model.equipment = [...(model.equipment ?? []), ...added]
+    reg.model = model
     await repo.save(reg)
   }
 
   /**
-   * 프로비저닝 — 레지스트리에 구조(board)를 등록만 하고 기동하지 않음(status='stopped').
+   * 프로비저닝 — 레지스트리에 구조(model)를 등록만 하고 기동하지 않음(status='stopped').
    * 재프로비전 시 구조 시그니처가 바뀌면(노드·무버 집합/속성 변경) 기존 저널을 purge 한다(ADR-0015):
-   * board 는 replay 의 마스터라 구조가 바뀌면 과거 이벤트의 전제가 깨진다. 좌표(layout)만 바뀌면 저널 보존.
+   * model 는 replay 의 마스터라 구조가 바뀌면 과거 이벤트의 전제가 깨진다. 좌표(layout)만 바뀌면 저널 보존.
    */
-  static async provision(domainId: string, instanceId: string, kind: string, board: BoardDef, comment?: string): Promise<void> {
-    if (this.instances[instanceId]) throw new Error(`instance "${instanceId}" is running — stop before re-provisioning`)
+  /**
+   * 실행 중이면 구조를 교체하지 않는다 — **판정 문장을 한 곳에 둔다.**
+   *
+   * 인제스트는 전량 교체라, 이벤트를 접고 있는 커널 밑에서 바닥을 바꾸는 셈이 된다. 지금은 거절이
+   * 유일한 답이지만 최종형은 아니다(`adoptStructure` 배선). 두 곳에서 같은 문장으로 거절해야
+   * 나중에 이 규칙을 걷어낼 때 걷어낼 것이 하나로 보인다.
+   */
+  private static assertNotRunning(domainId: string, instanceId: string): void {
+    if (!this.instances[runtimeKey(domainId, instanceId)]) return
+    /*
+     * **거절도 번역돼야 한다.** 이 문장은 던져져서 리졸버의 `catch` 를 지나 화면 토스트에 그대로
+     * 떴다 — 다섯 언어 제품에서 영어 한 줄이 사용자에게 보였다(2026-08-14 실측).
+     *
+     * 그래서 코드와 파라미터를 예외에 실어 보낸다(`ImportSpaceRefusal` 과 같은 규약: 영어 문장은
+     * canonical 이고 로그·폴백으로만 쓰인다). 이유가 코드로 오면 화면이 옮길 수 있다.
+     */
+    const err: any = new Error(`instance "${instanceId}" is running — stop before re-provisioning`)
+    err.code = 'twin-running'
+    err.params = { instanceId }
+    throw err
+  }
+
+  /**
+   * 돌면서 공장을 전환한다 — **미러 전용.**
+   *
+   * 미러가 비추는 현실은 안 멈춘다. 설비 한 대가 늘었다고 트윈을 멈췄다 세우면 그 사이의 사실을
+   * 잃고, 라이브에서 유실은 곧 거짓이다. 그래서 미러는 **동작 중에** 새 구조를 받는다.
+   *
+   * 시뮬레이션은 여기 오지 않는다. 조건이 바뀐 실험은 다른 실험이므로 멈추고 다시 세우는 것이
+   * 옳다 — 커널이 그렇게 거절한다(`FlowEngine.adoptStructure`).
+   *
+   * 세 가지가 **함께** 일어나야 한다. 하나라도 빠지면 층이 어긋난다:
+   *  ① 리비전 — 이 시점 이후의 이벤트가 새 번호를 달고 다닌다(재생이 마디를 나눌 수 있게)
+   *  ② 저장 model·구조 행 — 조회가 새 구조를 본다
+   *  ③ 커널 — 지금 접히는 이벤트가 새 구조 위에서 접힌다
+   */
+  static async adoptStructure(
+    domainId: string,
+    instanceId: string,
+    model: TwinModelDef,
+    comment?: string,
+    origin?: any
+  ): Promise<{ rev: number } & StructureShift> {
+    const inst = this.instances[runtimeKey(domainId, instanceId)]
+    if (!inst) throw new Error(`instance "${instanceId}" is not running — provision it instead of adopting`)
+    if (inst.mode !== 'live')
+      throw new Error(`instance "${instanceId}" is a simulation — stop it and re-provision (a changed experiment is a different experiment)`)
+
+    const reg = await getRepository(TwinInstance).findOne({ where: { domain: { id: domainId }, instanceId } })
+    if (!reg) 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: StructureShift = inst.kernel.adoptStructure(model)
+    /*
+     * **공정 명세·현장이 정한 시간도 함께 싣는다** — 커널의 구조 전환은 자리·설비를 갈지만, 공정 시간은
+     * 호스트가 실어 주는 것이므로(`model.localDurations`) 여기서 다시 부르지 않으면 돌고 있는 미러는
+     * 재기동할 때까지 옛 시간으로 돈다(화면은 「넣었습니다」라고 말한 값이다).
+     */
+    this.applyOperations(inst.kernel, model, instanceId)
+
+    /*
+     * **투영 행도 새 구조를 따른다** (2026-08-18 실측으로 붙임).
+     *
+     * 행(`twin_locations`·`twin_equipment`)은 구조의 캐시다. 그런데 이 경로는 커널만 갈고 행은 그대로
+     * 두었다 — 돌고 있는 미러에 값을 선언하면 커널은 새 값으로 계산하는데 **항목 패널은 옛 행을 보여
+     * 준다**(넣은 값이 화면에서 보이지 않는다). 구조가 바뀐 순간이 곧 캐시를 다시 그릴 순간이다.
+     *
+     * 실패는 흡수한다: 투영이 막혀도(예: 모델에 중복 id) 커널은 이미 새 구조로 돌고 있으므로 그 사실을
+     * 되돌리지 않는다 — 다만 조용히 넘기지 않고 말한다.
+     */
+    await projectStructure(domainId, instanceId, model, instanceId).catch((err: any) =>
+      console.warn(`[twin-engine] "${instanceId}" adopted a new structure but its projected rows were not refreshed — ${err?.message ?? err}`)
+    )
+
+    /*
+     * **구조가 바뀐 순간이 상태가 바뀐 순간이다** — 그러니 방송한다.
+     *
+     * ── 무엇이 났나 (2026-08-18) ────────────────────────────────────────────
+     * 구조 전환은 커널만 갈고 조용히 끝났다. 그런데 화면이 보는 것 상당수가 구조에서 파생된다 —
+     * 계약 대비 판정, 주목 신호, 자리 색. 현장이 계약을 고쳐 선언한 순간 조건이 성립하는데도, 상태
+     * 방송이 없어서 지도 레일은 **다음 계측 표본이 올 때까지** 옛 화면을 들고 있었다(그 사이 헤더
+     * 배지는 4초 폴링으로 먼저 알아, 「배지엔 있고 목록엔 없는」 어긋난 화면이 실제로 보였다).
+     *
+     * 새 방송 경로를 만들지 않는다: dirty 를 세워 **이미 있는 병합 규율**(200ms)에 얹는다. 구조 전환은
+     * 드물지만, 여러 트윈에 잇달아 들어올 수 있고(현장 일괄 선언) 그때도 방송률 상한은 지켜야 한다.
+     */
+    inst.dirty = true
+    this.ensureBroadcastCoalescer()
+
+    return { rev, ...shift }
+  }
+
+  static async provision(
+    domainId: string,
+    instanceId: string,
+    kind: string,
+    model: TwinModelDef,
+    comment?: string,
+    origin?: any,
+    /** 이름·저자 — 업무키를 나눠 둔 대가로 이름을 함께 남긴다(`register` 의 `meta` 그대로). */
+    meta?: { name?: string; description?: string; actor?: { id: string } }
+  ): Promise<void> {
+    this.assertNotRunning(domainId, instanceId)
+    /* 종류를 **저장하기 전에** 검증한다. 나중에 기동할 때 걸리면 원인이 프로비저닝에서 멀어지고,
+       그 사이 레지스트리에는 돌릴 수 없는 트윈이 앉아 있다. */
+    kernelFor(kind)
     const repo = getRepository(TwinInstance)
     const existing = await repo.findOne({ where: { domain: { id: domainId }, instanceId } })
 
@@ -677,10 +1348,10 @@ export class TwinEngine {
      * 하거나** 둘뿐이었고, 그래서 공장을 고칠 때마다 이력을 버려야 했다.
      *
      * 이제 셋째 길로 간다: 바뀐 구조를 **새 리비전**으로 남기고, 앞으로 쓰이는 이벤트가 그 번호를
-     * 달고 다닌다. 재생은 구조가 바뀌는 지점에서 갈아탄 뒤 이어 접는다(`replaySegments`).
+     * 달고 다닌다. 재생은 구조가 바뀌는 지점에서 전환한 뒤 이어 접는다(`replaySegments`).
      */
-    await this.recordStructure(domainId, instanceId, board, comment)
-    await this.register(domainId, instanceId, kind, board, existing?.status === 'running' ? 'stopped' : (existing?.status as any) ?? 'stopped')
+    await this.recordStructure(domainId, instanceId, model, comment)
+    await this.register(domainId, instanceId, kind, model, existing?.status === 'running' ? 'stopped' : (existing?.status as any) ?? 'stopped', undefined, origin, meta)
   }
 
   /**
@@ -689,9 +1360,9 @@ export class TwinEngine {
    * 프로비저닝은 부팅마다 다시 도는데, 그때마다 리비전이 늘면 이력이 뜻 없는 마디로 잘게 쪼개진다.
    * 그래서 **구조 서명이 같으면 있던 리비전을 그대로 쓴다.**
    */
-  static async recordStructure(domainId: string, instanceId: string, board: BoardDef, comment?: string): Promise<number> {
+  static async recordStructure(domainId: string, instanceId: string, model: TwinModelDef, comment?: string): Promise<number> {
     const repo = getRepository(TwinStructure)
-    const signature = this.structureFingerprint(board)
+    const signature = this.structureFingerprint(model)
     const latest = await repo.findOne({ where: { domain: { id: domainId }, instanceId }, order: { rev: 'DESC' } })
 
     /*
@@ -701,24 +1372,24 @@ export class TwinEngine {
      * 것이라 무엇과도 안 맞는다. 그러면 **아무것도 안 바뀐 트윈들이 전부 "구조가 바뀌었다"** 로
      * 기록된다 — 실제로 그렇게 됐고, 재기동 한 번에 리비전이 통째로 하나씩 늘었다.
      *
-     * 그래서 안 맞을 때 한 번 더 묻는다: 저장된 **보드**로 지문을 다시 계산하면 같은가? 같다면
+     * 그래서 안 맞을 때 한 번 더 묻는다: 저장된 **모델**로 지문을 다시 계산하면 같은가? 같다면
      * 공장은 그대로이고 지문 표기만 낡은 것이니, 리비전을 만들지 않고 표기만 고친다.
      */
-    if (latest && latest.signature !== signature && this.structureFingerprint(latest.board as BoardDef) === signature) {
+    if (latest && latest.signature !== signature && this.structureFingerprint(latest.model as TwinModelDef) === signature) {
       latest.signature = signature
       await repo.save(latest)
     }
 
     if (latest?.signature === signature) {
-      this.structureRevCache[`${domainId}:${instanceId}`] = latest.rev
+      this.structureRevCache[runtimeKey(domainId, instanceId)] = latest.rev
       return latest.rev
     }
 
     const rev = (latest?.rev ?? 0) + 1
-    await repo.save(repo.create({ domain: { id: domainId } as any, instanceId, rev, signature, board: board as any, ...(comment ? { comment } : {}) }))
-    this.structureRevCache[`${domainId}:${instanceId}`] = rev
+    await repo.save(repo.create({ domain: { id: domainId } as any, instanceId, rev, signature, model: model as any, ...(comment ? { comment } : {}) }))
+    this.structureRevCache[runtimeKey(domainId, instanceId)] = rev
     /* 구조가 바뀌면 재구성 캐시는 옛 공장의 것이다 — 버린다(지우는 건 캐시뿐, 사실은 남는다). */
-    delete this.recovered[instanceId]
+    delete this.recovered[runtimeKey(domainId, instanceId)]
     if (latest) console.info(`[twin-engine] "${instanceId}" structure changed → revision ${rev} (history kept; older events stay under revision ${latest.rev}).`)
     return rev
   }
@@ -727,7 +1398,7 @@ export class TwinEngine {
    * 이 트윈이 거쳐 온 구조들 — **무엇이 언제 달라졌나.**
    *
    * 리비전은 그 시절 공장을 통째로 담지만(재생에 필요하다), 사람이 보고 싶은 것은 통째가 아니라
-   * 차이다. 보드는 빼고 **차이 요약만** 내보낸다 — 62KB 짜리 보드를 화면에 실어 보낼 이유가 없다.
+   * 차이다. 모델은 빼고 **차이 요약만** 내보낸다 — 62KB 짜리 보드를 화면에 실어 보낼 이유가 없다.
    */
   static async structureHistory(
     domainId: string,
@@ -757,15 +1428,15 @@ export class TwinEngine {
       createdAt: r.createdAt,
       ...(r.comment ? { comment: r.comment } : {}),
       events: (counts.get(r.rev) ?? 0) + (r.rev === oldest ? legacy : 0),
-      diff: diffStructures(i === 0 ? undefined : (revs[i - 1].board as any), r.board as any)
+      diff: diffStructures(i === 0 ? undefined : (revs[i - 1].model as any), r.model as any)
     }))
   }
 
   /** 지금 쓰이는 구조 리비전 — 이벤트에 찍을 번호. 아직 없으면 기록하며 만든다. */
-  static async currentStructureRev(domainId: string, instanceId: string, board?: BoardDef): Promise<number | undefined> {
+  static async currentStructureRev(domainId: string, instanceId: string, model?: TwinModelDef): Promise<number | undefined> {
     const latest = await getRepository(TwinStructure).findOne({ where: { domain: { id: domainId }, instanceId }, order: { rev: 'DESC' } })
     if (latest) return latest.rev
-    return board ? this.recordStructure(domainId, instanceId, board) : undefined
+    return model ? this.recordStructure(domainId, instanceId, model) : undefined
   }
 
   /** 구조 동일성 지문 — 좌표(layout) 등 뷰 관심사는 제외하고 커널이 보는 위상·용량·무버만. */
@@ -776,27 +1447,28 @@ export class TwinEngine {
    * 길이를 강제하지 않아 그냥 들어가지만 **Postgres 는 거기서 터진다** — 개발에서는 멀쩡하고
    * 운영에서만 죽는 종류의 실패다. 비교에만 쓰는 값이므로 해시로 충분하다.
    */
-  private static structureFingerprint(board: BoardDef): string {
-    return createHash('sha256').update(this.structureSignature(board)).digest('hex')
+  private static structureFingerprint(model: TwinModelDef): string {
+    return createHash('sha256').update(this.structureSignature(model)).digest('hex')
   }
 
-  private static structureSignature(board: BoardDef): string {
-    const locations = [...(board.locations ?? [])]
+  private static structureSignature(model: TwinModelDef): string {
+    const locations = [...(model.locations ?? [])]
       .map(n => `${n.id}:${n.type}:${n.capacity}`)
       .sort()
       .join('|')
-    const equipment = [...(board.equipment ?? [])]
+    const equipment = [...(model.equipment ?? [])]
       .map(m => `${m.id}:${m.kind}:${m.homeLocation}`)
       .sort()
       .join('|')
     return `N[${locations}]M[${equipment}]`
   }
 
-  /** 레지스트리 board 로 기동(프로비전된 인스턴스 start). board 인자 없이 저장된 구조로 재기동. */
+  /** 레지스트리 model 로 기동(프로비전된 인스턴스 start). model 인자 없이 저장된 구조로 재기동. */
   static async startFromRegistry(domainId: string, instanceId: string, realityMode?: RealityMode): Promise<InstanceRuntime> {
-    if (this.instances[instanceId]) return this.instances[instanceId]
+    const key = runtimeKey(domainId, instanceId)
+    if (this.instances[key]) return this.instances[key]
     const reg = await getRepository(TwinInstance).findOne({ where: { domain: { id: domainId }, instanceId } })
-    if (!reg?.board) throw new Error(`instance "${instanceId}" not provisioned (no board)`)
+    if (!reg?.model) throw new Error(`instance "${instanceId}" not provisioned (no model)`)
 
     /*
      * 웜스타트 재료를 **여기서 확실히 확보한다.**
@@ -805,13 +1477,13 @@ export class TwinEngine {
      * 어떤 날은 조용히 빈 채로 뜬다 — 재현되지 않는 결함이 가장 나쁘다.
      * 체크포인트 캐시 우선(O(1) + 라이브 파생상태 보존), 없으면 저널 replay 폴백(부팅과 같은 순서).
      */
-    if (!this.recovered[instanceId] && reg.purpose !== 'bench') {
+    if (!this.recovered[key] && reg.purpose !== 'bench') {
       const cached = await this.loadSnapshot(domainId, instanceId).catch(() => null)
       if (cached?.state) {
-        this.recovered[instanceId] = { revision: cached.revision, state: cached.state }
+        this.recovered[key] = { revision: cached.revision, state: cached.state }
       } else {
         const state = await this.recover(domainId, instanceId).catch(() => null)
-        if (state) this.recovered[instanceId] = { revision: state.revision, state }
+        if (state) this.recovered[key] = { revision: state.revision, state }
       }
     }
 
@@ -819,7 +1491,7 @@ export class TwinEngine {
      * 저널에 남아 있는 마지막 번호 — **모드와 무관하게** 이것을 이어 센다.
      *
      * 저널을 초기화하고 기동하는 모드(sim-experiment)라면 이 값이 0이라 아무 영향이 없다. 규칙을
-     * 모드별로 가르지 않는 이유: "저널이 비어 있지 않으면 그 뒤부터" 하나면 어느 모드에서도
+     * 모드별로 구분하지 않는 이유: "저널이 비어 있지 않으면 그 뒤부터" 하나면 어느 모드에서도
      * 겹칠 수 없고, 모드가 늘어도 이 자리를 다시 손볼 일이 없다.
      */
     const last = await getRepository(TwinEvent)
@@ -832,16 +1504,18 @@ export class TwinEngine {
     return this.start(
       instanceId,
       domainId,
-      reg.kind ?? 'wms',
-      reg.board as BoardDef,
-      realityMode ?? (reg.realityMode as RealityMode) ?? undefined,
-      reg.purpose ?? undefined,
+      /* 커널 종류·현실 선언은 레지스트리에 반드시 있다(둘 다 NOT NULL). 예전에는 `?? 'wms'` 로
+         메웠는데, 그건 YMS/MES 트윈을 **조용히 WMS 로 부팅**시키는 길이었다 — 오류 없이 다른 공장이 뜬다. */
+      reg.kind,
+      reg.model as TwinModelDef,
+      realityMode ?? (reg.realityMode as RealityMode),
+      reg.purpose,
       Number(last?.max ?? 0) || 0
     )
   }
 
   /**
-   * 선언 기반 부팅(§0 프레임 ① → 부팅 거동 매핑) — 트윈이 선언한 realityMode 에 따라 재기동 방식을 가른다.
+   * 선언 기반 부팅(§0 프레임 ① → 부팅 거동 매핑) — 트윈이 선언한 realityMode 에 따라 재기동 방식을 구분한다.
    * 부팅 경로를 한 곳에 모아 "런타임 ≠ 현실" 범주오류를 코드로 강제한다.
    *   - 'mirror'         : 현실=외부 실물 → startLive(재동기). 이벤트는 어댑터 ingest 로 유입, 커널 tick 없음.
    *   - 'sim-world'      : 생성 타임라인 지속 → 저널 보존 + resume(현실 이어감).
@@ -853,8 +1527,8 @@ export class TwinEngine {
   static async bootDeclared(domainId: string, instanceId: string, mode: RealityMode = DEFAULT_REALITY_MODE): Promise<InstanceRuntime> {
     if (mode === 'mirror') {
       const reg = await getRepository(TwinInstance).findOne({ where: { domain: { id: domainId }, instanceId } })
-      if (!reg?.board) throw new Error(`instance "${instanceId}" not provisioned (no board)`)
-      return this.startLive(instanceId, domainId, reg.kind ?? 'wms', reg.board as BoardDef)
+      if (!reg?.model) throw new Error(`instance "${instanceId}" not provisioned (no model)`)
+      return this.startLive(instanceId, domainId, reg.kind, reg.model as TwinModelDef)
     }
     if (mode === 'sim-world') {
       /*
@@ -883,61 +1557,134 @@ export class TwinEngine {
    */
   static async resetJournal(domainId: string, instanceId: string): Promise<void> {
     await getRepository(TwinEvent).delete({ domain: { id: domainId } as any, instanceId })
-    delete this.recovered[instanceId]
+    delete this.recovered[runtimeKey(domainId, instanceId)]
   }
 
   /** 삭제 — 정지 + 레지스트리 삭제 + 저널 purge(domain 스코프). */
   static async remove(domainId: string, instanceId: string): Promise<void> {
-    await this.stop(instanceId)
-    delete this.recovered[instanceId]
+    await this.stop(domainId, instanceId)
+    this.forgetInstance(domainId, instanceId)
     await getRepository(TwinEvent).delete({ domain: { id: domainId } as any, instanceId })
     await getRepository(TwinInstance).delete({ domain: { id: domainId } as any, instanceId })
   }
 
+  /**
+   * 이 트윈에 대해 **메모리에 남은 것을 전부 잊는다** — 지움의 한 자리.
+   *
+   * 캐시가 라이프사이클과 어긋나 있었다: 저널·등록부는 지우면서 인스턴스별 캐시는 남겨, 삭제된 트윈의
+   * 항목이 **서버 재기동까지 살아 있었다.** 항목 하나가 하루치 KPI 그룹을 물고 있으므로 잊지 않으면
+   * 지운 트윈이 계속 메모리를 차지한다. TTL 은 값이 낡는 것을 막을 뿐 **없어진 주인을 지우지 않는다.**
+   *
+   * 잊을 것을 여기 모아 두는 이유: 캐시를 새로 만드는 사람이 지우는 자리를 찾아 헤매지 않게 한다.
+   * 새 인스턴스별 캐시를 만들면 **이 함수에 한 줄을 더한다** — 그러지 않으면 같은 누수가 다시 생긴다.
+   */
+  private static forgetInstance(domainId: string, instanceId: string): void {
+    const key = runtimeKey(domainId, instanceId)
+    delete this.recovered[key]
+    this.measuredCache.delete(key)
+    delete this.structureRevCache[key]
+  }
+
   /** 관리 목록 — domain 의 등록 인스턴스 전체(라이브 여부·최신 저널 revision·노드/무버 수 포함). */
   static async list(domainId: string): Promise<any[]> {
     const rows = await getRepository(TwinInstance).find({ where: { domain: { id: domainId } } })
+    /*
+     * **현장 이름을 함께 낸다** — 목록이 `spaceId` 만 내보내서 화면이 이름을 따로 조회하고 있었다.
+     * 그 조회(`twinSpaces`)는 공간마다 카운트 쿼리를 도는 N+1 이라 느리고, 그 사이 화면은 **id 를
+     * 이름처럼** 보여 준다(2026-08-13 관측: 「현장 crew-probe-site」). 한 번에 읽어 map 으로 붙이면
+     * 왕복도 줄고 그 깜빡임도 사라진다. 이름이 없으면 **비운다** — id 를 이름으로 베끼지 않는다.
+     */
+    const spaceNameOf = new Map(
+      (await getRepository(TwinSpace).find({ where: { domain: { id: domainId } } })).map(s => [s.spaceId, s.name])
+    )
+    /*
+     * **최신 리비전은 한 번에 묻는다.**
+     *
+     * 트윈마다 `findOne(order revision DESC)` 을 돌고 있었다 — 13개면 질의 13번이고, 트윈이 늘면
+     * 그대로 자란다. 이 목록은 트윈 관리·현장 구성·엔티티 패널이 모두 읽는 자리다.
+     * 한 번의 그룹 질의로 바꾼다(같은 모양의 선례가 이 파일에 이미 있다: structureRev 집계).
+     */
+    const tipOfInstance = new Map<string, number>()
+    try {
+      const tips = await getRepository(TwinEvent)
+        .createQueryBuilder('e')
+        .select('e.instanceId', 'instanceId')
+        .addSelect('MAX(e.revision)', 'revision')
+        .where('e.domain = :domainId', { domainId })
+        .groupBy('e.instanceId')
+        .getRawMany()
+      for (const t of tips) if (t?.instanceId != null) tipOfInstance.set(String(t.instanceId), Number(t.revision) || 0)
+    } catch (err: any) {
+      /* 집계가 실패하면 **0 으로 메우지 않는다** — 리비전 0 은 "아직 아무 일도 없었다" 는 사실 주장이다.
+         비워 두면 아래에서 `?? 0` 이 아니라 undefined 로 남고, 화면은 그것을 "모름" 으로 그린다. */
+      console.error('[twin-engine] latest revision aggregate failed', err?.message ?? err)
+    }
+
     const out: any[] = []
     for (const r of rows) {
-      const board = (r.board as BoardDef) ?? { locations: [], equipment: [] }
-      const last = await getRepository(TwinEvent).findOne({
-        where: { domain: { id: domainId } as any, instanceId: r.instanceId },
-        order: { revision: 'DESC' }
-      })
+      const model = (r.model as TwinModelDef) ?? { locations: [], equipment: [] }
       out.push({
         instanceId: r.instanceId,
+        /*
+         * **이름을 함께 낸다.** 업무키(`instanceId`)만 내보내고 있어서 목록이 `crew-two` 만 보였다 —
+         * 업무키를 나눠 둔 설계에서는 이름을 같이 실어야 그 나눔이 값을 한다.
+         * 없으면 `undefined` 다(id 를 베끼지 않는다 — 화면이 이름 없음을 알아볼 수 있어야 한다).
+         */
+        name: r.name ?? undefined,
+        description: r.description ?? undefined,
         kind: r.kind,
         status: r.status,
-        spaceId: r.spaceId, // co-location: 같은 spaceId 인스턴스들이 한 공간(공장) 공유 — 공간뷰 집약 키(G7)
-        realityMode: r.realityMode ?? DEFAULT_REALITY_MODE, // 현실 출처 선언(§0 ①) — mirror/sim-world/sim-experiment
-        purpose: r.purpose ?? 'operational', // 운영 vs 벤치 사본(1급 구별 — 이름 접두사 아님)
+        spaceId: r.spaceId, // co-location: 같은 spaceId 인스턴스들이 한 현장 공유 — 현장뷰 집약 키(G7)
+        /* 사람이 읽는 현장 이름 — 없으면 `undefined`(화면이 "이름 없음" 을 알아볼 수 있어야 한다). */
+        spaceName: (r.spaceId ? spaceNameOf.get(r.spaceId) : undefined) || undefined,
+        realityMode: r.realityMode, // 현실 출처 선언(§0 ①) — mirror/sim-world/sim-experiment. 저장 시 각인되므로 비지 않는다.
+        purpose: r.purpose, // 운영 vs 벤치 사본(1급 구별 — 이름 접두사 아님). 저장 시 각인되므로 비지 않는다.
         copyOf: r.copyOf ?? undefined,
-        running: !!this.instances[r.instanceId],
-        revision: last?.revision ?? 0,
-        locationCount: board.locations?.length ?? 0,
-        equipmentCount: board.equipment?.length ?? 0
+        running: !!this.instances[runtimeKey(domainId, r.instanceId)],
+        /*
+         * **계측이 들어오고 있나** — 「도는 중」과 다른 사실이다.
+         *
+         * 미러 트윈은 피드가 떨어져도 커널이 돌기만 하면 「도는 중」이었다. 그래서 아무것도 받지 않는
+         * 트윈과 흐르는 트윈이 화면에서 똑같이 보였다(재기동 뒤 실제로 그랬다). 시뮬·정지 트윈에는
+         * 「해당 없음」이다 — 없어야 하는 것을 끊겼다고 부르지 않는다.
+         */
+        /* 스스로 멈춘 이유 — 있으면 낸다. 재기동 뒤에는 없다(그때는 「모른다」가 사실이다). */
+        stopNote: this.stopNotes.get(runtimeKey(domainId, r.instanceId)) || undefined,
+        liveFeed: liveFeedStateOf({
+          realityMode: r.realityMode,
+          running: !!this.instances[runtimeKey(domainId, r.instanceId)],
+          instanceId: r.instanceId
+        }),
+        revision: tipOfInstance.get(r.instanceId) ?? 0,
+        /*
+         * **리더를 거쳐 센다** — 보드 키를 직접 읽으면 옛 세대 모델이 0 으로 보인다.
+         *
+         * 커널은 자리·설비 배열의 **옛 세대 키까지 흡수해** 읽어 주는데, 이 목록은 새 이름만 직접
+         * 세고 있었다. 그래서 옛 모델 12개가 화면에 **자리 0 · 설비 0**
+         * 으로 떴다 — 오류 없이, 그냥 빈 공장처럼. 세는 규칙이 두 벌이면 이런 식으로 어긋난다.
+         */
+        locationCount: readBoardLocations(model).length,
+        equipmentCount: readBoardEquipment(model).length
       })
     }
     return out
   }
 
-  /** 레거시 벤치 잔재 가드 — purpose 도입 전 만들어진 벤치/부하 공간(이름 규약)까지 걸러낸다. */
-  static isBenchSpace(spaceId?: string): boolean {
-    return !!spaceId && (/^bench-/.test(spaceId) || spaceId === 'rosarito-load' || /^loadtest/.test(spaceId))
-  }
-
-  /** 운영 공간 목록(벤치 소스 선택기) — 이름·규모 포함, 벤치 사본·잔재 제외. */
+  /** 운영 공간 목록(벤치 소스 선택기) — 이름·규모 포함, 벤치 사본 제외. */
   static async listSpaces(domainId: string): Promise<{ spaceId: string; name: string; instances: number; locations: number; equipment: number }[]> {
     const nameOf = new Map((await getRepository(TwinSpace).find({ where: { domain: { id: domainId } } })).map(s => [s.spaceId, s.name]))
     const insts = await getRepository(TwinInstance).find({ where: { domain: { id: domainId } } })
     const agg = new Map<string, { spaceId: string; name: string; instances: number; locations: number; equipment: number }>()
     for (const r of insts) {
-      if (!r.spaceId || r.purpose === 'bench' || this.isBenchSpace(r.spaceId)) continue // 벤치·잔재 제외
-      const board: any = r.board ?? {}
+      /* 벤치 제외는 **선언으로만** 판단한다. 예전에는 spaceId 이름(`bench-`·`loadtest*`)으로도 추측했는데,
+         그러면 그렇게 이름 지은 진짜 운영 공간이 목록에서 조용히 사라진다. purpose 가 정본이다. */
+      if (!r.spaceId || r.purpose === 'bench') continue
+      const model: any = r.model ?? {}
       const a = agg.get(r.spaceId) ?? { spaceId: r.spaceId, name: nameOf.get(r.spaceId) ?? r.spaceId, instances: 0, locations: 0, equipment: 0 }
       a.instances++
-      a.locations += board.locations?.length ?? 0
-      a.equipment += board.equipment?.length ?? 0
+      /* 목록과 **같은 규칙**으로 센다 — 여기만 직접 세면 공간 요약과 인스턴스 목록이 다른 수를 말한다. */
+      a.locations += readBoardLocations(model).length
+      a.equipment += readBoardEquipment(model).length
       agg.set(r.spaceId, a)
     }
     return [...agg.values()]
@@ -949,17 +1696,28 @@ export class TwinEngine {
   }
 
   /**
-   * 공간 구조 판독 — 완전복제(벤치 사본)의 소스. 저장물이 board(위상)·TwinSpace.content(치수·geo·표현)·TwinArea(영역)로
+   * 공간 구조 판독 — 완전복제(벤치 사본)의 소스. 저장물이 model(위상)·TwinSpace.content(치수·geo·표현)·TwinArea(영역)로
    * 분산돼 있으므로 셋을 모아 돌려준다. 호출측이 ReferenceMaster 로 재구성 → 재식별 → ingestMaster.
    */
-  static async spaceStructure(domainId: string, spaceId: string): Promise<{ name?: string; content: any; areas: any[]; instances: { instanceId: string; kind?: string; board: any }[] } | null> {
+  static async spaceStructure(domainId: string, spaceId: string): Promise<{
+    name?: string
+    /** 설계 좌표계 범위(미터)와 지오레퍼런스 — 사본이 원본과 같은 자리에 서려면 함께 가야 한다. */
+    frame: { extentX?: number; extentY?: number; geo?: any; primaryRepresentationId?: string }
+    areas: any[]
+    instances: { instanceId: string; kind?: string; model: any }[]
+  } | null> {
     const sp = await getRepository(TwinSpace).findOne({ where: { domain: { id: domainId }, spaceId } })
     const areas = sp
       ? (await getRepository(TwinArea).find({ where: { domain: { id: domainId } as any, space: { id: sp.id } as any } })).map(a => ({ id: a.areaId, type: a.type, name: a.name, parentId: a.parentId, layout: a.layout }))
       : []
     const insts = await getRepository(TwinInstance).find({ where: { domain: { id: domainId }, spaceId } })
     if (!insts.length) return null
-    return { name: sp?.name, content: sp?.content ?? {}, areas, instances: insts.map(i => ({ instanceId: i.instanceId, kind: i.kind, board: i.board })) }
+    return {
+      name: sp?.name,
+      frame: { extentX: sp?.extentX, extentY: sp?.extentY, geo: sp?.geo, primaryRepresentationId: sp?.primaryRepresentationId },
+      areas,
+      instances: insts.map(i => ({ instanceId: i.instanceId, kind: i.kind, model: i.model }))
+    }
   }
 
   /** 공간(+표현·영역) 삭제 — 벤치 정리 등. 호출측이 바인딩 인스턴스를 먼저 제거하는 전제(가드 없음). deleteTwinSpace 리졸버와 동형. */
@@ -978,44 +1736,121 @@ export class TwinEngine {
    * Face2 마스터 인제스트(ADR-0018) — 레퍼런스 시스템(실 또는 가상)의 마스터를 읽어 트윈을 생성.
    * 엔티티를 손배선/발명하지 않고 마스터에서 반영: 공간(Space) upsert + 인스턴스 provision(미기동).
    * 노드타입은 커널 카탈로그로 검증(warning). start 는 호출측(bootstrap/mutation)이 결정.
+   *
+   * `into.spaceId` — **이 현장에 더한다.** 한 현실을 여러 렌즈(WMS·MES·YMS)가 비추므로 새 트윈이
+   * 기존 공간으로 들어갈 수 있다. 아래 병합은 원래 그 경우를 위해 있었는데(N:1) 만드는 흐름에서
+   * 공간을 고를 방법이 없었다 — 마스터가 파생한 id 만 쓰였다. 판정은 `resolveIngestSpace`(순수).
    */
-  static async ingestMaster(domainId: string, master: ReferenceMaster): Promise<{ instanceId: string; spaceId: string; warnings: string[] }> {
-    const { board, spaceContent, warnings } = masterToTwin(master, DOMAIN_CATALOG)
-    const spaceId: string = board.spaceId
-    const repo = getRepository(TwinSpace)
-    const existing = await repo.findOne({ where: { domain: { id: domainId }, spaceId } })
+  static async ingestMaster(
+    domainId: string,
+    master: ReferenceMaster,
+    into?: { spaceId?: string },
+    /** 누가 인제스트했나 — 사람이 없는 경로(부팅)는 주지 않는다(감사 기록을 지어내지 않는다). */
+    actor?: { id: string }
+  ): Promise<{ instanceId: string; spaceId: string; warnings: IngestWarning[] }> {
     /*
-     * 공유 공간(여러 트윈이 한 spaceId, N:1) content 병합 — 마지막 인제스트가 통째로 덮어써 area(그룹)·표현이
-     * 유실되던 문제 보정. area·landmark 는 id 합집합, representations 는 비어있지 않은 쪽 보존, 나머지는 first-wins.
+     * **거절할 것이면 아무것도 쓰기 전에 거절한다.**
+     *
+     * 가동 중 재프로비저닝은 `provision` 이 막는다. 그런데 그 호출은 이 함수의 **맨 끝**이라,
+     * 그때까지 공간·표현·구역(TwinArea)은 이미 저장된 뒤였다. 사용자에게는 "인제스트 실패" 로
+     * 보이는데 실제로는 절반이 적용된 상태 — 실패라고 말하면서 데이터를 바꾸는 것이 가장 나쁘다.
+     *
+     * 그래서 판정을 앞으로 옮긴다. 아래 `provision` 의 같은 판정은 그대로 둔다 — 이건 편의를 위한
+     * 앞선 거절이고, 저기가 진짜 방벽이다(다른 경로가 생겨도 지켜져야 한다).
+     *
+     * **미러는 여기서 거절하지 않는다.** 미러가 비추는 현실은 안 멈추므로 동작 중에 전환한다
+     * (아래 `adoptStructure`). 거절은 시뮬레이션에만 남는다 — 조건이 바뀐 실험은 다른 실험이다.
      */
-    const prev: any = existing?.content ?? {}
-    const cur: any = spaceContent
-    const unionById = (a: any[] = [], b: any[] = []) => {
-      const m = new Map<string, any>()
-      for (const x of [...a, ...b]) if (x?.id) m.set(x.id, x)
-      return [...m.values()]
+    const running = this.instances[runtimeKey(domainId, master.source)]
+    if (running && running.mode !== 'live') this.assertNotRunning(domainId, master.source)
+
+    const { model, spaceContent, warnings } = masterToTwin(master, DOMAIN_CATALOG)
+    /*
+     * ── 현장 선언을 다시 얹는다 (2026-08-18) ──────────────────────────────────
+     *
+     * 여기가 「원천에서 다시 그리는」 자리다. 요금 단가·계약 정보처럼 **현장이 정한 수**는 원천이 모르므로
+     * 다시 그리면 그대로 사라진다 — 금액이 사라지고, 사용자는 자기가 넣은 값이 어디로 갔는지 알 수 없다.
+     * 그래서 겹으로 보관한 선언을 매번 다시 얹는다(`engine/local-declarations`).
+     *
+     * 대상이 사라졌으면(구조가 바뀌었다) 그 사실을 경고로 낸다 — 갈 곳 없는 선언을 조용히 버리지 않는다.
+     */
+    const prior = await getRepository(TwinInstance).findOne({ where: { domain: { id: domainId }, instanceId: master.source } })
+    /*
+     * 겹이 **둘**이다 — 현장(공간)의 것과 이 트윈의 것. 순서가 규율이다: 현장 먼저, 트윈이 나중.
+     * 요금처럼 현장이 정한 수는 그 현장의 트윈 전부가 같이 읽어야 하고, 한 트윈만 다르게 두는 실험은
+     * 좁은 겹이 이겨야 한다(넓은 값을 고치면 나머지 트윈이 함께 흔들린다).
+     */
+    const priorSpaceId = prior?.spaceId ?? (model as any)?.spaceId
+    const spaceRow = priorSpaceId
+      ? await getRepository(TwinSpace).findOne({ where: { domain: { id: domainId }, spaceId: priorSpaceId } })
+      : null
+    if (prior?.localDeclarations || spaceRow?.localDeclarations) {
+      const layered = applyDeclarationLayers(model as any, spaceRow?.localDeclarations as any, prior?.localDeclarations as any)
+      Object.assign(model as any, layered.model)
+      /*
+       * 겹을 **다시 저장한다** — 여기서 얹은 것은 원천에서 새로 그린 모델이므로, 그때 우리가 덮은 값이
+       * 곧 지금의 원천 값이다(`replaced`). 저장하지 않으면 그 기억이 낡아, 철회가 옛 원천 값으로
+       * 되돌린다 — 원천이 그동안 값을 고쳤어도 알 수 없다.
+       */
+      if (prior) {
+        prior.localDeclarations = layered.instanceLayerApplied as any
+        await getRepository(TwinInstance).save(prior)
+      }
+      if (spaceRow) {
+        spaceRow.localDeclarations = layered.spaceLayerApplied as any
+        await getRepository(TwinSpace).save(spaceRow)
+      }
+      /*
+       * 갈 곳 없는 선언은 경고로 낸다 — 다만 **현장 겹의 것은 뺀다**: 한 현장에는 여러 종류의 트윈이
+       * 살고(창고·야드·에너지), 요금 자리가 없는 트윈에 요금이 얹히지 않는 것은 정상이다.
+       */
+      for (const t of layered.missingTargets.filter(x => x.scope === 'instance')) {
+        warnings.push(unresolvedReference('localDeclaration.target', `${t.target}:${t.id}`))
+      }
     }
-    const mergedContent = {
-      width: prev.width ?? cur.width,
-      depth: prev.depth ?? cur.depth,
-      unit: prev.unit ?? cur.unit,
-      geo: prev.geo ?? cur.geo,
-      primaryId: prev.primaryId ?? cur.primaryId,
-      representations: (cur.representations?.length ? cur.representations : prev.representations) ?? [],
-      // areas 는 content 에 더 이상 쓰지 않는다(area 단일화 P3) — 권위=TwinArea. 아래 TwinArea 로만 기록.
-      landmarks: unionById(prev.landmarks, cur.landmarks)
+    const repo = getRepository(TwinSpace)
+    /* 합칠 공간을 골랐으면 **있는지 먼저 확인한다** — 없는 곳에 조용히 새 공간을 만들면 사용자는
+       합쳤다고 믿고 화면은 따로 논다. 판정 함수가 그 경우 거절한다. */
+    const wanted = (into?.spaceId ?? '').trim()
+    const wantedExists = wanted
+      ? (await repo.count({ where: { domain: { id: domainId }, spaceId: wanted } })) > 0
+      : false
+    const choice = resolveIngestSpace(model.spaceId, wanted, wantedExists)
+    const spaceId: string = choice.spaceId
+    model.spaceId = spaceId // 보드(커널 소비)도 같은 공간을 가리켜야 한다
+    const existing = await repo.findOne({ where: { domain: { id: domainId }, spaceId } })
+    if (choice.joined) {
+      /* 같은 id 의 구역·랜드마크는 합집합으로 접힌다 — 구분할 수 없는 것을 고르지 않고 무엇이
+         합쳐졌는지 말한다(정당한 경우가 많으므로 막지 않는다). */
     }
     /*
-     * **현장의 시각 기준을 공간에 남긴다** — 그러지 않으면 공간이 권위인데 그 값을 영원히 모른다.
+     * 공유 공간(여러 트윈이 한 spaceId, N:1) — **먼저 쓴 값이 이긴다.**
      *
-     * 마스터가 보드에 오프셋을 실어 주므로 갓 프로비저닝한 트윈은 맞게 돌지만, `withSpaceTimeBase` 가
-     * 읽는 곳은 **공간**이다. 여기서 옮기지 않으면 공간의 시간대가 계속 비어 있고, 사용자가 화면에서
-     * 그것을 보거나 고칠 수도 없다(만들고 잇지 않으면 없는 것이다).
-     *
-     * **사용자가 고친 값을 마스터가 덮지 않는다** — 이미 있으면 그대로 둔다(현장이 정본을 이긴다).
+     * 마지막 인제스트가 통째로 덮어써 표현·구역이 유실되던 문제 보정. 설계 좌표계 범위와
+     * 지오레퍼런스는 공간의 성질이라 트윈마다 다를 수 없다 — 두 번째 트윈이 들어오면서 바꾸면
+     * 먼저 놓인 구역들이 통째로 어긋난다. 그래서 이미 있으면 그대로 둔다.
      */
+    const cur: any = spaceContent
     const timezone = existing?.timezone || master.space.timezone
-    const savedSpace = await repo.save(repo.create({ ...(existing ?? {}), domain: { id: domainId } as any, spaceId, name: existing?.name || master.siteName, ...(timezone ? { timezone } : {}), content: mergedContent }))
+    const savedSpace = await repo.save(
+      repo.create({
+        ...(existing ?? {}),
+        domain: { id: domainId } as any,
+        spaceId,
+        name: existing?.name || master.siteName,
+        ...(timezone ? { timezone } : {}),
+        extentX: existing?.extentX ?? cur.width,
+        extentY: existing?.extentY ?? cur.depth,
+        geo: existing?.geo ?? cur.geo,
+        /*
+         * 대표 표현 포인터는 **표현을 저장한 뒤** 실제 행 id 로 채운다(아래). 여기서 마스터의 논리
+         * id(`r-map` 따위)를 넣으면 표현 행은 생성 uuid 를 받으므로 포인터가 **처음부터 허공을
+         * 가리킨다** — 실제로 13개 현장이 그 상태였고 정합성 점검이 잡았다(2026-08-13). 화면은
+         * 행의 `isPrimary` 로 ★를 그려서 증상이 보이지 않았다(사실이 두 벌이면 이렇게 조용하다).
+         */
+        primaryRepresentationId: existing?.primaryRepresentationId ?? null
+      })
+    )
     /*
      * 표현을 twin_space_representations 테이블에 저장한다 — 뷰(twin-map-page 등)는 content 가 아니라 테이블 표현을 소싱하므로,
      * 저장하지 않으면 인제스트 사이트에 "대표 표현" 이 없어 지도로 시작하지 못한다. rep.areas 가 있으면 TwinSpaceArea 도 함께 저장.
@@ -1037,6 +1872,17 @@ export class TwinEngine {
           await areaRepo.save(areaRepo.create({ domain: { id: domainId } as any, representation: { id: savedRep.id } as any, name: area.name, type: area.type, geometry: area.geometry, drillTo: area.drillTo ?? null, binding: area.binding ?? null, style: area.style ?? null }))
         }
       }
+      /*
+       * 대표를 **저장된 행 id** 로 가리킨다 — 마스터의 논리 id 는 저장 키가 아니다. 고른 순서:
+       * ① 마스터가 primary 로 표시한 표현 ② 없으면 첫 표현 ③ 표현이 없으면 비운다(지어내지 않는다).
+       */
+      const saved = await repRepo.find({ where: { domain: { id: domainId } as any, space: { id: savedSpace.id } as any }, order: { seq: 'ASC' } })
+      const primary = saved.find(r => r.isPrimary) ?? saved[0]
+      if (primary && savedSpace.primaryRepresentationId !== primary.id) {
+        await repo.save(repo.create({ ...savedSpace, primaryRepresentationId: primary.id }))
+        /* 하나만 대표다 — 행 플래그도 그 하나로 맞춘다(둘이 켜져 있으면 화면이 ★를 두 번 그린다). */
+        for (const r of saved) if (!!r.isPrimary !== (r.id === primary.id)) await repRepo.save(repRepo.create({ ...r, isPrimary: r.id === primary.id }))
+      }
     }
     /*
      * area 단일화(space #2, P1) — 논리 구역을 TwinArea(정규·표현무관·공유)에 dual-write(upsert by areaId).
@@ -1061,12 +1907,51 @@ export class TwinEngine {
       )
     }
 
-    await this.provision(domainId, master.source, master.system, board)
-    if (warnings.length) console.warn(`[twin-engine] ingest "${master.source}" warnings:`, warnings)
+    if (running) {
+      /* 실행 중인 미러 — 멈추지 않고 전환한다. 무엇이 사라졌는지는 **경고로 말한다**
+         (멈췄다 세우는 마디가 없으므로, 말하지 않으면 자리 하나가 조용히 없어진다). */
+      const shift = await this.adoptStructure(domainId, master.source, model, undefined, master.origin)
+      warnings.push(structureAdopted(shift.rev, shift))
+    } else {
+      /* 사이트 이름이 곧 트윈의 이름이다 — 마스터가 이미 말했으므로 지어내지 않고 그대로 싣는다. */
+      await this.provision(domainId, master.source, master.system, model, undefined, master.origin, {
+        name: master.siteName,
+        description: (master as any).description,
+        actor
+      })
+    }
+
+    /*
+     * 구조 투영 — model(커널 입력 문서)를 **표준 엔티티 행**으로 푼다(ADR-0032).
+     *
+     * 인제스트가 유일한 쓰기 경로다. 여기서 실패해도 인제스트 자체는 성공으로 둔다 —
+     * 행은 **원본에서 언제든 다시 그릴 수 있는 캐시**이고, 트윈 자체는 model 로 이미 동작한다.
+     * 다만 **조용히 넘기지 않는다**: 못 이은 참조는 인제스트 경고로 올라간다.
+     */
+    try {
+      const projected = await projectStructure(domainId, master.source, model, master.source)
+      for (const ref of projected.unresolvedHome) warnings.push(unresolvedReference('equipment.homeLocation', ref))
+      for (const ref of projected.unresolvedArea) warnings.push(unresolvedReference('location.area', ref))
+      /*
+       * 발전 형상은 **시각**을 읽는다 — 시간대를 모르면 UTC 로 읽히고, 현장 정오가 아닌 시각에 피크가 선다.
+       * 시간대를 지어내지 않고 그 조합을 말한다(공간에 선언하면 사라진다).
+       */
+      if ((model as any)?.utcOffsetMinutes === undefined) {
+        for (const e of ((model as any)?.equipment ?? []) as any[]) {
+          const hasProfile = ((e?.properties ?? []) as any[]).some(p => String(p?.id) === EMS_PROPERTY.genDailyProfile && String(p?.value ?? '').trim())
+          if (hasProfile) warnings.push(generationWithoutTimeZone(String((model as any)?.spaceId ?? ''), String(e.id)))
+        }
+      }
+    } catch (err: any) {
+      console.error(`[twin-engine] structure projection failed for "${master.source}":`, err?.message)
+      warnings.push(projectionFailed(err?.message ?? 'unknown'))
+    }
+
+    if (warnings.length) console.warn(`[twin-engine] ingest "${master.source}" warnings: ${describeWarnings(warnings)}`)
     return { instanceId: master.source, spaceId, warnings }
   }
 
-  /** 단건 상세 — 프로비저닝 에디터가 편집할 board(구조+layout) 포함. */
+  /** 단건 상세 — 프로비저닝 에디터가 편집할 model(구조+layout) 포함. */
   static async detail(domainId: string, instanceId: string): Promise<any | null> {
     const r = await getRepository(TwinInstance).findOne({ where: { domain: { id: domainId }, instanceId } })
     if (!r) return null
@@ -1074,9 +1959,9 @@ export class TwinEngine {
       instanceId: r.instanceId,
       kind: r.kind,
       status: r.status,
-      running: !!this.instances[r.instanceId],
+      running: !!this.instances[runtimeKey(domainId, r.instanceId)],
       realityMode: r.realityMode, // 현실 선언 — what-if 적용 가드용(mirror=예측 전용, 자극 주입 불가)
-      board: r.board
+      model: r.model
     }
   }
 
@@ -1085,16 +1970,53 @@ export class TwinEngine {
    * 보드 컴포넌트가 tag 로 구독(board-ui provider)해 `component.data` 로 라이브 갱신. delta 시에만(희소).
    * tag=엔티티 id(데모=단일 인스턴스). 멀티 인스턴스/보드 재사용 시 tag 네임스페이스는 후속.
    */
+  /** 방송 실패 로그 조절 — 창마다 한 줄(막힌 구독자는 초당 수십 번 실패한다). */
+  private static publishDrops = new Map<string, { count: number; lastLogMs: number }>()
+  private static readonly PUBLISH_DROP_LOG_MS = 10_000
+
+  /**
+   * 한 번의 방송 — **구독자 하나가 호스트를 죽이지 못하게.**
+   *
+   * ── 무엇이 죽였나 (2026-08-14) ─────────────────────────────────────────────
+   * 밀린 push 가 1024를 넘으면 pubsub 이 던진다(`RepeaterOverflowError`). 그 방송은 타이머 콜백
+   * 안에서 일어나므로 예외가 잡히는 곳 없이 올라가 **프로세스가 끝났다** — 트윈 14개가 도는 호스트가
+   * 소비를 멈춘 구독자 하나 때문에 통째로.
+   *
+   * 못 보낸 것은 **사실로 남긴다**(횟수를 세고 창마다 한 줄 남긴다). 삼키면 「보냈는데 화면이 낡았다」가
+   * 되고, 그건 가장 찾기 어려운 부류다.
+   */
+  private static publishGuarded(channel: 'data' | 'twin-state', payload: any, what: string): boolean {
+    try {
+      pubsub.publish(channel as any, payload)
+      return true
+    } catch (err: any) {
+      const d = this.publishDrops.get(what) ?? { count: 0, lastLogMs: 0 }
+      d.count++
+      const now = Date.now()
+      if (now - d.lastLogMs >= this.PUBLISH_DROP_LOG_MS) {
+        d.lastLogMs = now
+        console.warn(`[twin-engine] broadcast dropped on "${what}" (${d.count} so far) — ${err?.message ?? err}`)
+      }
+      this.publishDrops.set(what, d)
+      return false
+    }
+  }
+
   static publishEntityData(inst: InstanceRuntime): void {
     const domain = inst.domain
     if (!domain) return
     /* 상태 출처 스왑 — sim: 커널 runtime, live: projector 미러(+OEE 계산 층 보강). 계약·payload 동일, 드라이버만 다름. */
+    const load = inst.load ?? (inst.load = newLoadMeter())
+
+    /* ① 상태 투영 — 상태 크기에 비례한다(대규모에서 가장 무거운 축). */
+    const tSnap = performance.now()
     const st: any =
       inst.mode === 'live'
         ? inst.oee
           ? withLiveOee(inst.projector?.snapshot?.(), inst.oee) // 관측 커널 + 계산(OEE) → equipment payload 에 oee 포함(sim 동형)
           : inst.projector?.snapshot?.()
         : inst.runtime?.resync?.()?.state
+    recordPhase(load, 'snapshot', performance.now() - tSnap)
     if (!st) return
     /*
      * 변화한 엔티티만 발행 — 이전엔 delta 마다 전 엔티티(노드+무버+오더)를 값 변화와 무관하게 전량 재발행해
@@ -1105,13 +2027,24 @@ export class TwinEngine {
     const seen = new Set<string>()
     /* payload 매핑은 순수 함수(buildEntityDeltas)로 분리 — 여기선 시그니처 dedup + 발행만.
      * 변화한 엔티티만 발행(최신-상태 채널이라 무변화 재방송 무의미). */
-    for (const { tag, data } of buildEntityDeltas(st)) {
+    /* ② payload 만들기 — 엔티티 수에 비례. ③ 시그니처 비교 + 발행 — 바뀐 것 수에 비례. */
+    const tDelta = performance.now()
+    const deltas = buildEntityDeltas(st, inst.id)
+    recordPhase(load, 'deltas', performance.now() - tDelta)
+
+    const tPub = performance.now()
+    for (const { tag, data } of deltas) {
       seen.add(tag)
       const sig = JSON.stringify(data)
       if (sigs.get(tag) === sig) continue // 무변화 → 발행 생략
       sigs.set(tag, sig)
-      pubsub.publish('data', { data: { domain, tag, data } })
+      /*
+       * **못 보냈으면 보낸 것으로 적지 않는다.** 시그니처를 남겨 두면 다음 주기에 「무변화」로 건너뛰고,
+       * 그 태그는 영원히 낡은 값을 보여 준다(오류 없이). 되돌려 두면 다음 주기가 다시 시도한다.
+       */
+      if (!this.publishGuarded('data', { data: { domain, tag, data } }, `data:${inst.id}`)) sigs.delete(tag)
     }
+    recordPhase(load, 'publish', performance.now() - tPub)
     /* 사라진 엔티티의 시그니처 정리(맵 무한 성장 방지). */
     if (sigs.size > seen.size) for (const tag of sigs.keys()) if (!seen.has(tag)) sigs.delete(tag)
   }
@@ -1123,7 +2056,7 @@ export class TwinEngine {
 
   /**
    * 재부팅 복구 / 시간여행 — DB 저널을 replay 해 상태 재구성.
-   * board 는 레지스트리(TwinInstance)에서, 이벤트는 TwinEvent(revision ASC)에서.
+   * model 는 레지스트리(TwinInstance)에서, 이벤트는 TwinEvent(revision ASC)에서.
    * 커서 두 축(runtime-state-model §4): **시각(untilTime, 사용자 모국어·공간 공통축)** 우선, 없으면 리비전(untilRevision, 렌즈 내부).
    *   - untilTime 주면 `eventTime ≤ T` 인 이벤트만(그 시점 watermark) — 공동배치 여러 트윈을 하나의 시각 T로 통일 해소.
    *   - 둘 다 없으면 최신(라이브 인메모리 진실).
@@ -1133,27 +2066,106 @@ export class TwinEngine {
     // 라이브 최신(시간여행 아님) + 인메모리 인스턴스 → 라이브 커널 스냅샷을 직접 사용.
     // replay(StateProjector)는 attentions·ack 등 라이브 전용 파생 상태를 담지 못하므로, 최신은 커널 진실을 쓴다.
     if (untilRevision == null && untilTime == null) {
-      const live = this.instances[instanceId]
+      const live = this.instances[runtimeKey(domainId, instanceId)]
       if (live?.kernel?.getSnapshot) return live.kernel.getSnapshot()
       // live 모드는 kernel 이 없고 projector 미러 → 인메모리 최신 스냅샷(projector+OEE+attentions) 직접 사용.
       // (저널이 있어도 최신은 인메모리가 진실 — replay 는 시간여행/복구 전용.)
-      if (live?.mode === 'live' && live.projector) return this.snapshot(instanceId)
+      if (live?.mode === 'live' && live.projector) 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 = unwrapState(cachedForResume.state)
+      if (state && (cachedForResume.revision ?? 0) === tip!.revision && (cachedForResume.structureRev ?? null) === tip!.structureRev)
+        return state
+    }
+
     const reg = await getRepository(TwinInstance).findOne({ where: { domain: { id: domainId }, instanceId } })
-    if (!reg?.board) throw new Error(`twin instance "${instanceId}" not registered (no board to replay)`)
+    if (!reg?.model) throw new Error(`twin instance "${instanceId}" not registered (no model to replay)`)
+
+    /*
+     * ── 재개점에서 **이어 접는다** (2026-08-18) ────────────────────────────
+     *
+     * 우리는 이미 접은 결과를 남기고 있다(`saveFoldedSnapshot`). 그 지점의 **재개점**(리듀서 내부 상태
+     * 전부 + 가동 누적기)이 함께 있으면, 그 뒤에 일어난 것만 접어도 같은 답이 나온다 — 그 동치는
+     * 커널 시험이 증명한다(0부터 접기 == 재개점 + 꼬리).
+     *
+     * 쓰는 조건을 좁게 잡는다: **지금을 물었을 때만**(시간여행은 목표 이전 재개점이 필요한데 지금은
+     * 최신 하나만 남긴다 — 사슬은 다음 단계다), 구조가 그대로일 때만(구조가 바뀌면 그 경계에서 갈라
+     * 접어야 한다), 재개점이 저널 끝보다 앞설 때만. 하나라도 어긋나면 0부터 접는다 — **캐시가 사실을
+     * 이기지 않는다.**
+     */
+    /*
+     * 씨앗은 둘 중 하나다: **지금**을 물으면 최신 재개점, **과거**를 물으면 사슬에서 목표 직전 지점.
+     *
+     * 과거 씨앗은 구조가 한 번도 바뀌지 않은 트윈에서만 쓴다 — 구조가 갈린 저널은 마디마다 갈아 접어야
+     * 하고, 마디를 건너뛴 씨앗은 그 경계의 판정을 잃는다(그때는 0부터 접는 것이 옳다).
+     */
+    const structureCount = asOfNowRead
+      ? 0
+      : await getRepository(TwinStructure).count({ where: { domain: { id: domainId }, instanceId } }).catch(() => 99)
+    const pastSeed =
+      !asOfNowRead && structureCount <= 1
+        ? await this.chainSeedFor(domainId, instanceId, {
+            ...(untilRevision != null ? { revision: untilRevision } : {}),
+            ...(untilTime != null && !Number.isNaN(Date.parse(untilTime)) ? { timeMs: Date.parse(untilTime) } : {})
+          }).catch(() => null)
+        : null
+    const resume =
+      asOfNowRead && tip && cachedForResume && cachedForResume.fold && (cachedForResume.structureRev ?? null) === tip.structureRev
+        ? cachedForResume
+        : pastSeed
 
+    /*
+     * **자를 것을 알면서 다 읽어 오지 않는다** (2026-08-18 실측).
+     *
+     * 저널을 전량 읽어 온 뒤 JS 에서 걸렀다. 27만 건짜리 트윈(order-check)에서 한 시간 전 상태를 물으면
+     * **7.4초**가 걸렸고, 그 대부분이 「필요 없는 행을 읽어 오는 시간」이었다. 시각·리비전 상한은 SQL 이
+     * 아는 조건이므로 거기서 자른다(TypeORM 관용구만 — 원시 SQL 은 5개 드라이버에서 갈라진다).
+     *
+     * 시각 상한에는 **경계를 그대로** 쓴다(`<=`): 그 시각에 일어난 사실은 그 시각의 화면에 있어야 한다.
+     * 시각이 없는 레거시 행은 보수적으로 포함해 왔는데, SQL 로 자르면 그 행들이 빠진다 — 그래서 시각
+     * 조건일 때는 **시각이 비어 있는 행도 함께** 가져와 예전과 같은 결과를 낸다.
+     */
+    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
     const rows = await getRepository(TwinEvent).find({
-      where: { domain: { id: domainId }, instanceId },
+      where: useTime
+        ? from
+          ? /* 씨앗 뒤 · 목표 이내 — 시각이 빈 옛 행은 씨앗 뒤에 있는 것만 포함한다(보수적 포함을 유지). */
+            [
+              { ...baseWhere, revision: MoreThan(from), eventTime: LessThanOrEqual(new Date(cutoffMs)) },
+              { ...baseWhere, revision: MoreThan(from), eventTime: IsNull() }
+            ]
+          : [
+              { ...baseWhere, eventTime: LessThanOrEqual(new Date(cutoffMs)) },
+              { ...baseWhere, eventTime: IsNull() }
+            ]
+        : untilRevision != null
+          ? from
+            ? { ...baseWhere, revision: And(MoreThan(from), LessThanOrEqual(untilRevision)) }
+            : { ...baseWhere, revision: LessThanOrEqual(untilRevision) }
+          : from
+            ? { ...baseWhere, revision: MoreThan(from) }
+            : baseWhere,
       order: { revision: 'ASC' }
     })
-    const cutoffMs = untilTime != null ? Date.parse(untilTime) : NaN
-    const wanted = rows.filter(r => {
-      if (untilTime != null && !Number.isNaN(cutoffMs)) {
-        const t = r.eventTime != null ? Date.parse(String(r.eventTime)) : NaN
-        return Number.isNaN(t) ? true : t <= cutoffMs // eventTime 없는 레거시 행은 포함(보수적)
-      }
-      return untilRevision == null || (r.revision ?? 0) <= untilRevision
-    })
+    const wanted = rows
 
     /*
      * **그때의 공장으로 접는다.**
@@ -1169,19 +2181,19 @@ export class TwinEngine {
       where: { domain: { id: domainId }, instanceId },
       order: { rev: 'ASC' }
     })
-    const boardOf = new Map<number, BoardDef>(structures.map(x => [x.rev, x.board as BoardDef]))
+    const boardOf = new Map<number, TwinModelDef>(structures.map(x => [x.rev, x.model as TwinModelDef]))
     /* 컬럼이 생기기 전 행은 리비전이 비어 있다 — **가장 오래된 구조**에 속한다(0 으로 채우지 않는다). */
     const oldest = structures[0]?.rev
     const revOf = (r: { structureRev?: number }): number | undefined => r.structureRev ?? oldest
 
-    const segments: { board: BoardDef; events: any[] }[] = []
+    const segments: { model: TwinModelDef; events: any[] }[] = []
     for (const r of wanted) {
       if (!r.payload) continue
       const rev = revOf(r)
-      const board = (rev !== undefined && boardOf.get(rev)) || (reg.board as BoardDef)
+      const model = (rev !== undefined && boardOf.get(rev)) || (reg.model as TwinModelDef)
       const last = segments[segments.length - 1]
-      if (last && last.board === board) last.events.push(r.payload)
-      else segments.push({ board, events: [r.payload] })
+      if (last && last.model === model) last.events.push(r.payload)
+      else segments.push({ model, events: [r.payload] })
     }
     /*
      * **가장 새 구조가 지금의 공장이다** — 그 아래에서 아직 아무 일도 없었더라도.
@@ -1194,18 +2206,119 @@ export class TwinEngine {
      * 설비가 화면에 서고 — 이 작업이 막으려던 바로 그 거짓말이 된다.
      */
     const asOfNow = untilRevision == null && untilTime == null
-    const newest = structures[structures.length - 1]?.board as BoardDef | undefined
-    if (asOfNow && newest && segments[segments.length - 1]?.board !== newest) segments.push({ board: newest, events: [] })
+    const newest = structures[structures.length - 1]?.model as TwinModelDef | undefined
+    if (asOfNow && newest && segments[segments.length - 1]?.model !== newest) segments.push({ model: newest, events: [] })
 
-    if (!segments.length) return replay(((asOfNow && newest) || reg.board) as BoardDef, [])
-    if (segments.length === 1) return replay(segments[0].board, segments[0].events)
+    /*
+     * 접은 상태에 **주의 신호와 시각을 채운다.**
+     *
+     * 라이브·시뮬은 커널이 신호를 스스로 내지만, 저널을 접는 이 경로는 프로젝터 상태만 낸다 — 신호도
+     * `nowTime` 도 없다. 그래서 **과거를 다시 계산하면 주의 레일이 텅 비었고**(지도는 `snap.attentions` 를
+     * 읽는다), 기동돼 있지 않은 트윈을 보는 화면도 같았다. 신호는 상태에서 계산되는 것이므로
+     * 여기서 같은 공식(`deriveAttentions`)으로 채우면 된다 — 두 벌을 두지 않는다.
+     *
+     * `nowTime` 이 먼저다: "늦었나" 판정이 그 값을 본다. 다시 계산한 시점의 정직한 "지금" 은 물어본 시각
+     * (`untilTime`)이고, 없으면 마지막으로 적용한 이벤트의 시각이다. 둘 다 없으면 채우지 않는다 —
+     * 벽시계를 끼워 넣으면 과거 화면이 "지금 기준으로 늦었다" 고 말하게 된다.
+     */
+    const lastEventTime = rows.length ? (rows[rows.length - 1]?.eventTime?.toISOString() ?? '') : ''
+
+    /*
+     * **가동 이력도 되살린다** — 다시 계산한 화면에 설비 계측이 비어 있던 것.
+     *
+     * OEE 는 원 시스템이 누적을 보내 주지 않아 호스트가 상태 전이를 적분해 만든다(그래서 커널이 아니라
+     * 여기 있다). 그런데 그 누적기는 **라이브에서만** 돌았고, 저널을 접는 경로는 그 계산을 하지 않았다 —
+     * 과거를 다시 계산하면 모든 설비가 "가동 이력이 전혀 없음" 으로 보였다.
+     *
+     * 없는 것은 데이터가 아니라 계산이다: 입력(`equipment.status` 전이·`quality.output`)은 저널에 다
+     * 있다. 그래서 **같은 누적기에 같은 이벤트를 태운다** — 규칙을 두 벌 만들지 않는다.
+     *
+     * 시간여행에서도 맞다: 여기 태우는 것은 이미 잘라 낸(`wanted`) 이벤트뿐이므로, 그 시점까지의
+     * 가동 이력이 나온다(그 뒤에 일어난 고장이 과거 화면에 섞이지 않는다).
+     */
+    const oee = new OeeAccumulator()
+    /* 재개점이 있으면 그 위에 꼬리만 얹는다 — 없으면 꼬리분만 세어 가용률이 조용히 작아진다. */
+    if (resume?.fold?.oee) oee.restore(resume.fold.oee)
+    for (const r of wanted) {
+      try {
+        oee.apply(r.payload as any)
+      } catch {
+        /* 한 건이 이상해도 나머지 계측을 버리지 않는다 — 누적기는 모르는 이벤트를 무시하는 계약이다. */
+      }
+    }
+
+    const withNow = (st: any): any => {
+      if (!st || typeof st !== 'object') return st
+      const nowTime = st.nowTime || untilTime || lastEventTime || undefined
+      const based = nowTime ? { ...st, nowTime } : st
+      /* 계측 시점은 그 화면의 "지금" 이다 — 벽시계로 재면 과거 화면의 가용률이 시간이 갈수록 떨어진다. */
+      const nowMs = nowTime ? Date.parse(String(nowTime)) : Number.NaN
+      const withMetrics = withLiveOee(based, oee, Number.isFinite(nowMs) ? nowMs : undefined)
+      return withLiveAttentions(withMetrics)
+    }
+
+    /* 접은 결과를 남긴다 — **지금을 물었을 때만**(시간여행 결과를 "지금" 으로 저장하면 거짓이 된다). */
+    /*
+     * 접은 지점의 리비전 — 사슬에 적을 이름이다. 꼬리를 접었으면 그 꼬리의 끝, 아무것도 안 읽었으면
+     * 씨앗의 자리 그대로다(모르면 0).
+     */
+    const foldedTo = rows.length ? (rows[rows.length - 1]?.revision ?? 0) : (from ?? 0)
 
+    const keep = (st: any, fold?: { reducer: ReducerCheckpoint; oee: OeeCheckpoint }): any => {
+      /* 재개점을 함께 남긴다 — 상태만 남기면 다음 번에 또 0부터 접어야 한다(그것이 이 작업의 요점이다).
+         **구조가 갈린 폴드에는 재개점을 붙이지 않는다**: 마디를 건너뛴 씨앗은 그 경계의 판정을 잃는다. */
+      if (asOfNowRead && tip && st) {
+        void this.saveFoldedSnapshot(domainId, instanceId, { revision: tip.revision, state: st, structureRev: tip.structureRev, fold })
+      }
+      /*
+       * 사슬에는 **과거를 접었을 때도** 한 지점을 남긴다 (2026-08-18 실측으로 고침).
+       *
+       * 처음에는 「지금 읽기」에서만 남겼다. 그런데 도는 트윈의 지금 읽기는 커널 스냅샷으로 즉시 답하고
+       * 폴드에 닿지 않는다 — 그래서 사슬이 **영원히 비어 있었다**(실측: 지점 0개, 시간여행 3.7s 그대로).
+       *
+       * 지점은 「지금」을 주장하지 않는다: 자기 리비전과 시각을 달고 있으므로 과거 폴드의 결과를 남겨도
+       * 거짓이 아니다(그것이 스냅샷과 다른 점이다). 그래서 첫 과거 조회가 다음 과거 조회를 빠르게 한다.
+       */
+      if (fold && st) {
+        const at = asOfNowRead && tip ? tip.revision : foldedTo
+        if (at > 0)
+          void this.keepChainPoint(domainId, instanceId, {
+            revision: at,
+            ...(lastEventTime ? { eventTime: lastEventTime } : {}),
+            structureRev: (asOfNowRead && tip ? tip.structureRev : null) ?? null,
+            fold
+          }).catch(() => {})
+      }
+      return st
+    }
+
+    /*
+     * 씨앗이 있으면 **이어 접는다** — 한 구조 안에서만(구조가 갈리면 아래 마디 경로가 맡는다).
+     * 새 재개점도 함께 남긴다: 다음 번에 또 꼬리만 접을 수 있어야 이 지름길이 계속 산다.
+     */
+    if (resume?.fold?.reducer && segments.length <= 1) {
+      const model = (segments[0]?.model ?? (asOfNow && newest) ?? reg.model) as TwinModelDef
+      const out = replayFrom(model, resume.fold.reducer, segments[0]?.events ?? [])
+      return keep(withNow(out.state), { reducer: out.checkpoint, oee: oee.serialize() })
+    }
+
+    if (!segments.length) {
+      const model = ((asOfNow && newest) || reg.model) as TwinModelDef
+      const out = replayWithCheckpoint(model, [])
+      return keep(withNow(out.state), { reducer: out.checkpoint, oee: oee.serialize() })
+    }
+    if (segments.length === 1) {
+      const out = replayWithCheckpoint(segments[0].model, segments[0].events)
+      return keep(withNow(out.state), { reducer: out.checkpoint, oee: oee.serialize() })
+    }
+
+    /* 커널 계약도 `model` 이다(0.6.14) — 경계에서 어휘를 되돌려 담던 브릿지가 사라졌다. */
     const { state, shifts } = replaySegments(segments)
     /* 경계에서 사라진 것을 조용히 넘기지 않는다 — 수가 줄어든 이유를 어딘가에는 남겨야 한다. */
     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.`)
-    return state
+    return keep(withNow(state))
   }
 
   /**
@@ -1237,12 +2350,21 @@ export class TwinEngine {
     this.stopHooks.push(fn)
   }
 
-  static async stop(id: string): Promise<void> {
-    const i = this.instances[id]
+  static async stop(domainId: string, id: string): Promise<void> {
+    const i = this.instances[runtimeKey(domainId, id)]
     if (i) {
+      /*
+       * **끄기 전에 남긴다** — 지금이 메모리가 진실인 마지막 순간이다.
+       *
+       * 남기지 않으면 다음 조회가 저널을 전량 다시 접는다(그 값은 어차피 방금 메모리에 있던 것이다).
+       * 체크포인트 루프가 20초마다 뜨지만 그 사이에 멈추면 그 구간이 통째로 다시 접힌다.
+       */
+      await this.persistSnapshot(domainId, id).catch(err =>
+        console.error(`[twin-engine] snapshot on stop fail "${id}"`, err?.message ?? err)
+      )
       clearInterval(i.timer)
       i.unsub()
-      delete this.instances[id]
+      delete this.instances[runtimeKey(domainId, id)]
       await getRepository(TwinInstance)
         .update({ domain: { id: i.domainId }, instanceId: id }, { status: 'stopped' })
         .catch(err => console.error('twin deregister fail', err))
@@ -1250,8 +2372,177 @@ export class TwinEngine {
     for (const hook of this.stopHooks) { try { hook(id) } catch { /* 훅 격리 */ } }
   }
 
-  static runtime(id: string): TwinRuntimeType | undefined {
-    return this.instances[id]?.runtime
+  /*
+   * tick 한 번 — **한 트윈의 예외가 서버를 내리지 못하게** 감싼다.
+   *
+   * 잘못된 시나리오가 실렸을 때 다음 tick 에서 `rate.meanPerHour` 를 읽다 터졌고, 타이머 콜백의
+   * 예외는 아무도 받지 않아 **uncaught exception 으로 프로세스가 내려갔다.** 한 테넌트의 잘못된
+   * 선언이 모든 테넌트를 멈춘 셈이다. 문 앞에서 막는 것이 1차 방벽이고(`validateScenario`),
+   * 이것이 2차 방벽이다.
+   *
+   * **조용히 삼키지 않는다.** 실행을 멈추고 그 사실을 남긴다 — 예외를 무시하고 계속 tick 하면
+   * 같은 오류가 매 주기 쏟아지고, 그 트윈은 "도는 것처럼 보이면서" 아무것도 진행하지 않는다.
+   */
+  /**
+   * 같은 현장 트윈들의 **설비 상태**를 커널에 넘긴다 — 커널이 요청할 때만.
+   *
+   * ── 경계 (2026-08-14) ──────────────────────────────────────────────────────
+   * 호스트가 아는 것은 **누가 같은 현장에 있는가** 하나다. 무엇을 읽고 그것을 어떻게 부하로 바꿀지는
+   * 커널이 정한다(계수는 트윈의 모델이 선언한다). 호스트가 kW 를 계산해 주면 트윈마다 다른 규칙이
+   * 생기고, 그 규칙은 어디에도 적혀 있지 않게 된다.
+   *
+   * 상태만 넘긴다. 스냅샷을 통째로 넘기면 상태 크기에 비례한 비용을 매 tick 치르게 된다 —
+   * 설비 목록은 그 트윈의 커널이 이미 들고 있는 것이라 훑는 값이 싸다.
+   */
+  private static feedPeerEquipment(inst: InstanceRuntime): void {
+    const kernel: any = inst.kernel
+    if (typeof kernel?.observePeerEquipment !== 'function') return // 이웃을 읽지 않는 커널
+    if (!inst.spaceId) {
+      kernel.observePeerEquipment([]) // 현장이 없으면 이웃도 없다(옛 상태가 남지 않게 비운다)
+      return
+    }
+    const peers: { id: string; status?: string }[] = []
+    for (const other of Object.values(this.instances)) {
+      if (other === inst || other.domainId !== inst.domainId || other.spaceId !== inst.spaceId) continue
+      const eq: Map<string, any> | undefined = (other.kernel as any)?.equipment
+      if (!eq || typeof eq.forEach !== 'function') continue
+      eq.forEach(e => peers.push({ id: String(e?.id ?? ''), status: String(e?.status ?? '') }))
+    }
+    kernel.observePeerEquipment(peers)
+  }
+
+  private static tickGuarded(domainId: string, id: string, runtime: TwinRuntimeType): void {
+    const inst = this.instances[runtimeKey(domainId, id)]
+    const load = inst && (inst.load ?? (inst.load = newLoadMeter()))
+    const t0 = performance.now()
+    try {
+      /* 이웃의 설비 상태를 먼저 싣는다 — 커널이 이번 tick 에서 부하를 만들 때 읽는다. */
+      if (inst) this.feedPeerEquipment(inst)
+      runtime.tick(this.TICK_MS)
+
+      /* 재고 말한다 — 시뮬 틱은 메인 이벤트 루프에서 수행된다. 예산(간격의 절반)을 넘기면 HTTP·구독이
+         함께 느려지는데, 예전에는 그것을 볼 계기판이 없어 "터지면 알고 느려지면 몰랐다". */
+      if (load) {
+        const took = performance.now() - t0
+        recordPhase(load, 'tick', took)
+        const j = judgeCycle(load, took, this.TICK_MS, Date.now())
+        if (j.warn) console.warn(slowTickMessage(id, took, j.budgetMs, load))
+        this.guardStarvation(domainId, id, took)
+      }
+    } catch (err: any) {
+      /*
+       * 멈추는 길은 **하나**다(`stop`) — 예전에는 타이머만 껐다. 그러면 등록부는 계속 `running` 이라
+       * 말하고(아무 틱도 없는 채로), 부팅 재개는 그 거짓을 근거로 다시 세운다. 스냅샷 보존·피드 정리·
+       * 등록부 갱신이 모두 `stop` 안에 있다.
+       */
+      this.stopWithNote(
+        domainId,
+        id,
+        { code: 'tick-failed', params: { reason: String(err?.message ?? err) } },
+        `[twin-engine] "${id}" tick failed — this twin is stopped (other twins keep running). ` +
+          `Fix the declaration and start it again. Reason: ${err?.message ?? err}`
+      )
+    }
+  }
+
+  /**
+   * 호스트를 굶기는 트윈을 멈춘다 — **도는 척하는 것보다 멈춘 것이 낫다.**
+   *
+   * 굶김 문턱을 넘는 틱이 연속 `STARVE_STREAK` 번이면 그 트윈은 구조적으로 무겁다(우연이 아니다).
+   * 문턱 아래로 한 번만 내려와도 연속을 끊는다 — 무거운 순간 하나로 트윈을 내리지 않는다.
+   */
+  private static guardStarvation(domainId: string, id: string, tookMs: number): void {
+    const key = runtimeKey(domainId, id)
+    const starveMs = this.TICK_MS * this.STARVE_FACTOR
+    if (!(tookMs >= starveMs)) {
+      this.starveStreak.delete(key)
+      return
+    }
+    const streak = (this.starveStreak.get(key) ?? 0) + 1
+    this.starveStreak.set(key, streak)
+    if (streak < this.STARVE_STREAK) return
+
+    this.starveStreak.delete(key)
+    const secs = Math.round(tookMs) / 1000
+    this.stopWithNote(
+      domainId,
+      id,
+      { code: 'starved', params: { streak, thresholdSec: starveMs / 1000, lastSec: secs } },
+      `[twin-engine] "${id}" stopped — ${streak} consecutive ticks over ${starveMs / 1000}s (last ${secs}s). ` +
+        `A simulation tick runs on the main loop, so this twin was stalling HTTP, subscriptions and every other twin. ` +
+        `Its state is checkpointed; start it again after making it lighter (fewer orders/resources) or wait for off-loop ticking.`
+    )
+  }
+
+  /** 멈추고 **이유를 남긴다** — 이유 없는 「정지」는 사람이 자기가 멈춘 것으로 읽는다. */
+  private static stopWithNote(domainId: string, id: string, note: StopNote, log: string): void {
+    console.error(log)
+    this.stopNotes.set(runtimeKey(domainId, id), note)
+    this.stop(domainId, id).catch(err => console.error(`[twin-engine] stop after guard failed "${id}"`, err?.message ?? err))
+  }
+
+  /** 이 트윈이 스스로 멈춘 이유(있으면) — 화면이 옮겨 말한다. */
+  static stopNoteOf(domainId: string, id: string): StopNote | undefined {
+    return this.stopNotes.get(runtimeKey(domainId, id))
+  }
+
+  /**
+   * 이 트윈이 **지금 실행 중인가** — 판정의 집 하나.
+   *
+   * "스냅샷이 있나" 로는 답이 되지 않는다: 웜스타트가 되살린 상태가 캐시에 남아 있으면 멈춘 트윈도
+   * 스냅샷을 낸다. 그것을 관측 중으로 읽으면 화면이 **멈춘 트윈의 작업을 0 건이라고 단언**한다
+   * (실제로 그렇게 나왔다 — 관측이 없는 것과 0 건은 다르다는 이 프로젝트의 규율을 화면이 어겼다).
+   *
+   * 목록이 쓰는 것과 **같은 술어**다(`list()` 의 `running`) — 두 벌이면 어긋난다.
+   */
+  static isRunning(domainId: string, id: string): boolean {
+    return !!this.instances[runtimeKey(domainId, id)]
+  }
+
+  static runtime(domainId: string, id: string): TwinRuntimeType | undefined {
+    return this.instances[runtimeKey(domainId, id)]?.runtime
+  }
+
+  /*
+   * 커맨드 실행 — **판정은 `routeCommand`(순수)가 하고 여기서는 실행만** 한다.
+   * 판정을 코드 한가운데 두면 이 부류를 테스트로 못 잡는다(엔진은 DB 를 물고 있어 단위 테스트가
+   * 불러올 수 없다). 예전에는 리졸버가 `inst.runtime.dispatch` 를 곧바로 불러 미러에서 터졌다.
+   */
+  static async dispatchCommand(domainId: string, instanceId: string, command: any): Promise<{ accepted: boolean; error?: string; errorCode?: string; errorParams?: Record<string, string | number> }> {
+    const inst = this.instances[runtimeKey(domainId, instanceId)]
+    const type = String(command?.type ?? '')
+    const route = routeCommand(
+      inst && { mode: inst.mode, hasRuntime: !!inst.runtime, hasKernelDispatch: typeof (inst.kernel as any)?.dispatch === 'function' },
+      !!inst && inst.domainId === domainId,
+      type
+    )
+    if (route.target === 'reject') {
+      return { accepted: false, errorCode: route.errorCode, errorParams: route.errorParams, error: route.errorCode }
+    }
+
+    const cmd = { ...command, tenantId: domainId } // tenantId 는 호출자 도메인으로 각인(감사·무결성)
+    if (route.target === 'runtime') return inst!.runtime!.dispatch(cmd)
+
+    /*
+     * 미러 — 관측 커널로 보내고, **커맨드가 낸 사실을 저널 큐에 실어** 코얼레서가 번호를 부여하게 한다.
+     * 미러에는 State 구독 배관이 없어(시뮬은 그 경로로 저널링) 커널 방출이 아무 데도 닿지 않는다.
+     * 여기서 DB 를 따로 읽어 번호를 매기면 인메모리 카운터와 어긋나 리비전이 겹친다(겹침은 오류를
+     * 내지 않고 재생 순서만 조용히 뒤섞는다).
+     */
+    const kernel: any = inst!.kernel
+    const emitted: any[] = []
+    const off = kernel.onEvent?.((e: any) => emitted.push(e))
+    let ack: any
+    try {
+      ack = kernel.dispatch(cmd)
+    } finally {
+      off?.()
+    }
+    if (ack?.accepted && emitted.length) {
+      inst!.pendingJournal = [...(inst!.pendingJournal ?? []), ...emitted]
+      inst!.dirty = true // 코얼레서가 이번 주기에 비우고 방송까지 하게 한다
+    }
+    return ack ?? { accepted: false, errorCode: 'unknown-command', error: 'unknown-command' }
   }
 
   /**
@@ -1260,17 +2551,27 @@ export class TwinEngine {
    * this.instances[id] 를 만지기 전에 반드시 이걸로 확인해야 한다. 인스턴스 id 는 추측 가능하므로
    * 검증 없이 접근하면 크로스테넌트 읽기/정지가 가능해진다.
    */
+  /**
+   * 이 런타임의 **관측 모드** — `'live'`(외부 실물을 미러) 또는 `'sim'`(커널이 실행한다). 기동 중이 아니면 없다.
+   *
+   * 소비처가 `instances[id].mode` 를 직접 읽던 자리를 대신한다. 레지스트리를 밖에 열면 도메인 확인이
+   * 자리마다 제각각이 되고, 실제로 그렇게 됐다(테넌트 격리 전수 확인, 2026-08-06).
+   */
+  static modeOf(domainId: string, id: string): 'live' | 'sim' | undefined {
+    return this.instances[runtimeKey(domainId, id)]?.mode
+  }
+
   static owns(domainId: string, id: string): boolean {
-    return this.instances[id]?.domainId === domainId
+    return !!this.instances[runtimeKey(domainId, id)]
   }
 
   /**
    * 이 트윈이 이 테넌트 것인가 — **떠 있든 아니든.**
    *
-   * `owns()` 는 **떠 있는** 런타임만 안다. 그것을 이력 조회의 관문으로 쓰면, 꺼진 트윈의 저널을
+   * `owns()` 는 **기동 중인** 런타임만 안다. 그것을 이력 조회의 관문으로 쓰면, 꺼진 트윈의 저널을
    * 읽으려 할 때 "이 테넌트에 없다" 는 답이 돌아온다 — 두 가지가 틀렸다. 첫째, 저널은 트윈이 꺼져
    * 있을 때 **가장 필요한 것**이다(그게 이력의 존재 이유다). 둘째, 그 문장은 남의 것이라는 뜻이라
-   * 사용자가 권한 문제로 오해한다. 실제로는 그냥 안 돌고 있을 뿐이다.
+   * 사용자가 권한 문제로 오해한다. 실제로는 그냥 실행 중이 아닐 뿐이다.
    *
    * 소유는 **등록부**가 안다. 이력·집계처럼 런타임과 무관한 질문은 이쪽에 묻는다.
    */
@@ -1279,37 +2580,149 @@ export class TwinEngine {
     return !!(await getRepository(TwinInstance).findOne({ where: { domain: { id: domainId }, instanceId } }))
   }
 
+  /**
+   * **이 공간의 인스턴스들** — 한 현실을 여러 렌즈가 비추므로, 공간을 물으면 그 렌즈 전부를 답한다.
+   *
+   * 화면이 이 규칙을 손으로 짜지 않게 서버가 답한다. 예측 화면은 같은 확장을 **한 파일에서 두 번**
+   * 복제하고 있었다(전체 목록을 받아 클라이언트에서 걸렀다) — 규칙이 흩어지면 한쪽만 고쳐진다.
+   *
+   * 떠 있지 않은 것도 포함한다: 공간에 무엇이 있는지는 기동 여부와 다른 사실이다.
+   */
+  static async instanceIdsOfSpace(domainId: string, spaceId: string): Promise<string[]> {
+    if (!spaceId) return []
+    const rows = await getRepository(TwinInstance).find({ where: { domain: { id: domainId }, spaceId } })
+    return rows.map(r => r.instanceId).filter((x): x is string => !!x)
+  }
+
+  /**
+   * **이 공간에서 봐야 할 것** — 공간의 모든 렌즈에서 신호를 모은다.
+   *
+   * 합집합이 그대로 뜻이 있는 유일한 렌즈다(예측은 합칠 수 없다 — P50 두 개를 더할 수 없다).
+   * 정렬·잘라내기는 화면과 **같은 규칙**을 쓴다(`digestAttentions`) — 서버가 고른 상위 N 이 화면이
+   * 고를 N 과 달라지면 그 어긋남은 아무 데서도 오류로 드러나지 않는다.
+   *
+   * 신호마다 어느 트윈에서 왔는지(`instanceId`)를 붙인다. 공간에서 보면 같은 자리 id 가 렌즈마다
+   * 다른 것을 가리킬 수 있고, 조치는 결국 그 트윈에 보내야 한다.
+   */
+  static async attentionsOfSpace(domainId: string, spaceId: string, limit?: number): Promise<{ attentions: any[]; attentionTotal: number; severityByLocation: Record<string, string> }> {
+    const ids = await this.instanceIdsOfSpace(domainId, spaceId)
+    const lenses = ids
+      /* 떠 있지 않은 트윈은 **지금** 신호가 없다(그 시절 신호는 시간여행이 답한다). */
+      .filter(id => this.owns(domainId, id))
+      .map(id => {
+        const kernel: any = this.kernel(domainId, id)
+        const snap = kernel?.getSnapshot?.() ?? this.snapshot(domainId, id)
+        return { instanceId: id, attentions: snap?.attentions ?? [] }
+      })
+    /* 모으는 규칙(태깅·급한 순서·자리 색)은 순수 함수가 들고 있다 — 여기서 손으로 접지 않는다. */
+    return mergeLensAttentions(lenses, limit)
+  }
+
   /** 라이브 커널(ForecastTwin) — forecast/divergence 예측 연산용. */
-  static kernel(id: string): any {
-    return this.instances[id]?.kernel
+  static kernel(domainId: string, id: string): any {
+    return this.instances[runtimeKey(domainId, id)]?.kernel
   }
 
   /** 라이브 처리량 계측 스냅샷(모니터, ④-1) — 내부 누적(_acc*) 제외한 공개 지표. live 아니면 null. */
-  static metrics(id: string): any {
-    const m = this.instances[id]?.metrics
+  static metrics(domainId: string, id: string): any {
+    const m = this.instances[runtimeKey(domainId, id)]?.metrics
     if (!m) return null
     return {
       instanceId: id,
       ingestedTotal: m.ingestedTotal, broadcastTotal: m.broadcastTotal, journaledTotal: m.journaledTotal,
       ingestRate: m.ingestRate, broadcastRate: m.broadcastRate, journalRate: m.journalRate,
-      backlog: m.backlog, broadcastCoalesceMs: this.BROADCAST_COALESCE_MS
+      backlog: m.backlog, broadcastCoalesceMs: this.BROADCAST_COALESCE_MS,
+      /* 작업별 부하 — 무거운 것부터. 잰 적이 없으면 null(0 으로 채우면 "빠르다" 로 읽힌다). */
+      load: loadSummary(this.instances[runtimeKey(domainId, id)]?.load, this.TICK_MS)
+    }
+  }
+
+  /**
+   * 부하 계기판만 따로 — **시뮬 트윈도 포함한다.**
+   *
+   * `metrics()` 는 라이브 지표(`inst.metrics`)가 있어야 무언가를 돌려준다. 그런데 이벤트 루프를 점유하는
+   * 것은 주로 **시뮬 틱**이고, 시뮬 인스턴스에는 그 지표가 없어 통째로 안 보였다.
+   */
+  static load(domainId: string, id: string): any {
+    const inst = this.instances[runtimeKey(domainId, id)]
+    if (!inst) return null
+
+    return {
+      instanceId: id,
+      mode: inst.mode ?? 'sim',
+      domainId: inst.domainId,
+      domainLabel: inst.domain?.subdomain,
+      realityMode: inst.realityMode,
+      tickMs: this.TICK_MS,
+      running: !!inst.timer || inst.mode === 'live',
+      ...(loadSummary(inst.load, this.TICK_MS) ?? { recent: null, total: null, forksCreated: 0, overBudget: 0, budgetMs: this.TICK_MS * 0.5, loadRatio: null })
+    }
+  }
+
+  /**
+   * **한 곳에서 보는 전체 부하** — 몇 개가 실행 중이고, 누가 루프를 점유하고 있나.
+   *
+   * 시뮬 트윈도 포함한다(`metrics()` 는 라이브 지표가 있어야 답해서 시뮬이 통째로 안 보였다).
+   */
+  static fleet(domainId?: string): any {
+    const keys = Object.keys(this.instances).filter(key => !domainId || isOfDomain(key, domainId))
+    const rows = keys.map(key => {
+      const at = parseRuntimeKey(key)
+      const inst = this.instances[key]
+      /* 도메인을 함께 넘긴다 — 운영자가 먼저 묻는 것은 "어느 테넌트가 루프를 먹나" 다.
+         읽을 수 있는 이름(subdomain)은 라이브 인스턴스에만 붙어 있으므로, 없으면 리졸버가 채운다. */
+      return {
+        instanceId: at.instanceId,
+        mode: inst.mode ?? 'sim',
+        domainId: at.domainId,
+        domainLabel: inst.domain?.subdomain,
+        meter: inst.load
+      }
+    })
+
+    return {
+      tickMs: this.TICK_MS,
+      broadcastCoalesceMs: this.BROADCAST_COALESCE_MS,
+      ...fleetLoad(rows, this.TICK_MS),
+      /* 줄마다 상세 — 화면이 펼쳐 볼 수 있게. 최근 부하 순서는 fleetLoad 가 정한다. */
+      details: keys.map(key => { const at = parseRuntimeKey(key); return this.load(at.domainId, at.instanceId) }).filter(Boolean)
     }
   }
 
+  /** 이 트윈에서 fork 가 만들어졌다 — 예측 한 번이 수십 개를 만든다. */
+  static countForks(domainId: string, id: string, count: number): void {
+    const inst = this.instances[runtimeKey(domainId, id)]
+    if (inst) recordFork(inst.load ?? (inst.load = newLoadMeter()), count)
+  }
+
+  /** 엔진 밖(예측 질의 등)에서 무거운 작업을 잰다 — 같은 계기판에 모인다. */
+  static recordLoad(domainId: string, id: string, phase: LoadPhase, tookMs: number): void {
+    const inst = this.instances[runtimeKey(domainId, id)]
+    if (inst) recordPhase(inst.load ?? (inst.load = newLoadMeter()), phase, tookMs)
+  }
+
   /** 전체 라이브 인스턴스 계측(모니터 대시보드용). */
   static async allMetrics(domainId?: string): Promise<any[]> {
+    /* 도메인 없이 부르면 전 테넌트를 훑는다(내부 모니터용) — 키에서 도메인을 되돌려 각자에게 묻는다. */
     const rows = Object.keys(this.instances)
-      .filter(id => !domainId || this.instances[id].domainId === domainId)
-      .map(id => this.metrics(id))
+      .filter(key => !domainId || isOfDomain(key, domainId))
+      .map(key => {
+        const at = parseRuntimeKey(key)
+        return this.metrics(at.domainId, at.instanceId)
+      })
       .filter(Boolean)
     if (!rows.length || !domainId) return rows
     // 표시 이름 부여 — 실행중 카드가 id 만 보이지 않도록 공간명을 실어준다(공간 카드와 동일). name=공간명 폴백 spaceId 폴백 instanceId.
     const insts = await getRepository(TwinInstance).find({ where: { domain: { id: domainId } } })
     const spaceOf = new Map(insts.map(i => [i.instanceId, i.spaceId]))
+    /* 용도 선언도 함께 실어 보낸다 — 화면이 공간 이름으로 벤치를 **추측하지 않게** 한다.
+       추측하면 `loadtest-` 로 이름 지은 운영 트윈에 벤치 딱지가 붙는다. */
+    const purposeOf = new Map(insts.map(i => [i.instanceId, i.purpose]))
     const nameOf = new Map((await getRepository(TwinSpace).find({ where: { domain: { id: domainId } } })).map(s => [s.spaceId, s.name]))
     for (const r of rows) {
       const sp = spaceOf.get(r.instanceId)
       r.spaceId = sp
+      r.purpose = purposeOf.get(r.instanceId)
       r.name = (sp && nameOf.get(sp)) || sp || r.instanceId
     }
     return rows
@@ -1327,24 +2740,24 @@ export class TwinEngine {
 
   /**
    * 예측용 커널을 **임의 시각 T 기준**으로 재구성 — 과거-vantage 예측(백테스트)·"그때 서서 본 미래".
-   * recover(untilTime)로 T 시점 상태를, T 이하 오더 관측을 모아 hydrate → monteCarloForecast 가 T 에서 앞으로 굴린다.
+   * recover(untilTime)로 T 시점 상태를, T 이하 오더 관측을 모아 hydrate → monteCarloForecast 가 T 에서 앞으로 실행한다.
    * sim/live 무관(저널 기반 재구성). untilTime 생략 시 최신. 도메인 스코프(reg·journal 조회가 domainId).
    */
   static async buildForecastKernelAt(domainId: string, instanceId: string, untilTime?: string): Promise<any | null> {
     const reg = await getRepository(TwinInstance).findOne({ where: { domain: { id: domainId }, instanceId } })
-    if (!reg?.board) return null
-    const Kernel = KERNELS[reg.kind ?? 'wms'] ?? WmsKernel
-    const k = new Kernel(domainId, undefined, this.mesSpecOf(reg.board as BoardDef))
-    k.loadBoard(reg.board as BoardDef)
-    this.applyOperations(k, reg.board, instanceId) // 예측도 같은 명세로 굴러야 한다(화면과 다른 숫자 금지)
-    await this.installEstimators(k, domainId, instanceId, reg.board) // 예측은 기다린다 — 실측을 놓치면 예측이 상수로 돈다
+    if (!reg?.model) return null
+    const Kernel = kernelFor(reg.kind)
+    const k = new Kernel(domainId, undefined, this.productionSpecOf(reg.model as TwinModelDef))
+    k.loadTwinModel(reg.model as TwinModelDef)
+    this.applyOperations(k, reg.model, instanceId) // 예측도 같은 명세로 굴러야 한다(화면과 다른 숫자 금지)
+    await this.installEstimators(k, domainId, instanceId, reg.model) // 예측은 기다린다 — 실측을 놓치면 예측이 상수로 계산된다
     const state = await this.recover(domainId, instanceId, undefined, untilTime).catch(() => null)
     if (!state) return null
     const cutoff = untilTime != null ? Date.parse(untilTime) : Infinity
     const rows = await getRepository(TwinEvent).find({ where: { domain: { id: domainId }, instanceId, eventType: OP_EVENT.order }, order: { revision: 'ASC' } })
     const latest = new Map<string, any>()
     for (const r of rows) {
-      if (Number.isFinite(cutoff) && Date.parse(r.eventTime) > cutoff) continue
+      if (Number.isFinite(cutoff) && (r.eventTime?.getTime() ?? NaN) > cutoff) continue
       const d = (r.payload as any)?.data
       if (d?.orderId) latest.set(d.orderId, d)
     }
@@ -1353,8 +2766,8 @@ export class TwinEngine {
   }
 
   /** 현재 전체 스냅샷 — 라이브 우선, 없으면 저널 복구 캐시. */
-  static snapshot(id: string): any {
-    const inst = this.instances[id]
+  static snapshot(domainId: string, id: string): any {
+    const inst = this.instances[runtimeKey(domainId, id)]
     if (inst?.mode === 'live' && inst.projector) {
       /* live: **커널이 주목 신호를 스스로 낸다**(관측 모드) — 호스트가 덧붙이던 withLiveAttentions 는
        * 필요 없다. OEE 만 호스트가 채운다: 원 시스템이 시간 누적을 보내 주지 않아 상태 전이를 적분해
@@ -1362,6 +2775,6 @@ export class TwinEngine {
       const st = inst.projector.snapshot()
       return inst.oee ? withLiveOee(st, inst.oee) : st
     }
-    return inst?.runtime?.resync() ?? this.recovered[id]
+    return inst?.runtime?.resync() ?? this.recovered[runtimeKey(domainId, id)]
   }
 }