@operato/twin-kernel 0.7.3 → 0.7.5

package/dist/contract.d.ts

@@ -1193,6 +1193,14 @@ export interface DemandWindowState {
     /** 계약전력 대비 — 계약을 모르면 `undefined`(짐작하지 않는다). */
     contractKW?: number;
     overContract?: boolean;
+    /**
+     * 이 구간의 값이 **잰 것이 아니라 만든 것**임을 밝힌다(시뮬레이션).
+     *
+     * 시뮬 트윈은 선언된 부하 계수와 설비 가동 상태로 부하를 계산한다. 그 수를 계측과 같은 자리에
+     * 두면 화면·성과·보고서가 그것을 실측으로 읽는다 — 그래서 값 옆에 종류를 함께 싣는다.
+     * 미러 트윈에서는 절대 켜지지 않는다(관측 구동은 잰 것만 쓴다).
+     */
+    derived?: boolean;
 }
 export interface EnergyState {
     points: MeterPointState[];
@@ -1842,6 +1850,14 @@ export interface TwinKernel {
     adoptStructure(def: TwinModelDef): StructureShift;
     /** 이 커널이 관측으로 구동됨을 선언한다 — 첫 이벤트가 오기 전에도 그렇다. */
     observe(): void;
+    /**
+     * 시각 기준점을 세운다 — 이 트윈의 「지금」은 `기준점 + 경과`다.
+     *
+     * 세우는 쪽이 기동 순간의 실제 시각을 준다. 주지 않으면 커널의 기본 기준점을 쓰는데, 그러면 시뮬
+     * 트윈의 저널 시각이 재기동마다 되감겨 「언제 있었던 일인가」를 되짚을 수 없다.
+     * **기동 직후에만** 부른다 — 시계가 흐른 뒤에 옮기면 그전에 낸 사실들과 시간축이 어긋난다.
+     */
+    setClockOrigin?(originMs: number): void;
     getSnapshot(): StateSnapshot;
     onEvent(handler: EventHandler): Unsubscribe;
     dispatch(cmd: Command): CommandAck;

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 ?? []) {
@@ -252,12 +276,23 @@ export class EmsKernel extends FlowEngine {
                  * kW 를 못 읽은 경우(계기 오류·필드 누락)가 실제로 있고, 그것은 「아무것도 오지 않았다」와
                  * 다르다. 무엇이 왔는지는 지점별 `samplesInWindow` 가 답한다.
                  */
-                ...(w.samples === 0 ? { observedAbsence: 'no-load-samples' } : {})
+                ...(w.samples === 0 ? { observedAbsence: 'no-load-samples' } : {}),
+                /*
+                 * **만든 값이면 그렇게 말한다.** 상태에만 표시하고 사실에는 빠뜨리면, 저널을 읽는 쪽
+                 * (성과·이력·보고서)이 시뮬레이션의 수를 계측으로 읽는다 — 값이 그럴듯할수록 위험하다.
+                 */
+                ...(w.derived ? { derived: true } : {})
             });
             /* 피크는 **마감된 구간**으로만 갱신한다 — 열린 구간의 최대는 아직 확정이 아니다. */
             if (w.maxKW !== undefined && (this.peak === undefined || w.maxKW > this.peak.kW)) {
                 this.peak = { kW: w.maxKW, windowStartMs: w.startMs };
-                this.emitOp(ENERGY_EVENT.peak, { kW: w.maxKW, windowStartMs: w.startMs, ...(w.contractKW !== undefined ? { contractKW: w.contractKW } : {}) });
+                this.emitOp(ENERGY_EVENT.peak, {
+                    kW: w.maxKW,
+                    windowStartMs: w.startMs,
+                    ...(w.contractKW !== undefined ? { contractKW: w.contractKW } : {}),
+                    /* 피크도 그 구간에서 왔다 — 구간이 만든 값이면 피크도 만든 값이다. */
+                    ...(w.derived ? { derived: true } : {})
+                });
             }
             /* 다음 구간은 표본이 올 때 연다 — 미리 열면 오지 않은 구간을 존재하는 것처럼 만든다. */
             this.open = undefined;
@@ -330,9 +365,83 @@ 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.closeDue(this.clockMs);
+        /*
+         * 구간은 **이 트윈의 「지금」**으로 잡는다(`nowMs`) — 경과 시간(`clockMs`)이 아니다.
+         *
+         * 예전에는 경과 시간을 그대로 넘겨서 시뮬 트윈의 수요 구간이 **1970년**에 섰다. 계측 경로는
+         * 계측이 말한 절대 시각을 쓰므로, 두 경로가 서로 다른 시간축에 값을 넣고 있었던 셈이다.
+         * 요금은 벽시계의 15분으로 매겨지니 그 경계에 서야 견줄 수 있다.
+         *
+         * 부하를 먼저 만들고 마감한다 — 마감이 먼저면 마지막 값이 다음 구간으로 밀린다.
+         */
+        const at = this.nowMs();
+        this.deriveLoad(at);
+        this.closeDue(at);
     }
     getSnapshot() {
         const snap = super.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 = [
     /* ── 자리: 전기적 구간 ─────────────────────────────────────────────────── */

package/dist/flow-engine.d.ts

@@ -285,6 +285,20 @@ export declare abstract class FlowEngine implements TwinKernel {
     orders: Map<string, FlowOrder>;
     revision: number;
     clockMs: number;
+    /**
+     * 시각의 **기준점** — 이 트윈의 「지금」은 `originMs + clockMs` 다.
+     *
+     * ── 왜 고정 상수가 아닌가 (2026-08-15) ─────────────────────────────────────
+     * 기준점이 `BASE_EPOCH` 하나로 고정돼 있어서, 시뮬 트윈의 저널 시각이 **재기동마다 되감겼다.**
+     * 며칠을 돈 트윈의 사건들이 전부 `2026-01-01T00:00:xx` 에 몰려 있었고, 그래서 「언제 있었던 일인가」를
+     * 되짚을 수 없었다. 실 시각으로 창을 자르는 성과·이력 질의에는 그 트윈이 아예 보이지 않는다.
+     *
+     * 에너지에서는 더 아프다: 수요 구간은 벽시계의 15분에 맞춰 끊어야 요금과 견줄 수 있는데, 기준점이
+     * 가짜면 그 구간도 가짜 시각에 선다.
+     *
+     * 기본값은 그대로 둔다(시험·결정성). 살아 있는 시뮬 트윈을 세우는 호스트가 실제 시각으로 옮긴다.
+     */
+    protected originMs: number;
     protected rng: Rng;
     protected policy: AllocationPolicy;
     /** duration 시임(선택) — 미주입 시 명세, 명세도 없으면 도메인 상수. 이력 보정 추정기가 여기 들어온다. */
@@ -452,6 +466,15 @@ export declare abstract class FlowEngine implements TwinKernel {
      * 아직 아무것도 못 들었으면 시뮬 기준으로 떨어진다(그때는 판정할 사실도 없다).
      */
     protected nowMs(): number;
+    /**
+     * 시각 기준점을 세운다 — **살아 있는 시뮬 트윈은 실제 시각 위에서 돈다.**
+     *
+     * 세우는 쪽(호스트)이 기동 순간의 실제 시각을 준다. 재기동하면 그만큼 앞으로 뛰는데, 그것이 사실이다
+     * (그 사이 이 트윈은 돌지 않았고, 저널의 빈 구간이 그 사실을 말한다).
+     *
+     * 이미 시계가 흐른 뒤에 옮기면 그전에 낸 사실들과 시간축이 어긋나므로 **기동 직후에만** 부른다.
+     */
+    setClockOrigin(originMs: number): void;
     protected now(): string;
     /**
      * 자극이 선언한 **약속**을 오더 필드로 — 표준 `OperationsRequest.Priority`·`StartTime`·`EndTime`.

package/dist/flow-engine.js

@@ -227,6 +227,20 @@ export class FlowEngine {
     orders = new Map();
     revision = 0;
     clockMs = 0;
+    /**
+     * 시각의 **기준점** — 이 트윈의 「지금」은 `originMs + clockMs` 다.
+     *
+     * ── 왜 고정 상수가 아닌가 (2026-08-15) ─────────────────────────────────────
+     * 기준점이 `BASE_EPOCH` 하나로 고정돼 있어서, 시뮬 트윈의 저널 시각이 **재기동마다 되감겼다.**
+     * 며칠을 돈 트윈의 사건들이 전부 `2026-01-01T00:00:xx` 에 몰려 있었고, 그래서 「언제 있었던 일인가」를
+     * 되짚을 수 없었다. 실 시각으로 창을 자르는 성과·이력 질의에는 그 트윈이 아예 보이지 않는다.
+     *
+     * 에너지에서는 더 아프다: 수요 구간은 벽시계의 15분에 맞춰 끊어야 요금과 견줄 수 있는데, 기준점이
+     * 가짜면 그 구간도 가짜 시각에 선다.
+     *
+     * 기본값은 그대로 둔다(시험·결정성). 살아 있는 시뮬 트윈을 세우는 호스트가 실제 시각으로 옮긴다.
+     */
+    originMs = BASE_EPOCH;
     rng = mulberry32(1);
     policy;
     /** duration 시임(선택) — 미주입 시 명세, 명세도 없으면 도메인 상수. 이력 보정 추정기가 여기 들어온다. */
@@ -1016,7 +1030,20 @@ export class FlowEngine {
      */
     nowMs() {
         const observed = this.observeMode ? this.observer?.lastObservedMs : undefined;
-        return observed ?? BASE_EPOCH + this.clockMs;
+        return observed ?? this.originMs + this.clockMs;
+    }
+    /**
+     * 시각 기준점을 세운다 — **살아 있는 시뮬 트윈은 실제 시각 위에서 돈다.**
+     *
+     * 세우는 쪽(호스트)이 기동 순간의 실제 시각을 준다. 재기동하면 그만큼 앞으로 뛰는데, 그것이 사실이다
+     * (그 사이 이 트윈은 돌지 않았고, 저널의 빈 구간이 그 사실을 말한다).
+     *
+     * 이미 시계가 흐른 뒤에 옮기면 그전에 낸 사실들과 시간축이 어긋나므로 **기동 직후에만** 부른다.
+     */
+    setClockOrigin(originMs) {
+        if (!Number.isFinite(originMs))
+            throw new Error('clock origin must be a finite epoch millisecond value');
+        this.originMs = originMs;
     }
     now() { return new Date(this.nowMs()).toISOString(); }
     /**

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 = [
   /* ── 자리: 전기적 구간 ─────────────────────────────────────────────────── */
@@ -2799,6 +2809,20 @@ var FlowEngine = class {
   orders = /* @__PURE__ */ new Map();
   revision = 0;
   clockMs = 0;
+  /**
+   * 시각의 **기준점** — 이 트윈의 「지금」은 `originMs + clockMs` 다.
+   *
+   * ── 왜 고정 상수가 아닌가 (2026-08-15) ─────────────────────────────────────
+   * 기준점이 `BASE_EPOCH` 하나로 고정돼 있어서, 시뮬 트윈의 저널 시각이 **재기동마다 되감겼다.**
+   * 며칠을 돈 트윈의 사건들이 전부 `2026-01-01T00:00:xx` 에 몰려 있었고, 그래서 「언제 있었던 일인가」를
+   * 되짚을 수 없었다. 실 시각으로 창을 자르는 성과·이력 질의에는 그 트윈이 아예 보이지 않는다.
+   *
+   * 에너지에서는 더 아프다: 수요 구간은 벽시계의 15분에 맞춰 끊어야 요금과 견줄 수 있는데, 기준점이
+   * 가짜면 그 구간도 가짜 시각에 선다.
+   *
+   * 기본값은 그대로 둔다(시험·결정성). 살아 있는 시뮬 트윈을 세우는 호스트가 실제 시각으로 옮긴다.
+   */
+  originMs = BASE_EPOCH;
   rng = mulberry32(1);
   policy;
   /** duration 시임(선택) — 미주입 시 명세, 명세도 없으면 도메인 상수. 이력 보정 추정기가 여기 들어온다. */
@@ -3519,7 +3543,19 @@ var FlowEngine = class {
    */
   nowMs() {
     const observed = this.observeMode ? this.observer?.lastObservedMs : void 0;
-    return observed ?? BASE_EPOCH + this.clockMs;
+    return observed ?? this.originMs + this.clockMs;
+  }
+  /**
+   * 시각 기준점을 세운다 — **살아 있는 시뮬 트윈은 실제 시각 위에서 돈다.**
+   *
+   * 세우는 쪽(호스트)이 기동 순간의 실제 시각을 준다. 재기동하면 그만큼 앞으로 뛰는데, 그것이 사실이다
+   * (그 사이 이 트윈은 돌지 않았고, 저널의 빈 구간이 그 사실을 말한다).
+   *
+   * 이미 시계가 흐른 뒤에 옮기면 그전에 낸 사실들과 시간축이 어긋나므로 **기동 직후에만** 부른다.
+   */
+  setClockOrigin(originMs) {
+    if (!Number.isFinite(originMs)) throw new Error("clock origin must be a finite epoch millisecond value");
+    this.originMs = originMs;
   }
   now() {
     return new Date(this.nowMs()).toISOString();
@@ -5606,6 +5642,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;
@@ -5640,6 +5679,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 ?? []) {
@@ -5774,11 +5828,22 @@ var EmsKernel = class extends FlowEngine {
          * kW 를 못 읽은 경우(계기 오류·필드 누락)가 실제로 있고, 그것은 「아무것도 오지 않았다」와
          * 다르다. 무엇이 왔는지는 지점별 `samplesInWindow` 가 답한다.
          */
-        ...w.samples === 0 ? { observedAbsence: "no-load-samples" } : {}
+        ...w.samples === 0 ? { observedAbsence: "no-load-samples" } : {},
+        /*
+         * **만든 값이면 그렇게 말한다.** 상태에만 표시하고 사실에는 빠뜨리면, 저널을 읽는 쪽
+         * (성과·이력·보고서)이 시뮬레이션의 수를 계측으로 읽는다 — 값이 그럴듯할수록 위험하다.
+         */
+        ...w.derived ? { derived: true } : {}
       });
       if (w.maxKW !== void 0 && (this.peak === void 0 || w.maxKW > this.peak.kW)) {
         this.peak = { kW: w.maxKW, windowStartMs: w.startMs };
-        this.emitOp(ENERGY_EVENT.peak, { kW: w.maxKW, windowStartMs: w.startMs, ...w.contractKW !== void 0 ? { contractKW: w.contractKW } : {} });
+        this.emitOp(ENERGY_EVENT.peak, {
+          kW: w.maxKW,
+          windowStartMs: w.startMs,
+          ...w.contractKW !== void 0 ? { contractKW: w.contractKW } : {},
+          /* 피크도 그 구간에서 왔다 — 구간이 만든 값이면 피크도 만든 값이다. */
+          ...w.derived ? { derived: true } : {}
+        });
       }
       this.open = void 0;
     }
@@ -5845,9 +5910,62 @@ 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.closeDue(this.clockMs);
+    const at = this.nowMs();
+    this.deriveLoad(at);
+    this.closeDue(at);
   }
   getSnapshot() {
     const snap = super.getSnapshot();

package/package.json

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