@operato/twin-kernel 0.7.14 → 0.7.16

package/dist/contract.d.ts

@@ -1210,8 +1210,27 @@ export interface MeterPointState {
 export interface DemandWindowState {
     startMs: number;
     endMs: number;
-    /** 그 구간의 최대 순간부하 — 표본이 없으면 `undefined`(0 이 아니다). */
+    /**
+     * 그 구간의 최대 순간부하 — 표본이 없으면 `undefined`(0 이 아니다).
+     *
+     * **계통에서 끌어온 수요**다(요금이 이것에 매겨진다). 현장에 발전·축전이 있으면 설비가 끌어당긴
+     * 양과 다르다 — 그 차이는 `grossMaxKW` 와의 간격으로 읽는다.
+     */
     maxKW?: number;
+    /**
+     * 설비가 **끌어당긴** 최대(발전·방전 차감 전, 충전 포함).
+     *
+     * ── 왜 둘을 함께 두나 (2026-08-17) ────────────────────────────────────────
+     * 요금은 계통 수요(`maxKW`)로 매겨지지만, 「무엇이 그 수요를 만들었나」는 설비 부하가 답한다.
+     * 하나만 두면 둘 중 하나를 잃는다: 순수요만 두면 태양광이 잠깐 가려졌을 때 왜 피크가 올랐는지 설명할
+     * 수 없고, 총부하만 두면 요금이 실제보다 커 보인다.
+     *
+     * 그리고 **이 둘의 간격이 곧 깎인 양**이다(피크 셰이빙). 같은 표본에서 나온 두 최대값이므로 비교가
+     * 성립한다 — 서로 다른 창의 값을 견주는 것이 아니다.
+     *
+     * 발전·축전을 선언하지 않은 현장에서는 `maxKW` 와 같다(그때는 차감할 것이 없다).
+     */
+    grossMaxKW?: number;
     /** 표본 평균 부하 — 요금 산정의 평균 수요에 대응한다. */
     meanKW?: number;
     /** **kW 를 실은** 표본 수 — 부하 판정의 근거 수다(받은 표본 전체가 아니다). */
@@ -1414,6 +1433,40 @@ export interface ScenarioDef {
     speed?: number;
     horizon?: number;
     generators: GeneratorSpec[];
+    /**
+     * **가정한 개입** — 시각을 가진 행동들(what-if).
+     *
+     * ── 왜 시나리오에 있나 (2026-08-17) ───────────────────────────────────────
+     * 시나리오는 이미 「우리가 가정한 미래」다. 「30분 뒤 이 설비를 세운다」는 정확히 그 미래의 일부이므로
+     * 여기 있어야 한다. 호스트가 fork 를 굴리며 밖에서 커맨드를 쏘는 방법도 되지만, 그러면 가정이 fork
+     * 밖에 남아 **다른 소비처가 같은 미래를 재생할 수 없다**(예측·백테스트·AI·보드가 각자 타이밍을 다시
+     * 짜야 한다). fork 가 자기완결이면 같은 선언 하나로 어디서든 같은 미래가 나온다.
+     *
+     * `atMs` 는 **시나리오를 시작한 시점부터의 경과**다(절대 시각이 아니다) — fork 는 언제 갈라져도
+     * 같은 가정을 같은 순서로 겪어야 하고, 절대 시각으로 두면 갈라진 시점에 따라 다른 미래가 된다.
+     *
+     * `kind` 는 커맨드 어휘(`CMD`)를 그대로 쓴다 — 개입은 새 종류의 사건이 아니라 **행동**이고, 그 어휘는
+     * 이미 있다. 커널이 모르는 종류는 거절하고 그 사실을 남긴다(조용히 넘기면 「걸었는데 왜 안 바뀌나」를
+     * 아무도 답할 수 없다).
+     */
+    interventions?: ScenarioIntervention[];
+}
+/** 가정한 개입 하나 — 시각 + 행동. */
+export interface ScenarioIntervention {
+    /** 시나리오 시작부터의 경과(ms). 0 이면 시작하는 순간. */
+    atMs: number;
+    /** 커맨드 이름(`CMD` 의 값) — 예: `resource.hold`. */
+    kind: string;
+    args?: Record<string, unknown>;
+}
+/** 개입이 어떻게 됐나 — 걸린 것과 거절된 것. 조용히 사라지지 않게 소비처가 읽는다. */
+export interface InterventionOutcome {
+    atMs: number;
+    kind: string;
+    args?: Record<string, unknown>;
+    applied: boolean;
+    /** 거절 이유(커맨드가 낸 코드). 걸렸으면 없다. */
+    refusedCode?: string;
 }
 export interface ScenarioControl {
     load(def: ScenarioDef): void;

package/dist/ems-kernel.d.ts

@@ -129,6 +129,27 @@ export declare class EmsKernel extends FlowEngine {
      * ④ 미러 트윈에서는 아무것도 만들지 않는다 — 관측 구동은 잰 것만 쓴다.
      */
     private deriveLoad;
+    /** 이 설비가 방전 정책을 **선언했나** — 선언한 것의 방전은 정책이 매 틱 다시 정한다. */
+    private hasDispatchPolicy;
+    /**
+     * 선언된 정책으로 축전지를 방전시킨다 — **선언이 없으면 아무것도 하지 않는다.**
+     *
+     * 돌려주는 값은 이번 틱에 계통에서 덜어낸 kW 다. 부작용으로 그 설비의 `dischargeKW`·`soc` 를 고치고
+     * 사실(`energy.equipment`)을 낸다 — 저널을 읽는 쪽이 「배터리가 무엇을 했나」를 되짚을 수 있어야 한다.
+     *
+     * ── 무엇을 하지 않나 ──────────────────────────────────────────────────────
+     *  · 충전 계획을 만들지 않는다(언제 채울지는 요금 시간대의 일이고, 그 모델은 아직 없다).
+     *  · 용량·임계·최대율이 하나라도 없으면 방전하지 않는다 — 짐작한 수로 피크를 깎지 않는다.
+     *  · 미러 트윈에서는 불리지 않는다(호출자가 이미 관측 모드를 걸러낸다).
+     */
+    private dispatchStorage;
+    /**
+     * 파생된 설비 에너지 상태를 사실로 낸다 — **만든 값임을 밝힌다.**
+     *
+     * 계측으로 들어온 것과 같은 자리에 두면서 종류를 적지 않으면, 저널을 읽는 쪽이 우리가 계산한 방전을
+     * 계기가 잰 방전으로 읽는다(수요 구간의 `derived` 와 같은 규율).
+     */
+    private emitEnergyEquipment;
     /** 자원 속성에서 수 하나 — 값이 수가 아니면 없는 것으로 본다(짐작하지 않는다). */
     private numberProperty;
     tick(dtMs: number): void;

package/dist/ems-kernel.js

@@ -309,6 +309,9 @@ export class EmsKernel extends FlowEngine {
                 startMs: w.startMs,
                 endMs: w.endMs,
                 ...(w.maxKW !== undefined ? { maxKW: w.maxKW } : {}),
+                /* 총부하도 사실로 남긴다 — 이것이 없으면 저널을 읽는 쪽은 「무엇이 깎였나」를 되짚을 수 없다
+                   (요금은 순수요로 매겨지지만, 그 수요를 만든 것은 설비 부하다). */
+                ...(w.grossMaxKW !== undefined ? { grossMaxKW: w.grossMaxKW } : {}),
                 ...(w.meanKW !== undefined ? { meanKW: w.meanKW } : {}),
                 samples: w.samples,
                 ...(w.contractKW !== undefined ? { contractKW: w.contractKW } : {}),
@@ -420,7 +423,7 @@ export class EmsKernel extends FlowEngine {
      * ③ 멈춘 설비는 `power.standbyKW` 를 선언한 만큼만 센다. 선언이 없으면 0 이 아니라 **모름**이다.
      * ④ 미러 트윈에서는 아무것도 만들지 않는다 — 관측 구동은 잰 것만 쓴다.
      */
-    deriveLoad(atMs) {
+    deriveLoad(atMs, dtMs) {
         if (this.observing)
             return; // 미러 — 계측이 진실이다
         let total = 0;
@@ -450,17 +453,157 @@ export class EmsKernel extends FlowEngine {
         }
         if (!counted)
             return; // 셀 것이 하나도 없으면 구간에 값을 넣지 않는다(0 을 주장하지 않는다)
+        /*
+         * ── 계통에서 끌어오는 것은 **순수요**다 (2026-08-17) ──────────────────────
+         *
+         * 그동안 이 함수는 소비만 셌다. 그래서 태양광이 400kW 를 만들고 배터리가 300kW 를 내보내도 계통
+         * 수요가 한 톨도 줄지 않았다 — 「배터리로 피크를 깎는다」가 시뮬에서 성립하지 않는 상태였고,
+         * 그 위에 세운 요금·계약 판정도 그만큼 틀렸다.
+         *
+         * 요금이 매겨지는 것은 계량 지점을 지나는 전력이다:
+         *
+         *   순수요 = 설비 부하 + 충전 − 발전 − 방전
+         *
+         * 충전이 **더해지는** 이유: 배터리를 채우는 동안 그 전기도 계통에서 온다(피크를 만들 수 있다 —
+         * 잘못된 시각에 충전하면 깎으려던 피크를 오히려 키운다. 그 사실이 값에 보여야 한다).
+         *
+         * 음수는 **역송**이지 음의 수요가 아니다. 계통 수요는 0 에서 멈추고, 남는 발전은 그 설비의
+         * `exportKW` 가 이미 사실로 말한다(여기서 다시 만들지 않는다).
+         */
+        let generated = 0;
+        let discharged = 0;
+        let charged = 0;
+        for (const m of this.equipment.values()) {
+            const g = Number(m.generatedKW);
+            if (Number.isFinite(g) && g > 0)
+                generated += g;
+            const c = Number(m.chargeKW);
+            if (Number.isFinite(c) && c > 0)
+                charged += c;
+            /*
+             * **정책이 정하는 방전은 여기서 세지 않는다** (2026-08-17 시험이 잡았다).
+             *
+             * 세면 직전 틱에 우리가 만든 방전이 이번 틱의 입력으로 돌아와, 정책은 「임계 아래다, 쓸 이유가
+             * 없다」고 판단하고 방전을 멈춘다. 그러면 SOC 는 한 번만 줄고 피크는 깎인 채로 굳는다 —
+             * 배터리가 공짜로 무한히 일하는 그림이다.
+             *
+             * 계측으로 들어온 방전(정책이 없는 축전지)은 사실이므로 그대로 센다.
+             */
+            if (this.hasDispatchPolicy(m.id))
+                continue;
+            const d = Number(m.dischargeKW);
+            if (Number.isFinite(d) && d > 0)
+                discharged += d;
+        }
+        const gross = total + charged;
+        /*
+         * ── 선언된 방전 정책이 있으면 여기서 방전한다 (2026-08-17) ────────────────
+         *
+         * 임계를 넘는 만큼만, 최대율 안에서, 예비 SOC 위에 남은 에너지로만. **SOC 가 실제로 줄고**, 다 쓰면
+         * 방전이 멈춰 피크가 다시 올라온다 — 그것이 사실이다. 줄지 않으면 트윈이 「무한히 깎을 수 있다」고
+         * 주장하게 되고, 그 위에 세운 요금 절감액은 짐작이 된다.
+         */
+        const dispatched = this.dispatchStorage(Math.max(0, gross - generated - discharged), atMs, dtMs);
+        const net = Math.max(0, gross - generated - discharged - dispatched);
         this.closeDue(atMs);
         this.openWindow(atMs);
         const w = this.open;
         w.derived = true;
-        if (w.maxKW === undefined || total > w.maxKW)
-            w.maxKW = total;
+        /* 요금이 보는 수는 순수요다. 총부하는 「무엇이 그 수요를 만들었나」를 위해 함께 남긴다. */
+        if (w.maxKW === undefined || net > w.maxKW)
+            w.maxKW = net;
+        if (w.grossMaxKW === undefined || gross > w.grossMaxKW)
+            w.grossMaxKW = gross;
         w.samples++;
-        w.meanKW = w.meanKW === undefined ? total : (w.meanKW * (w.samples - 1) + total) / w.samples;
+        w.meanKW = w.meanKW === undefined ? net : (w.meanKW * (w.samples - 1) + net) / w.samples;
         this.revision++;
         this.judgeOpenWindow(atMs);
     }
+    /** 이 설비가 방전 정책을 **선언했나** — 선언한 것의 방전은 정책이 매 틱 다시 정한다. */
+    hasDispatchPolicy(equipmentId) {
+        for (const e of this.boardDef?.equipment ?? []) {
+            if (e.id !== equipmentId)
+                continue;
+            return (this.numberProperty(e, EMS_PROPERTY.capacityKWh) !== undefined &&
+                this.numberProperty(e, EMS_PROPERTY.dischargeAboveKW) !== undefined &&
+                this.numberProperty(e, EMS_PROPERTY.maxDischargeKW) !== undefined);
+        }
+        return false;
+    }
+    /**
+     * 선언된 정책으로 축전지를 방전시킨다 — **선언이 없으면 아무것도 하지 않는다.**
+     *
+     * 돌려주는 값은 이번 틱에 계통에서 덜어낸 kW 다. 부작용으로 그 설비의 `dischargeKW`·`soc` 를 고치고
+     * 사실(`energy.equipment`)을 낸다 — 저널을 읽는 쪽이 「배터리가 무엇을 했나」를 되짚을 수 있어야 한다.
+     *
+     * ── 무엇을 하지 않나 ──────────────────────────────────────────────────────
+     *  · 충전 계획을 만들지 않는다(언제 채울지는 요금 시간대의 일이고, 그 모델은 아직 없다).
+     *  · 용량·임계·최대율이 하나라도 없으면 방전하지 않는다 — 짐작한 수로 피크를 깎지 않는다.
+     *  · 미러 트윈에서는 불리지 않는다(호출자가 이미 관측 모드를 걸러낸다).
+     */
+    dispatchStorage(demandBeforeStorageKW, atMs, dtMs) {
+        let dispatched = 0;
+        for (const e of this.boardDef?.equipment ?? []) {
+            const capacity = this.numberProperty(e, EMS_PROPERTY.capacityKWh);
+            const above = this.numberProperty(e, EMS_PROPERTY.dischargeAboveKW);
+            const maxRate = this.numberProperty(e, EMS_PROPERTY.maxDischargeKW);
+            if (capacity === undefined || above === undefined || maxRate === undefined)
+                continue;
+            if (!(capacity > 0) || !(maxRate > 0))
+                continue;
+            const state = this.equipment.get(e.id);
+            if (!state)
+                continue;
+            const over = demandBeforeStorageKW - dispatched - above;
+            if (over <= 0) {
+                /* 임계 아래 — 쓸 이유가 없다. 낡은 방전값을 남기지 않는다(상태가 지난 틱을 말하게 된다). */
+                if (Number(state.dischargeKW) > 0) {
+                    state.dischargeKW = 0;
+                    this.emitEnergyEquipment(e.id, atMs, { dischargeKW: 0, ...(Number.isFinite(Number(state.soc)) ? { soc: Number(state.soc) } : {}) });
+                }
+                continue;
+            }
+            const reserve = this.numberProperty(e, EMS_PROPERTY.reserveSoc) ?? 0;
+            /* SOC 를 모르면 방전하지 않는다 — 남은 에너지를 모른 채 쓰면 얼마나 버티는지 지어내는 것이다. */
+            const soc = Number(state.soc);
+            if (!Number.isFinite(soc))
+                continue;
+            const usableKWh = ((soc - reserve) / 100) * capacity;
+            if (!(usableKWh > 0)) {
+                /* 다 썼다 — 방전을 멈추고 그 사실을 남긴다(피크가 다시 올라오는 것이 사실이다). */
+                if (Number(state.dischargeKW) > 0) {
+                    state.dischargeKW = 0;
+                    this.emitEnergyEquipment(e.id, atMs, { dischargeKW: 0, soc });
+                }
+                continue;
+            }
+            /*
+             * 이 틱에 낼 수 있는 kW — 남은 에너지를 이 틱 길이로 나눈 값이 상한이다. 틱이 짧으면 이 상한은
+             * 아주 크므로 실제로 묶는 것은 **누적**이다(SOC 가 줄면서 곧 위 검사에 걸린다).
+             */
+            const dtHours = dtMs / 3_600_000;
+            const rateCap = dtHours > 0 ? usableKWh / dtHours : maxRate;
+            const kW = Math.min(maxRate, over, rateCap);
+            if (!(kW > 0))
+                continue;
+            const drained = dtHours > 0 ? ((kW * dtHours) / capacity) * 100 : 0;
+            const nextSoc = Math.max(reserve, soc - drained);
+            state.dischargeKW = kW;
+            state.soc = nextSoc;
+            this.emitEnergyEquipment(e.id, atMs, { dischargeKW: kW, soc: nextSoc });
+            dispatched += kW;
+        }
+        return dispatched;
+    }
+    /**
+     * 파생된 설비 에너지 상태를 사실로 낸다 — **만든 값임을 밝힌다.**
+     *
+     * 계측으로 들어온 것과 같은 자리에 두면서 종류를 적지 않으면, 저널을 읽는 쪽이 우리가 계산한 방전을
+     * 계기가 잰 방전으로 읽는다(수요 구간의 `derived` 와 같은 규율).
+     */
+    emitEnergyEquipment(equipmentId, atMs, fields) {
+        this.emitOp(ENERGY_EVENT.equipment, { equipmentId, at: new Date(atMs).toISOString(), derived: true, ...fields });
+    }
     /** 자원 속성에서 수 하나 — 값이 수가 아니면 없는 것으로 본다(짐작하지 않는다). */
     numberProperty(resource, id) {
         for (const p of resource?.properties ?? []) {
@@ -484,7 +627,8 @@ export class EmsKernel extends FlowEngine {
          * 부하를 먼저 만들고 마감한다 — 마감이 먼저면 마지막 값이 다음 구간으로 밀린다.
          */
         const at = this.nowMs();
-        this.deriveLoad(at);
+        /* 틱 길이를 함께 넘긴다 — 방전량을 에너지로 바꿀 때 필요하다(필드로 숨기면 어디서 온 값인지 흐려진다). */
+        this.deriveLoad(at, dtMs);
         this.closeDue(at);
     }
     getSnapshot() {

package/dist/ems-profile.d.ts

@@ -22,5 +22,13 @@ export declare const EMS_PROPERTY: {
     readonly energyChargePerKWh: "tariff.energyChargePerKWh";
     /** 통화 — ISO 4217 코드(USD·KRW…). 없으면 금액에 단위를 붙이지 않는다. */
     readonly currency: "tariff.currency";
+    /** 축전지 용량(kWh) — SOC 를 에너지로 바꾸는 값. 없으면 방전을 만들지 않는다. */
+    readonly capacityKWh: "storage.capacityKWh";
+    /** 이 순수요를 넘으면 방전한다(kW) — 피크 억제 임계. */
+    readonly dischargeAboveKW: "dispatch.dischargeAboveKW";
+    /** 최대 방전율(kW) — 인버터가 낼 수 있는 한계. */
+    readonly maxDischargeKW: "dispatch.maxDischargeKW";
+    /** 예비 SOC(%) — 이 아래로는 쓰지 않는다(비상 대비). 없으면 0 으로 본다. */
+    readonly reserveSoc: "dispatch.reserveSoc";
 };
 export declare const EMS_TYPES: TwinTypeInfo[];

package/dist/ems-profile.js

@@ -39,7 +39,29 @@ export const EMS_PROPERTY = {
     /** 사용량 단가 — 1kWh 당. */
     energyChargePerKWh: 'tariff.energyChargePerKWh',
     /** 통화 — ISO 4217 코드(USD·KRW…). 없으면 금액에 단위를 붙이지 않는다. */
-    currency: 'tariff.currency'
+    currency: 'tariff.currency',
+    /*
+     * ── 축전지의 용량과 방전 정책 (2026-08-17) ─────────────────────────────────
+     *
+     * 「배터리로 피크를 깎는다」를 시뮬이 보이려면 방전을 만들어야 하고, 그것은 **선언에서** 나와야 한다.
+     * 임계·최대율·예비를 우리가 정하면 그 수가 어디서 왔는지 아무도 설명할 수 없다.
+     *
+     * ── 선언한다는 것은 「그 자동화가 있다」는 주장이다 ─────────────────────────
+     * 이 정책을 모델에 적으면 **라이브가 아닌 모든 구동이 그 규칙으로 돈다.** 현장에 BESS 제어기가 없는데
+     * 적으면 파생 부하가 실제보다 낙관적으로 나온다(피크가 깎인 것으로 보인다). 그러니 「도입하면?」을
+     * 묻는 것이라면 선언이 아니라 **what-if 가 덮어쓸 일**이다.
+     *
+     * 용량이 없으면 방전하지 않는다 — 용량을 모르면 「얼마나 버티나」를 답할 수 없고, 버티는 시간을
+     * 모른 채 깎으면 무한히 깎을 수 있다고 주장하는 셈이다.
+     */
+    /** 축전지 용량(kWh) — SOC 를 에너지로 바꾸는 값. 없으면 방전을 만들지 않는다. */
+    capacityKWh: 'storage.capacityKWh',
+    /** 이 순수요를 넘으면 방전한다(kW) — 피크 억제 임계. */
+    dischargeAboveKW: 'dispatch.dischargeAboveKW',
+    /** 최대 방전율(kW) — 인버터가 낼 수 있는 한계. */
+    maxDischargeKW: 'dispatch.maxDischargeKW',
+    /** 예비 SOC(%) — 이 아래로는 쓰지 않는다(비상 대비). 없으면 0 으로 본다. */
+    reserveSoc: 'dispatch.reserveSoc'
 };
 export const EMS_TYPES = [
     /* ── 자리: 전기적 구간 ─────────────────────────────────────────────────── */

package/dist/energy-attribution.d.ts

@@ -185,6 +185,15 @@ export interface WindowedEnergy {
     peakKW?: number;
     /** 그 최대수요가 난 구간의 시작 — 「언제였나」를 물으면 답할 수 있어야 한다. */
     peakStartMs?: number;
+    /**
+     * **그 피크 구간에서 설비가 끌어당긴 최대**(발전·방전 차감 전).
+     *
+     * `peakKW` 와의 간격이 그 순간에 깎인 양이다(태양광·배터리가 계통에서 덜어낸 몫). 다른 구간의 값과
+     * 견주지 않는다 — **같은 구간의 두 수**여야 그 차이가 뜻을 갖는다.
+     *
+     * 발전·축전을 선언하지 않은 현장에서는 `peakKW` 와 같다.
+     */
+    peakGrossKW?: number;
     /**
      * 어떻게 얻었나 — **파생임을 숨기지 않는다.**
      *  · `mean-kw` — 구간 평균부하 × 구간 길이. 표본의 평균이므로 **추정**이다.
@@ -217,6 +226,7 @@ export declare function energyOfWindows(windows: readonly {
     endMs: number;
     meanKW?: number;
     maxKW?: number;
+    grossMaxKW?: number;
 }[], range?: {
     startMs: number;
     endMs: number;

package/dist/energy-attribution.js

@@ -205,6 +205,7 @@ export function energyOfWindows(windows, range) {
     let last;
     let peakKW;
     let peakStartMs;
+    let peakGrossKW;
     for (const w of windows ?? []) {
         if (!inRange(w))
             continue;
@@ -216,6 +217,9 @@ export function energyOfWindows(windows, range) {
         if (Number.isFinite(max) && (peakKW === undefined || max > peakKW)) {
             peakKW = max;
             peakStartMs = Number(w.startMs);
+            /* **그 구간의** 총부하를 함께 집는다 — 다른 구간의 총부하와 견주면 차이가 뜻을 잃는다. */
+            const gross = Number(w.grossMaxKW);
+            peakGrossKW = Number.isFinite(gross) ? gross : undefined;
         }
         const mean = Number(w.meanKW);
         const hours = (Number(w.endMs) - Number(w.startMs)) / 3_600_000;
@@ -233,6 +237,7 @@ export function energyOfWindows(windows, range) {
     return {
         ...(counted > 0 ? { kWh } : {}),
         ...(peakKW !== undefined ? { peakKW, peakStartMs } : {}),
+        ...(peakGrossKW !== undefined ? { peakGrossKW } : {}),
         basis: 'mean-kw',
         counted,
         skipped,

package/dist/flow-engine.d.ts

@@ -1,4 +1,4 @@
-import type { TestResult, ISOTime, MaterialQuantity, WorkCalendarEntry, EffectivePeriod, Effectivity, OffCalendarReason, ResourceProperty, ResourceClassDef, MaterialDefinition, Attention, TwinModelDef, CanonicalEnvelope, Command, CommandAck, EventHandler, EquipmentMotion, OeeMetrics, AssetState, GeneratorSpec, OrderState, PersonState, ScenarioControl, StateSnapshot, TwinKernel, Unsubscribe, LocationState, ItemState, EquipmentState, OrderStatusDelta, TaskState, StructureShift } from './contract.ts';
+import type { TestResult, ISOTime, MaterialQuantity, WorkCalendarEntry, EffectivePeriod, Effectivity, OffCalendarReason, ResourceProperty, ResourceClassDef, MaterialDefinition, Attention, TwinModelDef, CanonicalEnvelope, Command, CommandAck, EventHandler, EquipmentMotion, OeeMetrics, AssetState, GeneratorSpec, InterventionOutcome, OrderState, PersonState, ScenarioControl, StateSnapshot, TwinKernel, Unsubscribe, LocationState, ItemState, EquipmentState, OrderStatusDelta, TaskState, StructureShift } from './contract.ts';
 import type { EpcisEvent, BizTransactionElement } from './epcis.ts';
 import type { AllocationPolicy, SlotView } from './allocation-policy.ts';
 import type { DurationEstimator, DurationContext } from './duration-estimator.ts';
@@ -325,6 +325,10 @@ export declare abstract class FlowEngine implements TwinKernel {
     /** 구독자 접근(관측 재방출) — emit 과 같은 목록을 쓴다(두 경로가 갈리지 않게). */
     private handlersRef;
     private gens;
+    /** 가정한 개입 — 시나리오가 실어 온 것들. `pendingMs` 는 시나리오 시작 기준 절대 클록으로 바뀐다. */
+    private interventions;
+    /** 개입이 어떻게 됐나 — 걸린 것·거절된 것. 조용히 사라지지 않게 소비처가 읽는다. */
+    private interventionLog;
     private generating;
     private speed;
     private eventSeq;
@@ -412,6 +416,18 @@ export declare abstract class FlowEngine implements TwinKernel {
         /** 확인해 둔 주목 신호 id — 계산으로 되살릴 수 없는 유일한 축이라 스냅샷에서 이어받는다. */
         acked?: string[];
     }, orders?: OrderStatusDelta[]): void;
+    /**
+     * what-if 구성 변주 — **선언을 덮어쓴다**(fork 대상). 바꿨으면 true.
+     *
+     * ── 왜 커맨드가 아닌가 (2026-08-17) ───────────────────────────────────────
+     * 「배터리에 피크 억제 정책을 넣으면?」은 **행동이 아니라 모델의 변주**다. 커맨드로 만들면 트윈이 실물
+     * 설비의 설정을 바꿀 수 있다는 뜻이 되는데, 제어는 범위 밖으로 두기로 했다(보호 계통·안전 사슬).
+     * 그래서 자리 용량 변경과 같은 자리에 둔다 — fork 에서 「만약 이렇게 선언돼 있었다면」을 묻는 손잡이다.
+     *
+     * **선언에 없던 속성도 넣을 수 있다** — 그것이 「도입하면?」의 뜻이다. 다만 원본이 아니라 fork 에
+     * 걸어야 한다: 실행 중 트윈에 걸면 그 트윈이 「우리 현장에 그 자동화가 있다」고 주장하게 된다.
+     */
+    setResourceProperty(resourceId: string, propertyId: string, value: string | number): boolean;
     /** what-if 구성 변주 — 자리 용량 변경(fork 대상). 존재하면 true. */
     setLocationCapacity(locationId: string, capacity: number): boolean;
     /**
@@ -451,6 +467,19 @@ export declare abstract class FlowEngine implements TwinKernel {
      * rng 는 fork 의 시나리오 load 시 재시드(드레인 예측은 생성 없어 rng 무관·결정적).
      */
     fork(tenantId?: string): this;
+    /**
+     * 시각이 된 개입을 적용한다 — **한 번만, 그리고 결과를 남긴다.**
+     *
+     * 거절도 사실이다: 커널이 모르는 종류이거나 대상이 없으면 커맨드가 코드로 답하고, 우리는 그것을
+     * 기록한다. 조용히 넘기면 「걸었는데 왜 안 바뀌나」를 아무도 답할 수 없다.
+     */
+    private applyInterventions;
+    /**
+     * 가정한 개입이 어떻게 됐나 — 소비처(예측 화면·AI)가 그대로 옮긴다.
+     *
+     * 아직 시각이 오지 않은 것은 여기 없다(일어나지 않은 일을 결과로 적지 않는다).
+     */
+    interventionOutcomes(): InterventionOutcome[];
     /**
      * 이 커널의 **지금**(ms) — 시각으로 바뀌는 모든 판정의 단일 기준.
      *

package/dist/flow-engine.js

@@ -286,6 +286,10 @@ export class FlowEngine {
         return this.handlers;
     }
     gens = [];
+    /** 가정한 개입 — 시나리오가 실어 온 것들. `pendingMs` 는 시나리오 시작 기준 절대 클록으로 바뀐다. */
+    interventions = [];
+    /** 개입이 어떻게 됐나 — 걸린 것·거절된 것. 조용히 사라지지 않게 소비처가 읽는다. */
+    interventionLog = [];
     generating = false;
     speed = 1;
     eventSeq = 0;
@@ -682,6 +686,31 @@ export class FlowEngine {
                 'they cannot be continued (the item was consumed/shipped, or the observation did not carry it).');
         }
     }
+    /**
+     * what-if 구성 변주 — **선언을 덮어쓴다**(fork 대상). 바꿨으면 true.
+     *
+     * ── 왜 커맨드가 아닌가 (2026-08-17) ───────────────────────────────────────
+     * 「배터리에 피크 억제 정책을 넣으면?」은 **행동이 아니라 모델의 변주**다. 커맨드로 만들면 트윈이 실물
+     * 설비의 설정을 바꿀 수 있다는 뜻이 되는데, 제어는 범위 밖으로 두기로 했다(보호 계통·안전 사슬).
+     * 그래서 자리 용량 변경과 같은 자리에 둔다 — fork 에서 「만약 이렇게 선언돼 있었다면」을 묻는 손잡이다.
+     *
+     * **선언에 없던 속성도 넣을 수 있다** — 그것이 「도입하면?」의 뜻이다. 다만 원본이 아니라 fork 에
+     * 걸어야 한다: 실행 중 트윈에 걸면 그 트윈이 「우리 현장에 그 자동화가 있다」고 주장하게 된다.
+     */
+    setResourceProperty(resourceId, propertyId, value) {
+        for (const e of this.boardDef?.equipment ?? []) {
+            if (e.id !== resourceId)
+                continue;
+            const props = (e.properties ??= []);
+            const found = props.find((p) => p?.id === propertyId);
+            if (found)
+                found.value = String(value);
+            else
+                props.push({ id: propertyId, value: String(value) });
+            return true;
+        }
+        return false;
+    }
     /** what-if 구성 변주 — 자리 용량 변경(fork 대상). 존재하면 true. */
     setLocationCapacity(locationId, capacity) {
         const n = this.locations.get(locationId);
@@ -843,6 +872,9 @@ export class FlowEngine {
             this.rng = mulberry32((def.seed ?? 1) >>> 0);
             this.speed = def.speed ?? 1;
             this.gens = def.generators.map(spec => ({ spec, nextMs: 0 }));
+            /* 개입은 **시작할 때** 시각이 정해진다(경과 기준) — 여기서는 받아만 둔다. */
+            this.interventions = (def.interventions ?? []).map(spec => ({ spec, dueMs: 0, done: false }));
+            this.interventionLog = [];
         },
         start: () => {
             if (this.generating)
@@ -850,14 +882,25 @@ export class FlowEngine {
             this.generating = true;
             for (const g of this.gens)
                 g.nextMs = this.nextFireMs(g.spec, this.clockMs);
+            /* 경과를 지금 기준으로 절대화한다 — fork 가 언제 갈라져도 같은 가정을 같은 순서로 겪는다. */
+            for (const iv of this.interventions) {
+                iv.dueMs = this.clockMs + Math.max(0, Number(iv.spec.atMs) || 0);
+                iv.done = false;
+            }
         },
         pause: () => { this.generating = false; },
-        reset: () => { this.generating = false; this.gens = []; },
+        reset: () => { this.generating = false; this.gens = []; this.interventions = []; this.interventionLog = []; },
         setSpeed: (f) => { this.speed = f; }
     };
     tick(dtMs) {
         const dt = dtMs * this.speed;
         this.clockMs += dt;
+        /*
+         * 개입을 **자극보다 먼저** 적용한다 — 그 틱에 생기는 일이 바뀐 조건을 보게 해야 한다.
+         * 나중에 적용하면 「세운 설비에 일감을 배정한 뒤 세우는」 한 틱이 생긴다.
+         */
+        if (this.generating)
+            this.applyInterventions();
         if (this.generating)
             this.generate();
         this.processFailures(dt);
@@ -1039,6 +1082,41 @@ export class FlowEngine {
         clone.specUse = new Map([...this.specUse.entries()].map(([k, u]) => [k, { duration: u.duration, variability: u.variability, params: new Set(u.params) }]));
         return clone;
     }
+    /**
+     * 시각이 된 개입을 적용한다 — **한 번만, 그리고 결과를 남긴다.**
+     *
+     * 거절도 사실이다: 커널이 모르는 종류이거나 대상이 없으면 커맨드가 코드로 답하고, 우리는 그것을
+     * 기록한다. 조용히 넘기면 「걸었는데 왜 안 바뀌나」를 아무도 답할 수 없다.
+     */
+    applyInterventions() {
+        for (const iv of this.interventions) {
+            if (iv.done || this.clockMs < iv.dueMs)
+                continue;
+            iv.done = true;
+            /* 커맨드 계약 그대로 만든다 — 개입은 새 종류의 사건이 아니라 **행동**이다. */
+            const ack = this.dispatch({
+                commandId: `iv-${this.tenantId}-${iv.spec.kind}-${iv.dueMs}`,
+                type: iv.spec.kind,
+                tenantId: this.tenantId,
+                args: iv.spec.args ?? {}
+            });
+            this.interventionLog.push({
+                atMs: iv.spec.atMs,
+                kind: iv.spec.kind,
+                ...(iv.spec.args ? { args: iv.spec.args } : {}),
+                applied: ack.accepted === true,
+                ...(ack.accepted === true ? {} : { refusedCode: ack.errorCode ?? 'refused' })
+            });
+        }
+    }
+    /**
+     * 가정한 개입이 어떻게 됐나 — 소비처(예측 화면·AI)가 그대로 옮긴다.
+     *
+     * 아직 시각이 오지 않은 것은 여기 없다(일어나지 않은 일을 결과로 적지 않는다).
+     */
+    interventionOutcomes() {
+        return this.interventionLog.map(o => ({ ...o }));
+    }
     // ── 보호 헬퍼 (도메인 hook 에서 사용) ──────────────────────────────────────
     /**
      * 이 커널의 **지금**(ms) — 시각으로 바뀌는 모든 판정의 단일 기준.

package/dist-cjs/index.cjs

@@ -1703,7 +1703,29 @@ var EMS_PROPERTY = {
   /** 사용량 단가 — 1kWh 당. */
   energyChargePerKWh: "tariff.energyChargePerKWh",
   /** 통화 — ISO 4217 코드(USD·KRW…). 없으면 금액에 단위를 붙이지 않는다. */
-  currency: "tariff.currency"
+  currency: "tariff.currency",
+  /*
+   * ── 축전지의 용량과 방전 정책 (2026-08-17) ─────────────────────────────────
+   *
+   * 「배터리로 피크를 깎는다」를 시뮬이 보이려면 방전을 만들어야 하고, 그것은 **선언에서** 나와야 한다.
+   * 임계·최대율·예비를 우리가 정하면 그 수가 어디서 왔는지 아무도 설명할 수 없다.
+   *
+   * ── 선언한다는 것은 「그 자동화가 있다」는 주장이다 ─────────────────────────
+   * 이 정책을 모델에 적으면 **라이브가 아닌 모든 구동이 그 규칙으로 돈다.** 현장에 BESS 제어기가 없는데
+   * 적으면 파생 부하가 실제보다 낙관적으로 나온다(피크가 깎인 것으로 보인다). 그러니 「도입하면?」을
+   * 묻는 것이라면 선언이 아니라 **what-if 가 덮어쓸 일**이다.
+   *
+   * 용량이 없으면 방전하지 않는다 — 용량을 모르면 「얼마나 버티나」를 답할 수 없고, 버티는 시간을
+   * 모른 채 깎으면 무한히 깎을 수 있다고 주장하는 셈이다.
+   */
+  /** 축전지 용량(kWh) — SOC 를 에너지로 바꾸는 값. 없으면 방전을 만들지 않는다. */
+  capacityKWh: "storage.capacityKWh",
+  /** 이 순수요를 넘으면 방전한다(kW) — 피크 억제 임계. */
+  dischargeAboveKW: "dispatch.dischargeAboveKW",
+  /** 최대 방전율(kW) — 인버터가 낼 수 있는 한계. */
+  maxDischargeKW: "dispatch.maxDischargeKW",
+  /** 예비 SOC(%) — 이 아래로는 쓰지 않는다(비상 대비). 없으면 0 으로 본다. */
+  reserveSoc: "dispatch.reserveSoc"
 };
 var EMS_TYPES = [
   /* ── 자리: 전기적 구간 ─────────────────────────────────────────────────── */
@@ -2970,6 +2992,10 @@ var FlowEngine = class {
     return this.handlers;
   }
   gens = [];
+  /** 가정한 개입 — 시나리오가 실어 온 것들. `pendingMs` 는 시나리오 시작 기준 절대 클록으로 바뀐다. */
+  interventions = [];
+  /** 개입이 어떻게 됐나 — 걸린 것·거절된 것. 조용히 사라지지 않게 소비처가 읽는다. */
+  interventionLog = [];
   generating = false;
   speed = 1;
   eventSeq = 0;
@@ -3334,6 +3360,28 @@ var FlowEngine = class {
       );
     }
   }
+  /**
+   * what-if 구성 변주 — **선언을 덮어쓴다**(fork 대상). 바꿨으면 true.
+   *
+   * ── 왜 커맨드가 아닌가 (2026-08-17) ───────────────────────────────────────
+   * 「배터리에 피크 억제 정책을 넣으면?」은 **행동이 아니라 모델의 변주**다. 커맨드로 만들면 트윈이 실물
+   * 설비의 설정을 바꿀 수 있다는 뜻이 되는데, 제어는 범위 밖으로 두기로 했다(보호 계통·안전 사슬).
+   * 그래서 자리 용량 변경과 같은 자리에 둔다 — fork 에서 「만약 이렇게 선언돼 있었다면」을 묻는 손잡이다.
+   *
+   * **선언에 없던 속성도 넣을 수 있다** — 그것이 「도입하면?」의 뜻이다. 다만 원본이 아니라 fork 에
+   * 걸어야 한다: 실행 중 트윈에 걸면 그 트윈이 「우리 현장에 그 자동화가 있다」고 주장하게 된다.
+   */
+  setResourceProperty(resourceId, propertyId, value) {
+    for (const e of this.boardDef?.equipment ?? []) {
+      if (e.id !== resourceId) continue;
+      const props = e.properties ??= [];
+      const found = props.find((p) => p?.id === propertyId);
+      if (found) found.value = String(value);
+      else props.push({ id: propertyId, value: String(value) });
+      return true;
+    }
+    return false;
+  }
   /** what-if 구성 변주 — 자리 용량 변경(fork 대상). 존재하면 true. */
   setLocationCapacity(locationId, capacity) {
     const n = this.locations.get(locationId);
@@ -3473,11 +3521,17 @@ var FlowEngine = class {
       this.rng = mulberry32((def.seed ?? 1) >>> 0);
       this.speed = def.speed ?? 1;
       this.gens = def.generators.map((spec) => ({ spec, nextMs: 0 }));
+      this.interventions = (def.interventions ?? []).map((spec) => ({ spec, dueMs: 0, done: false }));
+      this.interventionLog = [];
     },
     start: () => {
       if (this.generating) return;
       this.generating = true;
       for (const g of this.gens) g.nextMs = this.nextFireMs(g.spec, this.clockMs);
+      for (const iv of this.interventions) {
+        iv.dueMs = this.clockMs + Math.max(0, Number(iv.spec.atMs) || 0);
+        iv.done = false;
+      }
     },
     pause: () => {
       this.generating = false;
@@ -3485,6 +3539,8 @@ var FlowEngine = class {
     reset: () => {
       this.generating = false;
       this.gens = [];
+      this.interventions = [];
+      this.interventionLog = [];
     },
     setSpeed: (f) => {
       this.speed = f;
@@ -3493,6 +3549,7 @@ var FlowEngine = class {
   tick(dtMs) {
     const dt = dtMs * this.speed;
     this.clockMs += dt;
+    if (this.generating) this.applyInterventions();
     if (this.generating) this.generate();
     this.processFailures(dt);
     this.processOrders();
@@ -3654,6 +3711,39 @@ var FlowEngine = class {
     clone.specUse = new Map([...this.specUse.entries()].map(([k, u]) => [k, { duration: u.duration, variability: u.variability, params: new Set(u.params) }]));
     return clone;
   }
+  /**
+   * 시각이 된 개입을 적용한다 — **한 번만, 그리고 결과를 남긴다.**
+   *
+   * 거절도 사실이다: 커널이 모르는 종류이거나 대상이 없으면 커맨드가 코드로 답하고, 우리는 그것을
+   * 기록한다. 조용히 넘기면 「걸었는데 왜 안 바뀌나」를 아무도 답할 수 없다.
+   */
+  applyInterventions() {
+    for (const iv of this.interventions) {
+      if (iv.done || this.clockMs < iv.dueMs) continue;
+      iv.done = true;
+      const ack = this.dispatch({
+        commandId: `iv-${this.tenantId}-${iv.spec.kind}-${iv.dueMs}`,
+        type: iv.spec.kind,
+        tenantId: this.tenantId,
+        args: iv.spec.args ?? {}
+      });
+      this.interventionLog.push({
+        atMs: iv.spec.atMs,
+        kind: iv.spec.kind,
+        ...iv.spec.args ? { args: iv.spec.args } : {},
+        applied: ack.accepted === true,
+        ...ack.accepted === true ? {} : { refusedCode: ack.errorCode ?? "refused" }
+      });
+    }
+  }
+  /**
+   * 가정한 개입이 어떻게 됐나 — 소비처(예측 화면·AI)가 그대로 옮긴다.
+   *
+   * 아직 시각이 오지 않은 것은 여기 없다(일어나지 않은 일을 결과로 적지 않는다).
+   */
+  interventionOutcomes() {
+    return this.interventionLog.map((o) => ({ ...o }));
+  }
   // ── 보호 헬퍼 (도메인 hook 에서 사용) ──────────────────────────────────────
   /**
    * 이 커널의 **지금**(ms) — 시각으로 바뀌는 모든 판정의 단일 기준.
@@ -6019,6 +6109,9 @@ var EmsKernel = class extends FlowEngine {
         startMs: w.startMs,
         endMs: w.endMs,
         ...w.maxKW !== void 0 ? { maxKW: w.maxKW } : {},
+        /* 총부하도 사실로 남긴다 — 이것이 없으면 저널을 읽는 쪽은 「무엇이 깎였나」를 되짚을 수 없다
+           (요금은 순수요로 매겨지지만, 그 수요를 만든 것은 설비 부하다). */
+        ...w.grossMaxKW !== void 0 ? { grossMaxKW: w.grossMaxKW } : {},
         ...w.meanKW !== void 0 ? { meanKW: w.meanKW } : {},
         samples: w.samples,
         ...w.contractKW !== void 0 ? { contractKW: w.contractKW } : {},
@@ -6123,7 +6216,7 @@ var EmsKernel = class extends FlowEngine {
    * ③ 멈춘 설비는 `power.standbyKW` 를 선언한 만큼만 센다. 선언이 없으면 0 이 아니라 **모름**이다.
    * ④ 미러 트윈에서는 아무것도 만들지 않는다 — 관측 구동은 잰 것만 쓴다.
    */
-  deriveLoad(atMs) {
+  deriveLoad(atMs, dtMs) {
     if (this.observing) return;
     let total = 0;
     let counted = 0;
@@ -6144,16 +6237,102 @@ var EmsKernel = class extends FlowEngine {
       }
     }
     if (!counted) return;
+    let generated = 0;
+    let discharged = 0;
+    let charged = 0;
+    for (const m of this.equipment.values()) {
+      const g = Number(m.generatedKW);
+      if (Number.isFinite(g) && g > 0) generated += g;
+      const c = Number(m.chargeKW);
+      if (Number.isFinite(c) && c > 0) charged += c;
+      if (this.hasDispatchPolicy(m.id)) continue;
+      const d = Number(m.dischargeKW);
+      if (Number.isFinite(d) && d > 0) discharged += d;
+    }
+    const gross = total + charged;
+    const dispatched = this.dispatchStorage(Math.max(0, gross - generated - discharged), atMs, dtMs);
+    const net = Math.max(0, gross - generated - discharged - dispatched);
     this.closeDue(atMs);
     this.openWindow(atMs);
     const w = this.open;
     w.derived = true;
-    if (w.maxKW === void 0 || total > w.maxKW) w.maxKW = total;
+    if (w.maxKW === void 0 || net > w.maxKW) w.maxKW = net;
+    if (w.grossMaxKW === void 0 || gross > w.grossMaxKW) w.grossMaxKW = gross;
     w.samples++;
-    w.meanKW = w.meanKW === void 0 ? total : (w.meanKW * (w.samples - 1) + total) / w.samples;
+    w.meanKW = w.meanKW === void 0 ? net : (w.meanKW * (w.samples - 1) + net) / w.samples;
     this.revision++;
     this.judgeOpenWindow(atMs);
   }
+  /** 이 설비가 방전 정책을 **선언했나** — 선언한 것의 방전은 정책이 매 틱 다시 정한다. */
+  hasDispatchPolicy(equipmentId) {
+    for (const e of this.boardDef?.equipment ?? []) {
+      if (e.id !== equipmentId) continue;
+      return this.numberProperty(e, EMS_PROPERTY.capacityKWh) !== void 0 && this.numberProperty(e, EMS_PROPERTY.dischargeAboveKW) !== void 0 && this.numberProperty(e, EMS_PROPERTY.maxDischargeKW) !== void 0;
+    }
+    return false;
+  }
+  /**
+   * 선언된 정책으로 축전지를 방전시킨다 — **선언이 없으면 아무것도 하지 않는다.**
+   *
+   * 돌려주는 값은 이번 틱에 계통에서 덜어낸 kW 다. 부작용으로 그 설비의 `dischargeKW`·`soc` 를 고치고
+   * 사실(`energy.equipment`)을 낸다 — 저널을 읽는 쪽이 「배터리가 무엇을 했나」를 되짚을 수 있어야 한다.
+   *
+   * ── 무엇을 하지 않나 ──────────────────────────────────────────────────────
+   *  · 충전 계획을 만들지 않는다(언제 채울지는 요금 시간대의 일이고, 그 모델은 아직 없다).
+   *  · 용량·임계·최대율이 하나라도 없으면 방전하지 않는다 — 짐작한 수로 피크를 깎지 않는다.
+   *  · 미러 트윈에서는 불리지 않는다(호출자가 이미 관측 모드를 걸러낸다).
+   */
+  dispatchStorage(demandBeforeStorageKW, atMs, dtMs) {
+    let dispatched = 0;
+    for (const e of this.boardDef?.equipment ?? []) {
+      const capacity = this.numberProperty(e, EMS_PROPERTY.capacityKWh);
+      const above = this.numberProperty(e, EMS_PROPERTY.dischargeAboveKW);
+      const maxRate = this.numberProperty(e, EMS_PROPERTY.maxDischargeKW);
+      if (capacity === void 0 || above === void 0 || maxRate === void 0) continue;
+      if (!(capacity > 0) || !(maxRate > 0)) continue;
+      const state = this.equipment.get(e.id);
+      if (!state) continue;
+      const over = demandBeforeStorageKW - dispatched - above;
+      if (over <= 0) {
+        if (Number(state.dischargeKW) > 0) {
+          state.dischargeKW = 0;
+          this.emitEnergyEquipment(e.id, atMs, { dischargeKW: 0, ...Number.isFinite(Number(state.soc)) ? { soc: Number(state.soc) } : {} });
+        }
+        continue;
+      }
+      const reserve = this.numberProperty(e, EMS_PROPERTY.reserveSoc) ?? 0;
+      const soc = Number(state.soc);
+      if (!Number.isFinite(soc)) continue;
+      const usableKWh = (soc - reserve) / 100 * capacity;
+      if (!(usableKWh > 0)) {
+        if (Number(state.dischargeKW) > 0) {
+          state.dischargeKW = 0;
+          this.emitEnergyEquipment(e.id, atMs, { dischargeKW: 0, soc });
+        }
+        continue;
+      }
+      const dtHours = dtMs / 36e5;
+      const rateCap = dtHours > 0 ? usableKWh / dtHours : maxRate;
+      const kW = Math.min(maxRate, over, rateCap);
+      if (!(kW > 0)) continue;
+      const drained = dtHours > 0 ? kW * dtHours / capacity * 100 : 0;
+      const nextSoc = Math.max(reserve, soc - drained);
+      state.dischargeKW = kW;
+      state.soc = nextSoc;
+      this.emitEnergyEquipment(e.id, atMs, { dischargeKW: kW, soc: nextSoc });
+      dispatched += kW;
+    }
+    return dispatched;
+  }
+  /**
+   * 파생된 설비 에너지 상태를 사실로 낸다 — **만든 값임을 밝힌다.**
+   *
+   * 계측으로 들어온 것과 같은 자리에 두면서 종류를 적지 않으면, 저널을 읽는 쪽이 우리가 계산한 방전을
+   * 계기가 잰 방전으로 읽는다(수요 구간의 `derived` 와 같은 규율).
+   */
+  emitEnergyEquipment(equipmentId, atMs, fields) {
+    this.emitOp(ENERGY_EVENT.equipment, { equipmentId, at: new Date(atMs).toISOString(), derived: true, ...fields });
+  }
   /** 자원 속성에서 수 하나 — 값이 수가 아니면 없는 것으로 본다(짐작하지 않는다). */
   numberProperty(resource, id) {
     for (const p of resource?.properties ?? []) {
@@ -6166,7 +6345,7 @@ var EmsKernel = class extends FlowEngine {
   tick(dtMs) {
     super.tick(dtMs);
     const at = this.nowMs();
-    this.deriveLoad(at);
+    this.deriveLoad(at, dtMs);
     this.closeDue(at);
   }
   getSnapshot() {
@@ -6461,12 +6640,15 @@ function energyOfWindows(windows, range) {
   let last;
   let peakKW;
   let peakStartMs;
+  let peakGrossKW;
   for (const w of windows ?? []) {
     if (!inRange(w)) continue;
     const max = Number(w.maxKW);
     if (Number.isFinite(max) && (peakKW === void 0 || max > peakKW)) {
       peakKW = max;
       peakStartMs = Number(w.startMs);
+      const gross = Number(w.grossMaxKW);
+      peakGrossKW = Number.isFinite(gross) ? gross : void 0;
     }
     const mean = Number(w.meanKW);
     const hours = (Number(w.endMs) - Number(w.startMs)) / 36e5;
@@ -6482,6 +6664,7 @@ function energyOfWindows(windows, range) {
   return {
     ...counted > 0 ? { kWh } : {},
     ...peakKW !== void 0 ? { peakKW, peakStartMs } : {},
+    ...peakGrossKW !== void 0 ? { peakGrossKW } : {},
     basis: "mean-kw",
     counted,
     skipped,

package/package.json

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