@operato/twin-kernel 0.8.4 → 0.10.0

package/dist/flow-engine.d.ts

@@ -1,4 +1,4 @@
-import type { TestResult, ISOTime, MaterialQuantity, WorkCalendarEntry, EffectivePeriod, Effectivity, OffCalendarReason, ResourceProperty, ResourceClassDef, MaterialDefinition, Attention, TwinModelDef, CanonicalEnvelope, Command, CommandAck, EventHandler, EquipmentMotion, OeeMetrics, AssetState, GeneratorSpec, InterventionOutcome, OrderState, PersonState, ScenarioControl, ScenarioOverride, StateSnapshot, TwinKernel, Unsubscribe, LocationState, ItemState, EquipmentState, OrderStatusDelta, TaskState, TaskStatus, StructureShift, IdentityGroundingView, IdentityDeclaration, TestSpecificationCriterion, LocationObservation } from '@operato/ops-contract';
+import type { TestResult, ISOTime, MaterialQuantity, WorkCalendarEntry, EffectivePeriod, Effectivity, OffCalendarReason, ResourceProperty, ResourceClassDef, MaterialDefinition, Attention, TwinModelDef, CanonicalEnvelope, Command, CommandAck, EventHandler, EquipmentMotion, AssetState, GeneratorSpec, InterventionOutcome, OrderState, PersonState, ScenarioControl, ScenarioOverride, StateSnapshot, TwinKernel, Unsubscribe, LocationState, ItemState, EquipmentState, OrderStatusDelta, TaskState, TaskStatus, StructureShift, IdentityGroundingView, IdentityDeclaration, TestSpecificationCriterion, LocationObservation } from '@operato/ops-contract';
 import type { VocabularyElement } from '@operato/ops-contract';
 import type { ReducerCheckpoint } from './observed-reducer.ts';
 import type { EpcisEvent, BizTransactionElement } from '@operato/ops-contract';
@@ -411,22 +411,6 @@ nowIso?: ISOTime,
  * 부르는 쪽이 모델에서 뽑아 넘긴다(이 함수는 순수하게 남는다 — 모델을 읽는 규칙이 두 곳이 되지 않게).
  */
 thresholds?: AttentionThresholds): Attention[];
-/** OEE 계측 카운터 — sim 은 tick 으로 누적, live 는 실 텔레메트리 또는 이벤트 누적기가 채운다(face2-inbound-live §1.1). */
-export interface OeeCounters {
-    runMs: number;
-    setupMs: number;
-    downMs: number;
-    goodCount: number;
-    scrapCount: number;
-    holdMs?: number;
-    metricsSinceMs?: number;
-}
-/**
- * OEE 공식(순수) — 누적 카운터 + 현재 시각 → OEE. sim(oeeOf)과 live 가 **공유하는 계산 층**(face2-inbound-live §1.1).
- * ⚠ attentions 와 달리: 입력(카운터)이 관측 State·이벤트에 없다 → live 는 카운터를 텔레메트리(정확) 또는
- *    이벤트 누적기(근사)로 별도 공급해야 한다. 공식만 공유되고 입력원은 live 데이터-생산 결정.
- */
-export declare function computeOee(c: OeeCounters, nowMs: number): OeeMetrics;
 /**
  * 물품 저장소 — **맵과 「자리별 색인」을 함께 든다.**
  *

package/dist/flow-engine.js

@@ -9,7 +9,7 @@
  * 통합 타입은 도메인 필드를 옵셔널로 넓혀(FlowItem.gtin?, FlowOrder.shipmentEpc? 등) 두 도메인을 담는다.
  * (roadmap Phase5 발견 → 추출. [[project_flow_single_base_vision]] FlowLocation 단일 base 방향과 정합.)
  */
-import { OP_EVENT, CMD, locationStatusOf, readBoardEquipment, readBoardLocations, readBoardAssets, classClosure, capabilityOf, requiredTestsFor, priorityRank, dueStatusOf, isOrderTerminal, effectivityAt, offCalendarAt, offCalendarReasonAt, minuteOfDayAt, activeShiftAt, subLotIdOf, itemKeyOf, identityGroundingOf, outsideLimit } from '@operato/ops-contract';
+import { OP_EVENT, CMD, locationStatusOf, readBoardEquipment, readBoardLocations, readBoardAssets, classClosure, capabilityOf, requiredTestsFor, priorityRank, dueStatusOf, isOrderTerminal, effectivityAt, offCalendarAt, offCalendarReasonAt, minuteOfDayAt, activeShiftAt, subLotIdOf, itemKeyOf, identityGroundingOf, outsideLimit, computeOee } from '@operato/ops-contract';
 import { ObservedReducer } from "./observed-reducer.js";
 /* 주체를 정하는 규칙은 유입 문과 한 벌이다 — 두 곳에 적으면 한쪽만 고쳐진다. */
 import { resolveSubject } from '@operato/ops-contract';
@@ -332,32 +332,6 @@ thresholds) {
                 a.state = 'acknowledged';
     return out;
 }
-/**
- * OEE 공식(순수) — 누적 카운터 + 현재 시각 → OEE. sim(oeeOf)과 live 가 **공유하는 계산 층**(face2-inbound-live §1.1).
- * ⚠ attentions 와 달리: 입력(카운터)이 관측 State·이벤트에 없다 → live 는 카운터를 텔레메트리(정확) 또는
- *    이벤트 누적기(근사)로 별도 공급해야 한다. 공식만 공유되고 입력원은 live 데이터-생산 결정.
- */
-export function computeOee(c, nowMs) {
-    /*
-     * **계측 창을 모르면 잰 시간이 없다** — `?? 0` 으로 메우면 "1970년부터 재고 있었다" 가 된다.
-     *
-     * 그 결과가 화면까지 갔다: 갓 뜬 트윈의 절단기가 `idleMs 1767226603000`(약 56,000년) 유휴로 섰다.
-     * 시각을 소요시간 자리에 앉힌 것이고, 같은 값이 availability·overall 의 분모라 **성과 숫자 전체가
-     * 조용히 거짓**이 된다(가동률 100%, 성능 0%).
-     *
-     * 모르면 0 이 아니라 **없음**이다: 잰 구간이 없으면 유휴도 없다(아직 아무것도 재지 않았다).
-     */
-    const planned = c.metricsSinceMs == null ? 0 : Math.max(0, nowMs - c.metricsSinceMs - (c.holdMs ?? 0));
-    const uptime = Math.max(0, planned - c.setupMs - c.downMs); // 가용시간(셋업·고장 제외)
-    const availability = planned > 0 ? uptime / planned : 1;
-    const performance = uptime > 0 ? Math.min(1, c.runMs / uptime) : (c.runMs > 0 ? 1 : 0);
-    const totalQ = c.goodCount + c.scrapCount;
-    const quality = totalQ > 0 ? c.goodCount / totalQ : 1;
-    return {
-        availability, performance, quality, overall: availability * performance * quality,
-        runMs: c.runMs, setupMs: c.setupMs, downMs: c.downMs, idleMs: Math.max(0, uptime - c.runMs), goodCount: c.goodCount, scrapCount: c.scrapCount
-    };
-}
 /**
  * 에너지 능력이 선언한 상태 필드를 스냅샷에 싣는다 — **온 것만.**
  *
@@ -1075,7 +1049,7 @@ export class FlowEngine {
              * 한계가 있다 — busy 를 가동으로 근사하고 **셋업을 분리하지 못해 0** 으로 둔다. 여기서는 받은
              * 값을 그대로 이어받고, 없으면 0 에서 시작한다(꾸미지 않는다).
              */
-            /* `idleMs` 까지 읽는다 — 그것이 있어야 **잰 구간**을 되세울 수 있다(계획 시간 = 가동+준비+고장+유휴). */
+            /* `delayMs` 까지 읽는다 — 그것이 있어야 **잰 구간**을 되세울 수 있다(계획 조업 = 생산+준비+고장+대기). */
             const oee = m.oee;
             /* **마스터가 말한 것을 관측이 지우지 않는다.** 예전에는 이 자리에서 통째로 새 객체를 만들어
              * 교대 캘린더·속성·유효 기간·계획정지를 **전부 버렸다.** 그 결과 라이브(관측) 커널은
@@ -1105,7 +1079,7 @@ export class FlowEngine {
                  * 뒤로 물려 창을 다시 세운다. 지표가 없으면 창도 없다(그때는 지금부터 새로 잰다).
                  */
                 ...(oee
-                    ? { metricsSinceMs: this.clockMs - ((oee.runMs ?? 0) + (oee.setupMs ?? 0) + (oee.downMs ?? 0) + (oee.idleMs ?? 0)) }
+                    ? { metricsSinceMs: this.clockMs - ((oee.runMs ?? 0) + (oee.setupMs ?? 0) + (oee.downMs ?? 0) + (oee.delayMs ?? 0)) }
                     : {}),
                 /* 계획 정지를 이어받는다 — 잃으면 씨앗이 **정비 중인 설비를 가용으로 놓고** 미래를 시뮬레이션한다
                    (예측이 낙관 쪽으로 치우친다). 씨앗 왕복 대조가 이것을 잡았다. */

package/dist/observed-reducer.d.ts

@@ -1,4 +1,4 @@
-import type { AssetState, TestResult, MaterialQuantity, TwinModelDef, CanonicalEnvelope, LocationState, ItemState, LocationObservation, EquipmentState, PersonState, TaskState, OrderState, StructureShift } from '@operato/ops-contract';
+import type { AssetState, TestResult, MaterialQuantity, TwinModelDef, CanonicalEnvelope, LocationState, ItemState, LocationObservation, EquipmentState, PersonState, TaskState, OrderState, StructureShift, DispositionFact } from '@operato/ops-contract';
 import { type VocabularyElement } from '@operato/ops-contract';
 interface ProjItem {
     epc: string;
@@ -8,7 +8,10 @@ interface ProjItem {
     gtinKey?: string;
     lot?: string;
     location: string;
+    /** EPCIS 의 처지(`urn:epcglobal:cbv:disp:…`). 아래 `nonconformance` 와 다른 뜻이다. */
     disposition?: string;
+    /** ISA-95 의 부적합 처분 — 사람이 정한 결정. 로트 전체의 사실이라 부분마다 같은 값이 앉는다. */
+    nonconformance?: DispositionFact;
     parent?: string;
     qty?: number;
     uom?: string;
@@ -152,6 +155,23 @@ export interface ReducerCheckpoint {
         firstAtMs?: number;
         lastAtMs?: number;
     }[];
+    /**
+     * 설비마다 쌓은 OEE 계수기 — 산출은 `quality`, 시간은 `equipment-period` 에서 온다.
+     *
+     * 원천이 되풀어 주지 않는 축이라 저장해야 한다. 저장하지 않으면 재기동 뒤에 어제까지 쌓은 시간이
+     * 사라지고 가동률이 그 순간부터 다시 세어진다.
+     */
+    oeeCounters?: {
+        id: string;
+        metricsSinceMs?: number;
+        metricsUntilMs?: number;
+        runMs: number;
+        setupMs: number;
+        downMs: number;
+        holdMs: number;
+        goodCount: number;
+        scrapCount: number;
+    }[];
     /** 자리별 · 속성별 마지막 관측 — 이어 계산가 이 축을 0부터 다시 만들지 않게. */
     observations?: {
         id: string;
@@ -237,6 +257,13 @@ export declare class ObservedReducer {
     private corrections;
     /** 반영하지 못한 사건의 종류별 집계 — 원문은 쌓지 않는다(저널에 이미 있다). */
     private unhandled;
+    /**
+     * **설비마다 쌓는 OEE 계수기** — 상태가 아니라 누적이다.
+     *
+     * 원천이 되풀어 주지 않는 축이라 저장본에 함께 담는다(§`serialize`). 담지 않으면 재기동 뒤에 어제까지
+     * 쌓은 시간이 사라지고, 가동률이 그 순간부터 다시 세어진다.
+     */
+    private oeeCounters;
     /** 선언된 판정 기준(트윈 모델에서 한 번 읽는다) — 판정은 선언한 것에만 걸린다. */
     private testSpecs;
     /**
@@ -341,6 +368,19 @@ export declare class ObservedReducer {
      * `key` 를 주면 그 이름으로 센다: 종류 전체를 못 다룬 것과 **그 종류의 어떤 모양만** 못 다룬 것은
      * 다른 사실이다(예: 담김은 반영하는데 품번이 섞인 팔레트만 못 담는다).
      */
+    /**
+     * 그 설비의 OEE — **원천이 말해 준 구간까지만 센다.**
+     *
+     * 조업 시간의 끝을 시계에서 가져오지 않는다. 시계를 쓰면 원천이 말을 멈춘 동안에도 조업 시간만 자라
+     * 가동률이 계속 떨어지는데, 그것은 설비의 사실이 아니라 연결의 사실이다. 미러가 아는 것은
+     * **구간으로 들은 시간**뿐이고, 그 밖의 시간에 그 설비가 무엇을 했는지는 모른다.
+     *
+     * 그래서 창은 `[가장 이른 from, 가장 늦은 to]` 다. 구간을 하나도 못 들었으면 조업 시간이 없고,
+     * `computeOee` 가 가동률 대신 `missing` 을 낸다.
+     *
+     * 잰 것이 없으면 아무것도 내지 않는다. 빈 계수기로 0% 를 그리면 「재지 않았다」가 「안 돌았다」가 된다.
+     */
+    private oeePart;
     private noteUnhandled;
     /**
      * 팔레트 물품에 **담고 있는 것**을 채운다 — 이미 아는 값을 덮지 않는다.

package/dist/observed-reducer.js

@@ -19,6 +19,7 @@
  *  - 운영 델타(task/equipment/order.status) → tasks·equipment·orders (EPCIS 로 재구성 불가한 절반)
  * 마스터(로케이션)는 board 초기화 + applyMaster 로 갱신(마스터 동기).
  */
+import { computeOee } from '@operato/ops-contract';
 import { OP_EVENT, capabilityOf, itemKeyOf, judgeAgainstSpec, requiredTestsFor, locationStatusOf, readBoardEquipment, readBoardLocations, readBoardAssets, effectivityAt, offCalendarAt, offCalendarReasonAt, activeShiftAt } from '@operato/ops-contract';
 import { ILMD_ATTR, parseEpc } from '@operato/ops-contract';
 import { expiryFromAttributes, lotFromAttributes } from '@operato/ops-contract';
@@ -41,6 +42,9 @@ function effectiveOf(r) {
         ...(r?.effectiveEnd ? { effectiveEnd: r.effectiveEnd } : {})
     };
 }
+function emptyOeeCounters() {
+    return { runMs: 0, setupMs: 0, downMs: 0, holdMs: 0, goodCount: 0, scrapCount: 0 };
+}
 export class ObservedReducer {
     /** 로케이션 마스터 — 출처를 함께 들고 있다(마스터가 말한 자리 vs 관측으로 알게 된 자리). */
     master = new Map();
@@ -89,6 +93,13 @@ export class ObservedReducer {
     corrections = [];
     /** 반영하지 못한 사건의 종류별 집계 — 원문은 쌓지 않는다(저널에 이미 있다). */
     unhandled = new Map();
+    /**
+     * **설비마다 쌓는 OEE 계수기** — 상태가 아니라 누적이다.
+     *
+     * 원천이 되풀어 주지 않는 축이라 저장본에 함께 담는다(§`serialize`). 담지 않으면 재기동 뒤에 어제까지
+     * 쌓은 시간이 사라지고, 가동률이 그 순간부터 다시 세어진다.
+     */
+    oeeCounters = new Map();
     /** 선언된 판정 기준(트윈 모델에서 한 번 읽는다) — 판정은 선언한 것에만 걸린다. */
     testSpecs = new Map();
     /**
@@ -447,6 +458,96 @@ export class ObservedReducer {
                 this.touchLocation(d.location);
                 break;
             }
+            case OP_EVENT.quality: {
+                /*
+                 * **산출 누적** — 설비가 지금까지 몇 개를 냈나. OEE 의 양품률이 이 값에서만 나온다.
+                 *
+                 * 예전에는 이 사건을 관측이 읽지 않았다. 유입 문도 있고 저널에도 남는데 **상태에 앉는 자리가
+                 * 없어서**, 미러 트윈의 양품률이 영영 비어 있었다. 시뮬레이션 커널만 자기 계수기를 채웠다.
+                 *
+                 * 값은 **절대 누적**이다(계약이 그렇게 정의한다). 그래서 더하지 않고 그대로 놓는다 — 더하면
+                 * 재전송 한 번에 두 배가 된다.
+                 */
+                const d = e.data;
+                if (!d?.moverId)
+                    break;
+                if (this.stale(`quality:${d.moverId}`, e))
+                    return;
+                const c = this.oeeCounters.get(d.moverId) ?? emptyOeeCounters();
+                c.goodCount = d.goodCount;
+                c.scrapCount = d.scrapCount;
+                this.oeeCounters.set(d.moverId, c);
+                this.markHeard(d.moverId, e);
+                break;
+            }
+            case OP_EVENT.equipmentPeriod: {
+                /*
+                 * **마감된 상태 구간** — 그 설비가 그 구간 동안 그 상태였다. 시간을 종류별로 쌓는다.
+                 *
+                 * `stale` 을 지나지 않는다. 구간 하나하나가 **자기 사실**이지 상태를 덮는 것이 아니어서,
+                 * 시각으로 앞뒤를 가리면 늦게 적힌 어제의 정지가 버려진다. 되돌아가 적는 것이 이 어휘의 존재
+                 * 이유다. 같은 구간이 두 번 오는 것은 유입 경계가 거른다.
+                 *
+                 * **지금 상태를 바꾸지 않는다.** 어제의 구간이 오늘의 상태가 되면 안 된다.
+                 */
+                const d = e.data;
+                if (!d?.moverId || !d?.from || !d?.to)
+                    break;
+                const from = Date.parse(d.from);
+                const to = Date.parse(d.to);
+                if (!Number.isFinite(from) || !Number.isFinite(to) || to <= from)
+                    break;
+                const c = this.oeeCounters.get(d.moverId) ?? emptyOeeCounters();
+                const ms = to - from;
+                /* 어디에도 넣을 수 없는 상태는 세지 않는다 — 아무 칸에나 넣으면 가동률이 조용히 틀린다. */
+                if (d.status === 'busy')
+                    c.runMs += ms;
+                else if (d.status === 'setup')
+                    c.setupMs += ms;
+                else if (d.status === 'down')
+                    c.downMs += ms;
+                else if (d.status === 'planned-stop')
+                    c.holdMs += ms;
+                else if (d.status !== 'idle')
+                    break;
+                /* 대기(`idle`)는 따로 쌓지 않는다 — 조업 시간에서 나머지로 나온다(ISO 22400 의 ADOT). */
+                c.metricsSinceMs = c.metricsSinceMs === undefined ? from : Math.min(c.metricsSinceMs, from);
+                c.metricsUntilMs = c.metricsUntilMs === undefined ? to : Math.max(c.metricsUntilMs, to);
+                this.oeeCounters.set(d.moverId, c);
+                this.markHeard(d.moverId, e);
+                break;
+            }
+            case OP_EVENT.disposition: {
+                /*
+                 * **부적합 처분** — 이 로트를 어떻게 하기로 정했나. 대상을 가리켜 들어오고 그 개체 안에 앉는다
+                 * (§`OP_EVENT.test` 와 같은 좁힘).
+                 *
+                 * **물품을 지어내지 않는다.** 모르는 대상의 처분은 `unhandled` 로 세어서 낸다 — 없는 재고를
+                 * 만드는 것은 사실을 잃는 것보다 나쁘다.
+                 */
+                const d = e.data;
+                if (!d?.subjectId || !d?.decision)
+                    break;
+                if (this.stale(`disposition:${d.subjectId}`, e))
+                    return;
+                /*
+                 * **로트를 이름으로 찾는다.** 상태의 열쇠는 로트 하나가 아니다 — 같은 로트가 두 자리에 나뉘어
+                 * 놓이면 부분마다 한 줄이고(§`ItemState` 의 `MaterialSubLot`), 처분은 **로트 전체의 사실**이다.
+                 * 그래서 그 이름을 가진 부분 모두에 앉힌다.
+                 *
+                 * 부분마다 같은 사실이 앉으므로 **부분을 가로질러 수량을 합하면 안 된다.** 자리마다 다르게
+                 * 처분하는 일이 생기면 그것은 이 사실이 아니라 자리를 가리키는 다른 사실이다.
+                 */
+                const parts = [...this.items.values()].filter(i => i.epc === d.subjectId);
+                if (!parts.length) {
+                    this.noteUnhandled(e, `${OP_EVENT.disposition}:unknown-subject`);
+                    break;
+                }
+                /* `disposition` 은 EPCIS 의 이름이라 쓸 수 없다 — 같은 낱말을 두 표준이 다른 뜻으로 쓴다. */
+                for (const part of parts)
+                    part.nonconformance = { ...d };
+                break;
+            }
             case OP_EVENT.observation: {
                 /*
                  * **자리의 물리 관측** — 속성마다 마지막 값 하나만 든다(§`LocationState.observations`).
@@ -594,6 +695,24 @@ export class ObservedReducer {
      * `key` 를 주면 그 이름으로 센다: 종류 전체를 못 다룬 것과 **그 종류의 어떤 모양만** 못 다룬 것은
      * 다른 사실이다(예: 담김은 반영하는데 품번이 섞인 팔레트만 못 담는다).
      */
+    /**
+     * 그 설비의 OEE — **원천이 말해 준 구간까지만 센다.**
+     *
+     * 조업 시간의 끝을 시계에서 가져오지 않는다. 시계를 쓰면 원천이 말을 멈춘 동안에도 조업 시간만 자라
+     * 가동률이 계속 떨어지는데, 그것은 설비의 사실이 아니라 연결의 사실이다. 미러가 아는 것은
+     * **구간으로 들은 시간**뿐이고, 그 밖의 시간에 그 설비가 무엇을 했는지는 모른다.
+     *
+     * 그래서 창은 `[가장 이른 from, 가장 늦은 to]` 다. 구간을 하나도 못 들었으면 조업 시간이 없고,
+     * `computeOee` 가 가동률 대신 `missing` 을 낸다.
+     *
+     * 잰 것이 없으면 아무것도 내지 않는다. 빈 계수기로 0% 를 그리면 「재지 않았다」가 「안 돌았다」가 된다.
+     */
+    oeePart(id) {
+        const c = this.oeeCounters.get(id);
+        if (!c)
+            return {};
+        return { oee: computeOee(c, c.metricsUntilMs ?? 0) };
+    }
     noteUnhandled(e, key) {
         const at = Date.parse(String(e.eventTime ?? ''));
         const name = key ?? e.eventType;
@@ -1122,6 +1241,11 @@ export class ObservedReducer {
             unhandled: [...this.unhandled.entries()].map(([eventType, v]) => ({ eventType, ...v })),
             /* 마지막으로 들은 시각 — 이어받지 않으면 재기동 뒤에 아무 말이 없던 길이를 말할 수 없다. */
             heard: [...this.heard.entries()].map(([id, v]) => ({ id, ...v })),
+            /*
+             * OEE 계수기 — **원천이 되풀어 주지 않는 축**이다. 담지 않으면 재기동 뒤에 어제까지 쌓은 시간이
+             * 사라지고 가동률이 그 순간부터 다시 세어진다.
+             */
+            oeeCounters: [...this.oeeCounters.entries()].map(([id, c]) => ({ id, ...c })),
             /*
              * 마스터데이터도 담는다 — 지난 기록에 없는 값이므로, 담지 않으면 되세울 때 유통기한이 빈다.
              * 변하지 않는 값이라 어느 시점의 저장본에서 꺼내도 같은 답이다.
@@ -1147,6 +1271,7 @@ export class ObservedReducer {
         this.pendingQuantities = new Map((cp?.pendingQuantities ?? []).map(x => [x.parent, x.quantities]));
         this.tasks = new Map((cp?.tasks ?? []).map(t => [t.id, { ...t }]));
         this.equipment = new Map((cp?.equipment ?? []).map(m => [m.id, { ...m }]));
+        this.oeeCounters = new Map((cp?.oeeCounters ?? []).map((c) => [String(c.id), { ...emptyOeeCounters(), ...c, id: undefined }]));
         this.persons = new Map((cp?.persons ?? []).map(x => [x.id, { ...x }]));
         this.assets = new Map((cp?.assets ?? []).map(x => [x.id, { ...x }]));
         this.orders = new Map((cp?.orders ?? []).map(o => [o.id, { ...o }]));
@@ -1197,7 +1322,7 @@ export class ObservedReducer {
             persons: [...this.persons.values()].map(p => ({ ...p, ...this.effectivityPart(p), ...this.offShiftPart(`person:${p.id}`), ...this.capabilityPart(p, `person:${p.id}`, p.personnelClassIds, this.classDefs.personnel) })),
             assets: [...this.assets.values()].map(a => ({ ...a, ...this.effectivityPart(a), ...this.capabilityPart(a, `asset:${a.id}`, a.assetClassIds, this.classDefs.asset) })),
             tasks: [...this.tasks.values()].map(t => ({ ...t })),
-            equipment: [...this.equipment.values()].map(m => ({ ...m, ...this.effectivityPart(m), ...this.offShiftPart(`eq:${m.id}`), ...this.capabilityPart(m, `eq:${m.id}`, m.kind ? [m.kind] : [], this.classDefs.equipment) })),
+            equipment: [...this.equipment.values()].map(m => ({ ...m, ...this.oeePart(m.id), ...this.effectivityPart(m), ...this.offShiftPart(`eq:${m.id}`), ...this.capabilityPart(m, `eq:${m.id}`, m.kind ? [m.kind] : [], this.classDefs.equipment) })),
             orders: [...this.orders.values()].map(o => ({ ...o })),
             acked: [...this.acked]
         };

package/dist-cjs/index.cjs

@@ -38,7 +38,6 @@ __export(index_exports, {
   YmsKernel: () => YmsKernel,
   attributeEnergy: () => attributeEnergy,
   compareStates: () => compareStates,
-  computeOee: () => computeOee,
   constantDuration: () => constantDuration,
   counterfactualAt: () => counterfactualAt,
   demandWindowStart: () => demandWindowStart,
@@ -63,7 +62,7 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// node_modules/@operato/ops-contract/dist/capability.js
+// ../ops-contract/dist/capability.js
 var CAPABILITIES = {
   operable: {
     key: "operable",
@@ -198,7 +197,7 @@ function stateFieldsOf(caps) {
   return [...out];
 }
 
-// node_modules/@operato/ops-contract/dist/contract.js
+// ../ops-contract/dist/contract.js
 var ORDER_TERMINAL_STATUS = ["completed", "cancelled"];
 function isOrderTerminal(o) {
   const status = String(o?.status ?? "").trim().toLowerCase();
@@ -582,6 +581,15 @@ var OP_EVENT = {
    * 이 채널이 없으면 시험 결과는 **상태에만 있는 축**이 된다 — 재기동에서 사라지고, 폴드가 되살릴 수
    * 없고, 미러가 이어받지 못한다(§상태 ⊆ 이벤트).
    */
+  /**
+   * **마감된 설비 상태 구간** — 이 설비가 이 구간 동안 이 상태였다.
+   *
+   * 시점의 전이(`equipment.status`)와 다른 사실이다. 전이는 설비가 내고, 이것은 **사람이 나중에
+   * 적는다.** 자재 대기처럼 신호를 내지 않는 정지는 이 길로만 들어온다.
+   *
+   * ISO 22400-2 의 가동률 계산이 이 구간들을 읽는다.
+   */
+  equipmentPeriod: "equipment.state.period",
   test: "test.result",
   /**
    * **부적합 처분** — 재고 판정을 받은 것을 어떻게 하기로 정했나(재작업 · 특채 · 폐기 · 반품).
@@ -805,7 +813,7 @@ function gs1Namespaces(prefix) {
   return [`urn:epc:idpat:sgtin:${prefix}.`, `urn:epc:class:lgtin:${prefix}.`, `urn:epc:id:sgtin:${prefix}.`];
 }
 
-// node_modules/@operato/ops-contract/dist/capacity.js
+// ../ops-contract/dist/capacity.js
 function isoDurationHours(iso2) {
   if (!iso2)
     return 0;
@@ -913,7 +921,7 @@ function analyzeCapacity(input) {
   };
 }
 
-// node_modules/@operato/ops-contract/dist/wms-profile.js
+// ../ops-contract/dist/wms-profile.js
 var BIZSTEP = {
   receiving: "urn:epcglobal:cbv:bizstep:receiving",
   storing: "urn:epcglobal:cbv:bizstep:storing",
@@ -943,7 +951,7 @@ var WMS_TYPES = [
   { key: "packer", role: "equipment", label: "twin.type.packer", standardClass: { epcis: "object", isa95: "Equipment" }, identity: { scheme: "gs1:GIAI" }, capabilities: ["processable", "operable"] }
 ];
 
-// node_modules/@operato/ops-contract/dist/yms-profile.js
+// ../ops-contract/dist/yms-profile.js
 var YARD_BIZSTEP = {
   arriving: "urn:epcglobal:cbv:bizstep:arriving",
   // 게이트-인
@@ -969,7 +977,7 @@ var YMS_TYPES = [
   { key: "hostler", role: "equipment", label: "twin.type.hostler", standardClass: { epcis: "object", iso55000: "Asset" }, identity: { scheme: "gs1:GIAI" }, capabilities: ["mobile", "operable"] }
 ];
 
-// node_modules/@operato/ops-contract/dist/mes-profile.js
+// ../ops-contract/dist/mes-profile.js
 var MES_BIZSTEP = {
   receiving: "urn:epcglobal:cbv:bizstep:receiving",
   // 원자재 수령
@@ -1007,7 +1015,7 @@ var MES_TYPES = [
   { key: "assembler", role: "equipment", label: "twin.type.assembler", standardClass: { isa95: "Equipment", iso55000: "Asset" }, identity: { scheme: "gs1:GIAI" }, capabilities: ["processable", "operable"] }
 ];
 
-// node_modules/@operato/ops-contract/dist/ems-profile.js
+// ../ops-contract/dist/ems-profile.js
 var EMS_LOCATION_TYPES = ["incoming", "feeder", "submeter-zone"];
 var METER_DIRECTION = ["import", "export", "bidirectional"];
 var EMS_PROPERTY = {
@@ -1328,7 +1336,7 @@ function isElectricalLocationType(type) {
   return EMS_LOCATION_TYPES.includes(type);
 }
 
-// node_modules/@operato/ops-contract/dist/domain-catalog.js
+// ../ops-contract/dist/domain-catalog.js
 var locationKeys = (types) => types.filter((t) => t.role === "location").map((t) => t.key);
 var DOMAIN_CATALOG = {
   // label 은 언어 중립 i18n 키(twin.system.<code>) — 사람 언어는 표현계층이 렌더(L2).
@@ -1338,7 +1346,7 @@ var DOMAIN_CATALOG = {
   ems: { system: "ems", label: "twin.system.ems", types: EMS_TYPES, locationTypes: locationKeys(EMS_TYPES) }
 };
 
-// node_modules/@operato/ops-contract/dist/domain-definition.js
+// ../ops-contract/dist/domain-definition.js
 var OP_PARAM = {
   /** 양품률(0..1, 무차원). 없으면 커널 기본값 — 기본값을 쓴 사실은 `specCoverage()` 가 밝힌다. */
   yield: "yield",
@@ -1347,7 +1355,7 @@ var OP_PARAM = {
   setupDuration: "setupDuration"
 };
 
-// node_modules/@operato/ops-contract/dist/energy-ingest.js
+// ../ops-contract/dist/energy-ingest.js
 function resolveSubject(kind, localId, opts) {
   const declared = opts.identityOf?.(kind, localId);
   if (declared)
@@ -1358,7 +1366,7 @@ function periodFactId(tenantId, kind, subject, from, to) {
   return [tenantId, kind, subject, from, to].join("|");
 }
 
-// node_modules/@operato/ops-contract/dist/epcis.js
+// ../ops-contract/dist/epcis.js
 var EPCIS_CONTEXT = "https://ref.gs1.org/standards/epcis/2.0.0/epcis-context.jsonld";
 var UTC_OFFSET = "+00:00";
 var DISP = {
@@ -1617,7 +1625,7 @@ function transformationEvent(p) {
   return e;
 }
 
-// node_modules/@operato/ops-contract/dist/iso-duration.js
+// ../ops-contract/dist/iso-duration.js
 var RE = /^(-)?P(?:(\d+(?:\.\d+)?)W)?(?:(\d+(?:\.\d+)?)D)?(?:T(?:(\d+(?:\.\d+)?)H)?(?:(\d+(?:\.\d+)?)M)?(?:(\d+(?:\.\d+)?)S)?)?$/;
 function parseIsoDuration(text) {
   if (typeof text !== "string")
@@ -1643,7 +1651,7 @@ function parseIsoDuration(text) {
   return sign ? -ms2 : ms2;
 }
 
-// node_modules/@operato/ops-contract/dist/master-data.js
+// ../ops-contract/dist/master-data.js
 function expiryFromAttributes(attrs) {
   return readEpochMs(attrs?.[ILMD_ATTR.expiry]);
 }
@@ -1660,14 +1668,16 @@ function readEpochMs(raw) {
   return Number.isNaN(at) ? void 0 : at;
 }
 
-// node_modules/@operato/ops-contract/dist/operational-ingest.js
+// ../ops-contract/dist/operational-ingest.js
 var TASK_STATUS = ["created", "assigned", "in-progress", "completed"];
-var EQUIPMENT_STATUS = ["idle", "busy", "down"];
+var EQUIPMENT_STATUS = ["idle", "busy", "down", "setup", "planned-stop"];
 var PERSON_STATUS = ["idle", "busy"];
 var ASSET_STATUS = ["idle", "in-use"];
 var SPECS = {
   task: {
     eventType: OP_EVENT.task,
+    match: ["taskId"],
+    matchOrder: 50,
     identity: "taskId",
     /* 종류가 없으면 성과를 종류별로 모을 수 없고(선언된 시간·수율이 종류로 붙는다) 지어낼 수도 없다. */
     required: ["taskId", "kind", "status"],
@@ -1704,6 +1714,8 @@ var SPECS = {
   },
   equipment: {
     eventType: OP_EVENT.equipment,
+    match: ["moverId"],
+    matchOrder: 20,
     identity: "moverId",
     // vocabulary-guard: allow 저널 와이어 필드(델타의 이름이 계약이다)
     required: ["moverId", "kind", "status"],
@@ -1720,6 +1732,8 @@ var SPECS = {
       effectiveStart: "string",
       effectiveEnd: "string",
       recordTime: "string",
+      /* 왜 이 상태가 됐나 — 설비가 알려 주면 싣는다. 사람이 나중에 정하는 사유는 구간 사실에 적는다. */
+      reasonCode: "string",
       /* 이동 구간 — 실 시스템도 줄 수 있는 사실이다(AGV·RTLS 가 출발·도착·소요를 낸다). 안쪽 필드까지
          재검사하지는 않는다: 그 모양은 `EquipmentMotion` 계약이고, 여기서 두 번 지키면 두 벌이 된다. */
       motion: "object"
@@ -1728,6 +1742,8 @@ var SPECS = {
   },
   person: {
     eventType: OP_EVENT.person,
+    match: ["personId"],
+    matchOrder: 30,
     identity: "personId",
     required: ["personId", "status"],
     fields: {
@@ -1745,6 +1761,8 @@ var SPECS = {
   },
   asset: {
     eventType: OP_EVENT.asset,
+    match: ["assetId"],
+    matchOrder: 40,
     identity: "assetId",
     required: ["assetId", "status"],
     fields: {
@@ -1762,6 +1780,8 @@ var SPECS = {
   },
   order: {
     eventType: OP_EVENT.order,
+    match: ["orderId"],
+    matchOrder: 60,
     identity: "orderId",
     /*
      * 요청량·이행량을 **함께** 받는다. 없으면 리듀서가 진척을 0 으로 적는데(`requested ? … : 0`),
@@ -1791,12 +1811,23 @@ var SPECS = {
   },
   quality: {
     eventType: OP_EVENT.quality,
+    match: ["moverId", "good"],
+    matchOrder: 15,
     identity: "moverId",
     // vocabulary-guard: allow 저널 와이어 필드
     /* 누적 카운터가 없으면 OEE 가 양품률을 못 센다 — 판정 하나만으로는 비율이 나오지 않는다. */
     required: ["moverId", "good", "goodCount", "scrapCount"],
     // vocabulary-guard: allow
-    fields: { moverId: "string", good: "boolean", goodCount: "number", scrapCount: "number", recordTime: "string" }
+    /*
+     * `taskId` 는 **귀속**이다 — 이 산출이 어느 작업의 것인가. 수량의 뜻은 바뀌지 않는다(설비 누적).
+     *
+     * 왜 필요한가: 작업자가 올리는 실적은 작업 단위인데 이 갈래의 정체는 설비뿐이라, 두 사실이 만나는
+     * 자리가 없었다. 귀속이 없으면 「이 작업에서 몇 개 나왔나」를 저널에서 되짚을 방법이 없다.
+     *
+     * 정체를 `taskId` 로 바꾸지 않는 이유는 OEE 가 설비 단위여서다. 정체를 옮기면 설비 누적을 셀 수
+     * 없어진다.
+     */
+    fields: { moverId: "string", good: "boolean", goodCount: "number", scrapCount: "number", taskId: "string", recordTime: "string" }
     // vocabulary-guard: allow
   },
   /*
@@ -1809,6 +1840,51 @@ var SPECS = {
    * `propertyMeasurements` 안쪽은 재검사하지 않는다 — 그 모양은 `PropertyMeasurement` 계약이고,
    * 여기서 두 번 지키면 두 벌이 된다(설비 `motion` 과 같은 규율).
    */
+  /*
+   * **마감된 설비 상태 구간** — 이 설비가 이 구간 동안 이 상태였다.
+   *
+   * ── 전이만으로는 안 되는 이유 (2026-08-30) ───────────────────────────────
+   * 세 가지다. 셋째가 결정적이다.
+   *
+   *   사유가 붙을 자리가 없다   기계가 서는 순간에는 왜 섰는지 아무도 모른다. 작업자가 라인이 다시
+   *                            돈 뒤에 적는다. 그 사이에 전이가 더 있으면 어느 전이에 붙일지 정할 수 없다
+   *   계획·비계획을 나중에 정한다  ISO 22400 은 계획정지를 계획 조업 시간에서 빼고 고장은 빼지 않는다.
+   *                            그 분류는 전이가 일어난 순간에 모른다
+   *   전이를 내지 않는 정지가 많다  자재 대기 · 앞 공정 대기 · 작업자 부재. 기계는 전원이 켜진 채 `idle`
+   *                            이고 신호가 하나도 안 나온다. OEE 에서 가장 크게 깎이는 것이 보통 이 시간이다
+   *
+   * 마지막이 감시 시스템과 MES 가 갈리는 자리이기도 하다. 설비가 말하는 것만 모으면 감시이고,
+   * **설비가 말하지 못하는 것을 사람이 적어 넣는 자리**가 MES 다.
+   *
+   * ── 이름이 `downtime` 이 아닌 이유 ────────────────────────────────────────
+   * 이 구간은 `setup` 과 `planned-stop` 도 나른다. 그 둘은 정지가 아니다. 담는 것은 **상태 구간**이고,
+   * 어느 상태인지는 `status` 가 말한다.
+   *
+   * ── 되돌아가 적는 사실이다 ───────────────────────────────────────────────
+   * 봉투의 사건 시각은 **구간의 끝**(그때 성립한다)이고, 적은 시각은 `recordTime` 이다. 둘이 갈려 있어야
+   * 「언제 일어났나」와 「언제 알았나」를 구별할 수 있다.
+   */
+  "equipment-period": {
+    eventType: OP_EVENT.equipmentPeriod,
+    match: ["moverId", "status", "from", "to"],
+    matchOrder: 10,
+    identity: "moverId",
+    // vocabulary-guard: allow 저널 와이어 필드 — 전이와 같은 이름을 쓴다
+    required: ["moverId", "status", "from", "to"],
+    // vocabulary-guard: allow 위와 같은 이유
+    fields: {
+      moverId: "string",
+      status: "string",
+      from: "string",
+      to: "string",
+      // vocabulary-guard: allow
+      /* 사람이 정한 사유 — 없을 수 있다(적지 않은 것과 사유가 없는 것은 다르므로 지어내지 않는다). */
+      reasonCode: "string",
+      decidedBy: "string",
+      recordTime: "string"
+    },
+    enums: { status: EQUIPMENT_STATUS }
+  },
   /*
    * **부적합 처분** — 재고 판정을 받은 것을 어떻게 하기로 정했나.
    *
@@ -1826,6 +1902,8 @@ var SPECS = {
    */
   disposition: {
     eventType: OP_EVENT.disposition,
+    match: ["subjectId", "decision"],
+    matchOrder: 80,
     identity: "subjectId",
     /* 무엇을 어떻게 하기로 했나 — 둘 중 하나가 없으면 그 결정은 아무 데도 붙지 못한다. */
     required: ["subjectId", "decision"],
@@ -1844,6 +1922,8 @@ var SPECS = {
   },
   test: {
     eventType: OP_EVENT.test,
+    match: ["testableObjectId"],
+    matchOrder: 70,
     identity: "testableObjectId",
     /* 무엇을 어느 기준으로 시험했나 — 둘 중 하나가 없으면 그 결과는 아무 데도 붙지 못한다. */
     required: ["testableObjectId", "specId"],
@@ -1877,12 +1957,16 @@ var SPECS = {
    */
   complete: {
     eventType: OP_EVENT.complete,
+    match: ["completeAxis"],
+    matchOrder: 100,
     identity: "completeAxis",
     required: ["completeAxis", "since"],
     fields: { completeAxis: "string", since: "string", recordTime: "string" }
   },
   observation: {
     eventType: OP_EVENT.observation,
+    match: ["locationId", "propertyId"],
+    matchOrder: 90,
     identity: "locationId",
     /* 자리와 속성 — 둘 중 하나가 없으면 그 관측은 아무 데도 붙지 못한다. */
     required: ["locationId", "propertyId"],
@@ -1900,8 +1984,9 @@ var SPECS = {
     }
   }
 };
+var MATCH_ORDER = Object.keys(SPECS).sort((a, b) => (SPECS[a].matchOrder ?? 1e3) - (SPECS[b].matchOrder ?? 1e3));
 
-// node_modules/@operato/ops-contract/dist/operations-capability.js
+// ../ops-contract/dist/operations-capability.js
 function workingHoursBetween(calendar, fromMs, toMs, utcOffsetMinutes) {
   if (!(toMs > fromMs))
     return 0;
@@ -1971,6 +2056,39 @@ function operationsCapabilityOf(input) {
   };
 }
 
+// ../ops-contract/dist/oee.js
+function computeOee(c, nowMs) {
+  const missing = [];
+  const planned = c.metricsSinceMs == null ? 0 : Math.max(0, nowMs - c.metricsSinceMs - (c.holdMs ?? 0));
+  if (planned <= 0)
+    missing.push("planned-busy-time");
+  const delayMs = Math.max(0, planned - c.runMs - c.setupMs - c.downMs);
+  const availability = planned > 0 ? Math.min(1, c.runMs / planned) : void 0;
+  const produced = c.goodCount + c.scrapCount;
+  if (produced <= 0)
+    missing.push("produced-quantity");
+  const quality = produced > 0 ? c.goodCount / produced : void 0;
+  if (c.plannedRunTimePerItemMs == null)
+    missing.push("planned-run-time-per-item");
+  else if (c.runMs <= 0)
+    missing.push("actual-production-time");
+  const performance = c.plannedRunTimePerItemMs != null && c.runMs > 0 ? Math.min(1, c.plannedRunTimePerItemMs * produced / c.runMs) : void 0;
+  const overall = availability != null && performance != null && quality != null ? availability * performance * quality : void 0;
+  return {
+    ...availability != null ? { availability } : {},
+    ...performance != null ? { performance } : {},
+    ...quality != null ? { quality } : {},
+    ...overall != null ? { overall } : {},
+    ...missing.length ? { missing } : {},
+    runMs: c.runMs,
+    setupMs: c.setupMs,
+    downMs: c.downMs,
+    delayMs,
+    goodCount: c.goodCount,
+    scrapCount: c.scrapCount
+  };
+}
+
 // src/divergence.ts
 function diffBy(predicted, actual, idOf, valOf) {
   const p = new Map(predicted.map((e) => [idOf(e), valOf(e)]));
@@ -2207,6 +2325,9 @@ function effectiveOf(r) {
     ...r?.effectiveEnd ? { effectiveEnd: r.effectiveEnd } : {}
   };
 }
+function emptyOeeCounters() {
+  return { runMs: 0, setupMs: 0, downMs: 0, holdMs: 0, goodCount: 0, scrapCount: 0 };
+}
 var ObservedReducer = class {
   /** 로케이션 마스터 — 출처를 함께 들고 있다(마스터가 말한 자리 vs 관측으로 알게 된 자리). */
   master = /* @__PURE__ */ new Map();
@@ -2256,6 +2377,13 @@ var ObservedReducer = class {
   corrections = [];
   /** 반영하지 못한 사건의 종류별 집계 — 원문은 쌓지 않는다(저널에 이미 있다). */
   unhandled = /* @__PURE__ */ new Map();
+  /**
+   * **설비마다 쌓는 OEE 계수기** — 상태가 아니라 누적이다.
+   *
+   * 원천이 되풀어 주지 않는 축이라 저장본에 함께 담는다(§`serialize`). 담지 않으면 재기동 뒤에 어제까지
+   * 쌓은 시간이 사라지고, 가동률이 그 순간부터 다시 세어진다.
+   */
+  oeeCounters = /* @__PURE__ */ new Map();
   /** 선언된 판정 기준(트윈 모델에서 한 번 읽는다) — 판정은 선언한 것에만 걸린다. */
   testSpecs = /* @__PURE__ */ new Map();
   /**
@@ -2547,6 +2675,48 @@ var ObservedReducer = class {
         this.touchLocation(d.location);
         break;
       }
+      case OP_EVENT.quality: {
+        const d = e.data;
+        if (!d?.moverId) break;
+        if (this.stale(`quality:${d.moverId}`, e)) return;
+        const c = this.oeeCounters.get(d.moverId) ?? emptyOeeCounters();
+        c.goodCount = d.goodCount;
+        c.scrapCount = d.scrapCount;
+        this.oeeCounters.set(d.moverId, c);
+        this.markHeard(d.moverId, e);
+        break;
+      }
+      case OP_EVENT.equipmentPeriod: {
+        const d = e.data;
+        if (!d?.moverId || !d?.from || !d?.to) break;
+        const from = Date.parse(d.from);
+        const to = Date.parse(d.to);
+        if (!Number.isFinite(from) || !Number.isFinite(to) || to <= from) break;
+        const c = this.oeeCounters.get(d.moverId) ?? emptyOeeCounters();
+        const ms2 = to - from;
+        if (d.status === "busy") c.runMs += ms2;
+        else if (d.status === "setup") c.setupMs += ms2;
+        else if (d.status === "down") c.downMs += ms2;
+        else if (d.status === "planned-stop") c.holdMs += ms2;
+        else if (d.status !== "idle") break;
+        c.metricsSinceMs = c.metricsSinceMs === void 0 ? from : Math.min(c.metricsSinceMs, from);
+        c.metricsUntilMs = c.metricsUntilMs === void 0 ? to : Math.max(c.metricsUntilMs, to);
+        this.oeeCounters.set(d.moverId, c);
+        this.markHeard(d.moverId, e);
+        break;
+      }
+      case OP_EVENT.disposition: {
+        const d = e.data;
+        if (!d?.subjectId || !d?.decision) break;
+        if (this.stale(`disposition:${d.subjectId}`, e)) return;
+        const parts = [...this.items.values()].filter((i) => i.epc === d.subjectId);
+        if (!parts.length) {
+          this.noteUnhandled(e, `${OP_EVENT.disposition}:unknown-subject`);
+          break;
+        }
+        for (const part of parts) part.nonconformance = { ...d };
+        break;
+      }
       case OP_EVENT.observation: {
         const d = e.data;
         if (!d?.locationId || !d?.propertyId) break;
@@ -2632,6 +2802,23 @@ var ObservedReducer = class {
    * `key` 를 주면 그 이름으로 센다: 종류 전체를 못 다룬 것과 **그 종류의 어떤 모양만** 못 다룬 것은
    * 다른 사실이다(예: 담김은 반영하는데 품번이 섞인 팔레트만 못 담는다).
    */
+  /**
+   * 그 설비의 OEE — **원천이 말해 준 구간까지만 센다.**
+   *
+   * 조업 시간의 끝을 시계에서 가져오지 않는다. 시계를 쓰면 원천이 말을 멈춘 동안에도 조업 시간만 자라
+   * 가동률이 계속 떨어지는데, 그것은 설비의 사실이 아니라 연결의 사실이다. 미러가 아는 것은
+   * **구간으로 들은 시간**뿐이고, 그 밖의 시간에 그 설비가 무엇을 했는지는 모른다.
+   *
+   * 그래서 창은 `[가장 이른 from, 가장 늦은 to]` 다. 구간을 하나도 못 들었으면 조업 시간이 없고,
+   * `computeOee` 가 가동률 대신 `missing` 을 낸다.
+   *
+   * 잰 것이 없으면 아무것도 내지 않는다. 빈 계수기로 0% 를 그리면 「재지 않았다」가 「안 돌았다」가 된다.
+   */
+  oeePart(id) {
+    const c = this.oeeCounters.get(id);
+    if (!c) return {};
+    return { oee: computeOee(c, c.metricsUntilMs ?? 0) };
+  }
   noteUnhandled(e, key) {
     const at = Date.parse(String(e.eventTime ?? ""));
     const name = key ?? e.eventType;
@@ -3007,6 +3194,11 @@ var ObservedReducer = class {
       unhandled: [...this.unhandled.entries()].map(([eventType, v]) => ({ eventType, ...v })),
       /* 마지막으로 들은 시각 — 이어받지 않으면 재기동 뒤에 아무 말이 없던 길이를 말할 수 없다. */
       heard: [...this.heard.entries()].map(([id, v]) => ({ id, ...v })),
+      /*
+       * OEE 계수기 — **원천이 되풀어 주지 않는 축**이다. 담지 않으면 재기동 뒤에 어제까지 쌓은 시간이
+       * 사라지고 가동률이 그 순간부터 다시 세어진다.
+       */
+      oeeCounters: [...this.oeeCounters.entries()].map(([id, c]) => ({ id, ...c })),
       /*
        * 마스터데이터도 담는다 — 지난 기록에 없는 값이므로, 담지 않으면 되세울 때 유통기한이 빈다.
        * 변하지 않는 값이라 어느 시점의 저장본에서 꺼내도 같은 답이다.
@@ -3034,6 +3226,9 @@ var ObservedReducer = class {
     this.pendingQuantities = new Map((cp?.pendingQuantities ?? []).map((x) => [x.parent, x.quantities]));
     this.tasks = new Map((cp?.tasks ?? []).map((t) => [t.id, { ...t }]));
     this.equipment = new Map((cp?.equipment ?? []).map((m) => [m.id, { ...m }]));
+    this.oeeCounters = new Map(
+      (cp?.oeeCounters ?? []).map((c) => [String(c.id), { ...emptyOeeCounters(), ...c, id: void 0 }])
+    );
     this.persons = new Map((cp?.persons ?? []).map((x) => [x.id, { ...x }]));
     this.assets = new Map((cp?.assets ?? []).map((x) => [x.id, { ...x }]));
     this.orders = new Map((cp?.orders ?? []).map((o) => [o.id, { ...o }]));
@@ -3083,7 +3278,7 @@ var ObservedReducer = class {
       persons: [...this.persons.values()].map((p) => ({ ...p, ...this.effectivityPart(p), ...this.offShiftPart(`person:${p.id}`), ...this.capabilityPart(p, `person:${p.id}`, p.personnelClassIds, this.classDefs.personnel) })),
       assets: [...this.assets.values()].map((a) => ({ ...a, ...this.effectivityPart(a), ...this.capabilityPart(a, `asset:${a.id}`, a.assetClassIds, this.classDefs.asset) })),
       tasks: [...this.tasks.values()].map((t) => ({ ...t })),
-      equipment: [...this.equipment.values()].map((m) => ({ ...m, ...this.effectivityPart(m), ...this.offShiftPart(`eq:${m.id}`), ...this.capabilityPart(m, `eq:${m.id}`, m.kind ? [m.kind] : [], this.classDefs.equipment) })),
+      equipment: [...this.equipment.values()].map((m) => ({ ...m, ...this.oeePart(m.id), ...this.effectivityPart(m), ...this.offShiftPart(`eq:${m.id}`), ...this.capabilityPart(m, `eq:${m.id}`, m.kind ? [m.kind] : [], this.classDefs.equipment) })),
       orders: [...this.orders.values()].map((o) => ({ ...o })),
       acked: [...this.acked]
     };
@@ -3351,26 +3546,6 @@ function deriveAttentions(view, acked, nowIso, thresholds) {
   }
   return out;
 }
-function computeOee(c, nowMs) {
-  const planned = c.metricsSinceMs == null ? 0 : Math.max(0, nowMs - c.metricsSinceMs - (c.holdMs ?? 0));
-  const uptime = Math.max(0, planned - c.setupMs - c.downMs);
-  const availability = planned > 0 ? uptime / planned : 1;
-  const performance = uptime > 0 ? Math.min(1, c.runMs / uptime) : c.runMs > 0 ? 1 : 0;
-  const totalQ = c.goodCount + c.scrapCount;
-  const quality = totalQ > 0 ? c.goodCount / totalQ : 1;
-  return {
-    availability,
-    performance,
-    quality,
-    overall: availability * performance * quality,
-    runMs: c.runMs,
-    setupMs: c.setupMs,
-    downMs: c.downMs,
-    idleMs: Math.max(0, uptime - c.runMs),
-    goodCount: c.goodCount,
-    scrapCount: c.scrapCount
-  };
-}
 var ENERGY_STATE_FIELDS = [
   ...stateFieldsOf(["metered", "curtailable", "energyGenerating", "energyStoring", "switching"]),
   "measuredAt"
@@ -3995,7 +4170,7 @@ var FlowEngine = class {
          * 창은 지표 자신이 말해 준다 — 계획 시간은 가동·준비·고장·유휴의 합이다. 그래서 그 합만큼
          * 뒤로 물려 창을 다시 세운다. 지표가 없으면 창도 없다(그때는 지금부터 새로 잰다).
          */
-        ...oee ? { metricsSinceMs: this.clockMs - ((oee.runMs ?? 0) + (oee.setupMs ?? 0) + (oee.downMs ?? 0) + (oee.idleMs ?? 0)) } : {},
+        ...oee ? { metricsSinceMs: this.clockMs - ((oee.runMs ?? 0) + (oee.setupMs ?? 0) + (oee.downMs ?? 0) + (oee.delayMs ?? 0)) } : {},
         /* 계획 정지를 이어받는다 — 잃으면 씨앗이 **정비 중인 설비를 가용으로 놓고** 미래를 시뮬레이션한다
            (예측이 낙관 쪽으로 치우친다). 씨앗 왕복 대조가 이것을 잡았다. */
         ...m.held ? { held: true } : {},
@@ -9420,7 +9595,6 @@ function electricityCost(input) {
   YmsKernel,
   attributeEnergy,
   compareStates,
-  computeOee,
   constantDuration,
   counterfactualAt,
   demandWindowStart,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@operato/twin-kernel",
-  "version": "0.8.4",
+  "version": "0.10.0",
   "type": "module",
   "description": "Twin Domain Kernel — framework-agnostic, zero-dep (domain + sim + 3-channel contract). WMS/YMS/MES, EPCIS 2.0 · ISA-95.",
   "publishConfig": {
@@ -28,6 +28,6 @@
     "test": "node --test test/*.test.ts"
   },
   "dependencies": {
-    "@operato/ops-contract": "^0.4.0"
+    "@operato/ops-contract": "^0.7.0"
   }
 }