@operato/twin-kernel 0.7.64 → 0.7.66

package/dist/energy-ingest.js

@@ -99,8 +99,8 @@ export function isEnergyEquipmentRecord(record) {
     return typeof r.equipmentId === 'string' && r.equipmentId.trim().length > 0 && r.epc === undefined && r.meterId === undefined;
 }
 /**
- * 설비 에너지 레코드 → 봉투. 계량과 같은 규율이다: 지어낼 수 없는 것이 빠지면 거부하고, 거부한 것은
- * 이유와 함께 돌려준다.
+ * 설비 에너지 레코드 → 봉투. 계량과 같은 규율이다: 지어낼 수 없는 것이 빠지면 받지 않고, 받지 않은 것은
+ * 이유와 함께 알린다.
  *
  * **값이 하나도 없는 레코드는 거부한다** — 계량과 다른 점이다. 계량은 「응답했다」는 사실 자체가
  * 관측이지만(그래서 kW 없는 표본을 받는다), 여기서는 바꿀 상태가 없는 것을 사실로 적을 이유가 없다.
@@ -192,3 +192,59 @@ export function ingestEnergyEquipmentRecords(records, opts) {
     }
     return { accepted, rejected };
 }
+/** 이 레코드가 발전 적산인가 — 어느 갈래로 보낼지를 한 곳에서 정한다. */
+export 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 !== undefined &&
+        r.meterId === undefined &&
+        r.epc === undefined);
+}
+/**
+ * 발전 적산 레코드 → 봉투. 계량과 같은 규율이다: 지어낼 수 없는 것이 빠지면 받지 않고, 받지 않은 것은
+ * 이유와 함께 알린다.
+ *
+ * **적산이 없는 레코드는 받지 않는다** — 이 문의 값은 그것 하나다. 순시 출력은 설비 상태 문이 받는다
+ * (`EnergyEquipmentRecord.generatedKW`).
+ */
+export function ingestEnergyGenerationRecords(records, opts) {
+    const list = records === undefined || 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 가 없다 — 어느 설비가 만든 것인지 지어낼 수 없다');
+        const raw = r?.kWh;
+        const kWh = Number(raw);
+        if (raw === undefined || raw === null || !Number.isFinite(kWh)) {
+            errors.push('kWh 가 없다 — 이 문이 받는 값은 적산 하나다(순시 출력은 설비 상태로 보낸다)');
+        }
+        else if (kWh < 0) {
+            /* 음수 적산은 계기가 낼 수 있는 값이 아니다. 받아 두면 그 뒤의 차분이 전부 거짓이 된다. */
+            errors.push(`kWh 가 음수다(${kWh}) — 적산은 뒤로 가더라도 음수가 되지 않는다`);
+        }
+        const eventTime = String(r?.at ?? '').trim() || opts.defaultEventTime || '';
+        if (!eventTime)
+            errors.push('at 이 없고 기본 시각도 주지 않았다 — 언제 잰 것인지 지어낼 수 없다');
+        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 };
+}

package/dist/epcis.d.ts

@@ -11,12 +11,12 @@ export declare const DISP: {
     /**
      * **기한이 지났다** — CBV `expired`.
      *
-     * ── 왜 `non_sellable` 로 접지 않나 (2026-08-24) ─────────────────────────────
+     * ── 왜 `non_sellable` 로 계산하지 않나 (2026-08-24) ─────────────────────────────
      * 커널의 `non_sellable` 은 CBV 의 `non_sellable_other`, 즉 **「그 밖의 이유」**다. 기한 지남을 거기
      * 넣으면 「기한이 지나 못 판다」와 「깨져서 못 판다」가 같은 값이 되고, 화면은 회수·폐기의 사유를
      * 구별할 수 없다. 식품에서 그 둘은 다른 조치다.
      *
-     * 그리고 표준에 **정확한 낱말이 있다** — 접는 것은 있는 낱말을 버리는 것이다.
+     * 그리고 표준에 **정확한 낱말이 있다** — 합치는 것은 있는 낱말을 버리는 것이다.
      *
      * ── 기한 날짜와 다른 축이다 ────────────────────────────────────────────────
      * `ItemState.expiry` 는 **날짜**이고 이것은 **상태**다. 날짜가 있으면 「지났나」는 파생이지만, 원본이

package/dist/epcis.js

@@ -20,12 +20,12 @@ export const DISP = {
     /**
      * **기한이 지났다** — CBV `expired`.
      *
-     * ── 왜 `non_sellable` 로 접지 않나 (2026-08-24) ─────────────────────────────
+     * ── 왜 `non_sellable` 로 계산하지 않나 (2026-08-24) ─────────────────────────────
      * 커널의 `non_sellable` 은 CBV 의 `non_sellable_other`, 즉 **「그 밖의 이유」**다. 기한 지남을 거기
      * 넣으면 「기한이 지나 못 판다」와 「깨져서 못 판다」가 같은 값이 되고, 화면은 회수·폐기의 사유를
      * 구별할 수 없다. 식품에서 그 둘은 다른 조치다.
      *
-     * 그리고 표준에 **정확한 낱말이 있다** — 접는 것은 있는 낱말을 버리는 것이다.
+     * 그리고 표준에 **정확한 낱말이 있다** — 합치는 것은 있는 낱말을 버리는 것이다.
      *
      * ── 기한 날짜와 다른 축이다 ────────────────────────────────────────────────
      * `ItemState.expiry` 는 **날짜**이고 이것은 **상태**다. 날짜가 있으면 「지났나」는 파생이지만, 원본이

package/dist/event-journal.d.ts

@@ -16,14 +16,14 @@ export declare class EventJournal {
 /** 이벤트열 → 상태 재구성(시간여행). `model` = 그 시점의 트윈 모델(토폴로지·자원). */
 export declare function replay(model: TwinModelDef, events: readonly CanonicalEnvelope[]): ProjectedState;
 /**
- * **재개점에서 이어 접는다** — 0부터 다시 접지 않는다.
+ * **재개점에서 이어서 계산한다** — 0부터 다시 계산하지 않는다.
  *
  * ── 왜 (2026-08-18 실측) ────────────────────────────────────────────────────
- * 저널이 27만 건인 트윈에서 과거 상태를 물으면 전부 다시 접어야 했다. 그런데 우리는 이미 주기적으로
- * 재개점을 남기고 있다 — 그 지점부터 **뒤에 일어난 것만** 접으면 같은 답이 나온다.
+ * 저널이 27만 건인 트윈에서 과거 상태를 물으면 전부 다시 계산해야 했다. 그런데 우리는 이미 주기적으로
+ * 재개점을 남기고 있다 — 그 지점부터 **뒤에 일어난 것만** 계산하면 같은 답이 나온다.
  *
  * 「같은 답」은 말로 보장되지 않는다: 재개점이 리듀서의 **내부 상태 전부**여야 하고(보기가 아니라),
- * 그 사실은 시험이 증명한다(0부터 접기 == 재개점 + 꼬리). 그래서 이 함수는 새 재개점도 함께 낸다 —
+ * 그 사실은 시험이 증명한다(0부터 계산하기 == 재개점 + 꼬리). 그래서 이 함수는 새 재개점도 함께 낸다 —
  * 소비처가 그것을 저장해 다음 꼬리를 또 이어 붙일 수 있게.
  *
  * 구조가 바뀐 구간은 여기서 다루지 않는다(`replaySegments` 의 몫이다) — 재개점은 **한 구조 안에서**
@@ -33,7 +33,7 @@ export declare function replayFrom(model: TwinModelDef, checkpoint: ReducerCheck
     state: ProjectedState;
     checkpoint: ReducerCheckpoint;
 };
-/** 이벤트열을 접고 **재개점도 함께** 낸다 — 다음 번에 이어 붙일 수 있게. */
+/** 이벤트열을 계산하고 **재개점도 함께** 낸다 — 다음 번에 이어 붙일 수 있게. */
 export declare function replayWithCheckpoint(model: TwinModelDef, events: readonly CanonicalEnvelope[]): {
     state: ProjectedState;
     checkpoint: ReducerCheckpoint;
@@ -65,10 +65,10 @@ export interface SegmentShift extends StructureShift {
  * **구조가 바뀐 이력까지 이어서 재생한다.**
  *
  * 공장은 바뀐다. 지금까지는 구조가 바뀌면 저널을 지우는 것이 유일한 길이었다 — 안 지우면 옛 이벤트를
- * 새 공장에 대고 접게 되어 이력이 거짓말을 하기 때문이다(도장 부스가 둘이던 시절의 사실을 여섯 개짜리
- * 공장에 접는다). 역사를 잃거나 거짓말을 하거나, 둘뿐이었다.
+ * 새 공장에 대고 계산하게 되어 이력이 거짓말을 하기 때문이다(도장 부스가 둘이던 시절의 사실을 여섯 개짜리
+ * 공장에 계산한다). 역사를 잃거나 거짓말을 하거나, 둘뿐이었다.
  *
- * 셋째 길이 이것이다: 마디마다 **그때의 구조**로 접고, 경계에서 구조만 전환한다(관측된 사실은 이어
+ * 셋째 길이 이것이다: 마디마다 **그때의 구조**로 계산하고, 경계에서 구조만 전환한다(관측된 사실은 이어
  * 간다). 그러면 이력이 "그때 그 공장의 사실" 로 계속 읽힌다.
  *
  * 경계에서 사라진 자원은 결과에 실어 보낸다 — 수가 줄어든 것을 사용자가 눈치채지 못하면 안 된다.

package/dist/event-journal.js

@@ -40,14 +40,14 @@ export function replay(model, events) {
     return proj.snapshot();
 }
 /**
- * **재개점에서 이어 접는다** — 0부터 다시 접지 않는다.
+ * **재개점에서 이어서 계산한다** — 0부터 다시 계산하지 않는다.
  *
  * ── 왜 (2026-08-18 실측) ────────────────────────────────────────────────────
- * 저널이 27만 건인 트윈에서 과거 상태를 물으면 전부 다시 접어야 했다. 그런데 우리는 이미 주기적으로
- * 재개점을 남기고 있다 — 그 지점부터 **뒤에 일어난 것만** 접으면 같은 답이 나온다.
+ * 저널이 27만 건인 트윈에서 과거 상태를 물으면 전부 다시 계산해야 했다. 그런데 우리는 이미 주기적으로
+ * 재개점을 남기고 있다 — 그 지점부터 **뒤에 일어난 것만** 계산하면 같은 답이 나온다.
  *
  * 「같은 답」은 말로 보장되지 않는다: 재개점이 리듀서의 **내부 상태 전부**여야 하고(보기가 아니라),
- * 그 사실은 시험이 증명한다(0부터 접기 == 재개점 + 꼬리). 그래서 이 함수는 새 재개점도 함께 낸다 —
+ * 그 사실은 시험이 증명한다(0부터 계산하기 == 재개점 + 꼬리). 그래서 이 함수는 새 재개점도 함께 낸다 —
  * 소비처가 그것을 저장해 다음 꼬리를 또 이어 붙일 수 있게.
  *
  * 구조가 바뀐 구간은 여기서 다루지 않는다(`replaySegments` 의 몫이다) — 재개점은 **한 구조 안에서**
@@ -60,7 +60,7 @@ export function replayFrom(model, checkpoint, events) {
         proj.apply(e);
     return { state: proj.snapshot(), checkpoint: proj.serialize() };
 }
-/** 이벤트열을 접고 **재개점도 함께** 낸다 — 다음 번에 이어 붙일 수 있게. */
+/** 이벤트열을 계산하고 **재개점도 함께** 낸다 — 다음 번에 이어 붙일 수 있게. */
 export function replayWithCheckpoint(model, events) {
     const proj = new StateProjector(model);
     for (const e of events)
@@ -71,10 +71,10 @@ export function replayWithCheckpoint(model, events) {
  * **구조가 바뀐 이력까지 이어서 재생한다.**
  *
  * 공장은 바뀐다. 지금까지는 구조가 바뀌면 저널을 지우는 것이 유일한 길이었다 — 안 지우면 옛 이벤트를
- * 새 공장에 대고 접게 되어 이력이 거짓말을 하기 때문이다(도장 부스가 둘이던 시절의 사실을 여섯 개짜리
- * 공장에 접는다). 역사를 잃거나 거짓말을 하거나, 둘뿐이었다.
+ * 새 공장에 대고 계산하게 되어 이력이 거짓말을 하기 때문이다(도장 부스가 둘이던 시절의 사실을 여섯 개짜리
+ * 공장에 계산한다). 역사를 잃거나 거짓말을 하거나, 둘뿐이었다.
  *
- * 셋째 길이 이것이다: 마디마다 **그때의 구조**로 접고, 경계에서 구조만 전환한다(관측된 사실은 이어
+ * 셋째 길이 이것이다: 마디마다 **그때의 구조**로 계산하고, 경계에서 구조만 전환한다(관측된 사실은 이어
  * 간다). 그러면 이력이 "그때 그 공장의 사실" 로 계속 읽힌다.
  *
  * 경계에서 사라진 자원은 결과에 실어 보낸다 — 수가 줄어든 것을 사용자가 눈치채지 못하면 안 된다.

package/dist/face2-adapter.d.ts

@@ -2,6 +2,34 @@ import type { CanonicalEnvelope } from './contract.ts';
 import type { EpcisEvent } from './epcis.ts';
 /** 매핑 값: 리터럴, 또는 소스 필드 참조("$.field.path"). */
 export type MapValue = string;
+/**
+ * **정정 선언 매핑** — 「이 사건은 없던 일이 되었다」를 표준 어휘로 옮기는 자리.
+ *
+ * ── 왜 뒤늦게 생겼나 (2026-08-25) ───────────────────────────────────────────
+ * `quantityList` · `ilmd` 와 **똑같은 모양의 결함**이었다. 받는 쪽은 처음부터 다 있었다 —
+ * 타입(`ErrorDeclaration`) · 검증(선언 시각·정정 대상 검사) · 리듀서(정정 목록에 적고 상태는
+ * 흔들지 않는다). 옮길 자리만 없었다.
+ *
+ * 실 시스템은 잘못 보낸 것을 정정한다. 그 정정을 실을 자리가 없으면 두 길뿐인데 둘 다 나쁘다:
+ * 취소를 **새 사실**로 보내 재고를 두 번 흔들거나, 아예 보내지 않아 지난 기록이 일어나지 않은 일을
+ * 일어난 것으로 계속 말하게 한다. 표준이 세 번째 길을 정해 두었다 — 앞선 사건을 지우지 않고
+ * 「정정되었다」를 함께 남긴다(EPCIS 2.0 §7.5).
+ *
+ * **세 값은 함께여야 뜻이 있다.** 그래서 평평한 세 필드가 아니라 묶음 하나로 둔다 — 반쯤 채운
+ * 정정 선언은 정정이 아니다.
+ *
+ * 이유(`reason`)는 CBV 어휘다(`did_not_occur` · `incorrect_data`). 연결된 시스템의 낱말
+ * (`UNDO_UNLOADING` 같은 것)을 그 둘 중 하나로 옮기는 것은 커넥터의 일이다 — 여기서 그 번역을
+ * 대신하면 시스템마다 다른 규칙이 이 파일에 쌓인다.
+ */
+export interface ErrorDeclarationMapping {
+    /** 정정을 **선언한** 시각. 사건이 일어난 시각이 아니다 — 없으면 지어내지 않고 이유와 함께 알린다. */
+    declarationTime: MapValue;
+    /** CBV 이유 어휘. 연결된 시스템이 이유를 말하지 않으면 비워 둔다(둘 중 하나로 짐작하지 않는다). */
+    reason?: MapValue;
+    /** 정정이 가리키는 원래 사건들의 `eventID`("$.correctiveEventIDs") — 문자열 배열. */
+    correctiveEventIDs?: MapValue;
+}
 /** ObjectEvent 매핑 스펙(선언적). */
 export interface ObjectEventMapping {
     type: 'ObjectEvent';
@@ -47,6 +75,8 @@ export interface ObjectEventMapping {
     ilmd?: MapValue;
     readPoint?: MapValue;
     bizLocation?: MapValue;
+    /** 이 레코드가 앞선 사건의 정정이면 그 선언(§ErrorDeclarationMapping). */
+    errorDeclaration?: ErrorDeclarationMapping;
 }
 /**
  * AggregationEvent 매핑 스펙 — **담김의 사실**(무엇이 무엇에 실렸나).
@@ -74,6 +104,8 @@ export interface AggregationEventMapping {
     childQuantityList?: MapValue;
     readPoint?: MapValue;
     bizLocation?: MapValue;
+    /** 이 레코드가 앞선 사건의 정정이면 그 선언(§ErrorDeclarationMapping). */
+    errorDeclaration?: ErrorDeclarationMapping;
 }
 /**
  * **변환의 사실** — 무엇이 들어가 무엇이 나왔나(EPCIS `TransformationEvent`).
@@ -104,6 +136,8 @@ export interface TransformationEventMapping {
     transformationID?: MapValue;
     readPoint?: MapValue;
     bizLocation?: MapValue;
+    /** 이 레코드가 앞선 사건의 정정이면 그 선언(§ErrorDeclarationMapping). */
+    errorDeclaration?: ErrorDeclarationMapping;
 }
 export type EventMapping = ObjectEventMapping | AggregationEventMapping | TransformationEventMapping;
 /**
@@ -143,7 +177,6 @@ export interface IngestResult {
     }[];
 }
 type Rec = Record<string, unknown>;
-/** 단일 레코드 → 정규 EPCIS 이벤트 + 매핑에서 드러난 문제(검증은 `ingest` 가 이어서 한다). */
 export declare function mapRecordChecked(record: Rec, mapping: EventMapping, eventTime: string): {
     event: EpcisEvent;
     errors: string[];

package/dist/face2-adapter.js

@@ -120,12 +120,49 @@ function resolveObject(v, record, field, errors) {
     return Object.keys(o).length ? o : undefined;
 }
 /** 단일 레코드 → 정규 EPCIS 이벤트 + 매핑에서 드러난 문제(검증은 `ingest` 가 이어서 한다). */
+/**
+ * 정정 선언 묶음 → 표준 `ErrorDeclaration`.
+ *
+ * 선언 시각이 없으면 **이유와 함께 알리고 붙이지 않는다.** 사건 시각으로 메우고 싶어지는 자리인데,
+ * 그러면 「언제 정정했나」가 「언제 일어났나」와 같아져 둘을 다시 갈라낼 방법이 없다.
+ */
+function resolveErrorDeclaration(spec, record, errors) {
+    if (!spec)
+        return undefined;
+    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 이 반쯤 왔다 — 이유·정정 대상은 있는데 declarationTime 이 없다(정정 시각은 지어낼 수 없다)');
+        }
+        return undefined;
+    }
+    return {
+        declarationTime,
+        ...(reason ? { reason } : {}),
+        ...(correctiveEventIDs.length ? { correctiveEventIDs } : {})
+    };
+}
 export 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);
+    /* 정정 선언은 표준 **헤더**의 것이므로 세 종류 모두에 담긴다(§7.5). 한 종류에만 내면 같은 결함이
+       나머지 둘에 남는다 — 그것을 이미 두 번 겪었다(`quantityList` · `ilmd`). */
+    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);
@@ -156,6 +193,7 @@ export function mapRecordChecked(record, mapping, eventTime) {
                 ...(outputEPCList.length ? { outputEPCList } : {}),
                 ...(outputQuantityList.length ? { outputQuantityList } : {}),
                 ...(transformationID ? { transformationID } : {}),
+                ...(errorDeclaration ? { errorDeclaration } : {}),
                 readPoint, bizLocation
             }),
             errors
@@ -172,6 +210,7 @@ export function mapRecordChecked(record, mapping, eventTime) {
                 /* 없는 쪽은 **필드를 만들지 않는다** — 빈 배열을 실으면 「자식이 없다」고 말하는 것이 된다. */
                 ...(childEPCs.length ? { childEPCs } : {}),
                 ...(childQuantityList.length ? { childQuantityList } : {}),
+                ...(errorDeclaration ? { errorDeclaration } : {}),
                 readPoint, bizLocation
             }),
             errors
@@ -192,6 +231,7 @@ export function mapRecordChecked(record, mapping, eventTime) {
             epcList: epc ? [epc] : [],
             ...(quantityList.length ? { quantityList } : {}),
             ...(ilmd ? { ilmd } : {}),
+            ...(errorDeclaration ? { errorDeclaration } : {}),
             readPoint, bizLocation
         }),
         errors

package/dist/flow-engine.d.ts

@@ -365,6 +365,15 @@ export declare function deriveAttentions(view: {
         goodCount?: number;
         scrapCount?: number;
         offShift?: boolean;
+        /**
+         * 이 설비 소식이 끊긴 시간, 그리고 그때까지 가장 오래 끊겼던 시간(밀리초).
+         * 실제 현장을 따라가는 트윈만 이 값을 넣는다.
+         *
+         * 값이 없으면 이 항목은 판단하지 않는다. 스스로 상태를 만들어 가는 트윈에는 소식이 끊긴다는
+         * 것이 없으므로 값을 넣지 않는다(`tasks` · `now` 도 같은 방식이다).
+         */
+        silentMs?: number;
+        longestSilenceBeforeMs?: number;
     }[];
     locations: {
         id: string;
@@ -541,7 +550,7 @@ export declare abstract class FlowEngine implements TwinKernel {
      * 양품률 시임(선택) — **이력에서 배운 수율.** 소요시간과 같은 자리·같은 규율이다 (2026-08-19).
      *
      * 없으면 선언값(현장→원천), 그것도 없으면 도메인 상수. 무엇을 썼는지는 `specCoverage()` 가 밝힌다.
-     * 주입은 호스트가 한다(저널을 접는 쪽이 이력을 안다) — 커널은 시임만 든다.
+     * 주입은 호스트가 한다(저널을 계산하는 쪽이 이력을 안다) — 커널은 시임만 든다.
      */
     yieldEstimator?: YieldEstimator;
     /**
@@ -563,7 +572,7 @@ export declare abstract class FlowEngine implements TwinKernel {
      * 읽는 쪽(`paramNumber`·`paramDuration`)이 명세 행보다 이것을 먼저 본다.
      */
     protected localParams: Map<string, Map<string, string>>;
-    /** 관측 구동(P0) — 이벤트를 접는 투영기와 그 사실. tick 과 섞이지 않게 명시적으로 들고 있다. */
+    /** 관측 구동(P0) — 이벤트를 계산하는 투영기와 그 사실. tick 과 섞이지 않게 명시적으로 들고 있다. */
     private observer?;
     /**
      * **관측 리듀서의 재개점을 꺼낸다** — 호스트가 저장해 다음 기동에서 되돌릴 수 있게.
@@ -736,7 +745,7 @@ export declare abstract class FlowEngine implements TwinKernel {
      * 미러의 진실은 원천이다. 그래서 재고·위치·설비 상태는 스냅샷에서 심지 않는다 — 다음 계측·다음
      * 마스터 재읽기가 곧 정정하므로, 심으면 **떠난 물건이 되살아나는** 위험만 남는다.
      *
-     * 그런데 원천이 **애초에 다시 말해 주지 않는 축**이 있다. 우리가 접어 만든 것들이다:
+     * 그런데 원천이 **애초에 다시 말해 주지 않는 축**이 있다. 우리가 계산해 만든 것들이다:
      *  · 확인(ack)·조건이 처음 성립한 시각 — 사람이 한 일과 우리가 기억한 시각
      *  · 열린 구간의 누적·적산 기준점·관측 이후 최대 — SCADA 는 「이번 15분에 지금까지 얼마」를 모른다
      *
@@ -791,7 +800,7 @@ export declare abstract class FlowEngine implements TwinKernel {
      * 미러는 그 작업을 굴리지 않는다 — **들은 것을 말할 뿐이다.** 그런데 규칙이 하나였으므로 관측된
      * 사실이 씨앗 규칙에 걸려 사라졌다.
      *
-     * 실측: 포천 미러의 저널에 `task.status` 5,786건이 있고 투영기로 접으면 작업 2,881건인데
+     * 실측: 포천 미러의 저널에 `task.status` 5,786건이 있고 투영기로 계산하면 작업 2,881건인데
      * `getSnapshot().tasks` 는 **0** 이었다. 화면은 「아직 하나도 없습니다」라고 말했고 사용자가
      * 반나절을 찾았다. 재현하면 관측기 5건 → 커널 0건이고, 걸린 조건은 오더였다.
      *
@@ -826,7 +835,7 @@ export declare abstract class FlowEngine implements TwinKernel {
      */
     private _acked;
     /**
-     * 완료 시점에 **주체가 사라져 접은 작업 수** — 조용한 누락이 되지 않게 센다.
+     * 완료 시점에 **주체가 사라져 제외한 작업 수** — 조용한 누락이 되지 않게 센다.
      *
      * 물품이 포장·출하·소비로 없어지는 것은 정상이지만, 그 물품을 향한 작업이 남아 있었다는 것은
      * 상류에 어긋남이 있다는 신호다. 0 이 아니면 그 사실을 소비처가 볼 수 있어야 한다.
@@ -946,7 +955,7 @@ export declare abstract class FlowEngine implements TwinKernel {
      * 어긋난다(2026-08-01 하루에 아홉 곳). 근본 해법은 **한 상태 모델 두 구동**이고, 이것은 그 실현
      * 가능성을 재는 스파이크다(design/plans/kernel-unification-live-observe.md P0).
      *
-     * 여기서는 **이미 검증된 조각을 조립**한다: 투영기가 이벤트를 접고, 그 결과를 씨앗 경로
+     * 여기서는 **이미 검증된 조각을 조립**한다: 투영기가 이벤트를 계산하고, 그 결과를 씨앗 경로
      * (`hydrateObserved`)로 커널 상태에 주입한다. 그래서 관측으로 실행한 커널을 그대로 `fork`·`tick` 할 수
      * 있다 — "미러에서 예측한다" 가 별도 배관 없이 성립하는지가 이 스파이크의 질문이다.
      *
@@ -1425,7 +1434,7 @@ export declare abstract class FlowEngine implements TwinKernel {
      *
      * 그때 도메인 훅은 없는 것을 딛으려다 오류를 낸다(`order.gtin` · `item.location`). 그 예외 하나가
      * **예측 전체를 죽였다** — 사용자에게는 기능이 통째로 사라진 것으로 보였다. 그래서 완료 **전에**
-     * 여기서 묻고, 없으면 그 작업만 접는다.
+     * 여기서 묻고, 없으면 그 작업만 제외한다.
      */
     protected missingContextOf(t: FlowTask): 'item' | 'order' | 'domain' | undefined;
     /**

package/dist/flow-engine.js

@@ -16,6 +16,8 @@ import { OP_PARAM } from "./domain-definition.js";
 import { parseIsoDuration } from "./iso-duration.js";
 import { analyzeCapacity } from "./capacity.js";
 import { operationsCapabilityOf } from "./operations-capability.js";
+/* 에너지 상태 필드는 **능력 선언에서 뽑는다** — 손으로 적으면 능력에 필드를 더한 날 스냅샷이 빠진다. */
+import { stateFieldsOf } from "./capability.js";
 const BASE_EPOCH = Date.parse('2026-01-01T00:00:00Z');
 /**
  * 선언한 유효 기간만 뽑는다 — 마스터가 말하지 않으면 필드를 만들지 않는다.
@@ -106,6 +108,43 @@ thresholds) {
                 suggestedAction: { code: 'act.repair', command: CMD.resourceRepair, args: { resourceId: m.id } }
             });
         }
+        /*
+         * 이 설비 소식이 지난 간격보다 오래 끊겼다는 신호. 설비가 멈췄다는 뜻이 아니고, 지금 상태를 우리가
+         * 모르고 있다는 뜻이다.
+         *
+         * ── 왜 필요한가 ───────────────────────────────────────────────────────────
+         * 연결된 시스템에서 값이 오다가 끊기는 일은 흔하다(통신 두절, 야간 정지, 커넥터 중단). 그때
+         * 트윈은 마지막으로 받은 값을 그대로 들고 있고, 화면은 그 값을 지금 상태로 그린다. 어제 오후에
+         * 받은 「가동 중」이 오늘 아침에도 「가동 중」으로 보인다. 오류가 나지 않으므로 아무도 확인하지
+         * 않는다. 값이 비어 있으면 사람이 의심하지만, 오래된 값이 채워져 있으면 의심하지 않는다.
+         *
+         * ── 왜 상태 필드가 아니라 신호인가 ────────────────────────────────────────
+         * 「가동 중」은 설비의 상태이고, 「그 값을 언제 받았나」는 우리 쪽 사정이다. 두 가지를 한 필드에
+         * 담으면 화면과 집계가 구별할 수 없다. 물품 쪽에서 같은 이유로 `seenAtMs` 를 상태에서 뺐다.
+         *
+         * ── 판단 기준을 우리가 정하지 않는다 ──────────────────────────────────────
+         * 「몇 분 넘게 값이 없으면 이상하다」는 현장마다 다르다. 1초마다 값을 보내는 계측기와 하루 한 번
+         * 올라오는 점검 기록이 같은 표에 있다. 기준을 하나로 정하면 앞쪽에는 신호가 너무 많이 서고
+         * 뒤쪽에는 서지 않는다. 그래서 그 설비가 지금까지 보여 준 가장 긴 간격을 기준으로 쓴다.
+         *
+         * 지난 간격을 아직 모르는 설비는 신호를 내지 않는다. 조치도 붙이지 않는다 — 고쳐야 할 것이
+         * 설비인지 연결인지 우리가 알 수 없다.
+         */
+        if (m.silentMs !== undefined && m.longestSilenceBeforeMs !== undefined && 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) {
         /*
@@ -321,14 +360,27 @@ export function computeOee(c, nowMs) {
  * 에너지 능력이 선언한 상태 필드를 스냅샷에 싣는다 — **온 것만.**
  *
  * 능력 계약이 이 필드들을 관측으로 선언해 두었는데 투영이 싣지 않으면, 값이 커널 안에서만 살고
- * 화면·성과·저널 어디에도 나타나지 않는다(실제로 그랬다: 값을 적었는데 스냅샷에 없었다).
+ * 화면·성과·지난 기록 어디에도 나타나지 않는다(실제로 그랬다: 값을 적었는데 스냅샷에 없었다).
  *
  * 값이 없으면 **키를 만들지 않는다** — 에너지에서 「모른다」와 「0 이다」는 요금이 갈리는 차이다.
+ *
+ * ── 목록을 손으로 적지 않는다 (2026-08-26) ─────────────────────────────────
+ * 여기가 필드 이름을 하드코딩하고 있었다. 그래서 능력에 필드를 하나 더하면 이 줄도 함께 고쳐야 했고,
+ * 잊으면 **바로 위 주석이 말하는 그 결함**이 다시 난다 — 실제로 그렇게 났다: 발전 적산
+ * (`generatedKWh`)을 능력에 선언하고 값을 적었는데 그때의 상태에 그 값이 없었다.
+ *
+ * 그래서 **선언에서 뽑는다.** 능력이 정본이고(`CAPABILITIES[*].stateFields`) 이 함수는 그것을 따른다.
+ * `measuredAt` 만 손으로 더한다 — 그것은 어느 능력의 값도 아니라 **언제 들었나**이고, 에너지 상태
+ * 필드 전체에 붙는 사실이다.
  */
+const 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] !== undefined)
             out[k] = src[k];
     }
@@ -599,7 +651,7 @@ export class FlowEngine {
      * 양품률 시임(선택) — **이력에서 배운 수율.** 소요시간과 같은 자리·같은 규율이다 (2026-08-19).
      *
      * 없으면 선언값(현장→원천), 그것도 없으면 도메인 상수. 무엇을 썼는지는 `specCoverage()` 가 밝힌다.
-     * 주입은 호스트가 한다(저널을 접는 쪽이 이력을 안다) — 커널은 시임만 든다.
+     * 주입은 호스트가 한다(저널을 계산하는 쪽이 이력을 안다) — 커널은 시임만 든다.
      */
     yieldEstimator;
     /**
@@ -621,7 +673,7 @@ export class FlowEngine {
      * 읽는 쪽(`paramNumber`·`paramDuration`)이 명세 행보다 이것을 먼저 본다.
      */
     localParams = new Map();
-    /** 관측 구동(P0) — 이벤트를 접는 투영기와 그 사실. tick 과 섞이지 않게 명시적으로 들고 있다. */
+    /** 관측 구동(P0) — 이벤트를 계산하는 투영기와 그 사실. tick 과 섞이지 않게 명시적으로 들고 있다. */
     observer;
     /**
      * **관측 리듀서의 재개점을 꺼낸다** — 호스트가 저장해 다음 기동에서 되돌릴 수 있게.
@@ -905,7 +957,7 @@ export class FlowEngine {
      * 미러의 진실은 원천이다. 그래서 재고·위치·설비 상태는 스냅샷에서 심지 않는다 — 다음 계측·다음
      * 마스터 재읽기가 곧 정정하므로, 심으면 **떠난 물건이 되살아나는** 위험만 남는다.
      *
-     * 그런데 원천이 **애초에 다시 말해 주지 않는 축**이 있다. 우리가 접어 만든 것들이다:
+     * 그런데 원천이 **애초에 다시 말해 주지 않는 축**이 있다. 우리가 계산해 만든 것들이다:
      *  · 확인(ack)·조건이 처음 성립한 시각 — 사람이 한 일과 우리가 기억한 시각
      *  · 열린 구간의 누적·적산 기준점·관측 이후 최대 — SCADA 는 「이번 15분에 지금까지 얼마」를 모른다
      *
@@ -953,7 +1005,7 @@ export class FlowEngine {
      * 미러는 그 작업을 굴리지 않는다 — **들은 것을 말할 뿐이다.** 그런데 규칙이 하나였으므로 관측된
      * 사실이 씨앗 규칙에 걸려 사라졌다.
      *
-     * 실측: 포천 미러의 저널에 `task.status` 5,786건이 있고 투영기로 접으면 작업 2,881건인데
+     * 실측: 포천 미러의 저널에 `task.status` 5,786건이 있고 투영기로 계산하면 작업 2,881건인데
      * `getSnapshot().tasks` 는 **0** 이었다. 화면은 「아직 하나도 없습니다」라고 말했고 사용자가
      * 반나절을 찾았다. 재현하면 관측기 5건 → 커널 0건이고, 걸린 조건은 오더였다.
      *
@@ -977,7 +1029,7 @@ export class FlowEngine {
         }
         this.items.clear();
         for (const it of snap.items) {
-            /* **부분마다 한 줄로 주입한다** — `epc` 로 키를 잡으면 같은 로트의 두 부분이 하나로 접혀
+            /* **부분마다 한 줄로 주입한다** — `epc` 로 키를 잡으면 같은 로트의 두 부분이 하나로 합쳐져
                씨앗에서 재고가 줄어든다(§MaterialSubLot 에서 겪은 것과 같은 오류의 세 번째 자리). */
             this.items.set(itemKeyOf(it), {
                 /* 품번 키·로트는 식별자에서 파생되므로 주입하지 않는다(스냅샷이 다시 낸다 — 두 벌을 두면 어긋난다). */
@@ -1040,6 +1092,20 @@ export class FlowEngine {
                 ...(m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}),
                 /* 결과도 이어받는다 — 잃으면 예측이 **자격 만료를 모르는 현장**에서 출발한다(낙관 쪽으로 치우친다). */
                 ...(m.testResults ? { testResults: m.testResults } : {}),
+                /*
+                 * ── 에너지 값도 이어받는다 (2026-08-26) ────────────────────────────────
+                 *
+                 * 이 자리가 에너지 필드를 심지 않았다. 그래서 재기동하면 설비의 발전량·충전율·계량값이 빈 채로
+                 * 시작하고, 다음 표본이 올 때까지 화면이 비어 보였다. 태양광 발전소에서 관측했다 — 저장된
+                 * 상태에는 `generatedKW` 가 있는데 되살린 트윈에는 없었다.
+                 *
+                 * 어느 필드를 이어받는지는 **능력 선언에서 뽑는다**(`ENERGY_STATE_FIELDS`). 스냅샷을 만드는
+                 * 쪽(`energyFieldsOf`)과 같은 목록이다 — 두 곳에 손으로 적으면 한쪽이 빠진 날 값이 조용히
+                 * 사라진다. 실제로 오늘 그렇게 났다.
+                 *
+                 * 값이 없으면 키를 만들지 않는다 — 에너지에서 「모른다」와 「0 이다」는 요금이 갈리는 차이다.
+                 */
+                ...energyFieldsOf(m),
                 ...effectiveOnly(m)
             });
         }
@@ -1370,7 +1436,7 @@ export class FlowEngine {
      */
     _acked = new Set();
     /**
-     * 완료 시점에 **주체가 사라져 접은 작업 수** — 조용한 누락이 되지 않게 센다.
+     * 완료 시점에 **주체가 사라져 제외한 작업 수** — 조용한 누락이 되지 않게 센다.
      *
      * 물품이 포장·출하·소비로 없어지는 것은 정상이지만, 그 물품을 향한 작업이 남아 있었다는 것은
      * 상류에 어긋남이 있다는 신호다. 0 이 아니면 그 사실을 소비처가 볼 수 있어야 한다.
@@ -1773,8 +1839,21 @@ export class FlowEngine {
                     criteriaOf.set(n.id, cs);
             }
         }
+        /*
+         * 소식이 끊긴 시간은 상태에 없고 받은 기록에만 있으므로 리듀서에게 묻는다. 스스로 상태를 만들어
+         * 가는 트윈에는 그 리듀서가 없고, 그때는 값을 넣지 않으므로 이 신호도 서지 않는다.
+         *
+         * 앞날을 계산하는 사본(`fork`)에서도 묻지 않는다. 사본은 `structuredClone` 으로 만들어서 리듀서가
+         * 메서드 없는 객체가 되고(§`ItemStore.clone`), 그대로 부르면 오류가 난다. 실제로 테스트 네 건이
+         * 그렇게 실패했다. 다만 결과는 맞다 — 앞날 계산은 자기 시계로 진행하므로 소식이 끊긴다는 것이
+         * 없다. 소식이 끊긴 사실은 현장을 따라가는 트윈이 알리고, 앞날 계산은 그 뒤의 일이다.
+         */
+        const silence = typeof this.observer?.equipmentSilence === 'function' ? this.observer.equipmentSilence() : undefined;
         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;
@@ -1985,7 +2064,7 @@ export class FlowEngine {
      * 어긋난다(2026-08-01 하루에 아홉 곳). 근본 해법은 **한 상태 모델 두 구동**이고, 이것은 그 실현
      * 가능성을 재는 스파이크다(design/plans/kernel-unification-live-observe.md P0).
      *
-     * 여기서는 **이미 검증된 조각을 조립**한다: 투영기가 이벤트를 접고, 그 결과를 씨앗 경로
+     * 여기서는 **이미 검증된 조각을 조립**한다: 투영기가 이벤트를 계산하고, 그 결과를 씨앗 경로
      * (`hydrateObserved`)로 커널 상태에 주입한다. 그래서 관측으로 실행한 커널을 그대로 `fork`·`tick` 할 수
      * 있다 — "미러에서 예측한다" 가 별도 배관 없이 성립하는지가 이 스파이크의 질문이다.
      *
@@ -3109,7 +3188,7 @@ export class FlowEngine {
      *
      * 그때 도메인 훅은 없는 것을 딛으려다 오류를 낸다(`order.gtin` · `item.location`). 그 예외 하나가
      * **예측 전체를 죽였다** — 사용자에게는 기능이 통째로 사라진 것으로 보였다. 그래서 완료 **전에**
-     * 여기서 묻고, 없으면 그 작업만 접는다.
+     * 여기서 묻고, 없으면 그 작업만 제외한다.
      */
     missingContextOf(t) {
         if (t.itemEpc && !this.itemByRef(t.itemEpc))
@@ -3781,7 +3860,7 @@ export class FlowEngine {
              * 들어갈 때 없어지고 나올 때 생긴다.
              */
             /*
-             * **주체가 사라진 작업은 완료시키지 않고 접는다.**
+             * **주체가 사라진 작업은 완료시키지 않고 계산한다.**
              *
              * 진행 중에 그 물품이 없어질 수 있다(포장으로 합쳐지고, 출하로 나가고, 다른 공정이 소비한다).
              * 그때 도메인 훅은 "없는 물품을 옮기려" 하다 오류를 냈고, **그 예외 하나가 예측 전체를 죽였다** —

package/dist/index.d.ts

@@ -29,10 +29,10 @@ export { WmsKernel } from './kernel.ts';
 export { YmsKernel } from './yms-kernel.ts';
 export { MesKernel } from './mes-kernel.ts';
 export { EmsKernel, DEMAND_WINDOW_MS, demandWindowStart } from './ems-kernel.ts';
-export { ingestEnergyRecords, isEnergyRecord, ingestEnergyEquipmentRecords, isEnergyEquipmentRecord } from './energy-ingest.ts';
+export { ingestEnergyRecords, isEnergyRecord, ingestEnergyEquipmentRecords, isEnergyEquipmentRecord, ingestEnergyGenerationRecords, isEnergyGenerationRecord } from './energy-ingest.ts';
 export { ingestOperationalRecords, isOperationalRecord, operationalKindOf } from './operational-ingest.ts';
 export type { OperationalKind, OperationalRecord, OperationalIngestOptions } from './operational-ingest.ts';
 export { attributeEnergy, electricityCost, energyIntensity, energyOfWindows } from './energy-attribution.ts';
 export type { AttributionBasis, AttributionResult, ElectricityCost, EnergyConsumer, EnergyPool, EnergyShare, IntensityInput, IntensityResult, IntensityDenominator, TariffDeclaration, WeightKind, WindowedEnergy } from './energy-attribution.ts';
-export type { EnergyRecord, EnergyEquipmentRecord, EnergyIngestOptions, EnergyIngestResult } from './energy-ingest.ts';
+export type { EnergyRecord, EnergyEquipmentRecord, EnergyGenerationRecord, EnergyIngestOptions, EnergyIngestResult } from './energy-ingest.ts';
 export * from './vocabulary.ts';