@operato/twin-kernel 0.11.23 → 0.11.25

package/dist/flow-engine.d.ts

@@ -4,6 +4,7 @@ import type { VocabularyElement } from '@operato/ops-contract';
 import type { ReducerCheckpoint } from './observed-reducer.ts';
 import type { EpcisEvent, BizTransactionElement } from '@operato/ops-contract';
 import type { AllocationPolicy, SlotView } from './allocation-policy.ts';
+import { type FoldedOrders, type OrderFoldPolicy } from '@operato/ops-contract';
 import type { DurationEstimator, DurationContext } from './duration-estimator.ts';
 import type { OperationDef, IsoDuration, OpMaterialSpecification } from '@operato/ops-contract';
 import { type CapacityAnalysis } from '@operato/ops-contract';
@@ -290,6 +291,8 @@ export interface FlowOrder {
     picked: string[];
     gtin?: string;
     shipmentEpc?: string | null;
+    /** 언제 끝났나(ms) — 끝났다고 사건을 낸 시각. 끝난 오더를 접는 경계가 이 값으로 잰다(ADR-0092). */
+    terminalAtMs?: number;
     lines?: OrderLine[];
     held?: boolean;
     dockDoor?: string;
@@ -500,6 +503,9 @@ export declare class ItemStore {
      * 사라진다**(있는데 없다고 판정된다). 자리 색인과 같은 규율이다.
      */
     private byGtin;
+    /** 같은 글자를 매번 뜯지 않는다 — 클래스 글자의 종류는 적고 물품은 많다. */
+    private itemClassCache;
+    private itemClass;
     get size(): number;
     get(key: string): FlowItem | undefined;
     has(key: string): boolean;
@@ -565,6 +571,10 @@ export declare abstract class FlowEngine implements TwinKernel {
     assets: Map<string, FlowAsset>;
     tasks: Map<string, FlowTask>;
     orders: Map<string, FlowOrder>;
+    /** 접힌 오더(ADR-0092) — 세는 수와 경계만 든다. 미러는 리듀서가 들고 이것은 옮겨 받는다(§`hydrateObserved`). */
+    protected foldedOrders: FoldedOrders;
+    /** 끝난 오더를 언제 접나 — 모델의 `orderFold` 선언. 없으면 기본(24시간 · 1,000건). */
+    protected orderFoldPolicy: OrderFoldPolicy;
     revision: number;
     clockMs: number;
     /**
@@ -630,6 +640,16 @@ export declare abstract class FlowEngine implements TwinKernel {
      *
      * 관측 구동이 아니면 `undefined` — 시뮬은 리듀서를 갖지 않는다(저장할 것이 없다).
      */
+    /**
+     * **끝난 오더를 접는다**(ADR-0092) — 접은 수를 돌려준다.
+     *
+     * 부르는 것은 호스트다 — 체크포인트(미러는 `observedCheckpoint`, 시뮬은 상태 스냅샷)를 쓰기 직전에 부른다. 그래야
+     * 접힌 쪽이 씨앗과 같은 때에 적힌다. 커널이 스스로 접지 않는 것은, 접힌 목록을 읽는 쪽(예측 · 화면)이 그 뜻에
+     * 맞춰진 뒤에 호스트가 부르게 하려는 것이다.
+     *
+     * 미러는 원천인 리듀서에서 접고 옮겨 받는다 — 이 목록에서만 지우면 다음 옮김이 되살린다.
+     */
+    foldFinishedOrders(nowMs?: number): number;
     observedCheckpoint(): ReducerCheckpoint | undefined;
     /**
      * **재개점에서 관측 리듀서를 되세운다** — 저널을 0부터 다시 집계하지 않게.
@@ -834,6 +854,8 @@ export declare abstract class FlowEngine implements TwinKernel {
         assets?: AssetState[];
         tasks?: TaskState[];
         orders?: OrderState[];
+        /** 접힌 오더(ADR-0092) — 세는 수와 경계. 이어받지 않으면 재기동 · fork 뒤에 끝난 오더의 수를 잃는다. */
+        foldedOrders?: FoldedOrders;
         /** 확인해 둔 주목 신호 id — 계산으로 되살릴 수 없어 스냅샷에서 이어받는다. */
         acked?: string[];
         /** 주목 신호가 처음 성립한 시각 — 이어받지 않으면 지속된 조건이 「방금」으로 되살아난다. */

package/dist/flow-engine.js

@@ -10,13 +10,14 @@
  * (roadmap Phase5 발견 → 추출. [[project_flow_single_base_vision]] FlowLocation 단일 base 방향과 정합.)
  */
 import { isWorkShiftExecutionBasis } 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 { OP_EVENT, CMD, USE_UOM, locationStatusOf, readBoardEquipment, equipmentClassMembership, readBoardLocations, readBoardAssets, classClosure, capabilityOf, requiredTestsFor, priorityRank, dueStatusOf, isOrderTerminal, effectivityAt, offCalendarAt, offCalendarReasonAt, minuteOfDayAt, activeShiftAt, subLotIdOf, itemKeyOf, itemClassOf, identityGroundingOf, outsideLimit, computeOee } from '@operato/ops-contract';
 import { ObservedReducer } from "./observed-reducer.js";
 /* 주체를 정하는 규칙은 유입 문과 한 벌이다 — 두 곳에 적으면 한쪽만 고쳐진다. */
 import { resolveSubject } from '@operato/ops-contract';
 import { WMS_ORDER_KIND } from '@operato/ops-contract';
 import { transformationEvent, aggregationEvent, objectEvent, parseEpc, DISP, ILMD_ATTR, CBV_BIZSTEP, objectUri, bizTransactionUri, gdtiUri } from '@operato/ops-contract';
 import { allocationPolicyOf } from "./allocation-policy.js";
+import { ORDER_FOLD_DEFAULT, emptyFoldedOrders, foldOrdersInto, foldedOrderCount, orderFoldPolicyOf, planOrderFold } from '@operato/ops-contract';
 import { OP_PARAM } from '@operato/ops-contract';
 import { parseIsoDuration } from '@operato/ops-contract';
 import { analyzeCapacity } from '@operato/ops-contract';
@@ -407,7 +408,21 @@ export class ItemStore {
      * 색인을 밖에 따로 두지 않는다 — 갱신하는 자리가 흩어지면 한 자리라도 빠뜨렸을 때 **재고가 조용히
      * 사라진다**(있는데 없다고 판정된다). 자리 색인과 같은 규율이다.
      */
+    /*
+     * 품목 색인 — 키는 **품목 클래스**다(`itemClassOf`). 재고는 로트 클래스를 들고 오더는 품목 클래스를 묻는다
+     * (ADR-0076 ⑥ · ADR-0082 결정 2). 로트 글자를 키로 쓰면 품목을 물어도 로트 재고가 안 나온다.
+     */
     byGtin = new Map();
+    /** 같은 글자를 매번 뜯지 않는다 — 클래스 글자의 종류는 적고 물품은 많다. */
+    itemClassCache = new Map();
+    itemClass(gtin) {
+        let c = this.itemClassCache.get(gtin);
+        if (c === undefined) {
+            c = itemClassOf(gtin) ?? gtin;
+            this.itemClassCache.set(gtin, c);
+        }
+        return c;
+    }
     get size() {
         return this.map.size;
     }
@@ -515,7 +530,7 @@ export class ItemStore {
     }
     /** 그 품목인 물품들 — 색인이 답한다(자리를 모를 때 쓴다). */
     ofGtin(gtin) {
-        const keys = this.byGtin.get(gtin);
+        const keys = this.byGtin.get(this.itemClass(gtin));
         if (!keys)
             return [];
         const out = [];
@@ -549,7 +564,7 @@ export class ItemStore {
         }
         /* 품목 색인도 같은 규율로 본다 — 어긋나면 자재가 있는데 없다고 판정된다. */
         for (const [key, it] of this.map) {
-            if (it.gtin && !this.byGtin.get(it.gtin)?.has(key))
+            if (it.gtin && !this.byGtin.get(this.itemClass(it.gtin))?.has(key))
                 drift.push(`${key} 이 품목 '${it.gtin}' 색인에 없다`);
         }
         for (const [g, keys] of this.byGtin) {
@@ -557,7 +572,7 @@ export class ItemStore {
                 const it = this.map.get(k);
                 if (!it)
                     drift.push(`${k} 이 지워졌는데 품목 '${g}' 색인에 남아 있다`);
-                else if (it.gtin !== g)
+                else if (this.itemClass(it.gtin ?? '') !== g)
                     drift.push(`${k} 은 품목 '${it.gtin}' 인데 '${g}' 색인에 있다`);
             }
         }
@@ -566,9 +581,10 @@ export class ItemStore {
     index(key, location, gtin) {
         this.indexLocation(key, location);
         if (gtin) {
-            const set = this.byGtin.get(gtin) ?? new Set();
+            const g = this.itemClass(gtin);
+            const set = this.byGtin.get(g) ?? new Set();
             set.add(key);
-            this.byGtin.set(gtin, set);
+            this.byGtin.set(g, set);
         }
     }
     indexLocation(key, location) {
@@ -579,12 +595,13 @@ export class ItemStore {
     unindex(key, location, gtin) {
         this.unindexLocation(key, location);
         if (gtin) {
-            const set = this.byGtin.get(gtin);
+            const g = this.itemClass(gtin);
+            const set = this.byGtin.get(g);
             if (!set)
                 return;
             set.delete(key);
             if (!set.size)
-                this.byGtin.delete(gtin);
+                this.byGtin.delete(g);
         }
     }
     unindexLocation(key, location) {
@@ -614,6 +631,10 @@ export class FlowEngine {
     assets = new Map();
     tasks = new Map();
     orders = new Map();
+    /** 접힌 오더(ADR-0092) — 세는 수와 경계만 든다. 미러는 리듀서가 들고 이것은 옮겨 받는다(§`hydrateObserved`). */
+    foldedOrders = emptyFoldedOrders();
+    /** 끝난 오더를 언제 접나 — 모델의 `orderFold` 선언. 없으면 기본(24시간 · 1,000건). */
+    orderFoldPolicy = ORDER_FOLD_DEFAULT;
     revision = 0;
     clockMs = 0;
     /**
@@ -679,6 +700,33 @@ export class FlowEngine {
      *
      * 관측 구동이 아니면 `undefined` — 시뮬은 리듀서를 갖지 않는다(저장할 것이 없다).
      */
+    /**
+     * **끝난 오더를 접는다**(ADR-0092) — 접은 수를 돌려준다.
+     *
+     * 부르는 것은 호스트다 — 체크포인트(미러는 `observedCheckpoint`, 시뮬은 상태 스냅샷)를 쓰기 직전에 부른다. 그래야
+     * 접힌 쪽이 씨앗과 같은 때에 적힌다. 커널이 스스로 접지 않는 것은, 접힌 목록을 읽는 쪽(예측 · 화면)이 그 뜻에
+     * 맞춰진 뒤에 호스트가 부르게 하려는 것이다.
+     *
+     * 미러는 원천인 리듀서에서 접고 옮겨 받는다 — 이 목록에서만 지우면 다음 옮김이 되살린다.
+     */
+    foldFinishedOrders(nowMs) {
+        if (this.observeMode && this.observer) {
+            const n = this.observer.foldFinishedOrders(nowMs);
+            if (n) {
+                this.observedDirty = true;
+                this.settleObserved();
+            }
+            return n;
+        }
+        const ids = planOrderFold([...this.orders.values()], nowMs ?? this.nowMs(), this.orderFoldPolicy);
+        if (!ids.length)
+            return 0;
+        this.foldedOrders = foldOrdersInto(this.foldedOrders, ids.map(id => this.orders.get(id)).filter(Boolean));
+        for (const id of ids)
+            this.orders.delete(id);
+        this.revision++;
+        return ids.length;
+    }
     observedCheckpoint() {
         /*
          * 관측 구동인데 리듀서가 아직 없으면 만든다 (2026-08-27).
@@ -809,6 +857,11 @@ export class FlowEngine {
          */
         if (def.allocationPolicy)
             this.policy = allocationPolicyOf(def.allocationPolicy);
+        /* 끝난 오더를 접는 경계 — 0 · 무한은 거절한다. 접지 않는 선언은 끝난 오더가 끝없이 쌓이던 때로 돌아간다(ADR-0092). */
+        const fold = orderFoldPolicyOf(def.orderFold);
+        if ('error' in fold)
+            throw new Error(fold.error);
+        this.orderFoldPolicy = fold.policy;
         /*
          * **생산 선언은 어느 커널이든 싣는다.** 예전에는 MES 커널만 생성자에서 이것을 실었고(그 시절
          * 이름은 `mesSpec` 이었다), 그래서 창고 트윈은 "자재를 소비해 자재를 산출하는 공정" 을 선언할
@@ -1265,6 +1318,19 @@ export class FlowEngine {
          *
          * 지어내지 않는다 — 없는 물품을 만들어 채우면 그 뒤 계보와 재고가 전부 거짓 위에 선다.
          */
+        /* 접힌 쪽과 종결 시각을 이어받는다(ADR-0092). 종결 시각은 델타에 없으므로 스냅샷의 오더에서 찾는다. */
+        this.foldedOrders = snap.foldedOrders ? structuredClone(snap.foldedOrders) : emptyFoldedOrders();
+        const terminalAtOf = new Map((snap.orders ?? []).map(o => [o.id, o.terminalAtMs]));
+        /*
+         * **관측이면 원천에 없는 오더를 지운다.** 이 목록은 리듀서에서 옮겨 받는 것이라, 리듀서가 접은 오더를 여기 남기면
+         * 다시는 사라지지 않는다. 씨앗(웜스타트 · fork)은 새로 세우는 커널이라 지울 것이 없다.
+         */
+        if (purpose === 'observe') {
+            const present = new Set(observedOrders.map(o => o.orderId));
+            for (const id of [...this.orders.keys()])
+                if (!present.has(id))
+                    this.orders.delete(id);
+        }
         for (const o of observedOrders) {
             const lines = (o.lines ?? []).map(l => ({ gtin: l.gtin, requested: l.requested - (l.fulfilled ?? 0) })).filter(l => l.requested > 0);
             /* **라인이 없는 오더를 조용히 빼지 않는다.** 예전에는 남은 양을 라인에서만 셌으므로, 품목 라인
@@ -1325,7 +1391,9 @@ export class FlowEngine {
                 /* 약속해 둔 자리·시각창을 이어받는다 — 없으면 도메인이 「정해 뒀다」고 믿는 것을 잃는다.
                    사실이 말해 주지 않으면(옛 저널) 비는 것이 사실이다 — 지어내지 않는다. */
                 ...(o.dockDoor ? { dockDoor: o.dockDoor } : {}),
-                ...(o.windowStartMs !== undefined ? { windowStartMs: o.windowStartMs } : {})
+                ...(o.windowStartMs !== undefined ? { windowStartMs: o.windowStartMs } : {}),
+                /* 언제 끝났나 — 관측만 이어받는다(씨앗은 끝난 오더를 심지 않는다). */
+                ...(observing && terminalAtOf.get(o.orderId) !== undefined ? { terminalAtMs: terminalAtOf.get(o.orderId) } : {})
             });
         }
         /* 작업이 딛고 설 오더를 먼저 세운다 — 순서가 뒤바뀌면 아래 확인이 언제나 "없다" 로 답한다. */
@@ -1815,8 +1883,11 @@ export class FlowEngine {
                 ...(t.startTime ? { startTime: t.startTime } : {}),
                 ...(t.endTime ? { endTime: t.endTime } : {})
             })),
+            /* 접힌 오더 — 접은 것이 없으면 싣지 않는다(ADR-0092). */
+            ...(foldedOrderCount(this.foldedOrders) ? { foldedOrders: structuredClone(this.foldedOrders) } : {}),
             orders: [...this.orders.values()].map(o => ({
                 id: o.id, kind: o.kind, status: o.status,
+                ...(o.terminalAtMs !== undefined ? { terminalAtMs: o.terminalAtMs } : {}),
                 progress: o.requested ? o.fulfilled / o.requested : 0,
                 requested: o.requested, fulfilled: o.fulfilled,
                 /*
@@ -2991,6 +3062,15 @@ export class FlowEngine {
     }
     /** 오더 델타 — **라인까지 싣는다.** 라인이 빠지면 미러가 남은 데맨드를 라인별로 재계획할 수 없다. */
     emitOrder(o) {
+        /*
+         * **언제 끝났나를 여기서 적는다** — 오더의 상태를 바꾸는 자리는 여럿이지만 사건을 내는 문은 이것 하나다.
+         * 끝났던 오더는 처음 끝난 시각을 지키고, 다시 열리면 지운다. 미러는 같은 값을 그 사건의 `eventTime` 에서
+         * 되세운다(델타에 싣지 않는다 — 두 구동이 같은 시각을 든다).
+         */
+        if (isOrderTerminal(o))
+            o.terminalAtMs ??= this.nowMs();
+        else
+            delete o.terminalAtMs;
         this.emitOp(OP_EVENT.order, {
             orderId: o.id, kind: o.kind, status: o.status, requested: o.requested, fulfilled: o.fulfilled, held: o.held,
             ...(o.priority !== undefined ? { priority: o.priority } : {}),

package/dist/kernel.js

@@ -11,7 +11,7 @@ import { FlowEngine, allocatedQty } from "./flow-engine.js";
 import { planMakeToOrder } from "./make-to-order.js";
 import { BIZSTEP, BTT, WMS_ORDER_KIND } from '@operato/ops-contract';
 import { DISP, ILMD_ATTR, aggregationEvent, objectEvent, transactionEvent } from '@operato/ops-contract';
-import { subLotIdOf, itemKeyOf } from '@operato/ops-contract';
+import { subLotIdOf, itemKeyOf, sameItemClass, lotClassOfItem } from '@operato/ops-contract';
 const TRAVEL_MS = 30_000;
 const SHELF_MS = 30 * 24 * 3_600_000; // 기본 유통기한(30일)
 const SHELF_JITTER_MS = 5 * 24 * 3_600_000; // 로트별 만료 편차(FEFO 가 FIFO 와 갈리게)
@@ -57,8 +57,30 @@ export class WmsKernel extends FlowEngine {
         /* 발주 문서 식별자 — 선언된 이름공간 아래(CBV §8.5.5) 또는 선언된 GDTI 문서 타입. */
         const po = this.requireBizTransactionId(`PO-${poSeq}`, 'purchaseorder');
         const eventTime = this.now();
-        const qtyList = [{ epcClass: gtin, quantity: qty }];
+        /*
+         * ── 도착은 로트를 든다 (2026-09-24, ADR-0076 ⑥ · ADR-0082 결정 2) ──────────
+         * 로트는 발주 하나에 하나다(`L-<발주 번호>`) — rng 를 더 쓰지 않으므로 같은 씨앗이면 같은 사건이다.
+         * 케이스의 클래스는 계약이 만든 로트 클래스이고(`lotClassOfItem` → `lotClassUri`), plant · warehouse 가 보내는
+         * 로트와 같은 글자다. 오더 줄은 품목을 묻고 재고는 로트를 들므로 맞춤은 `sameItemClass` 가 한다.
+         *
+         * 선언된 품목이 로트를 붙일 수 없는 모양이면(식별자가 아닌 낱말) 품목 클래스 그대로 싣는다 — 로트를
+         * 말하지 않을 뿐 거짓은 없다. 자리 수가 틀린 GTIN 은 시나리오 검사가 선언에서 거절한다.
+         */
+        const lot = `L-${poSeq}`;
+        const lotClass = lotClassOfItem(gtin, lot) ?? gtin;
+        const qtyList = [{ epcClass: lotClass, quantity: qty }];
         const poTxn = [{ type: BTT.po, bizTransaction: po }];
+        /*
+         * **입고 오더가 도착보다 먼저 선다**(ADR-0076 ⑥, 판정 2026-09-24 — 물음 2 의 A). 「무엇이 오기로 되어
+         * 있었나」가 저널에 먼저 있어야 미러도 같은 순서로 안다. 리드 타임은 쓰는 소비자가 생길 때 연다.
+         * 배차 · 흐름 지표는 받는 오더를 이미 뺀다(`isFlowOrder`).
+         */
+        const inbound = {
+            id: `inbound-${poSeq}`, kind: WMS_ORDER_KIND.inbound, status: 'created', requested: qty, fulfilled: 0, bizTransaction: po,
+            allocated: [], picked: [], shipmentEpc: null, lines: [{ gtin, requested: qty }]
+        };
+        this.orders.set(inbound.id, inbound);
+        this.emitOrder(inbound);
         // 로트 만료(FEFO 용, 결정적 — rng 무소비로 byte-identical 유지). 편차로 도착순≠만료순 → FEFO 가 유의미.
         const expiry = this.clockMs + SHELF_MS - (this.epcSeq % 5) * SHELF_JITTER_MS;
         /* 방출한 마스터데이터를 **상태에도 들고 있는다** — 자기가 선언한 것을 자기가 모르면, 미러는 알고
@@ -68,7 +90,7 @@ export class WmsKernel extends FlowEngine {
          * 들어온 시각을 재고가 들고 있는다 — 「먼저 들어온 것 먼저」를 할 수 있는 유일한 근거다.
          * 값은 **receiving 이 일어난 시각**이고(수집 시각이 아니다), 여기서는 그 둘이 같다.
          */
-        this.items.set(epc, { epc, gtin, qty, location: dock.id, disposition: DISP.in_progress, expiry, ilmd, receivedAtMs: this.nowMs() });
+        this.items.set(epc, { epc, gtin: lotClass, qty, location: dock.id, disposition: DISP.in_progress, expiry, ilmd, receivedAtMs: this.nowMs() });
         dock.occupancy++;
         this.emit(transactionEvent({ eventTime, action: 'ADD', bizStep: BIZSTEP.receiving, bizTransactionList: poTxn, epcList: [epc], quantityList: qtyList, readPoint: dock.id }));
         this.emit(aggregationEvent({ eventTime, action: 'ADD', bizStep: BIZSTEP.receiving, parentID: epc, childQuantityList: qtyList, readPoint: dock.id }));
@@ -79,6 +101,11 @@ export class WmsKernel extends FlowEngine {
             epcList: [epc], quantityList: qtyList, readPoint: dock.id, bizLocation: dock.id, bizTransactionList: poTxn,
             ilmd
         }));
+        /* 수령했으므로 입고 오더를 이행하고 닫는다 — 시뮬에서 입고 오더를 닫는 것은 커널이다(ADR-0076 ⑥). */
+        inbound.fulfilled = qty;
+        inbound.status = 'completed';
+        this.emitOrder(inbound);
+        /* 적치는 품목으로 판단한다(같은 품목을 모으는 정책) — 로트가 아니라 품목 클래스를 넘긴다. */
         const binId = this.policy.selectPlacement({ item: { epc, gtin, qty }, slots: this.slotViews('storage') });
         if (!binId)
             return; // 수용 불가 → 도크 대기
@@ -156,7 +183,7 @@ export class WmsKernel extends FlowEngine {
         const staging = this.builtInLocation('staging', 'picked pallets wait here before shipping');
         const chosenAll = [];
         for (const line of o.lines) {
-            const already = allocatedQty(o.allocated.filter(a => this.items.get(a.epc)?.gtin === line.gtin));
+            const already = allocatedQty(o.allocated.filter(a => sameItemClass(this.items.get(a.epc)?.gtin, line.gtin)));
             const need = line.requested - already;
             if (need <= 0)
                 continue;
@@ -171,7 +198,7 @@ export class WmsKernel extends FlowEngine {
              * 모두 표현할 수 있고, **단위를 정하는 것은 부르는 쪽**이다.
              */
             const available = [...this.items.values()]
-                .filter(i => i.gtin === line.gtin && i.disposition === DISP.sellable && this.locations.get(i.location)?.type === 'storage')
+                .filter(i => sameItemClass(i.gtin, line.gtin) && i.disposition === DISP.sellable && this.locations.get(i.location)?.type === 'storage')
                 .filter(i => this.usableLot(i))
                 .map(i => ({ epc: i.epc, location: i.location, qty: 1, expiry: i.expiry, ...(i.receivedAtMs !== undefined ? { receivedAtMs: i.receivedAtMs } : {}) }));
             const chosen = this.policy.selectStock({ gtin: line.gtin, qty: need, available });
@@ -264,7 +291,7 @@ export class WmsKernel extends FlowEngine {
         const locations = [...this.locations.values()].map(l => ({ id: l.id, type: l.type }));
         const ops = this.declaredOperations();
         for (const line of o.lines) {
-            const have = stock.filter(s => s.gtin === line.gtin && s.sellable && this.locations.get(s.location)?.type === 'storage')
+            const have = stock.filter(s => sameItemClass(s.gtin, line.gtin) && s.sellable && this.locations.get(s.location)?.type === 'storage')
                 .reduce((n, s) => n + s.qty, 0);
             const short = line.requested - have;
             if (short <= 0)
@@ -301,7 +328,7 @@ export class WmsKernel extends FlowEngine {
     }
     /** 부품을 작업대로 — 팔레트 이동이므로 피킹과 같은 기제다(부분 소비는 코어가 한다). */
     issueFeed(o, gtin, from, to, qty) {
-        const src = [...this.items.values()].find(i => i.gtin === gtin && i.location === from && i.disposition === DISP.sellable);
+        const src = [...this.items.values()].find(i => sameItemClass(i.gtin, gtin) && i.location === from && i.disposition === DISP.sellable);
         if (!src)
             return;
         /* 이송 중에 다른 오더가 같은 팔레트를 집지 않게 예약으로 바꾼다 — 코어의 자재 게이트는
@@ -389,7 +416,7 @@ export class WmsKernel extends FlowEngine {
         if (order.lines)
             for (const epc of order.picked) {
                 const g = this.items.get(epc)?.gtin;
-                const line = order.lines.find(l => l.gtin === g && l.requested > 0);
+                const line = order.lines.find(l => sameItemClass(l.gtin, g) && l.requested > 0);
                 if (line)
                     line.requested--;
             }

package/dist/make-to-order.js

@@ -21,6 +21,7 @@
  * 그래서 한 오더가 부르는 것은 세 걸음이다: **부품 이송 → 가공 → 되돌리기.** 이 모듈은 그중
  * "지금 무엇을 발행해야 하나" 를 답한다 — 이송이 아직 안 끝났으면 가공을 발행하지 않는다.
  */
+import { sameItemClass } from '@operato/ops-contract';
 /** 품목 → 그것을 산출하는 공정. 선언에서 파생한다(코드에 표를 두지 않는다). */
 export function producedByIndex(ops) {
     const idx = new Map();
@@ -113,6 +114,6 @@ export function planMakeToOrder(gtin, shortQty, ops, stock, locations) {
 /** 이 재고가 명세를 만족하나 — 품목 지목만 본다(등급 상속은 엔진이 안다). */
 function matches(s, req) {
     if (req.materialDefinition)
-        return s.gtin === req.materialDefinition;
+        return sameItemClass(s.gtin, req.materialDefinition);
     return false;
 }

package/dist/mes-kernel.js

@@ -8,7 +8,7 @@
  *  ③ 셋업/체인지오버 = work-center 가 제품 전환 시 셋업(changeoverKey=제품 gtin) → OEE Availability.
  *  ④ OEE = base 가 설비(설비)별 계측(가동/셋업/기아/품질). cut=cutter·weld=welder 이종 자원.
  */
-import { identityGroundingOf, procedureViolations, isRecipeExecutionBasis } from '@operato/ops-contract';
+import { identityGroundingOf, procedureViolations, isRecipeExecutionBasis, sameItemClass } from '@operato/ops-contract';
 import { firstFitPolicy } from "./allocation-policy.js";
 import { FlowEngine, allocatedEpcs, allocatedQty } from "./flow-engine.js";
 import { DISP, objectEvent, transactionEvent, gdtiUri, sgtinClass, bizTransactionUri } from '@operato/ops-contract';
@@ -820,7 +820,7 @@ export class MesKernel extends FlowEngine {
             if (fromType) {
                 for (const n of locsOfType.get(fromType) ?? []) {
                     for (const i of this.items.at(n.id)) {
-                        if (i.gtin === g && i.disposition === DISP.sellable)
+                        if (sameItemClass(i.gtin, g) && i.disposition === DISP.sellable)
                             available.push({ epc: i.epc, location: i.location, qty: 1 });
                     }
                 }

package/dist/observed-reducer.d.ts

@@ -1,4 +1,5 @@
 import type { AssetState, TestResult, MaterialQuantity, TwinModelDef, CanonicalEnvelope, LocationState, ItemState, LocationObservation, EquipmentState, PersonState, TaskState, OrderState, StructureShift, DispositionFact } from '@operato/ops-contract';
+import { type FoldedOrders } from '@operato/ops-contract';
 import type { MaterialLotUse } from '@operato/ops-contract';
 import { type VocabularyElement } from '@operato/ops-contract';
 interface ProjItem {
@@ -103,6 +104,8 @@ export interface ProjectedState {
     tasks: TaskState[];
     equipment: EquipmentState[];
     orders: OrderState[];
+    /** 접힌 오더(ADR-0092) — 접은 것이 없으면 없다. */
+    foldedOrders?: FoldedOrders;
     /**
      * 사람이 확인(ack)해 둔 주목 신호 id — **파생될 수 없는 유일한 축**이라 저널에서 되살린다.
      *
@@ -159,6 +162,8 @@ export interface ReducerCheckpoint {
     persons: PersonState[];
     assets: AssetState[];
     orders: OrderState[];
+    /** 접힌 오더(ADR-0092) — 옛 저장본에는 없다(없으면 접은 것이 없는 것이다). */
+    foldedOrders?: FoldedOrders;
     acked: string[];
     corrections: {
         declaredAt: string;
@@ -267,6 +272,8 @@ export declare class ObservedReducer {
     private persons;
     private assets;
     private orders;
+    private foldedOrders;
+    private orderFoldPolicy;
     /** 확인해 둔 주목 신호 id — `attention.acked` 이벤트로만 들어온다(계산으로 만들지 않는다). */
     private acked;
     revision: number;
@@ -518,6 +525,14 @@ export declare class ObservedReducer {
      * 모델에서 오는 판정 입력(교대·등급·시간대)은 생성자가 이미 세웠으므로 건드리지 않는다.
      */
     restore(cp: ReducerCheckpoint): void;
+    /**
+     * **끝난 오더를 접는다**(ADR-0092) — 접은 수를 돌려준다.
+     *
+     * 부르는 것은 호스트다: 체크포인트를 쓰기 직전에 부른다. 그래야 접힌 쪽이 씨앗과 같은 때에 적혀 재기동 동치
+     * (`재개점 + 꼬리 == 0부터 접기`)가 선다. 「지금」은 트윈의 지금(마지막으로 들은 시각)이다 — 벽시계가 아니다.
+     * 아직 아무것도 못 들었으면 접지 않는다.
+     */
+    foldFinishedOrders(nowMs?: number | undefined): number;
     snapshot(): ProjectedState;
 }
 export {};

package/dist/observed-reducer.js

@@ -22,6 +22,7 @@
 import { computeOee, isWorkShiftExecutionBasis } 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 { emptyFoldedOrders, foldOrdersInto, foldedOrderCount, isOrderTerminal, orderFoldPolicyOf, planOrderFold, standsNewOrderRow } from '@operato/ops-contract';
 import { expiryFromAttributes, lotFromAttributes } from '@operato/ops-contract';
 /* 클래스 마스터 표는 상태를 들므로 커널에 있다(§`class-master-table`). */
 import { ClassMasterTable } from "./class-master-table.js";
@@ -86,6 +87,12 @@ export class ObservedReducer {
     persons = new Map();
     assets = new Map();
     orders = new Map();
+    /*
+     * **접힌 오더** — 끝나서 뜨거운 목록에서 걷힌 것의 세는 수와 경계(ADR-0092). 접는 때는 호스트가 정한다
+     * (체크포인트를 쓰기 직전에 `foldFinishedOrders` 를 부른다). 경계는 모델의 `orderFold` 선언이다.
+     */
+    foldedOrders = emptyFoldedOrders();
+    orderFoldPolicy;
     /** 확인해 둔 주목 신호 id — `attention.acked` 이벤트로만 들어온다(계산으로 만들지 않는다). */
     acked = new Set();
     revision = 0;
@@ -119,6 +126,11 @@ export class ObservedReducer {
     /** 시각 해석 기준(트윈 모델 선언) — 없으면 UTC. 캘린더의 `HH:MM` 이 어느 기준인지 정한다. */
     utcOffsetMinutes;
     constructor(model) {
+        /* 접지 않는 선언(0 · 무한)은 거절한다 — 기본값으로 조용히 바꾸면 선언한 사람은 자기 값이 쓰이는 줄 안다. */
+        const fold = orderFoldPolicyOf(model.orderFold);
+        if ('error' in fold)
+            throw new Error(fold.error);
+        this.orderFoldPolicy = fold.policy;
         this.utcOffsetMinutes = model.utcOffsetMinutes;
         this.classDefs = { personnel: model.personnelClasses, equipment: model.equipmentClasses, asset: model.assetClasses };
         /* 선언된 판정 기준 — 원천이 판정하지 않은 결과를 커널이 판정할 때 쓴다(§`judgeAgainstSpec`). */
@@ -711,11 +723,26 @@ export class ObservedReducer {
                 const d = e.data;
                 if (this.stale(`order:${d.orderId}`, e))
                     return;
+                const prev = this.orders.get(d.orderId);
+                const at = Date.parse(String(e.eventTime ?? ''));
+                /*
+                 * **접힌 오더의 옛 종결이 다시 오면 줄을 세우지 않는다**(ADR-0092 결정 2). 폴링 원본은 같은 종결을 다시
+                 * 보낸다 — 줄을 세우면 다음 경계에서 또 접혀 세는 수가 두 번 는다. 레코드 자신의 시각으로 가른다(도착
+                 * 시각이 아니다). 순서 판정에 적힌 이 오더의 시각도 지운다 — 남기면 그 맵이 오더 수만큼 다시 자란다.
+                 */
+                if (!prev && !standsNewOrderRow(d, Number.isFinite(at) ? at : undefined, this.foldedOrders)) {
+                    this.lastAt.delete(`order:${d.orderId}`);
+                    return;
+                }
+                /* 언제 끝났나 — 끝났던 오더는 처음 끝난 시각을 지킨다. 끝나지 않았으면(재개 포함) 없다. */
+                const terminal = isOrderTerminal({ status: d.status, requested: d.requested, fulfilled: d.fulfilled });
+                const terminalAtMs = terminal ? (prev?.terminalAtMs ?? (Number.isFinite(at) ? at : undefined)) : undefined;
                 /* **진척으로 압축하지 않는다.** 예전에는 progress 만 남겨서, 미러에서 예측을 세우려면 저널을
                  * 따로 읽어 오더 원값을 되찾아야 했다. 진척은 요청·이행에서 나오는 파생이다 — 파생을 남기고
                  * 원본을 버리면 남은 데맨드를 재계획할 수 없다. */
                 this.orders.set(d.orderId, {
                     id: d.orderId, kind: d.kind, status: d.status,
+                    ...(terminalAtMs !== undefined ? { terminalAtMs } : {}),
                     progress: d.requested ? d.fulfilled / d.requested : 0,
                     requested: d.requested, fulfilled: d.fulfilled,
                     ...(d.lines?.length ? { lines: d.lines.map(l => ({ ...l })) } : {}),
@@ -1332,6 +1359,8 @@ export class ObservedReducer {
             persons: [...this.persons.values()].map(x => ({ ...x })),
             assets: [...this.assets.values()].map(x => ({ ...x })),
             orders: [...this.orders.values()].map(o => ({ ...o })),
+            /* 접힌 쪽도 재개점에 든다 — 없으면 재기동 뒤에 끝난 오더의 수를 잃는다(ADR-0092). 접은 것이 없으면 싣지 않는다. */
+            ...(foldedOrderCount(this.foldedOrders) ? { foldedOrders: structuredClone(this.foldedOrders) } : {}),
             acked: [...this.acked],
             corrections: this.corrections.map(c => ({ ...c })),
             unhandled: [...this.unhandled.entries()].map(([eventType, v]) => ({ eventType, ...v })),
@@ -1375,10 +1404,33 @@ export class ObservedReducer {
         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 }]));
+        this.foldedOrders = cp?.foldedOrders ? structuredClone(cp.foldedOrders) : emptyFoldedOrders();
         this.acked = new Set(cp?.acked ?? []);
         this.corrections = (cp?.corrections ?? []).map(c => ({ ...c }));
         this.unhandled = new Map((cp?.unhandled ?? []).map(({ eventType, ...v }) => [eventType, { ...v }]));
     }
+    /**
+     * **끝난 오더를 접는다**(ADR-0092) — 접은 수를 돌려준다.
+     *
+     * 부르는 것은 호스트다: 체크포인트를 쓰기 직전에 부른다. 그래야 접힌 쪽이 씨앗과 같은 때에 적혀 재기동 동치
+     * (`재개점 + 꼬리 == 0부터 접기`)가 선다. 「지금」은 트윈의 지금(마지막으로 들은 시각)이다 — 벽시계가 아니다.
+     * 아직 아무것도 못 들었으면 접지 않는다.
+     */
+    foldFinishedOrders(nowMs = this.observedAtMs) {
+        if (nowMs === undefined || !Number.isFinite(nowMs))
+            return 0;
+        const ids = planOrderFold([...this.orders.values()], nowMs, this.orderFoldPolicy);
+        if (!ids.length)
+            return 0;
+        const rows = ids.map(id => this.orders.get(id)).filter(Boolean);
+        this.foldedOrders = foldOrdersInto(this.foldedOrders, rows);
+        for (const id of ids) {
+            this.orders.delete(id);
+            this.lastAt.delete(`order:${id}`);
+        }
+        this.revision++;
+        return ids.length;
+    }
     snapshot() {
         const occ = new Map();
         for (const it of this.items.values())
@@ -1425,6 +1477,7 @@ export class ObservedReducer {
             tasks: [...this.tasks.values()].map(t => structuredClone(t)),
             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 })),
+            ...(foldedOrderCount(this.foldedOrders) ? { foldedOrders: structuredClone(this.foldedOrders) } : {}),
             acked: [...this.acked]
         };
     }

package/dist-cjs/index.cjs

@@ -1629,12 +1629,19 @@ var ILMD_ATTR = {
   /** 로트·배치 번호(직렬 개체에 로트를 붙일 때). */
   lot: "cbvmda:lotNumber"
 };
+function lgtinClass(companyPrefix, itemRefAndIndicator, lot) {
+  return `urn:epc:class:lgtin:${companyPrefix}.${itemRefAndIndicator}.${encodeURIComponent(lot)}`;
+}
 function parseEpc(uri) {
   const raw = String(uri ?? "");
   if (/(?:\/obj\/|:obj:)[^/:\s]+$/.test(raw))
     return { scheme: "unknown", instance: true, uri: raw };
-  if (/(?:\/class\/|:class:)[^/:\s]+$/.test(raw))
-    return { scheme: "unknown", instance: false, uri: raw };
+  const inHouseClass = raw.match(/(?:\/class\/|:class:)([^/:\s]+)$/);
+  if (inHouseClass) {
+    const at = inHouseClass[1].indexOf(LOT_SEPARATOR);
+    const split = at > 0 ? decodedPair(inHouseClass[1].slice(0, at), inHouseClass[1].slice(at + LOT_SEPARATOR.length)) : void 0;
+    return split ? { scheme: "unknown", instance: false, item: split[0], lot: split[1], uri: raw } : { scheme: "unknown", instance: false, uri: raw };
+  }
   const cls = raw.match(/^urn:epc:class:lgtin:(.+)$/);
   if (cls) {
     const seg = cls[1].split(".");
@@ -1666,12 +1673,83 @@ function parseEpc(uri) {
   }
   return { scheme: "unknown", instance: false, uri: raw };
 }
+function decodedPair(item, lot) {
+  if (!lot)
+    return void 0;
+  try {
+    return [decodeURIComponent(item), decodeURIComponent(lot)];
+  } catch {
+    return void 0;
+  }
+}
+function itemClassOf(uri) {
+  if (!uri)
+    return void 0;
+  const parsed = parseEpc(uri);
+  if (parsed.scheme === "lgtin" && parsed.gtinKey)
+    return `urn:epc:idpat:sgtin:${parsed.gtinKey}.*`;
+  if (parsed.item !== void 0) {
+    const marker = /^(.*(?:\/class\/|:class:))[^/:\s]+$/.exec(parsed.uri);
+    if (marker)
+      return `${marker[1]}${parsed.item.replace(STRUCTURE_BREAKING, (c) => PERCENT_ENCODED[c])}`;
+  }
+  return parsed.uri;
+}
+function lotClassOfItem(itemClass, lot) {
+  if (!itemClass)
+    return void 0;
+  const idpat = /^urn:epc:idpat:sgtin:(\d+)\.(\d+)\.\*$/.exec(itemClass);
+  if (idpat)
+    return lotClassUri({ namespace: "", item: "", lot, gtin: `${idpat[1]}.${idpat[2]}` });
+  const parsed = parseEpc(itemClass);
+  if (parsed.instance || parsed.lot !== void 0)
+    return void 0;
+  const url = /^(https?:\/\/.+)\/class\/([^/:\s]+)$/.exec(itemClass);
+  const urn = /^(urn:.+):class:([^/:\s]+)$/.exec(itemClass);
+  const at = url ?? urn;
+  if (!at)
+    return void 0;
+  let item;
+  try {
+    item = decodeURIComponent(at[2]);
+  } catch {
+    return void 0;
+  }
+  return lotClassUri({ namespace: at[1], item, lot });
+}
+function sameItemClass(a, b) {
+  const x = itemClassOf(a);
+  return x !== void 0 && x === itemClassOf(b);
+}
 function gdtiUri(companyPrefix, docType, serial) {
   return `urn:epc:id:gdti:${companyPrefix}.${docType}.${serial}`;
 }
 function objectUri(namespace, objId) {
   return underNamespace(namespace, "obj", objId);
 }
+function lotClassUri(input) {
+  const item = String(input.item ?? "");
+  const lot = String(input.lot ?? "");
+  if (!lot)
+    throw new Error(`lotClassUri: \uB85C\uD2B8\uAC00 \uBE44\uC5C8\uB2E4 \u2014 \uB85C\uD2B8 \uC5C6\uB294 \uD488\uBAA9\uC740 classUri \uB85C \uBD80\uB978\uB2E4 (item=${item})`);
+  if (input.gtin !== void 0) {
+    const [prefix, ref, ...rest] = String(input.gtin).split(".");
+    if (!prefix || !ref || rest.length) {
+      throw new Error(`lotClassUri: gtin \uC740 'CompanyPrefix.ItemRefAndIndicator' \uC5EC\uC57C \uD55C\uB2E4: ${input.gtin}`);
+    }
+    const uri = lgtinClass(prefix, ref, lot);
+    const wrong = gs1KeyDigitViolation(uri);
+    if (wrong)
+      throw new Error(`lotClassUri: ${wrong}`);
+    return uri;
+  }
+  if (!item)
+    throw new Error(`lotClassUri: \uD488\uBC88\uC774 \uBE44\uC5C8\uB2E4 (lot=${lot})`);
+  const enc = (v) => v.replace(LOT_COMPONENT_BREAKING, (c) => PERCENT_ENCODED[c]);
+  return joinUnderNamespace(input.namespace, "class", `${enc(item)}${LOT_SEPARATOR}${enc(lot)}`);
+}
+var LOT_SEPARATOR = ";lot=";
+var LOT_COMPONENT_BREAKING = /[%/:?# ;]/g;
 function bizTransactionUri(namespace, transId) {
   return underNamespace(namespace, "bt", transId);
 }
@@ -1682,16 +1760,20 @@ var PERCENT_ENCODED = {
   ":": "%3A",
   "?": "%3F",
   "#": "%23",
-  " ": "%20"
+  " ": "%20",
+  /* 로트 클래스의 가르는 글자 — `lotClassUri` 만 쓴다(§`LOT_COMPONENT_BREAKING`). 표는 한 벌이다. */
+  ";": "%3B"
 };
 function underNamespace(namespace, marker, id) {
-  const ns = namespace?.trim();
-  if (!ns)
-    return void 0;
   const raw = String(id);
   if (!raw)
     return void 0;
-  const v = raw.replace(STRUCTURE_BREAKING, (c) => PERCENT_ENCODED[c]);
+  return joinUnderNamespace(namespace, marker, raw.replace(STRUCTURE_BREAKING, (c) => PERCENT_ENCODED[c]));
+}
+function joinUnderNamespace(namespace, marker, v) {
+  const ns = namespace?.trim();
+  if (!ns)
+    return void 0;
   if (/^https?:\/\/[^/\s]+/.test(ns))
     return `${ns.replace(/\/+$/, "")}/${marker}/${v}`;
   if (/^urn:epc(global)?:/.test(ns))
@@ -1802,6 +1884,92 @@ function transformationEvent(p) {
     e.bizTransactionList = p.bizTransactionList;
   return e;
 }
+var GS1_KEY_DIGITS = { sgtin: 13, lgtin: 13, sscc: 17, grai: 12, gdti: 12, sgln: 12 };
+function gs1KeyDigitViolation(uri) {
+  if (!uri)
+    return void 0;
+  const m = /^urn:epc:(?:id|idpat|class):([a-z]+):([^:]+)$/.exec(uri);
+  if (!m)
+    return void 0;
+  const want = GS1_KEY_DIGITS[m[1]];
+  if (!want)
+    return void 0;
+  const parts = m[2].split(".");
+  if (parts.length < 2)
+    return `${m[1]} \uD615\uC2DD \uC624\uB958: ${uri} \u2014 \uD68C\uC0AC \uD504\uB9AC\uD53D\uC2A4\uC640 \uCC38\uC870\uAC00 '.' \uB85C \uAC08\uB824\uC57C \uD55C\uB2E4`;
+  const [prefix, ref] = parts;
+  if (ref === "*")
+    return void 0;
+  if (!/^\d+$/.test(prefix) || !/^\d+$/.test(ref)) {
+    return `${m[1]} \uD615\uC2DD \uC624\uB958: ${uri} \u2014 \uD68C\uC0AC \uD504\uB9AC\uD53D\uC2A4\uC640 \uCC38\uC870\uB294 \uC22B\uC790\uB2E4`;
+  }
+  const got = prefix.length + ref.length;
+  if (got === want)
+    return void 0;
+  return `${m[1]} \uC790\uB9AC \uC218 \uC624\uB958: ${uri} \u2014 \uD68C\uC0AC \uD504\uB9AC\uD53D\uC2A4(${prefix.length}) + \uCC38\uC870(${ref.length}) = ${got} \uC774\uC9C0\uB9CC ${want} \uC5EC\uC57C \uD55C\uB2E4(GS1 TDS). \uD504\uB9AC\uD53D\uC2A4\uB97C \uBC14\uAFB8\uBA74 \uCC38\uC870 \uC790\uB9AC \uC218\uB97C \uD568\uAED8 \uB9DE\uCDB0\uC57C \uD55C\uB2E4.`;
+}
+
+// ../ops-contract/dist/order-fold.js
+var ORDER_FOLD_DEFAULT = Object.freeze({ afterMs: 24 * 60 * 60 * 1e3, maxTerminal: 1e3 });
+function orderFoldPolicyOf(declared) {
+  const policy = { ...ORDER_FOLD_DEFAULT };
+  for (const key of ["afterMs", "maxTerminal"]) {
+    const v = declared?.[key];
+    if (v === void 0 || v === null)
+      continue;
+    if (typeof v !== "number" || !Number.isFinite(v) || v <= 0) {
+      return { error: `order fold ${key} must be a positive finite number, got ${String(v)} \u2014 a fold that never folds is refused (ADR-0092)` };
+    }
+    policy[key] = key === "maxTerminal" ? Math.floor(v) : v;
+  }
+  if (policy.maxTerminal < 1)
+    return { error: "order fold maxTerminal must be at least 1 (ADR-0092)" };
+  return { policy };
+}
+function emptyFoldedOrders() {
+  return { counts: {}, boundaryMs: null };
+}
+function foldedOrderCount(folded) {
+  let n = 0;
+  for (const byStatus of Object.values(folded?.counts ?? {}))
+    for (const c of Object.values(byStatus))
+      n += c;
+  return n;
+}
+function planOrderFold(orders, nowMs, policy = ORDER_FOLD_DEFAULT) {
+  const candidates = orders.filter((o) => isOrderTerminal(o) && !o.held && typeof o.terminalAtMs === "number" && Number.isFinite(o.terminalAtMs)).sort((a, b) => a.terminalAtMs - b.terminalAtMs || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+  const cutoff = nowMs - policy.afterMs;
+  const byTime = candidates.filter((o) => o.terminalAtMs <= cutoff);
+  const stay = candidates.length - byTime.length;
+  const byCount = stay > policy.maxTerminal ? candidates.slice(byTime.length, byTime.length + (stay - policy.maxTerminal)) : [];
+  return [...byTime, ...byCount].map((o) => o.id);
+}
+function foldOrdersInto(folded, orders) {
+  const out = {
+    counts: Object.fromEntries(Object.entries(folded?.counts ?? {}).map(([k, v]) => [k, { ...v }])),
+    boundaryMs: folded?.boundaryMs ?? null
+  };
+  for (const o of orders) {
+    const kind = String(o.kind ?? "");
+    const status = String(o.status ?? "");
+    const byStatus = out.counts[kind] ??= {};
+    byStatus[status] = (byStatus[status] ?? 0) + 1;
+    if (typeof o.terminalAtMs === "number" && Number.isFinite(o.terminalAtMs)) {
+      out.boundaryMs = out.boundaryMs === null ? o.terminalAtMs : Math.max(out.boundaryMs, o.terminalAtMs);
+    }
+  }
+  return out;
+}
+function standsNewOrderRow(record, eventTimeMs, folded) {
+  if (!isOrderTerminal(record))
+    return true;
+  const boundary = folded?.boundaryMs;
+  if (boundary === null || boundary === void 0)
+    return true;
+  if (typeof eventTimeMs !== "number" || !Number.isFinite(eventTimeMs))
+    return true;
+  return eventTimeMs > boundary;
+}
 
 // ../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)?)?$/;
@@ -2727,6 +2895,12 @@ var ObservedReducer = class {
   persons = /* @__PURE__ */ new Map();
   assets = /* @__PURE__ */ new Map();
   orders = /* @__PURE__ */ new Map();
+  /*
+   * **접힌 오더** — 끝나서 뜨거운 목록에서 걷힌 것의 세는 수와 경계(ADR-0092). 접는 때는 호스트가 정한다
+   * (체크포인트를 쓰기 직전에 `foldFinishedOrders` 를 부른다). 경계는 모델의 `orderFold` 선언이다.
+   */
+  foldedOrders = emptyFoldedOrders();
+  orderFoldPolicy;
   /** 확인해 둔 주목 신호 id — `attention.acked` 이벤트로만 들어온다(계산으로 만들지 않는다). */
   acked = /* @__PURE__ */ new Set();
   revision = 0;
@@ -2760,6 +2934,9 @@ var ObservedReducer = class {
   /** 시각 해석 기준(트윈 모델 선언) — 없으면 UTC. 캘린더의 `HH:MM` 이 어느 기준인지 정한다. */
   utcOffsetMinutes;
   constructor(model) {
+    const fold = orderFoldPolicyOf(model.orderFold);
+    if ("error" in fold) throw new Error(fold.error);
+    this.orderFoldPolicy = fold.policy;
     this.utcOffsetMinutes = model.utcOffsetMinutes;
     this.classDefs = { personnel: model.personnelClasses, equipment: model.equipmentClasses, asset: model.assetClasses };
     for (const sp of model.testSpecifications ?? []) this.testSpecs.set(sp.id, sp);
@@ -3154,10 +3331,19 @@ var ObservedReducer = class {
       case OP_EVENT.order: {
         const d = e.data;
         if (this.stale(`order:${d.orderId}`, e)) return;
+        const prev = this.orders.get(d.orderId);
+        const at = Date.parse(String(e.eventTime ?? ""));
+        if (!prev && !standsNewOrderRow(d, Number.isFinite(at) ? at : void 0, this.foldedOrders)) {
+          this.lastAt.delete(`order:${d.orderId}`);
+          return;
+        }
+        const terminal = isOrderTerminal({ status: d.status, requested: d.requested, fulfilled: d.fulfilled });
+        const terminalAtMs = terminal ? prev?.terminalAtMs ?? (Number.isFinite(at) ? at : void 0) : void 0;
         this.orders.set(d.orderId, {
           id: d.orderId,
           kind: d.kind,
           status: d.status,
+          ...terminalAtMs !== void 0 ? { terminalAtMs } : {},
           progress: d.requested ? d.fulfilled / d.requested : 0,
           requested: d.requested,
           fulfilled: d.fulfilled,
@@ -3601,6 +3787,8 @@ var ObservedReducer = class {
       persons: [...this.persons.values()].map((x) => ({ ...x })),
       assets: [...this.assets.values()].map((x) => ({ ...x })),
       orders: [...this.orders.values()].map((o) => ({ ...o })),
+      /* 접힌 쪽도 재개점에 든다 — 없으면 재기동 뒤에 끝난 오더의 수를 잃는다(ADR-0092). 접은 것이 없으면 싣지 않는다. */
+      ...foldedOrderCount(this.foldedOrders) ? { foldedOrders: structuredClone(this.foldedOrders) } : {},
       acked: [...this.acked],
       corrections: this.corrections.map((c) => ({ ...c })),
       unhandled: [...this.unhandled.entries()].map(([eventType, v]) => ({ eventType, ...v })),
@@ -3647,10 +3835,31 @@ var ObservedReducer = class {
     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 }]));
+    this.foldedOrders = cp?.foldedOrders ? structuredClone(cp.foldedOrders) : emptyFoldedOrders();
     this.acked = new Set(cp?.acked ?? []);
     this.corrections = (cp?.corrections ?? []).map((c) => ({ ...c }));
     this.unhandled = new Map((cp?.unhandled ?? []).map(({ eventType, ...v }) => [eventType, { ...v }]));
   }
+  /**
+   * **끝난 오더를 접는다**(ADR-0092) — 접은 수를 돌려준다.
+   *
+   * 부르는 것은 호스트다: 체크포인트를 쓰기 직전에 부른다. 그래야 접힌 쪽이 씨앗과 같은 때에 적혀 재기동 동치
+   * (`재개점 + 꼬리 == 0부터 접기`)가 선다. 「지금」은 트윈의 지금(마지막으로 들은 시각)이다 — 벽시계가 아니다.
+   * 아직 아무것도 못 들었으면 접지 않는다.
+   */
+  foldFinishedOrders(nowMs = this.observedAtMs) {
+    if (nowMs === void 0 || !Number.isFinite(nowMs)) return 0;
+    const ids = planOrderFold([...this.orders.values()], nowMs, this.orderFoldPolicy);
+    if (!ids.length) return 0;
+    const rows = ids.map((id) => this.orders.get(id)).filter(Boolean);
+    this.foldedOrders = foldOrdersInto(this.foldedOrders, rows);
+    for (const id of ids) {
+      this.orders.delete(id);
+      this.lastAt.delete(`order:${id}`);
+    }
+    this.revision++;
+    return ids.length;
+  }
   snapshot() {
     const occ = /* @__PURE__ */ new Map();
     for (const it of this.items.values()) occ.set(it.location, (occ.get(it.location) ?? 0) + 1);
@@ -3696,6 +3905,7 @@ var ObservedReducer = class {
       tasks: [...this.tasks.values()].map((t) => structuredClone(t)),
       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 })),
+      ...foldedOrderCount(this.foldedOrders) ? { foldedOrders: structuredClone(this.foldedOrders) } : {},
       acked: [...this.acked]
     };
   }
@@ -4033,7 +4243,21 @@ var ItemStore = class _ItemStore {
    * 색인을 밖에 따로 두지 않는다 — 갱신하는 자리가 흩어지면 한 자리라도 빠뜨렸을 때 **재고가 조용히
    * 사라진다**(있는데 없다고 판정된다). 자리 색인과 같은 규율이다.
    */
+  /*
+   * 품목 색인 — 키는 **품목 클래스**다(`itemClassOf`). 재고는 로트 클래스를 들고 오더는 품목 클래스를 묻는다
+   * (ADR-0076 ⑥ · ADR-0082 결정 2). 로트 글자를 키로 쓰면 품목을 물어도 로트 재고가 안 나온다.
+   */
   byGtin = /* @__PURE__ */ new Map();
+  /** 같은 글자를 매번 뜯지 않는다 — 클래스 글자의 종류는 적고 물품은 많다. */
+  itemClassCache = /* @__PURE__ */ new Map();
+  itemClass(gtin) {
+    let c = this.itemClassCache.get(gtin);
+    if (c === void 0) {
+      c = itemClassOf(gtin) ?? gtin;
+      this.itemClassCache.set(gtin, c);
+    }
+    return c;
+  }
   get size() {
     return this.map.size;
   }
@@ -4123,7 +4347,7 @@ var ItemStore = class _ItemStore {
   }
   /** 그 품목인 물품들 — 색인이 답한다(자리를 모를 때 쓴다). */
   ofGtin(gtin) {
-    const keys = this.byGtin.get(gtin);
+    const keys = this.byGtin.get(this.itemClass(gtin));
     if (!keys) return [];
     const out = [];
     for (const k of keys) {
@@ -4151,13 +4375,13 @@ var ItemStore = class _ItemStore {
       }
     }
     for (const [key, it] of this.map) {
-      if (it.gtin && !this.byGtin.get(it.gtin)?.has(key)) drift.push(`${key} \uC774 \uD488\uBAA9 '${it.gtin}' \uC0C9\uC778\uC5D0 \uC5C6\uB2E4`);
+      if (it.gtin && !this.byGtin.get(this.itemClass(it.gtin))?.has(key)) drift.push(`${key} \uC774 \uD488\uBAA9 '${it.gtin}' \uC0C9\uC778\uC5D0 \uC5C6\uB2E4`);
     }
     for (const [g, keys] of this.byGtin) {
       for (const k of keys) {
         const it = this.map.get(k);
         if (!it) drift.push(`${k} \uC774 \uC9C0\uC6CC\uC84C\uB294\uB370 \uD488\uBAA9 '${g}' \uC0C9\uC778\uC5D0 \uB0A8\uC544 \uC788\uB2E4`);
-        else if (it.gtin !== g) drift.push(`${k} \uC740 \uD488\uBAA9 '${it.gtin}' \uC778\uB370 '${g}' \uC0C9\uC778\uC5D0 \uC788\uB2E4`);
+        else if (this.itemClass(it.gtin ?? "") !== g) drift.push(`${k} \uC740 \uD488\uBAA9 '${it.gtin}' \uC778\uB370 '${g}' \uC0C9\uC778\uC5D0 \uC788\uB2E4`);
       }
     }
     return drift;
@@ -4165,9 +4389,10 @@ var ItemStore = class _ItemStore {
   index(key, location, gtin) {
     this.indexLocation(key, location);
     if (gtin) {
-      const set = this.byGtin.get(gtin) ?? /* @__PURE__ */ new Set();
+      const g = this.itemClass(gtin);
+      const set = this.byGtin.get(g) ?? /* @__PURE__ */ new Set();
       set.add(key);
-      this.byGtin.set(gtin, set);
+      this.byGtin.set(g, set);
     }
   }
   indexLocation(key, location) {
@@ -4178,10 +4403,11 @@ var ItemStore = class _ItemStore {
   unindex(key, location, gtin) {
     this.unindexLocation(key, location);
     if (gtin) {
-      const set = this.byGtin.get(gtin);
+      const g = this.itemClass(gtin);
+      const set = this.byGtin.get(g);
       if (!set) return;
       set.delete(key);
-      if (!set.size) this.byGtin.delete(gtin);
+      if (!set.size) this.byGtin.delete(g);
     }
   }
   unindexLocation(key, location) {
@@ -4209,6 +4435,10 @@ var FlowEngine = class {
   assets = /* @__PURE__ */ new Map();
   tasks = /* @__PURE__ */ new Map();
   orders = /* @__PURE__ */ new Map();
+  /** 접힌 오더(ADR-0092) — 세는 수와 경계만 든다. 미러는 리듀서가 들고 이것은 옮겨 받는다(§`hydrateObserved`). */
+  foldedOrders = emptyFoldedOrders();
+  /** 끝난 오더를 언제 접나 — 모델의 `orderFold` 선언. 없으면 기본(24시간 · 1,000건). */
+  orderFoldPolicy = ORDER_FOLD_DEFAULT;
   revision = 0;
   clockMs = 0;
   /**
@@ -4274,6 +4504,31 @@ var FlowEngine = class {
    *
    * 관측 구동이 아니면 `undefined` — 시뮬은 리듀서를 갖지 않는다(저장할 것이 없다).
    */
+  /**
+   * **끝난 오더를 접는다**(ADR-0092) — 접은 수를 돌려준다.
+   *
+   * 부르는 것은 호스트다 — 체크포인트(미러는 `observedCheckpoint`, 시뮬은 상태 스냅샷)를 쓰기 직전에 부른다. 그래야
+   * 접힌 쪽이 씨앗과 같은 때에 적힌다. 커널이 스스로 접지 않는 것은, 접힌 목록을 읽는 쪽(예측 · 화면)이 그 뜻에
+   * 맞춰진 뒤에 호스트가 부르게 하려는 것이다.
+   *
+   * 미러는 원천인 리듀서에서 접고 옮겨 받는다 — 이 목록에서만 지우면 다음 옮김이 되살린다.
+   */
+  foldFinishedOrders(nowMs) {
+    if (this.observeMode && this.observer) {
+      const n = this.observer.foldFinishedOrders(nowMs);
+      if (n) {
+        this.observedDirty = true;
+        this.settleObserved();
+      }
+      return n;
+    }
+    const ids = planOrderFold([...this.orders.values()], nowMs ?? this.nowMs(), this.orderFoldPolicy);
+    if (!ids.length) return 0;
+    this.foldedOrders = foldOrdersInto(this.foldedOrders, ids.map((id) => this.orders.get(id)).filter(Boolean));
+    for (const id of ids) this.orders.delete(id);
+    this.revision++;
+    return ids.length;
+  }
   observedCheckpoint() {
     if (!this.observer && this.observeMode) {
       this.observer = new ObservedReducer(this.boardDef ?? { locations: [], equipment: [] });
@@ -4382,6 +4637,9 @@ var FlowEngine = class {
   loadTwinModel(def) {
     this.boardDef = def;
     if (def.allocationPolicy) this.policy = allocationPolicyOf(def.allocationPolicy);
+    const fold = orderFoldPolicyOf(def.orderFold);
+    if ("error" in fold) throw new Error(fold.error);
+    this.orderFoldPolicy = fold.policy;
     if (def.productionSpec?.definition?.operations?.length) this.loadOperations(def.productionSpec.definition.operations);
     for (const n of readBoardLocations(def)) this.locations.set(n.id, this.buildLocation(n));
     this.classDefs = { personnel: def.personnelClasses, equipment: def.equipmentClasses, asset: def.assetClasses, material: def.materialClasses };
@@ -4759,6 +5017,12 @@ var FlowEngine = class {
       ...o.dockDoor ? { dockDoor: o.dockDoor } : {},
       ...o.windowStartMs !== void 0 ? { windowStartMs: o.windowStartMs } : {}
     }));
+    this.foldedOrders = snap.foldedOrders ? structuredClone(snap.foldedOrders) : emptyFoldedOrders();
+    const terminalAtOf = new Map((snap.orders ?? []).map((o) => [o.id, o.terminalAtMs]));
+    if (purpose === "observe") {
+      const present = new Set(observedOrders.map((o) => o.orderId));
+      for (const id of [...this.orders.keys()]) if (!present.has(id)) this.orders.delete(id);
+    }
     for (const o of observedOrders) {
       const lines = (o.lines ?? []).map((l) => ({ gtin: l.gtin, requested: l.requested - (l.fulfilled ?? 0) })).filter((l) => l.requested > 0);
       const remaining = lines.length ? lines.reduce((s, l) => s + l.requested, 0) : Math.max(0, (o.requested ?? 0) - (o.fulfilled ?? 0));
@@ -4797,7 +5061,9 @@ var FlowEngine = class {
         /* 약속해 둔 자리·시각창을 이어받는다 — 없으면 도메인이 「정해 뒀다」고 믿는 것을 잃는다.
            사실이 말해 주지 않으면(옛 저널) 비는 것이 사실이다 — 지어내지 않는다. */
         ...o.dockDoor ? { dockDoor: o.dockDoor } : {},
-        ...o.windowStartMs !== void 0 ? { windowStartMs: o.windowStartMs } : {}
+        ...o.windowStartMs !== void 0 ? { windowStartMs: o.windowStartMs } : {},
+        /* 언제 끝났나 — 관측만 이어받는다(씨앗은 끝난 오더를 심지 않는다). */
+        ...observing && terminalAtOf.get(o.orderId) !== void 0 ? { terminalAtMs: terminalAtOf.get(o.orderId) } : {}
       });
     }
     const seededOrderIds = new Set(this.orders.keys());
@@ -5197,10 +5463,13 @@ var FlowEngine = class {
         ...t.startTime ? { startTime: t.startTime } : {},
         ...t.endTime ? { endTime: t.endTime } : {}
       })),
+      /* 접힌 오더 — 접은 것이 없으면 싣지 않는다(ADR-0092). */
+      ...foldedOrderCount(this.foldedOrders) ? { foldedOrders: structuredClone(this.foldedOrders) } : {},
       orders: [...this.orders.values()].map((o) => ({
         id: o.id,
         kind: o.kind,
         status: o.status,
+        ...o.terminalAtMs !== void 0 ? { terminalAtMs: o.terminalAtMs } : {},
         progress: o.requested ? o.fulfilled / o.requested : 0,
         requested: o.requested,
         fulfilled: o.fulfilled,
@@ -6236,6 +6505,8 @@ var FlowEngine = class {
   }
   /** 오더 델타 — **라인까지 싣는다.** 라인이 빠지면 미러가 남은 데맨드를 라인별로 재계획할 수 없다. */
   emitOrder(o) {
+    if (isOrderTerminal(o)) o.terminalAtMs ??= this.nowMs();
+    else delete o.terminalAtMs;
     this.emitOp(OP_EVENT.order, {
       orderId: o.id,
       kind: o.kind,
@@ -7276,7 +7547,7 @@ function planMakeToOrder(gtin, shortQty, ops, stock, locations) {
   return { steps: [{ step: "process", operation: op.key, at: station.id }] };
 }
 function matches(s, req) {
-  if (req.materialDefinition) return s.gtin === req.materialDefinition;
+  if (req.materialDefinition) return sameItemClass(s.gtin, req.materialDefinition);
   return false;
 }
 
@@ -7323,11 +7594,27 @@ var WmsKernel = class extends FlowEngine {
     const poSeq = ++this.poSeq;
     const po = this.requireBizTransactionId(`PO-${poSeq}`, "purchaseorder");
     const eventTime = this.now();
-    const qtyList = [{ epcClass: gtin, quantity: qty }];
+    const lot = `L-${poSeq}`;
+    const lotClass = lotClassOfItem(gtin, lot) ?? gtin;
+    const qtyList = [{ epcClass: lotClass, quantity: qty }];
     const poTxn = [{ type: BTT.po, bizTransaction: po }];
+    const inbound = {
+      id: `inbound-${poSeq}`,
+      kind: WMS_ORDER_KIND.inbound,
+      status: "created",
+      requested: qty,
+      fulfilled: 0,
+      bizTransaction: po,
+      allocated: [],
+      picked: [],
+      shipmentEpc: null,
+      lines: [{ gtin, requested: qty }]
+    };
+    this.orders.set(inbound.id, inbound);
+    this.emitOrder(inbound);
     const expiry = this.clockMs + SHELF_MS - this.epcSeq % 5 * SHELF_JITTER_MS;
     const ilmd = { [ILMD_ATTR.expiry]: expiry };
-    this.items.set(epc, { epc, gtin, qty, location: dock.id, disposition: DISP.in_progress, expiry, ilmd, receivedAtMs: this.nowMs() });
+    this.items.set(epc, { epc, gtin: lotClass, qty, location: dock.id, disposition: DISP.in_progress, expiry, ilmd, receivedAtMs: this.nowMs() });
     dock.occupancy++;
     this.emit(transactionEvent({ eventTime, action: "ADD", bizStep: BIZSTEP.receiving, bizTransactionList: poTxn, epcList: [epc], quantityList: qtyList, readPoint: dock.id }));
     this.emit(aggregationEvent({ eventTime, action: "ADD", bizStep: BIZSTEP.receiving, parentID: epc, childQuantityList: qtyList, readPoint: dock.id }));
@@ -7343,6 +7630,9 @@ var WmsKernel = class extends FlowEngine {
       bizTransactionList: poTxn,
       ilmd
     }));
+    inbound.fulfilled = qty;
+    inbound.status = "completed";
+    this.emitOrder(inbound);
     const binId = this.policy.selectPlacement({ item: { epc, gtin, qty }, slots: this.slotViews("storage") });
     if (!binId) return;
     const id = `task-${++this.taskSeq}`;
@@ -7421,10 +7711,10 @@ var WmsKernel = class extends FlowEngine {
     const staging = this.builtInLocation("staging", "picked pallets wait here before shipping");
     const chosenAll = [];
     for (const line of o.lines) {
-      const already = allocatedQty(o.allocated.filter((a) => this.items.get(a.epc)?.gtin === line.gtin));
+      const already = allocatedQty(o.allocated.filter((a) => sameItemClass(this.items.get(a.epc)?.gtin, line.gtin)));
       const need = line.requested - already;
       if (need <= 0) continue;
-      const available = [...this.items.values()].filter((i) => i.gtin === line.gtin && i.disposition === DISP.sellable && this.locations.get(i.location)?.type === "storage").filter((i) => this.usableLot(i)).map((i) => ({ epc: i.epc, location: i.location, qty: 1, expiry: i.expiry, ...i.receivedAtMs !== void 0 ? { receivedAtMs: i.receivedAtMs } : {} }));
+      const available = [...this.items.values()].filter((i) => sameItemClass(i.gtin, line.gtin) && i.disposition === DISP.sellable && this.locations.get(i.location)?.type === "storage").filter((i) => this.usableLot(i)).map((i) => ({ epc: i.epc, location: i.location, qty: 1, expiry: i.expiry, ...i.receivedAtMs !== void 0 ? { receivedAtMs: i.receivedAtMs } : {} }));
       const chosen = this.policy.selectStock({ gtin: line.gtin, qty: need, available });
       for (const row of chosen) {
         o.allocated.push(row);
@@ -7488,7 +7778,7 @@ var WmsKernel = class extends FlowEngine {
     const locations = [...this.locations.values()].map((l) => ({ id: l.id, type: l.type }));
     const ops = this.declaredOperations();
     for (const line of o.lines) {
-      const have = stock.filter((s) => s.gtin === line.gtin && s.sellable && this.locations.get(s.location)?.type === "storage").reduce((n, s) => n + s.qty, 0);
+      const have = stock.filter((s) => sameItemClass(s.gtin, line.gtin) && s.sellable && this.locations.get(s.location)?.type === "storage").reduce((n, s) => n + s.qty, 0);
       const short = line.requested - have;
       if (short <= 0) continue;
       const plan = planMakeToOrder(line.gtin, short, ops, stock, locations);
@@ -7514,7 +7804,7 @@ var WmsKernel = class extends FlowEngine {
   }
   /** 부품을 작업대로 — 팔레트 이동이므로 피킹과 같은 기제다(부분 소비는 코어가 한다). */
   issueFeed(o, gtin, from, to, qty) {
-    const src = [...this.items.values()].find((i) => i.gtin === gtin && i.location === from && i.disposition === DISP.sellable);
+    const src = [...this.items.values()].find((i) => sameItemClass(i.gtin, gtin) && i.location === from && i.disposition === DISP.sellable);
     if (!src) return;
     src.disposition = DISP.reserved;
     this.pushTask(o, "feed", src.epc, from, to);
@@ -7592,7 +7882,7 @@ var WmsKernel = class extends FlowEngine {
     order.fulfilled += allocatedQty(order.allocated);
     if (order.lines) for (const epc of order.picked) {
       const g = this.items.get(epc)?.gtin;
-      const line = order.lines.find((l) => l.gtin === g && l.requested > 0);
+      const line = order.lines.find((l) => sameItemClass(l.gtin, g) && l.requested > 0);
       if (line) line.requested--;
     }
     for (const epc of order.picked) {
@@ -8433,7 +8723,7 @@ The steps are the source of truth for execution order; the hierarchy only names
       if (fromType) {
         for (const n of locsOfType.get(fromType) ?? []) {
           for (const i of this.items.at(n.id)) {
-            if (i.gtin === g && i.disposition === DISP.sellable) available.push({ epc: i.epc, location: i.location, qty: 1 });
+            if (sameItemClass(i.gtin, g) && i.disposition === DISP.sellable) available.push({ epc: i.epc, location: i.location, qty: 1 });
           }
         }
       } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@operato/twin-kernel",
-  "version": "0.11.23",
+  "version": "0.11.25",
   "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.9.33"
+    "@operato/ops-contract": "^0.9.36"
   }
 }