@operato/twin-kernel 0.7.64 → 0.7.66

package/dist-cjs/index.cjs

@@ -52,6 +52,7 @@ __export(index_exports, {
   MES_BIZSTEP: () => MES_BIZSTEP,
   MES_LOCATION_TYPES: () => MES_LOCATION_TYPES,
   MES_TYPES: () => MES_TYPES,
+  METER_DIRECTION: () => METER_DIRECTION,
   MesKernel: () => MesKernel,
   OPERATION_PROPERTY: () => OPERATION_PROPERTY,
   OP_EVENT: () => OP_EVENT,
@@ -120,11 +121,13 @@ __export(index_exports, {
   inWorkCalendarAt: () => inWorkCalendarAt,
   ingest: () => ingest,
   ingestEnergyEquipmentRecords: () => ingestEnergyEquipmentRecords,
+  ingestEnergyGenerationRecords: () => ingestEnergyGenerationRecords,
   ingestEnergyRecords: () => ingestEnergyRecords,
   ingestOperationalRecords: () => ingestOperationalRecords,
   isAggregationRecord: () => isAggregationRecord,
   isElectricalLocationType: () => isElectricalLocationType,
   isEnergyEquipmentRecord: () => isEnergyEquipmentRecord,
+  isEnergyGenerationRecord: () => isEnergyGenerationRecord,
   isEnergyRecord: () => isEnergyRecord,
   isEquipmentLevel: () => isEquipmentLevel,
   isOperationalRecord: () => isOperationalRecord,
@@ -1036,12 +1039,12 @@ var DISP = {
   /**
    * **기한이 지났다** — CBV `expired`.
    *
-   * ── 왜 `non_sellable` 로 접지 않나 (2026-08-24) ─────────────────────────────
+   * ── 왜 `non_sellable` 로 계산하지 않나 (2026-08-24) ─────────────────────────────
    * 커널의 `non_sellable` 은 CBV 의 `non_sellable_other`, 즉 **「그 밖의 이유」**다. 기한 지남을 거기
    * 넣으면 「기한이 지나 못 판다」와 「깨져서 못 판다」가 같은 값이 되고, 화면은 회수·폐기의 사유를
    * 구별할 수 없다. 식품에서 그 둘은 다른 조치다.
    *
-   * 그리고 표준에 **정확한 낱말이 있다** — 접는 것은 있는 낱말을 버리는 것이다.
+   * 그리고 표준에 **정확한 낱말이 있다** — 합치는 것은 있는 낱말을 버리는 것이다.
    *
    * ── 기한 날짜와 다른 축이다 ────────────────────────────────────────────────
    * `ItemState.expiry` 는 **날짜**이고 이것은 **상태**다. 날짜가 있으면 「지났나」는 파생이지만, 원본이
@@ -1389,6 +1392,17 @@ var ObservedReducer = class {
   master = /* @__PURE__ */ new Map();
   /** 자리별 · 속성별 **마지막 관측** — 이력이 아니다(§`OP_EVENT.observation`). */
   observations = /* @__PURE__ */ new Map();
+  /**
+   * 설비별 **마지막으로 들은 시각** — 그 설비의 상태가 아니라 **우리 지식의 상태**다.
+   *
+   * ── 왜 상태에 넣지 않나 ─────────────────────────────────────────────────────
+   * 「가동 중」은 설비에 대한 사실이고 「그 말을 언제 들었나」는 우리에 대한 사실이다. 상태에 섞으면
+   * 두 종류가 한 통에 담기고, 자체 구동(시뮬)에는 없는 값이라 두 구동이 어긋난다 — 물품의
+   * `seenAtMs` 가 같은 이유로 상태에서 빠졌다(§`snapshot`).
+   *
+   * 그래서 여기 안에 두고, 밖으로는 **주의 신호**로만 낸다(§`equipmentSilence`).
+   */
+  heard = /* @__PURE__ */ new Map();
   items = /* @__PURE__ */ new Map();
   aggregation = /* @__PURE__ */ new Map();
   /** 아직 관측되지 않은 자식의 담김 — 물품을 지어내지 않고 보류했다가 등장할 때 붙인다. */
@@ -1447,12 +1461,12 @@ var ObservedReducer = class {
   /**
    * **구조를 전환한다** — 관측된 사실은 지키고 토폴로지만 새 선언으로 바꾼다.
    *
-   * 공장은 바뀐다. 도장 부스를 넷 더 놓고, 라인을 하나 접는다. 그런데 지금까지는 구조가 바뀌면
+   * 공장은 바뀐다. 도장 부스를 넷 더 놓고, 라인 하나를 닫는다. 그런데 지금까지는 구조가 바뀌면
    * **그 트윈의 저널을 통째로 지우는 것**이 유일한 길이었다 — 안 지우면 옛 이벤트를 새 공장에 대고
-   * 접게 되어 이력이 거짓말을 한다. 역사를 잃거나 거짓말을 하거나, 둘뿐이었다.
+   * 계산하게 되어 이력이 거짓말을 한다. 역사를 잃거나 거짓말을 하거나, 둘뿐이었다.
    *
    * 셋째 길이 이것이다: 이벤트가 **자기 구조를 달고** 다니고, 재생은 구조가 바뀌는 지점에서 여기를
-   * 불러 전환한 뒤 이어 접는다. 그러면 "그때 그 공장의 사실" 로 계속 읽힌다.
+   * 불러 전환한 뒤 이어서 계산한다. 그러면 "그때 그 공장의 사실" 로 계속 읽힌다.
    *
    * ── 무엇을 지키고 무엇을 버리는가 ───────────────────────────────────────
    * **관측은 지킨다** — 물품·오더·작업·집합은 구조와 무관한 사실이다(팔레트는 부스를 늘려도 그대로다).
@@ -1566,6 +1580,48 @@ var ObservedReducer = class {
     this.lastAt.set(key, { at, recorded: Number.isFinite(recorded) ? recorded : seen.recorded });
     return false;
   }
+  /**
+   * 이 설비의 값을 받은 시각을 적고, 지난번 값과의 간격 중 가장 긴 것을 함께 기록한다.
+   *
+   * 간격을 기록하는 이유는 판단 기준을 우리가 정하지 않기 위해서다. 「몇 분 넘게 소식이 없으면
+   * 이상하다」는 현장마다 다르다 — 1초마다 값을 보내는 계측기와 하루 한 번 올라오는 점검 기록이
+   * 같은 표에 있다. 기준을 하나로 정하면 앞쪽에는 신호가 너무 많이 서고 뒤쪽에는 서지 않는다.
+   * 그래서 그 설비가 지금까지 실제로 보여 준 간격을 기준으로 쓴다.
+   */
+  markHeard(id, e) {
+    const at = Date.parse(String(e.eventTime ?? ""));
+    if (!Number.isFinite(at)) return;
+    const prev = this.heard.get(id);
+    if (!prev) {
+      this.heard.set(id, { atMs: at });
+      return;
+    }
+    if (at <= prev.atMs) return;
+    const gap = at - prev.atMs;
+    this.heard.set(id, { atMs: at, longestGapMs: Math.max(prev.longestGapMs ?? 0, gap) });
+  }
+  /**
+   * 값이 지난 간격보다 오래 끊긴 설비의 목록. 밖으로 내보내는 값은 이것 하나다.
+   *
+   * 끊긴 시간은 이 트윈이 마지막으로 어떤 값이든 받은 시각을 기준으로 잰다. 연결이 통째로 멈추면 그
+   * 기준도 멈추므로 아무 신호도 서지 않는다. 그때 알려야 할 사실은 설비마다의 상태가 아니라 「연결이
+   * 끊겼다」 하나이고, 그것은 유입 장부가 알린다.
+   *
+   * 지난 간격을 아직 모르는 설비는 목록에 넣지 않는다. 값을 한 번만 받았다면 이 설비가 원래 얼마나
+   * 뜸하게 보내는지 알 수 없다.
+   */
+  equipmentSilence() {
+    const out = /* @__PURE__ */ new Map();
+    const now = this.observedAtMs;
+    if (now === void 0) return out;
+    for (const [id, h] of this.heard) {
+      if (h.longestGapMs === void 0) continue;
+      const silentMs = now - h.atMs;
+      if (silentMs <= 0) continue;
+      out.set(id, { silentMs, longestBeforeMs: h.longestGapMs });
+    }
+    return out;
+  }
   /** 대상별 마지막 반영 시각 — 순서 판정용(대상=EPC·작업·설비·오더 id). */
   lastAt = /* @__PURE__ */ new Map();
   /**
@@ -1624,6 +1680,7 @@ var ObservedReducer = class {
         const known = this.equipment.get(d.moverId);
         const homeLocation = d.homeLocation ?? known?.homeLocation;
         const eqPeriod = d.effectiveStart || d.effectiveEnd ? effectiveOf(d) : effectiveOf(known);
+        this.markHeard(d.moverId, e);
         this.equipment.set(d.moverId, { id: d.moverId, kind: d.kind, status: d.status, location: d.location, ...homeLocation ? { homeLocation } : {}, taskId: d.taskId, motion: d.motion, origin: known?.origin ?? "observed", ...eqPeriod, ...d.held ? { held: true } : {} });
         break;
       }
@@ -1974,7 +2031,7 @@ var ObservedReducer = class {
    * 시뮬 기준시각(BASE_EPOCH, 2026-01-01)에 얼어 있었다.
    *
    * 결과는 조용했다: 구간 마감·피크 같은 **커널이 낸 사실이 8개월 전으로 기록**되어, 저널을 기간으로
-   * 접는 소비처(성과·요금·피더 배분)가 그 트윈에서 영원히 아무것도 찾지 못했다. 계측 자체는 원천 시각을
+   * 계산하는 소비처(성과·요금·피더 배분)가 그 트윈에서 영원히 아무것도 찾지 못했다. 계측 자체는 원천 시각을
    * 달고 있었으므로 화면의 순간값만 정상으로 보였다 — 그래서 눈에 띄지 않았다.
    *
    * 시각을 되돌리지는 않는다: 늦게 도착한 옛 표본이 "지금" 을 과거로 끌면 그 뒤 판정이 전부 흔들린다.
@@ -2033,20 +2090,20 @@ var ObservedReducer = class {
   /**
    * **재개점(checkpoint)** — 스냅샷과 다르다.
    *
-   * ── 왜 스냅샷으로는 이어 접을 수 없나 (2026-08-18) ─────────────────────────
+   * ── 왜 스냅샷으로는 이어 계산할 수 없나 (2026-08-18) ─────────────────────────
    * `snapshot()` 은 **소비처가 보는 값**이다(파생된 판정·정리된 목록). 그것으로 리듀서를 되세우면
    * 보이지 않는 것들이 사라진다 — 아직 등장하지 않은 자식의 담김(`pendingParent`), 집합 관계
    * (`aggregation`), 반영 못 한 사건 집계(`unhandled`), 정정 선언(`corrections`). 그 상태에서 뒤 이벤트를
-   * 접으면 **0부터 접은 결과와 달라진다.** 다르면 그 차이는 조용하다(오류가 없다).
+   * 계산하면 **0부터 계산한 결과와 달라진다.** 다르면 그 차이는 조용하다(오류가 없다).
    *
-   * 그래서 재개점은 **내부 상태 전부**다. 「이어 접기」의 정합성은 시험이 증명한다:
-   * 0부터 접은 결과 == 앞부분 재개점 + 뒷부분 접기.
+   * 그래서 재개점은 **내부 상태 전부**다. 「이어 계산」의 정합성은 시험이 증명한다:
+   * 0부터 계산한 결과 == 앞부분 재개점 + 뒷부분 계산.
    *
    * 모델에서 오는 것(교대·등급·시간대)은 담지 않는다 — 되세울 때 같은 모델을 받기 때문이다.
    */
   serialize() {
     return {
-      /* 관측도 재개점에 든다 — 없으면 이어 접기가 그 축을 0부터 다시 만든다. */
+      /* 관측도 재개점에 든다 — 없으면 이어 계산가 그 축을 0부터 다시 만든다. */
       observations: [...this.observations.entries()].map(([id, bin]) => ({ id, values: [...bin.values()] })),
       revision: this.revision,
       master: [...this.master.values()].map((n) => ({ ...n })),
@@ -2063,7 +2120,9 @@ var ObservedReducer = class {
       orders: [...this.orders.values()].map((o) => ({ ...o })),
       acked: [...this.acked],
       corrections: this.corrections.map((c) => ({ ...c })),
-      unhandled: [...this.unhandled.entries()].map(([eventType, v]) => ({ eventType, ...v }))
+      unhandled: [...this.unhandled.entries()].map(([eventType, v]) => ({ eventType, ...v })),
+      /* 마지막으로 들은 시각 — 이어받지 않으면 재기동 뒤에 침묵의 길이를 말할 수 없다. */
+      heard: [...this.heard.entries()].map(([id, v]) => ({ id, ...v }))
     };
   }
   /**
@@ -2077,6 +2136,7 @@ var ObservedReducer = class {
     );
     this.revision = cp?.revision ?? 0;
     this.master = new Map((cp?.master ?? []).map((n) => [n.id, { ...n }]));
+    this.heard = new Map((cp?.heard ?? []).map((h) => [h.id, { atMs: h.atMs, ...h.longestGapMs !== void 0 ? { longestGapMs: h.longestGapMs } : {} }]));
     this.items = new Map((cp?.items ?? []).map((i) => [i.epc, { ...i }]));
     this.aggregation = new Map((cp?.aggregation ?? []).map((a) => [a.parent, [...a.children]]));
     this.pendingParent = new Map((cp?.pendingParent ?? []).map((x) => [x.child, x.parent]));
@@ -2225,10 +2285,29 @@ var WMS_TYPES = [
 
 // src/ems-profile.ts
 var EMS_LOCATION_TYPES = ["incoming", "feeder", "submeter-zone"];
+var METER_DIRECTION = ["import", "export", "bidirectional"];
 var EMS_EQUIPMENT_TYPES = ["meter", "breaker", "pv-array", "battery", "utility", "curtailable-load"];
 var EMS_PROPERTY = {
   /** 계약전력(kW) — 수전·분기 자리에 선언한다. 없으면 계약 대비 판정을 하지 않는다. */
   contractKW: "contract.kW",
+  /*
+   * ── 계량 지점의 방향 (2026-08-25) ──────────────────────────────────────────
+   * **요금은 계통 접속점의 순 유입에 매겨진다.** 그러니 그 지점의 계량기가 무엇을 재는지 모르면
+   * 요금을 사실대로 말할 수 없다 — 내보낸 양을 쓴 양으로 세면 계약 대비 판단이 반대로 뒤집힌다.
+   *
+   * 이 축이 없는 동안 계량 지점의 kW 를 전부 부하로 셌다. 상계 거래를 하는 현장, 축전지를 붙인 현장,
+   * 열병합이 있는 현장 — 접속점 계량기가 양쪽을 재는 곳은 늘 있다.
+   *
+   * **발전기를 계량기로 만드는 것과 다른 일이다.** 발전은 설비의 사실이고(`energyGenerating`), 그것을
+   * 계량 지점으로 보내는 것은 여전히 하지 않는다. 이 축은 **접속점 계량기**가 무엇을 재는지 말하는
+   * 자리다.
+   *
+   * 방향은 **관측이 아니라 선언**이다. 표본마다 바뀌는 값이 아니고, 그 계량기가 무엇을 재도록
+   * 설치되었는지는 현장이 안다. 그래서 표본(`EnergyRecord`)에 넣지 않고 자원 속성으로 둔다.
+   *
+   * 값은 계량기 자신의 낱말을 쓴다(적산 레지스터가 그렇게 갈려 있다). §`METER_DIRECTION`.
+   */
+  meterDirection: "meter.direction",
   /*
    * ── 부하 계수 — 시뮬레이션이 전기를 만들 수 있게 (2026-08-14) ───────────────
    * 「이 설비가 돌면 몇 kW 인가」는 **현장이 아는 값**이다. 그래서 타입 기본값을 두지 않는다:
@@ -2314,6 +2393,11 @@ var EMS_PROPERTY = {
 };
 var 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 \u2014 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." },
@@ -2571,7 +2655,15 @@ var CAPABILITIES = {
     label: "twin.capability.energyGenerating",
     semantics: "\uC804\uAE30\uB97C \uB9CC\uB4E0\uB2E4 \u2014 \uC5ED\uC1A1\uC740 \uC18C\uBE44\uC758 \uC74C\uC218\uAC00 \uC544\uB2C8\uB77C \uBCC4\uAC1C \uC0AC\uC2E4\uC774\uB2E4.",
     commands: [],
-    stateFields: ["generatedKW", "exportKW"],
+    /*
+     * ── 적산을 더한다 (2026-08-26) ─────────────────────────────────────────────
+     * 이 능력이 순시 출력만 선언하고 있었다. 그래서 「지금 발전 중」은 말하고 「얼마나 발전했나」는 말할
+     * 수 없었다 — 사건 이름(`energy.generated`)과 설계 문서에는 처음부터 있던 사실이다.
+     *
+     * 계량 능력(`metered`)이 `kW` 와 `kWh` 를 함께 선언한 것과 같은 짝이다. 적산은 발전 설비의 보편적
+     * 사실이고(태양광·열병합·디젤), 그것이 없으면 성능비·발전시간 같은 성과를 아무도 셀 수 없다.
+     */
+    stateFields: ["generatedKW", "exportKW", "generatedKWh", "generatedKWhResetAt"],
     models: ["GeneratingState"],
     results: ["generated"]
   },
@@ -2990,7 +3082,7 @@ var TWIN_RELATIONS = [
   { from: "operations", field: "resourceType", target: { kind: "type", role: "equipment" }, via: "twin.rel.by", optional: true }
 ];
 var TWIN_PROPERTIES = [
-  /* 공정 — 선언(ISO 8601 기간)과 관측(저널에서 접은 분포)이 둘 다 있는 유일한 짝. */
+  /* 공정 — 선언(ISO 8601 기간)과 관측(저널에서 계산한 분포)이 둘 다 있는 유일한 짝. */
   {
     axis: "operations",
     key: "duration",
@@ -3276,12 +3368,30 @@ function resolveObject(v, record, field, errors) {
   const o = { ...r };
   return Object.keys(o).length ? o : void 0;
 }
+function resolveErrorDeclaration(spec, record, errors) {
+  if (!spec) return void 0;
+  const declarationTime = resolve(spec.declarationTime, record, "errorDeclaration.declarationTime", errors);
+  const reason = resolve(spec.reason, record, "errorDeclaration.reason", errors);
+  const correctiveEventIDs = resolveList(spec.correctiveEventIDs, record, "errorDeclaration.correctiveEventIDs", errors);
+  if (!declarationTime) {
+    if (reason || correctiveEventIDs.length) {
+      errors.push("errorDeclaration \uC774 \uBC18\uCBE4 \uC654\uB2E4 \u2014 \uC774\uC720\xB7\uC815\uC815 \uB300\uC0C1\uC740 \uC788\uB294\uB370 declarationTime \uC774 \uC5C6\uB2E4(\uC815\uC815 \uC2DC\uAC01\uC740 \uC9C0\uC5B4\uB0BC \uC218 \uC5C6\uB2E4)");
+    }
+    return void 0;
+  }
+  return {
+    declarationTime,
+    ...reason ? { reason } : {},
+    ...correctiveEventIDs.length ? { correctiveEventIDs } : {}
+  };
+}
 function mapRecordChecked(record, mapping, eventTime) {
   const errors = [];
   const bizStep = resolve(mapping.bizStep, record, "bizStep", errors) ?? "";
   const disposition = resolve(mapping.disposition, record, "disposition", errors);
   const readPoint = resolve(mapping.readPoint, record, "readPoint", errors);
   const bizLocation = resolve(mapping.bizLocation, record, "bizLocation", errors);
+  const errorDeclaration = resolveErrorDeclaration(mapping.errorDeclaration, record, errors);
   if (mapping.type === "TransformationEvent") {
     const inputEPCList = resolveList(mapping.inputEPCList, record, "inputEPCList", errors);
     const inputQuantityList = resolveQuantityList(mapping.inputQuantityList, record, "inputQuantityList", errors);
@@ -3306,6 +3416,7 @@ function mapRecordChecked(record, mapping, eventTime) {
         ...outputEPCList.length ? { outputEPCList } : {},
         ...outputQuantityList.length ? { outputQuantityList } : {},
         ...transformationID ? { transformationID } : {},
+        ...errorDeclaration ? { errorDeclaration } : {},
         readPoint,
         bizLocation
       }),
@@ -3327,6 +3438,7 @@ function mapRecordChecked(record, mapping, eventTime) {
         /* 없는 쪽은 **필드를 만들지 않는다** — 빈 배열을 실으면 「자식이 없다」고 말하는 것이 된다. */
         ...childEPCs.length ? { childEPCs } : {},
         ...childQuantityList.length ? { childQuantityList } : {},
+        ...errorDeclaration ? { errorDeclaration } : {},
         readPoint,
         bizLocation
       }),
@@ -3349,6 +3461,7 @@ function mapRecordChecked(record, mapping, eventTime) {
       epcList: epc ? [epc] : [],
       ...quantityList.length ? { quantityList } : {},
       ...ilmd ? { ilmd } : {},
+      ...errorDeclaration ? { errorDeclaration } : {},
       readPoint,
       bizLocation
     }),
@@ -3652,6 +3765,21 @@ function deriveAttentions(view, acked, nowIso, thresholds) {
         suggestedAction: { code: "act.repair", command: CMD.resourceRepair, args: { resourceId: m.id } }
       });
     }
+    if (m.silentMs !== void 0 && m.longestSilenceBeforeMs !== void 0 && m.silentMs > m.longestSilenceBeforeMs) {
+      out.push({
+        id: `silent:${m.id}`,
+        kind: "equipment-silent",
+        severity: "medium",
+        anchor: { moverId: m.id, locationId: m.location },
+        params: {
+          moverId: m.id,
+          ...m.location ? { locationId: m.location } : {},
+          silentMs: m.silentMs,
+          longestBeforeMs: m.longestSilenceBeforeMs,
+          ...m.status ? { lastStatus: m.status } : {}
+        }
+      });
+    }
   }
   for (const n of view.locations) {
     for (const c of n.criteria ?? []) {
@@ -3812,10 +3940,14 @@ function computeOee(c, nowMs) {
     scrapCount: c.scrapCount
   };
 }
+var ENERGY_STATE_FIELDS = [
+  ...stateFieldsOf(["metered", "curtailable", "energyGenerating", "energyStoring", "switching"]),
+  "measuredAt"
+];
 function energyFieldsOf(m) {
   const out = {};
   const src = m;
-  for (const k of ["generatedKW", "exportKW", "soc", "chargeKW", "dischargeKW", "curtailable", "minKW", "position", "measuredAt"]) {
+  for (const k of ENERGY_STATE_FIELDS) {
     if (src[k] !== void 0) out[k] = src[k];
   }
   return out;
@@ -4038,7 +4170,7 @@ var FlowEngine = class {
    * 양품률 시임(선택) — **이력에서 배운 수율.** 소요시간과 같은 자리·같은 규율이다 (2026-08-19).
    *
    * 없으면 선언값(현장→원천), 그것도 없으면 도메인 상수. 무엇을 썼는지는 `specCoverage()` 가 밝힌다.
-   * 주입은 호스트가 한다(저널을 접는 쪽이 이력을 안다) — 커널은 시임만 든다.
+   * 주입은 호스트가 한다(저널을 계산하는 쪽이 이력을 안다) — 커널은 시임만 든다.
    */
   yieldEstimator;
   /**
@@ -4060,7 +4192,7 @@ var FlowEngine = class {
    * 읽는 쪽(`paramNumber`·`paramDuration`)이 명세 행보다 이것을 먼저 본다.
    */
   localParams = /* @__PURE__ */ new Map();
-  /** 관측 구동(P0) — 이벤트를 접는 투영기와 그 사실. tick 과 섞이지 않게 명시적으로 들고 있다. */
+  /** 관측 구동(P0) — 이벤트를 계산하는 투영기와 그 사실. tick 과 섞이지 않게 명시적으로 들고 있다. */
   observer;
   /**
    * **관측 리듀서의 재개점을 꺼낸다** — 호스트가 저장해 다음 기동에서 되돌릴 수 있게.
@@ -4333,7 +4465,7 @@ var FlowEngine = class {
    * 미러의 진실은 원천이다. 그래서 재고·위치·설비 상태는 스냅샷에서 심지 않는다 — 다음 계측·다음
    * 마스터 재읽기가 곧 정정하므로, 심으면 **떠난 물건이 되살아나는** 위험만 남는다.
    *
-   * 그런데 원천이 **애초에 다시 말해 주지 않는 축**이 있다. 우리가 접어 만든 것들이다:
+   * 그런데 원천이 **애초에 다시 말해 주지 않는 축**이 있다. 우리가 계산해 만든 것들이다:
    *  · 확인(ack)·조건이 처음 성립한 시각 — 사람이 한 일과 우리가 기억한 시각
    *  · 열린 구간의 누적·적산 기준점·관측 이후 최대 — SCADA 는 「이번 15분에 지금까지 얼마」를 모른다
    *
@@ -4431,6 +4563,20 @@ var FlowEngine = class {
         ...m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {},
         /* 결과도 이어받는다 — 잃으면 예측이 **자격 만료를 모르는 현장**에서 출발한다(낙관 쪽으로 치우친다). */
         ...m.testResults ? { testResults: m.testResults } : {},
+        /*
+         * ── 에너지 값도 이어받는다 (2026-08-26) ────────────────────────────────
+         *
+         * 이 자리가 에너지 필드를 심지 않았다. 그래서 재기동하면 설비의 발전량·충전율·계량값이 빈 채로
+         * 시작하고, 다음 표본이 올 때까지 화면이 비어 보였다. 태양광 발전소에서 관측했다 — 저장된
+         * 상태에는 `generatedKW` 가 있는데 되살린 트윈에는 없었다.
+         *
+         * 어느 필드를 이어받는지는 **능력 선언에서 뽑는다**(`ENERGY_STATE_FIELDS`). 스냅샷을 만드는
+         * 쪽(`energyFieldsOf`)과 같은 목록이다 — 두 곳에 손으로 적으면 한쪽이 빠진 날 값이 조용히
+         * 사라진다. 실제로 오늘 그렇게 났다.
+         *
+         * 값이 없으면 키를 만들지 않는다 — 에너지에서 「모른다」와 「0 이다」는 요금이 갈리는 차이다.
+         */
+        ...energyFieldsOf(m),
         ...effectiveOnly(m)
       });
     }
@@ -4679,7 +4825,7 @@ var FlowEngine = class {
    */
   _acked = /* @__PURE__ */ new Set();
   /**
-   * 완료 시점에 **주체가 사라져 접은 작업 수** — 조용한 누락이 되지 않게 센다.
+   * 완료 시점에 **주체가 사라져 제외한 작업 수** — 조용한 누락이 되지 않게 센다.
    *
    * 물품이 포장·출하·소비로 없어지는 것은 정상이지만, 그 물품을 향한 작업이 남아 있었다는 것은
    * 상류에 어긋남이 있다는 신호다. 0 이 아니면 그 사실을 소비처가 볼 수 있어야 한다.
@@ -5012,9 +5158,13 @@ var FlowEngine = class {
         if (cs.length) criteriaOf.set(n.id, cs);
       }
     }
+    const silence = typeof this.observer?.equipmentSilence === "function" ? this.observer.equipmentSilence() : void 0;
     const out = deriveAttentions(
       {
-        equipment: [...this.equipment.values()],
+        equipment: [...this.equipment.values()].map((m) => {
+          const s = silence?.get(m.id);
+          return s ? { ...m, silentMs: s.silentMs, longestSilenceBeforeMs: s.longestBeforeMs } : m;
+        }),
         locations: [...this.locations.values()].map((n) => {
           const criteria = criteriaOf.get(n.id);
           return criteria?.length ? { ...n, criteria } : n;
@@ -5217,7 +5367,7 @@ var FlowEngine = class {
    * 어긋난다(2026-08-01 하루에 아홉 곳). 근본 해법은 **한 상태 모델 두 구동**이고, 이것은 그 실현
    * 가능성을 재는 스파이크다(design/plans/kernel-unification-live-observe.md P0).
    *
-   * 여기서는 **이미 검증된 조각을 조립**한다: 투영기가 이벤트를 접고, 그 결과를 씨앗 경로
+   * 여기서는 **이미 검증된 조각을 조립**한다: 투영기가 이벤트를 계산하고, 그 결과를 씨앗 경로
    * (`hydrateObserved`)로 커널 상태에 주입한다. 그래서 관측으로 실행한 커널을 그대로 `fork`·`tick` 할 수
    * 있다 — "미러에서 예측한다" 가 별도 배관 없이 성립하는지가 이 스파이크의 질문이다.
    *
@@ -6190,7 +6340,7 @@ var FlowEngine = class {
    *
    * 그때 도메인 훅은 없는 것을 딛으려다 오류를 낸다(`order.gtin` · `item.location`). 그 예외 하나가
    * **예측 전체를 죽였다** — 사용자에게는 기능이 통째로 사라진 것으로 보였다. 그래서 완료 **전에**
-   * 여기서 묻고, 없으면 그 작업만 접는다.
+   * 여기서 묻고, 없으면 그 작업만 제외한다.
    */
   missingContextOf(t) {
     if (t.itemEpc && !this.itemByRef(t.itemEpc)) return "item";
@@ -7639,7 +7789,7 @@ var MesKernel = class extends FlowEngine {
    *
    * 씨앗이 이미 이행된 오더를 주입하지 않으므로(남은 수량 0) 그 오더에 딸린 작업만 남을 수 있고,
    * 관측이 오더 연결을 담지 못한 작업도 있다. 그때 예전에는 `order.gtin` 에서 오류가 났고 **그 예외
-   * 하나가 정확도 추세 전체를 죽였다.** 이제 코어가 이 답을 보고 그 작업만 접는다.
+   * 하나가 정확도 추세 전체를 죽였다.** 이제 코어가 이 답을 보고 그 작업만 제외한다.
    */
   canComplete(t) {
     return !!(t.orderId && this.orders.get(t.orderId));
@@ -8156,7 +8306,7 @@ var EmsKernel = class extends FlowEngine {
    * **뿌리 계량기** — 조상 중에 계량된 자리가 없는 계량 지점들.
    *
    * 계층 계량(수전 ⊃ 분기)에서 전부 더하면 이중 계상이 된다. 뿌리만 더하면 현장의 실제 부하가 된다.
-   * 모델이 그 계량기의 자리를 모르면 뿌리로 본다(모르는 것을 빼면 부하가 조용히 작아진다 — 그것이
+   * 모델이 그 계량기의 자리를 모르면 뿌리로 본다(모르는 것을 빼면 부하가 오류 없이 작아진다 — 그것이
    * 「계약 안쪽」이라는 더 위험한 거짓을 만든다).
    */
   rootMeterIds() {
@@ -8229,7 +8379,7 @@ var EmsKernel = class extends FlowEngine {
    * "지금" 이 시뮬 기준시각(2026-01-01)에 얼어, 구간 마감·피크·감축 제안이 전부 8개월 전으로 기록됐다.
    *
    * 계측 자체는 원천 시각을 달고 있어서 화면의 순간값은 정상으로 보였다 — 그래서 조용한 결함이었다.
-   * 저널을 기간으로 접는 쪽(성과·요금·피더 배분)은 그 트윈에서 영원히 아무것도 찾지 못했다.
+   * 저널을 기간으로 계산하는 쪽(성과·요금·피더 배분)은 그 트윈에서 영원히 아무것도 찾지 못했다.
    */
   apply(envelope) {
     if (envelope.eventType === ENERGY_EVENT.measured) {
@@ -8240,6 +8390,10 @@ var EmsKernel = class extends FlowEngine {
       this.applyEquipmentEnergy(envelope);
       return;
     }
+    if (envelope.eventType === ENERGY_EVENT.generated) {
+      this.applyGenerated(envelope);
+      return;
+    }
     super.apply(envelope);
   }
   /**
@@ -8254,6 +8408,51 @@ var EmsKernel = class 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) : void 0;
+    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 === void 0) return;
+    this.noteObserved(atMs);
+    const heardAt = this.generationHeardAtMs.get(id);
+    if (heardAt !== void 0 && 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 = /* @__PURE__ */ new Map();
   applyEquipmentEnergy(envelope) {
     const d = envelope.data;
     const id = String(d?.equipmentId ?? "").trim();
@@ -8293,6 +8492,9 @@ var EmsKernel = class extends FlowEngine {
     const kW = Number.isFinite(Number(d?.kW)) ? Number(d.kW) : void 0;
     const point = this.points.get(id) ?? { id, samplesInWindow: 0 };
     point.origin = this.equipment.has(id) ? "master" : "observed";
+    const declaredDirection = this.meterDirectionOf(id);
+    if (declaredDirection) point.direction = declaredDirection;
+    else delete point.direction;
     if (point.atMs === void 0 || atMs >= point.atMs) {
       point.atMs = atMs;
       if (kW !== void 0) point.kW = kW;
@@ -8307,12 +8509,18 @@ var EmsKernel = class extends FlowEngine {
       const roots = this.rootMeterIds();
       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 === void 0 || exported > w.exportKW)) w.exportKW = exported;
       if (w.maxKW === void 0 || total > w.maxKW) {
         w.maxKW = total;
         w.maxDeclaredKW = declared;
@@ -8379,6 +8587,7 @@ var EmsKernel = class extends FlowEngine {
         /* 총부하도 사실로 남긴다 — 이것이 없으면 저널을 읽는 쪽은 「무엇이 깎였나」를 되짚을 수 없다
            (요금은 순수요로 매겨지지만, 그 수요를 만든 것은 설비 부하다). */
         ...w.grossMaxKW !== void 0 ? { grossMaxKW: w.grossMaxKW } : {},
+        ...w.exportKW !== void 0 ? { exportKW: w.exportKW } : {},
         ...w.meanKW !== void 0 ? { meanKW: w.meanKW } : {},
         samples: w.samples,
         ...w.contractKW !== void 0 ? { contractKW: w.contractKW } : {},
@@ -8395,7 +8604,7 @@ var EmsKernel = class extends FlowEngine {
          * ── 지점별 몫을 함께 낸다 (2026-08-18) ────────────────────────────────
          *
          * 분기마다 계량기가 있는 현장에서 분기별 전력량은 **측정**이다. 그런데 그 사실이 저널에
-         * 없어서, 저널을 접는 쪽은 가동시간으로 **배분**할 수밖에 없었다 — 계량이 있는데 배분으로
+         * 없어서, 저널을 계산하는 쪽은 가동시간으로 **배분**할 수밖에 없었다 — 계량이 있는데 배분으로
          * 말하는 것은 근거를 실제보다 약하게 보고하는 것이고, 그 위에 세운 SEU 판단이 무거운 값을 놓친다.
          *
          * 표본을 그대로 저널에 흘리는 대신 **구간마다 한 줄**로 낸다: 계측은 초당 여러 건이라 표본을
@@ -8731,6 +8940,23 @@ var EmsKernel = class extends FlowEngine {
     return void 0;
   }
   /** 글자로 선언된 값(발전 형상·통화 같은 것) — 비어 있으면 없는 것으로 본다. */
+  /**
+   * 이 계량 지점의 선언된 방향 — 자리와 설비 둘 다 본다(수전 자리에도, 계량기 설비에도 걸린다).
+   *
+   * 선언에 없는 낱말은 **받지 않는다**. 「outgoing」·「생산」처럼 뜻이 통할 것 같은 말을 받아 주면
+   * 현장마다 다른 어휘가 쌓이고, 그중 하나를 우리가 잘못 읽는 날 발전이 부하로 세어진다.
+   */
+  meterDirectionOf(id) {
+    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 void 0;
+    return METER_DIRECTION.includes(declared) ? declared : void 0;
+  }
   stringProperty(resource, id) {
     for (const p of resource?.properties ?? []) {
       if (p?.id !== id) continue;
@@ -8749,10 +8975,10 @@ var EmsKernel = class extends FlowEngine {
    * 에너지의 연속성 — **SCADA 는 「이번 15분에 지금까지 얼마」를 모른다.**
    *
    * 계량기는 순간값과 적산값을 준다. 「이 구간의 최대」·「구간이 열릴 때의 적산」·「관측 이후 최대」는
-   * 우리가 접어 만든 값이라, 재기동하면 원천이 되풀어 주지 않는다. 잃으면 오류 없이 값이 작아진다 —
+   * 우리가 계산해 만든 값이라, 재기동하면 원천이 되풀어 주지 않는다. 잃으면 오류 없이 값이 작아진다 —
    * 구간 전력량이 기준점을 새로 잡아 짧아지고, 그 구간의 피크가 부팅 이후로만 잡힌다(요금이 걸린 수다).
    *
-   * 지난 마감 구간도 이어받는다: 이미 저널에 있는 사실이지만, 화면이 그것을 보려고 매번 저널을 접지
+   * 지난 마감 구간도 이어받는다: 이미 저널에 있는 사실이지만, 화면이 그것을 보려고 매번 저널을 계산하지
    * 않게 한다(자른 사실은 `closedTotal` 이 그대로 나른다).
    *
    * 지금 열린 구간이 **이미 지나간 것**이어도 그대로 받는다 — 다음 표본이 오면 커널이 그 구간을 정상
@@ -8930,6 +9156,44 @@ function ingestEnergyEquipmentRecords(records, opts) {
   }
   return { accepted, rejected };
 }
+function isEnergyGenerationRecord(record) {
+  if (!record || typeof record !== "object") return false;
+  const r = record;
+  return typeof r.equipmentId === "string" && r.equipmentId.trim().length > 0 && r.kWh !== void 0 && r.meterId === void 0 && r.epc === void 0;
+}
+function ingestEnergyGenerationRecords(records, opts) {
+  const list = records === void 0 || records === null ? [] : Array.isArray(records) ? records : [records];
+  const accepted = [];
+  const rejected = [];
+  let seq = 0;
+  for (const r of list) {
+    const errors = [];
+    const equipmentId = String(r?.equipmentId ?? "").trim();
+    if (!equipmentId) errors.push("equipmentId \uAC00 \uC5C6\uB2E4 \u2014 \uC5B4\uB290 \uC124\uBE44\uAC00 \uB9CC\uB4E0 \uAC83\uC778\uC9C0 \uC9C0\uC5B4\uB0BC \uC218 \uC5C6\uB2E4");
+    const raw = r?.kWh;
+    const kWh = Number(raw);
+    if (raw === void 0 || raw === null || !Number.isFinite(kWh)) {
+      errors.push("kWh \uAC00 \uC5C6\uB2E4 \u2014 \uC774 \uBB38\uC774 \uBC1B\uB294 \uAC12\uC740 \uC801\uC0B0 \uD558\uB098\uB2E4(\uC21C\uC2DC \uCD9C\uB825\uC740 \uC124\uBE44 \uC0C1\uD0DC\uB85C \uBCF4\uB0B8\uB2E4)");
+    } else if (kWh < 0) {
+      errors.push(`kWh \uAC00 \uC74C\uC218\uB2E4(${kWh}) \u2014 \uC801\uC0B0\uC740 \uB4A4\uB85C \uAC00\uB354\uB77C\uB3C4 \uC74C\uC218\uAC00 \uB418\uC9C0 \uC54A\uB294\uB2E4`);
+    }
+    const eventTime = String(r?.at ?? "").trim() || opts.defaultEventTime || "";
+    if (!eventTime) errors.push("at \uC774 \uC5C6\uACE0 \uAE30\uBCF8 \uC2DC\uAC01\uB3C4 \uC8FC\uC9C0 \uC54A\uC558\uB2E4 \u2014 \uC5B8\uC81C \uC7B0 \uAC83\uC778\uC9C0 \uC9C0\uC5B4\uB0BC \uC218 \uC5C6\uB2E4");
+    if (errors.length) {
+      rejected.push({ record: r, errors });
+      continue;
+    }
+    const data = { equipmentId, kWh, at: eventTime };
+    accepted.push({
+      eventId: `${opts.tenantId}-generated-${++seq}`,
+      eventType: ENERGY_EVENT.generated,
+      eventTime,
+      tenantId: opts.tenantId,
+      data
+    });
+  }
+  return { accepted, rejected };
+}
 
 // src/operational-ingest.ts
 var TASK_STATUS = ["created", "assigned", "in-progress", "completed"];
@@ -8940,7 +9204,7 @@ var SPECS = {
   task: {
     eventType: OP_EVENT.task,
     identity: "taskId",
-    /* 종류가 없으면 성과를 종류별로 접을 수 없고(선언된 시간·수율이 종류로 붙는다) 지어낼 수도 없다. */
+    /* 종류가 없으면 성과를 종류별로 모을 수 없고(선언된 시간·수율이 종류로 붙는다) 지어낼 수도 없다. */
     required: ["taskId", "kind", "status"],
     fields: {
       taskId: "string",
@@ -9193,7 +9457,7 @@ function ingestOperationalRecords(records, opts) {
           }
           const allowed = spec.enums?.[name];
           if (allowed && !allowed.includes(v)) {
-            errors.push(`${kind}.${name} \uC774 \uCEE4\uB110\uC774 \uC811\uB294 \uB0B1\uB9D0\uC774 \uC544\uB2C8\uB2E4: ${JSON.stringify(v)} \u2014 \uBC1B\uB294 \uAC12\uC740 ${allowed.join(" \xB7 ")}`);
+            errors.push(`${kind}.${name} \uC774 \uCEE4\uB110\uC774 \uB2E4\uB8E8\uB294 \uB0B1\uB9D0\uC774 \uC544\uB2C8\uB2E4: ${JSON.stringify(v)} \u2014 \uBC1B\uB294 \uAC12\uC740 ${allowed.join(" \xB7 ")}`);
             break;
           }
           data[name] = v;
@@ -9532,6 +9796,7 @@ function retiredVocabularyIn(line) {
   MES_BIZSTEP,
   MES_LOCATION_TYPES,
   MES_TYPES,
+  METER_DIRECTION,
   MesKernel,
   OPERATION_PROPERTY,
   OP_EVENT,
@@ -9600,11 +9865,13 @@ function retiredVocabularyIn(line) {
   inWorkCalendarAt,
   ingest,
   ingestEnergyEquipmentRecords,
+  ingestEnergyGenerationRecords,
   ingestEnergyRecords,
   ingestOperationalRecords,
   isAggregationRecord,
   isElectricalLocationType,
   isEnergyEquipmentRecord,
+  isEnergyGenerationRecord,
   isEnergyRecord,
   isEquipmentLevel,
   isOperationalRecord,