@things-factory/headless-twin 10.0.7 → 10.0.9

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

@@ -14,6 +14,8 @@ const cache_service_1 = require("@things-factory/cache-service");
 const twin_event_js_1 = require("../service/twin-event/twin-event.js");
 const twin_event_keys_js_1 = require("../service/twin-event/twin-event-keys.js");
 const warm_start_js_1 = require("./warm-start.js");
+const runtime_key_js_1 = require("./runtime-key.js");
+const command_routing_js_1 = require("./command-routing.js");
 const twin_instance_js_1 = require("../service/twin-instance/twin-instance.js");
 const twin_structure_js_1 = require("../service/twin-structure/twin-structure.js");
 const twin_space_js_1 = require("../service/twin-space/twin-space.js");
@@ -22,6 +24,8 @@ const twin_space_representation_js_1 = require("../service/twin-space/twin-space
 const twin_space_area_js_1 = require("../service/twin-space/twin-space-area.js");
 const twin_area_js_1 = require("../service/twin-space/twin-area.js");
 const reference_master_js_2 = require("../service/reference/reference-master.js");
+const ingest_space_js_1 = require("../service/reference/ingest-space.js");
+const reference_master_js_3 = require("../service/reference/reference-master.js");
 const travel_estimator_js_1 = require("./travel-estimator.js");
 const measured_estimator_js_1 = require("./measured-estimator.js");
 const kpi_query_js_1 = require("./kpi-query.js");
@@ -29,13 +33,23 @@ const node_crypto_1 = require("node:crypto");
 const entity_delta_js_1 = require("./entity-delta.js");
 const structure_diff_js_1 = require("./structure-diff.js");
 const oee_accumulator_js_1 = require("./oee-accumulator.js");
+const live_attentions_js_1 = require("./live-attentions.js");
+const attention_digest_js_1 = require("./attention-digest.js");
 /* 커널 런타임 로드 — 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 = { wms: WmsKernel, yms: YmsKernel, mes: MesKernel };
 exports.DEFAULT_REALITY_MODE = 'sim-experiment';
 class TwinEngine {
+    /*
+     * 떠 있는 런타임 — **키는 `runtimeKey(domainId, instanceId)`** 다(`runtime-key.ts` 에 이유).
+     *
+     * 예전엔 `instanceId` 하나로 키를 잡았다. 그런데 정체성은 `(domain, instanceId)` 이고 DB 유일성도
+     * 그쪽이라, 두 테넌트가 같은 id 를 쓰면(레퍼런스 경로가 소스 이름을 id 로 쓴다) 한 자리를 다퉜다.
+     * **엔진 밖에서 이 맵을 직접 색인하지 않는다** — `owns`·`runtime`·`kernel` 같은 접근자를 쓴다.
+     */
     static { this.instances = {}; }
     /** 라이브 런타임이 없을 때(복구 후 미기동) 저널에서 재구성한 상태 캐시. */
+    /** 웜스타트 씨앗 — `instances` 와 **같은 키**(겹치면 남의 스냅샷으로 재고가 섞인다). */
     static { this.recovered = {}; }
     static { this.TICK_MS = 1000; }
     /* 최신 스냅샷 영속(warm-start) — 재기동 시 저널 fold-from-0 replay 대신 마지막 라이브 스냅샷으로 복원.
@@ -46,10 +60,15 @@ class TwinEngine {
     static { this.CHECKPOINT_MS = 20000; } // 체크포인트 주기(핫 브로드캐스트 경로와 분리, O(state) 스로틀)
     /** 최신 스냅샷을 cache-service 에 체크포인트(도메인+instanceId 키). display-only·비차단·오류흡수. */
     static async persistSnapshot(domainId, instanceId) {
-        const inst = this.instances[instanceId];
+        const inst = this.instances[(0, runtime_key_js_1.runtimeKey)(domainId, instanceId)];
         if (!inst)
             return;
-        const state = this.snapshot(instanceId);
+        /*
+         * **봉투가 아니라 상태를 저장한다.** `snapshot()` 은 시뮬에서 `runtime.resync()` 봉투를 주는데,
+         * 그것을 다시 `{revision, state}` 로 감싸 넣어 왔다 → 꺼낸 값에 축이 하나도 없어 웜스타트가
+         * 조용히 넘어갔다(저널에 수천 건이 있어도 트윈이 빈 채로 떴다).
+         */
+        const state = (0, warm_start_js_1.unwrapState)(this.snapshot(domainId, instanceId));
         if (!state)
             return;
         const revision = inst.revision ?? state.revision ?? 0;
@@ -65,7 +84,8 @@ class TwinEngine {
         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 } = (0, runtime_key_js_1.parseRuntimeKey)(key);
                 this.persistSnapshot(inst.domainId, instanceId).catch(err => console.error(`[twin-engine] snapshot checkpoint fail "${instanceId}"`, err?.message ?? err));
             }
         }, this.CHECKPOINT_MS);
@@ -114,13 +134,14 @@ 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[(0, runtime_key_js_1.runtimeKey)(row.domainId, row.instanceId)] = { revision: cached.revision, state: (0, warm_start_js_1.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[(0, runtime_key_js_1.runtimeKey)(row.domainId, row.instanceId)] = { revision: state.revision, state };
                     console.log(`[twin-engine] recovered "${row.instanceId}" from journal → revision ${state.revision}.`);
                 }
             }
@@ -134,25 +155,33 @@ 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 만 있는 것)는 남은 수량을 알 수 없어 심지 않는다. **지어내지 않는
+     *    대신 몇 건인지 말한다** — 세지 않으면 "주문이 없다" 와 "주문을 못 심었다" 가 화면에서 같아진다.
+     *  · 진행 중 개별 작업의 내부 상태는 관측만으로 완전히 복원되지 않는다(커널이 명시한 한계, 재계획에 맡김).
      *
      * ── 벤치는 시드하지 않는다 ──────────────────────────────────────────────────
      * 부하 벤치는 **새 시작에서 용량을 재는 것**이 목적이라 현재 상태를 심으면 측정이 오염된다.
      */
-    static warmStart(id, kernel, purpose) {
+    static warmStart(domainId, id, kernel, purpose) {
         const hydrate = kernel.hydrateObserved;
-        const plan = (0, warm_start_js_1.planWarmStart)(this.recovered[id]?.state, purpose, typeof hydrate === 'function');
+        const plan = (0, warm_start_js_1.planWarmStart)(this.recovered[(0, runtime_key_js_1.runtimeKey)(domainId, id)]?.state, purpose, typeof hydrate === 'function');
         if (plan.action === 'skip') {
             if (plan.reason === 'bench') {
                 console.log(`[twin-engine] "${id}" is a bench twin — starting empty on purpose (seeding would skew the measurement).`);
@@ -163,8 +192,22 @@ class TwinEngine {
             return;
         }
         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 + 레지스트리 영속. */
     /**
@@ -280,8 +323,8 @@ class TwinEngine {
             where.spaceId = target.spaceId;
         const registered = await (0, shell_1.getRepository)(twin_instance_js_1.TwinInstance).find({ where });
         return registered.map(reg => {
-            const rt = this.instances[reg.instanceId];
-            const kernel = rt?.domainId === domainId ? rt.kernel : undefined;
+            const rt = this.instances[(0, runtime_key_js_1.runtimeKey)(domainId, reg.instanceId)];
+            const kernel = rt?.kernel; // 키에 도메인이 있으므로 남의 런타임을 집을 수 없다
             if (typeof kernel?.capacity !== 'function')
                 return { instanceId: reg.instanceId, kind: reg.kind, reason: 'not-running' };
             const analysis = kernel.capacity({ unitsPerDay, sampleWeekStartMs });
@@ -293,15 +336,16 @@ class TwinEngine {
         });
     }
     static start(id, domainId, kind, board, realityMode, purpose, resumeFrom) {
-        if (this.instances[id])
-            return this.instances[id];
+        const key = (0, runtime_key_js_1.runtimeKey)(domainId, id);
+        if (this.instances[key])
+            return this.instances[key];
         const Kernel = KERNELS[kind] ?? WmsKernel;
-        const kernel = new Kernel(domainId, undefined, this.mesSpecOf(board));
+        const kernel = 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);
         /*
          * **번호를 이어 센다** — 저널에 이미 있는 번호와 겹치지 않게.
          *
@@ -313,8 +357,8 @@ class TwinEngine {
         const runtime = new TwinRuntime(kernel);
         /* subscribe 는 RuntimeSubscription({ unsubscribe() }) 반환 → () => void 로 감쌈. */
         const inst = { id, domainId, runtime, kernel, realityMode: realityMode ?? exports.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회 해석해 둔다. */
         (0, shell_1.getRepository)(shell_1.Domain).findOne({ where: { id: domainId } }).then(d => (inst.domain = d)).catch(() => { });
         /* State 채널: runtime.subscribe(snapshot→delta→clock) → pubsub 방송(구독 리졸버가 instanceId 필터). */
@@ -332,7 +376,7 @@ class TwinEngine {
         /* 복구 앵커: 레지스트리에 board/kind/status/realityMode 영속(재부팅 시 이게 있어야 replay·선언 거동 가능). */
         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;
     }
     /**
@@ -357,8 +401,23 @@ class TwinEngine {
      *
      * 보드에 없으면 `undefined` — 레거시 경로 그대로다(기존 트윈의 거동을 바꾸지 않는다).
      */
-    static mesSpecOf(board) {
-        return board?.mesSpec;
+    /**
+     * 생산 선언을 꺼낸다 — 커널 생성자에 넘긴다.
+     *
+     * **옛 이름(`mesSpec`)은 읽지 않는다.** 그것은 계약에 선언조차 없던 필드였고(MES 커널 생성자 인자
+     * 이름이 그대로 굳은 것), 일반 기제에 한 시스템 이름이 붙어 있었기 때문에 창고 트윈이 이 자리를
+     * 쓰지 못했다. 별명으로 남겨 두면 그 혼동이 계속되므로 하나로 통일했다.
+     *
+     * 옛 이름만 가진 보드가 있으면 **조용히 생산 선언을 잃는 대신 분명히 멈춘다** — 그 트윈은 공정이
+     * 없는 채로 돌게 되고(라인이 서 있는 창고), 원인을 찾기 어렵다.
+     */
+    static productionSpecOf(board) {
+        const legacy = board?.mesSpec;
+        if (legacy && !board?.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?.productionSpec;
     }
     /**
      * 현장(공간)의 **시각 기준**을 보드에 얹는다 — 커널이 교대의 `HH:MM` 을 읽을 기준.
@@ -385,10 +444,11 @@ class TwinEngine {
         return { ...board, utcOffsetMinutes: offset };
     }
     static startLive(id, domainId, kind, board) {
-        if (this.instances[id])
-            return this.instances[id];
+        const key = (0, runtime_key_js_1.runtimeKey)(domainId, id);
+        if (this.instances[key])
+            return this.instances[key];
         const Kernel = KERNELS[kind] ?? WmsKernel;
-        const kernel = new Kernel(domainId, undefined, this.mesSpecOf(board));
+        const kernel = new Kernel(domainId, undefined, this.productionSpecOf(board));
         kernel.loadBoard(board);
         this.applyOperations(kernel, board, id); // 명세는 라이브에도 실린다(예측 자격이 sim 과 같아진다)
         /* `projector` 필드는 옛 이름으로 남긴다 — 소비처가 `snapshot()` 을 부르므로 얇은 어댑터로 잇는다.
@@ -398,8 +458,8 @@ 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 과 동일). */
         (0, shell_1.getRepository)(shell_1.Domain).findOne({ where: { id: domainId } }).then(d => (inst.domain = d)).catch(() => { });
         /* 저널 revision 카운터 시드 — 기존 저널 최대치에서 이어붙임(재기동 시 revision 충돌 방지). 이후 인메모리 증가. */
@@ -415,8 +475,8 @@ class TwinEngine {
      * reference 어댑터가 낸 records → 커널 face2-adapter.ingest → CanonicalEnvelope 를 여기로 밀어넣는다.
      * (State 채널 델타/저널 결선은 후속 — 스켈레톤은 data(tag) 미러 중심.)
      */
-    static ingestLive(id, envelopes) {
-        const inst = this.instances[id];
+    static ingestLive(domainId, id, envelopes) {
+        const inst = this.instances[(0, runtime_key_js_1.runtimeKey)(domainId, id)];
         if (inst?.mode !== 'live' || !inst.projector)
             return;
         for (const e of envelopes) {
@@ -436,6 +496,18 @@ class TwinEngine {
         inst.dirty = true;
         this.ensureBroadcastCoalescer();
     }
+    /**
+     * 구간 성과 방송은 **없앴다**(2026-08-06). 카드가 `twinKpi` 를 직접 묻는다.
+     *
+     * 왜: 카드를 여러 단계(공간·트윈·구역·자리·설비)에 붙이려면 방송으로는 태그가 트윈당 1,200개가 되고,
+     * **보드에 카드를 하나도 안 놓아도** 30초마다 트윈마다 저널을 접었다. 질의로 바꾸니 보고 있는 카드
+     * 수만큼만 들고, 같은 (대상·창·축) 은 클라이언트가 하나로 합친다.
+     *
+     * 덤으로 질의만 할 수 있는 것이 둘 생겼다 — **과거 시각**(`toTime`)과 **공간 단위 합산**(여러 트윈을
+     * 한 번에 접기). 방송 루프는 트윈별이라 둘 다 못 했다.
+     *
+     * 축을 나눠도 폴드 비용이 같다는 실측이 근거다(`test/kpi-query-bench.test.ts`).
+     */
     /** 방송 병합 주기(ms) — 방송률 상한. 인제스트가 아무리 빨라도 이 주기로만 방송. */
     static { this.BROADCAST_COALESCE_MS = 200; }
     /** live 방송 coalescer — dirty 인 live 인스턴스만 주기적으로 1회 방송(entitySigs 로 변경 엔티티만). */
@@ -573,7 +645,7 @@ class TwinEngine {
      * 저널은 보존된다(추가는 이미 equipment 델타로 저널됨 → replay 는 id-keyed upsert 라 이중계산 없음).
      */
     static async syncBoardEquipment(domainId, instanceId) {
-        const inst = this.instances[instanceId];
+        const inst = this.instances[(0, runtime_key_js_1.runtimeKey)(domainId, instanceId)];
         const snap = inst?.kernel?.getSnapshot?.();
         if (!snap?.equipment)
             return;
@@ -598,7 +670,7 @@ class TwinEngine {
      * board 는 replay 의 마스터라 구조가 바뀌면 과거 이벤트의 전제가 깨진다. 좌표(layout)만 바뀌면 저널 보존.
      */
     static async provision(domainId, instanceId, kind, board, comment) {
-        if (this.instances[instanceId])
+        if (this.instances[(0, runtime_key_js_1.runtimeKey)(domainId, instanceId)])
             throw new Error(`instance "${instanceId}" is running — stop before re-provisioning`);
         const repo = (0, shell_1.getRepository)(twin_instance_js_1.TwinInstance);
         const existing = await repo.findOne({ where: { domain: { id: domainId }, instanceId } });
@@ -648,7 +720,7 @@ class TwinEngine {
         await repo.save(repo.create({ domain: { id: domainId }, instanceId, rev, signature, board: board, ...(comment ? { comment } : {}) }));
         this.structureRevCache[`${domainId}:${instanceId}`] = rev;
         /* 구조가 바뀌면 재구성 캐시는 옛 공장의 것이다 — 버린다(지우는 건 캐시뿐, 사실은 남는다). */
-        delete this.recovered[instanceId];
+        delete this.recovered[(0, runtime_key_js_1.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;
@@ -716,8 +788,9 @@ class TwinEngine {
     }
     /** 레지스트리 board 로 기동(프로비전된 인스턴스 start). board 인자 없이 저장된 구조로 재기동. */
     static async startFromRegistry(domainId, instanceId, realityMode) {
-        if (this.instances[instanceId])
-            return this.instances[instanceId];
+        const key = (0, runtime_key_js_1.runtimeKey)(domainId, instanceId);
+        if (this.instances[key])
+            return this.instances[key];
         const reg = await (0, shell_1.getRepository)(twin_instance_js_1.TwinInstance).findOne({ where: { domain: { id: domainId }, instanceId } });
         if (!reg?.board)
             throw new Error(`instance "${instanceId}" not provisioned (no board)`);
@@ -728,15 +801,15 @@ 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 };
+                    this.recovered[key] = { revision: state.revision, state };
             }
         }
         /*
@@ -797,12 +870,12 @@ class TwinEngine {
      */
     static async resetJournal(domainId, instanceId) {
         await (0, shell_1.getRepository)(twin_event_js_1.TwinEvent).delete({ domain: { id: domainId }, instanceId });
-        delete this.recovered[instanceId];
+        delete this.recovered[(0, runtime_key_js_1.runtimeKey)(domainId, instanceId)];
     }
     /** 삭제 — 정지 + 레지스트리 삭제 + 저널 purge(domain 스코프). */
     static async remove(domainId, instanceId) {
-        await this.stop(instanceId);
-        delete this.recovered[instanceId];
+        await this.stop(domainId, instanceId);
+        delete this.recovered[(0, runtime_key_js_1.runtimeKey)(domainId, instanceId)];
         await (0, shell_1.getRepository)(twin_event_js_1.TwinEvent).delete({ domain: { id: domainId }, instanceId });
         await (0, shell_1.getRepository)(twin_instance_js_1.TwinInstance).delete({ domain: { id: domainId }, instanceId });
     }
@@ -824,10 +897,17 @@ class TwinEngine {
                 realityMode: r.realityMode ?? exports.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[(0, runtime_key_js_1.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;
@@ -847,8 +927,9 @@ class TwinEngine {
             const board = 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()];
@@ -887,12 +968,32 @@ 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, master) {
+    static async ingestMaster(domainId, master, into) {
         const { board, spaceContent, warnings } = (0, reference_master_js_2.masterToTwin)(master, DOMAIN_CATALOG);
-        const spaceId = board.spaceId;
         const repo = (0, shell_1.getRepository)(twin_space_js_1.TwinSpace);
+        /* 합칠 공간을 골랐으면 **있는지 먼저 확인한다** — 없는 곳에 조용히 새 공간을 만들면 사용자는
+           합쳤다고 믿고 화면은 따로 논다. 판정 함수가 그 경우 거절한다. */
+        const wanted = (into?.spaceId ?? '').trim();
+        const wantedExists = wanted
+            ? (await repo.count({ where: { domain: { id: domainId }, spaceId: wanted } })) > 0
+            : false;
+        const choice = (0, ingest_space_js_1.resolveIngestSpace)(board.spaceId, wanted, wantedExists);
+        const spaceId = choice.spaceId;
+        board.spaceId = spaceId; // 보드(커널 소비)도 같은 공간을 가리켜야 한다
         const existing = await repo.findOne({ where: { domain: { id: domainId }, spaceId } });
+        if (choice.joined) {
+            /* 같은 id 의 구역·랜드마크는 합집합으로 접힌다 — 가릴 수 없는 것을 고르지 않고 무엇이
+               합쳐졌는지 말한다(정당한 경우가 많으므로 막지 않는다). */
+            const prevContent = existing?.content ?? {};
+            const lm = (0, ingest_space_js_1.collidingIds)(prevContent.landmarks, spaceContent.landmarks);
+            if (lm.length)
+                warnings.push((0, reference_master_js_3.landmarkIdsMerged)(spaceId, lm));
+        }
         /*
          * 공유 공간(여러 트윈이 한 spaceId, N:1) content 병합 — 마지막 인제스트가 통째로 덮어써 area(그룹)·표현이
          * 유실되던 문제 보정. area·landmark 는 id 합집합, representations 는 비어있지 않은 쪽 보존, 나머지는 first-wins.
@@ -971,7 +1072,7 @@ class TwinEngine {
         }
         await this.provision(domainId, master.source, master.system, board);
         if (warnings.length)
-            console.warn(`[twin-engine] ingest "${master.source}" warnings:`, warnings);
+            console.warn(`[twin-engine] ingest "${master.source}" warnings: ${(0, reference_master_js_3.describeWarnings)(warnings)}`);
         return { instanceId: master.source, spaceId, warnings };
     }
     /** 단건 상세 — 프로비저닝 에디터가 편집할 board(구조+layout) 포함. */
@@ -983,7 +1084,7 @@ class TwinEngine {
             instanceId: r.instanceId,
             kind: r.kind,
             status: r.status,
-            running: !!this.instances[r.instanceId],
+            running: !!this.instances[(0, runtime_key_js_1.runtimeKey)(domainId, r.instanceId)],
             realityMode: r.realityMode, // 현실 선언 — what-if 적용 가드용(mirror=예측 전용, 자극 주입 불가)
             board: r.board
         };
@@ -1014,7 +1115,7 @@ class TwinEngine {
         const seen = new Set();
         /* payload 매핑은 순수 함수(buildEntityDeltas)로 분리 — 여기선 시그니처 dedup + 발행만.
          * 변화한 엔티티만 발행(최신-상태 채널이라 무변화 재방송 무의미). */
-        for (const { tag, data } of (0, entity_delta_js_1.buildEntityDeltas)(st)) {
+        for (const { tag, data } of (0, entity_delta_js_1.buildEntityDeltas)(st, inst.id)) {
             seen.add(tag);
             const sig = JSON.stringify(data);
             if (sigs.get(tag) === sig)
@@ -1044,13 +1145,13 @@ class TwinEngine {
         // 라이브 최신(시간여행 아님) + 인메모리 인스턴스 → 라이브 커널 스냅샷을 직접 사용.
         // replay(StateProjector)는 attentions·ack 등 라이브 전용 파생 상태를 담지 못하므로, 최신은 커널 진실을 쓴다.
         if (untilRevision == null && untilTime == null) {
-            const live = this.instances[instanceId];
+            const live = this.instances[(0, runtime_key_js_1.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);
+                return this.snapshot(domainId, instanceId);
         }
         const reg = await (0, shell_1.getRepository)(twin_instance_js_1.TwinInstance).findOne({ where: { domain: { id: domainId }, instanceId } });
         if (!reg?.board)
@@ -1111,16 +1212,61 @@ class TwinEngine {
         const newest = structures[structures.length - 1]?.board;
         if (asOfNow && newest && segments[segments.length - 1]?.board !== newest)
             segments.push({ board: newest, 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 oee_accumulator_js_1.OeeAccumulator();
+        for (const r of wanted) {
+            try {
+                oee.apply(r.payload);
+            }
+            catch {
+                /* 한 건이 이상해도 나머지 계측을 버리지 않는다 — 누적기는 모르는 이벤트를 무시하는 계약이다. */
+            }
+        }
+        const withNow = (st) => {
+            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 = (0, oee_accumulator_js_1.withLiveOee)(based, oee, Number.isFinite(nowMs) ? nowMs : undefined);
+            return (0, live_attentions_js_1.withLiveAttentions)(withMetrics);
+        };
         if (!segments.length)
-            return replay(((asOfNow && newest) || reg.board), []);
+            return withNow(replay(((asOfNow && newest) || reg.board), []));
         if (segments.length === 1)
-            return replay(segments[0].board, segments[0].events);
+            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);
     }
     /**
      * 공간(공동배치) 시각 범위 — 스크러버 앵커(runtime-state-model §4·§6). 그 공간 전 인스턴스 저널의 min/max eventTime.
@@ -1154,12 +1300,12 @@ class TwinEngine {
     static onStop(fn) {
         this.stopHooks.push(fn);
     }
-    static async stop(id) {
-        const i = this.instances[id];
+    static async stop(domainId, id) {
+        const i = this.instances[(0, runtime_key_js_1.runtimeKey)(domainId, id)];
         if (i) {
             clearInterval(i.timer);
             i.unsub();
-            delete this.instances[id];
+            delete this.instances[(0, runtime_key_js_1.runtimeKey)(domainId, id)];
             await (0, shell_1.getRepository)(twin_instance_js_1.TwinInstance)
                 .update({ domain: { id: i.domainId }, instanceId: id }, { status: 'stopped' })
                 .catch(err => console.error('twin deregister fail', err));
@@ -1171,8 +1317,70 @@ class TwinEngine {
             catch { /* 훅 격리 */ }
         }
     }
-    static runtime(id) {
-        return this.instances[id]?.runtime;
+    /*
+     * tick 한 번 — **한 트윈의 예외가 서버를 내리지 못하게** 감싼다.
+     *
+     * 잘못된 시나리오가 실렸을 때 다음 tick 에서 `rate.meanPerHour` 를 읽다 터졌고, 타이머 콜백의
+     * 예외는 아무도 받지 않아 **uncaught exception 으로 프로세스가 내려갔다.** 한 테넌트의 잘못된
+     * 선언이 모든 테넌트를 멈춘 셈이다. 문 앞에서 막는 것이 1차 방벽이고(`validateScenario`),
+     * 이것이 2차 방벽이다.
+     *
+     * **조용히 삼키지 않는다.** 굴리기를 멈추고 그 사실을 남긴다 — 예외를 무시하고 계속 tick 하면
+     * 같은 오류가 매 주기 쏟아지고, 그 트윈은 "도는 것처럼 보이면서" 아무것도 진행하지 않는다.
+     */
+    static tickGuarded(domainId, id, runtime) {
+        try {
+            runtime.tick(this.TICK_MS);
+        }
+        catch (err) {
+            const inst = this.instances[(0, runtime_key_js_1.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, id) {
+        return this.instances[(0, runtime_key_js_1.runtimeKey)(domainId, id)]?.runtime;
+    }
+    /*
+     * 커맨드 실행 — **판정은 `routeCommand`(순수)가 하고 여기서는 실행만** 한다.
+     * 판정을 코드 한가운데 두면 이 부류를 테스트로 못 잡는다(엔진은 DB 를 물고 있어 단위 테스트가
+     * 불러올 수 없다). 예전에는 리졸버가 `inst.runtime.dispatch` 를 곧바로 불러 미러에서 터졌다.
+     */
+    static async dispatchCommand(domainId, instanceId, command) {
+        const inst = this.instances[(0, runtime_key_js_1.runtimeKey)(domainId, instanceId)];
+        const type = String(command?.type ?? '');
+        const route = (0, command_routing_js_1.routeCommand)(inst && { mode: inst.mode, hasRuntime: !!inst.runtime, hasKernelDispatch: typeof inst.kernel?.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 = inst.kernel;
+        const emitted = [];
+        const off = kernel.onEvent?.((e) => emitted.push(e));
+        let ack;
+        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' };
     }
     /**
      * 도메인 소유 게이트 — 인스턴스가 이 도메인 소유일 때만 true(테넌트 격리).
@@ -1180,8 +1388,17 @@ class TwinEngine {
      * this.instances[id] 를 만지기 전에 반드시 이걸로 확인해야 한다. 인스턴스 id 는 추측 가능하므로
      * 검증 없이 접근하면 크로스테넌트 읽기/정지가 가능해진다.
      */
+    /**
+     * 이 런타임의 **관측 모드** — `'live'`(외부 실물을 미러) 또는 `'sim'`(커널이 굴린다). 떠 있지 않으면 없다.
+     *
+     * 소비처가 `instances[id].mode` 를 직접 읽던 자리를 대신한다. 레지스트리를 밖에 열면 도메인 확인이
+     * 자리마다 제각각이 되고, 실제로 그렇게 됐다(테넌트 격리 전수 확인, 2026-08-06).
+     */
+    static modeOf(domainId, id) {
+        return this.instances[(0, runtime_key_js_1.runtimeKey)(domainId, id)]?.mode;
+    }
     static owns(domainId, id) {
-        return this.instances[id]?.domainId === domainId;
+        return !!this.instances[(0, runtime_key_js_1.runtimeKey)(domainId, id)];
     }
     /**
      * 이 트윈이 이 테넌트 것인가 — **떠 있든 아니든.**
@@ -1198,13 +1415,50 @@ class TwinEngine {
             return true;
         return !!(await (0, shell_1.getRepository)(twin_instance_js_1.TwinInstance).findOne({ where: { domain: { id: domainId }, instanceId } }));
     }
+    /**
+     * **이 공간의 인스턴스들** — 한 현실을 여러 렌즈가 비추므로, 공간을 물으면 그 렌즈 전부를 답한다.
+     *
+     * 화면이 이 규칙을 손으로 짜지 않게 서버가 답한다. 예측 화면은 같은 확장을 **한 파일에서 두 번**
+     * 복제하고 있었다(전체 목록을 받아 클라이언트에서 걸렀다) — 규칙이 흩어지면 한쪽만 고쳐진다.
+     *
+     * 떠 있지 않은 것도 포함한다: 공간에 무엇이 있는지는 기동 여부와 다른 사실이다.
+     */
+    static async instanceIdsOfSpace(domainId, spaceId) {
+        if (!spaceId)
+            return [];
+        const rows = await (0, shell_1.getRepository)(twin_instance_js_1.TwinInstance).find({ where: { domain: { id: domainId }, spaceId } });
+        return rows.map(r => r.instanceId).filter((x) => !!x);
+    }
+    /**
+     * **이 공간에서 봐야 할 것** — 공간의 모든 렌즈에서 신호를 모은다.
+     *
+     * 합집합이 그대로 뜻이 있는 유일한 렌즈다(예측은 합칠 수 없다 — P50 두 개를 더할 수 없다).
+     * 정렬·잘라내기는 화면과 **같은 규칙**을 쓴다(`digestAttentions`) — 서버가 고른 상위 N 이 화면이
+     * 고를 N 과 달라지면 그 어긋남은 아무 데서도 오류로 드러나지 않는다.
+     *
+     * 신호마다 어느 트윈에서 왔는지(`instanceId`)를 붙인다. 공간에서 보면 같은 자리 id 가 렌즈마다
+     * 다른 것을 가리킬 수 있고, 조치는 결국 그 트윈에 보내야 한다.
+     */
+    static async attentionsOfSpace(domainId, spaceId, limit) {
+        const ids = await this.instanceIdsOfSpace(domainId, spaceId);
+        const lenses = ids
+            /* 떠 있지 않은 트윈은 **지금** 신호가 없다(그 시절 신호는 시간여행이 답한다). */
+            .filter(id => this.owns(domainId, id))
+            .map(id => {
+            const kernel = this.kernel(domainId, id);
+            const snap = kernel?.getSnapshot?.() ?? this.snapshot(domainId, id);
+            return { instanceId: id, attentions: snap?.attentions ?? [] };
+        });
+        /* 모으는 규칙(태깅·급한 순서·자리 색)은 순수 함수가 들고 있다 — 여기서 손으로 접지 않는다. */
+        return (0, attention_digest_js_1.mergeLensAttentions)(lenses, limit);
+    }
     /** 라이브 커널(ForecastTwin) — forecast/divergence 예측 연산용. */
-    static kernel(id) {
-        return this.instances[id]?.kernel;
+    static kernel(domainId, id) {
+        return this.instances[(0, runtime_key_js_1.runtimeKey)(domainId, id)]?.kernel;
     }
     /** 라이브 처리량 계측 스냅샷(모니터, ④-1) — 내부 누적(_acc*) 제외한 공개 지표. live 아니면 null. */
-    static metrics(id) {
-        const m = this.instances[id]?.metrics;
+    static metrics(domainId, id) {
+        const m = this.instances[(0, runtime_key_js_1.runtimeKey)(domainId, id)]?.metrics;
         if (!m)
             return null;
         return {
@@ -1216,9 +1470,13 @@ class TwinEngine {
     }
     /** 전체 라이브 인스턴스 계측(모니터 대시보드용). */
     static async allMetrics(domainId) {
+        /* 도메인 없이 부르면 전 테넌트를 훑는다(내부 모니터용) — 키에서 도메인을 되돌려 각자에게 묻는다. */
         const rows = Object.keys(this.instances)
-            .filter(id => !domainId || this.instances[id].domainId === domainId)
-            .map(id => this.metrics(id))
+            .filter(key => !domainId || (0, runtime_key_js_1.isOfDomain)(key, domainId))
+            .map(key => {
+            const at = (0, runtime_key_js_1.parseRuntimeKey)(key);
+            return this.metrics(at.domainId, at.instanceId);
+        })
             .filter(Boolean);
         if (!rows.length || !domainId)
             return rows;
@@ -1252,7 +1510,7 @@ class TwinEngine {
         if (!reg?.board)
             return null;
         const Kernel = KERNELS[reg.kind ?? 'wms'] ?? WmsKernel;
-        const k = new Kernel(domainId, undefined, this.mesSpecOf(reg.board));
+        const k = new Kernel(domainId, undefined, this.productionSpecOf(reg.board));
         k.loadBoard(reg.board);
         this.applyOperations(k, reg.board, instanceId); // 예측도 같은 명세로 굴러야 한다(화면과 다른 숫자 금지)
         await this.installEstimators(k, domainId, instanceId, reg.board); // 예측은 기다린다 — 실측을 놓치면 예측이 상수로 돈다
@@ -1273,8 +1531,8 @@ class TwinEngine {
         return k;
     }
     /** 현재 전체 스냅샷 — 라이브 우선, 없으면 저널 복구 캐시. */
-    static snapshot(id) {
-        const inst = this.instances[id];
+    static snapshot(domainId, id) {
+        const inst = this.instances[(0, runtime_key_js_1.runtimeKey)(domainId, id)];
         if (inst?.mode === 'live' && inst.projector) {
             /* live: **커널이 주목 신호를 스스로 낸다**(관측 모드) — 호스트가 덧붙이던 withLiveAttentions 는
              * 필요 없다. OEE 만 호스트가 채운다: 원 시스템이 시간 누적을 보내 주지 않아 상태 전이를 적분해
@@ -1282,7 +1540,7 @@ class TwinEngine {
             const st = inst.projector.snapshot();
             return inst.oee ? (0, oee_accumulator_js_1.withLiveOee)(st, inst.oee) : st;
         }
-        return inst?.runtime?.resync() ?? this.recovered[id];
+        return inst?.runtime?.resync() ?? this.recovered[(0, runtime_key_js_1.runtimeKey)(domainId, id)];
     }
 }
 exports.TwinEngine = TwinEngine;