@operato/twin-kernel 0.2.2 → 0.3.0

package/dist/flow-engine.js

@@ -1,15 +1,15 @@
 /*
  * FlowEngine — 도메인-일반 flow 엔진 base (WMS·YMS 공유 mechanics 추출).
  *
- * WMS/YMS 커널의 mechanics(RNG·clock·scenario·tick 루프·무버 배정·태스크 진행·emit·snapshot·
+ * WMS/YMS 커널의 mechanics(RNG·clock·scenario·tick 루프·설비 배정·태스크 진행·emit·snapshot·
  * slotViews)는 동일했다 → 이 base 로 승격. 도메인 kernel 은 **flow 동사만** 구현:
  *   onArrival(자극:입고 도착) · onOrder(자극:출고 오더) · allocate(오더→태스크) · onTaskComplete(태스크 완료)
  *
  * TwinKernel 구현 → StateProjector·TwinRuntime 가 도메인 무관하게 소비.
  * 통합 타입은 도메인 필드를 옵셔널로 넓혀(FlowItem.gtin?, FlowOrder.shipmentEpc? 등) 두 도메인을 담는다.
- * (roadmap Phase5 발견 → 추출. [[project_flow_single_base_vision]] FlowNode 단일 base 방향과 정합.)
+ * (roadmap Phase5 발견 → 추출. [[project_flow_single_base_vision]] FlowLocation 단일 base 방향과 정합.)
  */
-import { OP_EVENT, CMD, nodeStatusOf } from "./contract.js";
+import { OP_EVENT, CMD, locationStatusOf, readBoardEquipment, readBoardLocations, readBoardAssets, classClosure } from "./contract.js";
 import { ObservedReducer } from "./observed-reducer.js";
 import { transformationEvent, aggregationEvent, objectEvent, parseEpc, DISP, ILMD_ATTR } from "./epcis.js";
 import { parseIsoDuration } from "./iso-duration.js";
@@ -26,7 +26,7 @@ function mulberry32(seed) {
     return fn;
 }
 /**
- * 주목신호 계산(순수) — State 스냅샷(movers/nodes/orders)에서 attentions 파생.
+ * 주목신호 계산(순수) — State 스냅샷(equipment/locations/orders)에서 attentions 파생.
  * FlowEngine.computeAttentions(sim) 와 live projector 미러가 **공유**하는 계산 층(face2-inbound-live §1.1):
  * sim/live 가 같은 임계값·규칙을 쓴다. good/scrap 미제공(관측 상태에 없음)이면 scrap-high 는 자연 스킵(metric 층 갭).
  */
@@ -34,12 +34,12 @@ export function deriveAttentions(view, acked) {
     // 언어 중립: kind + params(원시값) + 조치 code 만 방출. 사람이 읽는 title/detail/rationale/라벨은
     // 표현계층(클라 i18next)이 kind/code 로 렌더한다(무방언·다국어 — design/plans/i18n.md L3).
     const out = [];
-    for (const m of view.movers) {
+    for (const m of view.equipment) {
         if (m.status === 'down') {
             out.push({
                 id: `breakdown:${m.id}`, kind: 'breakdown', severity: 'critical',
-                anchor: { moverId: m.id, nodeId: m.location },
-                params: { moverId: m.id, ...(m.location ? { nodeId: m.location } : {}) },
+                anchor: { moverId: m.id, locationId: m.location },
+                params: { moverId: m.id, ...(m.location ? { locationId: m.location } : {}) },
                 recommendedActions: [
                     { code: 'act.repair', command: CMD.resourceRepair, args: { resourceId: m.id } },
                     { code: 'act.hold-until-repair', command: CMD.resourceHold, args: { resourceId: m.id } }
@@ -48,29 +48,29 @@ export function deriveAttentions(view, acked) {
             });
         }
     }
-    for (const n of view.nodes) {
+    for (const n of view.locations) {
         if ((n.capacity ?? 0) > 0) {
             const r = (n.occupancy ?? 0) / n.capacity;
             if (r >= 0.9) {
                 const saturated = r >= 1;
                 out.push({
                     id: `bottleneck:${n.id}`, kind: 'bottleneck', severity: saturated ? 'high' : 'medium',
-                    anchor: { nodeId: n.id },
-                    params: { nodeId: n.id, occupancy: n.occupancy ?? 0, capacity: n.capacity ?? 0, ratioPct: Math.round(r * 100), saturated: saturated ? 1 : 0 },
+                    anchor: { locationId: n.id },
+                    params: { locationId: n.id, occupancy: n.occupancy ?? 0, capacity: n.capacity ?? 0, ratioPct: Math.round(r * 100), saturated: saturated ? 1 : 0 },
                     recommendedActions: [{ code: 'advice.add-resource' }, { code: 'advice.downstream-priority' }]
                     // 권고만(command 없음) — 표현계층이 advice.* 코드로 렌더
                 });
             }
         }
     }
-    for (const m of view.movers) {
+    for (const m of view.equipment) {
         const total = (m.goodCount ?? 0) + (m.scrapCount ?? 0);
         if (total >= 10) {
             const rate = (m.scrapCount ?? 0) / total;
             if (rate >= 0.15)
                 out.push({
                     id: `scrap:${m.id}`, kind: 'scrap-high', severity: rate >= 0.3 ? 'high' : 'medium',
-                    anchor: { moverId: m.id, nodeId: m.location },
+                    anchor: { moverId: m.id, locationId: m.location },
                     params: { moverId: m.id, goodCount: m.goodCount ?? 0, scrapCount: m.scrapCount ?? 0, ratePct: Math.round(rate * 100) },
                     recommendedActions: [
                         { code: 'act.hold-for-inspection', command: CMD.resourceHold, args: { resourceId: m.id } },
@@ -115,9 +115,11 @@ export function computeOee(c, nowMs) {
 }
 export class FlowEngine {
     tenantId;
-    nodes = new Map();
+    locations = new Map();
     items = new Map();
-    movers = new Map();
+    equipment = new Map();
+    /** 등급 정의(표준 `<X>Class`) — 상속·유효기간 판정의 재료. 선언 안 하면 비어 있고, 소속 그대로 판정한다. */
+    classDefs = {};
     /** 사람 — 선언하지 않으면 빈 맵(인원 제약 없는 트윈, 기존 거동). */
     persons = new Map();
     /** 물리 자산 — 선언하지 않으면 빈 맵(자산 제약 없는 트윈, 기존 거동). */
@@ -164,50 +166,51 @@ export class FlowEngine {
     // ── TwinKernel (mechanics, 도메인 무관) ───────────────────────────────────
     loadBoard(def) {
         this.boardDef = def;
-        for (const n of def.nodes)
-            this.nodes.set(n.id, { id: n.id, type: n.type, capacity: n.capacity, parallelism: n.parallelism, occupancy: 0, status: 'idle', parentId: n.parentId });
+        for (const n of readBoardLocations(def))
+            this.locations.set(n.id, { id: n.id, type: n.type, capacity: n.capacity, parallelism: n.parallelism, occupancy: 0, status: 'idle', parentId: n.parentId });
+        this.classDefs = { personnel: def.personnelClasses, equipment: def.equipmentClasses, asset: def.assetClasses };
         for (const p of def.persons ?? [])
-            this.persons.set(p.id, { id: p.id, personnelClass: p.personnelClass, status: 'idle', taskId: null, window: p.window });
-        for (const a of def.assets ?? [])
-            this.assets.set(a.id, { id: a.id, assetClass: a.assetClass, location: a.homeNode, status: 'idle', taskId: null });
-        for (const m of def.movers) {
-            const mover = { id: m.id, kind: m.kind, location: m.homeNode, status: 'idle', taskId: null, runMs: 0, setupMs: 0, downMs: 0, goodCount: 0, scrapCount: 0, window: m.window };
+            this.persons.set(p.id, { id: p.id, personnelClassIds: p.personnelClassIds, status: 'idle', taskId: null, window: p.window, ...(p.homeLocation ? { location: p.homeLocation } : {}), ...(p.properties ? { properties: p.properties } : {}), ...(p.testSpecificationIds ? { testSpecificationIds: p.testSpecificationIds } : {}) });
+        for (const a of readBoardAssets(def))
+            this.assets.set(a.id, { id: a.id, assetClassIds: a.assetClassIds, location: a.homeLocation, status: 'idle', taskId: null, ...(a.properties ? { properties: a.properties } : {}), ...(a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {}) });
+        for (const m of readBoardEquipment(def)) {
+            const eq = { id: m.id, kind: m.kind, location: m.homeLocation, homeLocation: m.homeLocation, ...(m.properties ? { properties: m.properties } : {}), ...(m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}), status: 'idle', taskId: null, runMs: 0, setupMs: 0, downMs: 0, goodCount: 0, scrapCount: 0, window: m.window };
             if (m.mtbfMs !== undefined) {
-                mover.mtbfMs = m.mtbfMs;
-                mover.mttrMs = m.mttrMs;
-                mover.nextFailureMs = this.sampleExp(m.mtbfMs);
+                eq.mtbfMs = m.mtbfMs;
+                eq.mttrMs = m.mttrMs;
+                eq.nextFailureMs = this.sampleExp(m.mtbfMs);
             }
-            this.movers.set(m.id, mover);
+            this.equipment.set(m.id, eq);
         }
     }
     /**
-     * what-if 구성 변주 — fork(또는 실행 중) 엔진에 무버 추가. loadBoard 무버 삽입과 동일 규약.
+     * what-if 구성 변주 — fork(또는 실행 중) 엔진에 설비 추가. loadBoard 설비 삽입과 동일 규약.
      * 기본은 mtbf 미지정(고장 없는 신뢰 자원) → sampleExp(rng) 무소비라 baseline fork 와 깨끗이 비교 가능.
      */
-    addMover(m) {
-        if (this.movers.has(m.id))
+    addEquipment(m) {
+        if (this.equipment.has(m.id))
             return;
-        const mover = { id: m.id, kind: m.kind, location: m.homeNode, status: 'idle', taskId: null, runMs: 0, setupMs: 0, downMs: 0, goodCount: 0, scrapCount: 0 };
+        const eq = { id: m.id, kind: m.kind, location: m.homeLocation, homeLocation: m.homeLocation, ...(m.properties ? { properties: m.properties } : {}), ...(m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}), status: 'idle', taskId: null, runMs: 0, setupMs: 0, downMs: 0, goodCount: 0, scrapCount: 0 };
         if (m.mtbfMs !== undefined) {
-            mover.mtbfMs = m.mtbfMs;
-            mover.mttrMs = m.mttrMs;
-            mover.nextFailureMs = this.sampleExp(m.mtbfMs);
+            eq.mtbfMs = m.mtbfMs;
+            eq.mttrMs = m.mttrMs;
+            eq.nextFailureMs = this.sampleExp(m.mtbfMs);
         }
-        this.movers.set(m.id, mover);
+        this.equipment.set(m.id, eq);
     }
     /**
-     * 관측 상태 주입(라이브 예측용, kernel-unification P1) — 외부 관측 스냅샷(재고·무버·노드)과
+     * 관측 상태 주입(라이브 예측용, kernel-unification P1) — 외부 관측 스냅샷(재고·설비·자리)과
      * 저널 오더(원값+라인)로 이 커널의 맵을 채운다. tick 으로 만든 게 아니라 "현재 관측된 현실"을 심어
      * 이후 fork/tick 으로 예측한다. 라이브 런타임은 여전히 projector 미러 — 이 커널은 예측용 임시본.
      * 오더는 남은 데맨드(라인별 requested-fulfilled)를 'created' 로 복원(현재 재고에서 재계획).
      * 진행 중 개별 task 의 내부 상태는 관측만으론 복원 불가 → 재계획에 맡김(정직한 한계).
      */
     hydrateObserved(snap, orders = []) {
-        /* **관측된 것을 버리지 않는다.** 예전에는 노드·무버 상태를 'idle' 로, OEE 누적을 0 으로 덮고
+        /* **관측된 것을 버리지 않는다.** 예전에는 자리·설비 상태를 'idle' 로, OEE 누적을 0 으로 덮고
          * 물품의 로트·단위·소속·마스터데이터를 떨어뜨렸다. 씨앗이 잃은 것은 **예측도 모른다** —
          * 고장 난 설비를 정상으로, 진행 중인 일을 없는 것으로 놓고 미래를 굴리면 답이 낙관 쪽으로 치우친다. */
-        for (const n of snap.nodes) {
-            this.nodes.set(n.id, { id: n.id, type: n.type, capacity: n.capacity ?? 0, parallelism: n.parallelism, occupancy: n.occupancy ?? 0, status: n.status ?? 'idle', parentId: n.parentId });
+        for (const n of snap.locations) {
+            this.locations.set(n.id, { id: n.id, type: n.type, capacity: n.capacity ?? 0, parallelism: n.parallelism, occupancy: n.occupancy ?? 0, status: n.status ?? 'idle', parentId: n.parentId });
         }
         this.items.clear();
         for (const it of snap.items) {
@@ -218,7 +221,7 @@ export class FlowEngine {
                 parent: it.parent, carriedBy: it.carriedBy, expiry: it.expiry, ilmd: it.ilmd
             });
         }
-        for (const m of snap.movers) {
+        for (const m of snap.equipment) {
             /*
              * 관측된 계측을 이어받는다 — **없어서 0 이었던 게 아니라 잘못 읽어서 0 이었다.**
              * `OeeMetrics` 의 이름은 `runMs`·`setupMs`·`downMs`·`goodCount`·`scrapCount` 인데 예전 코드가
@@ -231,8 +234,8 @@ export class FlowEngine {
              * 값을 그대로 이어받고, 없으면 0 에서 시작한다(꾸미지 않는다).
              */
             const oee = m.oee;
-            this.movers.set(m.id, {
-                id: m.id, kind: m.kind, location: m.location ?? '', status: m.status ?? 'idle', taskId: null,
+            this.equipment.set(m.id, {
+                id: m.id, kind: m.kind, location: m.location ?? '', ...(m.homeLocation ? { homeLocation: m.homeLocation } : {}), status: m.status ?? 'idle', taskId: null,
                 runMs: oee?.runMs ?? 0, setupMs: oee?.setupMs ?? 0, downMs: oee?.downMs ?? 0,
                 goodCount: oee?.goodCount ?? 0, scrapCount: oee?.scrapCount ?? 0
             });
@@ -241,11 +244,11 @@ export class FlowEngine {
          * 씨앗이 버리면, 인원을 요구하는 공정의 작업이 하나도 시작되지 못하고 예측이 멈춘다(0 명 < 2 명).
          * 배정 상태(busy/taskId)는 아래 작업 복원이 다시 세우므로 여기서는 등급·교대만 살린다. */
         for (const p of snap.persons ?? []) {
-            this.persons.set(p.id, { id: p.id, personnelClass: p.personnelClass, status: 'idle', taskId: null });
+            this.persons.set(p.id, { id: p.id, personnelClassIds: p.personnelClassIds, status: 'idle', taskId: null });
         }
         /* 자산도 같다 — 잃으면 자산을 요구하는 작업이 영원히 못 나간다(빈 팔레트 0개 < 1개). */
         for (const a of snap.assets ?? []) {
-            this.assets.set(a.id, { id: a.id, assetClass: a.assetClass, location: a.location, status: 'idle', taskId: null, carrying: a.carrying });
+            this.assets.set(a.id, { id: a.id, assetClassIds: a.assetClassIds, location: a.location, status: 'idle', taskId: null, carrying: a.carrying });
         }
         /* 진행 중이던 작업을 이어 붙인다 — 없으면 예측이 "일이 하나도 없는 현장" 에서 출발한다.
          * 남은 시간을 모르면 **진척을 꾸미지 않고** 미착수(created)로 되돌린다: 그 일이 남아 있다는 사실은
@@ -268,7 +271,7 @@ export class FlowEngine {
             });
             /* 진행 중으로 살린 작업은 그 자원을 점유한 상태여야 한다(자원이 동시에 다른 일을 받지 않게). */
             if (known && t.status === 'in-progress' && t.resourceRef) {
-                const mv = this.movers.get(t.resourceRef);
+                const mv = this.equipment.get(t.resourceRef);
                 if (mv) {
                     mv.status = 'busy';
                     mv.taskId = t.id;
@@ -303,9 +306,9 @@ export class FlowEngine {
             this.orders.set(o.orderId, { id: o.orderId, kind: o.kind, status: 'created', requested: remaining, fulfilled: 0, bizTransaction: '', allocated: [], picked: [], shipmentEpc: null, lines });
         }
     }
-    /** what-if 구성 변주 — 노드 용량 변경(fork 대상). 존재하면 true. */
-    setNodeCapacity(nodeId, capacity) {
-        const n = this.nodes.get(nodeId);
+    /** what-if 구성 변주 — 자리 용량 변경(fork 대상). 존재하면 true. */
+    setLocationCapacity(locationId, capacity) {
+        const n = this.locations.get(locationId);
         if (!n)
             return false;
         n.capacity = Math.max(0, capacity);
@@ -351,30 +354,30 @@ export class FlowEngine {
                     this._acked.add(id);
                 return ok();
             }
-            // Operable 코어 — 자원(설비·무버) 제어. capability-keyed(resourceId), 모든 operable 자원 공통.
+            // Operable 코어 — 자원(설비·설비) 제어. capability-keyed(resourceId), 모든 operable 자원 공통.
             case CMD.resourceHold:
             case CMD.resourceResume: {
-                const m = this.movers.get(cmd.args?.resourceId ?? '');
+                const m = this.equipment.get(cmd.args?.resourceId ?? '');
                 if (!m)
                     return fail('resource-not-found');
                 m.held = cmd.type === CMD.resourceHold; // 계획 정지 → 배정 스킵
-                this.emitMover(m);
+                this.emitEquipment(m);
                 return ok();
             }
             case CMD.resourceDown: {
                 const a = cmd.args;
-                const m = this.movers.get(a?.resourceId ?? '');
+                const m = this.equipment.get(a?.resourceId ?? '');
                 if (!m)
                     return fail('resource-not-found');
                 if (m.status !== 'down') {
                     m.status = 'down'; // 비계획 고장 주입 — 기존 고장 machinery(processFailures)가 downMs 누적·수리 처리
                     m.repairUntilMs = this.clockMs + (Number(a?.durationMs) || m.mttrMs || 60_000);
-                    this.emitMover(m);
+                    this.emitEquipment(m);
                 }
                 return ok();
             }
             case CMD.resourceRepair: {
-                const m = this.movers.get(cmd.args?.resourceId ?? '');
+                const m = this.equipment.get(cmd.args?.resourceId ?? '');
                 if (!m)
                     return fail('resource-not-found');
                 if (m.status === 'down') {
@@ -382,12 +385,12 @@ export class FlowEngine {
                     m.repairUntilMs = undefined;
                     if (m.mtbfMs !== undefined)
                         m.nextFailureMs = this.clockMs + this.sampleExp(m.mtbfMs);
-                    this.emitMover(m);
+                    this.emitEquipment(m);
                 }
                 return ok();
             }
             case CMD.resourceResetMetrics: {
-                const m = this.movers.get(cmd.args?.resourceId ?? '');
+                const m = this.equipment.get(cmd.args?.resourceId ?? '');
                 if (!m)
                     return fail('resource-not-found');
                 m.runMs = 0;
@@ -397,27 +400,27 @@ export class FlowEngine {
                 m.scrapCount = 0;
                 m.holdMs = 0;
                 m.metricsSinceMs = this.clockMs; // 계측 창을 지금부터 재시작
-                this.emitMover(m);
+                this.emitEquipment(m);
                 return ok();
             }
             case CMD.resourceAdd: {
-                // 라이브 자원 추가(실제 act) — addMover(what-if 와 동일 경로)로 런타임에 무버 삽입 + equipment 델타 방출.
-                // 새 무버는 즉시 배정 대상(다음 tick). 유일 id 생성(충돌 회피). 좌표/persistence 는 호스트 몫(커널=위상만).
+                // 라이브 자원 추가(실제 act) — addEquipment(what-if 와 동일 경로)로 런타임에 설비 삽입 + equipment 델타 방출.
+                // 새 설비는 즉시 배정 대상(다음 tick). 유일 id 생성(충돌 회피). 좌표/persistence 는 호스트 몫(커널=위상만).
                 const a = cmd.args;
                 if (!a?.kind)
                     return fail('kind-required');
-                if (!a?.homeNode || !this.nodes.has(a.homeNode))
-                    return fail('home-node-not-found', { homeNode: a?.homeNode ?? '' });
+                if (!a?.homeLocation || !this.locations.has(a.homeLocation))
+                    return fail('home-location-not-found', { homeLocation: a?.homeLocation ?? '' });
                 const count = Math.max(1, Math.min(50, Number(a.count) || 1));
-                let seq = this.movers.size;
+                let seq = this.equipment.size;
                 for (let i = 0; i < count; i++) {
                     let id = `${a.kind}-${++seq}`;
-                    while (this.movers.has(id))
+                    while (this.equipment.has(id))
                         id = `${a.kind}-${++seq}`;
-                    this.addMover({ id, kind: a.kind, homeNode: a.homeNode });
-                    const m = this.movers.get(id);
+                    this.addEquipment({ id, kind: a.kind, homeLocation: a.homeLocation });
+                    const m = this.equipment.get(id);
                     if (m)
-                        this.emitMover(m); // equipment.status 델타 → 상태/저널에 새 무버 반영
+                        this.emitEquipment(m); // equipment.status 델타 → 상태/저널에 새 설비 반영
                 }
                 return ok();
             }
@@ -462,28 +465,38 @@ export class FlowEngine {
             simClockMs: this.clockMs,
             /* 출처 표시 — 보드(마스터)에서 온 자리다. 미러는 관측으로 알게 된 자리를 'observed' 로 구별하는데,
              * 시뮬이 아무 표시도 안 하면 소비처가 두 스냅샷을 같은 규칙으로 읽지 못한다. */
-            nodes: [...this.nodes.values()].map(n => {
+            locations: [...this.locations.values()].map(n => {
                 const { status, ...rest } = n;
                 /* 상태는 저장값이 아니라 포화도 파생 — 미러와 **같은 함수**를 쓴다(규칙이 둘이면 갈라진다). */
-                const derived = nodeStatusOf(n);
+                const derived = locationStatusOf(n);
                 return { ...rest, ...(derived ? { status: derived } : {}), origin: 'master' };
             }),
             items: [...this.items.values()].map(i => this.itemState(i)),
-            movers: [...this.movers.values()].map(m => {
-                const s = { id: m.id, kind: m.kind, location: m.location, status: m.status, taskId: m.taskId ?? undefined, oee: this.oeeOf(m), held: m.held, origin: 'master', ...(this.offShift(m) ? { offShift: true } : {}) };
+            equipment: [...this.equipment.values()].map(m => {
+                const s = { id: m.id, kind: m.kind, location: m.location, ...(m.homeLocation ? { homeLocation: m.homeLocation } : {}), status: m.status, taskId: m.taskId ?? undefined, oee: this.oeeOf(m), held: m.held, ...(m.properties ? { properties: m.properties } : {}), ...(m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}), origin: 'master', ...(this.offShift(m) ? { offShift: true } : {}) };
                 const t = m.taskId ? this.tasks.get(m.taskId) : undefined;
                 if (t && t.status === 'in-progress' && t.intent !== 'process')
                     s.motion = { fromNode: t.fromNode, toNode: t.toNode, startedAtSimMs: this.clockMs - (t.durationMs - t.remainingMs), durationMs: t.durationMs, progress: this.progressOf(t), elapsedMs: t.durationMs - t.remainingMs };
                 return s;
             }),
             assets: [...this.assets.values()].map(a => {
-                const st = { id: a.id, assetClass: a.assetClass, location: a.location, status: a.status, taskId: a.taskId ?? undefined };
+                const st = { id: a.id, assetClassIds: a.assetClassIds, location: a.location, status: a.status, taskId: a.taskId ?? undefined };
                 if (a.carrying)
                     st.carrying = a.carrying;
+                if (a.properties)
+                    st.properties = a.properties;
+                if (a.testSpecificationIds)
+                    st.testSpecificationIds = a.testSpecificationIds;
                 return st;
             }),
             persons: [...this.persons.values()].map(p => {
-                const st = { id: p.id, personnelClass: p.personnelClass, status: p.status, taskId: p.taskId ?? undefined };
+                const st = { id: p.id, personnelClassIds: p.personnelClassIds, status: p.status, taskId: p.taskId ?? undefined };
+                if (p.location)
+                    st.location = p.location;
+                if (p.properties)
+                    st.properties = p.properties;
+                if (p.testSpecificationIds)
+                    st.testSpecificationIds = p.testSpecificationIds;
                 if (this.personOffShift(p))
                     st.offShift = true;
                 return st;
@@ -512,13 +525,13 @@ export class FlowEngine {
         };
     }
     /*
-     * 주목 신호 판단 — 상태(노드·무버·오더)에서 도메인 조건을 평가해 Attention 방출.
+     * 주목 신호 판단 — 상태(자리·설비·오더)에서 도메인 조건을 평가해 Attention 방출.
      * severity=ISA-18.2 우선순위 계열, kind=도메인 라벨. UI 는 판단 안 함(임계값 여기 소유).
      * 도메인별 추가 판단은 서브클래스가 override 로 확장(super.computeAttentions() 합성).
      */
     computeAttentions() {
         // 계산 층은 순수 함수 deriveAttentions 로 위임 — sim(여기)과 live projector 미러가 공유(face2-inbound-live §1.1).
-        const out = deriveAttentions({ movers: [...this.movers.values()], nodes: [...this.nodes.values()], orders: [...this.orders.values()] }, this._acked);
+        const out = deriveAttentions({ equipment: [...this.equipment.values()], locations: [...this.locations.values()], orders: [...this.orders.values()] }, this._acked);
         // 확인(ack) 프루닝 — 사라진 조건은 ack 해제(재발 시 다시 active). 엔진 상태 변이라 여기 유지(marking 은 deriveAttentions).
         const present = new Set(out.map(a => a.id));
         for (const id of [...this._acked])
@@ -577,7 +590,7 @@ export class FlowEngine {
      */
     apply(envelope) {
         if (!this.observer) {
-            this.observer = new ObservedReducer(this.boardDef ?? { nodes: [], movers: [] });
+            this.observer = new ObservedReducer(this.boardDef ?? { locations: [], equipment: [] });
             this.observeMode = true;
         }
         this.observer.apply(envelope);
@@ -754,8 +767,8 @@ export class FlowEngine {
         }
         return mix[mix.length - 1].gtin;
     }
-    nodeByType(type) {
-        for (const n of this.nodes.values())
+    locationByType(type) {
+        for (const n of this.locations.values())
             if (n.type === type)
                 return n;
         return undefined;
@@ -764,7 +777,7 @@ export class FlowEngine {
      * process 변화 대수(EPCIS TransformationEvent · ISA-95 Material Consumed/Produced · 씬 Processable.transform).
      * inputs 소비 → outputs 생산. 입출력 arity 가 곧 대수:
      *   merge N→1(조립) · split 1→N(분해) · transform 1→1(타입변경) · loss N→0(소실) · gain 0→N(부산물·생성).
-     * 아이템 상태(소비/생산)와 노드 점유를 갱신하고 계보(TransformationEvent)를 방출한다.
+     * 아이템 상태(소비/생산)와 자리 점유를 갱신하고 계보(TransformationEvent)를 방출한다.
      * 도메인은 이 원시만 호출 — onTaskComplete 의 소비/생산/EPCIS 손코딩을 대체.
      */
     transform(inputs, outputs, opts) {
@@ -772,14 +785,14 @@ export class FlowEngine {
             const it = this.items.get(epc);
             if (!it)
                 continue;
-            const n = this.nodes.get(it.location);
+            const n = this.locations.get(it.location);
             if (n)
                 n.occupancy--;
             this.items.delete(epc);
         }
         for (const o of outputs) {
             this.items.set(o.epc, { epc: o.epc, gtin: o.gtin, qty: o.qty, location: o.location, disposition: o.disposition });
-            const n = this.nodes.get(o.location);
+            const n = this.locations.get(o.location);
             if (n)
                 n.occupancy++;
         }
@@ -849,7 +862,7 @@ export class FlowEngine {
             for (const c of children) {
                 const it = this.items.get(c);
                 if (it) {
-                    const n = this.nodes.get(it.location);
+                    const n = this.locations.get(it.location);
                     if (n)
                         n.occupancy--;
                     this.items.delete(c);
@@ -867,7 +880,7 @@ export class FlowEngine {
     }
     /**
      * containment 분해(EPCIS AggregationEvent DELETE) — 부모(용기)에서 자식들을 풀어냄.
-     * materialize 지정 시 자식이 독립 아이템으로 등장(materialize: 노드 배치 + occupancy + ObjectEvent ADD).
+     * materialize 지정 시 자식이 독립 아이템으로 등장(materialize: 자리 배치 + occupancy + ObjectEvent ADD).
      * 미지정 시 이벤트만.
      */
     disaggregate(parent, children, opts) {
@@ -882,7 +895,7 @@ export class FlowEngine {
             const m = opts.materialize;
             for (const c of children) {
                 this.items.set(c, { epc: c, location: m.location, disposition: m.disposition });
-                const n = this.nodes.get(m.location);
+                const n = this.locations.get(m.location);
                 if (n)
                     n.occupancy++;
                 this.emit(objectEvent({ eventTime: this.now(), action: 'ADD', bizStep: opts.bizStep, disposition: m.disposition, epcList: [c], readPoint: m.location, bizLocation: m.location }));
@@ -891,7 +904,7 @@ export class FlowEngine {
     }
     /** 품질 보고(OEE Quality) — 도메인이 완료 시 자원별 양품/불량 1건 계상(예: 용접 수율). */
     recordOutput(moverId, good) {
-        const m = moverId ? this.movers.get(moverId) : undefined;
+        const m = moverId ? this.equipment.get(moverId) : undefined;
         if (!m)
             return;
         if (good)
@@ -901,20 +914,20 @@ export class FlowEngine {
         // 품질 델타 방출 — live OEE 누적기가 good/scrap 을 정확 추적(equipment.status 는 quality 미포함). WMS/YMS 는 미호출→무영향.
         this.emitOp(OP_EVENT.quality, { moverId: m.id, good, goodCount: m.goodCount, scrapCount: m.scrapCount });
     }
-    /** 무버 OEE(스냅샷 파생) — Availability×Performance×Quality. planned = 설비 존재 sim 시간(clockMs). */
+    /** 설비 OEE(스냅샷 파생) — Availability×Performance×Quality. planned = 설비 존재 sim 시간(clockMs). */
     oeeOf(m) {
         // 순수 공식 computeOee 로 위임 — sim(여기)과 live 가 같은 계산 층 공유. planned 는 hold 제외(계획정지 OEE 무영향).
         return computeOee(m, this.clockMs);
     }
-    /** 정책에 넘길 특정 타입 노드의 관측 뷰 — 예약(그 노드로 향하는 in-flight task) 포함. */
-    slotViews(nodeType) {
+    /** 정책에 넘길 특정 타입 자리의 관측 뷰 — 예약(그 자리로 향하는 in-flight task) 포함. */
+    slotViews(locationType) {
         const reserved = new Map();
         for (const t of this.tasks.values())
             if (t.status !== 'completed')
                 reserved.set(t.toNode, (reserved.get(t.toNode) ?? 0) + 1);
         const views = [];
-        for (const n of this.nodes.values())
-            if (n.type === nodeType)
+        for (const n of this.locations.values())
+            if (n.type === locationType)
                 views.push({ id: n.id, capacity: n.capacity, occupancy: n.occupancy, reserved: reserved.get(n.id) ?? 0 });
         return views;
     }
@@ -953,15 +966,15 @@ export class FlowEngine {
     }
     /** 사람 상태 전이 — 설비와 별개 채널(어휘가 다르다: 고장이 아니라 교대·투입). */
     emitAsset(a) {
-        this.emitOp(OP_EVENT.asset, { assetId: a.id, assetClass: a.assetClass, status: a.status, location: a.location, taskId: a.taskId ?? undefined, carrying: a.carrying });
+        this.emitOp(OP_EVENT.asset, { assetId: a.id, assetClassIds: a.assetClassIds, status: a.status, location: a.location, taskId: a.taskId ?? undefined, carrying: a.carrying });
     }
     emitPerson(p) {
-        this.emitOp(OP_EVENT.person, { personId: p.id, personnelClass: p.personnelClass, status: p.status, taskId: p.taskId ?? undefined, ...(this.personOffShift(p) ? { offShift: true } : {}) });
+        this.emitOp(OP_EVENT.person, { personId: p.id, personnelClassIds: p.personnelClassIds, status: p.status, taskId: p.taskId ?? undefined, ...(p.location ? { location: p.location } : {}), ...(this.personOffShift(p) ? { offShift: true } : {}) });
     }
     /** 설비 상태 전이 — `taskId` 를 함께 싣는다(사람·자산 델타와 같은 규칙). 없으면 미러가 "이 설비가
      *  무슨 일을 하는 중인가" 를 알 수 없어 작업↔자원 연결이 한쪽에서만 성립한다. */
-    emitMover(m, motion) {
-        this.emitOp(OP_EVENT.equipment, { moverId: m.id, kind: m.kind, status: m.status, location: m.location, taskId: m.taskId ?? undefined, motion });
+    emitEquipment(m, motion) {
+        this.emitOp(OP_EVENT.equipment, { moverId: m.id, kind: m.kind, status: m.status, location: m.location, ...(m.homeLocation ? { homeLocation: m.homeLocation } : {}), taskId: m.taskId ?? undefined, motion });
     }
     /** 오더 델타 — **라인까지 싣는다.** 라인이 빠지면 미러가 남은 데맨드를 라인별로 재계획할 수 없다. */
     emitOrder(o) {
@@ -1041,7 +1054,12 @@ export class FlowEngine {
             const want = Math.max(0, Math.floor(req.quantity ?? 0));
             if (!want)
                 continue;
-            const avail = [...this.assets.values()].filter(a => a.status === 'idle' && !picked.includes(a.id) && (req.assetClass === undefined || a.assetClass === req.assetClass));
+            const avail = [...this.assets.values()].filter(
+            /* 인원과 같은 규칙 — 상속을 타고 닫아 판정하고 유효기간 밖은 제외한다. 요구는 등급 하나+수량. */
+            a => a.status === 'idle' &&
+                !picked.includes(a.id) &&
+                (req.assetClass === undefined ||
+                    classClosure(a.assetClassIds, this.classDefs.asset, this.now()).has(req.assetClass)));
             if (avail.length < want)
                 return null;
             for (let i = 0; i < want; i++)
@@ -1110,7 +1128,11 @@ export class FlowEngine {
             const avail = [...this.persons.values()].filter(p => p.status === 'idle' &&
                 !picked.includes(p.id) &&
                 !this.personOffShift(p) &&
-                (req.personnelClass === undefined || p.personnelClass === req.personnelClass));
+                /* 자격은 **상속을 타고 닫아** 판정한다 — 사람은 여러 등급에 속할 수 있고(표준), 등급은
+                   다른 등급을 상속한다. "생산직 2명" 요구를 "용접 자격자" 가 만족해야 한다.
+                   유효기간 밖의 등급은 닫힘에서 빠진다(만료된 자격으로 배정되지 않는다). */
+                (req.personnelClass === undefined ||
+                    classClosure(p.personnelClassIds, this.classDefs.personnel, this.now()).has(req.personnelClass)));
             if (avail.length < want)
                 return null; // 한 등급이라도 모자라면 시작하지 않는다
             for (let i = 0; i < want; i++)
@@ -1124,7 +1146,14 @@ export class FlowEngine {
      * 여기서는 고르기만 한다 — 확정은 호출부가 다른 자원까지 확보한 뒤에 한다.
      */
     claimEquipment(t) {
-        const free = (kind, picked = []) => [...this.movers.values()].filter(m => m.status === 'idle' && !m.held && !this.offShift(m) && !picked.includes(m.id) && (kind === undefined || m.kind === kind));
+        const free = (kind, picked = []) => [...this.equipment.values()].filter(m => m.status === 'idle' &&
+            !m.held &&
+            !this.offShift(m) &&
+            !picked.includes(m.id) &&
+            /* 설비의 소속은 아직 단수(`kind`)다 — 저널에 기록이 쌓여 복수화를 별도 작업으로 두었다.
+               다만 등급 정의가 있으면 **상속은 지금도 탄다**: 'welder-6axis' 가 'welder' 를 상속하면
+               'welder' 요구를 만족한다. 단수/복수와 상속은 다른 축이므로 하나를 기다리지 않는다. */
+            (kind === undefined || classClosure(m.kind ? [m.kind] : [], this.classDefs.equipment, this.now()).has(kind)));
         const need = this.operationSpecs.get(t.kind)?.equipmentSpecification;
         if (!need?.length) {
             const one = free(t.resourceType)[0];
@@ -1180,15 +1209,15 @@ export class FlowEngine {
      * 이 자리가 동시 처리 한도에 찼는가 — `parallelism` 을 선언한 자리만 판정한다(미선언=제약 없음).
      * 세는 대상은 **그 자리에서 진행 중인 작업**(`toNode` 기준, in-progress). 대기 중인 작업은 세지 않는다.
      */
-    stationFull(nodeId) {
-        if (!nodeId)
+    stationFull(locationId) {
+        if (!locationId)
             return false;
-        const limit = this.nodes.get(nodeId)?.parallelism;
+        const limit = this.locations.get(locationId)?.parallelism;
         if (!(typeof limit === 'number' && limit > 0))
             return false;
         let running = 0;
         for (const t of this.tasks.values())
-            if (t.status === 'in-progress' && t.toNode === nodeId)
+            if (t.status === 'in-progress' && t.toNode === locationId)
                 running++;
         return running >= limit;
     }
@@ -1219,12 +1248,12 @@ export class FlowEngine {
     /** 지수분포 표본(고장/수리 간격) — mean 을 평균으로 하는 무기억 프로세스. */
     sampleExp(meanMs) { return -Math.log(1 - this.rng()) * meanMs; }
     /**
-     * 확률적 설비 고장(MTBF/MTTR) — mtbf 지정 무버만 참여(미지정=고장 없음, rng 무소비 → byte-identical).
+     * 확률적 설비 고장(MTBF/MTTR) — mtbf 지정 설비만 참여(미지정=고장 없음, rng 무소비 → byte-identical).
      * up: nextFailure 도래 시 down(수리까지 repairUntil). down: downMs 누적, repair 도래 시 up(다음 고장 예약).
-     * down 중 무버는 배정 불가 + 진행중 task 동결(processTasks 가 skip) → OEE Availability 손실.
+     * down 중 설비는 배정 불가 + 진행중 task 동결(processTasks 가 skip) → OEE Availability 손실.
      */
     processFailures(dt) {
-        for (const m of this.movers.values()) {
+        for (const m of this.equipment.values()) {
             if (m.status === 'down') {
                 // down 회계 + 수리 — 확률적 고장·강제 고장(resource.down) 공통. repairUntilMs 도래 시 복구.
                 m.downMs += dt;
@@ -1233,7 +1262,7 @@ export class FlowEngine {
                     m.repairUntilMs = undefined;
                     if (m.mtbfMs !== undefined)
                         m.nextFailureMs = this.clockMs + this.sampleExp(m.mtbfMs);
-                    this.emitMover(m);
+                    this.emitEquipment(m);
                 }
                 continue;
             }
@@ -1243,12 +1272,12 @@ export class FlowEngine {
                     m.holdMs = (m.holdMs ?? 0) + dt;
                 continue;
             }
-            // 확률적 고장 — mtbf 지정 무버만(미지정=고장 없음, rng 무소비 → byte-identical baseline).
+            // 확률적 고장 — mtbf 지정 설비만(미지정=고장 없음, rng 무소비 → byte-identical baseline).
             if (m.mtbfMs !== undefined && this.clockMs >= (m.nextFailureMs ?? Infinity)) {
                 m.status = 'down';
                 m.repairUntilMs = this.clockMs + this.sampleExp(m.mttrMs ?? m.mtbfMs);
                 m.nextFailureMs = undefined;
-                this.emitMover(m);
+                this.emitEquipment(m);
             }
         }
     }
@@ -1356,21 +1385,21 @@ export class FlowEngine {
             const rigs = this.claimEquipment(t);
             if (!rigs)
                 continue;
-            const mover = this.movers.get(rigs[0]);
-            // 체인지오버: task 의 changeoverKey 가 무버 직전 키와 다르면 셋업 부착(첫 작업은 셋업 없음).
-            if (t.setupMs && t.changeoverKey !== undefined && mover.lastChangeoverKey !== undefined && mover.lastChangeoverKey !== t.changeoverKey) {
+            const eq = this.equipment.get(rigs[0]);
+            // 체인지오버: task 의 changeoverKey 가 설비 직전 키와 다르면 셋업 부착(첫 작업은 셋업 없음).
+            if (t.setupMs && t.changeoverKey !== undefined && eq.lastChangeoverKey !== undefined && eq.lastChangeoverKey !== t.changeoverKey) {
                 t.appliedSetupMs = t.setupMs;
-                t.durationMs += t.setupMs; // 셋업을 가동 앞에 folded(무버 점유 = 셋업+사이클)
+                t.durationMs += t.setupMs; // 셋업을 가동 앞에 folded(설비 점유 = 셋업+사이클)
             }
             if (t.changeoverKey !== undefined)
-                mover.lastChangeoverKey = t.changeoverKey;
+                eq.lastChangeoverKey = t.changeoverKey;
             for (const id of rigs) {
-                const m = this.movers.get(id);
+                const m = this.equipment.get(id);
                 m.status = 'busy';
                 m.taskId = t.id;
             }
             t.status = 'in-progress';
-            t.resource = mover.id;
+            t.resource = eq.id;
             t.remainingMs = t.durationMs;
             t.startedAtSimMs = this.clockMs;
             if (rigs.length > 1)
@@ -1380,9 +1409,9 @@ export class FlowEngine {
             this.emitTask(t);
             // process: 제자리 변환(모션 없음). transport: 이동 모션 방출.
             if (t.intent === 'process')
-                this.emitMover(mover);
+                this.emitEquipment(eq);
             else
-                this.emitMover(mover, { fromNode: t.fromNode, toNode: t.toNode, startedAtSimMs: this.clockMs, durationMs: t.durationMs, progress: 0, elapsedMs: 0 });
+                this.emitEquipment(eq, { fromNode: t.fromNode, toNode: t.toNode, startedAtSimMs: this.clockMs, durationMs: t.durationMs, progress: 0, elapsedMs: 0 });
         }
     }
     /** in-progress 진행/완료 — 상태 효과는 전부 도메인(onTaskComplete). base 는 자원 해제·델타만. */
@@ -1390,7 +1419,7 @@ export class FlowEngine {
         for (const t of this.tasks.values()) {
             if (t.status !== 'in-progress')
                 continue;
-            if (t.resource && this.movers.get(t.resource)?.status === 'down')
+            if (t.resource && this.equipment.get(t.resource)?.status === 'down')
                 continue; // 설비 고장 → 작업 동결
             t.remainingMs -= dt;
             if (t.remainingMs > 0)
@@ -1403,20 +1432,20 @@ export class FlowEngine {
                 this.emitTask(t);
                 continue;
             } // dwell(무자원) — 해제할 자원 없음
-            const mover = this.movers.get(t.resource);
+            const eq = this.equipment.get(t.resource);
             // OEE 계측: 셋업/가동 누적(가동 = 총 duration − 셋업). onTaskComplete 가 recordOutput 로 품질 보고.
             const setup = t.appliedSetupMs ?? 0;
-            mover.setupMs += setup;
-            mover.runMs += t.durationMs - setup;
-            mover.status = 'idle';
-            mover.taskId = null;
+            eq.setupMs += setup;
+            eq.runMs += t.durationMs - setup;
+            eq.status = 'idle';
+            eq.taskId = null;
             if (t.intent !== 'process')
-                mover.location = t.toNode; // 운반만 위치 이동; process 는 제자리
+                eq.location = t.toNode; // 운반만 위치 이동; process 는 제자리
             /* 함께 잡힌 설비도 같은 규칙으로 놓아 준다 — 대표만 풀면 나머지가 영원히 묶인다. */
             for (const id of t.resources ?? []) {
-                if (id === mover.id)
+                if (id === eq.id)
                     continue;
-                const m = this.movers.get(id);
+                const m = this.equipment.get(id);
                 if (!m)
                     continue;
                 m.setupMs += setup;
@@ -1425,10 +1454,10 @@ export class FlowEngine {
                 m.taskId = null;
                 if (t.intent !== 'process')
                     m.location = t.toNode;
-                this.emitMover(m);
+                this.emitEquipment(m);
             }
             this.emitTask(t);
-            this.emitMover(mover);
+            this.emitEquipment(eq);
         }
     }
 }