@operato/twin-kernel 0.7.21 → 0.7.23

package/dist/contract.d.ts

@@ -1329,6 +1329,14 @@ export interface RecommendedAction {
     code: string;
     command?: string;
     args?: unknown;
+    /**
+     * 표현용 원시 파라미터 — 권고가 **무엇을 가리키는지** 말해야 할 때(예: 「어느 부하를 줄이나」).
+     *
+     * 실행 가능한 조치는 `args` 가 대상을 나른다(커맨드가 그것을 먹는다). 권고(command 없음)에는 그 자리가
+     * 없어서, 예전에는 「부하를 줄이세요」까지만 말할 수 있었다 — 감축 가능 설비가 여럿이면 사람이 어느
+     * 것인지 알 길이 없다. `Attention.params` 와 같은 규약이다(언어중립 원시값만, 문장은 표현계층이 만든다).
+     */
+    params?: Record<string, string | number>;
 }
 export interface StateSnapshot {
     revision: number;

package/dist/ems-kernel.d.ts

@@ -1,6 +1,6 @@
 import { FlowEngine } from './flow-engine.ts';
 import { type AllocationPolicy } from './allocation-policy.ts';
-import { type CanonicalEnvelope, type DemandWindowState, type StateSnapshot } from './contract.ts';
+import { type CanonicalEnvelope, type DemandWindowState, type StateSnapshot, type Attention, type StructureShift, type TwinModelDef } from './contract.ts';
 /** 수요 구간 — 요금의 알갱이다. 15분은 한국·다수 요금제의 최대수요 산정 단위다. */
 export declare const DEMAND_WINDOW_MS: number;
 /** 그 시각이 속한 구간의 시작 — 벽시계 경계(00·15·30·45분)에 맞춘다. */
@@ -63,6 +63,19 @@ export declare class EmsKernel extends FlowEngine {
      * 「계약 안쪽」이라는 더 위험한 거짓을 만든다).
      */
     private rootMeterIds;
+    /**
+     * 구조가 바뀌면 **열린 구간의 계약도 다시 읽는다.**
+     *
+     * ── 무엇이 났나 (2026-08-18) ────────────────────────────────────────────────
+     * 계약전력은 구간이 **열릴 때** 찍힌다(그 구간의 판정 기준이 도중에 바뀌지 않게 하려는 규율이다). 그런데
+     * 현장이 계약을 고쳐 선언하면(`declareTwinProperties` → 미러는 동작 중 구조 전환) 열린 구간은 **옛 한계로
+     * 계속 판정한다** — 실측으로 잡았다: 선언 800 kW, 열린 구간 3,500 kW. 미러는 계측이 멈추지 않으므로 최대
+     * 15분 동안 틀린 기준으로 초과를 판정하고, 그 사이의 경보는 있어야 할 것이 없거나 없어야 할 것이 있다.
+     *
+     * 구조 전환은 「현장이 달라졌다」는 선언이므로, 그 순간 기준을 다시 읽는 것이 맞다. 이미 지나간 구간의
+     * 판정은 건드리지 않는다(마감된 사실을 뒤늦게 고쳐 쓰지 않는다).
+     */
+    adoptStructure(def: TwinModelDef): StructureShift;
     /**
      * 계측 표본을 받는다 — 에너지 사건만 가로채고 나머지는 그대로 상위에 넘긴다.
      *
@@ -119,6 +132,25 @@ export declare class EmsKernel extends FlowEngine {
      * 우리는 끄지 않는다.
      */
     private judgeOpenWindow;
+    /**
+     * 주목 신호 — **계약을 넘길 것 같으면 사람이 보는 자리에 올린다.**
+     *
+     * ── 무엇이 났나 (2026-08-18) ────────────────────────────────────────────────
+     * 커널은 이미 초과 투영을 사실로 냈다(`energy.dr.suggested` — 실측으로 확인: 투영 705kW·계약 600kW·
+     * 부족 105kW). 그런데 그 사실이 **주의로 올라오지 않았다**: 저널에는 있고 화면에는 없었다. 요금은 15분
+     * 구간이 닫히면 확정되므로, 닫히기 전에 사람이 보지 못하면 그 경보는 아무 일도 하지 못한다.
+     *
+     * ── 왜 저널 사실과 따로 두나 ────────────────────────────────────────────────
+     * 저널의 `dr.suggested` 는 **한 번 일어난 일**이고(그 구간에 한 번만 낸다), 주의는 **지금 성립하는
+     * 조건**이다. 조건이 사라지면 주의는 스스로 사라져야 한다(상위 층이 그 수명을 관리한다 — 처음 성립한
+     * 시각을 기억하고, 조건이 없어지면 지운다). 둘을 합치면 「지나간 경보」와 「지금 위험」이 섞인다.
+     *
+     * 계약을 모르면 판정하지 않는다. 심각도는 **초과 폭**으로 가른다 — 5% 안쪽은 계량 오차와 구별하기
+     * 어려우므로 높게 부르지 않는다(경보가 소음이 되면 사람이 경보 자체를 읽지 않는다).
+     */
+    protected collectAttentions(): Attention[];
+    /** 계약을 선언한 수전 자리 — 주의가 가리킬 대상. 없으면 대상을 지어내지 않는다. */
+    private incomingLocationId;
     /** 감축 가능으로 **선언된** 설비 — 커널이 능력을 짐작하지 않는다(타입이 선언한다). */
     private curtailableIds;
     private flowRequests;
@@ -140,6 +172,16 @@ export declare class EmsKernel extends FlowEngine {
      * ④ 미러 트윈에서는 아무것도 만들지 않는다 — 관측 구동은 잰 것만 쓴다.
      */
     private deriveLoad;
+    /**
+     * 선언된 발전을 만든다 — **형상은 현장이 적는다.**
+     *
+     * 정격(`generation.ratedKW`)과 하루 형상(`generation.dailyProfile`)을 **둘 다** 선언한 설비만 발전한다:
+     * 하루 종일 정격으로 발전하는 태양광은 없으므로, 정격만 있는 선언으로 발전을 만들면 그 값은 거짓이다.
+     *
+     * 값은 **만든 것**이라고 사실에 밝힌다(`derived: true`) — 저널을 읽는 쪽이 계측과 구별할 수 있어야 한다.
+     * 시각은 현장 시간대로 읽는다(모델이 시간대를 말해 준다 — 교대 판정과 같은 기준).
+     */
+    private deriveGeneration;
     /** 이 설비가 방전 정책을 **선언했나** — 선언한 것의 방전은 정책이 매 틱 다시 정한다. */
     private hasDispatchPolicy;
     /**
@@ -163,6 +205,8 @@ export declare class EmsKernel extends FlowEngine {
     private emitEnergyEquipment;
     /** 자원 속성에서 수 하나 — 값이 수가 아니면 없는 것으로 본다(짐작하지 않는다). */
     private numberProperty;
+    /** 글자로 선언된 값(발전 형상·통화 같은 것) — 비어 있으면 없는 것으로 본다. */
+    private stringProperty;
     tick(dtMs: number): void;
     getSnapshot(): StateSnapshot;
 }

package/dist/ems-kernel.js

@@ -27,8 +27,8 @@
  */
 import { FlowEngine } from "./flow-engine.js";
 import { firstFitPolicy } from "./allocation-policy.js";
-import { ENERGY_EVENT } from "./contract.js";
-import { EMS_PROPERTY, electricalUpstreamOf } from "./ems-profile.js";
+import { CMD, ENERGY_EVENT, minuteOfDayAt } from "./contract.js";
+import { EMS_PROPERTY, electricalUpstreamOf, generationFractionAt } from "./ems-profile.js";
 /** 수요 구간 — 요금의 알갱이다. 15분은 한국·다수 요금제의 최대수요 산정 단위다. */
 export const DEMAND_WINDOW_MS = 15 * 60 * 1000;
 /** 그 시각이 속한 구간의 시작 — 벽시계 경계(00·15·30·45분)에 맞춘다. */
@@ -170,6 +170,31 @@ export class EmsKernel extends FlowEngine {
         }
         return out;
     }
+    /**
+     * 구조가 바뀌면 **열린 구간의 계약도 다시 읽는다.**
+     *
+     * ── 무엇이 났나 (2026-08-18) ────────────────────────────────────────────────
+     * 계약전력은 구간이 **열릴 때** 찍힌다(그 구간의 판정 기준이 도중에 바뀌지 않게 하려는 규율이다). 그런데
+     * 현장이 계약을 고쳐 선언하면(`declareTwinProperties` → 미러는 동작 중 구조 전환) 열린 구간은 **옛 한계로
+     * 계속 판정한다** — 실측으로 잡았다: 선언 800 kW, 열린 구간 3,500 kW. 미러는 계측이 멈추지 않으므로 최대
+     * 15분 동안 틀린 기준으로 초과를 판정하고, 그 사이의 경보는 있어야 할 것이 없거나 없어야 할 것이 있다.
+     *
+     * 구조 전환은 「현장이 달라졌다」는 선언이므로, 그 순간 기준을 다시 읽는 것이 맞다. 이미 지나간 구간의
+     * 판정은 건드리지 않는다(마감된 사실을 뒤늦게 고쳐 쓰지 않는다).
+     */
+    adoptStructure(def) {
+        const shift = super.adoptStructure(def);
+        if (this.open) {
+            const contractKW = this.declaredContractKW();
+            if (contractKW === undefined)
+                delete this.open.contractKW;
+            else
+                this.open.contractKW = contractKW;
+            /* 새 기준으로 다시 판정할 수 있게 이 구간의 「이미 제안했다」 표식을 지운다. */
+            this.suggestedFor = undefined;
+        }
+        return shift;
+    }
     /**
      * 계측 표본을 받는다 — 에너지 사건만 가로채고 나머지는 그대로 상위에 넘긴다.
      *
@@ -463,6 +488,75 @@ export class EmsKernel extends FlowEngine {
             curtailableCandidates: this.curtailableIds()
         });
     }
+    /**
+     * 주목 신호 — **계약을 넘길 것 같으면 사람이 보는 자리에 올린다.**
+     *
+     * ── 무엇이 났나 (2026-08-18) ────────────────────────────────────────────────
+     * 커널은 이미 초과 투영을 사실로 냈다(`energy.dr.suggested` — 실측으로 확인: 투영 705kW·계약 600kW·
+     * 부족 105kW). 그런데 그 사실이 **주의로 올라오지 않았다**: 저널에는 있고 화면에는 없었다. 요금은 15분
+     * 구간이 닫히면 확정되므로, 닫히기 전에 사람이 보지 못하면 그 경보는 아무 일도 하지 못한다.
+     *
+     * ── 왜 저널 사실과 따로 두나 ────────────────────────────────────────────────
+     * 저널의 `dr.suggested` 는 **한 번 일어난 일**이고(그 구간에 한 번만 낸다), 주의는 **지금 성립하는
+     * 조건**이다. 조건이 사라지면 주의는 스스로 사라져야 한다(상위 층이 그 수명을 관리한다 — 처음 성립한
+     * 시각을 기억하고, 조건이 없어지면 지운다). 둘을 합치면 「지나간 경보」와 「지금 위험」이 섞인다.
+     *
+     * 계약을 모르면 판정하지 않는다. 심각도는 **초과 폭**으로 가른다 — 5% 안쪽은 계량 오차와 구별하기
+     * 어려우므로 높게 부르지 않는다(경보가 소음이 되면 사람이 경보 자체를 읽지 않는다).
+     */
+    collectAttentions() {
+        const out = super.collectAttentions();
+        const w = this.open;
+        if (!w || w.contractKW === undefined || w.meanKW === undefined)
+            return out;
+        /* 투영은 커널이 이미 쓰는 규칙과 같다(`mean-so-far`) — 두 벌이 되면 화면과 저널이 다른 말을 한다. */
+        const projected = w.meanKW;
+        if (projected <= w.contractKW)
+            return out;
+        const over = projected - w.contractKW;
+        const ratio = over / w.contractKW;
+        const candidates = this.curtailableIds();
+        out.push({
+            /* 구간마다 새 신호다 — 15분이 지나면 다른 요금 단위이고, 확인(ack)도 그 구간에만 걸려야 한다. */
+            id: `contract-projected-over:${w.startMs}`,
+            kind: 'contract-projected-over',
+            severity: ratio > 0.15 ? 'critical' : ratio > 0.05 ? 'high' : 'medium',
+            anchor: { locationId: this.incomingLocationId() },
+            /* 언어중립 원시값만 — 문장은 표현계층이 kind 로 골라 렌더한다(커널은 사람 말을 만들지 않는다). */
+            params: {
+                projectedKW: Math.round(projected),
+                contractKW: w.contractKW,
+                gapKW: Math.round(over),
+                windowEndMs: w.endMs,
+                curtailableCount: candidates.length
+            },
+            /*
+             * 조치는 **선언된 감축 가능 설비**에만 건다 — 커널이 무엇을 끌 수 있는지 짐작하지 않는다.
+             *
+             * ── 구동 방식이 조치의 성질을 바꾼다 ─────────────────────────────────────
+             * 시뮬레이션에서 감축은 **실행할 수 있는 조치**다: 설비를 세우면 그 설비의 부하가 실제로 빠지고
+             * 투영이 내려간다(what-if 의 값이 여기서 나온다). 미러에서는 그렇지 않다 — 진실은 계량기가 정하고
+             * 이 커널은 **제어하지 않는다**(설계 §1). 트윈 안에서 설비를 세워도 현장 전기는 그대로 흐르므로,
+             * 실행 버튼을 주면 화면이 「눌렀으니 내려갈 것」이라고 거짓말한다. 그래서 미러에서는 **권고**로만
+             * 낸다(command 없이 code 만 — 표현계층이 advice 로 렌더한다).
+             */
+            recommendedActions: candidates.map(id => this.observing
+                ? { code: 'advice.curtail-load', params: { resourceId: id } }
+                : { code: 'act.curtail-load', command: CMD.resourceHold, args: { resourceId: id } }),
+            ...(candidates.length && !this.observing
+                ? { suggestedAction: { code: 'act.curtail-load', command: CMD.resourceHold, args: { resourceId: candidates[0] } } }
+                : {})
+        });
+        return out;
+    }
+    /** 계약을 선언한 수전 자리 — 주의가 가리킬 대상. 없으면 대상을 지어내지 않는다. */
+    incomingLocationId() {
+        for (const loc of this.boardDef?.locations ?? []) {
+            if ((loc.properties ?? []).some(p => p.id === EMS_PROPERTY.contractKW))
+                return loc.id;
+        }
+        return undefined;
+    }
     /** 감축 가능으로 **선언된** 설비 — 커널이 능력을 짐작하지 않는다(타입이 선언한다). */
     curtailableIds() {
         return (this.boardDef?.equipment ?? [])
@@ -555,6 +649,14 @@ export class EmsKernel extends FlowEngine {
          * 음수는 **역송**이지 음의 수요가 아니다. 계통 수요는 0 에서 멈추고, 남는 발전은 그 설비의
          * `exportKW` 가 이미 사실로 말한다(여기서 다시 만들지 않는다).
          */
+        /*
+         * ── 선언된 발전을 먼저 만든다 (2026-08-18) ─────────────────────────────────
+         * 정격과 하루 형상을 선언한 설비는 이 시각의 비율만큼 발전한다. 형상을 우리가 지어내지 않으므로
+         * (위도·날씨로 곡선을 만들면 그 수의 출처를 설명할 수 없다) 선언이 없으면 발전하지 않는다.
+         *
+         * 미러에서는 여기까지 오지 않는다(위에서 관측이 진실이라 돌아간다) — 계측이 발전량을 말해 준다.
+         */
+        this.deriveGeneration(atMs);
         let generated = 0;
         let discharged = 0;
         let charged = 0;
@@ -604,6 +706,43 @@ export class EmsKernel extends FlowEngine {
         this.revision++;
         this.judgeOpenWindow(atMs);
     }
+    /**
+     * 선언된 발전을 만든다 — **형상은 현장이 적는다.**
+     *
+     * 정격(`generation.ratedKW`)과 하루 형상(`generation.dailyProfile`)을 **둘 다** 선언한 설비만 발전한다:
+     * 하루 종일 정격으로 발전하는 태양광은 없으므로, 정격만 있는 선언으로 발전을 만들면 그 값은 거짓이다.
+     *
+     * 값은 **만든 것**이라고 사실에 밝힌다(`derived: true`) — 저널을 읽는 쪽이 계측과 구별할 수 있어야 한다.
+     * 시각은 현장 시간대로 읽는다(모델이 시간대를 말해 준다 — 교대 판정과 같은 기준).
+     */
+    deriveGeneration(atMs) {
+        for (const e of this.boardDef?.equipment ?? []) {
+            const rated = this.numberProperty(e, EMS_PROPERTY.genRatedKW);
+            if (rated === undefined || !(rated > 0))
+                continue;
+            const profile = this.stringProperty(e, EMS_PROPERTY.genDailyProfile);
+            const hour = Math.floor(minuteOfDayAt(atMs, this.boardDef?.utcOffsetMinutes) / 60);
+            const fraction = generationFractionAt(profile, hour);
+            const state = this.equipment.get(e.id);
+            if (!state)
+                continue;
+            if (fraction === undefined) {
+                /* 형상이 없거나 형태가 아니면 발전하지 않는다 — 낡은 값을 남기지 않는다(지난 시각을 말하게 된다). */
+                if (Number(state.generatedKW) > 0) {
+                    ;
+                    state.generatedKW = 0;
+                    this.emitEnergyEquipment(e.id, atMs, { generatedKW: 0 });
+                }
+                continue;
+            }
+            const kW = rated * fraction;
+            const before = Number(state.generatedKW);
+            state.generatedKW = kW;
+            /* 값이 실제로 바뀔 때만 사실을 낸다 — 매 틱 같은 값을 되풀면 저널이 소음으로 찬다. */
+            if (!(Number.isFinite(before) && Math.abs(before - kW) < 1e-9))
+                this.emitEnergyEquipment(e.id, atMs, { generatedKW: kW });
+        }
+    }
     /** 이 설비가 방전 정책을 **선언했나** — 선언한 것의 방전은 정책이 매 틱 다시 정한다. */
     hasDispatchPolicy(equipmentId) {
         for (const e of this.boardDef?.equipment ?? []) {
@@ -709,6 +848,17 @@ export class EmsKernel extends FlowEngine {
         }
         return undefined;
     }
+    /** 글자로 선언된 값(발전 형상·통화 같은 것) — 비어 있으면 없는 것으로 본다. */
+    stringProperty(resource, id) {
+        for (const p of resource?.properties ?? []) {
+            if (p?.id !== id)
+                continue;
+            const v = String(p.value ?? '').trim();
+            if (v)
+                return v;
+        }
+        return undefined;
+    }
     tick(dtMs) {
         super.tick(dtMs);
         /*

package/dist/ems-profile.d.ts

@@ -40,6 +40,14 @@ export declare const EMS_PROPERTY: {
      * 이것은 상태의 씨앗이지 계측이 아니다. 그래서 계측이 들어오는 순간 그것이 이긴다.
      */
     readonly initialSoc: "storage.initialSoc";
+    /** 발전 정격(kW) — 맑은 정오의 최대 출력. */
+    readonly genRatedKW: "generation.ratedKW";
+    /**
+     * 하루 형상 — 쉼표로 나눈 **24개 비율**(0~1). 시각(현장 시간대)의 정격 대비 출력이다.
+     *
+     * 예: `0,0,0,0,0,0,0.05,0.2,0.45,0.7,0.9,1,1,0.95,0.8,0.6,0.35,0.12,0.02,0,0,0,0,0`
+     */
+    readonly genDailyProfile: "generation.dailyProfile";
 };
 /**
  * 이 선언들의 **단위와 범위** — 값을 읽는 쪽이 아니라 **주는 쪽**을 위한 표다.
@@ -66,6 +74,13 @@ export interface EmsPropertySpec {
     note: string;
 }
 export declare const EMS_PROPERTY_SPEC: Record<string, EmsPropertySpec>;
+/**
+ * 하루 형상에서 **이 시각의 비율**을 읽는다 — 없거나 형태가 아니면 `undefined`(발전하지 않는다).
+ *
+ * 24개가 아니면 받지 않는다: 값이 몇 개인지 짐작해 늘리거나 자르면, 사람이 적은 곡선과 우리가 쓰는 곡선이
+ * 달라진다. 0~1 밖의 값도 받지 않는다(정격의 배수로 발전하는 태양광은 없다).
+ */
+export declare function generationFractionAt(profile: string | undefined | null, hourOfDay: number): number | undefined;
 export declare const EMS_TYPES: TwinTypeInfo[];
 /**
  * 이 자리의 **전기 상류** — 어디서 전기를 받는가.

package/dist/ems-profile.js

@@ -71,7 +71,28 @@ export const EMS_PROPERTY = {
      *
      * 이것은 상태의 씨앗이지 계측이 아니다. 그래서 계측이 들어오는 순간 그것이 이긴다.
      */
-    initialSoc: 'storage.initialSoc'
+    initialSoc: 'storage.initialSoc',
+    /*
+     * ── 발전 — 태양광이 서 있기만 하던 자리 (2026-08-18) ────────────────────────
+     *
+     * 계통도에 태양광을 그려 놓고 시뮬에서는 한 톨도 만들지 못했다. 미러는 원천이 발전량을 보내 주지만,
+     * 시뮬 트윈에는 그것을 만들 근거가 없었다 — 그래서 「태양광을 늘리면 피크가 얼마나 내려가나」를 물을 수
+     * 없었다(what-if 의 값이 절반만 성립했다).
+     *
+     * **형상을 우리가 지어내지 않는다.** 위도·계절·날씨로 곡선을 만들면 그 수가 어디서 왔는지 아무도
+     * 설명할 수 없고, 흐린 날 현장의 실적과 어긋난다. 그래서 현장이 **하루 형상을 적는다**: 24개 비율
+     * (0~1)이면 그것이 그 현장의 곡선이다(측정한 형상을 그대로 붙일 수 있다).
+     *
+     * 정격만 있고 형상이 없으면 발전하지 않는다 — 하루 종일 정격으로 발전하는 태양광은 없다.
+     */
+    /** 발전 정격(kW) — 맑은 정오의 최대 출력. */
+    genRatedKW: 'generation.ratedKW',
+    /**
+     * 하루 형상 — 쉼표로 나눈 **24개 비율**(0~1). 시각(현장 시간대)의 정격 대비 출력이다.
+     *
+     * 예: `0,0,0,0,0,0,0.05,0.2,0.45,0.7,0.9,1,1,0.95,0.8,0.6,0.35,0.12,0.02,0,0,0,0,0`
+     */
+    genDailyProfile: 'generation.dailyProfile'
 };
 export const EMS_PROPERTY_SPEC = {
     [EMS_PROPERTY.contractKW]: { uom: 'kW', dataType: 'xs:double', note: 'contracted power at the metering point, in kW.' },
@@ -85,8 +106,34 @@ export const EMS_PROPERTY_SPEC = {
     [EMS_PROPERTY.maxDischargeKW]: { uom: 'kW', dataType: 'xs:double', note: 'inverter limit on discharge rate, in kW.' },
     /* 퍼센트다 — 0.8 은 0.8% 이고 80% 가 아니다. 이 한 줄이 없어서 배터리가 조용히 비어 있었다. */
     [EMS_PROPERTY.reserveSoc]: { uom: '%', dataType: 'xs:double', range: [0, 100], note: 'reserve state of charge as a percentage 0-100 (20 means 20%), never discharged below.' },
-    [EMS_PROPERTY.initialSoc]: { uom: '%', dataType: 'xs:double', range: [0, 100], note: 'starting state of charge as a percentage 0-100 (80 means 80%, not 0.8).' }
+    [EMS_PROPERTY.initialSoc]: { uom: '%', dataType: 'xs:double', range: [0, 100], note: 'starting state of charge as a percentage 0-100 (80 means 80%, not 0.8).' },
+    [EMS_PROPERTY.genRatedKW]: { uom: 'kW', dataType: 'xs:double', note: 'rated generation output at clear-sky noon, in kW.' },
+    [EMS_PROPERTY.genDailyProfile]: {
+        dataType: 'xs:string',
+        note: 'daily shape as 24 comma-separated fractions of rated output (0-1), one per hour of local time — the site declares its own curve; we do not invent one.'
+    }
 };
+/**
+ * 하루 형상에서 **이 시각의 비율**을 읽는다 — 없거나 형태가 아니면 `undefined`(발전하지 않는다).
+ *
+ * 24개가 아니면 받지 않는다: 값이 몇 개인지 짐작해 늘리거나 자르면, 사람이 적은 곡선과 우리가 쓰는 곡선이
+ * 달라진다. 0~1 밖의 값도 받지 않는다(정격의 배수로 발전하는 태양광은 없다).
+ */
+export function generationFractionAt(profile, hourOfDay) {
+    const parts = String(profile ?? '')
+        .split(',')
+        .map(v => v.trim())
+        .filter(v => v !== '');
+    if (parts.length !== 24)
+        return undefined;
+    const h = Math.floor(hourOfDay);
+    if (!Number.isFinite(h) || h < 0 || h > 23)
+        return undefined;
+    const v = Number(parts[h]);
+    if (!Number.isFinite(v) || v < 0 || v > 1)
+        return undefined;
+    return v;
+}
 export const EMS_TYPES = [
     /* ── 자리: 전기적 구간 ─────────────────────────────────────────────────── */
     {

package/dist/flow-engine.d.ts

@@ -462,6 +462,7 @@ export declare abstract class FlowEngine implements TwinKernel {
     tick(dtMs: number): void;
     getSnapshot(): StateSnapshot;
     protected computeAttentions(): Attention[];
+    protected collectAttentions(): Attention[];
     /**
      * fork — 현재 상태를 정확히 복제한 새 엔진 (디지털트윈 본연: "현재로부터 예측").
      * 원본(live/sim)은 계속 진행, fork 는 what-if 를 앞으로 시뮬레이션해 forecast·발산(predicted vs actual) 검사에 쓴다.

package/dist/flow-engine.js

@@ -1026,20 +1026,16 @@ export class FlowEngine {
         };
     }
     /*
-     * 주목 신호 판단 — 상태(자리·설비·오더)에서 도메인 조건을 평가해 Attention 방출.
-     * severity=ISA-18.2 우선순위 계열, kind=도메인 라벨. UI 는 판단 안 함(임계값 여기 소유).
-     * 도메인별 추가 판단은 서브클래스가 override 로 확장(super.computeAttentions() 합성).
+     * 주목 신호 — **수명 관리는 여기 한 곳**이다(확장하지 말 것, 확장점은 `collectAttentions`).
+     *
+     * 확인(ack)·처음 성립한 시각·사라진 조건 프루닝은 신호를 **누가 냈든** 같아야 한다. 예전에는 판단과
+     * 수명이 이 메서드 하나에 섞여 있어서, 서브클래스가 `super.computeAttentions()` 뒤에 신호를 덧붙이면
+     * 그 신호만 **timeStamp 도 ack 도 못 받았다**(화면은 「몇 분째」를 쓸 수 없고, 확인 버튼이 듣지 않는다).
+     * 그래서 판단(`collectAttentions`)과 수명(여기)을 갈랐다.
      */
     computeAttentions() {
-        // 계산 층은 순수 함수 deriveAttentions 로 위임 — sim(여기)과 live projector 미러가 공유(face2-inbound-live §1.1).
+        const out = this.collectAttentions();
         const now = this.now();
-        const out = deriveAttentions({
-            equipment: [...this.equipment.values()],
-            locations: [...this.locations.values()],
-            orders: [...this.orders.values()],
-            tasks: [...this.tasks.values()]
-        }, this._acked, now // 지연 판정의 "지금" — 관측 중이면 마지막으로 들은 시각이다(§nowMs)
-        );
         const present = new Set(out.map(a => a.id));
         /*
          * **조건이 처음 성립한 시각**을 기억해 붙인다(표준 `WorkAlert.TimeStamp`).
@@ -1052,6 +1048,9 @@ export class FlowEngine {
             const first = this._attentionSince.get(a.id) ?? now;
             this._attentionSince.set(a.id, first);
             a.timeStamp = first;
+            /* 확인 상태도 신호를 낸 주체와 무관하게 적용한다 — 순수 함수가 낸 것만 확인되면 반쪽이다. */
+            if (this._acked.has(a.id))
+                a.state = 'acknowledged';
         }
         // 확인(ack)·시작 시각 프루닝 — 사라진 조건은 함께 지운다(재발하면 그때가 새 시작이다).
         for (const id of [...this._acked])
@@ -1062,6 +1061,24 @@ export class FlowEngine {
                 this._attentionSince.delete(id);
         return out;
     }
+    /*
+     * 주목 신호 판단 — 상태(자리·설비·오더)에서 도메인 조건을 평가해 Attention 방출.
+     * severity=ISA-18.2 우선순위 계열, kind=도메인 라벨. UI 는 판단 안 함(임계값 여기 소유).
+     * **도메인별 추가 판단은 이것을 override 로 확장한다**(`super.collectAttentions()` 합성) — 수명은
+     * 상위 `computeAttentions` 가 붙여 준다.
+     */
+    collectAttentions() {
+        // 계산 층은 순수 함수 deriveAttentions 로 위임 — sim(여기)과 live projector 미러가 공유(face2-inbound-live §1.1).
+        const now = this.now();
+        const out = deriveAttentions({
+            equipment: [...this.equipment.values()],
+            locations: [...this.locations.values()],
+            orders: [...this.orders.values()],
+            tasks: [...this.tasks.values()]
+        }, this._acked, now // 지연 판정의 "지금" — 관측 중이면 마지막으로 들은 시각이다(§nowMs)
+        );
+        return out;
+    }
     /**
      * fork — 현재 상태를 정확히 복제한 새 엔진 (디지털트윈 본연: "현재로부터 예측").
      * 원본(live/sim)은 계속 진행, fork 는 what-if 를 앞으로 시뮬레이션해 forecast·발산(predicted vs actual) 검사에 쓴다.

package/dist-cjs/index.cjs

@@ -106,6 +106,7 @@ __export(index_exports, {
   foldJobResponses: () => foldJobResponses,
   foldTaskRecords: () => foldTaskRecords,
   gdtiUri: () => gdtiUri,
+  generationFractionAt: () => generationFractionAt,
   graiUri: () => graiUri,
   hierarchyOf: () => hierarchyOf,
   inWorkCalendar: () => inWorkCalendar,
@@ -1757,7 +1758,28 @@ var EMS_PROPERTY = {
    *
    * 이것은 상태의 씨앗이지 계측이 아니다. 그래서 계측이 들어오는 순간 그것이 이긴다.
    */
-  initialSoc: "storage.initialSoc"
+  initialSoc: "storage.initialSoc",
+  /*
+   * ── 발전 — 태양광이 서 있기만 하던 자리 (2026-08-18) ────────────────────────
+   *
+   * 계통도에 태양광을 그려 놓고 시뮬에서는 한 톨도 만들지 못했다. 미러는 원천이 발전량을 보내 주지만,
+   * 시뮬 트윈에는 그것을 만들 근거가 없었다 — 그래서 「태양광을 늘리면 피크가 얼마나 내려가나」를 물을 수
+   * 없었다(what-if 의 값이 절반만 성립했다).
+   *
+   * **형상을 우리가 지어내지 않는다.** 위도·계절·날씨로 곡선을 만들면 그 수가 어디서 왔는지 아무도
+   * 설명할 수 없고, 흐린 날 현장의 실적과 어긋난다. 그래서 현장이 **하루 형상을 적는다**: 24개 비율
+   * (0~1)이면 그것이 그 현장의 곡선이다(측정한 형상을 그대로 붙일 수 있다).
+   *
+   * 정격만 있고 형상이 없으면 발전하지 않는다 — 하루 종일 정격으로 발전하는 태양광은 없다.
+   */
+  /** 발전 정격(kW) — 맑은 정오의 최대 출력. */
+  genRatedKW: "generation.ratedKW",
+  /**
+   * 하루 형상 — 쉼표로 나눈 **24개 비율**(0~1). 시각(현장 시간대)의 정격 대비 출력이다.
+   *
+   * 예: `0,0,0,0,0,0,0.05,0.2,0.45,0.7,0.9,1,1,0.95,0.8,0.6,0.35,0.12,0.02,0,0,0,0,0`
+   */
+  genDailyProfile: "generation.dailyProfile"
 };
 var EMS_PROPERTY_SPEC = {
   [EMS_PROPERTY.contractKW]: { uom: "kW", dataType: "xs:double", note: "contracted power at the metering point, in kW." },
@@ -1771,8 +1793,22 @@ var EMS_PROPERTY_SPEC = {
   [EMS_PROPERTY.maxDischargeKW]: { uom: "kW", dataType: "xs:double", note: "inverter limit on discharge rate, in kW." },
   /* 퍼센트다 — 0.8 은 0.8% 이고 80% 가 아니다. 이 한 줄이 없어서 배터리가 조용히 비어 있었다. */
   [EMS_PROPERTY.reserveSoc]: { uom: "%", dataType: "xs:double", range: [0, 100], note: "reserve state of charge as a percentage 0-100 (20 means 20%), never discharged below." },
-  [EMS_PROPERTY.initialSoc]: { uom: "%", dataType: "xs:double", range: [0, 100], note: "starting state of charge as a percentage 0-100 (80 means 80%, not 0.8)." }
+  [EMS_PROPERTY.initialSoc]: { uom: "%", dataType: "xs:double", range: [0, 100], note: "starting state of charge as a percentage 0-100 (80 means 80%, not 0.8)." },
+  [EMS_PROPERTY.genRatedKW]: { uom: "kW", dataType: "xs:double", note: "rated generation output at clear-sky noon, in kW." },
+  [EMS_PROPERTY.genDailyProfile]: {
+    dataType: "xs:string",
+    note: "daily shape as 24 comma-separated fractions of rated output (0-1), one per hour of local time \u2014 the site declares its own curve; we do not invent one."
+  }
 };
+function generationFractionAt(profile, hourOfDay) {
+  const parts = String(profile ?? "").split(",").map((v2) => v2.trim()).filter((v2) => v2 !== "");
+  if (parts.length !== 24) return void 0;
+  const h = Math.floor(hourOfDay);
+  if (!Number.isFinite(h) || h < 0 || h > 23) return void 0;
+  const v = Number(parts[h]);
+  if (!Number.isFinite(v) || v < 0 || v > 1) return void 0;
+  return v;
+}
 var EMS_TYPES = [
   /* ── 자리: 전기적 구간 ─────────────────────────────────────────────────── */
   {
@@ -3725,12 +3761,35 @@ var FlowEngine = class {
       acked: [...this._acked]
     };
   }
+  /*
+   * 주목 신호 — **수명 관리는 여기 한 곳**이다(확장하지 말 것, 확장점은 `collectAttentions`).
+   *
+   * 확인(ack)·처음 성립한 시각·사라진 조건 프루닝은 신호를 **누가 냈든** 같아야 한다. 예전에는 판단과
+   * 수명이 이 메서드 하나에 섞여 있어서, 서브클래스가 `super.computeAttentions()` 뒤에 신호를 덧붙이면
+   * 그 신호만 **timeStamp 도 ack 도 못 받았다**(화면은 「몇 분째」를 쓸 수 없고, 확인 버튼이 듣지 않는다).
+   * 그래서 판단(`collectAttentions`)과 수명(여기)을 갈랐다.
+   */
+  computeAttentions() {
+    const out = this.collectAttentions();
+    const now = this.now();
+    const present = new Set(out.map((a) => a.id));
+    for (const a of out) {
+      const first = this._attentionSince.get(a.id) ?? now;
+      this._attentionSince.set(a.id, first);
+      a.timeStamp = first;
+      if (this._acked.has(a.id)) a.state = "acknowledged";
+    }
+    for (const id of [...this._acked]) if (!present.has(id)) this._acked.delete(id);
+    for (const id of [...this._attentionSince.keys()]) if (!present.has(id)) this._attentionSince.delete(id);
+    return out;
+  }
   /*
    * 주목 신호 판단 — 상태(자리·설비·오더)에서 도메인 조건을 평가해 Attention 방출.
    * severity=ISA-18.2 우선순위 계열, kind=도메인 라벨. UI 는 판단 안 함(임계값 여기 소유).
-   * 도메인별 추가 판단은 서브클래스가 override 로 확장(super.computeAttentions() 합성).
+   * **도메인별 추가 판단은 이것을 override 로 확장한다**(`super.collectAttentions()` 합성) — 수명은
+   * 상위 `computeAttentions` 가 붙여 준다.
    */
-  computeAttentions() {
+  collectAttentions() {
     const now = this.now();
     const out = deriveAttentions(
       {
@@ -3743,14 +3802,6 @@ var FlowEngine = class {
       now
       // 지연 판정의 "지금" — 관측 중이면 마지막으로 들은 시각이다(§nowMs)
     );
-    const present = new Set(out.map((a) => a.id));
-    for (const a of out) {
-      const first = this._attentionSince.get(a.id) ?? now;
-      this._attentionSince.set(a.id, first);
-      a.timeStamp = first;
-    }
-    for (const id of [...this._acked]) if (!present.has(id)) this._acked.delete(id);
-    for (const id of [...this._attentionSince.keys()]) if (!present.has(id)) this._attentionSince.delete(id);
     return out;
   }
   /**
@@ -6093,6 +6144,28 @@ var EmsKernel = class extends FlowEngine {
     }
     return out;
   }
+  /**
+   * 구조가 바뀌면 **열린 구간의 계약도 다시 읽는다.**
+   *
+   * ── 무엇이 났나 (2026-08-18) ────────────────────────────────────────────────
+   * 계약전력은 구간이 **열릴 때** 찍힌다(그 구간의 판정 기준이 도중에 바뀌지 않게 하려는 규율이다). 그런데
+   * 현장이 계약을 고쳐 선언하면(`declareTwinProperties` → 미러는 동작 중 구조 전환) 열린 구간은 **옛 한계로
+   * 계속 판정한다** — 실측으로 잡았다: 선언 800 kW, 열린 구간 3,500 kW. 미러는 계측이 멈추지 않으므로 최대
+   * 15분 동안 틀린 기준으로 초과를 판정하고, 그 사이의 경보는 있어야 할 것이 없거나 없어야 할 것이 있다.
+   *
+   * 구조 전환은 「현장이 달라졌다」는 선언이므로, 그 순간 기준을 다시 읽는 것이 맞다. 이미 지나간 구간의
+   * 판정은 건드리지 않는다(마감된 사실을 뒤늦게 고쳐 쓰지 않는다).
+   */
+  adoptStructure(def) {
+    const shift = super.adoptStructure(def);
+    if (this.open) {
+      const contractKW = this.declaredContractKW();
+      if (contractKW === void 0) delete this.open.contractKW;
+      else this.open.contractKW = contractKW;
+      this.suggestedFor = void 0;
+    }
+    return shift;
+  }
   /**
    * 계측 표본을 받는다 — 에너지 사건만 가로채고 나머지는 그대로 상위에 넘긴다.
    *
@@ -6319,6 +6392,69 @@ var EmsKernel = class extends FlowEngine {
       curtailableCandidates: this.curtailableIds()
     });
   }
+  /**
+   * 주목 신호 — **계약을 넘길 것 같으면 사람이 보는 자리에 올린다.**
+   *
+   * ── 무엇이 났나 (2026-08-18) ────────────────────────────────────────────────
+   * 커널은 이미 초과 투영을 사실로 냈다(`energy.dr.suggested` — 실측으로 확인: 투영 705kW·계약 600kW·
+   * 부족 105kW). 그런데 그 사실이 **주의로 올라오지 않았다**: 저널에는 있고 화면에는 없었다. 요금은 15분
+   * 구간이 닫히면 확정되므로, 닫히기 전에 사람이 보지 못하면 그 경보는 아무 일도 하지 못한다.
+   *
+   * ── 왜 저널 사실과 따로 두나 ────────────────────────────────────────────────
+   * 저널의 `dr.suggested` 는 **한 번 일어난 일**이고(그 구간에 한 번만 낸다), 주의는 **지금 성립하는
+   * 조건**이다. 조건이 사라지면 주의는 스스로 사라져야 한다(상위 층이 그 수명을 관리한다 — 처음 성립한
+   * 시각을 기억하고, 조건이 없어지면 지운다). 둘을 합치면 「지나간 경보」와 「지금 위험」이 섞인다.
+   *
+   * 계약을 모르면 판정하지 않는다. 심각도는 **초과 폭**으로 가른다 — 5% 안쪽은 계량 오차와 구별하기
+   * 어려우므로 높게 부르지 않는다(경보가 소음이 되면 사람이 경보 자체를 읽지 않는다).
+   */
+  collectAttentions() {
+    const out = super.collectAttentions();
+    const w = this.open;
+    if (!w || w.contractKW === void 0 || w.meanKW === void 0) return out;
+    const projected = w.meanKW;
+    if (projected <= w.contractKW) return out;
+    const over = projected - w.contractKW;
+    const ratio = over / w.contractKW;
+    const candidates = this.curtailableIds();
+    out.push({
+      /* 구간마다 새 신호다 — 15분이 지나면 다른 요금 단위이고, 확인(ack)도 그 구간에만 걸려야 한다. */
+      id: `contract-projected-over:${w.startMs}`,
+      kind: "contract-projected-over",
+      severity: ratio > 0.15 ? "critical" : ratio > 0.05 ? "high" : "medium",
+      anchor: { locationId: this.incomingLocationId() },
+      /* 언어중립 원시값만 — 문장은 표현계층이 kind 로 골라 렌더한다(커널은 사람 말을 만들지 않는다). */
+      params: {
+        projectedKW: Math.round(projected),
+        contractKW: w.contractKW,
+        gapKW: Math.round(over),
+        windowEndMs: w.endMs,
+        curtailableCount: candidates.length
+      },
+      /*
+       * 조치는 **선언된 감축 가능 설비**에만 건다 — 커널이 무엇을 끌 수 있는지 짐작하지 않는다.
+       *
+       * ── 구동 방식이 조치의 성질을 바꾼다 ─────────────────────────────────────
+       * 시뮬레이션에서 감축은 **실행할 수 있는 조치**다: 설비를 세우면 그 설비의 부하가 실제로 빠지고
+       * 투영이 내려간다(what-if 의 값이 여기서 나온다). 미러에서는 그렇지 않다 — 진실은 계량기가 정하고
+       * 이 커널은 **제어하지 않는다**(설계 §1). 트윈 안에서 설비를 세워도 현장 전기는 그대로 흐르므로,
+       * 실행 버튼을 주면 화면이 「눌렀으니 내려갈 것」이라고 거짓말한다. 그래서 미러에서는 **권고**로만
+       * 낸다(command 없이 code 만 — 표현계층이 advice 로 렌더한다).
+       */
+      recommendedActions: candidates.map(
+        (id) => this.observing ? { code: "advice.curtail-load", params: { resourceId: id } } : { code: "act.curtail-load", command: CMD.resourceHold, args: { resourceId: id } }
+      ),
+      ...candidates.length && !this.observing ? { suggestedAction: { code: "act.curtail-load", command: CMD.resourceHold, args: { resourceId: candidates[0] } } } : {}
+    });
+    return out;
+  }
+  /** 계약을 선언한 수전 자리 — 주의가 가리킬 대상. 없으면 대상을 지어내지 않는다. */
+  incomingLocationId() {
+    for (const loc of this.boardDef?.locations ?? []) {
+      if ((loc.properties ?? []).some((p) => p.id === EMS_PROPERTY.contractKW)) return loc.id;
+    }
+    return void 0;
+  }
   /** 감축 가능으로 **선언된** 설비 — 커널이 능력을 짐작하지 않는다(타입이 선언한다). */
   curtailableIds() {
     return (this.boardDef?.equipment ?? []).filter((e) => String(e.kind ?? "") === "curtailable-load").map((e) => e.id);
@@ -6383,6 +6519,7 @@ var EmsKernel = class extends FlowEngine {
       }
     }
     if (!counted) return;
+    this.deriveGeneration(atMs);
     let generated = 0;
     let discharged = 0;
     let charged = 0;
@@ -6409,6 +6546,38 @@ var EmsKernel = class extends FlowEngine {
     this.revision++;
     this.judgeOpenWindow(atMs);
   }
+  /**
+   * 선언된 발전을 만든다 — **형상은 현장이 적는다.**
+   *
+   * 정격(`generation.ratedKW`)과 하루 형상(`generation.dailyProfile`)을 **둘 다** 선언한 설비만 발전한다:
+   * 하루 종일 정격으로 발전하는 태양광은 없으므로, 정격만 있는 선언으로 발전을 만들면 그 값은 거짓이다.
+   *
+   * 값은 **만든 것**이라고 사실에 밝힌다(`derived: true`) — 저널을 읽는 쪽이 계측과 구별할 수 있어야 한다.
+   * 시각은 현장 시간대로 읽는다(모델이 시간대를 말해 준다 — 교대 판정과 같은 기준).
+   */
+  deriveGeneration(atMs) {
+    for (const e of this.boardDef?.equipment ?? []) {
+      const rated = this.numberProperty(e, EMS_PROPERTY.genRatedKW);
+      if (rated === void 0 || !(rated > 0)) continue;
+      const profile = this.stringProperty(e, EMS_PROPERTY.genDailyProfile);
+      const hour = Math.floor(minuteOfDayAt(atMs, this.boardDef?.utcOffsetMinutes) / 60);
+      const fraction = generationFractionAt(profile, hour);
+      const state = this.equipment.get(e.id);
+      if (!state) continue;
+      if (fraction === void 0) {
+        if (Number(state.generatedKW) > 0) {
+          ;
+          state.generatedKW = 0;
+          this.emitEnergyEquipment(e.id, atMs, { generatedKW: 0 });
+        }
+        continue;
+      }
+      const kW = rated * fraction;
+      const before = Number(state.generatedKW);
+      state.generatedKW = kW;
+      if (!(Number.isFinite(before) && Math.abs(before - kW) < 1e-9)) this.emitEnergyEquipment(e.id, atMs, { generatedKW: kW });
+    }
+  }
   /** 이 설비가 방전 정책을 **선언했나** — 선언한 것의 방전은 정책이 매 틱 다시 정한다. */
   hasDispatchPolicy(equipmentId) {
     for (const e of this.boardDef?.equipment ?? []) {
@@ -6492,6 +6661,15 @@ var EmsKernel = class extends FlowEngine {
     }
     return void 0;
   }
+  /** 글자로 선언된 값(발전 형상·통화 같은 것) — 비어 있으면 없는 것으로 본다. */
+  stringProperty(resource, id) {
+    for (const p of resource?.properties ?? []) {
+      if (p?.id !== id) continue;
+      const v = String(p.value ?? "").trim();
+      if (v) return v;
+    }
+    return void 0;
+  }
   tick(dtMs) {
     super.tick(dtMs);
     const at = this.nowMs();
@@ -6974,6 +7152,7 @@ function retiredVocabularyIn(line) {
   foldJobResponses,
   foldTaskRecords,
   gdtiUri,
+  generationFractionAt,
   graiUri,
   hierarchyOf,
   inWorkCalendar,

package/package.json

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