@operato/twin-kernel 0.7.64 → 0.7.66

package/dist/capability.d.ts

@@ -51,6 +51,8 @@ export interface CurtailableState {
 export interface GeneratingState {
     generatedKW?: number;
     exportKW?: number;
+    generatedKWh?: number;
+    generatedKWhResetAt?: string;
 }
 /** 저장 — 담고 낸다. 충전과 방전을 나눈다(손실·수명 판단이 둘을 구별해야 한다). */
 export interface StoringState {

package/dist/capability.js

@@ -78,7 +78,15 @@ export const CAPABILITIES = {
     energyGenerating: {
         key: 'energyGenerating', label: 'twin.capability.energyGenerating', semantics: '전기를 만든다 — 역송은 소비의 음수가 아니라 별개 사실이다.',
         commands: [],
-        stateFields: ['generatedKW', 'exportKW'], models: ['GeneratingState'], results: ['generated']
+        /*
+         * ── 적산을 더한다 (2026-08-26) ─────────────────────────────────────────────
+         * 이 능력이 순시 출력만 선언하고 있었다. 그래서 「지금 발전 중」은 말하고 「얼마나 발전했나」는 말할
+         * 수 없었다 — 사건 이름(`energy.generated`)과 설계 문서에는 처음부터 있던 사실이다.
+         *
+         * 계량 능력(`metered`)이 `kW` 와 `kWh` 를 함께 선언한 것과 같은 짝이다. 적산은 발전 설비의 보편적
+         * 사실이고(태양광·열병합·디젤), 그것이 없으면 성능비·발전시간 같은 성과를 아무도 셀 수 없다.
+         */
+        stateFields: ['generatedKW', 'exportKW', 'generatedKWh', 'generatedKWhResetAt'], models: ['GeneratingState'], results: ['generated']
     },
     /*
      * ── 왜 `storing` 이 아니라 `energyStoring` 인가 (2026-08-15) ────────────────

package/dist/contract.d.ts

@@ -43,7 +43,7 @@ export interface CanonicalEnvelope<T = unknown> {
  * 로 부르면 **표준 이름을 쓰면서 다른 뜻으로 쓰는 것**이 된다. 대조 문서가 그 판정을 적어 두었다.
  *
  * ── 왜 **닫혀** 있나 ────────────────────────────────────────────────────────
- * 커널이 이 넷으로 접는다: 성과 폴드가 착수·완료로 갈리고(`foldTaskRecords`), 주목 계산이
+ * 커널이 이 넷으로 처리한다: 성과 폴드가 착수·완료로 갈리고(`foldTaskRecords`), 주목 계산이
  * `created`·`assigned` 를 대기로 센다, 배정 루프는 `created` 만 집는다. 그러니 낱말이 하나 늘면
  * 그 셋이 조용히 달라진다 — 유입 문이 이 넷만 받는 이유다(다른 낱말은 오류 없이 사라진다).
  */
@@ -384,7 +384,7 @@ export interface TestResult {
 /**
  * `OP_EVENT.test` 의 페이로드 — **결과가 대상을 가리킨다.**
  *
- * 표준(`TestResultType`)의 방향 그대로다. 상태에서는 개체 안에 접어 두지만(소비처가 대상별로 묻는다)
+ * 표준(`TestResultType`)의 방향 그대로다. 상태에서는 개체 안에 계산해 두지만(소비처가 대상별로 묻는다)
  * 사건에서는 가리킨다 — 그래야 대상이 무엇이든(로트·설비·사람·자리) 한 채널로 들어온다.
  */
 export interface TestResultFact extends TestResult {
@@ -557,7 +557,7 @@ export interface PropertyMeasurement extends StandardValue {
     /** 표준 `MeasurementDate` — 언제 쟀나. */
     measurementDate?: ISOTime;
     /**
-     * 이 값이 **잰 것이 아니라 접은 것**임을 밝힌다 — §`DemandWindowState.derived` 와 같은 규율.
+     * 이 값이 **잰 것이 아니라 계산한 값**임을 밝힌다 — §`DemandWindowState.derived` 와 같은 규율.
      *
      * 트윈은 원본이 주지 않는 값을 계산할 수 있다(그것이 트윈의 존재 이유다). 그런데 그 수를 실측과
      * **같은 자리에 같은 모양으로** 두면 화면·보고서가 그것을 잰 값으로 읽는다. 규제 기록에서 그
@@ -758,7 +758,7 @@ export interface MaterialQuantity {
 /**
  * 물품을 구별하는 키 — 직렬 물품은 `epc`, 로트의 부분은 `subLotId`(표준 `MaterialSubLot.ID`).
  *
- * **한 곳에서 정한다.** 소비처마다 `epc` 로 키를 잡으면 같은 로트의 두 부분이 하나로 접히고,
+ * **한 곳에서 정한다.** 소비처마다 `epc` 로 키를 잡으면 같은 로트의 두 부분이 하나로 합쳐지고,
  * 그 순간 재고가 조용히 줄어든다(실제로 그랬다 — §ItemState.subLotId).
  *
  * ── 규약 (2026-08-21에 확정) ────────────────────────────────────────────────
@@ -1179,7 +1179,7 @@ export interface LocationObservation extends StandardValue {
     /** 누가 말했나 — 표준 `Source`. 계측기인지 사람이 적은 장부인지는 이 값이 답한다. */
     source?: string;
     /**
-     * 이 값이 **잰 것이 아니라 접은 것**임을 밝힌다 — §`PropertyMeasurement.derived` 와 같은 규율.
+     * 이 값이 **잰 것이 아니라 계산한 값**임을 밝힌다 — §`PropertyMeasurement.derived` 와 같은 규율.
      *
      * 트윈은 원본이 주지 않는 값을 계산할 수 있다(그것이 존재 이유다). 그러나 실측과 같은 자리에 같은
      * 모양으로 두면 보고서가 그것을 잰 값으로 읽는다. 규제 기록에서 그 구별이 사라지는 것은 결함이
@@ -1265,7 +1265,7 @@ export interface ItemState {
      * 기록이고 `TestableObjectID` 로 **대상을 가리킨다**(B2MML-OperationsTest.xsd).
      *
      * **그것이 우리가 좁힌 자리다**: 우리 상태는 대상별 투영이라(소비처가 「이 물품은?」을 묻는다) 가리키는
-     * 기록을 개체 안에 접어 둔다. 같은 사실이고 방향만 다르다 — 사건에서는 표준 그대로 대상을 가리킨다
+     * 기록을 개체 안에 계산해 둔다. 같은 사실이고 방향만 다르다 — 사건에서는 표준 그대로 대상을 가리킨다
      * (§`OP_EVENT.test`). 자원에서 이미 같은 좁힘을 했다(`EquipmentState.testResults`).
      *
      * ── 명세당 하나인 이유 ────────────────────────────────────────────────────
@@ -1361,6 +1361,23 @@ export interface EquipmentState extends EffectivePeriod {
     /** generating — 만든 전력·역송(kW). */
     generatedKW?: number;
     exportKW?: number;
+    /**
+     * generating — **지금까지 만든 양**(kWh, 계기 적산값).
+     *
+     * 연결된 시스템이 준 값 그대로다(우리가 kW 를 적분한 값이 아니다). 「오늘 얼마나 발전했나」는 두 시점의 차이로
+     * 얻는다 — 그 구간을 무엇으로 잡을지는 현장이 정하는 것이므로 커널이 구간을 정해 두지 않는다.
+     */
+    generatedKWh?: number;
+    /**
+     * 적산이 **되돌아간 시각** — 계기가 뒤로 간 것을 본 마지막 시점.
+     *
+     * 인버터를 교체하면 적산이 0부터 다시 오른다. 그것을 모르면 차분을 구하는 쪽이 그 계단을 「음의
+     * 발전」으로 읽거나, 반대로 그 앞의 값을 잃는다. 되돌아간 사실을 **우리가 메우지 않고 표시만** 한다 —
+     * 없던 발전량을 지어내는 것보다 「이 시점을 건너 계산하지 말라」고 말하는 것이 정직하다.
+     *
+     * 되돌아간 적이 없으면 이 칸이 없다.
+     */
+    generatedKWhResetAt?: ISOTime;
     /** storing — 충전율(%)·충전·방전(kW). 충전과 방전을 나눈다(손실·수명 판단이 그 둘을 구별한다). */
     soc?: number;
     chargeKW?: number;
@@ -1776,6 +1793,16 @@ export interface MeterPointState {
      * 커널은 표본이 올 때마다 이 값을 다시 맞춘다.
      */
     origin?: 'master' | 'observed';
+    /**
+     * **무엇을 재는 계량기인가** — 쓰는 쪽(`import`) · 내는 쪽(`export`) · 양쪽(`bidirectional`).
+     *
+     * 관측이 아니라 **선언**에서 온다(자원 속성 `meter.direction`). 표본마다 바뀌는 값이 아니고, 그
+     * 계량기가 무엇을 재도록 설치되었는지는 현장이 안다. 그래서 표본에는 이 칸이 없다.
+     *
+     * 선언하지 않으면 이 칸이 없고, 그때 그 지점은 **부하로 센다**. 빼면 부하가 오류 없이 작아지고, 작아진
+     * 부하는 「계약 안쪽」이라는 더 위험한 거짓을 만든다.
+     */
+    direction?: 'import' | 'export' | 'bidirectional';
     kW?: number;
     /** 누적 전력량(원천이 준 적산값) — 우리가 적분한 값이 아니다. */
     kWh?: number;
@@ -1799,7 +1826,7 @@ export interface DemandWindowState {
     /**
      * `maxKW` 가 찍힌 **그 순간**의, **모델이 선언한** 뿌리 계량기들만의 합.
      *
-     * `maxKW` 는 모르는 계량기까지 포함한 합이다(그것을 빼면 부하가 조용히 작아지고, 작아진 부하는
+     * `maxKW` 는 모르는 계량기까지 포함한 합이다(그것을 빼면 부하가 오류 없이 작아지고, 작아진 부하는
      * 「계약 안쪽」이라는 더 위험한 거짓을 만든다). 그러나 그 값 하나만 내면 반대쪽 거짓이 생긴다 —
      * 오타로 생긴 유령 계량기가 계약 초과를 만들어도 화면은 그것을 진짜 초과로 말한다.
      *
@@ -1840,6 +1867,24 @@ export interface DemandWindowState {
      * 발전·축전을 선언하지 않은 현장에서는 `maxKW` 와 같다(그때는 차감할 것이 없다).
      */
     grossMaxKW?: number;
+    /**
+     * 이 구간에 **내보낸 최대**(kW) — 내는 쪽으로 선언된 계량 지점들의 합.
+     *
+     * 수요의 최대와 **같은 순간이 아니다.** 해가 가장 좋은 때와 부하가 가장 큰 때는 다르고, 한쪽 순간에
+     * 맞춰 다른 쪽을 적으면 두 수 다 사실이 아니게 된다.
+     *
+     * ── 왜 빼지 않고 따로 내나 (2026-08-25) ───────────────────────────────────
+     * 내보낸 양을 재는 계량은 수요에 **더하지 않는다**(그것이 이 축을 만든 이유다). 그렇다고 수요에서 **빼지도
+     * 않는다**: 수전 계량기가 이미 상계 계량이면 그 값에 발전이 반영되어 있고, 거기서 또 빼면 두 번
+     * 깎는다. 어느 쪽인지는 현장의 결선이 정하는 것이고 우리가 표본만 보고 알 수는 없다.
+     *
+     * 그래서 두 수를 나란히 낸다. 화면은 「계통에서 받은 최대 320kW, 같은 순간 내보낸 것 180kW」라고
+     * 말할 수 있다. 자체 구동 경로는 설비의 발전량으로 순수요를 계산한다(§`grossMaxKW`) — 그것은 우리가
+     * 만든 값이라 이중 계상이 없다.
+     *
+     * 잰 적이 없으면 `undefined` 다(0 이 아니다).
+     */
+    exportKW?: number;
     /** 표본 평균 부하 — 요금 산정의 평균 수요에 대응한다. */
     meanKW?: number;
     /** **kW 를 실은** 표본 수 — 부하 판정의 근거 수다(받은 표본 전체가 아니다). */
@@ -2333,6 +2378,35 @@ export interface EnergyEquipmentData {
     minKW?: number;
     position?: 'open' | 'closed' | 'intermediate' | 'bad';
 }
+/**
+ * 발전 적산으로 담기는 값 — **발전 설비 하나가 지금까지 만든 양.**
+ *
+ * ── 왜 계량과 따로 있나 (2026-08-26) ───────────────────────────────────────
+ * 이 사건 이름(`energy.generated`)은 오래 **선언만 되어 있었다.** 설계 문서(`profiles/ems.md` §4)와
+ * 이 표에 이름이 있고, 내는 곳이 한 곳도 없었다. 그래서 태양광 발전소를 붙인 현장에서 「지금 발전
+ * 중」은 보이고 「얼마나 발전했나」는 보이지 않았다(호현에너지 실측: 하루에 174kWh 가 자랐는데 트윈에는
+ * 없었다).
+ *
+ * 계량(`EnergyMeasuredData`)으로 보낼 수는 없다. 계량 지점의 값은 부하 합에 들어가고(§`MeterPointState`),
+ * 발전을 그 합에 넣으면 계약 대비 판단이 반대로 틀린다. 발전은 **음의 소비가 아니라 별개 사실**이다 —
+ * 이 표의 `generated` 주석이 처음부터 그렇게 적어 두었다.
+ *
+ * ── 왜 순시 출력(kW)은 여기 없나 ───────────────────────────────────────────
+ * 그것은 이미 갈 곳이 있다(`EnergyEquipmentData.generatedKW`). 같은 값을 두 문으로 받으면 어느 쪽이
+ * 맞는지 정하는 규칙이 또 필요해진다. 이 문은 **적산만** 받는다 — 그것이 없던 것이다.
+ */
+export interface EnergyGeneratedData {
+    /** 발전 설비(id) — 계량 지점이 아니다. */
+    equipmentId: string;
+    /**
+     * 계기 적산값(kWh) — **연결된 시스템이 준 값 그대로.** 차분은 소비처가 한다.
+     *
+     * 우리가 kW 를 적분해 만들지 않는다. 적산은 그 계기 자신의 회계이고, 우리가 적분한 값과 미세하게
+     * 다르며 다를 때 맞는 쪽은 계기다(계량 쪽과 같은 규율).
+     */
+    kWh: number;
+    at: ISOTime;
+}
 /** 계량 도착의 실린 값 — 계량 지점 하나의 한 시점. */
 export interface EnergyMeasuredData {
     /** 계량 지점(설비 id). */

package/dist/contract.js

@@ -519,7 +519,7 @@ export function dueStatusOf(x, nowIso) {
 /**
  * 물품을 구별하는 키 — 직렬 물품은 `epc`, 로트의 부분은 `subLotId`(표준 `MaterialSubLot.ID`).
  *
- * **한 곳에서 정한다.** 소비처마다 `epc` 로 키를 잡으면 같은 로트의 두 부분이 하나로 접히고,
+ * **한 곳에서 정한다.** 소비처마다 `epc` 로 키를 잡으면 같은 로트의 두 부분이 하나로 합쳐지고,
  * 그 순간 재고가 조용히 줄어든다(실제로 그랬다 — §ItemState.subLotId).
  *
  * ── 규약 (2026-08-21에 확정) ────────────────────────────────────────────────

package/dist/divergence.js

@@ -20,7 +20,7 @@ function diffBy(predicted, actual, idOf, valOf) {
 }
 /** predicted(fork forecast)와 actual(관측) 스냅샷을 대조. 같은 sim 시점에 호출하는 것이 의미 있음. */
 export function compareStates(predicted, actual) {
-    /* 키는 **한 규칙**으로 잡는다(`itemKeyOf`) — 같은 로트의 두 부분을 `epc` 로 접으면 발산 비교가
+    /* 키는 **한 규칙**으로 잡는다(`itemKeyOf`) — 같은 로트의 두 부분을 `epc` 로 합치면 발산 비교가
        "같은 물품이 두 곳에 있다" 를 자기 오류로 착각한다. */
     const itemLocation = diffBy(predicted.items, actual.items, itemKeyOf, i => i.location);
     const itemDisposition = diffBy(predicted.items, actual.items, itemKeyOf, i => i.disposition);

package/dist/domain-catalog.js

@@ -227,7 +227,7 @@ export const TWIN_RELATIONS = [
  * `series` 는 아직 **아무도 내지 않는다** — EMS 가 붙을 때 생산자와 함께 선언한다.
  */
 export const TWIN_PROPERTIES = [
-    /* 공정 — 선언(ISO 8601 기간)과 관측(저널에서 접은 분포)이 둘 다 있는 유일한 짝. */
+    /* 공정 — 선언(ISO 8601 기간)과 관측(저널에서 계산한 분포)이 둘 다 있는 유일한 짝. */
     { axis: 'operations', key: 'duration', label: 'twin.prop.duration', kind: 'distribution',
         declaredField: 'duration', observedBy: 'kpi-fold.workTime', uom: 'ms' },
     /* 자리 — 용량은 선언, 점유는 관측. 단위가 다른 것이 아니라 **같은 축의 두 값**이다. */

package/dist/ems-kernel.d.ts

@@ -59,7 +59,7 @@ export declare class EmsKernel extends FlowEngine {
      * **뿌리 계량기** — 조상 중에 계량된 자리가 없는 계량 지점들.
      *
      * 계층 계량(수전 ⊃ 분기)에서 전부 더하면 이중 계상이 된다. 뿌리만 더하면 현장의 실제 부하가 된다.
-     * 모델이 그 계량기의 자리를 모르면 뿌리로 본다(모르는 것을 빼면 부하가 조용히 작아진다 — 그것이
+     * 모델이 그 계량기의 자리를 모르면 뿌리로 본다(모르는 것을 빼면 부하가 오류 없이 작아진다 — 그것이
      * 「계약 안쪽」이라는 더 위험한 거짓을 만든다).
      */
     private rootMeterIds;
@@ -91,7 +91,7 @@ export declare class EmsKernel extends FlowEngine {
      * "지금" 이 시뮬 기준시각(2026-01-01)에 얼어, 구간 마감·피크·감축 제안이 전부 8개월 전으로 기록됐다.
      *
      * 계측 자체는 원천 시각을 달고 있어서 화면의 순간값은 정상으로 보였다 — 그래서 조용한 결함이었다.
-     * 저널을 기간으로 접는 쪽(성과·요금·피더 배분)은 그 트윈에서 영원히 아무것도 찾지 못했다.
+     * 저널을 기간으로 계산하는 쪽(성과·요금·피더 배분)은 그 트윈에서 영원히 아무것도 찾지 못했다.
      */
     apply(envelope: CanonicalEnvelope): void;
     /**
@@ -106,6 +106,26 @@ export declare class EmsKernel extends FlowEngine {
      *
      * 온 값만 덮는다: 보내지 않은 필드는 그대로 둔다(없는 값을 0 으로 만들지 않는다).
      */
+    /**
+     * **지금까지 만든 양**(적산)을 설비에 세운다 — 이 사건 이름은 오래 선언만 되어 있었다.
+     *
+     * ── 무엇이 없었나 (2026-08-26) ─────────────────────────────────────────────
+     * 설계 문서와 계약의 표에 `energy.generated` 가 있고 **내는 곳이 한 곳도 없었다.** 그래서 태양광
+     * 발전소를 붙인 현장에서 「지금 발전 중」은 보이고 「얼마나 발전했나」는 보이지 않았다(호현에너지
+     * 실측: 하루에 174kWh 가 자랐는데 트윈에는 없었다).
+     *
+     * ── 되돌아간 적산을 메우지 않는다 ──────────────────────────────────────────
+     * 인버터를 교체하면 적산이 0부터 다시 오른다. 그 계단을 우리가 메우면 **없던 발전량이 생긴다.** 그래서
+     * 값은 연결된 시스템이 준 대로 두고 「이 시각에 되돌아갔다」만 표시한다. 차분을 구하는 쪽이 그 시점을 건너
+     * 계산할 수 있어야 하고, 그 판단은 그쪽의 것이다.
+     *
+     * ── 늦게 온 옛 표본은 최신을 덮지 않는다 ───────────────────────────────────
+     * 계량 지점과 같은 규율이다(`point.atMs` 비교). 사건이 일어난 순서대로 도착하지 않으므로, 시각을 비교하지
+     * 않으면 늦게 온 옛 적산이 최신 값을 뒤로 돌린다 — 그리고 그것이 「계기가 되돌아갔다」로 잘못 적힌다.
+     */
+    private applyGenerated;
+    /** 설비마다 발전 적산을 마지막으로 들은 시각 — 늦게 온 옛 표본을 가리는 데만 쓴다. */
+    private generationHeardAtMs;
     private applyEquipmentEnergy;
     /** 우리 모델이 모르는 설비가 상태를 보내 온 횟수 — 조용히 버리지 않는다. */
     private unknownEquipmentReports;
@@ -206,16 +226,23 @@ export declare class EmsKernel extends FlowEngine {
     /** 자원 속성에서 수 하나 — 값이 수가 아니면 없는 것으로 본다(짐작하지 않는다). */
     private numberProperty;
     /** 글자로 선언된 값(발전 형상·통화 같은 것) — 비어 있으면 없는 것으로 본다. */
+    /**
+     * 이 계량 지점의 선언된 방향 — 자리와 설비 둘 다 본다(수전 자리에도, 계량기 설비에도 걸린다).
+     *
+     * 선언에 없는 낱말은 **받지 않는다**. 「outgoing」·「생산」처럼 뜻이 통할 것 같은 말을 받아 주면
+     * 현장마다 다른 어휘가 쌓이고, 그중 하나를 우리가 잘못 읽는 날 발전이 부하로 세어진다.
+     */
+    private meterDirectionOf;
     private stringProperty;
     tick(dtMs: number): void;
     /**
      * 에너지의 연속성 — **SCADA 는 「이번 15분에 지금까지 얼마」를 모른다.**
      *
      * 계량기는 순간값과 적산값을 준다. 「이 구간의 최대」·「구간이 열릴 때의 적산」·「관측 이후 최대」는
-     * 우리가 접어 만든 값이라, 재기동하면 원천이 되풀어 주지 않는다. 잃으면 오류 없이 값이 작아진다 —
+     * 우리가 계산해 만든 값이라, 재기동하면 원천이 되풀어 주지 않는다. 잃으면 오류 없이 값이 작아진다 —
      * 구간 전력량이 기준점을 새로 잡아 짧아지고, 그 구간의 피크가 부팅 이후로만 잡힌다(요금이 걸린 수다).
      *
-     * 지난 마감 구간도 이어받는다: 이미 저널에 있는 사실이지만, 화면이 그것을 보려고 매번 저널을 접지
+     * 지난 마감 구간도 이어받는다: 이미 저널에 있는 사실이지만, 화면이 그것을 보려고 매번 저널을 계산하지
      * 않게 한다(자른 사실은 `closedTotal` 이 그대로 나른다).
      *
      * 지금 열린 구간이 **이미 지나간 것**이어도 그대로 받는다 — 다음 표본이 오면 커널이 그 구간을 정상

package/dist/ems-kernel.js

@@ -28,7 +28,7 @@
 import { FlowEngine } from "./flow-engine.js";
 import { firstFitPolicy } from "./allocation-policy.js";
 import { CMD, ENERGY_EVENT, minuteOfDayAt } from "./contract.js";
-import { EMS_PROPERTY, electricalUpstreamOf, generationFractionAt } from "./ems-profile.js";
+import { EMS_PROPERTY, METER_DIRECTION, electricalUpstreamOf, generationFractionAt } from "./ems-profile.js";
 /** 수요 구간 — 요금의 알갱이다. 15분은 한국·다수 요금제의 최대수요 산정 단위다. */
 export const DEMAND_WINDOW_MS = 15 * 60 * 1000;
 /** 그 시각이 속한 구간의 시작 — 벽시계 경계(00·15·30·45분)에 맞춘다. */
@@ -121,7 +121,7 @@ export class EmsKernel extends FlowEngine {
      * **뿌리 계량기** — 조상 중에 계량된 자리가 없는 계량 지점들.
      *
      * 계층 계량(수전 ⊃ 분기)에서 전부 더하면 이중 계상이 된다. 뿌리만 더하면 현장의 실제 부하가 된다.
-     * 모델이 그 계량기의 자리를 모르면 뿌리로 본다(모르는 것을 빼면 부하가 조용히 작아진다 — 그것이
+     * 모델이 그 계량기의 자리를 모르면 뿌리로 본다(모르는 것을 빼면 부하가 오류 없이 작아진다 — 그것이
      * 「계약 안쪽」이라는 더 위험한 거짓을 만든다).
      */
     rootMeterIds() {
@@ -210,7 +210,7 @@ export class EmsKernel extends FlowEngine {
      * "지금" 이 시뮬 기준시각(2026-01-01)에 얼어, 구간 마감·피크·감축 제안이 전부 8개월 전으로 기록됐다.
      *
      * 계측 자체는 원천 시각을 달고 있어서 화면의 순간값은 정상으로 보였다 — 그래서 조용한 결함이었다.
-     * 저널을 기간으로 접는 쪽(성과·요금·피더 배분)은 그 트윈에서 영원히 아무것도 찾지 못했다.
+     * 저널을 기간으로 계산하는 쪽(성과·요금·피더 배분)은 그 트윈에서 영원히 아무것도 찾지 못했다.
      */
     apply(envelope) {
         if (envelope.eventType === ENERGY_EVENT.measured) {
@@ -221,6 +221,10 @@ export class EmsKernel extends FlowEngine {
             this.applyEquipmentEnergy(envelope);
             return;
         }
+        if (envelope.eventType === ENERGY_EVENT.generated) {
+            this.applyGenerated(envelope);
+            return;
+        }
         super.apply(envelope);
     }
     /**
@@ -235,6 +239,58 @@ export class EmsKernel extends FlowEngine {
      *
      * 온 값만 덮는다: 보내지 않은 필드는 그대로 둔다(없는 값을 0 으로 만들지 않는다).
      */
+    /**
+     * **지금까지 만든 양**(적산)을 설비에 세운다 — 이 사건 이름은 오래 선언만 되어 있었다.
+     *
+     * ── 무엇이 없었나 (2026-08-26) ─────────────────────────────────────────────
+     * 설계 문서와 계약의 표에 `energy.generated` 가 있고 **내는 곳이 한 곳도 없었다.** 그래서 태양광
+     * 발전소를 붙인 현장에서 「지금 발전 중」은 보이고 「얼마나 발전했나」는 보이지 않았다(호현에너지
+     * 실측: 하루에 174kWh 가 자랐는데 트윈에는 없었다).
+     *
+     * ── 되돌아간 적산을 메우지 않는다 ──────────────────────────────────────────
+     * 인버터를 교체하면 적산이 0부터 다시 오른다. 그 계단을 우리가 메우면 **없던 발전량이 생긴다.** 그래서
+     * 값은 연결된 시스템이 준 대로 두고 「이 시각에 되돌아갔다」만 표시한다. 차분을 구하는 쪽이 그 시점을 건너
+     * 계산할 수 있어야 하고, 그 판단은 그쪽의 것이다.
+     *
+     * ── 늦게 온 옛 표본은 최신을 덮지 않는다 ───────────────────────────────────
+     * 계량 지점과 같은 규율이다(`point.atMs` 비교). 사건이 일어난 순서대로 도착하지 않으므로, 시각을 비교하지
+     * 않으면 늦게 온 옛 적산이 최신 값을 뒤로 돌린다 — 그리고 그것이 「계기가 되돌아갔다」로 잘못 적힌다.
+     */
+    applyGenerated(envelope) {
+        const d = envelope.data;
+        const id = String(d?.equipmentId ?? '').trim();
+        const eq = id ? this.equipment.get(id) : undefined;
+        if (!eq) {
+            this.unknownEquipmentReports++;
+            return;
+        }
+        const kWh = Number(d?.kWh);
+        if (!Number.isFinite(kWh))
+            return;
+        const atMs = [String(d?.at ?? ''), String(envelope?.eventTime ?? '')]
+            .map(v => Date.parse(v))
+            .find(v => Number.isFinite(v));
+        if (atMs === undefined)
+            return;
+        this.noteObserved(atMs);
+        /* 이 설비에 대해 마지막으로 들은 시각보다 오래된 것이면 값을 바꾸지 않는다. */
+        const heardAt = this.generationHeardAtMs.get(id);
+        if (heardAt !== undefined && atMs < heardAt)
+            return;
+        this.generationHeardAtMs.set(id, atMs);
+        const before = Number(eq.generatedKWh);
+        if (Number.isFinite(before) && kWh < before) {
+            /* 되돌아갔다 — 값은 새것으로 두고, 그 사실을 시각으로 남긴다(우리가 계단을 메우지 않는다). */
+            ;
+            eq.generatedKWhResetAt = new Date(atMs).toISOString();
+        }
+        ;
+        eq.generatedKWh = kWh;
+        eq.measuredAt = new Date(atMs).toISOString();
+        this.revision++;
+    }
+    /** 설비마다 발전 적산을 마지막으로 들은 시각 — 늦게 온 옛 표본을 가리는 데만 쓴다. */
+    generationHeardAtMs = new Map();
     applyEquipmentEnergy(envelope) {
         const d = envelope.data;
         const id = String(d?.equipmentId ?? '').trim();
@@ -300,6 +356,19 @@ export class EmsKernel extends FlowEngine {
          * 찍고 두면 나중에 선언된 계량기가 영원히 `observed` 로 남는다. 자리(`origin: 'observed'`)와 같은 어휘다.
          */
         point.origin = this.equipment.has(id) ? 'master' : 'observed';
+        /*
+         * ── 방향도 **표본마다 다시 맞춘다** (2026-08-25) ────────────────────────────
+         * `origin` 과 같은 이유다: 선언의 정본은 모델이고 모델은 채택으로 늘어난다. 한 번 찍고 두면
+         * 나중에 선언된 방향이 반영되지 않는다.
+         *
+         * 계량 지점은 자리일 수도 설비일 수도 있으므로 둘 다 본다(수전 자리에 계약이 걸리고, 계량기
+         * 설비에도 걸린다). 선언이 없으면 **칸을 만들지 않는다** — 「모른다」와 「쓰는 쪽이다」는 다르다.
+         */
+        const declaredDirection = this.meterDirectionOf(id);
+        if (declaredDirection)
+            point.direction = declaredDirection;
+        else
+            delete point.direction;
         /* 늦게 온 옛 표본이 최신 관측을 덮지 않게 — 상위 커널의 `stale` 판정과 같은 규율. */
         if (point.atMs === undefined || atMs >= point.atMs) {
             point.atMs = atMs;
@@ -341,7 +410,7 @@ export class EmsKernel extends FlowEngine {
             /*
              * ── 합을 **두 벌** 낸다 (2026-08-20) ──────────────────────────────────────
              *
-             * 전부의 합(`total`)이 요금 판정의 근거다 — 모르는 계량기를 빼면 부하가 조용히 작아지고, 작아진
+             * 전부의 합(`total`)이 요금 판정의 근거다 — 모르는 계량기를 빼면 부하가 오류 없이 작아지고, 작아진
              * 부하는 「계약 안쪽」이라는 더 위험한 거짓을 만든다.
              *
              * 그런데 그 값 하나만 내면 반대쪽 거짓이 생긴다: 오타로 생긴 유령 계량기가 만든 초과를 화면이
@@ -352,16 +421,39 @@ export class EmsKernel extends FlowEngine {
              * 옛 스냅샷에서 이어받은 지점에는 그 칸이 없고, 없는 것을 「선언되었다」로 읽으면 이 값이 조용히
              * 전부의 합과 같아지기 때문이다.
              */
+            /*
+             * ── 내는 쪽은 수요에 더하지 않는다 (2026-08-25) ────────────────────────────
+             *
+             * **요금은 계통 접속점의 순 유입에 매겨진다.** 여기가 지점의 kW 를 전부 부하로 세고 있었으므로,
+             * 내보낸 양을 재는 계량기가 붙으면 그것이 수요에 더해지고 계약 대비 판단이 반대로 뒤집혔다.
+             * 상계 거래·축전지·열병합이 있는 곳에서는 접속점 계량기가 양쪽을 잰다.
+             *
+             * 세 갈래다.
+             *   export          더하지 않고 `exportKW` 로 따로 센다. 빼지도 않는다(§`exportKW` 주석).
+             *   bidirectional   그대로 더한다 — 그 계량기는 부호로 방향을 말한다(내보내는 동안 음수).
+             *   그 밖 · 선언 없음   더한다. 모르는 것을 빼면 부하가 오류 없이 작아진다.
+             */
             let total = 0;
             let declared = 0;
+            let exported = 0;
             for (const p of this.points.values()) {
                 if (!roots.has(p.id))
                     continue;
                 const v = p.kW ?? 0;
+                if (p.direction === 'export') {
+                    exported += v;
+                    continue;
+                }
                 total += v;
                 if (this.equipment.has(p.id))
                     declared += v;
             }
+            /*
+             * 내보낸 양은 **따로 최대를 잡는다** — 수요의 최대와 같은 순간이 아니다. 해가 가장 좋은 때와
+             * 부하가 가장 큰 때는 다르고, 한쪽 순간에 맞춰 다른 쪽을 적으면 두 수 다 사실이 아니게 된다.
+             */
+            if (exported > 0 && (w.exportKW === undefined || exported > w.exportKW))
+                w.exportKW = exported;
             if (w.maxKW === undefined || total > w.maxKW) {
                 w.maxKW = total;
                 w.maxDeclaredKW = declared;
@@ -451,6 +543,7 @@ export class EmsKernel extends FlowEngine {
                 /* 총부하도 사실로 남긴다 — 이것이 없으면 저널을 읽는 쪽은 「무엇이 깎였나」를 되짚을 수 없다
                    (요금은 순수요로 매겨지지만, 그 수요를 만든 것은 설비 부하다). */
                 ...(w.grossMaxKW !== undefined ? { grossMaxKW: w.grossMaxKW } : {}),
+                ...(w.exportKW !== undefined ? { exportKW: w.exportKW } : {}),
                 ...(w.meanKW !== undefined ? { meanKW: w.meanKW } : {}),
                 samples: w.samples,
                 ...(w.contractKW !== undefined ? { contractKW: w.contractKW } : {}),
@@ -467,7 +560,7 @@ export class EmsKernel extends FlowEngine {
                  * ── 지점별 몫을 함께 낸다 (2026-08-18) ────────────────────────────────
                  *
                  * 분기마다 계량기가 있는 현장에서 분기별 전력량은 **측정**이다. 그런데 그 사실이 저널에
-                 * 없어서, 저널을 접는 쪽은 가동시간으로 **배분**할 수밖에 없었다 — 계량이 있는데 배분으로
+                 * 없어서, 저널을 계산하는 쪽은 가동시간으로 **배분**할 수밖에 없었다 — 계량이 있는데 배분으로
                  * 말하는 것은 근거를 실제보다 약하게 보고하는 것이고, 그 위에 세운 SEU 판단이 무거운 값을 놓친다.
                  *
                  * 표본을 그대로 저널에 흘리는 대신 **구간마다 한 줄**로 낸다: 계측은 초당 여러 건이라 표본을
@@ -899,6 +992,20 @@ export class EmsKernel extends FlowEngine {
         return undefined;
     }
     /** 글자로 선언된 값(발전 형상·통화 같은 것) — 비어 있으면 없는 것으로 본다. */
+    /**
+     * 이 계량 지점의 선언된 방향 — 자리와 설비 둘 다 본다(수전 자리에도, 계량기 설비에도 걸린다).
+     *
+     * 선언에 없는 낱말은 **받지 않는다**. 「outgoing」·「생산」처럼 뜻이 통할 것 같은 말을 받아 주면
+     * 현장마다 다른 어휘가 쌓이고, 그중 하나를 우리가 잘못 읽는 날 발전이 부하로 세어진다.
+     */
+    meterDirectionOf(id) {
+        /* 선언의 정본은 모델이다(`boardDef`) — 실행 중 상태(`this.locations`)에는 속성이 없다. */
+        const declared = this.stringProperty((this.boardDef?.equipment ?? []).find(e => e.id === id), EMS_PROPERTY.meterDirection) ??
+            this.stringProperty((this.boardDef?.locations ?? []).find(l => l.id === id), EMS_PROPERTY.meterDirection);
+        if (!declared)
+            return undefined;
+        return METER_DIRECTION.includes(declared) ? declared : undefined;
+    }
     stringProperty(resource, id) {
         for (const p of resource?.properties ?? []) {
             if (p?.id !== id)
@@ -929,10 +1036,10 @@ export class EmsKernel extends FlowEngine {
      * 에너지의 연속성 — **SCADA 는 「이번 15분에 지금까지 얼마」를 모른다.**
      *
      * 계량기는 순간값과 적산값을 준다. 「이 구간의 최대」·「구간이 열릴 때의 적산」·「관측 이후 최대」는
-     * 우리가 접어 만든 값이라, 재기동하면 원천이 되풀어 주지 않는다. 잃으면 오류 없이 값이 작아진다 —
+     * 우리가 계산해 만든 값이라, 재기동하면 원천이 되풀어 주지 않는다. 잃으면 오류 없이 값이 작아진다 —
      * 구간 전력량이 기준점을 새로 잡아 짧아지고, 그 구간의 피크가 부팅 이후로만 잡힌다(요금이 걸린 수다).
      *
-     * 지난 마감 구간도 이어받는다: 이미 저널에 있는 사실이지만, 화면이 그것을 보려고 매번 저널을 접지
+     * 지난 마감 구간도 이어받는다: 이미 저널에 있는 사실이지만, 화면이 그것을 보려고 매번 저널을 계산하지
      * 않게 한다(자른 사실은 `closedTotal` 이 그대로 나른다).
      *
      * 지금 열린 구간이 **이미 지나간 것**이어도 그대로 받는다 — 다음 표본이 오면 커널이 그 구간을 정상

package/dist/ems-profile.d.ts

@@ -1,6 +1,24 @@
 import type { TwinTypeInfo } from './domain-catalog.ts';
 /** 로케이션(수동) 타입 키 — 배전 계통의 구간. */
 export declare const EMS_LOCATION_TYPES: readonly ["incoming", "feeder", "submeter-zone"];
+/**
+ * 계량 지점의 방향 — **무엇을 재는 계량기인가.**
+ *
+ *   import          쓰는 쪽. 계통에서 받는다(대부분의 계량기).
+ *   export          내는 쪽. 발전이 계통으로 나가는 것을 잰다.
+ *   bidirectional   양쪽을 한 계량기로 잰다(상계 거래·축전지). 부호가 방향을 담는다.
+ *
+ * 선언하지 않으면 **모르는 것**이고, 모르는 것은 부하로 센다. 빼면 부하가 오류 없이 작아지고, 작아진
+ * 부하는 「계약 안쪽」이라는 더 위험한 거짓을 만든다(같은 이유로 정체 모를 계량기도 합에 넣는다).
+ *
+ * `bidirectional` 은 **그 계량기가 순 유입을 재는 것**이다. 발전을 부하에서 빼는 것이 아니다 — 그
+ * 계량기가 읽은 값이 그 접속점의 사실이고, 요금이 그 값에 매겨진다.
+ *
+ * 표준 근거: 계량기의 적산 레지스터가 유입·유출로 갈려 있고(IEC 62053 계열), ISO 50001 은 유입 경계를
+ * 따로 둔다(`EnergyInput`). 우리가 지은 낱말이 아니다.
+ */
+export declare const METER_DIRECTION: readonly ["import", "export", "bidirectional"];
+export type MeterDirection = (typeof METER_DIRECTION)[number];
 /** 설비(능동) 타입 키 — 계량 지점과 에너지 자원. */
 export declare const EMS_EQUIPMENT_TYPES: readonly ["meter", "breaker", "pv-array", "battery", "utility", "curtailable-load"];
 /**
@@ -12,6 +30,7 @@ export declare const EMS_EQUIPMENT_TYPES: readonly ["meter", "breaker", "pv-arra
 export declare const EMS_PROPERTY: {
     /** 계약전력(kW) — 수전·분기 자리에 선언한다. 없으면 계약 대비 판정을 하지 않는다. */
     readonly contractKW: "contract.kW";
+    readonly meterDirection: "meter.direction";
     /** 가동 중 소비(kW). */
     readonly ratedKW: "power.ratedKW";
     /** 멈춰 있을 때의 소비(kW). 없으면 멈춘 동안을 **비운다** — 0 이라고 주장하지 않는다. */

package/dist/ems-profile.js

@@ -1,5 +1,22 @@
 /** 로케이션(수동) 타입 키 — 배전 계통의 구간. */
 export const EMS_LOCATION_TYPES = ['incoming', 'feeder', 'submeter-zone'];
+/**
+ * 계량 지점의 방향 — **무엇을 재는 계량기인가.**
+ *
+ *   import          쓰는 쪽. 계통에서 받는다(대부분의 계량기).
+ *   export          내는 쪽. 발전이 계통으로 나가는 것을 잰다.
+ *   bidirectional   양쪽을 한 계량기로 잰다(상계 거래·축전지). 부호가 방향을 담는다.
+ *
+ * 선언하지 않으면 **모르는 것**이고, 모르는 것은 부하로 센다. 빼면 부하가 오류 없이 작아지고, 작아진
+ * 부하는 「계약 안쪽」이라는 더 위험한 거짓을 만든다(같은 이유로 정체 모를 계량기도 합에 넣는다).
+ *
+ * `bidirectional` 은 **그 계량기가 순 유입을 재는 것**이다. 발전을 부하에서 빼는 것이 아니다 — 그
+ * 계량기가 읽은 값이 그 접속점의 사실이고, 요금이 그 값에 매겨진다.
+ *
+ * 표준 근거: 계량기의 적산 레지스터가 유입·유출로 갈려 있고(IEC 62053 계열), ISO 50001 은 유입 경계를
+ * 따로 둔다(`EnergyInput`). 우리가 지은 낱말이 아니다.
+ */
+export const METER_DIRECTION = ['import', 'export', 'bidirectional'];
 /** 설비(능동) 타입 키 — 계량 지점과 에너지 자원. */
 export const EMS_EQUIPMENT_TYPES = ['meter', 'breaker', 'pv-array', 'battery', 'utility', 'curtailable-load'];
 /**
@@ -11,6 +28,24 @@ export const EMS_EQUIPMENT_TYPES = ['meter', 'breaker', 'pv-array', 'battery', '
 export const EMS_PROPERTY = {
     /** 계약전력(kW) — 수전·분기 자리에 선언한다. 없으면 계약 대비 판정을 하지 않는다. */
     contractKW: 'contract.kW',
+    /*
+     * ── 계량 지점의 방향 (2026-08-25) ──────────────────────────────────────────
+     * **요금은 계통 접속점의 순 유입에 매겨진다.** 그러니 그 지점의 계량기가 무엇을 재는지 모르면
+     * 요금을 사실대로 말할 수 없다 — 내보낸 양을 쓴 양으로 세면 계약 대비 판단이 반대로 뒤집힌다.
+     *
+     * 이 축이 없는 동안 계량 지점의 kW 를 전부 부하로 셌다. 상계 거래를 하는 현장, 축전지를 붙인 현장,
+     * 열병합이 있는 현장 — 접속점 계량기가 양쪽을 재는 곳은 늘 있다.
+     *
+     * **발전기를 계량기로 만드는 것과 다른 일이다.** 발전은 설비의 사실이고(`energyGenerating`), 그것을
+     * 계량 지점으로 보내는 것은 여전히 하지 않는다. 이 축은 **접속점 계량기**가 무엇을 재는지 말하는
+     * 자리다.
+     *
+     * 방향은 **관측이 아니라 선언**이다. 표본마다 바뀌는 값이 아니고, 그 계량기가 무엇을 재도록
+     * 설치되었는지는 현장이 안다. 그래서 표본(`EnergyRecord`)에 넣지 않고 자원 속성으로 둔다.
+     *
+     * 값은 계량기 자신의 낱말을 쓴다(적산 레지스터가 그렇게 갈려 있다). §`METER_DIRECTION`.
+     */
+    meterDirection: 'meter.direction',
     /*
      * ── 부하 계수 — 시뮬레이션이 전기를 만들 수 있게 (2026-08-14) ───────────────
      * 「이 설비가 돌면 몇 kW 인가」는 **현장이 아는 값**이다. 그래서 타입 기본값을 두지 않는다:
@@ -96,6 +131,13 @@ export const EMS_PROPERTY = {
 };
 export const EMS_PROPERTY_SPEC = {
     [EMS_PROPERTY.contractKW]: { uom: 'kW', dataType: 'xs:double', note: 'contracted power at the metering point, in kW.' },
+    /* 값이 셋 중 하나여야 한다 — 그 밖의 낱말은 받지 않는다(뜻이 통할 것 같은 말도 받지 않는다). */
+    [EMS_PROPERTY.meterDirection]: {
+        dataType: 'xs:string',
+        note: 'what this metering point measures: "import" (drawn from the grid), "export" (generation sent out), ' +
+            'or "bidirectional" (one meter for both, sign carries the direction). ' +
+            'Left undeclared, the point counts as load — leaving it out never makes demand look smaller than it is.'
+    },
     [EMS_PROPERTY.ratedKW]: { uom: 'kW', dataType: 'xs:double', note: 'power drawn while running, in kW.' },
     [EMS_PROPERTY.standbyKW]: { uom: 'kW', dataType: 'xs:double', note: 'power drawn while idle, in kW.' },
     [EMS_PROPERTY.demandChargePerKW]: { dataType: 'xs:double', note: 'demand charge per kW of billing-period peak, in the declared currency.' },

package/dist/energy-ingest.d.ts

@@ -53,10 +53,27 @@ export interface EnergyEquipmentRecord {
 /** 이 레코드가 설비 에너지 상태인가 — 라우팅 판정을 한 곳에 둔다. */
 export declare function isEnergyEquipmentRecord(record: unknown): boolean;
 /**
- * 설비 에너지 레코드 → 봉투. 계량과 같은 규율이다: 지어낼 수 없는 것이 빠지면 거부하고, 거부한 것은
- * 이유와 함께 돌려준다.
+ * 설비 에너지 레코드 → 봉투. 계량과 같은 규율이다: 지어낼 수 없는 것이 빠지면 받지 않고, 받지 않은 것은
+ * 이유와 함께 알린다.
  *
  * **값이 하나도 없는 레코드는 거부한다** — 계량과 다른 점이다. 계량은 「응답했다」는 사실 자체가
  * 관측이지만(그래서 kW 없는 표본을 받는다), 여기서는 바꿀 상태가 없는 것을 사실로 적을 이유가 없다.
  */
 export declare function ingestEnergyEquipmentRecords(records: EnergyEquipmentRecord | EnergyEquipmentRecord[] | undefined | null, opts: EnergyIngestOptions): EnergyIngestResult;
+/** 정규 발전 적산 레코드 — 커넥터가 이 모양으로 맞춰 준다(필드 이름이 계약이다). */
+export interface EnergyGenerationRecord {
+    equipmentId: string;
+    /** 계기 적산값(kWh) — 연결된 시스템이 준 값 그대로. 차분은 소비처가 한다. */
+    kWh?: number;
+    at?: string;
+}
+/** 이 레코드가 발전 적산인가 — 어느 갈래로 보낼지를 한 곳에서 정한다. */
+export declare function isEnergyGenerationRecord(record: unknown): boolean;
+/**
+ * 발전 적산 레코드 → 봉투. 계량과 같은 규율이다: 지어낼 수 없는 것이 빠지면 받지 않고, 받지 않은 것은
+ * 이유와 함께 알린다.
+ *
+ * **적산이 없는 레코드는 받지 않는다** — 이 문의 값은 그것 하나다. 순시 출력은 설비 상태 문이 받는다
+ * (`EnergyEquipmentRecord.generatedKW`).
+ */
+export declare function ingestEnergyGenerationRecords(records: EnergyGenerationRecord | EnergyGenerationRecord[] | undefined | null, opts: EnergyIngestOptions): EnergyIngestResult;