@things-factory/headless-twin 10.0.7 → 10.0.9

package/server/engine/twin-engine.ts

@@ -12,7 +12,9 @@ import { cacheService } from '@things-factory/cache-service'
 
 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 { planWarmStart, unwrapState } from './warm-start.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,6 +23,8 @@ 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, collidingIds } from '../service/reference/ingest-space.js'
+import { type IngestWarning, landmarkIdsMerged, describeWarnings } from '../service/reference/reference-master.js'
 import { buildTravelEstimator, chainEstimators } from './travel-estimator.js'
 import { buildMeasuredEstimator } from './measured-estimator.js'
 import { describeModelBasis, type ModelBasis } from './model-basis.js'
@@ -30,11 +34,13 @@ import { createHash } from 'node:crypto'
 import { buildEntityDeltas } from './entity-delta.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'
 
 /* 커널 런타임 로드 — 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, TwinRuntime, StateProjector, replay, replaySegments, readBoardLocations, readBoardEquipment, DOMAIN_CATALOG, OP_EVENT } = require('@operato/twin-kernel')
 
 const KERNELS: Record<string, any> = { wms: WmsKernel, yms: YmsKernel, mes: MesKernel }
 
@@ -93,8 +99,16 @@ interface InstanceRuntime {
 }
 
 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
 
@@ -108,9 +122,14 @@ export class TwinEngine {
 
   /** 최신 스냅샷을 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)
@@ -126,7 +145,8 @@ export class TwinEngine {
   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)
         )
@@ -175,13 +195,14 @@ 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 }
+          /* 예전에 겹포장으로 저장된 값이 남아 있을 수 있다 — 읽는 쪽에서도 벗긴다(한 번은 반드시 만난다). */
+          this.recovered[runtimeKey(row.domainId, row.instanceId)] = { revision: cached.revision, state: unwrapState(cached.state) }
           console.log(`[twin-engine] warm-started "${row.instanceId}" from snapshot cache → revision ${cached.revision}.`)
           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}.`)
         }
       }
@@ -195,25 +216,33 @@ export class TwinEngine {
    * 웜스타트 — 기동하는 커널에 **직전 관측 상태**를 심는다.
    *
    * ── 왜 필요한가 ─────────────────────────────────────────────────────────────
-   * `loadBoard` 는 **구조만** 싣는다(노드·무버). 상태(무엇이 어디에 얼마나)는 없다. 그래서 재기동한
+   * `loadBoard` 는 **구조만** 싣는다(자리·설비). 상태(무엇이 어디에 얼마나)는 없다. 그래서 재기동한
    * 트윈은 저널에 입고 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,10 +256,24 @@ 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)`] : [])
+    ].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 + 레지스트리 영속. */
@@ -352,8 +395,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 })
@@ -365,15 +408,16 @@ 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]
+    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))
+    const kernel: TwinKernel = new Kernel(domainId, undefined, this.productionSpecOf(board))
     kernel.loadBoard(board) // 구조만. 상태는 아래 웜스타트가 심는다.
     this.applyOperations(kernel, board, 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.warmStart(domainId, id, kernel, purpose)
     /*
      * **번호를 이어 센다** — 저널에 이미 있는 번호와 겹치지 않게.
      *
@@ -385,8 +429,8 @@ export class TwinEngine {
 
     /* 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] // 웜스타트로 커널에 옮겨 심었다 — 이제 라이브가 진실이다.
+    this.instances[key] = inst
+    delete this.recovered[key] // 웜스타트로 커널에 옮겨 심었다 — 이제 라이브가 진실이다.
 
     /* 라이브 바인딩(P3): data 채널 필터가 subdomain 을 보므로 Domain 객체를 1회 해석해 둔다. */
     getRepository(Domain).findOne({ where: { id: domainId } }).then(d => (inst.domain = d)).catch(() => {})
@@ -408,7 +452,7 @@ export class TwinEngine {
     this.register(domainId, id, kind, board, '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
   }
 
@@ -434,8 +478,25 @@ export class TwinEngine {
    *
    * 보드에 없으면 `undefined` — 레거시 경로 그대로다(기존 트윈의 거동을 바꾸지 않는다).
    */
-  private static mesSpecOf(board: BoardDef | undefined): any {
-    return (board as any)?.mesSpec
+  /**
+   * 생산 선언을 꺼낸다 — 커널 생성자에 넘긴다.
+   *
+   * **옛 이름(`mesSpec`)은 읽지 않는다.** 그것은 계약에 선언조차 없던 필드였고(MES 커널 생성자 인자
+   * 이름이 그대로 굳은 것), 일반 기제에 한 시스템 이름이 붙어 있었기 때문에 창고 트윈이 이 자리를
+   * 쓰지 못했다. 별명으로 남겨 두면 그 혼동이 계속되므로 하나로 통일했다.
+   *
+   * 옛 이름만 가진 보드가 있으면 **조용히 생산 선언을 잃는 대신 분명히 멈춘다** — 그 트윈은 공정이
+   * 없는 채로 돌게 되고(라인이 서 있는 창고), 원인을 찾기 어렵다.
+   */
+  private static productionSpecOf(board: BoardDef | undefined): any {
+    const legacy = (board as any)?.mesSpec
+    if (legacy && !(board as any)?.productionSpec) {
+      throw new Error(
+        'board 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 (board as any)?.productionSpec
   }
 
   /**
@@ -462,9 +523,10 @@ export class TwinEngine {
   }
 
   static startLive(id: string, domainId: string, kind: string, board: BoardDef): InstanceRuntime {
-    if (this.instances[id]) return this.instances[id]
+    const key = runtimeKey(domainId, id)
+    if (this.instances[key]) return this.instances[key]
     const Kernel = KERNELS[kind] ?? WmsKernel
-    const kernel: any = new Kernel(domainId, undefined, this.mesSpecOf(board))
+    const kernel: any = new Kernel(domainId, undefined, this.productionSpecOf(board))
     kernel.loadBoard(board)
     this.applyOperations(kernel, board, id) // 명세는 라이브에도 실린다(예측 자격이 sim 과 같아진다)
     /* `projector` 필드는 옛 이름으로 남긴다 — 소비처가 `snapshot()` 을 부르므로 얇은 어댑터로 잇는다.
@@ -474,8 +536,8 @@ export class TwinEngine {
     /* 추정기(실측·거리)도 라이브에 붙인다 — 예측이 상수로 돌지 않게. 기동을 막지 않는다. */
     this.installEstimators(kernel, domainId, id, board).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
+    delete this.recovered[key]
     /* 라이브 바인딩(data 채널) subdomain 필터용 Domain 1회 해석(sim 과 동일). */
     getRepository(Domain).findOne({ where: { id: domainId } }).then(d => (inst.domain = d)).catch(() => {})
     /* 저널 revision 카운터 시드 — 기존 저널 최대치에서 이어붙임(재기동 시 revision 충돌 방지). 이후 인메모리 증가. */
@@ -492,8 +554,8 @@ 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 누적)
     // 저널 결선(라이브도 sim 처럼 이벤트 영속) — 단 이벤트마다 DB write 하면 부하폭발이라 모아뒀다가
@@ -506,6 +568,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
@@ -641,7 +715,7 @@ export class TwinEngine {
    * 저널은 보존된다(추가는 이미 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)
@@ -664,7 +738,7 @@ export class TwinEngine {
    * board 는 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`)
+    if (this.instances[runtimeKey(domainId, instanceId)]) throw new Error(`instance "${instanceId}" is running — stop before re-provisioning`)
     const repo = getRepository(TwinInstance)
     const existing = await repo.findOne({ where: { domain: { id: domainId }, instanceId } })
 
@@ -718,7 +792,7 @@ export class TwinEngine {
     await repo.save(repo.create({ domain: { id: domainId } as any, instanceId, rev, signature, board: board as any, ...(comment ? { comment } : {}) }))
     this.structureRevCache[`${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
   }
@@ -794,7 +868,8 @@ export class TwinEngine {
 
   /** 레지스트리 board 로 기동(프로비전된 인스턴스 start). board 인자 없이 저장된 구조로 재기동. */
   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)`)
 
@@ -805,13 +880,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 }
       }
     }
 
@@ -883,13 +958,13 @@ 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)
+    delete this.recovered[runtimeKey(domainId, instanceId)]
     await getRepository(TwinEvent).delete({ domain: { id: domainId } as any, instanceId })
     await getRepository(TwinInstance).delete({ domain: { id: domainId } as any, instanceId })
   }
@@ -912,10 +987,17 @@ export class TwinEngine {
         realityMode: r.realityMode ?? DEFAULT_REALITY_MODE, // 현실 출처 선언(§0 ①) — mirror/sim-world/sim-experiment
         purpose: r.purpose ?? 'operational', // 운영 vs 벤치 사본(1급 구별 — 이름 접두사 아님)
         copyOf: r.copyOf ?? undefined,
-        running: !!this.instances[r.instanceId],
+        running: !!this.instances[runtimeKey(domainId, r.instanceId)],
         revision: last?.revision ?? 0,
-        locationCount: board.locations?.length ?? 0,
-        equipmentCount: board.equipment?.length ?? 0
+        /*
+         * **리더를 거쳐 센다** — 보드 키를 직접 읽으면 옛 세대 보드가 0 으로 보인다.
+         *
+         * 커널은 자리·설비 배열의 **옛 세대 키까지 흡수해** 읽어 주는데, 이 목록은 새 이름만 직접
+         * 세고 있었다. 그래서 옛 보드 12개가 화면에 **자리 0 · 설비 0**
+         * 으로 떴다 — 오류 없이, 그냥 빈 공장처럼. 세는 규칙이 두 벌이면 이런 식으로 갈라진다.
+         */
+        locationCount: readBoardLocations(board).length,
+        equipmentCount: readBoardEquipment(board).length
       })
     }
     return out
@@ -936,8 +1018,9 @@ export class TwinEngine {
       const board: any = r.board ?? {}
       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(board).length
+      a.equipment += readBoardEquipment(board).length
       agg.set(r.spaceId, a)
     }
     return [...agg.values()]
@@ -978,12 +1061,35 @@ 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[] }> {
+  static async ingestMaster(
+    domainId: string,
+    master: ReferenceMaster,
+    into?: { spaceId?: string }
+  ): Promise<{ instanceId: string; spaceId: string; warnings: IngestWarning[] }> {
     const { board, spaceContent, warnings } = masterToTwin(master, DOMAIN_CATALOG)
-    const spaceId: string = board.spaceId
     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(board.spaceId, wanted, wantedExists)
+    const spaceId: string = choice.spaceId
+    board.spaceId = spaceId // 보드(커널 소비)도 같은 공간을 가리켜야 한다
     const existing = await repo.findOne({ where: { domain: { id: domainId }, spaceId } })
+    if (choice.joined) {
+      /* 같은 id 의 구역·랜드마크는 합집합으로 접힌다 — 가릴 수 없는 것을 고르지 않고 무엇이
+         합쳐졌는지 말한다(정당한 경우가 많으므로 막지 않는다). */
+      const prevContent: any = existing?.content ?? {}
+      const lm = collidingIds(prevContent.landmarks, (spaceContent as any).landmarks)
+      if (lm.length) warnings.push(landmarkIdsMerged(spaceId, lm))
+    }
     /*
      * 공유 공간(여러 트윈이 한 spaceId, N:1) content 병합 — 마지막 인제스트가 통째로 덮어써 area(그룹)·표현이
      * 유실되던 문제 보정. area·landmark 는 id 합집합, representations 는 비어있지 않은 쪽 보존, 나머지는 first-wins.
@@ -1062,7 +1168,7 @@ 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 (warnings.length) console.warn(`[twin-engine] ingest "${master.source}" warnings: ${describeWarnings(warnings)}`)
     return { instanceId: master.source, spaceId, warnings }
   }
 
@@ -1074,7 +1180,7 @@ 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
     }
@@ -1105,7 +1211,7 @@ export class TwinEngine {
     const seen = new Set<string>()
     /* payload 매핑은 순수 함수(buildEntityDeltas)로 분리 — 여기선 시그니처 dedup + 발행만.
      * 변화한 엔티티만 발행(최신-상태 채널이라 무변화 재방송 무의미). */
-    for (const { tag, data } of buildEntityDeltas(st)) {
+    for (const { tag, data } of buildEntityDeltas(st, inst.id)) {
       seen.add(tag)
       const sig = JSON.stringify(data)
       if (sigs.get(tag) === sig) continue // 무변화 → 발행 생략
@@ -1133,11 +1239,11 @@ 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)
     }
     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)`)
@@ -1197,15 +1303,61 @@ export class TwinEngine {
     const newest = structures[structures.length - 1]?.board as BoardDef | undefined
     if (asOfNow && newest && segments[segments.length - 1]?.board !== newest) segments.push({ board: 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 ? String(rows[rows.length - 1]?.eventTime ?? '') : ''
+
+    /*
+     * **가동 이력도 되살린다** — 되짚은 화면에 설비 계측이 비어 있던 것.
+     *
+     * OEE 는 원 시스템이 누적을 보내 주지 않아 호스트가 상태 전이를 적분해 만든다(그래서 커널이 아니라
+     * 여기 있다). 그런데 그 누적기는 **라이브에서만** 돌았고, 저널을 접는 경로는 그 계산을 하지 않았다 —
+     * 과거를 되짚으면 모든 설비가 "가동 이력이 전혀 없음" 으로 보였다.
+     *
+     * 없는 것은 데이터가 아니라 계산이다: 입력(`equipment.status` 전이·`quality.output`)은 저널에 다
+     * 있다. 그래서 **같은 누적기에 같은 이벤트를 태운다** — 규칙을 두 벌 만들지 않는다.
+     *
+     * 시간여행에서도 맞다: 여기 태우는 것은 이미 잘라 낸(`wanted`) 이벤트뿐이므로, 그 시점까지의
+     * 가동 이력이 나온다(그 뒤에 일어난 고장이 과거 화면에 섞이지 않는다).
+     */
+    const oee = new OeeAccumulator()
+    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)
+    }
+
+    if (!segments.length) return withNow(replay(((asOfNow && newest) || reg.board) as BoardDef, []))
+    if (segments.length === 1) return withNow(replay(segments[0].board, segments[0].events))
 
     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 withNow(state)
   }
 
   /**
@@ -1237,12 +1389,12 @@ 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) {
       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 +1402,77 @@ 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 하면
+   * 같은 오류가 매 주기 쏟아지고, 그 트윈은 "도는 것처럼 보이면서" 아무것도 진행하지 않는다.
+   */
+  private static tickGuarded(domainId: string, id: string, runtime: TwinRuntimeType): void {
+    try {
+      runtime.tick(this.TICK_MS)
+    } catch (err: any) {
+      const inst = this.instances[runtimeKey(domainId, id)]
+      if (inst?.timer) {
+        clearInterval(inst.timer)
+        inst.timer = undefined
+      }
+      console.error(
+        `[twin-engine] "${id}" tick failed — simulation stopped for this twin (other twins keep running). ` +
+          `Fix the declaration and start it again. Reason: ${err?.message ?? err}`
+      )
+    }
+  }
+
+  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,8 +1481,18 @@ 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)]
   }
 
   /**
@@ -1279,14 +1510,52 @@ 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,
@@ -1298,9 +1567,13 @@ export class TwinEngine {
 
   /** 전체 라이브 인스턴스 계측(모니터 대시보드용). */
   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.
@@ -1334,7 +1607,7 @@ export class TwinEngine {
     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))
+    const k = new Kernel(domainId, undefined, this.productionSpecOf(reg.board as BoardDef))
     k.loadBoard(reg.board as BoardDef)
     this.applyOperations(k, reg.board, instanceId) // 예측도 같은 명세로 굴러야 한다(화면과 다른 숫자 금지)
     await this.installEstimators(k, domainId, instanceId, reg.board) // 예측은 기다린다 — 실측을 놓치면 예측이 상수로 돈다
@@ -1353,8 +1626,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 +1635,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)]
   }
 }