@operato/twin-kernel 0.7.2 → 0.7.4

package/dist/capability.d.ts

@@ -1,4 +1,4 @@
-export type CapabilityKey = 'operable' | 'storable' | 'mobile' | 'processable' | 'trackable' | 'metered' | 'curtailable' | 'generating' | 'storing';
+export type CapabilityKey = 'operable' | 'storable' | 'mobile' | 'processable' | 'trackable' | 'switching' | 'metered' | 'curtailable' | 'generating' | 'storing';
 /** 이동 관측 — Mobile 이 노출. */
 export interface Motion {
     fromNode: string;
@@ -58,6 +58,15 @@ export interface StoringState {
     chargeKW?: number;
     dischargeKW?: number;
 }
+/**
+ * 개폐 위치 — IEC 61850 `XCBR.Pos`·`XSWI.Pos` 의 넷 값을 그대로 쓴다.
+ *
+ * `intermediate`(과도)와 `bad`(위치 불량)를 **뭉개지 않는다**: 실 계통에서 이 둘은 이중 접점이 서로
+ * 다른 말을 하는 상태이고, 「열림/닫힘」으로 반올림하면 트윈이 없는 확신을 갖는다.
+ */
+export interface SwitchingState {
+    position?: 'open' | 'closed' | 'intermediate' | 'bad';
+}
 /** 능력 관측 계약 메타(발견·검증). ops 없음(원칙 ①). */
 export interface CapabilitySpec {
     key: CapabilityKey;

package/dist/capability.js

@@ -33,6 +33,22 @@ export const CAPABILITIES = {
         key: 'processable', label: 'twin.capability.processable', semantics: '변환/가공 수행 — 산출(양품/불량). 운영 status 는 Operable 조합. progress 방출은 후속.',
         stateFields: ['output'], results: ['completed']
     },
+    /*
+     * ── 「위치를 읽는다」 ≠ 「조작할 수 있다」 (2026-08-14) ─────────────────────
+     * 차단기는 이 둘이 갈리는 자리다. 상태를 읽어 계통 구성을 알지만 **우리는 조작하지 않는다**
+     * (안전 계통은 범위 밖: profiles/ems.md §1). 그런데 능력을 `operable` 로 주면 저작면이 그 설비에
+     * **제어 컴포넌트를 권한다** — 화면이 우리가 하지 않기로 한 것을 하라고 부추긴다.
+     *
+     * 그래서 개폐 기기의 관측을 따로 세운다. 이름을 `observable` 로 하지 않은 이유: 그러면 상태 필드가
+     * `status` 여야 하고 그건 `operable` 의 것이다(원칙 ② 직교). 없는 필드를 지어내는 대신 **표준이 주는
+     * 이름**을 쓴다 — 개폐 기기의 관측은 `Pos`(위치)다.
+     *
+     * `operable` 은 그대로 「명령을 받는 능동 자원」의 자리로 남는다.
+     */
+    switching: {
+        key: 'switching', label: 'twin.capability.switching', semantics: '회로를 열고 닫는 기기의 **위치를 읽는다** — 우리는 조작하지 않는다(명령 없음). IEC 61850 XCBR/XSWI Pos.',
+        stateFields: ['position'], models: ['SwitchingState'], results: ['positionChanged']
+    },
     trackable: {
         key: 'trackable', label: 'twin.capability.trackable', semantics: '오더/아이템 생애 추적 — 생애단계(도메인 라벨, 무방언)·진행·보류.',
         stateFields: ['lifecycle', 'progress', 'held'], results: ['lifecycleChanged']
@@ -60,7 +76,7 @@ export const CAPABILITIES = {
         stateFields: ['soc', 'chargeKW', 'dischargeKW'], models: ['StoringState'], invariants: ['0 <= soc <= 100'], results: ['stored', 'discharged']
     }
 };
-export const CAPABILITY_KEYS = ['operable', 'storable', 'mobile', 'processable', 'trackable', 'metered', 'curtailable', 'generating', 'storing'];
+export const CAPABILITY_KEYS = ['operable', 'storable', 'mobile', 'processable', 'trackable', 'switching', 'metered', 'curtailable', 'generating', 'storing'];
 /** 능력 집합이 관측 노출하는 상태 필드 합집합(직교이므로 단순 병합). */
 export function stateFieldsOf(caps) {
     const out = new Set();

package/dist/contract.d.ts

@@ -1193,6 +1193,14 @@ export interface DemandWindowState {
     /** 계약전력 대비 — 계약을 모르면 `undefined`(짐작하지 않는다). */
     contractKW?: number;
     overContract?: boolean;
+    /**
+     * 이 구간의 값이 **잰 것이 아니라 만든 것**임을 밝힌다(시뮬레이션).
+     *
+     * 시뮬 트윈은 선언된 부하 계수와 설비 가동 상태로 부하를 계산한다. 그 수를 계측과 같은 자리에
+     * 두면 화면·성과·보고서가 그것을 실측으로 읽는다 — 그래서 값 옆에 종류를 함께 싣는다.
+     * 미러 트윈에서는 절대 켜지지 않는다(관측 구동은 잰 것만 쓴다).
+     */
+    derived?: boolean;
 }
 export interface EnergyState {
     points: MeterPointState[];

package/dist/ems-kernel.d.ts

@@ -38,6 +38,22 @@ export declare class EmsKernel extends FlowEngine {
      * 한계는 수전이 정한다. 선언이 없으면 `undefined` — 계약을 모르면 계약 대비 판정을 하지 않는다
      * (기본값을 지어내면 그 뒤 모든 판정이 거짓 위에 선다).
      */
+    /**
+     * 같은 현장 이웃 트윈의 **설비 가동 상태** — 부하를 만들 때 읽는다.
+     *
+     * ── 왜 커널이 읽나 (2026-08-14) ────────────────────────────────────────────
+     * 시뮬 EMS 트윈은 계측이 없으므로 스스로 전기를 만들어야 한다. 그런데 「무엇이 돌고 있나」는
+     * 공장 트윈이 아는 사실이다. 호스트는 **누가 같은 현장에 있는지**만 알려 주고, 무엇을 읽어
+     * 어떻게 부하로 바꿀지는 커널이 정한다 — 계수와 규칙이 호스트에 흩어지면 트윈마다 다른 답이 된다.
+     *
+     * 여기 실리는 것은 상태뿐이다(kW 가 아니다). kW 는 **이 트윈의 모델이 선언한 계수**로 커널이 만든다.
+     */
+    private peerStatus;
+    /** 이웃 설비 상태를 싣는다 — 매 tick 갱신을 전제로 통째로 바꾼다(사라진 설비가 남지 않게). */
+    observePeerEquipment(list: readonly {
+        id: string;
+        status?: string;
+    }[]): void;
     private declaredContractKW;
     /**
      * **뿌리 계량기** — 조상 중에 계량된 자리가 없는 계량 지점들.
@@ -86,6 +102,20 @@ export declare class EmsKernel extends FlowEngine {
     protected allocate(): void;
     protected onTaskComplete(): void;
     /** 시뮬 시간으로도 구간이 닫힌다 — 관측이 없어도 시간은 간다. */
+    /**
+     * 선언된 부하 계수 × 가동 상태 → **이 현장의 부하**. 시뮬레이션에서만 만든다.
+     *
+     * ── 규칙 ──────────────────────────────────────────────────────────────────
+     * ① 계수를 선언한 설비만 센다(`power.ratedKW`). 선언이 없으면 그 설비는 부하를 만들지 않는다 —
+     *    타입 기본값을 두지 않기로 했다(계수는 현장이 안다).
+     * ② 가동 여부는 **상태**로 판단한다. 자기 설비에 상태가 있으면 그것을, 없으면 이웃 트윈(같은 현장)의
+     *    상태를 본다. 어느 쪽에도 없으면 **모르는 것**이므로 그 설비는 이번 계산에서 빠진다.
+     * ③ 멈춘 설비는 `power.standbyKW` 를 선언한 만큼만 센다. 선언이 없으면 0 이 아니라 **모름**이다.
+     * ④ 미러 트윈에서는 아무것도 만들지 않는다 — 관측 구동은 잰 것만 쓴다.
+     */
+    private deriveLoad;
+    /** 자원 속성에서 수 하나 — 값이 수가 아니면 없는 것으로 본다(짐작하지 않는다). */
+    private numberProperty;
     tick(dtMs: number): void;
     getSnapshot(): StateSnapshot;
 }

package/dist/ems-kernel.js

@@ -44,6 +44,15 @@ function windowMsOf(opts) {
 }
 /** 상태에 남기는 마감 구간 수 — 하루치(15분 × 96). 그 앞은 저널이 답한다. */
 const KEEP_CLOSED = 96;
+/**
+ * 이 상태를 「돌고 있다」로 볼 것인가 — 커널의 상태 어휘를 그대로 쓴다.
+ *
+ * `busy`·`in-use` 는 일하는 중이고, `idle` 은 서 있는 중이며, `down` 은 고장이다. 셋 다 「돌지 않음」
+ * 쪽이지만 대기전력은 선언된 만큼 센다(그 판단은 부르는 쪽에 있다).
+ */
+function isRunningStatus(status) {
+    return status === 'busy' || status === 'in-use' || status === 'running';
+}
 export class EmsKernel extends FlowEngine {
     points = new Map();
     open;
@@ -78,6 +87,21 @@ export class EmsKernel extends FlowEngine {
      * 한계는 수전이 정한다. 선언이 없으면 `undefined` — 계약을 모르면 계약 대비 판정을 하지 않는다
      * (기본값을 지어내면 그 뒤 모든 판정이 거짓 위에 선다).
      */
+    /**
+     * 같은 현장 이웃 트윈의 **설비 가동 상태** — 부하를 만들 때 읽는다.
+     *
+     * ── 왜 커널이 읽나 (2026-08-14) ────────────────────────────────────────────
+     * 시뮬 EMS 트윈은 계측이 없으므로 스스로 전기를 만들어야 한다. 그런데 「무엇이 돌고 있나」는
+     * 공장 트윈이 아는 사실이다. 호스트는 **누가 같은 현장에 있는지**만 알려 주고, 무엇을 읽어
+     * 어떻게 부하로 바꿀지는 커널이 정한다 — 계수와 규칙이 호스트에 흩어지면 트윈마다 다른 답이 된다.
+     *
+     * 여기 실리는 것은 상태뿐이다(kW 가 아니다). kW 는 **이 트윈의 모델이 선언한 계수**로 커널이 만든다.
+     */
+    peerStatus = new Map();
+    /** 이웃 설비 상태를 싣는다 — 매 tick 갱신을 전제로 통째로 바꾼다(사라진 설비가 남지 않게). */
+    observePeerEquipment(list) {
+        this.peerStatus = new Map(list.filter(e => e?.id).map(e => [String(e.id), String(e.status ?? '')]));
+    }
     declaredContractKW() {
         let max;
         for (const loc of this.boardDef?.locations ?? []) {
@@ -330,8 +354,73 @@ export class EmsKernel extends FlowEngine {
         this.noteFlowRequest('onTaskComplete');
     }
     /** 시뮬 시간으로도 구간이 닫힌다 — 관측이 없어도 시간은 간다. */
+    /**
+     * 선언된 부하 계수 × 가동 상태 → **이 현장의 부하**. 시뮬레이션에서만 만든다.
+     *
+     * ── 규칙 ──────────────────────────────────────────────────────────────────
+     * ① 계수를 선언한 설비만 센다(`power.ratedKW`). 선언이 없으면 그 설비는 부하를 만들지 않는다 —
+     *    타입 기본값을 두지 않기로 했다(계수는 현장이 안다).
+     * ② 가동 여부는 **상태**로 판단한다. 자기 설비에 상태가 있으면 그것을, 없으면 이웃 트윈(같은 현장)의
+     *    상태를 본다. 어느 쪽에도 없으면 **모르는 것**이므로 그 설비는 이번 계산에서 빠진다.
+     * ③ 멈춘 설비는 `power.standbyKW` 를 선언한 만큼만 센다. 선언이 없으면 0 이 아니라 **모름**이다.
+     * ④ 미러 트윈에서는 아무것도 만들지 않는다 — 관측 구동은 잰 것만 쓴다.
+     */
+    deriveLoad(atMs) {
+        if (this.observing)
+            return; // 미러 — 계측이 진실이다
+        let total = 0;
+        let counted = 0;
+        for (const e of this.boardDef?.equipment ?? []) {
+            const rated = this.numberProperty(e, EMS_PROPERTY.ratedKW);
+            if (rated === undefined)
+                continue;
+            /*
+             * **이웃이 말한 상태가 먼저다.** 설비를 실제로 돌리는 것은 공정 트윈이고, 에너지 트윈의 자기
+             * 설비 상태는 모델을 실을 때의 씨앗값(`idle`)일 뿐이다. 자기 것을 먼저 보면 그 씨앗값이 이웃의
+             * 사실을 덮어, 공장이 도는데도 대기전력만 세는 일이 벌어진다(실제로 그렇게 났다).
+             */
+            const status = this.peerStatus.get(e.id) ?? this.equipment.get(e.id)?.status;
+            if (status === undefined || status === '')
+                continue; // 모르는 상태 — 지어내지 않는다
+            if (isRunningStatus(status)) {
+                total += rated;
+                counted++;
+                continue;
+            }
+            const standby = this.numberProperty(e, EMS_PROPERTY.standbyKW);
+            if (standby !== undefined) {
+                total += standby;
+                counted++;
+            }
+        }
+        if (!counted)
+            return; // 셀 것이 하나도 없으면 구간에 값을 넣지 않는다(0 을 주장하지 않는다)
+        this.closeDue(atMs);
+        this.openWindow(atMs);
+        const w = this.open;
+        w.derived = true;
+        if (w.maxKW === undefined || total > w.maxKW)
+            w.maxKW = total;
+        w.samples++;
+        w.meanKW = w.meanKW === undefined ? total : (w.meanKW * (w.samples - 1) + total) / w.samples;
+        this.revision++;
+        this.judgeOpenWindow(atMs);
+    }
+    /** 자원 속성에서 수 하나 — 값이 수가 아니면 없는 것으로 본다(짐작하지 않는다). */
+    numberProperty(resource, id) {
+        for (const p of resource?.properties ?? []) {
+            if (p?.id !== id)
+                continue;
+            const v = Number(p.value);
+            if (Number.isFinite(v) && v >= 0)
+                return v;
+        }
+        return undefined;
+    }
     tick(dtMs) {
         super.tick(dtMs);
+        /* 부하를 먼저 만들고 마감한다 — 마감이 먼저면 마지막 값이 다음 구간으로 밀린다. */
+        this.deriveLoad(this.clockMs);
         this.closeDue(this.clockMs);
     }
     getSnapshot() {

package/dist/ems-profile.d.ts

@@ -12,5 +12,9 @@ export declare const EMS_EQUIPMENT_TYPES: readonly ["meter", "breaker", "pv-arra
 export declare const EMS_PROPERTY: {
     /** 계약전력(kW) — 수전·분기 자리에 선언한다. 없으면 계약 대비 판정을 하지 않는다. */
     readonly contractKW: "contract.kW";
+    /** 가동 중 소비(kW). */
+    readonly ratedKW: "power.ratedKW";
+    /** 멈춰 있을 때의 소비(kW). 없으면 멈춘 동안을 **비운다** — 0 이라고 주장하지 않는다. */
+    readonly standbyKW: "power.standbyKW";
 };
 export declare const EMS_TYPES: TwinTypeInfo[];

package/dist/ems-profile.js

@@ -10,7 +10,17 @@ export const EMS_EQUIPMENT_TYPES = ['meter', 'breaker', 'pv-array', 'battery', '
  */
 export const EMS_PROPERTY = {
     /** 계약전력(kW) — 수전·분기 자리에 선언한다. 없으면 계약 대비 판정을 하지 않는다. */
-    contractKW: 'contract.kW'
+    contractKW: 'contract.kW',
+    /*
+     * ── 부하 계수 — 시뮬레이션이 전기를 만들 수 있게 (2026-08-14) ───────────────
+     * 「이 설비가 돌면 몇 kW 인가」는 **현장이 아는 값**이다. 그래서 타입 기본값을 두지 않는다:
+     * 선언하지 않은 설비는 부하를 만들지 않는다. 기본값을 두면 아무도 그 수가 짐작인 줄 모른 채
+     * 요금 판정이 그 위에 선다.
+     */
+    /** 가동 중 소비(kW). */
+    ratedKW: 'power.ratedKW',
+    /** 멈춰 있을 때의 소비(kW). 없으면 멈춘 동안을 **비운다** — 0 이라고 주장하지 않는다. */
+    standbyKW: 'power.standbyKW'
 };
 export const EMS_TYPES = [
     /* ── 자리: 전기적 구간 ─────────────────────────────────────────────────── */
@@ -69,11 +79,15 @@ export const EMS_TYPES = [
         label: 'twin.type.breaker',
         /*
          * 차단기 — IEC 61850 `XCBR`. **우리는 이것을 조작하지 않는다**(안전 계통은 범위 밖: ems.md §1).
-         * 상태를 읽어 계통 구성을 알 뿐이다 — 그래서 능력은 `operable` 만이고 `curtailable` 이 아니다.
+         * 상태를 읽어 계통 구성을 알 뿐이다.
+         *
+         * 능력은 `switching` 이다 — `operable` 이 아니다(2026-08-14). `operable` 이던 동안 저작면이 차단기에
+         * **제어 컴포넌트**를 권했다: 우리가 하지 않기로 한 조작을 화면이 부추긴 것이다. 「위치를 읽는다」와
+         * 「명령을 받는다」는 다른 능력이고, 이제 그 둘이 갈려 있다(capability.ts 주석).
          */
         standardClass: { iec61850: 'XCBR', iso55000: 'Asset' },
         identity: { scheme: 'kernel:id' },
-        capabilities: ['operable']
+        capabilities: ['switching']
     },
     {
         key: 'pv-array',

package/dist-cjs/index.cjs

@@ -1606,7 +1606,17 @@ var EMS_LOCATION_TYPES = ["incoming", "feeder", "submeter-zone"];
 var EMS_EQUIPMENT_TYPES = ["meter", "breaker", "pv-array", "battery", "utility", "curtailable-load"];
 var EMS_PROPERTY = {
   /** 계약전력(kW) — 수전·분기 자리에 선언한다. 없으면 계약 대비 판정을 하지 않는다. */
-  contractKW: "contract.kW"
+  contractKW: "contract.kW",
+  /*
+   * ── 부하 계수 — 시뮬레이션이 전기를 만들 수 있게 (2026-08-14) ───────────────
+   * 「이 설비가 돌면 몇 kW 인가」는 **현장이 아는 값**이다. 그래서 타입 기본값을 두지 않는다:
+   * 선언하지 않은 설비는 부하를 만들지 않는다. 기본값을 두면 아무도 그 수가 짐작인 줄 모른 채
+   * 요금 판정이 그 위에 선다.
+   */
+  /** 가동 중 소비(kW). */
+  ratedKW: "power.ratedKW",
+  /** 멈춰 있을 때의 소비(kW). 없으면 멈춘 동안을 **비운다** — 0 이라고 주장하지 않는다. */
+  standbyKW: "power.standbyKW"
 };
 var EMS_TYPES = [
   /* ── 자리: 전기적 구간 ─────────────────────────────────────────────────── */
@@ -1665,11 +1675,15 @@ var EMS_TYPES = [
     label: "twin.type.breaker",
     /*
      * 차단기 — IEC 61850 `XCBR`. **우리는 이것을 조작하지 않는다**(안전 계통은 범위 밖: ems.md §1).
-     * 상태를 읽어 계통 구성을 알 뿐이다 — 그래서 능력은 `operable` 만이고 `curtailable` 이 아니다.
+     * 상태를 읽어 계통 구성을 알 뿐이다.
+     *
+     * 능력은 `switching` 이다 — `operable` 이 아니다(2026-08-14). `operable` 이던 동안 저작면이 차단기에
+     * **제어 컴포넌트**를 권했다: 우리가 하지 않기로 한 조작을 화면이 부추긴 것이다. 「위치를 읽는다」와
+     * 「명령을 받는다」는 다른 능력이고, 이제 그 둘이 갈려 있다(capability.ts 주석).
      */
     standardClass: { iec61850: "XCBR", iso55000: "Asset" },
     identity: { scheme: "kernel:id" },
-    capabilities: ["operable"]
+    capabilities: ["switching"]
   },
   {
     key: "pv-array",
@@ -1760,6 +1774,26 @@ var CAPABILITIES = {
     stateFields: ["output"],
     results: ["completed"]
   },
+  /*
+   * ── 「위치를 읽는다」 ≠ 「조작할 수 있다」 (2026-08-14) ─────────────────────
+   * 차단기는 이 둘이 갈리는 자리다. 상태를 읽어 계통 구성을 알지만 **우리는 조작하지 않는다**
+   * (안전 계통은 범위 밖: profiles/ems.md §1). 그런데 능력을 `operable` 로 주면 저작면이 그 설비에
+   * **제어 컴포넌트를 권한다** — 화면이 우리가 하지 않기로 한 것을 하라고 부추긴다.
+   *
+   * 그래서 개폐 기기의 관측을 따로 세운다. 이름을 `observable` 로 하지 않은 이유: 그러면 상태 필드가
+   * `status` 여야 하고 그건 `operable` 의 것이다(원칙 ② 직교). 없는 필드를 지어내는 대신 **표준이 주는
+   * 이름**을 쓴다 — 개폐 기기의 관측은 `Pos`(위치)다.
+   *
+   * `operable` 은 그대로 「명령을 받는 능동 자원」의 자리로 남는다.
+   */
+  switching: {
+    key: "switching",
+    label: "twin.capability.switching",
+    semantics: "\uD68C\uB85C\uB97C \uC5F4\uACE0 \uB2EB\uB294 \uAE30\uAE30\uC758 **\uC704\uCE58\uB97C \uC77D\uB294\uB2E4** \u2014 \uC6B0\uB9AC\uB294 \uC870\uC791\uD558\uC9C0 \uC54A\uB294\uB2E4(\uBA85\uB839 \uC5C6\uC74C). IEC 61850 XCBR/XSWI Pos.",
+    stateFields: ["position"],
+    models: ["SwitchingState"],
+    results: ["positionChanged"]
+  },
   trackable: {
     key: "trackable",
     label: "twin.capability.trackable",
@@ -1808,7 +1842,7 @@ var CAPABILITIES = {
     results: ["stored", "discharged"]
   }
 };
-var CAPABILITY_KEYS = ["operable", "storable", "mobile", "processable", "trackable", "metered", "curtailable", "generating", "storing"];
+var CAPABILITY_KEYS = ["operable", "storable", "mobile", "processable", "trackable", "switching", "metered", "curtailable", "generating", "storing"];
 function stateFieldsOf(caps) {
   const out = /* @__PURE__ */ new Set();
   for (const c of caps) for (const f of CAPABILITIES[c]?.stateFields ?? []) out.add(f);
@@ -5582,6 +5616,9 @@ function windowMsOf(opts) {
   return Number.isFinite(n) && n > 0 ? n : DEMAND_WINDOW_MS;
 }
 var KEEP_CLOSED = 96;
+function isRunningStatus(status) {
+  return status === "busy" || status === "in-use" || status === "running";
+}
 var EmsKernel = class extends FlowEngine {
   points = /* @__PURE__ */ new Map();
   open;
@@ -5616,6 +5653,21 @@ var EmsKernel = class extends FlowEngine {
    * 한계는 수전이 정한다. 선언이 없으면 `undefined` — 계약을 모르면 계약 대비 판정을 하지 않는다
    * (기본값을 지어내면 그 뒤 모든 판정이 거짓 위에 선다).
    */
+  /**
+   * 같은 현장 이웃 트윈의 **설비 가동 상태** — 부하를 만들 때 읽는다.
+   *
+   * ── 왜 커널이 읽나 (2026-08-14) ────────────────────────────────────────────
+   * 시뮬 EMS 트윈은 계측이 없으므로 스스로 전기를 만들어야 한다. 그런데 「무엇이 돌고 있나」는
+   * 공장 트윈이 아는 사실이다. 호스트는 **누가 같은 현장에 있는지**만 알려 주고, 무엇을 읽어
+   * 어떻게 부하로 바꿀지는 커널이 정한다 — 계수와 규칙이 호스트에 흩어지면 트윈마다 다른 답이 된다.
+   *
+   * 여기 실리는 것은 상태뿐이다(kW 가 아니다). kW 는 **이 트윈의 모델이 선언한 계수**로 커널이 만든다.
+   */
+  peerStatus = /* @__PURE__ */ new Map();
+  /** 이웃 설비 상태를 싣는다 — 매 tick 갱신을 전제로 통째로 바꾼다(사라진 설비가 남지 않게). */
+  observePeerEquipment(list) {
+    this.peerStatus = new Map(list.filter((e) => e?.id).map((e) => [String(e.id), String(e.status ?? "")]));
+  }
   declaredContractKW() {
     let max;
     for (const loc of this.boardDef?.locations ?? []) {
@@ -5821,8 +5873,60 @@ var EmsKernel = class extends FlowEngine {
     this.noteFlowRequest("onTaskComplete");
   }
   /** 시뮬 시간으로도 구간이 닫힌다 — 관측이 없어도 시간은 간다. */
+  /**
+   * 선언된 부하 계수 × 가동 상태 → **이 현장의 부하**. 시뮬레이션에서만 만든다.
+   *
+   * ── 규칙 ──────────────────────────────────────────────────────────────────
+   * ① 계수를 선언한 설비만 센다(`power.ratedKW`). 선언이 없으면 그 설비는 부하를 만들지 않는다 —
+   *    타입 기본값을 두지 않기로 했다(계수는 현장이 안다).
+   * ② 가동 여부는 **상태**로 판단한다. 자기 설비에 상태가 있으면 그것을, 없으면 이웃 트윈(같은 현장)의
+   *    상태를 본다. 어느 쪽에도 없으면 **모르는 것**이므로 그 설비는 이번 계산에서 빠진다.
+   * ③ 멈춘 설비는 `power.standbyKW` 를 선언한 만큼만 센다. 선언이 없으면 0 이 아니라 **모름**이다.
+   * ④ 미러 트윈에서는 아무것도 만들지 않는다 — 관측 구동은 잰 것만 쓴다.
+   */
+  deriveLoad(atMs) {
+    if (this.observing) return;
+    let total = 0;
+    let counted = 0;
+    for (const e of this.boardDef?.equipment ?? []) {
+      const rated = this.numberProperty(e, EMS_PROPERTY.ratedKW);
+      if (rated === void 0) continue;
+      const status = this.peerStatus.get(e.id) ?? this.equipment.get(e.id)?.status;
+      if (status === void 0 || status === "") continue;
+      if (isRunningStatus(status)) {
+        total += rated;
+        counted++;
+        continue;
+      }
+      const standby = this.numberProperty(e, EMS_PROPERTY.standbyKW);
+      if (standby !== void 0) {
+        total += standby;
+        counted++;
+      }
+    }
+    if (!counted) return;
+    this.closeDue(atMs);
+    this.openWindow(atMs);
+    const w = this.open;
+    w.derived = true;
+    if (w.maxKW === void 0 || total > w.maxKW) w.maxKW = total;
+    w.samples++;
+    w.meanKW = w.meanKW === void 0 ? total : (w.meanKW * (w.samples - 1) + total) / w.samples;
+    this.revision++;
+    this.judgeOpenWindow(atMs);
+  }
+  /** 자원 속성에서 수 하나 — 값이 수가 아니면 없는 것으로 본다(짐작하지 않는다). */
+  numberProperty(resource, id) {
+    for (const p of resource?.properties ?? []) {
+      if (p?.id !== id) continue;
+      const v = Number(p.value);
+      if (Number.isFinite(v) && v >= 0) return v;
+    }
+    return void 0;
+  }
   tick(dtMs) {
     super.tick(dtMs);
+    this.deriveLoad(this.clockMs);
     this.closeDue(this.clockMs);
   }
   getSnapshot() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@operato/twin-kernel",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "type": "module",
   "description": "Twin Domain Kernel — framework-agnostic, zero-dep (domain + sim + 3-channel contract). WMS/YMS/MES, EPCIS 2.0 · ISA-95.",
   "publishConfig": {