@operato/twin-kernel 0.7.18 → 0.7.20

package/dist/contract.d.ts

@@ -699,6 +699,25 @@ export interface LocationState {
      * 중간 단이 생기는 순간 그 아래 자리를 **집계에서 조용히 빠뜨린다**(정합성이 아니라 침묵이 문제다).
      */
     parentId?: string;
+    /**
+     * **전기적으로 어디서 받는가** — 이 자리에 전기를 주는 상류 자리(수전·분기).
+     *
+     * ── 왜 `parentId` 와 따로 두나 (2026-08-18) ─────────────────────────────────
+     * 한동안 분기의 `parentId` 에 수전을 적었다. 그러면 한 필드가 두 뜻을 겸한다: **공간 포함**(이 분기는
+     * 공장 안에 있다)과 **전기 상류**(이 분기는 수전에서 받는다). 겸용의 값은 조용히 새어 나간다 — 공간
+     * 해석기가 수전을 「구역」으로 읽어 매 인제스트마다 거짓 경보를 냈고(「area 가 없는 것을 가리킨다」),
+     * 계통을 읽는 쪽은 공간 부모를 전기 상류로 오해할 위험을 안고 있었다.
+     *
+     * 두 관계는 실제로 다르다: 분기는 공장 **안에** 있고(공간), 수전에서 **받는다**(전기). 한 자리가 둘을
+     * 함께 가질 수 있으므로 필드도 둘이어야 한다.
+     *
+     * **옛 세대는 읽는 경계에서 흡수한다**(`electricalUpstreamOf`): 이 값이 없고 `parentId` 가 전기 자리를
+     * 가리키면 그것을 상류로 읽는다. 저장된 모델을 고치지 않고도 두 세대가 같은 답을 낸다.
+     *
+     * ⚠️ **물류 흐름의 상·하류가 아니다.** 흐름 쪽에는 같은 낱말이 다른 뜻으로 있다(씬의 `downstreamRef` 는
+     * 물건이 다음에 갈 곳이다). 이 값은 **전기를 어디서 받는가**이고, 물건의 이동과 무관하다.
+     */
+    upstreamId?: string;
     /**
      * 이 자리를 **어떻게 알게 됐는가** — `master`(원 시스템 마스터/저작이 말해 준 자리) ·
      * `observed`(이벤트에 등장해서 알게 된 자리). 소비처가 둘을 구별해야 한다: 관측으로 알게 된 자리는
@@ -1206,6 +1225,14 @@ export interface MeterPointState {
     atMs?: number;
     /** 이 구간에 받은 표본 수 — 「못 쟀다」와 「0이었다」를 구별한다. */
     samplesInWindow: number;
+    /**
+     * 이 구간이 열릴 때의 적산값 — **구간 전력량을 뺄셈으로 얻기 위한 기준점.**
+     *
+     * 지점별 구간 전력량은 「끝 적산 − 시작 적산」이다. 그것을 우리가 kW 로 적분하지 않는 이유는,
+     * 적산은 **계량기 자신의 회계**이고 그것이 요금의 근거이기 때문이다(우리가 적분한 값과 미세하게
+     * 다르며, 다를 때 맞는 쪽은 계량기다).
+     */
+    kWhAtWindowStart?: number;
 }
 export interface DemandWindowState {
     startMs: number;

package/dist/ems-kernel.d.ts

@@ -69,6 +69,17 @@ export declare class EmsKernel extends FlowEngine {
      * 가로챈 표본은 **다시 방출하지 않는다**: 원천이 이미 그 사실을 갖고 있고, 저널은 인입에서 한 번만
      * 적는다(상위 `apply` 의 재방출 규약과 같은 이유).
      */
+    /**
+     * 계측·설비 상태는 **에너지 어휘로** 받는다(물품 투영으로 보내지 않는다).
+     *
+     * ── 관측 시각을 함께 민다 (2026-08-18) ──────────────────────────────────────
+     * 이 두 문은 투영기(`ObservedReducer`)를 거치지 않는다. 그래서 「마지막으로 들은 시각」이 갱신되지
+     * 않았고, 초당 여러 건의 계측을 받는 미러 트윈이 **자기가 아무것도 못 들었다고 여겼다**: 커널의
+     * "지금" 이 시뮬 기준시각(2026-01-01)에 얼어, 구간 마감·피크·감축 제안이 전부 8개월 전으로 기록됐다.
+     *
+     * 계측 자체는 원천 시각을 달고 있어서 화면의 순간값은 정상으로 보였다 — 그래서 조용한 결함이었다.
+     * 저널을 기간으로 접는 쪽(성과·요금·피더 배분)은 그 트윈에서 영원히 아무것도 찾지 못했다.
+     */
     apply(envelope: CanonicalEnvelope): void;
     /**
      * 설비가 낸 자기 에너지 상태를 그 설비에 적는다 — 발전·저장·감축 여지·개폐 위치.

package/dist/ems-kernel.js

@@ -28,7 +28,7 @@
 import { FlowEngine } from "./flow-engine.js";
 import { firstFitPolicy } from "./allocation-policy.js";
 import { ENERGY_EVENT } from "./contract.js";
-import { EMS_PROPERTY } from "./ems-profile.js";
+import { EMS_PROPERTY, electricalUpstreamOf } from "./ems-profile.js";
 /** 수요 구간 — 요금의 알갱이다. 15분은 한국·다수 요금제의 최대수요 산정 단위다. */
 export const DEMAND_WINDOW_MS = 15 * 60 * 1000;
 /** 그 시각이 속한 구간의 시작 — 벽시계 경계(00·15·30·45분)에 맞춘다. */
@@ -128,9 +128,17 @@ export class EmsKernel extends FlowEngine {
         const locOf = new Map();
         for (const e of this.boardDef?.equipment ?? [])
             locOf.set(e.id, e.homeLocation);
+        /*
+         * 계층을 **전기 상류**로 걷는다 — 공간 부모가 아니다.
+         *
+         * 예전에는 `parentId` 를 그대로 걸었다. 그때는 분기의 `parentId` 에 수전이 적혀 있어서 답이 같았지만,
+         * 공간 부모(공장·구역)를 적은 모델에서는 그 사슬이 **전기적으로 뜻이 없는 길**을 따라간다. 상류의
+         * 뜻을 읽는 규칙은 한 곳에 있다(`electricalUpstreamOf` — 옛 세대도 그 안에서 흡수한다).
+         */
+        const locs = this.boardDef?.locations ?? [];
         const parentOf = new Map();
-        for (const l of this.boardDef?.locations ?? [])
-            parentOf.set(l.id, l.parentId);
+        for (const l of locs)
+            parentOf.set(l.id, electricalUpstreamOf(locs, l.id));
         /* 계량되고 있는 자리들 — 표본이 실제로 온 계량기의 자리만 센다(선언만 있고 값이 없는 계량기는
            부하에 기여하지 않으므로 계층 판정에서도 제외한다). */
         const meteredLocs = new Set();
@@ -168,6 +176,17 @@ export class EmsKernel extends FlowEngine {
      * 가로챈 표본은 **다시 방출하지 않는다**: 원천이 이미 그 사실을 갖고 있고, 저널은 인입에서 한 번만
      * 적는다(상위 `apply` 의 재방출 규약과 같은 이유).
      */
+    /**
+     * 계측·설비 상태는 **에너지 어휘로** 받는다(물품 투영으로 보내지 않는다).
+     *
+     * ── 관측 시각을 함께 민다 (2026-08-18) ──────────────────────────────────────
+     * 이 두 문은 투영기(`ObservedReducer`)를 거치지 않는다. 그래서 「마지막으로 들은 시각」이 갱신되지
+     * 않았고, 초당 여러 건의 계측을 받는 미러 트윈이 **자기가 아무것도 못 들었다고 여겼다**: 커널의
+     * "지금" 이 시뮬 기준시각(2026-01-01)에 얼어, 구간 마감·피크·감축 제안이 전부 8개월 전으로 기록됐다.
+     *
+     * 계측 자체는 원천 시각을 달고 있어서 화면의 순간값은 정상으로 보였다 — 그래서 조용한 결함이었다.
+     * 저널을 기간으로 접는 쪽(성과·요금·피더 배분)은 그 트윈에서 영원히 아무것도 찾지 못했다.
+     */
     apply(envelope) {
         if (envelope.eventType === ENERGY_EVENT.measured) {
             this.ingestMeasured(envelope);
@@ -215,6 +234,10 @@ export class EmsKernel extends FlowEngine {
         /* **값과 함께 시각을 남긴다** — 없으면 화면이 멈춘 값을 지금 값으로 그린다(계량 지점과 같은 규율). */
         if (d?.at)
             eq.measuredAt = d.at;
+        /* 설비 상태도 관측이다 — 계측과 같은 규칙으로 「마지막으로 들은 시각」을 민다(규칙 한 벌). */
+        const heardAt = Date.parse(String(d?.at ?? envelope.eventTime ?? ''));
+        if (Number.isFinite(heardAt))
+            this.noteObserved(heardAt);
         this.revision++;
     }
     /** 우리 모델이 모르는 설비가 상태를 보내 온 횟수 — 조용히 버리지 않는다. */
@@ -231,6 +254,8 @@ export class EmsKernel extends FlowEngine {
         const id = String(d?.meterId ?? '').trim();
         if (!id)
             throw new Error('energy.measured has no meterId — a measurement with no meter cannot be accumulated');
+        /* 들은 시각을 먼저 민다 — 이 뒤에 나오는 사실(구간 마감·피크)의 시각이 여기서 나온다. */
+        this.noteObserved(atMs);
         /* 이 표본이 새 구간의 것이면 앞 구간을 먼저 닫는다 — 마감이 표본보다 늦으면 최대가 섞인다. */
         this.closeDue(atMs);
         this.openWindow(atMs);
@@ -246,6 +271,15 @@ export class EmsKernel extends FlowEngine {
             if (Number.isFinite(Number(d?.powerFactor)))
                 point.powerFactor = Number(d.powerFactor);
         }
+        /*
+         * 기준점이 아직 없으면 **이 구간의 첫 적산**으로 심는다.
+         *
+         * 구간이 열릴 때 심는 것이 원칙이다(그러면 구간 경계에서 전기가 새지 않는다 — 앞 구간의 마지막
+         * 적산이 이어진다). 그런데 처음 보는 지점은 그때 아직 존재하지 않으므로 심을 값이 없다. 그 지점의
+         * **첫 구간만** 첫 표본을 기준으로 삼는다 — 그 앞의 소비는 우리가 듣지 못한 것이고, 지어내지 않는다.
+         */
+        if (point.kWhAtWindowStart === undefined && point.kWh !== undefined)
+            point.kWhAtWindowStart = point.kWh;
         point.samplesInWindow++;
         this.points.set(id, point);
         const w = this.open;
@@ -280,9 +314,12 @@ export class EmsKernel extends FlowEngine {
             return;
         const contractKW = this.declaredContractKW();
         this.open = { startMs: start, endMs: start + this.windowMs, samples: 0, ...(contractKW !== undefined ? { contractKW } : {}) };
-        /* 새 구간이면 지점별 표본 수도 새로 센다 — 구간마다 「못 쟀다」를 답할 수 있어야 한다. */
-        for (const p of this.points.values())
+        /* 새 구간이면 지점별 표본 수도 새로 센다 — 구간마다 「못 쟀다」를 답할 수 있어야 한다.
+           적산 기준점도 함께 찍는다 — 이 구간의 지점별 전력량은 「끝 − 시작」으로 나온다. */
+        for (const p of this.points.values()) {
             p.samplesInWindow = 0;
+            p.kWhAtWindowStart = p.kWh;
+        }
         this.suggestedFor = undefined;
     }
     /**
@@ -300,6 +337,16 @@ export class EmsKernel extends FlowEngine {
             const w = this.open;
             if (w.contractKW !== undefined && w.maxKW !== undefined)
                 w.overContract = w.maxKW > w.contractKW;
+            /* 지점별 구간 전력량 — 적산의 뺄셈. 기준점이 없거나 적산이 줄었으면(계기 교체) 내지 않는다. */
+            const roots = this.rootMeterIds();
+            const pointShares = [...this.points.values()]
+                .map(p => {
+                const from = p.kWhAtWindowStart;
+                const to = p.kWh;
+                const kWh = from !== undefined && to !== undefined && to >= from ? to - from : undefined;
+                return { id: p.id, ...(kWh !== undefined ? { kWh } : {}), ...(roots.has(p.id) ? { root: true } : {}) };
+            })
+                .filter(p => p.kWh !== undefined);
             this.closed.push(w);
             this.closedTotal++;
             if (this.closed.length > KEEP_CLOSED)
@@ -324,6 +371,22 @@ export class EmsKernel extends FlowEngine {
                  * 다르다. 무엇이 왔는지는 지점별 `samplesInWindow` 가 답한다.
                  */
                 ...(w.samples === 0 ? { observedAbsence: 'no-load-samples' } : {}),
+                /*
+                 * ── 지점별 몫을 함께 낸다 (2026-08-18) ────────────────────────────────
+                 *
+                 * 분기마다 계량기가 있는 현장에서 분기별 전력량은 **측정**이다. 그런데 그 사실이 저널에
+                 * 없어서, 저널을 접는 쪽은 가동시간으로 **배분**할 수밖에 없었다 — 계량이 있는데 배분으로
+                 * 말하는 것은 근거를 실제보다 약하게 보고하는 것이고, 그 위에 세운 SEU 판단이 무거운 값을 놓친다.
+                 *
+                 * 표본을 그대로 저널에 흘리는 대신 **구간마다 한 줄**로 낸다: 계측은 초당 여러 건이라 표본을
+                 * 저널에서 읽게 하면 조회 상한에 먼저 걸린다(호스트가 실제로 그 벽에 부딪혔다).
+                 *
+                 * 값은 적산의 뺄셈이다 — 계량기 자신의 회계이고, 그것이 요금의 근거다. 적산을 주지 않는
+                 * 지점은 **빠진다**(우리가 적분한 수를 계량기가 잰 것처럼 내지 않는다).
+                 *
+                 * `root` 는 계층 판정을 우리가 말해 주는 것이다 — 소비처가 같은 규칙을 다시 쓰면 갈라진다.
+                 */
+                ...(pointShares.length ? { points: pointShares } : {}),
                 /*
                  * **만든 값이면 그렇게 말한다.** 상태에만 표시하고 사실에는 빠뜨리면, 저널을 읽는 쪽
                  * (성과·이력·보고서)이 시뮬레이션의 수를 계측으로 읽는다 — 값이 그럴듯할수록 위험하다.

package/dist/ems-profile.d.ts

@@ -67,3 +67,22 @@ export interface EmsPropertySpec {
 }
 export declare const EMS_PROPERTY_SPEC: Record<string, EmsPropertySpec>;
 export declare const EMS_TYPES: TwinTypeInfo[];
+/**
+ * 이 자리의 **전기 상류** — 어디서 전기를 받는가.
+ *
+ * ── 왜 함수로 두나 (2026-08-18) ─────────────────────────────────────────────
+ * 두 세대가 섞여 있다. 새 모델은 `upstream` 을 적고, 그 전 모델은 분기의 `parentId` 에 수전을 적었다.
+ * 판정을 소비처마다 쓰면(호스트·계통도·커널) 한쪽만 고쳐지고 그때부터 화면과 계산이 다른 계통을 말한다.
+ * 그래서 **읽는 규칙을 한 곳**에 둔다.
+ *
+ * 옛 세대를 흡수하는 조건이 좁다: `parentId` 가 **전기 자리**(수전·분기·구역 계량)를 가리킬 때만
+ * 상류로 읽는다. 공장·구역 같은 공간 부모를 상류로 읽으면 없는 결선을 만들어 낸다.
+ */
+export declare function electricalUpstreamOf(locations: readonly {
+    id: string;
+    type?: string;
+    parentId?: string;
+    upstreamId?: string;
+}[] | undefined | null, id: string): string | undefined;
+/** 전기 계통의 자리인가 — 수전·분기·구역 계량. */
+export declare function isElectricalLocationType(type: string): boolean;

package/dist/ems-profile.js

@@ -210,3 +210,30 @@ export const EMS_TYPES = [
         capabilities: ['curtailable', 'metered', 'operable']
     }
 ];
+/**
+ * 이 자리의 **전기 상류** — 어디서 전기를 받는가.
+ *
+ * ── 왜 함수로 두나 (2026-08-18) ─────────────────────────────────────────────
+ * 두 세대가 섞여 있다. 새 모델은 `upstream` 을 적고, 그 전 모델은 분기의 `parentId` 에 수전을 적었다.
+ * 판정을 소비처마다 쓰면(호스트·계통도·커널) 한쪽만 고쳐지고 그때부터 화면과 계산이 다른 계통을 말한다.
+ * 그래서 **읽는 규칙을 한 곳**에 둔다.
+ *
+ * 옛 세대를 흡수하는 조건이 좁다: `parentId` 가 **전기 자리**(수전·분기·구역 계량)를 가리킬 때만
+ * 상류로 읽는다. 공장·구역 같은 공간 부모를 상류로 읽으면 없는 결선을 만들어 낸다.
+ */
+export function electricalUpstreamOf(locations, id) {
+    const byId = new Map((locations ?? []).filter(l => l?.id).map(l => [String(l.id), l]));
+    const self = byId.get(String(id));
+    if (!self)
+        return undefined;
+    if (self.upstreamId)
+        return String(self.upstreamId);
+    const parent = self.parentId ? byId.get(String(self.parentId)) : undefined;
+    if (!parent)
+        return undefined;
+    return isElectricalLocationType(String(parent.type ?? '')) ? String(parent.id) : undefined;
+}
+/** 전기 계통의 자리인가 — 수전·분기·구역 계량. */
+export function isElectricalLocationType(type) {
+    return EMS_LOCATION_TYPES.includes(type);
+}

package/dist/energy-attribution.d.ts

@@ -32,6 +32,18 @@ export interface EnergyPool {
      * 같은 규율이고, 그 결과는 배분(`apportioned`)이며 `overhead: true` 로 표시된다.
      */
     overhead?: boolean;
+    /**
+     * **하위 계량이 덮지 않는 나머지** — 뿌리 계량에서 하위 계량의 합을 뺀 몫.
+     *
+     * ── 왜 종류를 따로 두나 (2026-08-18) ──────────────────────────────────────
+     * 분기마다 계량기가 있는 현장에서 분기별 값은 **측정**이다(배분이 아니다). 그런데 분기 계량의 합은
+     * 뿌리 계량보다 대개 작다 — 수전에 바로 매달린 부하, 변압기 손실, 계량되지 않은 회로가 그 차이다.
+     * 그 차이를 어느 분기에 얹으면 그 분기가 쓰지 않은 전기를 쓴 것으로 만들고, 버리면 합이 깨진다.
+     *
+     * 그래서 나머지도 **하나의 몫**으로 남기되, 「덮는 대상이 선언되지 않았다(no-consumers)」와는 다른
+     * 사실로 적는다. 앞의 것은 사람이 선언을 채워야 하는 결손이고, 이것은 **계량 범위의 사실**이다.
+     */
+    remainder?: boolean;
 }
 export interface EnergyShare {
     consumerId: string;
@@ -54,10 +66,11 @@ export interface Unattributed {
     kWh: number;
     /**
      * 왜 나누지 못했나 — **언어중립 코드**(화면이 옮긴다).
-     *  · `no-consumers` — 이 계량기가 무엇을 덮는지 선언되지 않았다
-     *  · `no-weights`   — 소비처는 있는데 나눌 몫이 없다(가동시간·산출량 어느 것도)
+     *  · `no-consumers`   — 이 계량기가 무엇을 덮는지 선언되지 않았다
+     *  · `no-weights`     — 소비처는 있는데 나눌 몫이 없다(가동시간·산출량 어느 것도)
+     *  · `not-submetered` — 뿌리에서 재었지만 **하위 계량이 덮지 않는** 부분이다(§EnergyPool.remainder)
      */
-    reason: 'no-consumers' | 'no-weights';
+    reason: 'no-consumers' | 'no-weights' | 'not-submetered';
     /** 몫을 못 정한 소비처들 — 사람이 무엇을 채워야 할지 알 수 있게. */
     consumerIds?: string[];
 }

package/dist/energy-attribution.js

@@ -84,10 +84,11 @@ export function attributeEnergy(opts) {
             });
             continue;
         }
-        /* ② 덮는 소비처가 선언되지 않았다 — 나눌 대상이 없다. */
+        /* ② 덮는 소비처가 선언되지 않았다 — 나눌 대상이 없다.
+           나머지 몫(`remainder`)은 **결손이 아니라 계량 범위의 사실**이므로 다른 코드로 적는다. */
         const covered = (pool.consumerIds ?? []).map(id => byId.get(id)).filter((c) => !!c);
         if (!covered.length) {
-            unattributed.push({ poolMeterId: pool.meterId, kWh, reason: 'no-consumers' });
+            unattributed.push({ poolMeterId: pool.meterId, kWh, reason: pool.remainder ? 'not-submetered' : 'no-consumers' });
             continue;
         }
         /* ③ 하나뿐이면 그것도 측정이다 — 그 계량기가 그 소비처만 덮는다는 선언이므로. */

package/dist/flow-engine.d.ts

@@ -502,6 +502,10 @@ export declare abstract class FlowEngine implements TwinKernel {
      *
      * 관측 중이면 **마지막으로 들은 발생 시각**을 쓴다(미러의 `lastObservedMs` 와 같은 기준 — 규칙 한 벌).
      * 아직 아무것도 못 들었으면 시뮬 기준으로 떨어진다(그때는 판정할 사실도 없다).
+     *
+     * 들은 시각의 출처가 **둘**이다: 물류 투영기(`ObservedReducer`)와, 도메인 어휘로 직접 받는 경로
+     * (`noteObserved` — 에너지 계측). 둘 중 **나중 것**을 쓴다: 한쪽만 보면 그 트윈이 실제로 듣고 있는데도
+     * 「아무것도 못 들었다」가 되어, 커널이 내는 사실이 시뮬 기준시각(2026-01-01)으로 기록된다.
      */
     protected nowMs(): number;
     /**
@@ -567,6 +571,18 @@ export declare abstract class FlowEngine implements TwinKernel {
     private settleObserved;
     /** 구독자 목록 — 관측 재방출용(private handlers 에 접근). */
     private observedHandlers;
+    /**
+     * 관측 시각을 앞으로 민다 — **투영기를 거치지 않는 관측을 위한 문.**
+     *
+     * 도메인 커널이 자기 어휘의 관측을 `apply()` 에서 먼저 처리하고 돌아가는 경우가 있다(에너지 계측이
+     * 그렇다 — 물품 투영과 어휘가 다르므로 옳다). 그때도 「마지막으로 들은 시각」은 갱신돼야 한다:
+     * 그것이 관측 구동 커널의 **지금**이고, 커널이 내는 모든 사실의 시각이 여기서 나온다.
+     *
+     * 이 문이 없던 동안 미러 에너지 트윈의 사실들이 시뮬 기준시각으로 기록됐다([[noteObservedAt]]).
+     */
+    protected noteObserved(atMs: number): void;
+    /** 도메인 어휘로 직접 들은 마지막 관측 시각 — 투영기를 거치지 않는 경로의 「지금」. */
+    private heardAtMs?;
     /** 관측 구동으로 굴러가는 중인가 — 소비처가 "이 커널의 진실이 어디서 오나" 를 물을 수 있게. */
     get observing(): boolean;
     /**

package/dist/flow-engine.js

@@ -1150,10 +1150,17 @@ export class FlowEngine {
      *
      * 관측 중이면 **마지막으로 들은 발생 시각**을 쓴다(미러의 `lastObservedMs` 와 같은 기준 — 규칙 한 벌).
      * 아직 아무것도 못 들었으면 시뮬 기준으로 떨어진다(그때는 판정할 사실도 없다).
+     *
+     * 들은 시각의 출처가 **둘**이다: 물류 투영기(`ObservedReducer`)와, 도메인 어휘로 직접 받는 경로
+     * (`noteObserved` — 에너지 계측). 둘 중 **나중 것**을 쓴다: 한쪽만 보면 그 트윈이 실제로 듣고 있는데도
+     * 「아무것도 못 들었다」가 되어, 커널이 내는 사실이 시뮬 기준시각(2026-01-01)으로 기록된다.
      */
     nowMs() {
-        const observed = this.observeMode ? this.observer?.lastObservedMs : undefined;
-        return observed ?? this.originMs + this.clockMs;
+        if (!this.observeMode)
+            return this.originMs + this.clockMs;
+        const fromProjection = this.observer?.lastObservedMs;
+        const heard = [fromProjection, this.heardAtMs].filter((v) => Number.isFinite(v));
+        return heard.length ? Math.max(...heard) : this.originMs + this.clockMs;
     }
     /**
      * 시각 기준점을 세운다 — **살아 있는 시뮬 트윈은 실제 시각 위에서 돈다.**
@@ -1253,6 +1260,28 @@ export class FlowEngine {
     observedHandlers() {
         return this.handlersRef();
     }
+    /**
+     * 관측 시각을 앞으로 민다 — **투영기를 거치지 않는 관측을 위한 문.**
+     *
+     * 도메인 커널이 자기 어휘의 관측을 `apply()` 에서 먼저 처리하고 돌아가는 경우가 있다(에너지 계측이
+     * 그렇다 — 물품 투영과 어휘가 다르므로 옳다). 그때도 「마지막으로 들은 시각」은 갱신돼야 한다:
+     * 그것이 관측 구동 커널의 **지금**이고, 커널이 내는 모든 사실의 시각이 여기서 나온다.
+     *
+     * 이 문이 없던 동안 미러 에너지 트윈의 사실들이 시뮬 기준시각으로 기록됐다([[noteObservedAt]]).
+     */
+    noteObserved(atMs) {
+        if (!Number.isFinite(atMs))
+            return;
+        /*
+         * 투영기에도 알리지만(있으면), **커널 자신도 기억한다.** 투영기는 첫 물류 이벤트에서야 생기므로,
+         * 계측만 받는 트윈(에너지 미러)에는 아직 없을 수 있다 — 그 경우 알릴 곳이 없어 조용히 사라졌다.
+         */
+        this.observer?.noteObservedAt(atMs);
+        if (this.heardAtMs === undefined || atMs > this.heardAtMs)
+            this.heardAtMs = atMs;
+    }
+    /** 도메인 어휘로 직접 들은 마지막 관측 시각 — 투영기를 거치지 않는 경로의 「지금」. */
+    heardAtMs;
     /** 관측 구동으로 굴러가는 중인가 — 소비처가 "이 커널의 진실이 어디서 오나" 를 물을 수 있게. */
     get observing() {
         return this.observeMode;

package/dist/observed-reducer.d.ts

@@ -181,6 +181,22 @@ export declare class ObservedReducer {
      * `undefined` — 없는 기준으로 단정하지 않는다.
      */
     get lastObservedMs(): number | undefined;
+    /**
+     * 관측 시각을 앞으로 민다 — **이 문을 거치지 않는 관측이 있다.**
+     *
+     * ── 무엇이 났나 (2026-08-18) ────────────────────────────────────────────────
+     * 에너지 커널은 계측(`energy.measured`)을 이 리듀서 **앞에서** 가로채 자기 구간에 누적한다(물류 투영과
+     * 어휘가 다르므로 옳다). 그런데 그 경로가 「마지막으로 들은 시각」을 갱신하지 않았다. 그래서 계측이
+     * 초당 여러 건 들어오는 미러 트윈이 **자기가 아무것도 못 들었다고 여겼고**, 커널의 "지금" 이
+     * 시뮬 기준시각(BASE_EPOCH, 2026-01-01)에 얼어 있었다.
+     *
+     * 결과는 조용했다: 구간 마감·피크 같은 **커널이 낸 사실이 8개월 전으로 기록**되어, 저널을 기간으로
+     * 접는 소비처(성과·요금·피더 배분)가 그 트윈에서 영원히 아무것도 찾지 못했다. 계측 자체는 원천 시각을
+     * 달고 있었으므로 화면의 순간값만 정상으로 보였다 — 그래서 눈에 띄지 않았다.
+     *
+     * 시각을 되돌리지는 않는다: 늦게 도착한 옛 표본이 "지금" 을 과거로 끌면 그 뒤 판정이 전부 흔들린다.
+     */
+    noteObservedAt(atMs: number): void;
     /** 선언된 교대만 기억한다 — 아무 선언이 없으면 키를 만들지 않는다(24시간 가용이 기존 거동). */
     private rememberShift;
     /**

package/dist/observed-reducer.js

@@ -565,6 +565,27 @@ export class ObservedReducer {
     get lastObservedMs() {
         return this.observedAtMs;
     }
+    /**
+     * 관측 시각을 앞으로 민다 — **이 문을 거치지 않는 관측이 있다.**
+     *
+     * ── 무엇이 났나 (2026-08-18) ────────────────────────────────────────────────
+     * 에너지 커널은 계측(`energy.measured`)을 이 리듀서 **앞에서** 가로채 자기 구간에 누적한다(물류 투영과
+     * 어휘가 다르므로 옳다). 그런데 그 경로가 「마지막으로 들은 시각」을 갱신하지 않았다. 그래서 계측이
+     * 초당 여러 건 들어오는 미러 트윈이 **자기가 아무것도 못 들었다고 여겼고**, 커널의 "지금" 이
+     * 시뮬 기준시각(BASE_EPOCH, 2026-01-01)에 얼어 있었다.
+     *
+     * 결과는 조용했다: 구간 마감·피크 같은 **커널이 낸 사실이 8개월 전으로 기록**되어, 저널을 기간으로
+     * 접는 소비처(성과·요금·피더 배분)가 그 트윈에서 영원히 아무것도 찾지 못했다. 계측 자체는 원천 시각을
+     * 달고 있었으므로 화면의 순간값만 정상으로 보였다 — 그래서 눈에 띄지 않았다.
+     *
+     * 시각을 되돌리지는 않는다: 늦게 도착한 옛 표본이 "지금" 을 과거로 끌면 그 뒤 판정이 전부 흔들린다.
+     */
+    noteObservedAt(atMs) {
+        if (!Number.isFinite(atMs))
+            return;
+        if (this.observedAtMs === undefined || atMs > this.observedAtMs)
+            this.observedAtMs = atMs;
+    }
     /** 선언된 교대만 기억한다 — 아무 선언이 없으면 키를 만들지 않는다(24시간 가용이 기존 거동). */
     rememberShift(key, r) {
         if (!r.workCalendar?.length && !r.window)

package/dist-cjs/index.cjs

@@ -97,6 +97,7 @@ __export(index_exports, {
   documentPath: () => documentPath,
   dueStatusOf: () => dueStatusOf,
   effectivityAt: () => effectivityAt,
+  electricalUpstreamOf: () => electricalUpstreamOf,
   electricityCost: () => electricityCost,
   energyIntensity: () => energyIntensity,
   energyOfWindows: () => energyOfWindows,
@@ -112,6 +113,7 @@ __export(index_exports, {
   ingest: () => ingest,
   ingestEnergyEquipmentRecords: () => ingestEnergyEquipmentRecords,
   ingestEnergyRecords: () => ingestEnergyRecords,
+  isElectricalLocationType: () => isElectricalLocationType,
   isEnergyEquipmentRecord: () => isEnergyEquipmentRecord,
   isEnergyRecord: () => isEnergyRecord,
   isEquipmentLevel: () => isEquipmentLevel,
@@ -1515,6 +1517,25 @@ var ObservedReducer = class {
   get lastObservedMs() {
     return this.observedAtMs;
   }
+  /**
+   * 관측 시각을 앞으로 민다 — **이 문을 거치지 않는 관측이 있다.**
+   *
+   * ── 무엇이 났나 (2026-08-18) ────────────────────────────────────────────────
+   * 에너지 커널은 계측(`energy.measured`)을 이 리듀서 **앞에서** 가로채 자기 구간에 누적한다(물류 투영과
+   * 어휘가 다르므로 옳다). 그런데 그 경로가 「마지막으로 들은 시각」을 갱신하지 않았다. 그래서 계측이
+   * 초당 여러 건 들어오는 미러 트윈이 **자기가 아무것도 못 들었다고 여겼고**, 커널의 "지금" 이
+   * 시뮬 기준시각(BASE_EPOCH, 2026-01-01)에 얼어 있었다.
+   *
+   * 결과는 조용했다: 구간 마감·피크 같은 **커널이 낸 사실이 8개월 전으로 기록**되어, 저널을 기간으로
+   * 접는 소비처(성과·요금·피더 배분)가 그 트윈에서 영원히 아무것도 찾지 못했다. 계측 자체는 원천 시각을
+   * 달고 있었으므로 화면의 순간값만 정상으로 보였다 — 그래서 눈에 띄지 않았다.
+   *
+   * 시각을 되돌리지는 않는다: 늦게 도착한 옛 표본이 "지금" 을 과거로 끌면 그 뒤 판정이 전부 흔들린다.
+   */
+  noteObservedAt(atMs) {
+    if (!Number.isFinite(atMs)) return;
+    if (this.observedAtMs === void 0 || atMs > this.observedAtMs) this.observedAtMs = atMs;
+  }
   /** 선언된 교대만 기억한다 — 아무 선언이 없으면 키를 만들지 않는다(24시간 가용이 기존 거동). */
   rememberShift(key, r) {
     if (!r.workCalendar?.length && !r.window) return;
@@ -1875,6 +1896,18 @@ var EMS_TYPES = [
     capabilities: ["curtailable", "metered", "operable"]
   }
 ];
+function electricalUpstreamOf(locations, id) {
+  const byId = new Map((locations ?? []).filter((l) => l?.id).map((l) => [String(l.id), l]));
+  const self = byId.get(String(id));
+  if (!self) return void 0;
+  if (self.upstreamId) return String(self.upstreamId);
+  const parent = self.parentId ? byId.get(String(self.parentId)) : void 0;
+  if (!parent) return void 0;
+  return isElectricalLocationType(String(parent.type ?? "")) ? String(parent.id) : void 0;
+}
+function isElectricalLocationType(type) {
+  return EMS_LOCATION_TYPES.includes(type);
+}
 
 // src/capability.ts
 var CAPABILITIES = {
@@ -3799,10 +3832,16 @@ var FlowEngine = class {
    *
    * 관측 중이면 **마지막으로 들은 발생 시각**을 쓴다(미러의 `lastObservedMs` 와 같은 기준 — 규칙 한 벌).
    * 아직 아무것도 못 들었으면 시뮬 기준으로 떨어진다(그때는 판정할 사실도 없다).
+   *
+   * 들은 시각의 출처가 **둘**이다: 물류 투영기(`ObservedReducer`)와, 도메인 어휘로 직접 받는 경로
+   * (`noteObserved` — 에너지 계측). 둘 중 **나중 것**을 쓴다: 한쪽만 보면 그 트윈이 실제로 듣고 있는데도
+   * 「아무것도 못 들었다」가 되어, 커널이 내는 사실이 시뮬 기준시각(2026-01-01)으로 기록된다.
    */
   nowMs() {
-    const observed = this.observeMode ? this.observer?.lastObservedMs : void 0;
-    return observed ?? this.originMs + this.clockMs;
+    if (!this.observeMode) return this.originMs + this.clockMs;
+    const fromProjection = this.observer?.lastObservedMs;
+    const heard = [fromProjection, this.heardAtMs].filter((v) => Number.isFinite(v));
+    return heard.length ? Math.max(...heard) : this.originMs + this.clockMs;
   }
   /**
    * 시각 기준점을 세운다 — **살아 있는 시뮬 트윈은 실제 시각 위에서 돈다.**
@@ -3893,6 +3932,22 @@ var FlowEngine = class {
   observedHandlers() {
     return this.handlersRef();
   }
+  /**
+   * 관측 시각을 앞으로 민다 — **투영기를 거치지 않는 관측을 위한 문.**
+   *
+   * 도메인 커널이 자기 어휘의 관측을 `apply()` 에서 먼저 처리하고 돌아가는 경우가 있다(에너지 계측이
+   * 그렇다 — 물품 투영과 어휘가 다르므로 옳다). 그때도 「마지막으로 들은 시각」은 갱신돼야 한다:
+   * 그것이 관측 구동 커널의 **지금**이고, 커널이 내는 모든 사실의 시각이 여기서 나온다.
+   *
+   * 이 문이 없던 동안 미러 에너지 트윈의 사실들이 시뮬 기준시각으로 기록됐다([[noteObservedAt]]).
+   */
+  noteObserved(atMs) {
+    if (!Number.isFinite(atMs)) return;
+    this.observer?.noteObservedAt(atMs);
+    if (this.heardAtMs === void 0 || atMs > this.heardAtMs) this.heardAtMs = atMs;
+  }
+  /** 도메인 어휘로 직접 들은 마지막 관측 시각 — 투영기를 거치지 않는 경로의 「지금」. */
+  heardAtMs;
   /** 관측 구동으로 굴러가는 중인가 — 소비처가 "이 커널의 진실이 어디서 오나" 를 물을 수 있게. */
   get observing() {
     return this.observeMode;
@@ -6008,8 +6063,9 @@ var EmsKernel = class extends FlowEngine {
   rootMeterIds() {
     const locOf = /* @__PURE__ */ new Map();
     for (const e of this.boardDef?.equipment ?? []) locOf.set(e.id, e.homeLocation);
+    const locs = this.boardDef?.locations ?? [];
     const parentOf = /* @__PURE__ */ new Map();
-    for (const l of this.boardDef?.locations ?? []) parentOf.set(l.id, l.parentId);
+    for (const l of locs) parentOf.set(l.id, electricalUpstreamOf(locs, l.id));
     const meteredLocs = /* @__PURE__ */ new Set();
     for (const id of this.points.keys()) {
       const loc = locOf.get(id);
@@ -6043,6 +6099,17 @@ var EmsKernel = class extends FlowEngine {
    * 가로챈 표본은 **다시 방출하지 않는다**: 원천이 이미 그 사실을 갖고 있고, 저널은 인입에서 한 번만
    * 적는다(상위 `apply` 의 재방출 규약과 같은 이유).
    */
+  /**
+   * 계측·설비 상태는 **에너지 어휘로** 받는다(물품 투영으로 보내지 않는다).
+   *
+   * ── 관측 시각을 함께 민다 (2026-08-18) ──────────────────────────────────────
+   * 이 두 문은 투영기(`ObservedReducer`)를 거치지 않는다. 그래서 「마지막으로 들은 시각」이 갱신되지
+   * 않았고, 초당 여러 건의 계측을 받는 미러 트윈이 **자기가 아무것도 못 들었다고 여겼다**: 커널의
+   * "지금" 이 시뮬 기준시각(2026-01-01)에 얼어, 구간 마감·피크·감축 제안이 전부 8개월 전으로 기록됐다.
+   *
+   * 계측 자체는 원천 시각을 달고 있어서 화면의 순간값은 정상으로 보였다 — 그래서 조용한 결함이었다.
+   * 저널을 기간으로 접는 쪽(성과·요금·피더 배분)은 그 트윈에서 영원히 아무것도 찾지 못했다.
+   */
   apply(envelope) {
     if (envelope.eventType === ENERGY_EVENT.measured) {
       this.ingestMeasured(envelope);
@@ -6087,6 +6154,8 @@ var EmsKernel = class extends FlowEngine {
     put("minKW");
     put("position");
     if (d?.at) eq.measuredAt = d.at;
+    const heardAt = Date.parse(String(d?.at ?? envelope.eventTime ?? ""));
+    if (Number.isFinite(heardAt)) this.noteObserved(heardAt);
     this.revision++;
   }
   /** 우리 모델이 모르는 설비가 상태를 보내 온 횟수 — 조용히 버리지 않는다. */
@@ -6097,6 +6166,7 @@ var EmsKernel = class extends FlowEngine {
     if (atMs === void 0) throw new Error("energy.measured has no usable time (data.at / eventTime) \u2014 cannot place it in a demand window");
     const id = String(d?.meterId ?? "").trim();
     if (!id) throw new Error("energy.measured has no meterId \u2014 a measurement with no meter cannot be accumulated");
+    this.noteObserved(atMs);
     this.closeDue(atMs);
     this.openWindow(atMs);
     const kW = Number.isFinite(Number(d?.kW)) ? Number(d.kW) : void 0;
@@ -6107,6 +6177,7 @@ var EmsKernel = class extends FlowEngine {
       if (Number.isFinite(Number(d?.kWh))) point.kWh = Number(d.kWh);
       if (Number.isFinite(Number(d?.powerFactor))) point.powerFactor = Number(d.powerFactor);
     }
+    if (point.kWhAtWindowStart === void 0 && point.kWh !== void 0) point.kWhAtWindowStart = point.kWh;
     point.samplesInWindow++;
     this.points.set(id, point);
     const w = this.open;
@@ -6125,7 +6196,10 @@ var EmsKernel = class extends FlowEngine {
     if (this.open?.startMs === start) return;
     const contractKW = this.declaredContractKW();
     this.open = { startMs: start, endMs: start + this.windowMs, samples: 0, ...contractKW !== void 0 ? { contractKW } : {} };
-    for (const p of this.points.values()) p.samplesInWindow = 0;
+    for (const p of this.points.values()) {
+      p.samplesInWindow = 0;
+      p.kWhAtWindowStart = p.kWh;
+    }
     this.suggestedFor = void 0;
   }
   /**
@@ -6142,6 +6216,13 @@ var EmsKernel = class extends FlowEngine {
     while (this.open && nowMs >= this.open.endMs) {
       const w = this.open;
       if (w.contractKW !== void 0 && w.maxKW !== void 0) w.overContract = w.maxKW > w.contractKW;
+      const roots = this.rootMeterIds();
+      const pointShares = [...this.points.values()].map((p) => {
+        const from = p.kWhAtWindowStart;
+        const to = p.kWh;
+        const kWh = from !== void 0 && to !== void 0 && to >= from ? to - from : void 0;
+        return { id: p.id, ...kWh !== void 0 ? { kWh } : {}, ...roots.has(p.id) ? { root: true } : {} };
+      }).filter((p) => p.kWh !== void 0);
       this.closed.push(w);
       this.closedTotal++;
       if (this.closed.length > KEEP_CLOSED) this.closed.splice(0, this.closed.length - KEEP_CLOSED);
@@ -6165,6 +6246,22 @@ var EmsKernel = class extends FlowEngine {
          * 다르다. 무엇이 왔는지는 지점별 `samplesInWindow` 가 답한다.
          */
         ...w.samples === 0 ? { observedAbsence: "no-load-samples" } : {},
+        /*
+         * ── 지점별 몫을 함께 낸다 (2026-08-18) ────────────────────────────────
+         *
+         * 분기마다 계량기가 있는 현장에서 분기별 전력량은 **측정**이다. 그런데 그 사실이 저널에
+         * 없어서, 저널을 접는 쪽은 가동시간으로 **배분**할 수밖에 없었다 — 계량이 있는데 배분으로
+         * 말하는 것은 근거를 실제보다 약하게 보고하는 것이고, 그 위에 세운 SEU 판단이 무거운 값을 놓친다.
+         *
+         * 표본을 그대로 저널에 흘리는 대신 **구간마다 한 줄**로 낸다: 계측은 초당 여러 건이라 표본을
+         * 저널에서 읽게 하면 조회 상한에 먼저 걸린다(호스트가 실제로 그 벽에 부딪혔다).
+         *
+         * 값은 적산의 뺄셈이다 — 계량기 자신의 회계이고, 그것이 요금의 근거다. 적산을 주지 않는
+         * 지점은 **빠진다**(우리가 적분한 수를 계량기가 잰 것처럼 내지 않는다).
+         *
+         * `root` 는 계층 판정을 우리가 말해 주는 것이다 — 소비처가 같은 규칙을 다시 쓰면 갈라진다.
+         */
+        ...pointShares.length ? { points: pointShares } : {},
         /*
          * **만든 값이면 그렇게 말한다.** 상태에만 표시하고 사실에는 빠뜨리면, 저널을 읽는 쪽
          * (성과·이력·보고서)이 시뮬레이션의 수를 계측으로 읽는다 — 값이 그럴듯할수록 위험하다.
@@ -6603,7 +6700,7 @@ function attributeEnergy(opts) {
     }
     const covered = (pool.consumerIds ?? []).map((id) => byId.get(id)).filter((c) => !!c);
     if (!covered.length) {
-      unattributed.push({ poolMeterId: pool.meterId, kWh, reason: "no-consumers" });
+      unattributed.push({ poolMeterId: pool.meterId, kWh, reason: pool.remainder ? "not-submetered" : "no-consumers" });
       continue;
     }
     if (covered.length === 1) {
@@ -6860,6 +6957,7 @@ function retiredVocabularyIn(line) {
   documentPath,
   dueStatusOf,
   effectivityAt,
+  electricalUpstreamOf,
   electricityCost,
   energyIntensity,
   energyOfWindows,
@@ -6875,6 +6973,7 @@ function retiredVocabularyIn(line) {
   ingest,
   ingestEnergyEquipmentRecords,
   ingestEnergyRecords,
+  isElectricalLocationType,
   isEnergyEquipmentRecord,
   isEnergyRecord,
   isEquipmentLevel,

package/package.json

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