@operato/twin-kernel 0.7.22 → 0.7.24

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;
@@ -1368,6 +1376,19 @@ export interface StateSnapshot {
      * 왕복시켜야 재기동·재계산에서 확인 상태가 유지된다.
      */
     acked?: string[];
+    /**
+     * 주목 신호가 **처음 성립한 시각**(id → ISO) — 확인과 마찬가지로 **계산으로 되살릴 수 없다.**
+     *
+     * 신호는 매 스냅샷 다시 계산되지만 「언제부터인가」는 그 계산 안에 없다. 왕복시키지 않으면 재기동·
+     * 웜스타트 뒤 **세 시간째 지속된 조건이 「0초째」로 되살아난다** — 방금 찬 자리와 세 시간째 막힌
+     * 자리는 할 일이 다르므로, 그 값이 거짓이면 화면은 사람을 잘못된 순서로 움직인다.
+     *
+     * 사라진 조건은 함께 지운다(재발은 새 시작이다) — 그 규율은 `computeAttentions` 가 지킨다.
+     */
+    attentionSince?: {
+        id: string;
+        since: ISOTime;
+    }[];
     /**
      * 에너지 — **에너지 트윈만 채운다**(계량 지점·수요 구간·피크). 다른 종류에서는 없다.
      *

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 EnergyState, 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;
@@ -176,5 +208,27 @@ export declare class EmsKernel extends FlowEngine {
     /** 글자로 선언된 값(발전 형상·통화 같은 것) — 비어 있으면 없는 것으로 본다. */
     private stringProperty;
     tick(dtMs: number): void;
+    /**
+     * 에너지의 연속성 — **SCADA 는 「이번 15분에 지금까지 얼마」를 모른다.**
+     *
+     * 계량기는 순간값과 적산값을 준다. 「이 구간의 최대」·「구간이 열릴 때의 적산」·「관측 이후 최대」는
+     * 우리가 접어 만든 값이라, 재기동하면 원천이 되풀어 주지 않는다. 잃으면 오류 없이 값이 작아진다 —
+     * 구간 전력량이 기준점을 새로 잡아 짧아지고, 그 구간의 피크가 부팅 이후로만 잡힌다(요금이 걸린 수다).
+     *
+     * 지난 마감 구간도 이어받는다: 이미 저널에 있는 사실이지만, 화면이 그것을 보려고 매번 저널을 접지
+     * 않게 한다(자른 사실은 `closedTotal` 이 그대로 나른다).
+     *
+     * 지금 열린 구간이 **이미 지나간 것**이어도 그대로 받는다 — 다음 표본이 오면 커널이 그 구간을 정상
+     * 경로로 마감한다(그 사실은 자기 시각을 달고 있어 늦게 나가도 참이다). 여기서 버리면 그 15분은
+     * 통째로 사라진다.
+     */
+    hydrateContinuity(snap: {
+        acked?: string[];
+        attentionSince?: {
+            id: string;
+            since: string;
+        }[];
+        energy?: EnergyState;
+    }): void;
     getSnapshot(): StateSnapshot;
 }

package/dist/ems-kernel.js

@@ -27,7 +27,7 @@
  */
 import { FlowEngine } from "./flow-engine.js";
 import { firstFitPolicy } from "./allocation-policy.js";
-import { ENERGY_EVENT, minuteOfDayAt } from "./contract.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;
@@ -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 ?? [])
@@ -781,6 +875,38 @@ export class EmsKernel extends FlowEngine {
         this.deriveLoad(at, dtMs);
         this.closeDue(at);
     }
+    /**
+     * 에너지의 연속성 — **SCADA 는 「이번 15분에 지금까지 얼마」를 모른다.**
+     *
+     * 계량기는 순간값과 적산값을 준다. 「이 구간의 최대」·「구간이 열릴 때의 적산」·「관측 이후 최대」는
+     * 우리가 접어 만든 값이라, 재기동하면 원천이 되풀어 주지 않는다. 잃으면 오류 없이 값이 작아진다 —
+     * 구간 전력량이 기준점을 새로 잡아 짧아지고, 그 구간의 피크가 부팅 이후로만 잡힌다(요금이 걸린 수다).
+     *
+     * 지난 마감 구간도 이어받는다: 이미 저널에 있는 사실이지만, 화면이 그것을 보려고 매번 저널을 접지
+     * 않게 한다(자른 사실은 `closedTotal` 이 그대로 나른다).
+     *
+     * 지금 열린 구간이 **이미 지나간 것**이어도 그대로 받는다 — 다음 표본이 오면 커널이 그 구간을 정상
+     * 경로로 마감한다(그 사실은 자기 시각을 달고 있어 늦게 나가도 참이다). 여기서 버리면 그 15분은
+     * 통째로 사라진다.
+     */
+    hydrateContinuity(snap) {
+        super.hydrateContinuity(snap);
+        const e = snap?.energy;
+        if (!e)
+            return;
+        for (const p of e.points ?? [])
+            if (p?.id)
+                this.points.set(p.id, { ...p });
+        if (e.open)
+            this.open = { ...e.open };
+        if (e.closed?.length)
+            this.closed = e.closed.map(w => ({ ...w })).slice(-KEEP_CLOSED);
+        /* 자른 수는 이어받은 목록으로 다시 세지 않는다 — 그러면 잘려 나간 과거가 조용히 0 이 된다. */
+        if (Number.isFinite(e.closedTotal))
+            this.closedTotal = Number(e.closedTotal);
+        if (e.peakSince && Number.isFinite(e.peakSince.kW))
+            this.peak = { kW: e.peakSince.kW, windowStartMs: e.peakSince.windowStartMs };
+    }
     getSnapshot() {
         const snap = super.getSnapshot();
         const contractKW = this.declaredContractKW();

package/dist/flow-engine.d.ts

@@ -407,6 +407,29 @@ export declare abstract class FlowEngine implements TwinKernel {
      * 것이고, 그것을 허용하면 이 함수가 막으려던 일이 이 함수를 통해 일어난다.
      */
     resumeRevision(from: number): void;
+    /**
+     * **원천이 되풀어 주지 않는 것만 잇는다** — 미러(관측 구동) 재기동의 연속성.
+     *
+     * ── 왜 따로 두나 (2026-08-18) ──────────────────────────────────────────────
+     * 미러의 진실은 원천이다. 그래서 재고·위치·설비 상태는 스냅샷에서 심지 않는다 — 다음 계측·다음
+     * 마스터 재읽기가 곧 정정하므로, 심으면 **떠난 물건이 되살아나는** 위험만 남는다.
+     *
+     * 그런데 원천이 **애초에 다시 말해 주지 않는 축**이 있다. 우리가 접어 만든 것들이다:
+     *  · 확인(ack)·조건이 처음 성립한 시각 — 사람이 한 일과 우리가 기억한 시각
+     *  · 열린 구간의 누적·적산 기준점·관측 이후 최대 — SCADA 는 「이번 15분에 지금까지 얼마」를 모른다
+     *
+     * 이것을 잃으면 오류 없이 값이 작아진다(실측: 재기동 뒤 그 구간의 전력량·피크가 작게 나오고, 세
+     * 시간째 지속된 경보가 「0초째」가 된다). 그래서 축을 갈라, 되풀어 주지 않는 것만 이어받는다.
+     *
+     * 도메인 축(에너지 등)은 서브클래스가 override 로 덧붙인다(`super.hydrateContinuity(snap)` 합성).
+     */
+    hydrateContinuity(snap: {
+        acked?: string[];
+        attentionSince?: {
+            id: string;
+            since: string;
+        }[];
+    }): void;
     hydrateObserved(snap: {
         locations: LocationState[];
         items: ItemState[];
@@ -415,8 +438,13 @@ export declare abstract class FlowEngine implements TwinKernel {
         assets?: AssetState[];
         tasks?: TaskState[];
         orders?: OrderState[];
-        /** 확인해 둔 주목 신호 id — 계산으로 되살릴 수 없는 유일한 축이라 스냅샷에서 이어받는다. */
+        /** 확인해 둔 주목 신호 id — 계산으로 되살릴 수 없어 스냅샷에서 이어받는다. */
         acked?: string[];
+        /** 주목 신호가 처음 성립한 시각 — 이어받지 않으면 지속된 조건이 「방금」으로 되살아난다. */
+        attentionSince?: {
+            id: string;
+            since: string;
+        }[];
     }, orders?: OrderStatusDelta[]): void;
     /**
      * what-if 구성 변주 — **선언을 덮어쓴다**(fork 대상). 바꿨으면 true.
@@ -462,6 +490,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

@@ -465,11 +465,39 @@ export class FlowEngine {
             throw new Error(`리비전을 뒤로 되돌릴 수 없다: ${this.revision} → ${from} (겹치는 번호가 생긴다)`);
         this.revision = from;
     }
+    /**
+     * **원천이 되풀어 주지 않는 것만 잇는다** — 미러(관측 구동) 재기동의 연속성.
+     *
+     * ── 왜 따로 두나 (2026-08-18) ──────────────────────────────────────────────
+     * 미러의 진실은 원천이다. 그래서 재고·위치·설비 상태는 스냅샷에서 심지 않는다 — 다음 계측·다음
+     * 마스터 재읽기가 곧 정정하므로, 심으면 **떠난 물건이 되살아나는** 위험만 남는다.
+     *
+     * 그런데 원천이 **애초에 다시 말해 주지 않는 축**이 있다. 우리가 접어 만든 것들이다:
+     *  · 확인(ack)·조건이 처음 성립한 시각 — 사람이 한 일과 우리가 기억한 시각
+     *  · 열린 구간의 누적·적산 기준점·관측 이후 최대 — SCADA 는 「이번 15분에 지금까지 얼마」를 모른다
+     *
+     * 이것을 잃으면 오류 없이 값이 작아진다(실측: 재기동 뒤 그 구간의 전력량·피크가 작게 나오고, 세
+     * 시간째 지속된 경보가 「0초째」가 된다). 그래서 축을 갈라, 되풀어 주지 않는 것만 이어받는다.
+     *
+     * 도메인 축(에너지 등)은 서브클래스가 override 로 덧붙인다(`super.hydrateContinuity(snap)` 합성).
+     */
+    hydrateContinuity(snap) {
+        for (const id of snap?.acked ?? [])
+            this._acked.add(id);
+        for (const e of snap?.attentionSince ?? [])
+            if (e?.id && e.since)
+                this._attentionSince.set(e.id, e.since);
+    }
     hydrateObserved(snap, orders = []) {
         /* 확인 처리를 먼저 이어받는다 — 아래에서 상태를 주입하면 곧바로 주목 신호가 계산되므로, 늦게
          * 이어받으면 그 한 번은 확인 안 된 것으로 계산된다(화면이 잠깐 빨개진다). */
         for (const id of snap.acked ?? [])
             this._acked.add(id);
+        /* 「언제부터인가」도 함께 이어받는다 — 상태를 심으면 곧바로 신호가 계산되므로, 늦게 받으면 그 한 번은
+           모두 방금 생긴 것으로 찍히고 그 값이 그대로 굳는다(다음 계산은 이미 기억된 시각을 쓴다). */
+        for (const e of snap.attentionSince ?? [])
+            if (e?.id && e.since)
+                this._attentionSince.set(e.id, e.since);
         /* **관측된 것을 버리지 않는다.** 예전에는 자리·설비 상태를 'idle' 로, OEE 누적을 0 으로 덮고
          * 물품의 로트·단위·소속·마스터데이터를 떨어뜨렸다. 씨앗이 잃은 것은 **예측도 모른다** —
          * 고장 난 설비를 정상으로, 진행 중인 일을 없는 것으로 놓고 미래를 실행하면 답이 낙관 쪽으로 치우친다. */
@@ -748,7 +776,7 @@ export class FlowEngine {
      */
     abandonedTasks = 0;
     /** 주목 신호가 **처음 성립한 시각**(id → ISO). 조건이 사라지면 지운다 — 재발은 새 시작이다. */
-    _attentionSince = new Map(); // 확인(ack)된 주목 신호 id — 조건 지속돼도 acknowledged 로 표시(재발 시 재활성)
+    _attentionSince = new Map();
     dispatch(cmd) {
         /*
          * 이 커맨드가 낳는 이벤트에 상관값을 단다. 명시값이 없으면 **commandId 를 쓴다** — 호출자가
@@ -1022,24 +1050,22 @@ export class FlowEngine {
             })),
             attentions: this.computeAttentions(),
             /* 확인해 둔 신호 — 스냅샷으로 왕복해야 재기동 후에도 확인 상태가 유지된다. */
-            acked: [...this._acked]
+            acked: [...this._acked],
+            /* 언제부터인가 — 이것도 계산으로 되살릴 수 없다. 위 계산이 사라진 조건을 이미 지웠으므로 지금 남은 것이 곧 진실이다. */
+            attentionSince: [...this._attentionSince].map(([id, since]) => ({ id, since }))
         };
     }
     /*
-     * 주목 신호 판단 — 상태(자리·설비·오더)에서 도메인 조건을 평가해 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 +1078,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 +1091,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

@@ -3254,8 +3254,29 @@ var FlowEngine = class {
     if (from < this.revision) throw new Error(`\uB9AC\uBE44\uC804\uC744 \uB4A4\uB85C \uB418\uB3CC\uB9B4 \uC218 \uC5C6\uB2E4: ${this.revision} \u2192 ${from} (\uACB9\uCE58\uB294 \uBC88\uD638\uAC00 \uC0DD\uAE34\uB2E4)`);
     this.revision = from;
   }
+  /**
+   * **원천이 되풀어 주지 않는 것만 잇는다** — 미러(관측 구동) 재기동의 연속성.
+   *
+   * ── 왜 따로 두나 (2026-08-18) ──────────────────────────────────────────────
+   * 미러의 진실은 원천이다. 그래서 재고·위치·설비 상태는 스냅샷에서 심지 않는다 — 다음 계측·다음
+   * 마스터 재읽기가 곧 정정하므로, 심으면 **떠난 물건이 되살아나는** 위험만 남는다.
+   *
+   * 그런데 원천이 **애초에 다시 말해 주지 않는 축**이 있다. 우리가 접어 만든 것들이다:
+   *  · 확인(ack)·조건이 처음 성립한 시각 — 사람이 한 일과 우리가 기억한 시각
+   *  · 열린 구간의 누적·적산 기준점·관측 이후 최대 — SCADA 는 「이번 15분에 지금까지 얼마」를 모른다
+   *
+   * 이것을 잃으면 오류 없이 값이 작아진다(실측: 재기동 뒤 그 구간의 전력량·피크가 작게 나오고, 세
+   * 시간째 지속된 경보가 「0초째」가 된다). 그래서 축을 갈라, 되풀어 주지 않는 것만 이어받는다.
+   *
+   * 도메인 축(에너지 등)은 서브클래스가 override 로 덧붙인다(`super.hydrateContinuity(snap)` 합성).
+   */
+  hydrateContinuity(snap) {
+    for (const id of snap?.acked ?? []) this._acked.add(id);
+    for (const e of snap?.attentionSince ?? []) if (e?.id && e.since) this._attentionSince.set(e.id, e.since);
+  }
   hydrateObserved(snap, orders = []) {
     for (const id of snap.acked ?? []) this._acked.add(id);
+    for (const e of snap.attentionSince ?? []) if (e?.id && e.since) this._attentionSince.set(e.id, e.since);
     for (const n of snap.locations) {
       this.locations.set(n.id, { id: n.id, type: n.type, capacity: n.capacity ?? 0, parallelism: n.parallelism, occupancy: n.occupancy ?? 0, status: n.status ?? "idle", parentId: n.parentId });
     }
@@ -3515,7 +3536,6 @@ var FlowEngine = class {
   abandonedTasks = 0;
   /** 주목 신호가 **처음 성립한 시각**(id → ISO). 조건이 사라지면 지운다 — 재발은 새 시작이다. */
   _attentionSince = /* @__PURE__ */ new Map();
-  // 확인(ack)된 주목 신호 id — 조건 지속돼도 acknowledged 로 표시(재발 시 재활성)
   dispatch(cmd) {
     this._correlationId = cmd.correlationId ?? cmd.commandId;
     try {
@@ -3758,15 +3778,40 @@ var FlowEngine = class {
       })),
       attentions: this.computeAttentions(),
       /* 확인해 둔 신호 — 스냅샷으로 왕복해야 재기동 후에도 확인 상태가 유지된다. */
-      acked: [...this._acked]
+      acked: [...this._acked],
+      /* 언제부터인가 — 이것도 계산으로 되살릴 수 없다. 위 계산이 사라진 조건을 이미 지웠으므로 지금 남은 것이 곧 진실이다. */
+      attentionSince: [...this._attentionSince].map(([id, since]) => ({ id, since }))
     };
   }
+  /*
+   * 주목 신호 — **수명 관리는 여기 한 곳**이다(확장하지 말 것, 확장점은 `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(
       {
@@ -3779,14 +3824,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;
   }
   /**
@@ -6129,6 +6166,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;
+  }
   /**
    * 계측 표본을 받는다 — 에너지 사건만 가로채고 나머지는 그대로 상위에 넘긴다.
    *
@@ -6355,6 +6414,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);
@@ -6576,6 +6698,30 @@ var EmsKernel = class extends FlowEngine {
     this.deriveLoad(at, dtMs);
     this.closeDue(at);
   }
+  /**
+   * 에너지의 연속성 — **SCADA 는 「이번 15분에 지금까지 얼마」를 모른다.**
+   *
+   * 계량기는 순간값과 적산값을 준다. 「이 구간의 최대」·「구간이 열릴 때의 적산」·「관측 이후 최대」는
+   * 우리가 접어 만든 값이라, 재기동하면 원천이 되풀어 주지 않는다. 잃으면 오류 없이 값이 작아진다 —
+   * 구간 전력량이 기준점을 새로 잡아 짧아지고, 그 구간의 피크가 부팅 이후로만 잡힌다(요금이 걸린 수다).
+   *
+   * 지난 마감 구간도 이어받는다: 이미 저널에 있는 사실이지만, 화면이 그것을 보려고 매번 저널을 접지
+   * 않게 한다(자른 사실은 `closedTotal` 이 그대로 나른다).
+   *
+   * 지금 열린 구간이 **이미 지나간 것**이어도 그대로 받는다 — 다음 표본이 오면 커널이 그 구간을 정상
+   * 경로로 마감한다(그 사실은 자기 시각을 달고 있어 늦게 나가도 참이다). 여기서 버리면 그 15분은
+   * 통째로 사라진다.
+   */
+  hydrateContinuity(snap) {
+    super.hydrateContinuity(snap);
+    const e = snap?.energy;
+    if (!e) return;
+    for (const p of e.points ?? []) if (p?.id) this.points.set(p.id, { ...p });
+    if (e.open) this.open = { ...e.open };
+    if (e.closed?.length) this.closed = e.closed.map((w) => ({ ...w })).slice(-KEEP_CLOSED);
+    if (Number.isFinite(e.closedTotal)) this.closedTotal = Number(e.closedTotal);
+    if (e.peakSince && Number.isFinite(e.peakSince.kW)) this.peak = { kW: e.peakSince.kW, windowStartMs: e.peakSince.windowStartMs };
+  }
   getSnapshot() {
     const snap = super.getSnapshot();
     const contractKW = this.declaredContractKW();

package/package.json

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