@operato/twin-kernel 0.11.18 → 0.11.20

package/README.md

@@ -221,6 +221,6 @@ Host binding (transport, persistence, connectors) · board binding (component
 
 - [`fold-and-resume.md`](../../design/fold-and-resume.md) — folding and resume points (the wrong turns, the principles, what is implemented)
 - [`runtime-state-model.md`](../../design/runtime-state-model.md) — live = authority / history = derived, the time axis, identity
-- [`04-decisions.md`](../../design/04-decisions.md) — ADRs
+- `operato-application/adr/` — ADRs
 - `plans/simulation-spec.md` (specs, estimators, forecast standing) · `plans/four-resources-and-conformance.md` (four resources, invariants) · `plans/kernel-unification-live-observe.md` (driver unification)
 - `profiles/ems.md` — the energy profile's standard anchors

package/dist/allocation-policy.d.ts

@@ -1,3 +1,4 @@
+import type { AllocatedQuantity, AllocationPolicyName } from '@operato/ops-contract';
 /** 배치(placement) 대상 후보 슬롯의 관측 뷰 (내부 상태 누출 없이 결정에 필요한 만큼만). */
 export interface SlotView {
     id: string;
@@ -11,6 +12,19 @@ export interface StockView {
     location: string;
     qty: number;
     expiry?: number;
+    /**
+     * **이 재고가 들어온 시각**(sim-ms) — 출처는 receiving 관측의 `eventTime` 이다(수집 시각이 아니다).
+     *
+     * ── 없는 값이 있다 ──────────────────────────────────────────────────────────
+     * 씨앗으로 선 재고, 입고 기록 없이 서 있던 재고는 이 값을 갖지 않는다. **없음을 시각으로 메우지
+     * 않는다** — 0 으로 두면 가장 오래된 것이 되어 먼저 나가고, 지금 시각으로 두면 영영 안 나간다.
+     * 둘 다 없는 근거로 순서를 정하는 것이다.
+     *
+     * 지금 이 값을 읽는 정책은 없다(닫힌 목록 셋 중 시각을 보는 것은 없다 — `firstFit` 은 식별자 순이다).
+     * 「먼저 들어온 것 먼저」를 실제로 하는 정책이 설 때, 시각 없는 재고를 어디에 세울지는 그 정책이
+     * 한 곳에서 선언한다.
+     */
+    receivedAtMs?: number;
 }
 export interface PlacementContext {
     item: {
@@ -39,8 +53,18 @@ export interface StockRequest {
 export interface AllocationPolicy {
     /** 배치 목적지 슬롯 id. 수용 불가면 null(도크 대기 → 다음 tick 재시도). */
     selectPlacement(ctx: PlacementContext): string | null;
-    /** 이번 라운드에 할당할 재고 epc 목록(부분 가능). 빈 배열 = 이번엔 할당 보류. */
-    selectStock(ctx: StockRequest): readonly string[];
+    /**
+     * 이번 라운드에 잡을 **줄들**(부분 가능). 빈 배열 = 이번엔 할당 보류.
+     *
+     * ── 왜 줄인가 (2026-09-19, ADR-0076 보탬) ─────────────────────────────────
+     * 예전에는 EPC 목록이었고 **줄 수**를 셌다(`total++`). 한 EPC = 한 개라는 전제였고, 그래서
+     * 「100 중 30」을 표현할 수 없었다 — 수량 로트를 다루는 창고와 MES 의 자재 확보(밀가루 3.5kg)가
+     * 그 전제 밖이다. 이제 각 줄이 자기 수를 들고, 마지막 줄은 요청에 맞춰 일부만 잡을 수 있다.
+     *
+     * 열쇠의 낱말은 `epc` 그대로다 — 수량 로트의 줄도 그 식별자로 불린다(한 개념에 낱말 둘을 만들지
+     * 않는다).
+     */
+    selectStock(ctx: StockRequest): readonly AllocatedQuantity[];
 }
 /**
  * 기본 정책 — first-fit slot + all-or-nothing 오더 할당.
@@ -57,3 +81,18 @@ export declare const partialFitPolicy: AllocationPolicy;
  * all-or-nothing(전량 확보 전 대기)이되 선택 순서는 만료 오름차순(동률은 epc). 코어 수정 없이 정책 교체만으로 확장(원칙 2).
  */
 export declare const fefoPolicy: AllocationPolicy;
+/**
+ * 이름 → 정책 — **닫힌 목록**(계약의 `ALLOCATION_POLICY`).
+ *
+ * 선언은 「이 현장은 어느 규칙으로 고르나」이고(트윈 모델의 `allocationPolicy`), 그것을 창고 앱과
+ * 커널이 **같이** 읽는다. 등록부가 없으면 선언이 이름만 남고 커널은 계속 기본 정책으로 돈다 —
+ * 그러면 트윈이 그 창고의 미래를 다른 규칙으로 실행한다(ADR-0076 결정 1).
+ */
+export declare const ALLOCATION_POLICIES: Record<AllocationPolicyName, AllocationPolicy>;
+/**
+ * 선언한 이름의 정책을 찾는다. **모르는 이름은 거절한다** — 기본값으로 조용히 떨어지면 선언한
+ * 규칙과 도는 규칙이 갈리고, 그 사실은 아무 데도 나타나지 않는다.
+ *
+ * 선언이 없으면(`undefined`) 기본 정책이다 — 선언하지 않은 현장은 지금까지와 같이 돈다.
+ */
+export declare function allocationPolicyOf(name: string | undefined | null): AllocationPolicy;

package/dist/allocation-policy.js

@@ -5,6 +5,7 @@
  * 결정은 정책에 위임한다. 고객은 FIFO/FEFO/nearest/zone·부분할당 등을 정책 교체로만
  * 확장 — 코어 수정 없이. (설계 gap #5 "할당 정책 플러그")
  */
+import { ALLOCATION_POLICY } from '@operato/ops-contract';
 /*
  * ── 식별자 비교에 `localeCompare` 를 쓰지 않는다 (2026-08-21 프로파일) ───────
  *
@@ -37,24 +38,60 @@ function freeBinsFirstFit(slots) {
  * 작은 정렬 버퍼를 들고 한 번 순회한다. k 가 작을 때(오더가 요구하는 수는 보통 한 자리다) 전량 정렬보다
  * 훨씬 싸고, 결과는 정렬한 뒤 앞의 k 개와 **같다**.
  */
-function smallestByEpc(available, k) {
-    if (k <= 0)
+/*
+ * 줄 하나가 든 수 — **틱의 뜨거운 길**이라 흔한 경우를 먼저 본다(`Number()` 변환을 태우지 않는다).
+ * 값이 수가 아니거나 0 이하면 0 이다: 그 줄에서 잡을 수 있는 것이 없다는 뜻이고, 「모른다」를 1 로
+ * 메우면 없는 재고를 잡는다.
+ */
+function qtyOf(s) {
+    const q = s?.qty;
+    return typeof q === 'number' && q > 0 && q < Infinity ? q : 0;
+}
+function smallestByEpc(available, need) {
+    if (need <= 0)
         return { picked: [], total: 0 };
     const out = [];
+    /* 버퍼가 들고 있는 수 — 요청을 덮는 **가장 짧은 앞머리**만 남긴다. */
+    let held = 0;
     let total = 0;
     for (const s of available) {
-        total++;
-        if (out.length === k && byId(s.epc, out[out.length - 1].epc) >= 0)
+        const q = qtyOf(s);
+        total += q;
+        if (q === 0)
+            continue;
+        /* 이미 덮었고 이 줄이 마지막 것보다 뒤면 볼 것 없다 — 순회 한 번을 지키는 자리다. */
+        if (held >= need && byId(s.epc, out[out.length - 1].epc) >= 0)
             continue;
         let i = out.length;
         while (i > 0 && byId(out[i - 1].epc, s.epc) > 0)
             i--;
         out.splice(i, 0, s);
-        if (out.length > k)
-            out.pop();
+        held += q;
+        /* 뒤에서부터 덜어 낸다 — 빼도 여전히 덮이면 그 줄은 필요 없다. */
+        while (out.length > 0 && held - qtyOf(out[out.length - 1]) >= need)
+            held -= qtyOf(out.pop());
     }
     return { picked: out, total };
 }
+/**
+ * 고른 줄들에서 요청한 **수만큼** 떼어 낸다 — 마지막 줄은 일부만 잡힐 수 있다.
+ *
+ * 「100 중 30」이 여기서 생긴다. 직렬 물품(`qty: 1`)은 예전과 같이 줄마다 하나씩이다.
+ */
+function takeFrom(views, need) {
+    const out = [];
+    let left = need;
+    for (const s of views) {
+        if (left <= 0)
+            break;
+        const take = Math.min(left, qtyOf(s));
+        if (take <= 0)
+            continue;
+        out.push({ epc: s.epc, qty: take });
+        left -= take;
+    }
+    return out;
+}
 /**
  * 기본 정책 — first-fit slot + all-or-nothing 오더 할당.
  * (재고가 요청 전량을 못 채우면 이번 라운드 보류 → 전량 확보 시 단일 출하.)
@@ -62,11 +99,11 @@ function smallestByEpc(available, k) {
 export const firstFitPolicy = {
     selectPlacement: ({ slots }) => freeBinsFirstFit(slots),
     selectStock: ({ qty, available }) => {
-        /* 고르는 것과 세는 것을 **한 번의 순회**로 한다 — 전량 확보 판정에 개수가 필요하다. */
+        /* 고르는 것과 세는 것을 **한 번의 순회**로 한다 — 전량 확보 판정에 총수가 필요하다. */
         const { picked, total } = smallestByEpc(available, qty);
         if (total < qty)
-            return []; // 전량 확보 전엔 대기
-        return picked.map(s => s.epc);
+            return []; // 전량 확보 전엔 대기 — 세는 것은 줄 수가 아니라 수다
+        return takeFrom(picked, qty);
     }
 };
 /**
@@ -75,7 +112,7 @@ export const firstFitPolicy = {
  */
 export const partialFitPolicy = {
     selectPlacement: ({ slots }) => freeBinsFirstFit(slots),
-    selectStock: ({ qty, available }) => smallestByEpc(available, qty).picked.map(s => s.epc)
+    selectStock: ({ qty, available }) => takeFrom(smallestByEpc(available, qty).picked, qty)
 };
 /**
  * FEFO 정책 — First-Expired-First-Out. 만료 임박 로트를 먼저 출고(신선/제약 도메인).
@@ -86,9 +123,38 @@ export const fefoPolicy = {
     selectStock: ({ qty, available }) => {
         /* 만료 순이 필요하므로 전체를 펼친다 — 이 정책이 실제로 필요해서 치르는 비용이다. */
         const all = [...available];
-        if (all.length < qty)
+        const total = all.reduce((sum, s) => sum + qtyOf(s), 0);
+        if (total < qty)
             return []; // 전량 확보 전엔 대기
         const byExpiry = all.sort((a, b) => (a.expiry ?? Infinity) - (b.expiry ?? Infinity) || byId(a.epc, b.epc));
-        return byExpiry.slice(0, qty).map(s => s.epc);
+        return takeFrom(byExpiry, qty);
     }
 };
+/**
+ * 이름 → 정책 — **닫힌 목록**(계약의 `ALLOCATION_POLICY`).
+ *
+ * 선언은 「이 현장은 어느 규칙으로 고르나」이고(트윈 모델의 `allocationPolicy`), 그것을 창고 앱과
+ * 커널이 **같이** 읽는다. 등록부가 없으면 선언이 이름만 남고 커널은 계속 기본 정책으로 돈다 —
+ * 그러면 트윈이 그 창고의 미래를 다른 규칙으로 실행한다(ADR-0076 결정 1).
+ */
+export const ALLOCATION_POLICIES = {
+    [ALLOCATION_POLICY.firstFit]: firstFitPolicy,
+    [ALLOCATION_POLICY.partialFit]: partialFitPolicy,
+    [ALLOCATION_POLICY.fefo]: fefoPolicy
+};
+/**
+ * 선언한 이름의 정책을 찾는다. **모르는 이름은 거절한다** — 기본값으로 조용히 떨어지면 선언한
+ * 규칙과 도는 규칙이 갈리고, 그 사실은 아무 데도 나타나지 않는다.
+ *
+ * 선언이 없으면(`undefined`) 기본 정책이다 — 선언하지 않은 현장은 지금까지와 같이 돈다.
+ */
+export function allocationPolicyOf(name) {
+    const key = String(name ?? '').trim();
+    if (!key)
+        return firstFitPolicy;
+    const found = ALLOCATION_POLICIES[key];
+    if (!found) {
+        throw new Error(`unknown allocation policy "${key}" — declare one of: ${Object.keys(ALLOCATION_POLICIES).join(' · ')}`);
+    }
+    return found;
+}

package/dist/flow-engine.d.ts

@@ -1,4 +1,4 @@
-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, DispositionFact } from '@operato/ops-contract';
+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, DispositionFact, AllocatedQuantity, MaterialLotUse } 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';
@@ -42,6 +42,16 @@ export interface FlowItem {
     /** 이 물류단위를 싣고 있는 반복사용 자산(GRAI) — `parent` 와 다른 축. */
     carriedBy?: string;
     expiry?: number;
+    /**
+     * **이 재고가 들어온 시각**(sim-ms) — receiving 관측의 `eventTime` 이다(수집 시각이 아니다).
+     *
+     * 「먼저 들어온 것 먼저」를 실제로 하려면 이 축이 있어야 한다 — 지금 시각 축은 만료(`expiry`)
+     * 뿐이고, 그래서 `firstFit` 은 FIFO 가 아니라 식별자 순이다(ADR-0076 정정 ②).
+     *
+     * **없는 값이 있다**: 씨앗으로 선 재고, 입고 기록 없이 서 있던 재고. 없음을 시각으로 메우지
+     * 않는다 — 0 도 지금도 없는 근거다(§`StockView.receivedAtMs`).
+     */
+    receivedAtMs?: number;
     /** 개체·로트 마스터데이터 원문 — 생겨날 때 정해지고 뒤 이벤트가 지우지 않는다. */
     ilmd?: Record<string, unknown>;
     /** 선언된 모든 수량 — 표준 `MaterialLot.Quantity`(복수). 관측에서 온 물품이 여러 단위를 들 수 있다. */
@@ -53,6 +63,13 @@ export interface FlowItem {
      */
     nonconformance?: DispositionFact;
     status?: string;
+    /**
+     * 그 상태의 **효과** — 이 로트를 쓸 수 있나(계약 `MATERIAL_LOT_USE`). 할당이 읽는 유일한 칸이다.
+     *
+     * 낱말(`status`)은 현장의 것이라 커널이 읽지 않는다 — 읽으면 현장이 다른 낱말을 쓰는 날 보류가
+     * 조용히 할당에 든다. **없으면 「모름」이다**(`allowed` 가 아니다).
+     */
+    use?: MaterialLotUse;
 }
 /** 물리 자산 — 반복사용(팔레트·랙·용기). 설비도 물품도 아니다(GRAI vs SSCC 구분은 계약 주석 참조). */
 export interface FlowAsset extends EffectivePeriod {
@@ -239,7 +256,20 @@ export interface FlowTask {
 export interface OrderLine {
     gtin: string;
     requested: number;
+    /** 이 줄이 이행한 수 — 입고 오더는 「몇 개 받았나」다. */
+    fulfilled?: number;
+    /**
+     * 이 줄이 **잡아 둔 수** — 「100 중 30 을 잡았다」의 30(계약 `ObservedOrderLine.allocated`).
+     *
+     * 전량 확보는 물류단위의 처분 관측으로도 나가지만 부분 확보는 그렇게 적을 수 없다(나머지까지
+     * 잡힌 것으로 읽힌다 — ADR-0076 결정 2 의 정정). 그 수가 사는 자리가 여기다.
+     */
+    allocated?: number;
 }
+/** 잡아 둔 줄들의 **합계** — 줄 수가 아니라 수다(직렬 물품은 둘이 같다). */
+export declare function allocatedQty(rows: readonly AllocatedQuantity[] | undefined): number;
+/** 잡아 둔 줄들의 식별자 — EPCIS 이벤트가 싣는 것은 열쇠뿐이다. */
+export declare function allocatedEpcs(rows: readonly AllocatedQuantity[] | undefined): string[];
 export interface FlowOrder {
     id: string;
     kind: string;
@@ -247,7 +277,13 @@ export interface FlowOrder {
     requested: number;
     fulfilled: number;
     bizTransaction: string;
-    allocated: string[];
+    /**
+     * 이 오더가 잡아 둔 줄들 — **무엇을 얼마나**(계약 `AllocatedQuantity`).
+     *
+     * 2026-09-19 에 EPC 목록에서 넓혔다: 한 EPC = 한 개라는 전제가 수량 로트(케이스 100 중 30 ·
+     * 밀가루 3.5kg)를 적지 못했다. 직렬 물품은 `qty: 1` 이고 거동이 같다.
+     */
+    allocated: AllocatedQuantity[];
     picked: string[];
     gtin?: string;
     shipmentEpc?: string | null;
@@ -633,6 +669,8 @@ export declare abstract class FlowEngine implements TwinKernel {
      * 부족한 씨앗 위에서 낸 답을 완전한 답으로 읽는다.
      */
     private seedDanglingRefs;
+    /** 로트 상태를 모르는 채로 할당 후보에 든 수 — 「모름」을 안전으로 읽지 않기 위한 셈(ADR-0080 결정 2). */
+    private allocatedWithUnknownLotUse;
     private transformInputsAbsent;
     /**
      * 일반 요구(공정)와 구체 요구(레시피 × 공정)가 **등급 ↔ 품목으로 교차**한 횟수.
@@ -771,6 +809,19 @@ export declare abstract class FlowEngine implements TwinKernel {
      * 그래서 심을 때 맞춘다. **없는 물품을 만들어 채우지 않는다** — 채우면 계보와 재고가 거짓 위에 선다.
      * 대신 몇 건이 맞지 않았는지 남겨 씨앗이 불완전했다는 사실을 답에 실을 수 있게 한다.
      */
+    /**
+     * **이 로트를 할당 후보에 넣어도 되나** — 판정은 이 한 곳이다(ADR-0080 결정 2).
+     *
+     * 읽는 것은 효과(`use`)뿐이고 낱말(`status`)은 읽지 않는다. 낱말을 읽으면 현장이 `quarantine` ·
+     * `검사대기` 를 쓰는 날 **오류 없이** 보류된 로트가 할당에 든다.
+     *
+     * **말해 주지 않은 로트는 「모름」이다.** 지금 거동 그대로 후보에 넣되 그 수를 센다 — 멈추면 로트
+     * 상태를 아직 안 보내는 현장의 트윈이 통째로 서고, 「모름」을 안전으로 읽으면 보류가 새는 것을
+     * 아무도 모른다. 답에 실린 그 수가 「이 원본은 아직 상태를 안 보낸다」를 말한다.
+     */
+    protected usableLot(item: {
+        use?: MaterialLotUse;
+    }): boolean;
     private resolvedAllocated;
     hydrateObserved(snap: {
         locations: LocationState[];

package/dist/flow-engine.js

@@ -13,7 +13,9 @@ import { OP_EVENT, CMD, USE_UOM, locationStatusOf, readBoardEquipment, equipment
 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 { OP_PARAM } from '@operato/ops-contract';
 import { parseIsoDuration } from '@operato/ops-contract';
 import { analyzeCapacity } from '@operato/ops-contract';
@@ -33,6 +35,14 @@ function effectiveOnly(r) {
         ...(r.effectiveEnd ? { effectiveEnd: r.effectiveEnd } : {})
     };
 }
+/** 잡아 둔 줄들의 **합계** — 줄 수가 아니라 수다(직렬 물품은 둘이 같다). */
+export function allocatedQty(rows) {
+    return (rows ?? []).reduce((sum, a) => sum + (Number(a?.qty) || 0), 0);
+}
+/** 잡아 둔 줄들의 식별자 — EPCIS 이벤트가 싣는 것은 열쇠뿐이다. */
+export function allocatedEpcs(rows) {
+    return (rows ?? []).map(a => a.epc);
+}
 function mulberry32(seed) {
     let a = seed >>> 0;
     const fn = (() => {
@@ -743,6 +753,8 @@ export class FlowEngine {
      * 부족한 씨앗 위에서 낸 답을 완전한 답으로 읽는다.
      */
     seedDanglingRefs = 0;
+    /** 로트 상태를 모르는 채로 할당 후보에 든 수 — 「모름」을 안전으로 읽지 않기 위한 셈(ADR-0080 결정 2). */
+    allocatedWithUnknownLotUse = 0;
     transformInputsAbsent = 0;
     /**
      * 일반 요구(공정)와 구체 요구(레시피 × 공정)가 **등급 ↔ 품목으로 교차**한 횟수.
@@ -784,6 +796,18 @@ export class FlowEngine {
     // ── TwinKernel (mechanics, 도메인 무관) ───────────────────────────────────
     loadTwinModel(def) {
         this.boardDef = def;
+        /*
+         * **선언한 규칙으로 고른다** (2026-09-19, ADR-0076 결정 1).
+         *
+         * 고르는 일은 기록의 주인(창고 앱)이 하고 예측 · what-if 는 커널이 한다. 둘이 같은 선언을 읽지
+         * 않으면 트윈이 그 현장의 미래를 **다른 규칙으로** 실행한다. 선언이 없으면 생성자가 준 정책
+         * 그대로다 — 지금까지 세운 트윈은 아무것도 바뀌지 않는다.
+         *
+         * 모르는 이름은 `allocationPolicyOf` 가 거절한다. 기본값으로 조용히 떨어지면 선언한 규칙과 도는
+         * 규칙이 갈리고 그 사실이 아무 데도 나타나지 않는다.
+         */
+        if (def.allocationPolicy)
+            this.policy = allocationPolicyOf(def.allocationPolicy);
         /*
          * **생산 선언은 어느 커널이든 싣는다.** 예전에는 MES 커널만 생성자에서 이것을 실었고(그 시절
          * 이름은 `mesSpec` 이었다), 그래서 창고 트윈은 "자재를 소비해 자재를 산출하는 공정" 을 선언할
@@ -980,11 +1004,28 @@ export class FlowEngine {
      * 그래서 심을 때 맞춘다. **없는 물품을 만들어 채우지 않는다** — 채우면 계보와 재고가 거짓 위에 선다.
      * 대신 몇 건이 맞지 않았는지 남겨 씨앗이 불완전했다는 사실을 답에 실을 수 있게 한다.
      */
+    /**
+     * **이 로트를 할당 후보에 넣어도 되나** — 판정은 이 한 곳이다(ADR-0080 결정 2).
+     *
+     * 읽는 것은 효과(`use`)뿐이고 낱말(`status`)은 읽지 않는다. 낱말을 읽으면 현장이 `quarantine` ·
+     * `검사대기` 를 쓰는 날 **오류 없이** 보류된 로트가 할당에 든다.
+     *
+     * **말해 주지 않은 로트는 「모름」이다.** 지금 거동 그대로 후보에 넣되 그 수를 센다 — 멈추면 로트
+     * 상태를 아직 안 보내는 현장의 트윈이 통째로 서고, 「모름」을 안전으로 읽으면 보류가 새는 것을
+     * 아무도 모른다. 답에 실린 그 수가 「이 원본은 아직 상태를 안 보낸다」를 말한다.
+     */
+    usableLot(item) {
+        if (item.use === 'blocked')
+            return false;
+        if (item.use === undefined)
+            this.allocatedWithUnknownLotUse++;
+        return true;
+    }
     resolvedAllocated(allocated) {
         const all = allocated ?? [];
         if (!all.length)
             return { kept: [], dropped: 0 };
-        const kept = all.filter(epc => this.items.has(epc));
+        const kept = all.filter(a => this.items.has(a.epc));
         const dropped = all.length - kept.length;
         this.seedDanglingRefs += dropped;
         return { kept, dropped };
@@ -1041,7 +1082,9 @@ export class FlowEngine {
                  * 넣다가 `nonconformance` 도 여기서 빠져 있던 것을 찾았다 — 자리는 있고 길이 없는 부류). 있을 때만 옮긴다.
                  */
                 ...(it.nonconformance ? { nonconformance: it.nonconformance } : {}),
-                ...(it.status ? { status: it.status } : {})
+                ...(it.status ? { status: it.status } : {}),
+                /* 그 상태의 효과 — 이 칸이 빠지면 미러가 보류를 알고도 할당이 모른다(ADR-0080 결정 2). */
+                ...(it.use ? { use: it.use } : {})
             });
         }
         for (const m of snap.equipment) {
@@ -1645,11 +1688,12 @@ export class FlowEngine {
             nowTime: this.now(), // 트윈의 "지금" — 관측 모드면 마지막으로 들은 시각(§nowMs)
             identityGrounding: this.identityGroundingView(),
             /* 원본과 어긋난 사실 — 0 이면 싣지 않는다(어긋난 적 없는 트윈에 빈 칸을 만들지 않는다). */
-            ...(this.transformInputsAbsent || this.seedDanglingRefs || this.materialSpecCrossKeyOverlaps
+            ...(this.transformInputsAbsent || this.seedDanglingRefs || this.materialSpecCrossKeyOverlaps || this.allocatedWithUnknownLotUse
                 ? { conformance: {
                         ...(this.transformInputsAbsent ? { transformInputsAbsent: this.transformInputsAbsent } : {}),
                         ...(this.seedDanglingRefs ? { seedDanglingRefs: this.seedDanglingRefs } : {}),
-                        ...(this.materialSpecCrossKeyOverlaps ? { materialSpecCrossKeyOverlaps: this.materialSpecCrossKeyOverlaps } : {})
+                        ...(this.materialSpecCrossKeyOverlaps ? { materialSpecCrossKeyOverlaps: this.materialSpecCrossKeyOverlaps } : {}),
+                        ...(this.allocatedWithUnknownLotUse ? { allocatedWithUnknownLotUse: this.allocatedWithUnknownLotUse } : {})
                     } }
                 : {}),
             /* 출처 표시 — 트윈 모델(마스터)에서 온 자리다. 미러는 관측으로 알게 된 자리를 'observed' 로 구별하는데,
@@ -3879,7 +3923,9 @@ export class FlowEngine {
             ...(i.ilmd ? { ilmd: i.ilmd } : {}),
             /* 로트의 두 표준 칸(§FlowItem) — 여기서 빠지면 리듀서·엔진에는 있고 스냅샷에는 없다. */
             ...(i.nonconformance ? { nonconformance: i.nonconformance } : {}),
-            ...(i.status ? { status: i.status } : {})
+            ...(i.status ? { status: i.status } : {}),
+            /* 그 상태의 효과 — 화면과 다음 씨앗이 읽는다(§`ItemState.use`). */
+            ...(i.use ? { use: i.use } : {})
         };
     }
     /**
@@ -3934,7 +3980,12 @@ export class FlowEngine {
     processOrders() {
         /* **우선순위 순으로 할당한다** — 표준 `OperationsRequest.Priority`. 같은 우선순위는 입력 순서를
            지켜 결정성을 잃지 않는다(정렬이 안정적이어야 같은 seed 가 같은 결과를 낸다). */
-        const pending = [...this.orders.values()].filter(o => o.status === 'created' && !o.held);
+        /*
+         * **입고 오더는 고르기의 대상이 아니다** (2026-09-19). 그 오더가 기다리는 것은 재고가 아니라
+         * 물건의 도착이고, 커널이 그것을 고를 수는 없다. 걸러 내지 않으면 `allocate` 가 매 틱마다 라인을
+         * 들고 재고를 뒤지고, 못 찾아 `shortage` 를 적는다 — 「입고 대기」가 「자재 부족」으로 보인다.
+         */
+        const pending = [...this.orders.values()].filter(o => o.status === 'created' && !o.held && o.kind !== WMS_ORDER_KIND.inbound);
         if (pending.some(o => o.priority !== undefined))
             pending.sort((a, b) => priorityRank(a.priority) - priorityRank(b.priority));
         for (const o of pending)

package/dist/kernel.js

@@ -7,7 +7,7 @@
  */
 import { CMD } from '@operato/ops-contract';
 import { firstFitPolicy } from "./allocation-policy.js";
-import { FlowEngine } from "./flow-engine.js";
+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';
@@ -64,7 +64,11 @@ export class WmsKernel extends FlowEngine {
         /* 방출한 마스터데이터를 **상태에도 들고 있는다** — 자기가 선언한 것을 자기가 모르면, 미러는 알고
          * 시뮬은 모르는 비대칭이 생긴다(파리티 테스트가 잡은 바로 그 종류). */
         const ilmd = { [ILMD_ATTR.expiry]: expiry };
-        this.items.set(epc, { epc, gtin, qty, location: dock.id, disposition: DISP.in_progress, expiry, ilmd });
+        /*
+         * 들어온 시각을 재고가 들고 있는다 — 「먼저 들어온 것 먼저」를 할 수 있는 유일한 근거다.
+         * 값은 **receiving 이 일어난 시각**이고(수집 시각이 아니다), 여기서는 그 둘이 같다.
+         */
+        this.items.set(epc, { epc, gtin, 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 }));
@@ -152,17 +156,28 @@ 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 = o.allocated.filter(e => this.items.get(e)?.gtin === line.gtin).length;
+            const already = allocatedQty(o.allocated.filter(a => this.items.get(a.epc)?.gtin === line.gtin));
             const need = line.requested - already;
             if (need <= 0)
                 continue;
+            /*
+             * ── 이 커널이 잡는 단위는 **팔레트 하나**다 (2026-09-19) ────────────────
+             *
+             * 요청(`line.requested`)도 팔레트 수이고, 뒤의 걸음(pick · pack · 라인 차감)이 전부 팔레트를
+             * 하나씩 움직인다. 그래서 후보 줄도 **1** 을 낸다 — 팔레트 안의 케이스 수(`i.qty`)를 내면
+             * 요청과 단위가 갈려 두 배로 잡는다.
+             *
+             * 수량으로 잡는 쪽은 MES 의 자재 확보다(밀가루 3.5kg — `mes-kernel.ts`). 시임은 두 단위를
+             * 모두 표현할 수 있고, **단위를 정하는 것은 부르는 쪽**이다.
+             */
             const available = [...this.items.values()]
                 .filter(i => i.gtin === line.gtin && i.disposition === DISP.sellable && this.locations.get(i.location)?.type === 'storage')
-                .map(i => ({ epc: i.epc, location: i.location, qty: i.qty ?? 1, expiry: i.expiry }));
+                .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 });
-            for (const epc of chosen) {
-                o.allocated.push(epc);
-                chosenAll.push(epc);
+            for (const row of chosen) {
+                o.allocated.push(row);
+                chosenAll.push(row.epc);
             }
         }
         /*
@@ -369,7 +384,7 @@ export class WmsKernel extends FlowEngine {
         order.status = 'packed';
         this.emit(objectEvent({ eventTime, action: 'OBSERVE', bizStep: BIZSTEP.staging_outbound, disposition: DISP.reserved, epcList: [shipment], readPoint: staging.id, bizLocation: staging.id, bizTransactionList: soTxn }));
         this.emit(objectEvent({ eventTime, action: 'DELETE', bizStep: BIZSTEP.shipping, disposition: DISP.in_transit, epcList: [shipment], readPoint: shipDock.id, bizTransactionList: soTxn }));
-        order.fulfilled += order.allocated.length;
+        order.fulfilled += allocatedQty(order.allocated);
         // 라인 잔량 차감(멀티SKU 백오더) — 출하 팔레트의 gtin 으로 라인 매핑(라인 SKU distinct).
         if (order.lines)
             for (const epc of order.picked) {

package/dist/mes-kernel.js

@@ -10,7 +10,7 @@
  */
 import { identityGroundingOf, procedureViolations } from '@operato/ops-contract';
 import { firstFitPolicy } from "./allocation-policy.js";
-import { FlowEngine } from "./flow-engine.js";
+import { FlowEngine, allocatedEpcs, allocatedQty } from "./flow-engine.js";
 import { DISP, objectEvent, transactionEvent, gdtiUri, sgtinClass, bizTransactionUri } from '@operato/ops-contract';
 import { MES_BIZSTEP, BTT_PRODORDER, sgtinUri } from '@operato/ops-contract';
 import { OP_PARAM } from '@operato/ops-contract';
@@ -426,8 +426,9 @@ export class MesKernel extends FlowEngine {
         const order = t.orderId ? this.orders.get(t.orderId) : undefined;
         if (!order)
             return false;
+        /* 자리가 만든 것도 오더가 들고 있는 것에 들어간다 — 직렬 개체라 줄마다 하나다. */
         for (const epc of epcs)
-            order.allocated.push(epc);
+            order.allocated.push({ epc, qty: 1 });
         return true;
     }
     // ── 정의-구동 모드 (도메인 정의 데이터로 실행 — 레거시와 분리, 하드코딩 대체) ──
@@ -818,12 +819,12 @@ export class MesKernel extends FlowEngine {
             }
             else {
                 for (const i of this.items.ofGtin(g)) {
-                    if (i.disposition === DISP.sellable)
+                    if (i.disposition === DISP.sellable && this.usableLot(i))
                         available.push({ epc: i.epc, location: i.location, qty: 1 });
                 }
             }
             const chosen = this.policy.selectStock({ gtin: g, qty: line.qty, available });
-            if (chosen.length < line.qty) {
+            if (allocatedQty(chosen) < line.qty) {
                 /*
                  * **왜 대기하는지 남긴다** (2026-08-21).
                  *
@@ -834,7 +835,7 @@ export class MesKernel extends FlowEngine {
                  * 첫 줄에서 멈추지 않고 **모자란 줄을 다 센다.** 하나만 알려 주면 그것을 채운 뒤 다음 줄에서
                  * 또 막히고, 사람은 같은 진단을 여섯 번 반복한다.
                  */
-                short.push({ material: line.material, need: line.qty, have: chosen.length });
+                short.push({ material: line.material, need: line.qty, have: allocatedQty(chosen) });
                 continue;
             }
             picks.push(...chosen);
@@ -848,11 +849,11 @@ export class MesKernel extends FlowEngine {
         /* 채워졌으면 표시를 지운다 — 남겨 두면 화면이 이미 해결된 것을 계속 말한다. */
         if (o.shortage)
             delete o.shortage;
-        for (const epc of picks)
-            o.allocated.push(epc);
-        this.reserve(picks, MES_BIZSTEP.producing);
-        this.emit(transactionEvent({ eventTime: this.now(), action: 'ADD', bizStep: MES_BIZSTEP.producing, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: o.bizTransaction }], epcList: o.allocated.slice() }));
-        this.emitStationDef(o, ops[0], o.allocated[0]);
+        for (const row of picks)
+            o.allocated.push(row);
+        this.reserve(allocatedEpcs(picks), MES_BIZSTEP.producing);
+        this.emit(transactionEvent({ eventTime: this.now(), action: 'ADD', bizStep: MES_BIZSTEP.producing, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: o.bizTransaction }], epcList: allocatedEpcs(o.allocated) }));
+        this.emitStationDef(o, ops[0], o.allocated[0]?.epc);
         o.status = 'op-' + ops[0].key;
         this.emitOrder(o);
     }
@@ -894,13 +895,13 @@ export class MesKernel extends FlowEngine {
             const producedKey = this.producedMaterialKeyOf(t.kind);
             const next = ops[i + 1];
             if (producedKey) {
-                const inputs = order.allocated.slice();
+                const inputs = allocatedEpcs(order.allocated);
                 const made = this.serialOf(producedKey, ++this.wipSeq);
                 this.transform(inputs, [{ epc: made, gtin: this.classOf(producedKey), qty: 1, location: loc.id, disposition: DISP.in_progress }], { bizStep, disposition: DISP.in_progress, transformationId: order.bizTransaction, readPoint: loc.id, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: order.bizTransaction }] });
-                order.allocated = [made];
+                order.allocated = [{ epc: made, qty: 1 }];
             }
             /* 다음 자리에 무엇을 들고 가는가 — 만든 것이 있으면 그것, 없으면 들고 있던 것. */
-            const carried = order.allocated[0];
+            const carried = order.allocated[0]?.epc;
             /*
              * ── 개체가 없어도 **진행은 막지 않는다** (2026-08-24) ───────────────────────
              * 예전에는 여기서 무조건 던졌다. 그래서 **미러에서 예측이 구조적으로 실패했다**: 미러의 오더는
@@ -962,7 +963,7 @@ export class MesKernel extends FlowEngine {
          *
          * 중간 산출물을 선언한 경로에서는 `allocated` 가 이미 `[made]` 하나이므로 거동이 같다.
          */
-        const consumed = order.allocated.slice();
+        const consumed = allocatedEpcs(order.allocated);
         if (!consumed.length) {
             /*
              * 씨앗이 이 오더의 확보분을 다 심지 못했으면(원본이 말한 물품이 스냅샷에 없었다) 이 오더는

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 { MaterialLotUse } from '@operato/ops-contract';
 import { type VocabularyElement } from '@operato/ops-contract';
 interface ProjItem {
     epc: string;
@@ -14,6 +15,8 @@ interface ProjItem {
     nonconformance?: DispositionFact;
     /** ISA-95 `MaterialLot.Status` — `nonconformance` 와 다른 칸(§계약 `ItemState.status`). 마지막 하나만. */
     status?: string;
+    /** 그 상태의 효과 — 이 로트를 쓸 수 있나(계약 `MATERIAL_LOT_USE`). 없으면 「모름」이다. */
+    use?: MaterialLotUse;
     parent?: string;
     qty?: number;
     uom?: string;

package/dist/observed-reducer.js

@@ -583,8 +583,20 @@ export class ObservedReducer {
                     this.noteUnhandled(e, `${OP_EVENT.materialLot}:unknown-lot`);
                     break;
                 }
-                for (const part of parts)
+                /*
+                 * 낱말과 **효과**를 함께 앉힌다(ADR-0080 결정 2). 낱말은 사람이 읽고, 효과(`use`)는 할당이 읽는다.
+                 *
+                 * 레코드가 효과를 말하지 않으면 **비운다.** 앞의 값을 남기면 원본이 상태를 바꿨는데 효과는 옛
+                 * 결정으로 남는다 — 보류가 풀렸는데 계속 막히거나, 그 반대가 된다. 비어 있는 것은 「모름」이고
+                 * 할당이 그것을 세어 답에 싣는다.
+                 */
+                for (const part of parts) {
                     part.status = d.status;
+                    if (d.use)
+                        part.use = d.use;
+                    else
+                        delete part.use;
+                }
                 break;
             }
             case OP_EVENT.observation: {
@@ -958,6 +970,28 @@ export class ObservedReducer {
         /* 개체 없이 수량만 오는 입고(비직렬 자재) — 표준이 허용하고 검증기도 유효로 판정한다.
          * 이 경우 클래스 식별자 자체가 물품의 키다(로트 관리 자재는 LGTIN 이라 로트별로 갈린다). */
         if (!ev.epcList?.length) {
+            /*
+             * ── 자리를 말하지 않은 수량 관측은 **앉히지 않는다** (2026-09-19, ADR-0082) ──
+             *
+             * 열쇠가 `${epcClass}@${자리}` 이므로 자리가 없으면 `@undefined` 라는 줄이 선다. 그 줄은 어느
+             * 자리의 재고도 아닌데 합에는 든다 — 실측: 자리 있는 100 + 자리 없는 40 = 140, 그리고 아무 데도
+             * 세어지지 않았다.
+             *
+             * **전수로 세어 보니 일부러 그렇게 보내는 원본이 없다** — 수량 관측을 만드는 여덟 자리(chef v1
+             * 셋 · v2 하나 · warehouse 입고 둘 · 출고 둘)가 전부 `readPoint` 를 싣고, sap-ewm · oracle-wms ·
+             * ppms · ems 는 수량 관측을 내지 않는다. 그래서 잃는 원본 없이 닫을 수 있다.
+             *
+             * 「없어졌다」(`DELETE`)는 **건드리지 않는다** — 그쪽에서 자리를 말하지 않은 것은 「그 로트가
+             * 통째로 없어졌다」는 진술이고 위에서 그 범위대로 지운다.
+             *
+             * 순서 판정(`stale`)을 지나지 않는다. 그 함수가 트윈의 「지금」을 미는 유일한 자리인데, 받아들이지
+             * 않은 사실로 시계를 움직이면 이 트윈이 「방금 들었다」고 말하면서 아무것도 앉히지 않은 것이 된다.
+             */
+            if (!loc && (ev.quantityList ?? []).some(qe => qe?.epcClass)) {
+                if (envelope)
+                    this.noteUnhandled(envelope, 'epcis.ObjectEvent:quantity-without-readpoint');
+                return;
+            }
             for (const qe of ev.quantityList ?? []) {
                 if (!qe?.epcClass)
                     continue;

package/dist/yms-kernel.js

@@ -77,7 +77,7 @@ export class YmsKernel extends FlowEngine {
         const id = `order-${++this.orderSeq}`;
         const apSeq = ++this.soSeq;
         const appt = this.requireBizTransactionId(`APPT-${apSeq}`, 'appointment');
-        const order = { id, kind, status: 'created', requested: 1, fulfilled: 0, bizTransaction: appt, allocated: [epc], picked: [], dockDoor: door.id,
+        const order = { id, kind, status: 'created', requested: 1, fulfilled: 0, bizTransaction: appt, allocated: [{ epc, qty: 1 }], picked: [], dockDoor: door.id,
             /* 내부 스케줄 게이트(시뮬 ms) — 표준 `EarliestStartTime` 과 같은 개념의 우리 단위. */
             windowStartMs: this.clockMs + WINDOW_DELAY_MS,
             /* 표준 필드로도 함께 낸다 — 소비처(화면·집계·미러)는 표준 축으로 읽는다.
@@ -105,7 +105,8 @@ export class YmsKernel extends FlowEngine {
      * 하나라도 안 되면 대기(다음 tick 재시도). = 시간창 예약 스케줄링.
      */
     allocate(o) {
-        const trailer = this.items.get(o.allocated[0]);
+        /* 어포인트먼트가 든 것은 트레일러 하나다 — 줄마다 하나이므로 첫 줄의 열쇠를 본다. */
+        const trailer = this.items.get(o.allocated[0]?.epc);
         if (!trailer)
             return;
         if (this.clockMs < (o.windowStartMs ?? 0))

package/dist-cjs/index.cjs

@@ -19,6 +19,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ALLOCATION_POLICIES: () => ALLOCATION_POLICIES,
   ATTENTION_DEFAULTS: () => ATTENTION_DEFAULTS,
   ATTENTION_PROPERTY: () => ATTENTION_PROPERTY,
   ClassMasterTable: () => ClassMasterTable,
@@ -36,6 +37,9 @@ __export(index_exports, {
   TwinRuntime: () => TwinRuntime,
   WmsKernel: () => WmsKernel,
   YmsKernel: () => YmsKernel,
+  allocatedEpcs: () => allocatedEpcs,
+  allocatedQty: () => allocatedQty,
+  allocationPolicyOf: () => allocationPolicyOf,
   attributeEnergy: () => attributeEnergy,
   compareStates: () => compareStates,
   constantDuration: () => constantDuration,
@@ -247,6 +251,7 @@ function locationStatusOf(n) {
   const r = (n.occupancy ?? 0) / cap;
   return r >= 1 ? "full" : r >= LOCATION_SATURATION_NEAR ? "near-full" : "available";
 }
+var MATERIAL_LOT_USE = ["allowed", "blocked"];
 var DISPOSITION_DECISION = [
   /** 원 규격으로 되돌린다 — 공정에 다시 들어가고, 산출물은 원 품목이다. */
   "rework",
@@ -660,15 +665,20 @@ var OP_EVENT = {
    * 로트에도 붙는 상태(released · quarantine · on-hold …). 출하 승인(batch release)이 이 축이다. 처분에 실으면
    * 정상 출하가 전부 부적합 이력이 된다 — 진짜 term 을 틀린 뜻으로 쓰는 것이 자리가 없는 것보다 나쁘다.
    *
-   * ── 낱말은 열려 있다 ──────────────────────────────────────────────────────
-   * 오더 상태와 같은 규율 — 커널이 이 낱말로 무엇을 계산하지 않으므로 닫을 근거가 없다. 도메인이 소유한다.
+   * ── 낱말은 열려 있고, **효과는 닫혀 있다** (2026-09-19, ADR-0080 결정 2) ────
+   * `status` 는 도메인이 소유한다 — 오더 상태와 같은 규율이다. 커널은 그 낱말로 계산하지 않는다.
+   *
+   * 계산하는 것은 **`use`** 다(§`MATERIAL_LOT_USE`): 닫힌 둘이고, 「이 로트를 쓸 수 있나」만 말한다.
+   * 낱말을 읽어 효과를 정하면 현장이 `quarantine` · `검사대기` 를 쓰는 날 조용히 새기 때문이다 —
+   * 자원 속성에서 이미 선 원칙 그대로다(속성은 열리고 효과는 닫힌다). 둘은 같은 레코드에 함께 오고,
+   * 그 낱말의 주인이 짝을 정한다.
    *
    * ── 출발과 다른 사실이다 ─────────────────────────────────────────────────
    * 승인은 자재를 움직이지 않는다. 자재가 트윈 밖으로 나가는 것은 EPCIS `shipping` 사건이다. 둘을 한 사건으로
    * 접지 않는다 — 승인됐는데 안 나간 배치가 트윈이 보여야 할 상태다.
    */
   materialLot: "material-lot.status",
-  // 레코드: { lotId(표준 MaterialLotID = ItemState.epc 의 값), status, decidedBy?, reason?, decidedAt? }
+  // 레코드: { lotId(표준 MaterialLotID = ItemState.epc 의 값), status, use?, decidedBy?, reason?, decidedAt? }
   /**
    * **이 목록이 전부다** — 연결된 시스템이 현재 목록을 한 바퀴 다 보낸 뒤 그것을 알린다.
    *
@@ -814,6 +824,14 @@ var ENERGY_EVENT = {
   drSuggested: "energy.dr.suggested"
 };
 var MATERIAL_ACTUAL_USE = ["consumed", "produced"];
+var ALLOCATION_POLICY = {
+  /** 가장 작은 식별자부터. FIFO 가 아니다 — 입고 시각을 보지 않는다. */
+  firstFit: "firstFit",
+  /** 모자라도 있는 만큼 잡는다. */
+  partialFit: "partialFit",
+  /** 먼저 만료되는 것부터(First Expired, First Out). */
+  fefo: "fefo"
+};
 var CMD = {
   orderHold: "order.hold",
   orderResume: "order.resume",
@@ -1007,7 +1025,12 @@ var BTT = {
   bol: "urn:epcglobal:cbv:btt:bol"
 };
 var WMS_ORDER_KIND = {
-  /** Expected receipt (ASN). The kernel has no inbound order yet — arrival carries a `po` without one. */
+  /**
+   * Expected receipt (ASN) — what was promised to arrive, and how much of it has.
+   *
+   * Flow metrics leave it out: the arrival both raises and fulfils it, so counting it would add a
+   * completed order per arrival and never clear the backlog (`isFlowOrder`).
+   */
   inbound: "inbound",
   /** Outbound order — what the kernel's sales order is. */
   outbound: "outbound",
@@ -1016,6 +1039,7 @@ var WMS_ORDER_KIND = {
   /** Stock transfer between sites. CBV has no document type for it: carry the id without a type. */
   transfer: "transfer"
 };
+var WMS_RECEIVING_ORDER_KINDS = [WMS_ORDER_KIND.inbound, WMS_ORDER_KIND.return];
 var WMS_LOCATION_TYPES = ["dock", "storage", "staging", "dock-ship", "vas-station"];
 var WMS_LOCATION_LEVEL = {
   dock: "StorageZone",
@@ -1939,7 +1963,8 @@ var SPECS = {
       priority: "number",
       startTime: "string",
       endTime: "string",
-      allocated: "string[]",
+      /* 확보분은 `{ epc, qty }` 줄이다(2026-09-19, ADR-0076 보탬) — 옛 EPC 목록은 받지 않는다. */
+      allocated: "object[]",
       bizTransaction: "string",
       operationsRequestId: "string",
       dockDoor: "string",
@@ -1962,6 +1987,17 @@ var SPECS = {
        * 새 어휘가 아니다 — 계약이 `recipeKey` 를 네 자리에서 이미 쓴다. 오더 관측에만 자리가 없었다.
        */
       recipeKey: "string"
+    },
+    /*
+     * 확보분의 안쪽을 본다 — 열쇠와 수 둘이다(§`AllocatedQuantity`). 안 보면 틀린 이름이 조용히
+     * 지나가고(`epcs`·`quantity` 따위), 미러는 잡힌 수를 0 으로 읽는다.
+     */
+    shapes: {
+      allocated: {
+        required: ["epc", "qty"],
+        fields: { epc: "string", qty: "number" },
+        positive: ["qty"]
+      }
     }
     /* 상태·종류는 도메인이 소유한다 — 닫지 않는다. */
   },
@@ -2084,6 +2120,17 @@ var SPECS = {
    * (§`operationalKindOf`). 값은 로트의 식별자(`ItemState.epc` 와 같은 값)다. 상태 낱말은 열려 있어 enum 이
    * 없다(오더 상태와 같은 규율). 로트 전체의 사실이므로 부분(`subLotId`)은 받지 않는다 — 부분마다 다른 상태가
    * 필요해지면 그것은 다른 사실이다.
+   *
+   * ── 낱말은 열리고 **효과는 닫힌다** (2026-09-19, ADR-0080 결정 2) ────────────
+   * `status` 는 현장의 낱말이다(`on-hold` · `quarantine` · `검사대기` — 도메인이 소유한다). 커널이 그
+   * 낱말을 읽어 「보류면 할당에서 뺀다」를 정하면, 현장이 다른 낱말을 쓰는 날 조용히 샌다.
+   *
+   * 그래서 **효과를 따로 싣는다**: `use` 는 닫힌 둘(`allowed` · `blocked`)이고 기계가 읽는다. 낱말의
+   * 주인이 둘을 같이 정한다 — 자원 속성에서 이미 선 원칙 그대로다(속성은 열리고 효과는 닫힌다).
+   *
+   * **`use` 가 없는 레코드는 `allowed` 가 아니라 「모름」이다.** 그래서 필수로 만들지 않는다: 이 문을
+   * 이미 쓰고 있는 원본이 있으면 그 사실이 통째로 거절되는 것이 더 나쁘다. 모르는 것을 할당이 어떻게
+   * 다루는지는 커널이 한 곳에서 정하고 그 수를 센다.
    */
   "material-lot": {
     eventType: OP_EVENT.materialLot,
@@ -2091,7 +2138,8 @@ var SPECS = {
     matchOrder: 85,
     identity: "lotId",
     required: ["lotId", "status"],
-    fields: { lotId: "string", status: "string", decidedBy: "string", reason: "string", decidedAt: "string", recordTime: "string" }
+    fields: { lotId: "string", status: "string", use: "string", decidedBy: "string", reason: "string", decidedAt: "string", recordTime: "string" },
+    enums: { use: MATERIAL_LOT_USE }
   },
   test: {
     eventType: OP_EVENT.test,
@@ -2944,7 +2992,11 @@ var ObservedReducer = class {
           this.noteUnhandled(e, `${OP_EVENT.materialLot}:unknown-lot`);
           break;
         }
-        for (const part of parts) part.status = d.status;
+        for (const part of parts) {
+          part.status = d.status;
+          if (d.use) part.use = d.use;
+          else delete part.use;
+        }
         break;
       }
       case OP_EVENT.observation: {
@@ -3175,6 +3227,10 @@ var ObservedReducer = class {
       this.items.set(itemKeyOf(seen), Number.isFinite(atSeen) ? { ...seen, seenAtMs: atSeen } : seen);
     }
     if (!ev.epcList?.length) {
+      if (!loc && (ev.quantityList ?? []).some((qe) => qe?.epcClass)) {
+        if (envelope) this.noteUnhandled(envelope, "epcis.ObjectEvent:quantity-without-readpoint");
+        return;
+      }
       for (const qe of ev.quantityList ?? []) {
         if (!qe?.epcClass) continue;
         const mine = all.filter((x) => x.epcClass === qe.epcClass);
@@ -3542,41 +3598,76 @@ function freeBinsFirstFit(slots) {
   }
   return best?.id ?? null;
 }
-function smallestByEpc(available, k) {
-  if (k <= 0) return { picked: [], total: 0 };
+function qtyOf(s) {
+  const q = s?.qty;
+  return typeof q === "number" && q > 0 && q < Infinity ? q : 0;
+}
+function smallestByEpc(available, need) {
+  if (need <= 0) return { picked: [], total: 0 };
   const out = [];
+  let held = 0;
   let total = 0;
   for (const s of available) {
-    total++;
-    if (out.length === k && byId(s.epc, out[out.length - 1].epc) >= 0) continue;
+    const q = qtyOf(s);
+    total += q;
+    if (q === 0) continue;
+    if (held >= need && byId(s.epc, out[out.length - 1].epc) >= 0) continue;
     let i = out.length;
     while (i > 0 && byId(out[i - 1].epc, s.epc) > 0) i--;
     out.splice(i, 0, s);
-    if (out.length > k) out.pop();
+    held += q;
+    while (out.length > 0 && held - qtyOf(out[out.length - 1]) >= need) held -= qtyOf(out.pop());
   }
   return { picked: out, total };
 }
+function takeFrom(views, need) {
+  const out = [];
+  let left = need;
+  for (const s of views) {
+    if (left <= 0) break;
+    const take = Math.min(left, qtyOf(s));
+    if (take <= 0) continue;
+    out.push({ epc: s.epc, qty: take });
+    left -= take;
+  }
+  return out;
+}
 var firstFitPolicy = {
   selectPlacement: ({ slots }) => freeBinsFirstFit(slots),
   selectStock: ({ qty, available }) => {
     const { picked, total } = smallestByEpc(available, qty);
     if (total < qty) return [];
-    return picked.map((s) => s.epc);
+    return takeFrom(picked, qty);
   }
 };
 var partialFitPolicy = {
   selectPlacement: ({ slots }) => freeBinsFirstFit(slots),
-  selectStock: ({ qty, available }) => smallestByEpc(available, qty).picked.map((s) => s.epc)
+  selectStock: ({ qty, available }) => takeFrom(smallestByEpc(available, qty).picked, qty)
 };
 var fefoPolicy = {
   selectPlacement: ({ slots }) => freeBinsFirstFit(slots),
   selectStock: ({ qty, available }) => {
     const all = [...available];
-    if (all.length < qty) return [];
+    const total = all.reduce((sum, s) => sum + qtyOf(s), 0);
+    if (total < qty) return [];
     const byExpiry = all.sort((a, b) => (a.expiry ?? Infinity) - (b.expiry ?? Infinity) || byId(a.epc, b.epc));
-    return byExpiry.slice(0, qty).map((s) => s.epc);
+    return takeFrom(byExpiry, qty);
   }
 };
+var ALLOCATION_POLICIES = {
+  [ALLOCATION_POLICY.firstFit]: firstFitPolicy,
+  [ALLOCATION_POLICY.partialFit]: partialFitPolicy,
+  [ALLOCATION_POLICY.fefo]: fefoPolicy
+};
+function allocationPolicyOf(name) {
+  const key = String(name ?? "").trim();
+  if (!key) return firstFitPolicy;
+  const found = ALLOCATION_POLICIES[key];
+  if (!found) {
+    throw new Error(`unknown allocation policy "${key}" \u2014 declare one of: ${Object.keys(ALLOCATION_POLICIES).join(" \xB7 ")}`);
+  }
+  return found;
+}
 
 // src/flow-engine.ts
 var BASE_EPOCH = Date.parse("2026-01-01T00:00:00Z");
@@ -3586,6 +3677,12 @@ function effectiveOnly(r) {
     ...r.effectiveEnd ? { effectiveEnd: r.effectiveEnd } : {}
   };
 }
+function allocatedQty(rows) {
+  return (rows ?? []).reduce((sum, a) => sum + (Number(a?.qty) || 0), 0);
+}
+function allocatedEpcs(rows) {
+  return (rows ?? []).map((a) => a.epc);
+}
 function mulberry32(seed) {
   let a = seed >>> 0;
   const fn = () => {
@@ -4128,6 +4225,8 @@ var FlowEngine = class {
    * 부족한 씨앗 위에서 낸 답을 완전한 답으로 읽는다.
    */
   seedDanglingRefs = 0;
+  /** 로트 상태를 모르는 채로 할당 후보에 든 수 — 「모름」을 안전으로 읽지 않기 위한 셈(ADR-0080 결정 2). */
+  allocatedWithUnknownLotUse = 0;
   transformInputsAbsent = 0;
   /**
    * 일반 요구(공정)와 구체 요구(레시피 × 공정)가 **등급 ↔ 품목으로 교차**한 횟수.
@@ -4169,6 +4268,7 @@ var FlowEngine = class {
   // ── TwinKernel (mechanics, 도메인 무관) ───────────────────────────────────
   loadTwinModel(def) {
     this.boardDef = def;
+    if (def.allocationPolicy) this.policy = allocationPolicyOf(def.allocationPolicy);
     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 };
@@ -4353,10 +4453,25 @@ var FlowEngine = class {
    * 그래서 심을 때 맞춘다. **없는 물품을 만들어 채우지 않는다** — 채우면 계보와 재고가 거짓 위에 선다.
    * 대신 몇 건이 맞지 않았는지 남겨 씨앗이 불완전했다는 사실을 답에 실을 수 있게 한다.
    */
+  /**
+   * **이 로트를 할당 후보에 넣어도 되나** — 판정은 이 한 곳이다(ADR-0080 결정 2).
+   *
+   * 읽는 것은 효과(`use`)뿐이고 낱말(`status`)은 읽지 않는다. 낱말을 읽으면 현장이 `quarantine` ·
+   * `검사대기` 를 쓰는 날 **오류 없이** 보류된 로트가 할당에 든다.
+   *
+   * **말해 주지 않은 로트는 「모름」이다.** 지금 거동 그대로 후보에 넣되 그 수를 센다 — 멈추면 로트
+   * 상태를 아직 안 보내는 현장의 트윈이 통째로 서고, 「모름」을 안전으로 읽으면 보류가 새는 것을
+   * 아무도 모른다. 답에 실린 그 수가 「이 원본은 아직 상태를 안 보낸다」를 말한다.
+   */
+  usableLot(item) {
+    if (item.use === "blocked") return false;
+    if (item.use === void 0) this.allocatedWithUnknownLotUse++;
+    return true;
+  }
   resolvedAllocated(allocated) {
     const all = allocated ?? [];
     if (!all.length) return { kept: [], dropped: 0 };
-    const kept = all.filter((epc) => this.items.has(epc));
+    const kept = all.filter((a) => this.items.has(a.epc));
     const dropped = all.length - kept.length;
     this.seedDanglingRefs += dropped;
     return { kept, dropped };
@@ -4390,7 +4505,9 @@ var FlowEngine = class {
          * 넣다가 `nonconformance` 도 여기서 빠져 있던 것을 찾았다 — 자리는 있고 길이 없는 부류). 있을 때만 옮긴다.
          */
         ...it.nonconformance ? { nonconformance: it.nonconformance } : {},
-        ...it.status ? { status: it.status } : {}
+        ...it.status ? { status: it.status } : {},
+        /* 그 상태의 효과 — 이 칸이 빠지면 미러가 보류를 알고도 할당이 모른다(ADR-0080 결정 2). */
+        ...it.use ? { use: it.use } : {}
       });
     }
     for (const m of snap.equipment) {
@@ -4864,10 +4981,11 @@ var FlowEngine = class {
       // 트윈의 "지금" — 관측 모드면 마지막으로 들은 시각(§nowMs)
       identityGrounding: this.identityGroundingView(),
       /* 원본과 어긋난 사실 — 0 이면 싣지 않는다(어긋난 적 없는 트윈에 빈 칸을 만들지 않는다). */
-      ...this.transformInputsAbsent || this.seedDanglingRefs || this.materialSpecCrossKeyOverlaps ? { conformance: {
+      ...this.transformInputsAbsent || this.seedDanglingRefs || this.materialSpecCrossKeyOverlaps || this.allocatedWithUnknownLotUse ? { conformance: {
         ...this.transformInputsAbsent ? { transformInputsAbsent: this.transformInputsAbsent } : {},
         ...this.seedDanglingRefs ? { seedDanglingRefs: this.seedDanglingRefs } : {},
-        ...this.materialSpecCrossKeyOverlaps ? { materialSpecCrossKeyOverlaps: this.materialSpecCrossKeyOverlaps } : {}
+        ...this.materialSpecCrossKeyOverlaps ? { materialSpecCrossKeyOverlaps: this.materialSpecCrossKeyOverlaps } : {},
+        ...this.allocatedWithUnknownLotUse ? { allocatedWithUnknownLotUse: this.allocatedWithUnknownLotUse } : {}
       } } : {},
       /* 출처 표시 — 트윈 모델(마스터)에서 온 자리다. 미러는 관측으로 알게 된 자리를 'observed' 로 구별하는데,
        * 시뮬이 아무 표시도 안 하면 소비처가 두 스냅샷을 같은 규칙으로 읽지 못한다. */
@@ -6800,7 +6918,9 @@ var FlowEngine = class {
       ...i.ilmd ? { ilmd: i.ilmd } : {},
       /* 로트의 두 표준 칸(§FlowItem) — 여기서 빠지면 리듀서·엔진에는 있고 스냅샷에는 없다. */
       ...i.nonconformance ? { nonconformance: i.nonconformance } : {},
-      ...i.status ? { status: i.status } : {}
+      ...i.status ? { status: i.status } : {},
+      /* 그 상태의 효과 — 화면과 다음 씨앗이 읽는다(§`ItemState.use`). */
+      ...i.use ? { use: i.use } : {}
     };
   }
   /**
@@ -6845,7 +6965,7 @@ var FlowEngine = class {
     }
   }
   processOrders() {
-    const pending = [...this.orders.values()].filter((o) => o.status === "created" && !o.held);
+    const pending = [...this.orders.values()].filter((o) => o.status === "created" && !o.held && o.kind !== WMS_ORDER_KIND.inbound);
     if (pending.some((o) => o.priority !== void 0)) pending.sort((a, b) => priorityRank(a.priority) - priorityRank(b.priority));
     for (const o of pending) this.allocate(o);
   }
@@ -7079,7 +7199,7 @@ var WmsKernel = class extends FlowEngine {
     const poTxn = [{ type: BTT.po, bizTransaction: po }];
     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 });
+    this.items.set(epc, { epc, gtin, 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 }));
@@ -7173,14 +7293,14 @@ 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 = o.allocated.filter((e) => this.items.get(e)?.gtin === line.gtin).length;
+      const already = allocatedQty(o.allocated.filter((a) => 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").map((i) => ({ epc: i.epc, location: i.location, qty: i.qty ?? 1, expiry: i.expiry }));
+      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 chosen = this.policy.selectStock({ gtin: line.gtin, qty: need, available });
-      for (const epc of chosen) {
-        o.allocated.push(epc);
-        chosenAll.push(epc);
+      for (const row of chosen) {
+        o.allocated.push(row);
+        chosenAll.push(row.epc);
       }
     }
     if (chosenAll.length === 0) return this.makeShortLines(o);
@@ -7341,7 +7461,7 @@ var WmsKernel = class extends FlowEngine {
     order.status = "packed";
     this.emit(objectEvent({ eventTime, action: "OBSERVE", bizStep: BIZSTEP.staging_outbound, disposition: DISP.reserved, epcList: [shipment], readPoint: staging.id, bizLocation: staging.id, bizTransactionList: soTxn }));
     this.emit(objectEvent({ eventTime, action: "DELETE", bizStep: BIZSTEP.shipping, disposition: DISP.in_transit, epcList: [shipment], readPoint: shipDock.id, bizTransactionList: soTxn }));
-    order.fulfilled += order.allocated.length;
+    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);
@@ -7420,7 +7540,7 @@ var YmsKernel = class extends FlowEngine {
       requested: 1,
       fulfilled: 0,
       bizTransaction: appt,
-      allocated: [epc],
+      allocated: [{ epc, qty: 1 }],
       picked: [],
       dockDoor: door.id,
       /* 내부 스케줄 게이트(시뮬 ms) — 표준 `EarliestStartTime` 과 같은 개념의 우리 단위. */
@@ -7449,7 +7569,7 @@ var YmsKernel = class extends FlowEngine {
    * 하나라도 안 되면 대기(다음 tick 재시도). = 시간창 예약 스케줄링.
    */
   allocate(o) {
-    const trailer = this.items.get(o.allocated[0]);
+    const trailer = this.items.get(o.allocated[0]?.epc);
     if (!trailer) return;
     if (this.clockMs < (o.windowStartMs ?? 0)) return;
     const door = o.dockDoor ? this.locations.get(o.dockDoor) : void 0;
@@ -7877,7 +7997,7 @@ The steps are the source of truth for execution order; the hierarchy only names
     if (!this.producesOwnOutputs(t.kind)) return false;
     const order = t.orderId ? this.orders.get(t.orderId) : void 0;
     if (!order) return false;
-    for (const epc of epcs) order.allocated.push(epc);
+    for (const epc of epcs) order.allocated.push({ epc, qty: 1 });
     return true;
   }
   // ── 정의-구동 모드 (도메인 정의 데이터로 실행 — 레거시와 분리, 하드코딩 대체) ──
@@ -8182,12 +8302,12 @@ The steps are the source of truth for execution order; the hierarchy only names
         }
       } else {
         for (const i of this.items.ofGtin(g)) {
-          if (i.disposition === DISP.sellable) available.push({ epc: i.epc, location: i.location, qty: 1 });
+          if (i.disposition === DISP.sellable && this.usableLot(i)) available.push({ epc: i.epc, location: i.location, qty: 1 });
         }
       }
       const chosen = this.policy.selectStock({ gtin: g, qty: line.qty, available });
-      if (chosen.length < line.qty) {
-        short.push({ material: line.material, need: line.qty, have: chosen.length });
+      if (allocatedQty(chosen) < line.qty) {
+        short.push({ material: line.material, need: line.qty, have: allocatedQty(chosen) });
         continue;
       }
       picks.push(...chosen);
@@ -8198,10 +8318,10 @@ The steps are the source of truth for execution order; the hierarchy only names
       return;
     }
     if (o.shortage) delete o.shortage;
-    for (const epc of picks) o.allocated.push(epc);
-    this.reserve(picks, MES_BIZSTEP.producing);
-    this.emit(transactionEvent({ eventTime: this.now(), action: "ADD", bizStep: MES_BIZSTEP.producing, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: o.bizTransaction }], epcList: o.allocated.slice() }));
-    this.emitStationDef(o, ops[0], o.allocated[0]);
+    for (const row of picks) o.allocated.push(row);
+    this.reserve(allocatedEpcs(picks), MES_BIZSTEP.producing);
+    this.emit(transactionEvent({ eventTime: this.now(), action: "ADD", bizStep: MES_BIZSTEP.producing, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: o.bizTransaction }], epcList: allocatedEpcs(o.allocated) }));
+    this.emitStationDef(o, ops[0], o.allocated[0]?.epc);
     o.status = "op-" + ops[0].key;
     this.emitOrder(o);
   }
@@ -8232,12 +8352,12 @@ The steps are the source of truth for execution order; the hierarchy only names
       const producedKey = this.producedMaterialKeyOf(t.kind);
       const next = ops[i + 1];
       if (producedKey) {
-        const inputs = order.allocated.slice();
+        const inputs = allocatedEpcs(order.allocated);
         const made = this.serialOf(producedKey, ++this.wipSeq);
         this.transform(inputs, [{ epc: made, gtin: this.classOf(producedKey), qty: 1, location: loc.id, disposition: DISP.in_progress }], { bizStep, disposition: DISP.in_progress, transformationId: order.bizTransaction, readPoint: loc.id, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: order.bizTransaction }] });
-        order.allocated = [made];
+        order.allocated = [{ epc: made, qty: 1 }];
       }
-      const carried = order.allocated[0];
+      const carried = order.allocated[0]?.epc;
       if (!carried && !this.observationDriven) {
         throw new Error(
           `order ${order.id} at step '${t.kind}': nothing to carry to '${next.key}' \u2014 the order holds no allocated material and this step declares no produced material. Declare the step's input or its output in the model.`
@@ -8251,7 +8371,7 @@ The steps are the source of truth for execution order; the hierarchy only names
     }
     const declaredFg = this.declaredLocationTypeOfMaterial(rc.outputs[0].material);
     const fgStore = declaredFg ? this.locationOfMaterial(rc.outputs[0].material) : loc;
-    const consumed = order.allocated.slice();
+    const consumed = allocatedEpcs(order.allocated);
     if (!consumed.length) {
       if (order.seedIncomplete) {
         order.status = "blocked-seed-incomplete";
@@ -9949,6 +10069,7 @@ function electricityCost(input) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ALLOCATION_POLICIES,
   ATTENTION_DEFAULTS,
   ATTENTION_PROPERTY,
   ClassMasterTable,
@@ -9966,6 +10087,9 @@ function electricityCost(input) {
   TwinRuntime,
   WmsKernel,
   YmsKernel,
+  allocatedEpcs,
+  allocatedQty,
+  allocationPolicyOf,
   attributeEnergy,
   compareStates,
   constantDuration,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@operato/twin-kernel",
-  "version": "0.11.18",
+  "version": "0.11.20",
   "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.28"
+    "@operato/ops-contract": "^0.9.30"
   }
 }