@operato/twin-kernel 0.11.1 → 0.11.3

package/dist/flow-engine.d.ts

@@ -1,4 +1,5 @@
 import type { MaterialActual, 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 RatedUsage, type UsedUsage } 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';
@@ -51,6 +52,10 @@ export interface FlowAsset extends EffectivePeriod {
     id: string;
     /** 속한 등급들 — 표준 `PhysicalAssetClassID`(복수). */
     assetClassIds?: string[];
+    /** 정격 사용량 — 선언(§RatedUsage). 이 자산이 얼마를 쓰면 교체되나. */
+    ratedUsage?: RatedUsage;
+    /** 지금까지 쓴 양 — 시뮬은 작업이 끝날 때 올리고, 미러는 원천이 말한 값을 든다. */
+    usedUsage?: UsedUsage;
     location?: string;
     status: string;
     taskId: string | null;
@@ -109,6 +114,14 @@ export interface FlowEquipment extends EffectivePeriod {
     location: string;
     status: string;
     taskId: string | null;
+    /**
+     * 속한 **등급들** — 표준 `EquipmentClassID`(복수). 사람·자산의 `personnelClassIds`·`assetClassIds` 와
+     * 같은 뜻이다.
+     *
+     * **판정에 이 필드를 직접 쓰지 않는다** — `equipmentClassMembership(eq)` 를 거친다. 소속은 이 선언과
+     * `kind` 를 합친 것이고, 합치는 규칙이 계약 한 자리에 있다(여섯 자리가 같은 답을 내야 한다).
+     */
+    equipmentClassIds?: string[];
     /** 붙박인 자리 — 소속. `location` 은 지금 위치. 고정 설비는 둘이 항상 같다(EquipmentState.homeLocation 참조). */
     homeLocation?: string;
     /** 자원 속성 — 표준 `EquipmentProperty`(§ResourceProperty). */
@@ -128,7 +141,7 @@ export interface FlowEquipment extends EffectivePeriod {
     setupMs: number;
     downMs: number;
     goodCount: number;
-    scrapCount: number;
+    nonconformingCount: number;
     lastChangeoverKey?: string;
     mtbfMs?: number;
     mttrMs?: number;
@@ -204,7 +217,7 @@ export interface FlowTask {
      * 이 작업의 **품질 판정 결과** — 판정이 있었을 때만 채운다 (2026-08-19).
      *
      * ── 왜 작업에 적나 ────────────────────────────────────────────────────────
-     * 양품/불량은 지금까지 두 곳에만 남았다: 설비 누적 카운터(`goodCount`·`scrapCount` — 종류를 모른다)와
+     * 양품/불량은 지금까지 두 곳에만 남았다: 설비 누적 카운터(`goodCount`·`nonconformingCount` — 종류를 모른다)와
      * EPCIS disposition(`sellable`/`non_sellable` — 종류를 모른다). 그래서 **「이 공정의 양품률이 얼마였나」**
      * 를 되짚을 방법이 저널에 없었다 — 재기동하면 종류별 품질 이력이 통째로 사라진다.
      *
@@ -359,7 +372,7 @@ export declare function deriveAttentions(view: {
         status?: string;
         location?: string;
         goodCount?: number;
-        scrapCount?: number;
+        nonconformingCount?: number;
         offShift?: boolean;
         /**
          * 이 설비 소식이 끊긴 시간, 그리고 그때까지 가장 오래 끊겼던 시간(밀리초).
@@ -1298,7 +1311,44 @@ export declare abstract class FlowEngine implements TwinKernel {
         subject: string;
         basis: 'declared' | 'twin-local';
     };
-    protected emitOp(eventType: string, data: unknown): void;
+    /**
+     * 운영 델타 방출 — **같은 사실을 다시 적지 않는다.**
+     *
+     * ── 무엇이 있었나 (2026-09-05 실측) ────────────────────────────────────────
+     * `flow-engine.ts` 의 배정 패스가 **매 틱** `created` 인 오더 전부에 `allocate` 를 건다. 자재가
+     * 모자란 오더는 그때마다 `mes-kernel` 의 「모자람을 적고 다음 틱에 다시 본다」 줄에 닿았고, 거기서
+     * **바뀐 것이 없어도 방출**했다.
+     *
+     *   hatio-mx2   오더 315개 → 세 시간에 order.status 2,433,116건 (오더당 7,700)
+     *   다른 트윈    오더당 1~2건
+     *   틱 로그      「journal 706.92ms(88%)」
+     *
+     * 다시 보는 것은 옳다(모자람은 채워질 수 있다). **다시 볼 때마다 적는 것**이 결함이다.
+     *
+     * ── 파급이 디스크가 아니다 ─────────────────────────────────────────────────
+     *   재기동      저널을 접어 상태를 세운다 — 되세우는 시간이 그만큼 는다
+     *   구독        이 사건들은 방송된다. 막힌 오더 × 매 틱 × 구독자 수
+     *   틱          시뮬 틱은 메인 이벤트 루프에서 돈다 — HTTP·구독이 함께 느려진다
+     *   지표        오더 사건을 세는 모든 것이 부푼다
+     *   진짜 문제   「오더가 자재를 못 구해 멈췄다」가 자기가 만든 소음에 묻힌다
+     *
+     * 가장 나쁜 것은 방향이다. **현장이 막힐수록 트윈이 더 무너진다** — 잘 흐르면 사건이 적고 막히면
+     * 폭증한다. 트윈이 가장 필요한 순간에 가장 약해진다.
+     *
+     * ── 왜 여기인가 ────────────────────────────────────────────────────────────
+     * 부르는 자리 하나를 막으면 다른 자리에서 같은 일이 난다 — `emitOrder` 를 부르는 곳만 열다섯이다.
+     * 그리고 `revision` 이 여기서 오르므로, 여기서 막지 않으면 **적지 않고도 판만 올라간다.**
+     *
+     * ── 무엇을 같다고 보나 ─────────────────────────────────────────────────────
+     * `data` 가 바이트까지 같으면 같다. 시각은 `data` 에 없다(여기서 붙인다) — 그래서 「같은 사실을
+     * 다른 시각에 다시 말한 것」이 정확히 걸러진다.
+     *
+     * `subject` 를 안 주면 거르지 않는다. 대상이 없는 사건(주의 등)은 반복 자체가 사실이다.
+     *
+     * 재기동하면 이 기억이 비므로 **첫 방출은 언제나 나간다** — 되세운 상태가 조용히 빠지지 않는다.
+     */
+    private lastEmitted;
+    protected emitOp(eventType: string, data: unknown, subject?: string): void;
     /**
      * 작업 전이 방출 — **커널이 아는 것을 미러도 알게** 한다.
      *
@@ -1354,6 +1404,25 @@ export declare abstract class FlowEngine implements TwinKernel {
      * 작업이 끝나면 자산을 놓아 준다 — **사람과 다른 점: 자산은 도착 자리에 남는다**(물건이므로).
      * 싣고 있던 것은 놓는다(빈 팔레트로 돌아간다 — 회수·재사용의 출발점).
      */
+    /**
+     * 이 자산을 **한 번 썼다**고 센다 — 작업이 자산을 놓을 때.
+     *
+     * ── 셀 수 있는 것만 센다 ────────────────────────────────────────────────
+     * 정격이 「번」(`USE_UOM`)이면 작업 하나가 곧 한 번이다. 그러면 올릴 수 있다.
+     *
+     * **정격이 「미터」면 올리지 않는다.** 그 작업이 몇 미터를 깎았는지는 공정이 말해 줘야 하는
+     * 사실이고, 커널이 「한 번이니 1미터」로 놓으면 그것은 지어낸 값이다. 라우터 비트가 50미터
+     * 정격인데 한 번에 0.2미터를 깎는다면, 1로 세는 순간 실제 수명의 250분의 1에서 교체하라고
+     * 말하게 된다.
+     *
+     * 정격을 선언하지 않은 자산도 세지 않는다. 셀 이유가 없고(견줄 것이 없다), 세면 화면에 「쓴
+     * 양은 있는데 정격은 없다」는 반쪽 사실이 생긴다.
+     *
+     * ── 미러에서는 부르지 않는다 ────────────────────────────────────────────
+     * 이 함수는 시뮬레이션이 자기 우주에서 세는 것이다. 미러의 쓴 양은 **원천이 센 값**이고
+     * (`AssetStatusDelta.usedUsage`), 우리가 거기에 더하면 같은 사용을 두 번 센다.
+     */
+    private countOneUse;
     private releaseAssets;
     /**
      * 필요 인원을 확보한다 — **등급으로 요구하고 등급으로 고른다**(특정인 지목이 아니다).

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, computeOee } from '@operato/ops-contract';
+import { OP_EVENT, CMD, USE_UOM, locationStatusOf, readBoardEquipment, equipmentClassMembership, 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';
@@ -270,11 +270,11 @@ thresholds) {
         }
     }
     for (const m of view.equipment) {
-        const total = (m.goodCount ?? 0) + (m.scrapCount ?? 0);
+        const total = (m.goodCount ?? 0) + (m.nonconformingCount ?? 0);
         const declaredMin = thresholds?.scrapMinSamplesOf?.(m.id);
         const minSamples = declaredMin ?? ATTENTION_DEFAULTS.scrapMinSamples;
         if (total >= minSamples) {
-            const rate = (m.scrapCount ?? 0) / total;
+            const rate = (m.nonconformingCount ?? 0) / total;
             const declaredPct = thresholds?.scrapPctOf?.(m.id);
             const thresholdPct = declaredPct ?? ATTENTION_DEFAULTS.scrapPct;
             /* 「높음」은 기준의 두 배에서 — 기준이 현장의 것이면 그 두 배도 현장의 것이다(상수 두 벌을 두지 않는다). */
@@ -283,7 +283,7 @@ thresholds) {
                     id: `scrap:${m.id}`, kind: 'scrap-high', severity: rate * 100 >= thresholdPct * 2 ? 'high' : 'medium',
                     anchor: { moverId: m.id, locationId: m.location },
                     params: {
-                        moverId: m.id, goodCount: m.goodCount ?? 0, scrapCount: m.scrapCount ?? 0, ratePct: Math.round(rate * 100),
+                        moverId: m.id, goodCount: m.goodCount ?? 0, nonconformingCount: m.nonconformingCount ?? 0, ratePct: Math.round(rate * 100),
                         thresholdPct, basis: declaredPct === undefined ? 'default' : 'declared'
                     },
                     recommendedActions: [
@@ -817,7 +817,7 @@ export class FlowEngine {
             ...(p.testSpecificationIds ? { testSpecificationIds: p.testSpecificationIds } : {}), ...(p.testResults ? { testResults: p.testResults } : {}), ...effectiveOnly(p) };
     }
     buildAsset(a) {
-        return { id: a.id, assetClassIds: a.assetClassIds, location: a.homeLocation, status: 'idle', taskId: null, ...(a.properties ? { properties: a.properties } : {}),
+        return { id: a.id, assetClassIds: a.assetClassIds, ...(a.ratedUsage ? { ratedUsage: a.ratedUsage } : {}), ...(a.usedUsage ? { usedUsage: a.usedUsage } : {}), location: a.homeLocation, status: 'idle', taskId: null, ...(a.properties ? { properties: a.properties } : {}),
             ...(a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {}), ...(a.testResults ? { testResults: a.testResults } : {}), ...effectiveOnly(a) };
     }
     /**
@@ -900,7 +900,7 @@ export class FlowEngine {
     buildEquipment(m) {
         /* **계측은 이 자원이 모델에 들어온 순간부터** 잰다(`metricsSinceMs`). 빠뜨리면 공식이 창을 모르고,
            예전에는 그것을 epoch 로 메워 갓 뜬 설비가 56,000년 유휴로 보였다(§computeOee). */
-        const eq = { id: m.id, kind: m.kind, location: m.homeLocation, homeLocation: m.homeLocation, ...(m.properties ? { properties: m.properties } : {}), ...(m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}), ...(m.testResults ? { testResults: m.testResults } : {}), status: 'idle', taskId: null, runMs: 0, setupMs: 0, downMs: 0, goodCount: 0, scrapCount: 0, metricsSinceMs: this.clockMs, window: m.window, ...(m.workCalendar ? { workCalendar: m.workCalendar } : {}), ...effectiveOnly(m) };
+        const eq = { id: m.id, kind: m.kind, ...(m.equipmentClassIds ? { equipmentClassIds: m.equipmentClassIds } : {}), location: m.homeLocation, homeLocation: m.homeLocation, ...(m.properties ? { properties: m.properties } : {}), ...(m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}), ...(m.testResults ? { testResults: m.testResults } : {}), status: 'idle', taskId: null, runMs: 0, setupMs: 0, downMs: 0, goodCount: 0, nonconformingCount: 0, metricsSinceMs: this.clockMs, window: m.window, ...(m.workCalendar ? { workCalendar: m.workCalendar } : {}), ...effectiveOnly(m) };
         if (m.mtbfMs !== undefined) {
             eq.mtbfMs = m.mtbfMs;
             eq.mttrMs = m.mttrMs;
@@ -915,7 +915,7 @@ export class FlowEngine {
     addEquipment(m) {
         if (this.equipment.has(m.id))
             return;
-        const eq = { id: m.id, kind: m.kind, location: m.homeLocation, homeLocation: m.homeLocation, ...(m.properties ? { properties: m.properties } : {}), ...(m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}), ...(m.testResults ? { testResults: m.testResults } : {}), status: 'idle', taskId: null, runMs: 0, setupMs: 0, downMs: 0, goodCount: 0, scrapCount: 0, metricsSinceMs: this.clockMs };
+        const eq = { id: m.id, kind: m.kind, ...(m.equipmentClassIds ? { equipmentClassIds: m.equipmentClassIds } : {}), location: m.homeLocation, homeLocation: m.homeLocation, ...(m.properties ? { properties: m.properties } : {}), ...(m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}), ...(m.testResults ? { testResults: m.testResults } : {}), status: 'idle', taskId: null, runMs: 0, setupMs: 0, downMs: 0, goodCount: 0, nonconformingCount: 0, metricsSinceMs: this.clockMs };
         if (m.mtbfMs !== undefined) {
             eq.mtbfMs = m.mtbfMs;
             eq.mttrMs = m.mttrMs;
@@ -1040,7 +1040,7 @@ export class FlowEngine {
         for (const m of snap.equipment) {
             /*
              * 관측된 계측을 이어받는다 — **없어서 0 이었던 게 아니라 잘못 읽어서 0 이었다.**
-             * `OeeMetrics` 의 이름은 `runMs`·`setupMs`·`downMs`·`goodCount`·`scrapCount` 인데 예전 코드가
+             * `OeeMetrics` 의 이름은 `runMs`·`setupMs`·`downMs`·`goodCount`·`nonconformingCount` 인데 예전 코드가
              * `oee.good`·`oee.scrap`(존재하지 않는 키)을 읽어 항상 0 으로 떨어졌고, 시간 누적은 아예 0 으로
              * 시작했다. 그래서 씨앗이 "가동 이력이 전혀 없는 설비" 로 출발해 예측의 OEE 가 리셋됐다.
              *
@@ -1056,8 +1056,13 @@ export class FlowEngine {
              * 근무 시간을 모르고(항상 가용), 폐기를 모르고, 속도를 몰라 이동시간을 상수로 떨어뜨렸다.
              * 관측이 말하는 것(위치·상태·계측)만 덮고 **선언은 지킨다**. */
             const prev = this.equipment.get(m.id);
+            /* 등급 소속은 **선언**이다 — 위 규율대로 마스터가 말한 것이 이긴다. 스냅샷의 값은 마스터가 아직
+               실리지 않았을 때(관측만으로 되살리는 경로) 소속을 채운다. 둘 다 없으면 키를 만들지 않는다 —
+               빈 배열을 심으면 "등급이 없는 설비" 와 "모르는 설비" 가 같아진다. */
+            const classIds = prev?.equipmentClassIds ?? m.equipmentClassIds;
             this.equipment.set(m.id, {
                 ...(prev ?? {}),
+                ...(classIds ? { equipmentClassIds: classIds } : {}),
                 /*
                  * `taskId` — **관측이면 원본이 말한 값이다.**
                  *
@@ -1068,7 +1073,7 @@ export class FlowEngine {
                  */
                 id: m.id, kind: m.kind, location: m.location ?? '', ...(m.homeLocation ? { homeLocation: m.homeLocation } : {}), status: m.status ?? 'idle', taskId: purpose === 'observe' ? (m.taskId ?? null) : null,
                 runMs: oee?.runMs ?? 0, setupMs: oee?.setupMs ?? 0, downMs: oee?.downMs ?? 0,
-                goodCount: oee?.goodCount ?? 0, scrapCount: oee?.scrapCount ?? 0,
+                goodCount: oee?.goodCount ?? 0, nonconformingCount: oee?.nonconformingCount ?? 0,
                 /*
                  * **잰 값을 이어받으면 잰 구간도 이어받아야 한다.**
                  *
@@ -1140,7 +1145,12 @@ export class FlowEngine {
             this.assets.set(a.id, {
                 ...(prev ?? {}),
                 /* 설비·사람과 같은 규율 — 관측이면 원본이 말한 상태·묶임을 지킨다. */
-                id: a.id, assetClassIds: a.assetClassIds ?? prev?.assetClassIds, location: a.location,
+                id: a.id, assetClassIds: a.assetClassIds ?? prev?.assetClassIds,
+                /* 정격은 선언이라 마스터가 이긴다. 쓴 양은 **관측이 이긴다** — 원천이 센 값이 우리 추정보다
+                   참이고, 되살릴 때 우리 것을 쓰면 그 사이 실제로 쓴 만큼이 사라진다. */
+                ...(prev?.ratedUsage ?? a.ratedUsage ? { ratedUsage: prev?.ratedUsage ?? a.ratedUsage } : {}),
+                ...(a.usedUsage ?? prev?.usedUsage ? { usedUsage: a.usedUsage ?? prev?.usedUsage } : {}),
+                location: a.location,
                 status: purpose === 'observe' ? (a.status ?? 'idle') : 'idle',
                 taskId: purpose === 'observe' ? (a.taskId ?? null) : null, carrying: a.carrying,
                 ...(a.properties ? { properties: a.properties } : {}),
@@ -1526,7 +1536,7 @@ export class FlowEngine {
                 m.setupMs = 0;
                 m.downMs = 0;
                 m.goodCount = 0;
-                m.scrapCount = 0;
+                m.nonconformingCount = 0;
                 m.holdMs = 0;
                 m.metricsSinceMs = this.clockMs; // 계측 창을 지금부터 재시작
                 this.emitEquipment(m);
@@ -1634,7 +1644,7 @@ export class FlowEngine {
             }),
             items: [...this.items.values()].map(i => this.itemState(i)),
             equipment: [...this.equipment.values()].map(m => {
-                const s = { id: m.id, kind: m.kind, location: m.location, ...(m.homeLocation ? { homeLocation: m.homeLocation } : {}), status: m.status, taskId: m.taskId ?? undefined, oee: this.oeeOf(m), held: m.held, ...(m.properties ? { properties: m.properties } : {}), ...(m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}), ...(m.testResults ? { testResults: m.testResults } : {}), capability: this.capabilityOfResource(m, m.kind ? [m.kind] : [], this.classDefs.equipment), origin: 'master', ...(this.offShift(m) ? { offShift: true, ...this.offReason(m) } : {}), ...this.effectivePart(m), ...(this.shiftOf(m) ? { shift: this.shiftOf(m) } : {}), ...energyFieldsOf(m) };
+                const s = { id: m.id, kind: m.kind, ...(m.equipmentClassIds ? { equipmentClassIds: m.equipmentClassIds } : {}), location: m.location, ...(m.homeLocation ? { homeLocation: m.homeLocation } : {}), status: m.status, taskId: m.taskId ?? undefined, oee: this.oeeOf(m), held: m.held, ...(m.properties ? { properties: m.properties } : {}), ...(m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}), ...(m.testResults ? { testResults: m.testResults } : {}), capability: this.capabilityOfResource(m, equipmentClassMembership(m), this.classDefs.equipment), origin: 'master', ...(this.offShift(m) ? { offShift: true, ...this.offReason(m) } : {}), ...this.effectivePart(m), ...(this.shiftOf(m) ? { shift: this.shiftOf(m) } : {}), ...energyFieldsOf(m) };
                 const t = m.taskId ? this.tasks.get(m.taskId) : undefined;
                 /*
                  * 이동 구간은 **소요를 알 때만** 낸다. 모르면 아래 산수가 전부 0 이나 음수가 되고, 화면은 「제자리에서
@@ -1646,7 +1656,7 @@ export class FlowEngine {
                 return s;
             }),
             assets: [...this.assets.values()].map(a => {
-                const st = { id: a.id, assetClassIds: a.assetClassIds, location: a.location, status: a.status, taskId: a.taskId ?? undefined };
+                const st = { id: a.id, assetClassIds: a.assetClassIds, ...(a.ratedUsage ? { ratedUsage: a.ratedUsage } : {}), ...(a.usedUsage ? { usedUsage: a.usedUsage } : {}), location: a.location, status: a.status, taskId: a.taskId ?? undefined };
                 if (a.carrying)
                     st.carrying = a.carrying;
                 if (a.properties)
@@ -2308,7 +2318,7 @@ export class FlowEngine {
         /* 판정 시각은 **구간의 시작**이다 — 능력은 그 구간을 두고 묻는 것이므로, 지금 고장 난 설비가 아니라
            그 구간에 못 쓰는 설비를 세야 한다(같은 판정 함수에 다른 시각을 준다). */
         const at = opts.window.fromTime;
-        const usableEquipment = [...this.equipment.values()].filter(m => this.capabilityOfResource(m, m.kind ? [m.kind] : [], this.classDefs.equipment, at).available);
+        const usableEquipment = [...this.equipment.values()].filter(m => this.capabilityOfResource(m, equipmentClassMembership(m), this.classDefs.equipment, at).available);
         const usablePersons = [...this.persons.values()].filter(p => this.capabilityOfResource(p, p.personnelClassIds, this.classDefs.personnel, at).available);
         const usableAssets = [...this.assets.values()].filter(a => this.capabilityOfResource(a, a.assetClassIds, this.classDefs.asset, at).available);
         const base = {
@@ -2725,9 +2735,9 @@ export class FlowEngine {
         if (good)
             m.goodCount++;
         else
-            m.scrapCount++;
+            m.nonconformingCount++;
         // 품질 델타 방출 — live OEE 누적기가 good/scrap 을 정확 추적(equipment.status 는 quality 미포함). WMS/YMS 는 미호출→무영향.
-        this.emitOp(OP_EVENT.quality, { moverId: m.id, good, goodCount: m.goodCount, scrapCount: m.scrapCount });
+        this.emitOp(OP_EVENT.quality, { moverId: m.id, good, goodCount: m.goodCount, nonconformingCount: m.nonconformingCount });
     }
     /** 설비 OEE(스냅샷 파생) — Availability×Performance×Quality. planned = 설비 존재 sim 시간(clockMs). */
     oeeOf(m) {
@@ -2810,7 +2820,51 @@ export class FlowEngine {
     subjectOf(kind, localId) {
         return resolveSubject(kind, localId, { tenantId: this.tenantId, scopeId: this.scopeId, identityOf: (k, id) => (k === 'equipment' ? this.equipmentIdentity(id) : undefined) });
     }
-    emitOp(eventType, data) {
+    /**
+     * 운영 델타 방출 — **같은 사실을 다시 적지 않는다.**
+     *
+     * ── 무엇이 있었나 (2026-09-05 실측) ────────────────────────────────────────
+     * `flow-engine.ts` 의 배정 패스가 **매 틱** `created` 인 오더 전부에 `allocate` 를 건다. 자재가
+     * 모자란 오더는 그때마다 `mes-kernel` 의 「모자람을 적고 다음 틱에 다시 본다」 줄에 닿았고, 거기서
+     * **바뀐 것이 없어도 방출**했다.
+     *
+     *   hatio-mx2   오더 315개 → 세 시간에 order.status 2,433,116건 (오더당 7,700)
+     *   다른 트윈    오더당 1~2건
+     *   틱 로그      「journal 706.92ms(88%)」
+     *
+     * 다시 보는 것은 옳다(모자람은 채워질 수 있다). **다시 볼 때마다 적는 것**이 결함이다.
+     *
+     * ── 파급이 디스크가 아니다 ─────────────────────────────────────────────────
+     *   재기동      저널을 접어 상태를 세운다 — 되세우는 시간이 그만큼 는다
+     *   구독        이 사건들은 방송된다. 막힌 오더 × 매 틱 × 구독자 수
+     *   틱          시뮬 틱은 메인 이벤트 루프에서 돈다 — HTTP·구독이 함께 느려진다
+     *   지표        오더 사건을 세는 모든 것이 부푼다
+     *   진짜 문제   「오더가 자재를 못 구해 멈췄다」가 자기가 만든 소음에 묻힌다
+     *
+     * 가장 나쁜 것은 방향이다. **현장이 막힐수록 트윈이 더 무너진다** — 잘 흐르면 사건이 적고 막히면
+     * 폭증한다. 트윈이 가장 필요한 순간에 가장 약해진다.
+     *
+     * ── 왜 여기인가 ────────────────────────────────────────────────────────────
+     * 부르는 자리 하나를 막으면 다른 자리에서 같은 일이 난다 — `emitOrder` 를 부르는 곳만 열다섯이다.
+     * 그리고 `revision` 이 여기서 오르므로, 여기서 막지 않으면 **적지 않고도 판만 올라간다.**
+     *
+     * ── 무엇을 같다고 보나 ─────────────────────────────────────────────────────
+     * `data` 가 바이트까지 같으면 같다. 시각은 `data` 에 없다(여기서 붙인다) — 그래서 「같은 사실을
+     * 다른 시각에 다시 말한 것」이 정확히 걸러진다.
+     *
+     * `subject` 를 안 주면 거르지 않는다. 대상이 없는 사건(주의 등)은 반복 자체가 사실이다.
+     *
+     * 재기동하면 이 기억이 비므로 **첫 방출은 언제나 나간다** — 되세운 상태가 조용히 빠지지 않는다.
+     */
+    lastEmitted = new Map();
+    emitOp(eventType, data, subject) {
+        if (subject !== undefined) {
+            const key = `${eventType}\u0000${subject}`;
+            const json = JSON.stringify(data);
+            if (this.lastEmitted.get(key) === json)
+                return;
+            this.lastEmitted.set(key, json);
+        }
         this.revision++;
         const e = { eventId: `${this.tenantId}-evt-${++this.eventSeq}`, eventType, eventTime: this.now(), tenantId: this.tenantId, ...(this._correlationId ? { correlationId: this._correlationId } : {}), data };
         for (const h of this.handlers)
@@ -2842,14 +2896,14 @@ export class FlowEngine {
             ...(t.startTime ? { startTime: t.startTime } : {}),
             ...(t.endTime ? { endTime: t.endTime } : {}),
             ...(inProgress ? { remainingMs: t.remainingMs, startedAtSimMs: t.startedAtSimMs, progress: t.durationMs ? done / t.durationMs : undefined } : {})
-        });
+        }, t.id);
     }
     /** 사람 상태 전이 — 설비와 별개 채널(어휘가 다르다: 고장이 아니라 교대·투입). */
     emitAsset(a) {
-        this.emitOp(OP_EVENT.asset, { assetId: a.id, assetClassIds: a.assetClassIds, status: a.status, location: a.location, taskId: a.taskId ?? undefined, carrying: a.carrying, ...effectiveOnly(a) });
+        this.emitOp(OP_EVENT.asset, { assetId: a.id, assetClassIds: a.assetClassIds, ...(a.ratedUsage ? { ratedUsage: a.ratedUsage } : {}), ...(a.usedUsage ? { usedUsage: a.usedUsage } : {}), status: a.status, location: a.location, taskId: a.taskId ?? undefined, carrying: a.carrying, ...effectiveOnly(a) }, a.id);
     }
     emitPerson(p) {
-        this.emitOp(OP_EVENT.person, { personId: p.id, personnelClassIds: p.personnelClassIds, status: p.status, taskId: p.taskId ?? undefined, ...(p.location ? { location: p.location } : {}), ...effectiveOnly(p) });
+        this.emitOp(OP_EVENT.person, { personId: p.id, personnelClassIds: p.personnelClassIds, status: p.status, taskId: p.taskId ?? undefined, ...(p.location ? { location: p.location } : {}), ...effectiveOnly(p) }, p.id);
         /* `offShift` 를 더 이상 실어 보내지 않는다 — 교대 경계는 **이벤트 없이 시각만으로** 넘어가므로
            전이 순간의 판정을 보내면 유휴로 경계를 지난 사람이 옛 값에 머문다. 미러는 같은 함수
            (`offCalendarAt`)를 자기 시각으로 부른다(유효 기간과 같은 규율). */
@@ -2857,7 +2911,7 @@ export class FlowEngine {
     /** 설비 상태 전이 — `taskId` 를 함께 싣는다(사람·자산 델타와 같은 규칙). 없으면 미러가 "이 설비가
      *  무슨 일을 하는 중인가" 를 알 수 없어 작업↔자원 연결이 한쪽에서만 성립한다. */
     emitEquipment(m, motion) {
-        this.emitOp(OP_EVENT.equipment, { moverId: m.id, kind: m.kind, status: m.status, location: m.location, ...(m.homeLocation ? { homeLocation: m.homeLocation } : {}), taskId: m.taskId ?? undefined, motion, ...(m.held ? { held: true } : {}), ...effectiveOnly(m) });
+        this.emitOp(OP_EVENT.equipment, { moverId: m.id, kind: m.kind, ...(m.equipmentClassIds ? { equipmentClassIds: m.equipmentClassIds } : {}), status: m.status, location: m.location, ...(m.homeLocation ? { homeLocation: m.homeLocation } : {}), taskId: m.taskId ?? undefined, motion, ...(m.held ? { held: true } : {}), ...effectiveOnly(m) }, m.id);
     }
     /** 오더 델타 — **라인까지 싣는다.** 라인이 빠지면 미러가 남은 데맨드를 라인별로 재계획할 수 없다. */
     emitOrder(o) {
@@ -2878,7 +2932,7 @@ export class FlowEngine {
             /* 약속해 둔 자리·시각창 — 이것이 빠져서 야드 트윈이 재기동마다 첫 틱에 죽었다(§dockDoor). */
             ...(o.dockDoor ? { dockDoor: o.dockDoor } : {}),
             ...(o.windowStartMs !== undefined ? { windowStartMs: o.windowStartMs } : {})
-        });
+        }, o.id);
     }
     // ── 내부 mechanics ─────────────────────────────────────────────────────────
     /**
@@ -2990,11 +3044,40 @@ export class FlowEngine {
      * 작업이 끝나면 자산을 놓아 준다 — **사람과 다른 점: 자산은 도착 자리에 남는다**(물건이므로).
      * 싣고 있던 것은 놓는다(빈 팔레트로 돌아간다 — 회수·재사용의 출발점).
      */
+    /**
+     * 이 자산을 **한 번 썼다**고 센다 — 작업이 자산을 놓을 때.
+     *
+     * ── 셀 수 있는 것만 센다 ────────────────────────────────────────────────
+     * 정격이 「번」(`USE_UOM`)이면 작업 하나가 곧 한 번이다. 그러면 올릴 수 있다.
+     *
+     * **정격이 「미터」면 올리지 않는다.** 그 작업이 몇 미터를 깎았는지는 공정이 말해 줘야 하는
+     * 사실이고, 커널이 「한 번이니 1미터」로 놓으면 그것은 지어낸 값이다. 라우터 비트가 50미터
+     * 정격인데 한 번에 0.2미터를 깎는다면, 1로 세는 순간 실제 수명의 250분의 1에서 교체하라고
+     * 말하게 된다.
+     *
+     * 정격을 선언하지 않은 자산도 세지 않는다. 셀 이유가 없고(견줄 것이 없다), 세면 화면에 「쓴
+     * 양은 있는데 정격은 없다」는 반쪽 사실이 생긴다.
+     *
+     * ── 미러에서는 부르지 않는다 ────────────────────────────────────────────
+     * 이 함수는 시뮬레이션이 자기 우주에서 세는 것이다. 미러의 쓴 양은 **원천이 센 값**이고
+     * (`AssetStatusDelta.usedUsage`), 우리가 거기에 더하면 같은 사용을 두 번 센다.
+     */
+    countOneUse(a) {
+        const rated = a.ratedUsage;
+        if (!rated || rated.uom !== USE_UOM)
+            return;
+        const prev = a.usedUsage;
+        /* 단위가 어긋난 값에 더하지 않는다 — 더하면 두 단위가 한 수에 섞인다. */
+        if (prev && prev.uom !== USE_UOM)
+            return;
+        a.usedUsage = { value: (prev?.value ?? 0) + 1, uom: USE_UOM, ...(prev?.since ? { since: prev.since } : {}) };
+    }
     releaseAssets(t) {
         for (const id of t.assets ?? []) {
             const a = this.assets.get(id);
             if (!a)
                 continue;
+            this.countOneUse(a);
             a.status = 'idle';
             a.taskId = null;
             a.location = t.toNode || a.location;
@@ -3557,12 +3640,12 @@ export class FlowEngine {
         const free = (kind, picked = []) => [...this.equipment.values()].filter(m => 
         /* 사람과 **같은 판정**(§capabilityOfResource) — 예전에는 이 자리에 조건을 늘어놓아서
            설비의 검사 결과는 배정에서 아예 읽히지 않았다(사람만 자격을 봤다). */
-        this.capabilityOfResource(m, m.kind ? [m.kind] : [], this.classDefs.equipment).available &&
+        this.capabilityOfResource(m, equipmentClassMembership(m), this.classDefs.equipment).available &&
             !picked.includes(m.id) &&
-            /* 설비의 소속은 아직 단수(`kind`)다 — 저널에 기록이 쌓여 복수화를 별도 작업으로 두었다.
-               다만 등급 정의가 있으면 **상속은 지금도 탄다**: 'welder-6axis' 가 'welder' 를 상속하면
-               'welder' 요구를 만족한다. 단수/복수와 상속은 다른 축이므로 하나를 기다리지 않는다. */
-            (kind === undefined || classClosure(m.kind ? [m.kind] : [], this.classDefs.equipment, this.now()).has(kind)));
+            /* 소속은 **선언한 등급들과 `kind` 를 합친 것**이다(§equipmentClassMembership). 상속도 탄다:
+               'welder-6axis' 가 'welder' 를 상속하면 'welder' 요구를 만족한다. 예전에는 이 자리가
+               `kind` 하나만 봤고, 그래서 `equipmentClasses` 정의표를 아무도 가리킬 수 없었다. */
+            (kind === undefined || classClosure(equipmentClassMembership(m), this.classDefs.equipment, this.now()).has(kind)));
         const need = this.operationSpecs.get(t.kind)?.equipmentSpecification;
         if (!need?.length) {
             const one = free(t.resourceType)[0];
@@ -3913,10 +3996,28 @@ export class FlowEngine {
             this.consumeMaterials(t, stock);
             this.emitTask(t);
             // process: 제자리 변환(모션 없음). transport: 이동 모션 방출.
-            if (t.intent === 'process')
-                this.emitEquipment(eq);
-            else
-                this.emitEquipment(eq, { fromNode: t.fromNode, toNode: t.toNode, startedAtSimMs: this.clockMs, durationMs: t.durationMs, progress: 0, elapsedMs: 0 });
+            const motion = t.intent === 'process'
+                ? undefined
+                : { fromNode: t.fromNode, toNode: t.toNode, startedAtSimMs: this.clockMs, durationMs: t.durationMs, progress: 0, elapsedMs: 0 };
+            this.emitEquipment(eq, motion);
+            /*
+             * 함께 잡힌 설비도 이벤트를 낸다 — **해제 쪽과 대칭**(§advanceTasks: "함께 잡힌 설비도 같은
+             * 규칙으로 놓아 준다").
+             *
+             * 이 자리가 대표 한 대만 냈다. 위에서 `rigs` 전부를 `busy` 로 바꾸는데 이벤트는 하나였으니
+             * 미러는 나머지가 **잡힌 것을 못 보고 놓이는 것만 봤다** — 상태⊆이벤트 위반이고, 미러에서 그
+             * 설비는 계속 유휴로 보인다(오류는 없다).
+             *
+             * 예전에는 등급 요구 여러 대를 잡는 일이 드물었다: 소속이 `kind` 하나였으니 "한 등급 2대" 를
+             * 종류가 다른 설비로 채울 수 없었다. 소속을 복수로 열면서 이 경로가 흔해진다.
+             */
+            for (const id of rigs) {
+                if (id === eq.id)
+                    continue;
+                const m = this.equipment.get(id);
+                if (m)
+                    this.emitEquipment(m, motion);
+            }
         }
     }
     /** in-progress 진행/완료 — 상태 효과는 전부 도메인(onTaskComplete). base 는 자원 해제·델타만. */

package/dist/observed-reducer.d.ts

@@ -170,7 +170,7 @@ export interface ReducerCheckpoint {
         downMs: number;
         holdMs: number;
         goodCount: number;
-        scrapCount: number;
+        nonconformingCount: number;
     }[];
     /** 자리별 · 속성별 마지막 관측 — 이어 계산가 이 축을 0부터 다시 만들지 않게. */
     observations?: {

package/dist/observed-reducer.js

@@ -43,7 +43,7 @@ function effectiveOf(r) {
     };
 }
 function emptyOeeCounters() {
-    return { runMs: 0, setupMs: 0, downMs: 0, holdMs: 0, goodCount: 0, scrapCount: 0 };
+    return { runMs: 0, setupMs: 0, downMs: 0, holdMs: 0, goodCount: 0, nonconformingCount: 0 };
 }
 export class ObservedReducer {
     /** 로케이션 마스터 — 출처를 함께 들고 있다(마스터가 말한 자리 vs 관측으로 알게 된 자리). */
@@ -128,7 +128,7 @@ export class ObservedReducer {
             this.master.set(n.id, { id: n.id, type: n.type, capacity: n.capacity, parallelism: n.parallelism, parentId: n.parentId, origin: 'master' });
         // 설비 기준선(마스터) — equipment.status 델타로 갱신됨.
         for (const m of readBoardEquipment(model))
-            this.equipment.set(m.id, { id: m.id, kind: m.kind, status: 'idle', location: m.homeLocation, homeLocation: m.homeLocation, ...(m.properties ? { properties: m.properties } : {}), ...(m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}), ...(m.testResults ? { testResults: m.testResults } : {}), ...effectiveOf(m), origin: 'master' });
+            this.equipment.set(m.id, { id: m.id, kind: m.kind, ...(m.equipmentClassIds ? { equipmentClassIds: m.equipmentClassIds } : {}), status: 'idle', location: m.homeLocation, homeLocation: m.homeLocation, ...(m.properties ? { properties: m.properties } : {}), ...(m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}), ...(m.testResults ? { testResults: m.testResults } : {}), ...effectiveOf(m), origin: 'master' });
         // 사람 기준선(마스터) — person.status 델타로 갱신됨.
         for (const p of model.persons ?? [])
             this.persons.set(p.id, { id: p.id, personnelClassIds: p.personnelClassIds, status: 'idle', ...(p.homeLocation ? { location: p.homeLocation } : {}), ...(p.properties ? { properties: p.properties } : {}), ...(p.testSpecificationIds ? { testSpecificationIds: p.testSpecificationIds } : {}), ...(p.testResults ? { testResults: p.testResults } : {}), ...effectiveOf(p) });
@@ -139,7 +139,7 @@ export class ObservedReducer {
         for (const p of model.persons ?? [])
             this.rememberShift(`person:${p.id}`, p);
         for (const a of readBoardAssets(model))
-            this.assets.set(a.id, { id: a.id, assetClassIds: a.assetClassIds, location: a.homeLocation, status: 'idle', ...(a.properties ? { properties: a.properties } : {}), ...(a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {}), ...(a.testResults ? { testResults: a.testResults } : {}), ...effectiveOf(a) });
+            this.assets.set(a.id, { id: a.id, assetClassIds: a.assetClassIds, ...(a.ratedUsage ? { ratedUsage: a.ratedUsage } : {}), ...(a.usedUsage ? { usedUsage: a.usedUsage } : {}), location: a.homeLocation, status: 'idle', ...(a.properties ? { properties: a.properties } : {}), ...(a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {}), ...(a.testResults ? { testResults: a.testResults } : {}), ...effectiveOf(a) });
     }
     /**
      * **구조를 전환한다** — 관측된 사실은 지키고 토폴로지만 새 선언으로 바꾼다.
@@ -196,7 +196,7 @@ export class ObservedReducer {
         const assetsDropped = dropMissing(this.assets, assets);
         for (const m of equipment) {
             if (!this.equipment.has(m.id))
-                this.equipment.set(m.id, { id: m.id, kind: m.kind, status: 'idle', location: m.homeLocation, homeLocation: m.homeLocation, ...(m.properties ? { properties: m.properties } : {}), ...(m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}), ...(m.testResults ? { testResults: m.testResults } : {}), ...effectiveOf(m), origin: 'master' });
+                this.equipment.set(m.id, { id: m.id, kind: m.kind, ...(m.equipmentClassIds ? { equipmentClassIds: m.equipmentClassIds } : {}), status: 'idle', location: m.homeLocation, homeLocation: m.homeLocation, ...(m.properties ? { properties: m.properties } : {}), ...(m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}), ...(m.testResults ? { testResults: m.testResults } : {}), ...effectiveOf(m), origin: 'master' });
             this.rememberShift(`eq:${m.id}`, m);
         }
         for (const p of persons) {
@@ -206,7 +206,7 @@ export class ObservedReducer {
         }
         for (const a of assets)
             if (!this.assets.has(a.id))
-                this.assets.set(a.id, { id: a.id, assetClassIds: a.assetClassIds, location: a.homeLocation, status: 'idle', ...(a.properties ? { properties: a.properties } : {}), ...(a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {}), ...(a.testResults ? { testResults: a.testResults } : {}), ...effectiveOf(a) });
+                this.assets.set(a.id, { id: a.id, assetClassIds: a.assetClassIds, ...(a.ratedUsage ? { ratedUsage: a.ratedUsage } : {}), ...(a.usedUsage ? { usedUsage: a.usedUsage } : {}), location: a.homeLocation, status: 'idle', ...(a.properties ? { properties: a.properties } : {}), ...(a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {}), ...(a.testResults ? { testResults: a.testResults } : {}), ...effectiveOf(a) });
         return { locationsAdded, locationsDropped, equipmentDropped, personsDropped, assetsDropped };
     }
     /** 마스터 동기 — 로케이션 추가/변경/제거. */
@@ -414,7 +414,8 @@ export class ObservedReducer {
                    판정은 여기서 하지 않는다 — `snapshot()` 이 관측 시각으로 `effectivityAt` 을 부른다. */
                 const eqPeriod = d.effectiveStart || d.effectiveEnd ? effectiveOf(d) : effectiveOf(known);
                 this.markHeard(d.moverId, e);
-                this.equipment.set(d.moverId, { id: d.moverId, kind: d.kind, status: d.status, location: d.location, ...(homeLocation ? { homeLocation } : {}), taskId: d.taskId, motion: d.motion, origin: known?.origin ?? 'observed', ...eqPeriod, ...(d.held ? { held: true } : {}) });
+                this.equipment.set(d.moverId, { id: d.moverId, kind: d.kind, /* 소속은 선언이라 관측이 지우지 않는다 — 이벤트가 실어 온 것이 있으면 그것, 없으면 이미 알던 것. */
+                    ...(d.equipmentClassIds ?? known?.equipmentClassIds ? { equipmentClassIds: d.equipmentClassIds ?? known?.equipmentClassIds } : {}), status: d.status, location: d.location, ...(homeLocation ? { homeLocation } : {}), taskId: d.taskId, motion: d.motion, origin: known?.origin ?? 'observed', ...eqPeriod, ...(d.held ? { held: true } : {}) });
                 break;
             }
             case OP_EVENT.person: {
@@ -471,11 +472,28 @@ export class ObservedReducer {
                 const d = e.data;
                 if (!d?.moverId)
                     break;
+                /*
+                 * **두 수가 다 있어야 받는다.** 하나라도 수가 아니면 그 줄을 버린다.
+                 *
+                 * 예전에는 그대로 놓았다. 그러면 없는 값이 계수기에 `undefined` 로 앉고, 품질률의 분모
+                 * `goodCount + nonconformingCount` 가 **NaN** 이 된다 — 그 뒤 모든 OEE 가 수가 아니게 되고
+                 * 화면은 그것을 「빈 값」으로 그린다. 어느 줄이 그랬는지는 아무도 모른다.
+                 *
+                 * 실제로 그런 줄이 있다: `scrapCount` 시절의 저널 51행(실측). vocabulary-guard: allow
+                 * 적힌 것이라 새 이름으로는 비어 있다. **읽어 주지 않는다** — 대개조 중에는 저장된 이름의
+                 * 호환을 두지 않기로 했고, 두 키가 한 사실을 가리키는 것이 낡은 이름보다 나쁘다. 대신 그
+                 * 줄을 조용히 0으로 세지 않고 **버린다**: 그 설비의 품질률은 「아직 모른다」로 남고, 다음
+                 * 산출 보고가 오면 절대 누적이 그것을 다시 채운다.
+                 *
+                 * 이 검사는 커넥터가 필드를 빼먹은 경우도 같이 잡는다.
+                 */
+                if (!Number.isFinite(d.goodCount) || !Number.isFinite(d.nonconformingCount))
+                    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;
+                c.nonconformingCount = d.nonconformingCount;
                 this.oeeCounters.set(d.moverId, c);
                 this.markHeard(d.moverId, e);
                 break;

package/dist-cjs/index.cjs

@@ -197,6 +197,34 @@ function stateFieldsOf(caps) {
   return [...out];
 }
 
+// ../ops-contract/dist/rated-usage.js
+var USE_UOM = "C62";
+var num = (n) => typeof n === "number" && Number.isFinite(n);
+function ratedUsageOf(r) {
+  const rated = r?.ratedUsage;
+  const used = r?.usedUsage;
+  const missing = [];
+  const countable = rated?.uom === USE_UOM;
+  if (!rated)
+    missing.push("not-declared");
+  else if (!num(rated.limit) || rated.limit <= 0)
+    missing.push("invalid-limit");
+  if (!used || !num(used.value))
+    missing.push("usage-unknown");
+  if (rated && used && rated.uom !== used.uom)
+    missing.push("uom-mismatch");
+  const out = {
+    ...rated ? { rated } : {},
+    ...used ? { used } : {},
+    countable,
+    missing
+  };
+  if (missing.length)
+    return out;
+  const remaining = Math.max(0, rated.limit - used.value);
+  return { ...out, remaining, exhausted: used.value >= rated.limit };
+}
+
 // ../ops-contract/dist/contract.js
 var ORDER_TERMINAL_STATUS = ["completed", "cancelled"];
 function isOrderTerminal(o) {
@@ -366,6 +394,15 @@ function classClosure(directIds, defs, at) {
   }
   return out;
 }
+function equipmentClassMembership(e) {
+  const out = [];
+  for (const id of e?.equipmentClassIds ?? [])
+    if (id && !out.includes(id))
+      out.push(id);
+  if (e?.kind && !out.includes(e.kind))
+    out.push(e.kind);
+  return out;
+}
 var PRIORITY_UNSET = Number.POSITIVE_INFINITY;
 function priorityRank(p) {
   return typeof p === "number" && Number.isFinite(p) ? p : PRIORITY_UNSET;
@@ -543,6 +580,8 @@ function capabilityOf(r, ctx) {
     return { available: false, reason: "held" };
   if (r.status === "down")
     return { available: false, reason: "down" };
+  if (ratedUsageOf(r).exhausted === true)
+    return { available: false, reason: "worn-out" };
   if (at) {
     const ms2 = parsedMs(at);
     if (Number.isFinite(ms2)) {
@@ -753,6 +792,7 @@ var ENERGY_EVENT = {
    */
   drSuggested: "energy.dr.suggested"
 };
+var MATERIAL_ACTUAL_USE = ["consumed", "produced"];
 var CMD = {
   orderHold: "order.hold",
   orderResume: "order.resume",
@@ -1535,13 +1575,23 @@ function objectUri(namespace, objId) {
 function bizTransactionUri(namespace, transId) {
   return underNamespace(namespace, "bt", transId);
 }
+var STRUCTURE_BREAKING = /[%/:?# ]/g;
+var PERCENT_ENCODED = {
+  "%": "%25",
+  "/": "%2F",
+  ":": "%3A",
+  "?": "%3F",
+  "#": "%23",
+  " ": "%20"
+};
 function underNamespace(namespace, marker, id) {
   const ns = namespace?.trim();
   if (!ns)
     return void 0;
-  const v = String(id);
-  if (!v || v.includes("/") || v.includes(":"))
+  const raw = String(id);
+  if (!raw)
     return void 0;
+  const v = raw.replace(STRUCTURE_BREAKING, (c) => PERCENT_ENCODED[c]);
   if (/^https?:\/\/[^/\s]+/.test(ns))
     return `${ns.replace(/\/+$/, "")}/${marker}/${v}`;
   if (/^urn:epc(global)?:/.test(ns))
@@ -1731,6 +1781,27 @@ var SPECS = {
       materialActual: "object[]",
       recordTime: "string"
     },
+    /*
+     * **자재 줄의 안쪽** — 계약의 `MaterialActual` 그대로다.
+     *
+     * `definitionId` 를 요구하는 이유: 이 이름이 없으면 그 줄이 무엇을 가리키는지 아무도 모른다.
+     * 실제로 `materialDefinitionId` 로 온 줄이 저널에 앉았고, 계약의 타입으로 읽으면 비어 있었다.
+     *
+     * `quantity` 를 `positive` 에 두는 이유: 「모른다」는 **비워서** 말한다. 0 으로 실으면 받는
+     * 쪽에서 「0개」와 구별되지 않고, 소요량 집계가 조용히 틀린다.
+     *
+     * `uom` 은 요구하지 않는다 — 계약에서 선택이다(§`MaterialActual`). ERP 경로는 요구하는데
+     * 그것은 **그 경로의 규칙**이다(정산에 단위 없는 수량을 쓸 수 없다). 커널이 그 규칙을 통째로
+     * 물려받으면 단위를 모르는 현장의 사실이 통째로 거절된다.
+     */
+    shapes: {
+      materialActual: {
+        required: ["definitionId", "use"],
+        fields: { definitionId: "string", lotId: "string", quantity: "number", uom: "string" },
+        enums: { use: MATERIAL_ACTUAL_USE },
+        positive: ["quantity"]
+      }
+    },
     enums: {
       status: TASK_STATUS,
       intent: ["transport", "process", "dwell"],
@@ -1842,7 +1913,7 @@ var SPECS = {
     identity: "moverId",
     // vocabulary-guard: allow 저널 와이어 필드
     /* 누적 카운터가 없으면 OEE 가 양품률을 못 센다 — 판정 하나만으로는 비율이 나오지 않는다. */
-    required: ["moverId", "good", "goodCount", "scrapCount"],
+    required: ["moverId", "good", "goodCount", "nonconformingCount"],
     // vocabulary-guard: allow
     /*
      * `taskId` 는 **귀속**이다 — 이 산출이 어느 작업의 것인가. 수량의 뜻은 바뀌지 않는다(설비 누적).
@@ -1853,7 +1924,7 @@ var SPECS = {
      * 정체를 `taskId` 로 바꾸지 않는 이유는 OEE 가 설비 단위여서다. 정체를 옮기면 설비 누적을 셀 수
      * 없어진다.
      */
-    fields: { moverId: "string", good: "boolean", goodCount: "number", scrapCount: "number", taskId: "string", recordTime: "string" }
+    fields: { moverId: "string", good: "boolean", goodCount: "number", nonconformingCount: "number", taskId: "string", recordTime: "string" }
     // vocabulary-guard: allow
   },
   /*
@@ -2090,7 +2161,7 @@ function computeOee(c, nowMs) {
     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;
+  const produced = c.goodCount + c.nonconformingCount;
   if (produced <= 0)
     missing.push("produced-quantity");
   const quality = produced > 0 ? c.goodCount / produced : void 0;
@@ -2111,7 +2182,7 @@ function computeOee(c, nowMs) {
     downMs: c.downMs,
     delayMs,
     goodCount: c.goodCount,
-    scrapCount: c.scrapCount
+    nonconformingCount: c.nonconformingCount
   };
 }
 
@@ -2352,7 +2423,7 @@ function effectiveOf(r) {
   };
 }
 function emptyOeeCounters() {
-  return { runMs: 0, setupMs: 0, downMs: 0, holdMs: 0, goodCount: 0, scrapCount: 0 };
+  return { runMs: 0, setupMs: 0, downMs: 0, holdMs: 0, goodCount: 0, nonconformingCount: 0 };
 }
 var ObservedReducer = class {
   /** 로케이션 마스터 — 출처를 함께 들고 있다(마스터가 말한 자리 vs 관측으로 알게 된 자리). */
@@ -2433,11 +2504,11 @@ var ObservedReducer = class {
     this.classDefs = { personnel: model.personnelClasses, equipment: model.equipmentClasses, asset: model.assetClasses };
     for (const sp of model.testSpecifications ?? []) this.testSpecs.set(sp.id, sp);
     for (const n of readBoardLocations(model)) this.master.set(n.id, { id: n.id, type: n.type, capacity: n.capacity, parallelism: n.parallelism, parentId: n.parentId, origin: "master" });
-    for (const m of readBoardEquipment(model)) this.equipment.set(m.id, { id: m.id, kind: m.kind, status: "idle", location: m.homeLocation, homeLocation: m.homeLocation, ...m.properties ? { properties: m.properties } : {}, ...m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}, ...m.testResults ? { testResults: m.testResults } : {}, ...effectiveOf(m), origin: "master" });
+    for (const m of readBoardEquipment(model)) this.equipment.set(m.id, { id: m.id, kind: m.kind, ...m.equipmentClassIds ? { equipmentClassIds: m.equipmentClassIds } : {}, status: "idle", location: m.homeLocation, homeLocation: m.homeLocation, ...m.properties ? { properties: m.properties } : {}, ...m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}, ...m.testResults ? { testResults: m.testResults } : {}, ...effectiveOf(m), origin: "master" });
     for (const p of model.persons ?? []) this.persons.set(p.id, { id: p.id, personnelClassIds: p.personnelClassIds, status: "idle", ...p.homeLocation ? { location: p.homeLocation } : {}, ...p.properties ? { properties: p.properties } : {}, ...p.testSpecificationIds ? { testSpecificationIds: p.testSpecificationIds } : {}, ...p.testResults ? { testResults: p.testResults } : {}, ...effectiveOf(p) });
     for (const m of readBoardEquipment(model)) this.rememberShift(`eq:${m.id}`, m);
     for (const p of model.persons ?? []) this.rememberShift(`person:${p.id}`, p);
-    for (const a of readBoardAssets(model)) this.assets.set(a.id, { id: a.id, assetClassIds: a.assetClassIds, location: a.homeLocation, status: "idle", ...a.properties ? { properties: a.properties } : {}, ...a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {}, ...a.testResults ? { testResults: a.testResults } : {}, ...effectiveOf(a) });
+    for (const a of readBoardAssets(model)) this.assets.set(a.id, { id: a.id, assetClassIds: a.assetClassIds, ...a.ratedUsage ? { ratedUsage: a.ratedUsage } : {}, ...a.usedUsage ? { usedUsage: a.usedUsage } : {}, location: a.homeLocation, status: "idle", ...a.properties ? { properties: a.properties } : {}, ...a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {}, ...a.testResults ? { testResults: a.testResults } : {}, ...effectiveOf(a) });
   }
   /**
    * **구조를 전환한다** — 관측된 사실은 지키고 토폴로지만 새 선언으로 바꾼다.
@@ -2489,7 +2560,7 @@ var ObservedReducer = class {
     const assetsDropped = dropMissing(this.assets, assets);
     for (const m of equipment) {
       if (!this.equipment.has(m.id))
-        this.equipment.set(m.id, { id: m.id, kind: m.kind, status: "idle", location: m.homeLocation, homeLocation: m.homeLocation, ...m.properties ? { properties: m.properties } : {}, ...m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}, ...m.testResults ? { testResults: m.testResults } : {}, ...effectiveOf(m), origin: "master" });
+        this.equipment.set(m.id, { id: m.id, kind: m.kind, ...m.equipmentClassIds ? { equipmentClassIds: m.equipmentClassIds } : {}, status: "idle", location: m.homeLocation, homeLocation: m.homeLocation, ...m.properties ? { properties: m.properties } : {}, ...m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}, ...m.testResults ? { testResults: m.testResults } : {}, ...effectiveOf(m), origin: "master" });
       this.rememberShift(`eq:${m.id}`, m);
     }
     for (const p of persons) {
@@ -2499,7 +2570,7 @@ var ObservedReducer = class {
     }
     for (const a of assets)
       if (!this.assets.has(a.id))
-        this.assets.set(a.id, { id: a.id, assetClassIds: a.assetClassIds, location: a.homeLocation, status: "idle", ...a.properties ? { properties: a.properties } : {}, ...a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {}, ...a.testResults ? { testResults: a.testResults } : {}, ...effectiveOf(a) });
+        this.assets.set(a.id, { id: a.id, assetClassIds: a.assetClassIds, ...a.ratedUsage ? { ratedUsage: a.ratedUsage } : {}, ...a.usedUsage ? { usedUsage: a.usedUsage } : {}, location: a.homeLocation, status: "idle", ...a.properties ? { properties: a.properties } : {}, ...a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {}, ...a.testResults ? { testResults: a.testResults } : {}, ...effectiveOf(a) });
     return { locationsAdded, locationsDropped, equipmentDropped, personsDropped, assetsDropped };
   }
   /** 마스터 동기 — 로케이션 추가/변경/제거. */
@@ -2662,7 +2733,20 @@ var ObservedReducer = class {
         const homeLocation = d.homeLocation ?? known?.homeLocation;
         const eqPeriod = d.effectiveStart || d.effectiveEnd ? effectiveOf(d) : effectiveOf(known);
         this.markHeard(d.moverId, e);
-        this.equipment.set(d.moverId, { id: d.moverId, kind: d.kind, status: d.status, location: d.location, ...homeLocation ? { homeLocation } : {}, taskId: d.taskId, motion: d.motion, origin: known?.origin ?? "observed", ...eqPeriod, ...d.held ? { held: true } : {} });
+        this.equipment.set(d.moverId, {
+          id: d.moverId,
+          kind: d.kind,
+          /* 소속은 선언이라 관측이 지우지 않는다 — 이벤트가 실어 온 것이 있으면 그것, 없으면 이미 알던 것. */
+          ...d.equipmentClassIds ?? known?.equipmentClassIds ? { equipmentClassIds: d.equipmentClassIds ?? known?.equipmentClassIds } : {},
+          status: d.status,
+          location: d.location,
+          ...homeLocation ? { homeLocation } : {},
+          taskId: d.taskId,
+          motion: d.motion,
+          origin: known?.origin ?? "observed",
+          ...eqPeriod,
+          ...d.held ? { held: true } : {}
+        });
         break;
       }
       case OP_EVENT.person: {
@@ -2704,10 +2788,11 @@ var ObservedReducer = class {
       case OP_EVENT.quality: {
         const d = e.data;
         if (!d?.moverId) break;
+        if (!Number.isFinite(d.goodCount) || !Number.isFinite(d.nonconformingCount)) 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;
+        c.nonconformingCount = d.nonconformingCount;
         this.oeeCounters.set(d.moverId, c);
         this.markHeard(d.moverId, e);
         break;
@@ -3513,11 +3598,11 @@ function deriveAttentions(view, acked, nowIso, thresholds) {
     }
   }
   for (const m of view.equipment) {
-    const total = (m.goodCount ?? 0) + (m.scrapCount ?? 0);
+    const total = (m.goodCount ?? 0) + (m.nonconformingCount ?? 0);
     const declaredMin = thresholds?.scrapMinSamplesOf?.(m.id);
     const minSamples = declaredMin ?? ATTENTION_DEFAULTS.scrapMinSamples;
     if (total >= minSamples) {
-      const rate = (m.scrapCount ?? 0) / total;
+      const rate = (m.nonconformingCount ?? 0) / total;
       const declaredPct = thresholds?.scrapPctOf?.(m.id);
       const thresholdPct = declaredPct ?? ATTENTION_DEFAULTS.scrapPct;
       if (rate * 100 >= thresholdPct) out.push({
@@ -3528,7 +3613,7 @@ function deriveAttentions(view, acked, nowIso, thresholds) {
         params: {
           moverId: m.id,
           goodCount: m.goodCount ?? 0,
-          scrapCount: m.scrapCount ?? 0,
+          nonconformingCount: m.nonconformingCount ?? 0,
           ratePct: Math.round(rate * 100),
           thresholdPct,
           basis: declaredPct === void 0 ? "default" : "declared"
@@ -3983,6 +4068,8 @@ var FlowEngine = class {
     return {
       id: a.id,
       assetClassIds: a.assetClassIds,
+      ...a.ratedUsage ? { ratedUsage: a.ratedUsage } : {},
+      ...a.usedUsage ? { usedUsage: a.usedUsage } : {},
       location: a.homeLocation,
       status: "idle",
       taskId: null,
@@ -4056,7 +4143,7 @@ var FlowEngine = class {
     };
   }
   buildEquipment(m) {
-    const eq = { id: m.id, kind: m.kind, location: m.homeLocation, homeLocation: m.homeLocation, ...m.properties ? { properties: m.properties } : {}, ...m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}, ...m.testResults ? { testResults: m.testResults } : {}, status: "idle", taskId: null, runMs: 0, setupMs: 0, downMs: 0, goodCount: 0, scrapCount: 0, metricsSinceMs: this.clockMs, window: m.window, ...m.workCalendar ? { workCalendar: m.workCalendar } : {}, ...effectiveOnly(m) };
+    const eq = { id: m.id, kind: m.kind, ...m.equipmentClassIds ? { equipmentClassIds: m.equipmentClassIds } : {}, location: m.homeLocation, homeLocation: m.homeLocation, ...m.properties ? { properties: m.properties } : {}, ...m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}, ...m.testResults ? { testResults: m.testResults } : {}, status: "idle", taskId: null, runMs: 0, setupMs: 0, downMs: 0, goodCount: 0, nonconformingCount: 0, metricsSinceMs: this.clockMs, window: m.window, ...m.workCalendar ? { workCalendar: m.workCalendar } : {}, ...effectiveOnly(m) };
     if (m.mtbfMs !== void 0) {
       eq.mtbfMs = m.mtbfMs;
       eq.mttrMs = m.mttrMs;
@@ -4070,7 +4157,7 @@ var FlowEngine = class {
    */
   addEquipment(m) {
     if (this.equipment.has(m.id)) return;
-    const eq = { id: m.id, kind: m.kind, location: m.homeLocation, homeLocation: m.homeLocation, ...m.properties ? { properties: m.properties } : {}, ...m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}, ...m.testResults ? { testResults: m.testResults } : {}, status: "idle", taskId: null, runMs: 0, setupMs: 0, downMs: 0, goodCount: 0, scrapCount: 0, metricsSinceMs: this.clockMs };
+    const eq = { id: m.id, kind: m.kind, ...m.equipmentClassIds ? { equipmentClassIds: m.equipmentClassIds } : {}, location: m.homeLocation, homeLocation: m.homeLocation, ...m.properties ? { properties: m.properties } : {}, ...m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}, ...m.testResults ? { testResults: m.testResults } : {}, status: "idle", taskId: null, runMs: 0, setupMs: 0, downMs: 0, goodCount: 0, nonconformingCount: 0, metricsSinceMs: this.clockMs };
     if (m.mtbfMs !== void 0) {
       eq.mtbfMs = m.mtbfMs;
       eq.mttrMs = m.mttrMs;
@@ -4166,8 +4253,10 @@ var FlowEngine = class {
     for (const m of snap.equipment) {
       const oee = m.oee;
       const prev = this.equipment.get(m.id);
+      const classIds = prev?.equipmentClassIds ?? m.equipmentClassIds;
       this.equipment.set(m.id, {
         ...prev ?? {},
+        ...classIds ? { equipmentClassIds: classIds } : {},
         /*
          * `taskId` — **관측이면 원본이 말한 값이다.**
          *
@@ -4186,7 +4275,7 @@ var FlowEngine = class {
         setupMs: oee?.setupMs ?? 0,
         downMs: oee?.downMs ?? 0,
         goodCount: oee?.goodCount ?? 0,
-        scrapCount: oee?.scrapCount ?? 0,
+        nonconformingCount: oee?.nonconformingCount ?? 0,
         /*
          * **잰 값을 이어받으면 잰 구간도 이어받아야 한다.**
          *
@@ -4255,6 +4344,10 @@ var FlowEngine = class {
         /* 설비·사람과 같은 규율 — 관측이면 원본이 말한 상태·묶임을 지킨다. */
         id: a.id,
         assetClassIds: a.assetClassIds ?? prev?.assetClassIds,
+        /* 정격은 선언이라 마스터가 이긴다. 쓴 양은 **관측이 이긴다** — 원천이 센 값이 우리 추정보다
+           참이고, 되살릴 때 우리 것을 쓰면 그 사이 실제로 쓴 만큼이 사라진다. */
+        ...prev?.ratedUsage ?? a.ratedUsage ? { ratedUsage: prev?.ratedUsage ?? a.ratedUsage } : {},
+        ...a.usedUsage ?? prev?.usedUsage ? { usedUsage: a.usedUsage ?? prev?.usedUsage } : {},
         location: a.location,
         status: purpose === "observe" ? a.status ?? "idle" : "idle",
         taskId: purpose === "observe" ? a.taskId ?? null : null,
@@ -4542,7 +4635,7 @@ var FlowEngine = class {
         m.setupMs = 0;
         m.downMs = 0;
         m.goodCount = 0;
-        m.scrapCount = 0;
+        m.nonconformingCount = 0;
         m.holdMs = 0;
         m.metricsSinceMs = this.clockMs;
         this.emitEquipment(m);
@@ -4638,14 +4731,14 @@ var FlowEngine = class {
       }),
       items: [...this.items.values()].map((i) => this.itemState(i)),
       equipment: [...this.equipment.values()].map((m) => {
-        const s = { id: m.id, kind: m.kind, location: m.location, ...m.homeLocation ? { homeLocation: m.homeLocation } : {}, status: m.status, taskId: m.taskId ?? void 0, oee: this.oeeOf(m), held: m.held, ...m.properties ? { properties: m.properties } : {}, ...m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}, ...m.testResults ? { testResults: m.testResults } : {}, capability: this.capabilityOfResource(m, m.kind ? [m.kind] : [], this.classDefs.equipment), origin: "master", ...this.offShift(m) ? { offShift: true, ...this.offReason(m) } : {}, ...this.effectivePart(m), ...this.shiftOf(m) ? { shift: this.shiftOf(m) } : {}, ...energyFieldsOf(m) };
+        const s = { id: m.id, kind: m.kind, ...m.equipmentClassIds ? { equipmentClassIds: m.equipmentClassIds } : {}, location: m.location, ...m.homeLocation ? { homeLocation: m.homeLocation } : {}, status: m.status, taskId: m.taskId ?? void 0, oee: this.oeeOf(m), held: m.held, ...m.properties ? { properties: m.properties } : {}, ...m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}, ...m.testResults ? { testResults: m.testResults } : {}, capability: this.capabilityOfResource(m, equipmentClassMembership(m), this.classDefs.equipment), origin: "master", ...this.offShift(m) ? { offShift: true, ...this.offReason(m) } : {}, ...this.effectivePart(m), ...this.shiftOf(m) ? { shift: this.shiftOf(m) } : {}, ...energyFieldsOf(m) };
         const t = m.taskId ? this.tasks.get(m.taskId) : void 0;
         const motionProgress = t && t.status === "in-progress" && t.intent !== "process" ? this.progressOf(t) : void 0;
         if (t && motionProgress !== void 0) s.motion = { fromNode: t.fromNode, toNode: t.toNode, startedAtSimMs: this.clockMs - (t.durationMs - t.remainingMs), durationMs: t.durationMs, progress: motionProgress, elapsedMs: t.durationMs - t.remainingMs };
         return s;
       }),
       assets: [...this.assets.values()].map((a) => {
-        const st = { id: a.id, assetClassIds: a.assetClassIds, location: a.location, status: a.status, taskId: a.taskId ?? void 0 };
+        const st = { id: a.id, assetClassIds: a.assetClassIds, ...a.ratedUsage ? { ratedUsage: a.ratedUsage } : {}, ...a.usedUsage ? { usedUsage: a.usedUsage } : {}, location: a.location, status: a.status, taskId: a.taskId ?? void 0 };
         if (a.carrying) st.carrying = a.carrying;
         if (a.properties) st.properties = a.properties;
         if (a.testSpecificationIds) st.testSpecificationIds = a.testSpecificationIds;
@@ -5220,7 +5313,7 @@ var FlowEngine = class {
     const calendar = calendars.size === 1 ? [...calendars.values()][0] : void 0;
     const at = opts.window.fromTime;
     const usableEquipment = [...this.equipment.values()].filter(
-      (m) => this.capabilityOfResource(m, m.kind ? [m.kind] : [], this.classDefs.equipment, at).available
+      (m) => this.capabilityOfResource(m, equipmentClassMembership(m), this.classDefs.equipment, at).available
     );
     const usablePersons = [...this.persons.values()].filter(
       (p) => this.capabilityOfResource(p, p.personnelClassIds, this.classDefs.personnel, at).available
@@ -5581,8 +5674,8 @@ var FlowEngine = class {
     const m = moverId ? this.equipment.get(moverId) : void 0;
     if (!m) return;
     if (good) m.goodCount++;
-    else m.scrapCount++;
-    this.emitOp(OP_EVENT.quality, { moverId: m.id, good, goodCount: m.goodCount, scrapCount: m.scrapCount });
+    else m.nonconformingCount++;
+    this.emitOp(OP_EVENT.quality, { moverId: m.id, good, goodCount: m.goodCount, nonconformingCount: m.nonconformingCount });
   }
   /** 설비 OEE(스냅샷 파생) — Availability×Performance×Quality. planned = 설비 존재 sim 시간(clockMs). */
   oeeOf(m) {
@@ -5657,7 +5750,50 @@ var FlowEngine = class {
   subjectOf(kind, localId) {
     return resolveSubject(kind, localId, { tenantId: this.tenantId, scopeId: this.scopeId, identityOf: (k, id) => k === "equipment" ? this.equipmentIdentity(id) : void 0 });
   }
-  emitOp(eventType, data) {
+  /**
+   * 운영 델타 방출 — **같은 사실을 다시 적지 않는다.**
+   *
+   * ── 무엇이 있었나 (2026-09-05 실측) ────────────────────────────────────────
+   * `flow-engine.ts` 의 배정 패스가 **매 틱** `created` 인 오더 전부에 `allocate` 를 건다. 자재가
+   * 모자란 오더는 그때마다 `mes-kernel` 의 「모자람을 적고 다음 틱에 다시 본다」 줄에 닿았고, 거기서
+   * **바뀐 것이 없어도 방출**했다.
+   *
+   *   hatio-mx2   오더 315개 → 세 시간에 order.status 2,433,116건 (오더당 7,700)
+   *   다른 트윈    오더당 1~2건
+   *   틱 로그      「journal 706.92ms(88%)」
+   *
+   * 다시 보는 것은 옳다(모자람은 채워질 수 있다). **다시 볼 때마다 적는 것**이 결함이다.
+   *
+   * ── 파급이 디스크가 아니다 ─────────────────────────────────────────────────
+   *   재기동      저널을 접어 상태를 세운다 — 되세우는 시간이 그만큼 는다
+   *   구독        이 사건들은 방송된다. 막힌 오더 × 매 틱 × 구독자 수
+   *   틱          시뮬 틱은 메인 이벤트 루프에서 돈다 — HTTP·구독이 함께 느려진다
+   *   지표        오더 사건을 세는 모든 것이 부푼다
+   *   진짜 문제   「오더가 자재를 못 구해 멈췄다」가 자기가 만든 소음에 묻힌다
+   *
+   * 가장 나쁜 것은 방향이다. **현장이 막힐수록 트윈이 더 무너진다** — 잘 흐르면 사건이 적고 막히면
+   * 폭증한다. 트윈이 가장 필요한 순간에 가장 약해진다.
+   *
+   * ── 왜 여기인가 ────────────────────────────────────────────────────────────
+   * 부르는 자리 하나를 막으면 다른 자리에서 같은 일이 난다 — `emitOrder` 를 부르는 곳만 열다섯이다.
+   * 그리고 `revision` 이 여기서 오르므로, 여기서 막지 않으면 **적지 않고도 판만 올라간다.**
+   *
+   * ── 무엇을 같다고 보나 ─────────────────────────────────────────────────────
+   * `data` 가 바이트까지 같으면 같다. 시각은 `data` 에 없다(여기서 붙인다) — 그래서 「같은 사실을
+   * 다른 시각에 다시 말한 것」이 정확히 걸러진다.
+   *
+   * `subject` 를 안 주면 거르지 않는다. 대상이 없는 사건(주의 등)은 반복 자체가 사실이다.
+   *
+   * 재기동하면 이 기억이 비므로 **첫 방출은 언제나 나간다** — 되세운 상태가 조용히 빠지지 않는다.
+   */
+  lastEmitted = /* @__PURE__ */ new Map();
+  emitOp(eventType, data, subject) {
+    if (subject !== void 0) {
+      const key = `${eventType}\0${subject}`;
+      const json = JSON.stringify(data);
+      if (this.lastEmitted.get(key) === json) return;
+      this.lastEmitted.set(key, json);
+    }
     this.revision++;
     const e = { eventId: `${this.tenantId}-evt-${++this.eventSeq}`, eventType, eventTime: this.now(), tenantId: this.tenantId, ...this._correlationId ? { correlationId: this._correlationId } : {}, data };
     for (const h of this.handlers) h(e);
@@ -5694,19 +5830,19 @@ var FlowEngine = class {
       ...t.startTime ? { startTime: t.startTime } : {},
       ...t.endTime ? { endTime: t.endTime } : {},
       ...inProgress ? { remainingMs: t.remainingMs, startedAtSimMs: t.startedAtSimMs, progress: t.durationMs ? done / t.durationMs : void 0 } : {}
-    });
+    }, t.id);
   }
   /** 사람 상태 전이 — 설비와 별개 채널(어휘가 다르다: 고장이 아니라 교대·투입). */
   emitAsset(a) {
-    this.emitOp(OP_EVENT.asset, { assetId: a.id, assetClassIds: a.assetClassIds, status: a.status, location: a.location, taskId: a.taskId ?? void 0, carrying: a.carrying, ...effectiveOnly(a) });
+    this.emitOp(OP_EVENT.asset, { assetId: a.id, assetClassIds: a.assetClassIds, ...a.ratedUsage ? { ratedUsage: a.ratedUsage } : {}, ...a.usedUsage ? { usedUsage: a.usedUsage } : {}, status: a.status, location: a.location, taskId: a.taskId ?? void 0, carrying: a.carrying, ...effectiveOnly(a) }, a.id);
   }
   emitPerson(p) {
-    this.emitOp(OP_EVENT.person, { personId: p.id, personnelClassIds: p.personnelClassIds, status: p.status, taskId: p.taskId ?? void 0, ...p.location ? { location: p.location } : {}, ...effectiveOnly(p) });
+    this.emitOp(OP_EVENT.person, { personId: p.id, personnelClassIds: p.personnelClassIds, status: p.status, taskId: p.taskId ?? void 0, ...p.location ? { location: p.location } : {}, ...effectiveOnly(p) }, p.id);
   }
   /** 설비 상태 전이 — `taskId` 를 함께 싣는다(사람·자산 델타와 같은 규칙). 없으면 미러가 "이 설비가
    *  무슨 일을 하는 중인가" 를 알 수 없어 작업↔자원 연결이 한쪽에서만 성립한다. */
   emitEquipment(m, motion) {
-    this.emitOp(OP_EVENT.equipment, { moverId: m.id, kind: m.kind, status: m.status, location: m.location, ...m.homeLocation ? { homeLocation: m.homeLocation } : {}, taskId: m.taskId ?? void 0, motion, ...m.held ? { held: true } : {}, ...effectiveOnly(m) });
+    this.emitOp(OP_EVENT.equipment, { moverId: m.id, kind: m.kind, ...m.equipmentClassIds ? { equipmentClassIds: m.equipmentClassIds } : {}, status: m.status, location: m.location, ...m.homeLocation ? { homeLocation: m.homeLocation } : {}, taskId: m.taskId ?? void 0, motion, ...m.held ? { held: true } : {}, ...effectiveOnly(m) }, m.id);
   }
   /** 오더 델타 — **라인까지 싣는다.** 라인이 빠지면 미러가 남은 데맨드를 라인별로 재계획할 수 없다. */
   emitOrder(o) {
@@ -5732,7 +5868,7 @@ var FlowEngine = class {
       /* 약속해 둔 자리·시각창 — 이것이 빠져서 야드 트윈이 재기동마다 첫 틱에 죽었다(§dockDoor). */
       ...o.dockDoor ? { dockDoor: o.dockDoor } : {},
       ...o.windowStartMs !== void 0 ? { windowStartMs: o.windowStartMs } : {}
-    });
+    }, o.id);
   }
   // ── 내부 mechanics ─────────────────────────────────────────────────────────
   /**
@@ -5829,10 +5965,36 @@ var FlowEngine = class {
    * 작업이 끝나면 자산을 놓아 준다 — **사람과 다른 점: 자산은 도착 자리에 남는다**(물건이므로).
    * 싣고 있던 것은 놓는다(빈 팔레트로 돌아간다 — 회수·재사용의 출발점).
    */
+  /**
+   * 이 자산을 **한 번 썼다**고 센다 — 작업이 자산을 놓을 때.
+   *
+   * ── 셀 수 있는 것만 센다 ────────────────────────────────────────────────
+   * 정격이 「번」(`USE_UOM`)이면 작업 하나가 곧 한 번이다. 그러면 올릴 수 있다.
+   *
+   * **정격이 「미터」면 올리지 않는다.** 그 작업이 몇 미터를 깎았는지는 공정이 말해 줘야 하는
+   * 사실이고, 커널이 「한 번이니 1미터」로 놓으면 그것은 지어낸 값이다. 라우터 비트가 50미터
+   * 정격인데 한 번에 0.2미터를 깎는다면, 1로 세는 순간 실제 수명의 250분의 1에서 교체하라고
+   * 말하게 된다.
+   *
+   * 정격을 선언하지 않은 자산도 세지 않는다. 셀 이유가 없고(견줄 것이 없다), 세면 화면에 「쓴
+   * 양은 있는데 정격은 없다」는 반쪽 사실이 생긴다.
+   *
+   * ── 미러에서는 부르지 않는다 ────────────────────────────────────────────
+   * 이 함수는 시뮬레이션이 자기 우주에서 세는 것이다. 미러의 쓴 양은 **원천이 센 값**이고
+   * (`AssetStatusDelta.usedUsage`), 우리가 거기에 더하면 같은 사용을 두 번 센다.
+   */
+  countOneUse(a) {
+    const rated = a.ratedUsage;
+    if (!rated || rated.uom !== USE_UOM) return;
+    const prev = a.usedUsage;
+    if (prev && prev.uom !== USE_UOM) return;
+    a.usedUsage = { value: (prev?.value ?? 0) + 1, uom: USE_UOM, ...prev?.since ? { since: prev.since } : {} };
+  }
   releaseAssets(t) {
     for (const id of t.assets ?? []) {
       const a = this.assets.get(id);
       if (!a) continue;
+      this.countOneUse(a);
       a.status = "idle";
       a.taskId = null;
       a.location = t.toNode || a.location;
@@ -6290,10 +6452,10 @@ var FlowEngine = class {
       (m) => (
         /* 사람과 **같은 판정**(§capabilityOfResource) — 예전에는 이 자리에 조건을 늘어놓아서
            설비의 검사 결과는 배정에서 아예 읽히지 않았다(사람만 자격을 봤다). */
-        this.capabilityOfResource(m, m.kind ? [m.kind] : [], this.classDefs.equipment).available && !picked2.includes(m.id) && /* 설비의 소속은 아직 단수(`kind`)다 — 저널에 기록이 쌓여 복수화를 별도 작업으로 두었다.
-           다만 등급 정의가 있으면 **상속은 지금도 탄다**: 'welder-6axis' 가 'welder' 를 상속하면
-           'welder' 요구를 만족한다. 단수/복수와 상속은 다른 축이므로 하나를 기다리지 않는다. */
-        (kind === void 0 || classClosure(m.kind ? [m.kind] : [], this.classDefs.equipment, this.now()).has(kind))
+        this.capabilityOfResource(m, equipmentClassMembership(m), this.classDefs.equipment).available && !picked2.includes(m.id) && /* 소속은 **선언한 등급들과 `kind` 를 합친 것**이다(§equipmentClassMembership). 상속도 탄다:
+           'welder-6axis' 가 'welder' 를 상속하면 'welder' 요구를 만족한다. 예전에는 이 자리가
+           `kind` 하나만 봤고, 그래서 `equipmentClasses` 정의표를 아무도 가리킬 수 없었다. */
+        (kind === void 0 || classClosure(equipmentClassMembership(m), this.classDefs.equipment, this.now()).has(kind))
       )
     );
     const need = this.operationSpecs.get(t.kind)?.equipmentSpecification;
@@ -6592,8 +6754,13 @@ var FlowEngine = class {
       this.assignAssets(t, gear);
       this.consumeMaterials(t, stock);
       this.emitTask(t);
-      if (t.intent === "process") this.emitEquipment(eq);
-      else this.emitEquipment(eq, { fromNode: t.fromNode, toNode: t.toNode, startedAtSimMs: this.clockMs, durationMs: t.durationMs, progress: 0, elapsedMs: 0 });
+      const motion = t.intent === "process" ? void 0 : { fromNode: t.fromNode, toNode: t.toNode, startedAtSimMs: this.clockMs, durationMs: t.durationMs, progress: 0, elapsedMs: 0 };
+      this.emitEquipment(eq, motion);
+      for (const id of rigs) {
+        if (id === eq.id) continue;
+        const m = this.equipment.get(id);
+        if (m) this.emitEquipment(m, motion);
+      }
     }
   }
   /** in-progress 진행/완료 — 상태 효과는 전부 도메인(onTaskComplete). base 는 자원 해제·델타만. */

package/package.json

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