@operato/twin-kernel 0.7.53 → 0.7.55

package/dist/contract.d.ts

@@ -204,17 +204,34 @@ levelOfType?: (type: string) => EquipmentLevel | undefined): Hierarchy;
  * 템플릿이다. 즉 「모른다」가 아니라 「원천 쪽」이다. 표식은 그 기본값과 다를 때 달린다.
  */
 export type PropertySource = 'reference' | 'local';
-export interface ResourceProperty {
-    /** 속성 식별자 — 표준 `ID`. 어휘는 표준이 정하지 않으므로 우리가 한 곳에서 정한다 — 그 자리는 읽는 쪽에 있다
-     * (headless-twin `EQUIPMENT_PROPERTY`·`PROPERTY_EFFECTS`). 커널은 속성을 **나르기만** 한다. */
-    id: string;
-    description?: string;
+/**
+ * **ISA-95 `ValueType`** — 값·데이터형·단위 한 묶음. 1차 출처(B2MML v0700+): `ValueType`
+ * (`B2MML-Common.xsd`)의 `ValueString`·`DataType`·`UnitOfMeasure`.
+ *
+ * ── 왜 따로 뽑나 (2026-08-24) ────────────────────────────────────────────────
+ * 표준은 이 묶음을 **여러 곳에서 재사용한다** — 자원 속성(`<X>PropertyType.Value`) · 시험 측정값
+ * (`PropertyMeasurementType.Value`) · 공정 모수 실측(`OpSegmentDataType.Value`) · 자리 속성
+ * (`OperationalLocationPropertyType.Value`). 처음에는 자원 속성에만 있었고 세 필드가 그 안에 인라인
+ * 이었다. 두 번째 자리가 생기는 순간 **같은 매핑을 두 번 적게 되고**, 그때부터 한쪽만 고쳐지는 길이
+ * 열린다(단위를 한쪽에서만 필수로 만들거나, `dataType` 주석이 갈리는 식으로).
+ *
+ * 표준이 한 타입으로 둔 것을 우리도 한 타입으로 둔다. **평평하게 펴는 것**은 우리 선택이다 —
+ * 표준은 `Value` 를 자식 요소로 두지만, 소비처가 `p.value` 로 읽는 편이 `p.value.valueString` 보다
+ * 낫고 이 저장소가 이미 그렇게 하고 있었다. 그 선택을 여기 적어 둔다(되돌리려면 소비처 전부가 움직인다).
+ */
+export interface StandardValue {
     /** 표준 `Value.ValueString`. 값의 표기는 문자열이고, 뜻은 `dataType`·`uom` 이 정한다. */
     value?: string;
     /** 표준 `Value.DataType` — 예: `xs:double`. 미지정이면 소비처가 형을 짐작하지 않는다. */
     dataType?: string;
-    /** 표준 `Value.UnitOfMeasure` — UN/CEFACT 공통코드(예: `MTS`·`KMH`). **단위 없는 물리량은 쓰지 않는다.** */
+    /** 표준 `Value.UnitOfMeasure` — UN/CEFACT 공통코드(예: `MTS`·`KMH`·`CEL`). **단위 없는 물리량은 쓰지 않는다.** */
     uom?: string;
+}
+export interface ResourceProperty extends StandardValue {
+    /** 속성 식별자 — 표준 `ID`. 어휘는 표준이 정하지 않으므로 우리가 한 곳에서 정한다 — 그 자리는 읽는 쪽에 있다
+     * (headless-twin `EQUIPMENT_PROPERTY`·`PROPERTY_EFFECTS`). 커널은 속성을 **나르기만** 한다. */
+    id: string;
+    description?: string;
     /** 하위 속성 — 표준 `<X>PropertyChild`(재귀). 구조화된 속성(예: 정격/실측 묶음)을 잃지 않기 위해. */
     children?: ResourceProperty[];
     /** 이 개체 속성이 구체화하는 **등급 속성** — 표준 `<X>ClassPropertyID`. */
@@ -278,14 +295,29 @@ export type TestSpecificationRefs = string[];
  * **결과가 선언돼 있으면 그때부터 제약이 된다**: 불합격이거나 유효기간이 지났으면 그 등급으로 자격이
  * 성립하지 않는다. 그것이 이 값을 싣는 이유다(싣지 않으면 아무 제약도 없다).
  *
- * 필드 이름은 최소로 둔다 — 표준 결과 타입(`B2MML-OperationsTest.xsd`)과 아직 대조하지 않았다.
+ * ── 1차 출처와 대조했다 (2026-08-24) ─────────────────────────────────────────
+ * 예전에는 「필드 이름을 아직 대조하지 않았다」고 유보해 두었다. `B2MML-OperationsTest.xsd` 의
+ * `TestResultType` 을 읽었고, 그 결과 **둘이 갈렸다.**
+ *
+ *   표준이 준 것       `EvaluationDate` · `Expiration` · `TestableObjectID`
+ *                     · `EvaluatedCriterionResult` · `PropertyMeasurement`(unbounded)
+ *   우리가 좁힌 것     `result: 'pass' | 'fail'` — **표준은 판정을 열거하지 않는다**(`TextType`)
+ *
+ * 좁힘을 적어 두는 이유: HACCP 같은 규제 판정에는 「적합·부적합」 밖의 값이 온다(재검·조건부). 그때
+ * 이 유니온을 넓혀야 하는데, **좁힘이라고 적혀 있지 않으면 다음 사람이 「표준이 둘만 정했다」고 읽는다.**
+ *
+ * `at`·`expiresAt` 은 표준 `EvaluationDate`·`Expiration` 이다 — 이름을 바꾸지 않는다(이미 나간 계약이고,
+ * 개명이 사는 값은 이 주석이 대신 낸다).
  */
 export interface TestResult {
     /** 어느 시험인가 — `TestSpecification.id` 를 가리킨다. */
     specId: string;
-    /** 합격 여부. 표준의 판정 어휘를 대조하기 전이므로 둘만 둔다(모르는 값을 만들지 않는다). */
+    /**
+     * 합격 여부 — **우리가 좁힌 것이다.** 표준 `EvaluatedCriterionResult` 는 `TextType` 이고
+     * 판정 어휘를 열거하지 않는다(원문 대조 2026-08-24). 넓힐 때는 이 주석과 함께 움직인다.
+     */
     result: 'pass' | 'fail';
-    /** 언제 통과·불합격했나(ISO). */
+    /** 언제 통과·불합격했나(ISO) — 표준 `EvaluationDate`. */
     at?: ISOTime;
     /**
      * 언제까지 유효한가(ISO) — 자격에는 대개 유효기간이 있다.
@@ -294,6 +326,18 @@ export interface TestResult {
      * (유효기간을 모르는 것과 지난 것은 다르다).
      */
     expiresAt?: ISOTime;
+    /**
+     * 이 판정의 **근거가 된 측정값들** — 표준 `TestResult.PropertyMeasurement`(`maxOccurs="unbounded"`).
+     *
+     * ── 왜 판정에 값을 붙이나 (당위) ──────────────────────────────────────────
+     * 「부적합」이라고만 적힌 기록과 「4.2°C 를 재어 한계를 넘었다」는 기록은 **다른 물건**이다. 앞의
+     * 것으로는 되짚을 수 없다 — 얼마나 벗어났나, 언제였나, 다시 재면 같은 답이 나오나에 답할 수 없다.
+     * 규제 기록은 성질상 **사고 뒤에** 읽히므로, 근거 없는 판정은 그때 아무 일도 하지 못한다.
+     *
+     * **없어도 판정은 성립한다** — 원본이 결론만 주는 현장이 있고, 그때 값을 지어내지 않는다. 빈 것은
+     * `testEvidenceGaps` 가 세어 낸다(조용히 넘기지 않는다).
+     */
+    propertyMeasurements?: PropertyMeasurement[];
 }
 /**
  * 이 시험 결과가 **이 시각에 유효한 합격인가.**
@@ -348,6 +392,76 @@ export interface Capability {
     available: boolean;
     reason: CapabilityReason;
 }
+/**
+ * **판정 기준 하나** — 표준 `TestSpecificationCriteriaType`(`B2MML-OperationsTest.xsd`).
+ *
+ * ── 왜 이 축이 필요한가 (당위) ────────────────────────────────────────────────
+ * 측정값만 있으면 트윈은 「4.2」를 들고 있을 뿐이고 **그것이 괜찮은지 모른다.** 판정의 재료는
+ * 「값」과 「기준」 둘이다. 기준이 없으면 트윈은 조건을 알면서도 아무 말도 할 수 없다 — 계기판이 된다.
+ *
+ * ── 커널은 기준을 **정하지 않고, 재해석하지도 않는다** ──────────────────────
+ * 기준은 그 현장의 규정이다(식품안전·약전·사내 규격). 트윈이 정할 것이 아니고, **표현식을 커널이
+ * 평가하지도 않는다** — 표준의 `Expression` 이 `TextType` 이라 문법이 정의돼 있지 않다. 문법을 우리가
+ * 만들면 그 순간 방언이 되고, 현장의 규정과 우리 해석이 갈리는 날 어느 쪽이 옳은지 아무도 모른다.
+ *
+ * 그러면 이 값이 무슨 일을 하나: **판정에 근거가 있는지를 물을 수 있게 한다**(§`testEvidenceGaps`).
+ * 「부적합」이라고만 적힌 기록과 「4.2°C 를 재어 한계 4.0 을 넘었다」는 기록은 다른 물건이다.
+ */
+export interface TestSpecificationCriterion {
+    /** 표준 `ID`. */
+    id: string;
+    /** 표준 `Description`. */
+    description?: string;
+    /** 표준 `Sequence` — 기준이 여럿일 때의 순서. */
+    sequence?: number;
+    /**
+     * 표준 `Expression`(`TextType`) — **그 현장의 표기 그대로** 나른다. 커널은 이것을 평가하지 않는다.
+     *
+     * 문법이 정의돼 있지 않으므로(자유 문자열) 파싱하면 그 순간 방언이고, 현장 규정과 우리 해석이
+     * 갈리는 날 어느 쪽이 옳은지 아무도 모른다. 사람이 읽는 값이다.
+     *
+     * **`expression` 과 `limit` 중 적어도 하나는 있어야 한다**(§`criterionSaysNothing`) — 둘 다 없는
+     * 기준은 아무 한계도 말하지 않으면서 「기준이 선언됐다」는 착각만 만든다.
+     */
+    expression?: string;
+    /**
+     * **평가 가능한 한계** — 이것이 있으면 커널이 판정할 수 있다.
+     *
+     * ── 이 축은 **표준에 없다. 우리 것이다** (2026-08-24) ──────────────────────
+     * B2MML 일곱 파일(Common · OperationsTest · OperationsPerformance(+Types) · OperationalLocation ·
+     * OperationsEvent · OperationsSchedule · WorkAlert)을 원문으로 훑었고 `Minimum`·`Maximum`·
+     * `Tolerance`·`Range`·`LowerLimit`·`UpperLimit` 이 **하나도 없다.** ISA-95 의 기준은
+     * `Expression`(TextType)과 `Result`(TextType)뿐이고, `ValueType` 도 `ValueString`·`DataType`·
+     * `UnitOfMeasure`·`Key` 넷이다. 즉 표준은 한계를 **사람이 읽는 문장**으로만 담는다.
+     *
+     * 그런데 트윈은 **아무도 판정하지 않을 때 판정해야 한다** — 그것이 이 축의 근거다(당위). 자유 문장
+     * 으로는 그것을 할 수 없다. 그래서 숫자 한계를 우리가 더한다. **더한 것이라고 적어 두는 것**이
+     * 이 저장소의 규율이고(§`TestResult.result` 의 좁힘과 같은 자리), 그러면 다음 사람이 이것을
+     * 「표준이 준 이름」으로 읽지 않는다.
+     *
+     * 실 원본이 이 모양으로 준다는 것이 확인됐다(첫 실 연동: `criticalLimits.{minimum,maximum}`).
+     * **그것이 이 축을 정한 것은 아니다** — 판정이 필요하다는 당위가 정했고, 원본은 그것을 채울 수
+     * 있다는 사실을 확인해 준 것이다.
+     */
+    limit?: {
+        /** 이 값 미만이면 벗어난다. 없으면 아래쪽 한계가 없다(모르는 것이 아니라 없는 것이다). */
+        minimum?: number;
+        /** 이 값 초과면 벗어난다. */
+        maximum?: number;
+        /**
+         * 한계의 단위 — 표준 `UnitOfMeasure` 와 같은 어휘(UN/CEFACT).
+         *
+         * **없으면 짐작하지 않는다.** 관측도 단위를 말하지 않으면 같은 척도로 보고 비교하고(같은 선언에서
+         * 온 값들이다), **둘이 서로 다른 단위를 말하면 판정하지 않는다** — 섭씨 한계에 화씨 관측을
+         * 견주면 조용히 틀린다.
+         */
+        uom?: string;
+    };
+    /** 표준 `Result` — 이 기준이 만족될 때 기대하는 값(현장 표기). */
+    result?: string;
+    /** 표준 `EvaluatedPropertyID` — 이 기준이 **무엇을 재어** 판정하나. 측정값과 짝을 맞추는 키다. */
+    evaluatedPropertyId?: string;
+}
 export interface TestSpecification {
     /** 표준 `ID` — 자원의 `testSpecificationIds` 가 이 값을 가리킨다. */
     id: string;
@@ -355,7 +469,84 @@ export interface TestSpecification {
     description?: string;
     /** 표준 `Version` — 같은 시험의 판이 바뀌면 자격의 뜻도 바뀐다(어느 판으로 검증했나). */
     version?: string;
+    /**
+     * 판정 기준들 — 표준 `TestSpecificationCriteria`(`maxOccurs="unbounded"`).
+     *
+     * 선언하지 않아도 명세는 성립한다(「무엇으로 검증했다고 하는지」를 이름으로 답하는 것이 그 최소
+     * 역할이었다). 선언하면 **판정에 근거가 있는지**를 물을 수 있게 된다.
+     */
+    criteria?: TestSpecificationCriterion[];
 }
+/**
+ * **측정값 하나** — 표준 `PropertyMeasurementType`(`B2MML-OperationsTest.xsd`).
+ *
+ * 표준에서 이것은 `TestResult` 의 자식이다: 판정 하나가 **자기 근거가 된 측정들을 든다.** 값의 모양은
+ * `ValueType` 이라 `StandardValue` 를 그대로 쓴다 — 단위 없는 물리량은 쓰지 않는다는 규율이 여기에도 산다.
+ */
+export interface PropertyMeasurement extends StandardValue {
+    /** 표준 `ID`. */
+    id?: string;
+    /** 표준 `Description`. */
+    description?: string;
+    /** 표준 `TestableObjectPropertyID` — **무엇을 쟀나**(그 개체의 어느 속성인가). 기준과 짝을 맞추는 키다. */
+    testableObjectPropertyId?: string;
+    /** 표준 `MeasurementDate` — 언제 쟀나. */
+    measurementDate?: ISOTime;
+    /**
+     * 이 값이 **잰 것이 아니라 접은 것**임을 밝힌다 — §`DemandWindowState.derived` 와 같은 규율.
+     *
+     * 트윈은 원본이 주지 않는 값을 계산할 수 있다(그것이 트윈의 존재 이유다). 그런데 그 수를 실측과
+     * **같은 자리에 같은 모양으로** 두면 화면·보고서가 그것을 잰 값으로 읽는다. 규제 기록에서 그
+     * 구별이 사라지는 것은 결함이 아니라 사고다. 그래서 값 옆에 종류를 함께 싣는다.
+     */
+    derived?: boolean;
+}
+/**
+ * **이 기준이 아무 한계도 말하지 않나** — 선언만 있고 내용이 없는 것을 가려낸다.
+ *
+ * 표현식(사람이 읽는 것)도 없고 숫자 한계(커널이 판정하는 것)도 없으면, 그 기준은 「기준이 선언됐다」는
+ * 착각만 만든다. 화면이 「관리점 셋이 걸려 있다」고 말하는데 그중 하나가 아무것도 재지 않는 것은
+ * 이 저장소가 거절하는 모양이다.
+ */
+export declare function criterionSaysNothing(c: Pick<TestSpecificationCriterion, 'expression' | 'limit'>): boolean;
+/**
+ * **이 값이 한계를 벗어났나** — 판정할 수 있을 때만 답한다.
+ *
+ * ── 세 갈래를 가린다 ────────────────────────────────────────────────────────
+ *   `true`       벗어났다
+ *   `false`      한계 안이다
+ *   `undefined`  **판정할 수 없다** — 숫자 한계가 없거나, 값이 수가 아니거나, 단위가 어긋난다
+ *
+ * `undefined` 를 `false` 로 뭉개지 않는 것이 이 함수의 요점이다. 「한계 안이다」와 「판정 못 했다」를
+ * 같은 값으로 답하면 화면이 판정하지 못한 것을 **적합으로** 보여 준다 — 규제 기록에서 그것은 사고다.
+ *
+ * ── 표현식은 읽지 않는다 ────────────────────────────────────────────────────
+ * `expression` 이 있어도 파싱하지 않는다(§`TestSpecificationCriterion.expression`). 숫자 한계가
+ * 없으면 사람이 읽을 문장은 있어도 커널은 「모른다」고 답한다.
+ *
+ * ── 단위가 어긋나면 판정하지 않는다 ─────────────────────────────────────────
+ * 섭씨 한계에 화씨 관측을 견주면 **오류 없이 틀린다.** 둘 다 단위를 말하지 않으면 같은 척도로 본다 —
+ * 같은 선언에서 온 값들이고, 그때 판정을 거부하면 단위를 적지 않는 원본에서 이 축이 영원히 침묵한다.
+ */
+export declare function outsideLimit(criterion: Pick<TestSpecificationCriterion, 'limit'> | undefined, observed: Pick<StandardValue, 'value' | 'uom'> | undefined): boolean | undefined;
+/**
+ * **이 판정에 근거가 있나** — 기준과 측정값의 짝을 맞춰 빈 곳을 돌려준다.
+ *
+ * ── 왜 커널이 이것을 답하나 ─────────────────────────────────────────────────
+ * 커널은 기준을 **평가하지 않는다**(`Expression` 은 문법이 정의되지 않은 자유 문자열). 그러나
+ * **짝이 맞는지는 문법을 몰라도 알 수 있다** — 그리고 그것이 이 축을 실은 이유다: 「부적합」이라고만
+ * 적힌 기록과 근거를 든 기록을 화면이 구별할 수 있어야 한다.
+ *
+ *   unmeasured  기준은 있는데 그것을 잰 값이 없다 — **판정의 근거가 비었다**
+ *   unmatched   측정값은 있는데 그것을 요구한 기준이 없다 — 어느 규정으로 잰 것인지 모른다
+ *
+ * 판정하지 않고 **세어서 낸다**: 이 저장소는 빈 것을 조용히 넘기지 않는다(§`ObservedReducer.unhandled`).
+ * 그리고 짝의 키는 표준이 준 것 그대로다 — `EvaluatedPropertyID` ↔ `TestableObjectPropertyID`.
+ */
+export declare function testEvidenceGaps(spec: Pick<TestSpecification, 'criteria'> | undefined, result: Pick<TestResult, 'propertyMeasurements'> | undefined): {
+    unmeasured: string[];
+    unmatched: string[];
+};
 /**
  * 유효 기간 — **ISA-95 `EffectiveStartDate` / `EffectiveEndDate`.**
  *
@@ -817,7 +1008,105 @@ export interface LocationState {
      * 보드에 좌표가 없고 용량이 비어 있어 **계획에 참여하지 못한다**(그 사실을 감추지 않기 위한 표시).
      */
     origin?: 'master' | 'observed';
+    /**
+     * 이 자리에서 관측된 **물리량들의 마지막 값** — 속성마다 하나(§`LocationObservation`).
+     *
+     * 이력이 아니라 **지금 값**이다: 이력은 저널이 든다(그것이 「그때 그 방이 몇 도였나」에 답하는
+     * 자리다). 여기 두는 이유는 판정이 지금 값을 보기 때문이고, 상태가 시간에 비례해 자라지 않게
+     * **속성당 하나**만 든다.
+     *
+     * 없으면 **두지 않는다** — 빈 배열을 두면 「센서가 없는 자리」와 「아직 못 들은 자리」가 같아진다.
+     */
+    observations?: LocationObservation[];
 }
+/**
+ * **자리에서 관측된 물리량 하나** — 냉장실 온도·습도, 세척수 유량 같은 것.
+ *
+ * ── 왜 트윈이 이것을 들어야 하나 (당위) ─────────────────────────────────────
+ * 트윈의 판정 대상은 「물건의 상태」이고, 물건의 상태는 **조건 없이 정해지지 않는다.** 「이 로트가
+ * 냉장실에 있었다」까지만 아는 트윈은 그 로트가 괜찮았는지 말할 수 없다 — 기능 하나가 없는 것이
+ * 아니라 **판정의 재료가 없는 것**이다.
+ *
+ * 그리고 **이 조인은 트윈만 할 수 있다.** 계측 시스템은 물건의 자리 이력을 모르고, 물류 시스템은
+ * 조건 이력을 모른다. 물건이 여러 시스템을 지나면 어느 원본도 전 경로를 모른다.
+ *
+ * ── 주인은 **자리**다. 물건이 아니다 ────────────────────────────────────────
+ * 방 하나의 온도가 그 안의 물건 수백 개와 관계되고, **그 수백 개는 시간에 따라 바뀐다.** 값을 물건마다
+ * 복사하면 한 사실의 사본이 수백 개 생기고 드나드는 물건마다 어긋난다. 그래서 관측은 **자리에 한 번**
+ * 두고, 「그때 그 방에 있던 물건」은 시각∩자리로 파생한다(파생은 저장하지 않는다).
+ *
+ * 진행 중인 공정이 있어도 마찬가지다: 숙성창고에 로트가 여럿이면 숙성 작업도 여럿이고 구간이 각기
+ * 다른데 **센서는 하나**다. 그 값은 어느 한 작업의 것이 아니다.
+ *
+ * ── 표준 근거 — 붙는 자리가 「자리」가 아니라 **설비 계층 노드**다 ────────────
+ * 1차 출처: `OperationsEventType`(`B2MML-OperationsEvent.xsd`) + `OperationsRecordTemplateType`
+ * (`B2MML-Common.xsd`). 붙는 자리는 `HierarchyScope.EquipmentID` 인데, ISA-95 에서는 **장소 계층이
+ * 곧 설비 계층**이다(Enterprise → Site → Area → StorageZone → StorageUnit) — 냉장실은 `StorageZone`
+ * 수준의 설비다. 커널의 자리가 그 노드이므로(§`LocationState.level` 이 `EquipmentLevel1Type` 근거)
+ * `locationId` 가 그대로 대응된다.
+ *
+ * `OperationalLocationType` 에는 이 축이 **없다** — 그쪽은 나중에 들어온 공간(spatial) 개념이고
+ * 마스터 속성만 든다(시계열이 아니다).
+ *
+ * ── 우리가 좁힌 것 ──────────────────────────────────────────────────────────
+ * 표준의 기록 항목은 `InformationObject`(무엇이든)다. **그 임의성을 쓰지 않는다** — 값을 `ValueType`
+ * 으로 좁힌다(§`StandardValue`). 단위 없는 물리량을 받으면 소비처가 3이 섭씨인지 화씨인지 알 수 없고,
+ * 그 상태로는 어떤 판정도 못 한다.
+ */
+export interface LocationObservation extends StandardValue {
+    /** 표준 `HierarchyScope.EquipmentID` — 어느 자리인가. 커널의 자리 id 다. */
+    locationId: string;
+    /**
+     * **무엇을 쟀나** — 속성 식별자. 기준과 짝을 맞추는 키다
+     * (§`TestSpecificationCriterion.evaluatedPropertyId`).
+     *
+     * 어휘는 커널이 정하지 않는다 — 재는 것은 현장이 정한다(온도·습도·유량·중량). 커널은 나르고
+     * 짝만 맞춘다. `OP_PARAM` 과 같은 규율이고, 표준도 파라미터 ID 어휘를 정하지 않는다.
+     */
+    propertyId: string;
+    /**
+     * **언제의 사실인가** — 표준 `EffectiveTimestamp`.
+     *
+     * 관측 시각이지 기록 시각이 아니다. 둘이 어긋나는 것이 실 연동의 정상이고, 그래서 아래를 따로 든다.
+     */
+    effectiveTime: ISOTime;
+    /**
+     * **언제까지의 사실인가** — 표준 `EffectiveEndDate`. 없으면 그 시점 하나의 값이다.
+     *
+     * ── 왜 구간이 필요한가 ────────────────────────────────────────────────────
+     * ① **원본이 시각을 주지 않는 기록이 있다.** 수동 점검 장부는 「그날 아침」처럼 적고 시계를 적지
+     *    않는다(표준도 주기 점검을 전제한다 — `RecurrenceTimeInterval`). 그때 09:00 을 찍으면 **자정을
+     *    지어내는 것과 같은 발명**이다(§ADR-0039 「선언이 있으면 변환이지만 없으면 발명이다」).
+     *    구간으로 적으면 참인 것만 말한다: 그날 아침의 어느 때.
+     * ② **영향 로트를 찾는 데 구간이 필요하다.** 점 하나로는 며칠 머문 로트를 잡지 못한다 — 온도가 튄
+     *    한 시간의 이벤트 목록에는 정작 그 방의 로트가 하나도 없을 수 있다.
+     *
+     * 구간을 **모르는 것**과 **점인 것**은 다르다: 점이면 이 값이 없고, 모르면 넓은 구간으로 적는다.
+     */
+    effectiveEndTime?: ISOTime;
+    /** 언제 적혔나 — 표준 `RecordTimestamp`. 늦게 도착한 옛 관측이 최신을 덮지 않게 하는 재료다. */
+    recordTime?: ISOTime;
+    /** 누가 말했나 — 표준 `Source`. 계측기인지 사람이 적은 장부인지는 이 값이 답한다. */
+    source?: string;
+    /**
+     * 이 값이 **잰 것이 아니라 접은 것**임을 밝힌다 — §`PropertyMeasurement.derived` 와 같은 규율.
+     *
+     * 트윈은 원본이 주지 않는 값을 계산할 수 있다(그것이 존재 이유다). 그러나 실측과 같은 자리에 같은
+     * 모양으로 두면 보고서가 그것을 잰 값으로 읽는다. 규제 기록에서 그 구별이 사라지는 것은 결함이
+     * 아니라 사고다.
+     */
+    derived?: boolean;
+}
+/**
+ * **이 시각에 이 자리에서 참인 관측** — 구간을 든 관측을 시각으로 찾는다.
+ *
+ * 「그때 그 방이 몇 도였나」에 답하는 첫 칸이다. 점 관측은 그 시각에만, 구간 관측은 구간 안에서 참이다.
+ * 여러 개가 겹치면 **가장 늦게 시작한 것**이 답이다(정정이 나중에 온다).
+ *
+ * 커널은 값이 옳은지 **판정하지 않는다** — 기준의 표현식은 문법이 정의되지 않은 자유 문자열이다
+ * (§`TestSpecificationCriterion`). 여기서 하는 일은 짝을 찾아 주는 것까지다.
+ */
+export declare function observationAt(observations: readonly LocationObservation[] | undefined, propertyId: string, at: ISOTime): LocationObservation | undefined;
 /**
  * 물품 상태 — 표준이 담는 것을 담는다(EPCIS 2.0 / TDS).
  *
@@ -1557,6 +1846,28 @@ export interface StateSnapshot {
         firstAtMs?: number;
         lastAtMs?: number;
     }[];
+    /**
+     * **개체를 잇지 못한 채 다음 공정으로 넘어간 횟수** — 계보에 구멍이 남았다.
+     *
+     * ── 왜 이 값이 필요했나 (2026-08-24 실측) ────────────────────────────────────
+     * 미러의 오더는 **확보분을 가진 적이 없다.** 원본이 「이 오더에 어느 개체가 잡혀 있나」를 말하지
+     * 않는 것이 정상이다(첫 실 연동: 오더 사실이 `status`·`requested`·`fulfilled` 만 든다). 그런데
+     * 커널이 중간 공정을 넘을 때 **들고 갈 개체를 요구하고 던졌다** — 그래서 미러에서 예측이
+     * 구조적으로 실패했다(`twinForecast` 가 오더 하나 때문에 전부 실패).
+     *
+     * 진행을 막은 것이 과했다. **단계를 넘는 것은 공정의 진행이고 개체를 잇는 것은 계보**다. 계보를
+     * 못 이으면 계보를 비우는 것이 맞고, 그렇다고 진행까지 멈추면 있는 답(언제 끝나나·처리량)까지 잃는다.
+     *
+     * 그래서 넘기되 **세어 낸다.** 세지 않으면 계보에 구멍이 있는데 화면이 정상으로 보인다 —
+     * `unhandled` 를 스냅샷이 떨어뜨려 정합성 검사가 영원히 조용했던 것과 같은 부류의 실수다.
+     *
+     * **목록이 아니라 수다**: 오더 수가 규모에 비례해 자라므로 목록은 잘라야 하고, 자르면 「조용히
+     * 자르지 않는다」를 지킬 수 없다. 어느 오더인지는 그 오더의 계보가 빈 것으로 답한다.
+     *
+     * 자체 구동(시뮬)에서는 **이 값이 오르지 않는다** — 시뮬은 개체를 스스로 만들므로 확보분이 비는
+     * 것이 곧 결함이고, 거기서는 여전히 던진다(진짜 결함을 조용하게 만들지 않는다).
+     */
+    stepsWithoutMaterial?: number;
     /**
      * 확인(ack)해 둔 주목 신호 id — **상태에서 파생되지 않는 유일한 축.**
      *

package/dist/contract.js

@@ -245,6 +245,92 @@ export function meetsTests(required, results, at) {
     }
     return true;
 }
+/**
+ * **이 기준이 아무 한계도 말하지 않나** — 선언만 있고 내용이 없는 것을 가려낸다.
+ *
+ * 표현식(사람이 읽는 것)도 없고 숫자 한계(커널이 판정하는 것)도 없으면, 그 기준은 「기준이 선언됐다」는
+ * 착각만 만든다. 화면이 「관리점 셋이 걸려 있다」고 말하는데 그중 하나가 아무것도 재지 않는 것은
+ * 이 저장소가 거절하는 모양이다.
+ */
+export function criterionSaysNothing(c) {
+    if (c?.expression?.trim())
+        return false;
+    const l = c?.limit;
+    return !(typeof l?.minimum === 'number' || typeof l?.maximum === 'number');
+}
+/**
+ * **이 값이 한계를 벗어났나** — 판정할 수 있을 때만 답한다.
+ *
+ * ── 세 갈래를 가린다 ────────────────────────────────────────────────────────
+ *   `true`       벗어났다
+ *   `false`      한계 안이다
+ *   `undefined`  **판정할 수 없다** — 숫자 한계가 없거나, 값이 수가 아니거나, 단위가 어긋난다
+ *
+ * `undefined` 를 `false` 로 뭉개지 않는 것이 이 함수의 요점이다. 「한계 안이다」와 「판정 못 했다」를
+ * 같은 값으로 답하면 화면이 판정하지 못한 것을 **적합으로** 보여 준다 — 규제 기록에서 그것은 사고다.
+ *
+ * ── 표현식은 읽지 않는다 ────────────────────────────────────────────────────
+ * `expression` 이 있어도 파싱하지 않는다(§`TestSpecificationCriterion.expression`). 숫자 한계가
+ * 없으면 사람이 읽을 문장은 있어도 커널은 「모른다」고 답한다.
+ *
+ * ── 단위가 어긋나면 판정하지 않는다 ─────────────────────────────────────────
+ * 섭씨 한계에 화씨 관측을 견주면 **오류 없이 틀린다.** 둘 다 단위를 말하지 않으면 같은 척도로 본다 —
+ * 같은 선언에서 온 값들이고, 그때 판정을 거부하면 단위를 적지 않는 원본에서 이 축이 영원히 침묵한다.
+ */
+export function outsideLimit(criterion, observed) {
+    const l = criterion?.limit;
+    if (!l)
+        return undefined;
+    const hasMin = typeof l.minimum === 'number';
+    const hasMax = typeof l.maximum === 'number';
+    if (!hasMin && !hasMax)
+        return undefined;
+    const raw = observed?.value;
+    if (raw === undefined || raw === null || String(raw).trim() === '')
+        return undefined;
+    const n = Number(raw);
+    if (!Number.isFinite(n))
+        return undefined;
+    /* 단위가 **둘 다 있고 다르면** 판정하지 않는다. 하나만 있거나 둘 다 없으면 같은 척도로 본다. */
+    const lu = l.uom?.trim();
+    const ou = observed?.uom?.trim();
+    if (lu && ou && lu !== ou)
+        return undefined;
+    if (hasMin && n < l.minimum)
+        return true;
+    if (hasMax && n > l.maximum)
+        return true;
+    return false;
+}
+/**
+ * **이 판정에 근거가 있나** — 기준과 측정값의 짝을 맞춰 빈 곳을 돌려준다.
+ *
+ * ── 왜 커널이 이것을 답하나 ─────────────────────────────────────────────────
+ * 커널은 기준을 **평가하지 않는다**(`Expression` 은 문법이 정의되지 않은 자유 문자열). 그러나
+ * **짝이 맞는지는 문법을 몰라도 알 수 있다** — 그리고 그것이 이 축을 실은 이유다: 「부적합」이라고만
+ * 적힌 기록과 근거를 든 기록을 화면이 구별할 수 있어야 한다.
+ *
+ *   unmeasured  기준은 있는데 그것을 잰 값이 없다 — **판정의 근거가 비었다**
+ *   unmatched   측정값은 있는데 그것을 요구한 기준이 없다 — 어느 규정으로 잰 것인지 모른다
+ *
+ * 판정하지 않고 **세어서 낸다**: 이 저장소는 빈 것을 조용히 넘기지 않는다(§`ObservedReducer.unhandled`).
+ * 그리고 짝의 키는 표준이 준 것 그대로다 — `EvaluatedPropertyID` ↔ `TestableObjectPropertyID`.
+ */
+export function testEvidenceGaps(spec, result) {
+    const criteria = spec?.criteria ?? [];
+    const measurements = result?.propertyMeasurements ?? [];
+    /* 기준이 재는 속성들 / 실제로 잰 속성들 — 속성 id 를 말하지 않은 것은 짝을 맞출 수 없으므로 뺀다. */
+    const wanted = new Set(criteria.map(c => c.evaluatedPropertyId).filter((k) => !!k));
+    const got = new Set(measurements.map(m => m.testableObjectPropertyId).filter((k) => !!k));
+    return {
+        unmeasured: criteria
+            .filter(c => c.evaluatedPropertyId && !got.has(c.evaluatedPropertyId))
+            .map(c => c.id),
+        unmatched: measurements
+            .map(m => m.testableObjectPropertyId)
+            .filter((k) => !!k && !wanted.has(k))
+    };
+}
 /**
  * 이 시각에 유효 기간 밖인가 — **한 규칙**으로 개체·등급·설비↔자산 매핑을 모두 판정한다.
  *
@@ -753,6 +839,40 @@ export function capabilityOf(r, ctx) {
         return { available: false, reason: 'working' };
     return { available: true, reason: 'available' };
 }
+/**
+ * **이 시각에 이 자리에서 참인 관측** — 구간을 든 관측을 시각으로 찾는다.
+ *
+ * 「그때 그 방이 몇 도였나」에 답하는 첫 칸이다. 점 관측은 그 시각에만, 구간 관측은 구간 안에서 참이다.
+ * 여러 개가 겹치면 **가장 늦게 시작한 것**이 답이다(정정이 나중에 온다).
+ *
+ * 커널은 값이 옳은지 **판정하지 않는다** — 기준의 표현식은 문법이 정의되지 않은 자유 문자열이다
+ * (§`TestSpecificationCriterion`). 여기서 하는 일은 짝을 찾아 주는 것까지다.
+ */
+export function observationAt(observations, propertyId, at) {
+    const t = parsedMs(at);
+    if (!(t >= 0))
+        return undefined;
+    let best;
+    let bestStart = -1;
+    for (const o of observations ?? []) {
+        if (o.propertyId !== propertyId)
+            continue;
+        const from = parsedMs(o.effectiveTime);
+        if (!(from >= 0) || from > t)
+            continue;
+        /* 구간이 있으면 그 안이어야 한다. 없으면 그 시점의 값이고, 그 뒤로도 정정될 때까지 유효하다. */
+        if (o.effectiveEndTime) {
+            const to = parsedMs(o.effectiveEndTime);
+            if (to >= 0 && to < t)
+                continue;
+        }
+        if (from > bestStart) {
+            best = o;
+            bestStart = from;
+        }
+    }
+    return best;
+}
 // ── 운영 델타(비-EPCIS) — State 채널의 나머지 절반 ──────────────────────────
 // EPCIS 이벤트는 재고/위치만 재구성 가능. tasks·equipment·orders 의 운영 상태는
 // 이 델타로 미러한다. envelope.eventType = 'task.status' | 'equipment.status' | 'order.status'.

package/dist/flow-engine.d.ts

@@ -560,6 +560,19 @@ export declare abstract class FlowEngine implements TwinKernel {
     protected localParams: Map<string, Map<string, string>>;
     /** 관측 구동(P0) — 이벤트를 접는 투영기와 그 사실. tick 과 섞이지 않게 명시적으로 들고 있다. */
     private observer?;
+    /**
+     * 이 커널의 상태가 **관측에서 왔나** — 미러인가.
+     *
+     * 자체 구동(시뮬)과 가르는 축이다. 두 구동은 **같은 빈 값에 다른 뜻**을 갖는다: 시뮬에서 확보분이
+     * 비는 것은 결함이고, 미러에서는 원본이 말하지 않는 정상이다. 그 구분 없이 한쪽 규칙을 쓰면
+     * 시뮬의 진짜 결함이 조용해지거나 미러가 정상 상태에서 죽는다.
+     *
+     * fork 도 이 표식을 물려받는다(§`fork` — skip 목록에 없다). 예측은 미러에서 갈라져 나오므로
+     * 그것이 맞다: 예측이 든 상태는 여전히 **관측에서 온 상태**다.
+     */
+    protected get observationDriven(): boolean;
+    /** 계보를 잇지 못한 채 넘어간 횟수 — §`StateSnapshot.stepsWithoutMaterial`. */
+    protected stepsWithoutMaterial: number;
     /** 관측분이 아직 커널 상태로 옮겨지지 않았다 — 스냅샷·fork 직전에 한 번만 옮긴다. */
     /**
      * **관측 모드에서 원본과 어긋난 횟수** — 받아들였지만 사실이 맞지 않았다.

package/dist/flow-engine.js

@@ -573,6 +573,21 @@ export class FlowEngine {
     localParams = new Map();
     /** 관측 구동(P0) — 이벤트를 접는 투영기와 그 사실. tick 과 섞이지 않게 명시적으로 들고 있다. */
     observer;
+    /**
+     * 이 커널의 상태가 **관측에서 왔나** — 미러인가.
+     *
+     * 자체 구동(시뮬)과 가르는 축이다. 두 구동은 **같은 빈 값에 다른 뜻**을 갖는다: 시뮬에서 확보분이
+     * 비는 것은 결함이고, 미러에서는 원본이 말하지 않는 정상이다. 그 구분 없이 한쪽 규칙을 쓰면
+     * 시뮬의 진짜 결함이 조용해지거나 미러가 정상 상태에서 죽는다.
+     *
+     * fork 도 이 표식을 물려받는다(§`fork` — skip 목록에 없다). 예측은 미러에서 갈라져 나오므로
+     * 그것이 맞다: 예측이 든 상태는 여전히 **관측에서 온 상태**다.
+     */
+    get observationDriven() {
+        return !!this.observer;
+    }
+    /** 계보를 잇지 못한 채 넘어간 횟수 — §`StateSnapshot.stepsWithoutMaterial`. */
+    stepsWithoutMaterial = 0;
     /** 관측분이 아직 커널 상태로 옮겨지지 않았다 — 스냅샷·fork 직전에 한 번만 옮긴다. */
     /**
      * **관측 모드에서 원본과 어긋난 횟수** — 받아들였지만 사실이 맞지 않았다.
@@ -1528,6 +1543,8 @@ export class FlowEngine {
                 const u = this.observer?.snapshot?.().unhandled;
                 return u?.length ? { unhandled: u } : {};
             })(),
+            /* 계보를 잇지 못한 채 넘어간 횟수 — 같은 규율(세기만 하고 내보내지 않으면 없는 것과 같다). */
+            ...(this.stepsWithoutMaterial > 0 ? { stepsWithoutMaterial: this.stepsWithoutMaterial } : {}),
             tasks: [...this.tasks.values()].map(t => ({
                 id: t.id, kind: t.kind, status: t.status, itemRefs: [t.itemEpc],
                 fromNode: t.fromNode, toNode: t.toNode, resourceRef: t.resource ?? undefined, orderId: t.orderId,

package/dist/forecast.d.ts

@@ -22,6 +22,23 @@ export interface MonteCarloResult {
     mean: number;
     p50: number;
     p90: number;
+    /**
+     * **계보를 잇지 못한 채 넘어간 횟수** — 회차들 중 **최대값**(§`StateSnapshot.stepsWithoutMaterial`).
+     *
+     * ── 왜 예측 결과에 실어야 하나 (2026-08-24) ──────────────────────────────────
+     * 미러의 오더는 확보분을 갖지 않는다(원본이 「어느 개체가 잡혀 있나」를 말하지 않는 것이 그 시스템의
+     * 정상이다). 그래서 예측이 공정을 넘을 때 개체를 이을 수 없고, 커널은 **넘기되 세어 둔다.**
+     *
+     * 그런데 예측은 **회차마다 fork 를 만들고 버린다.** 그 카운터가 사본 안에만 있으면 아무에게도 닿지
+     * 않는다 — 이 저장소가 이미 그 실수를 겪었다(리듀서가 오래 세어 온 값을 스냅샷이 떨어뜨려, 그것을
+     * 읽도록 쓰인 검사가 영원히 조용했다). **세어 놓고 내보내지 않으면 안 센 것과 같다.**
+     *
+     * 왜 합이 아니라 최대인가: 회차는 **같은 미래의 표본들**이다. 서른 번 굴려 각 회차가 열 칸을
+     * 비웠으면 사실은 「열 칸」이고 300이 아니다. 합을 내면 회차 수를 늘리는 것만으로 숫자가 커진다.
+     *
+     * 0 이면 **싣지 않는다** — 0 을 정보처럼 보이게 하지 않는다.
+     */
+    stepsWithoutMaterial?: number;
 }
 export interface MonteCarloOptions {
     runs: number;

package/dist/forecast.js

@@ -19,14 +19,17 @@ function clockOf(twin) {
 export function monteCarloForecast(twin, opts) {
     const now = clockOf(twin);
     const samples = [];
+    let gaps = 0;
     for (let i = 0; i < opts.runs; i++) {
         const { fc, step, target } = startRun(twin, opts, now, i);
         let guard = 0;
         while (clockOf(fc) < target && guard++ < 1_000_000)
             fc.tick(step);
-        samples.push(opts.metric(fc.getSnapshot()));
+        const snap = fc.getSnapshot();
+        gaps = Math.max(gaps, snap.stepsWithoutMaterial ?? 0);
+        samples.push(opts.metric(snap));
     }
-    return summarize(opts.runs, samples);
+    return summarize(opts.runs, samples, gaps);
 }
 /**
  * 한 회차의 **출발점** — fork(현재 보존) + 그 회차의 미래(seed 변주).
@@ -66,6 +69,7 @@ export async function monteCarloForecastAsync(twin, opts) {
      */
     const everyTicks = Math.max(1, opts.yieldEveryTicks ?? 50);
     const samples = [];
+    let gaps = 0;
     for (let i = 0; i < opts.runs; i++) {
         const { fc, step, target } = startRun(twin, opts, now, i);
         let guard = 0;
@@ -77,15 +81,27 @@ export async function monteCarloForecastAsync(twin, opts) {
                 await yieldFn();
             }
         }
-        samples.push(opts.metric(fc.getSnapshot()));
+        const snap = fc.getSnapshot();
+        gaps = Math.max(gaps, snap.stepsWithoutMaterial ?? 0);
+        samples.push(opts.metric(snap));
         if (i < opts.runs - 1)
             await yieldFn();
     }
-    return summarize(opts.runs, samples);
+    return summarize(opts.runs, samples, gaps);
 }
-function summarize(runs, samples) {
+function summarize(runs, samples, stepsWithoutMaterial = 0) {
     const sorted = [...samples].sort((a, b) => a - b);
     const pct = (p) => sorted[Math.min(sorted.length - 1, Math.floor(p * sorted.length))];
     const mean = samples.reduce((a, b) => a + b, 0) / (samples.length || 1);
-    return { runs, samples, min: sorted[0], max: sorted[sorted.length - 1], mean, p50: pct(0.5), p90: pct(0.9) };
+    return {
+        runs,
+        samples,
+        min: sorted[0],
+        max: sorted[sorted.length - 1],
+        mean,
+        p50: pct(0.5),
+        p90: pct(0.9),
+        /* 0 은 싣지 않는다 — 「구멍이 없다」와 「이 축을 모른다」를 화면이 구별할 수 있게. */
+        ...(stepsWithoutMaterial > 0 ? { stepsWithoutMaterial } : {})
+    };
 }

package/dist/mes-kernel.d.ts

@@ -275,6 +275,13 @@ export declare class MesKernel extends FlowEngine {
     private onOrderDef;
     /** 정의 모드 할당 — 레시피 입력 BOM 전량 확보 후 첫 라우트 스텝 태스크. */
     private allocateDef;
+    /**
+     * 공정 하나의 작업을 낸다.
+     *
+     * `itemEpc` 가 **비어 있을 수 있다**(빈 문자열) — 원본이 개체를 말하지 않는 미러에서 그렇다. 그때
+     * 이 작업은 「무엇을」 없이 「어디서 무엇을 한다」만 안다. 빈 값으로 두는 것이 규약이다(§1453 의
+     * `t.itemRefs?.[0] ?? ''` 와 같은 자리) — 없는 개체를 지어내지 않는다.
+     */
     private emitStationDef;
     /** 정의 모드 완료 — 라우트 인덱스: 중간=WIP 변환+다음 스텝, 마지막=완제품(수율). */
     private onTaskCompleteDef;

package/dist/mes-kernel.js

@@ -811,9 +811,16 @@ export class MesKernel extends FlowEngine {
         o.status = 'op-' + ops[0].key;
         this.emitOrder(o);
     }
+    /**
+     * 공정 하나의 작업을 낸다.
+     *
+     * `itemEpc` 가 **비어 있을 수 있다**(빈 문자열) — 원본이 개체를 말하지 않는 미러에서 그렇다. 그때
+     * 이 작업은 「무엇을」 없이 「어디서 무엇을 한다」만 안다. 빈 값으로 두는 것이 규약이다(§1453 의
+     * `t.itemRefs?.[0] ?? ''` 와 같은 자리) — 없는 개체를 지어내지 않는다.
+     */
     emitStationDef(o, op, itemEpc) {
         const loc = this.locationByType(op.locationType);
-        const task = { id: `task-${++this.taskSeq}`, kind: op.key, status: 'created', itemEpc, fromNode: loc.id, toNode: loc.id, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: op.key, fromNode: loc.id, toNode: loc.id, resourceKind: op.resourceType }, DEFAULT_CYCLE_MS), orderId: o.id, resourceType: op.resourceType, changeoverKey: o.gtin, setupMs: this.paramDuration(op.key, OP_PARAM.setupDuration) ?? DEFAULT_SETUP_MS, intent: op.intent };
+        const task = { id: `task-${++this.taskSeq}`, kind: op.key, status: 'created', itemEpc: itemEpc ?? '', fromNode: loc.id, toNode: loc.id, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: op.key, fromNode: loc.id, toNode: loc.id, resourceKind: op.resourceType }, DEFAULT_CYCLE_MS), orderId: o.id, resourceType: op.resourceType, changeoverKey: o.gtin, setupMs: this.paramDuration(op.key, OP_PARAM.setupDuration) ?? DEFAULT_SETUP_MS, intent: op.intent };
         this.tasks.set(task.id, task);
         this.emitTask(task);
     }
@@ -849,10 +856,34 @@ export class MesKernel extends FlowEngine {
             }
             /* 다음 자리에 무엇을 들고 가는가 — 만든 것이 있으면 그것, 없으면 들고 있던 것. */
             const carried = order.allocated[0];
-            if (!carried) {
+            /*
+             * ── 개체가 없어도 **진행은 막지 않는다** (2026-08-24) ───────────────────────
+             * 예전에는 여기서 무조건 던졌다. 그래서 **미러에서 예측이 구조적으로 실패했다**: 미러의 오더는
+             * 확보분을 가진 적이 없고(원본이 「어느 개체가 잡혀 있나」를 말하지 않는 것이 정상이다 — 첫 실
+             * 연동의 오더 사실은 `status`·`requested`·`fulfilled` 뿐이다), 그 오더가 중간 공정을 넘는
+             * 순간마다 터졌다. 오더 하나 때문에 `twinForecast` 가 통째로 실패했다.
+             *
+             * 두 가지를 섞은 것이 잘못이었다.
+             *
+             *   단계를 넘는 것    공정의 **진행**이다 — 라우트·소요·용량이 답한다. 개체 번호가 필요 없다
+             *   개체를 잇는 것    **계보**다 — 개체가 없으면 이을 수 없다
+             *
+             * 계보를 못 이으면 **계보를 비우는 것**이 맞다(지어내지 않는다 — 예전에 `'WIP'` 를 지어내던
+             * 그 자리다). 그런데 진행까지 멈추면 있는 답(언제 끝나나·처리량)까지 잃는다. **없어도 되는
+             * 것을 요구해서 있는 답을 잃고 있었다.**
+             *
+             * ── 그러나 시뮬에서는 여전히 결함이다 ────────────────────────────────────
+             * 자체 구동은 개체를 스스로 만든다. 거기서 확보분이 비면 `allocateDef` 가 확보하지 못했거나
+             * 선언이 어긋난 것이고, 조용히 넘기면 **계보가 통째로 빈 시뮬**이 정상처럼 보인다. 그래서
+             * 관측 구동일 때만 넘긴다(§`observationDriven`).
+             */
+            if (!carried && !this.observationDriven) {
                 throw new Error(`order ${order.id} at step '${t.kind}': nothing to carry to '${next.key}' — the order holds no allocated material ` +
                     `and this step declares no produced material. Declare the step's input or its output in the model.`);
             }
+            /* 넘기되 **세어 낸다** — 세지 않으면 계보에 구멍이 있는데 화면이 정상으로 보인다. */
+            if (!carried)
+                this.stepsWithoutMaterial++;
             this.emitStationDef(order, next, carried);
             order.status = 'op-' + next.key;
             this.emitOrder(order);
@@ -898,6 +929,24 @@ export class MesKernel extends FlowEngine {
                 this.emitOrder(order);
                 return;
             }
+            /*
+             * ── 원본이 개체를 말하지 않는 현장 (2026-08-24) ────────────────────────────
+             * 위 `seedIncomplete` 는 **우리가 못 심은 것**이다(원본이 말한 물품이 스냅샷에 없었다). 이것은
+             * 다른 사실이다: **원본이 애초에 말하지 않는다.** 첫 실 연동의 오더 사실은 `status`·`requested`
+             * ·`fulfilled` 뿐이고, 「어느 개체가 잡혀 있나」를 주지 않는 것이 그 시스템의 정상이다.
+             *
+             * 두 사실을 한 값으로 뭉개지 않는다 — 앞의 것은 고칠 수 있는 결함이고 뒤의 것은 원본의 성질이다.
+             *
+             * **여기서는 진행도 넘기지 않는다.** 중간 단계는 넘긴다(§`onTaskCompleteDef` — 단계를 넘는 것은
+             * 공정의 진행이고 개체가 필요 없다). 그러나 마지막 단계는 **산출을 만든다**: 소비할 것 없이
+             * 제품을 내면 「일어나지 않은 생산」을 기록하는 것이고, 그것은 계보가 비는 것보다 나쁘다.
+             * 그래서 막혔다고 말하고 멈춘다 — 이유가 상태에 남으므로 화면이 원인을 지어내지 않는다.
+             */
+            if (this.observationDriven) {
+                order.status = 'blocked-source-omits-material';
+                this.emitOrder(order);
+                return;
+            }
             throw new Error(`order ${order.id} at final step '${t.kind}': nothing allocated to consume — the kernel does not make a ` +
                 `product out of nothing. Declare the recipe inputs, or the step's produced material.`);
         }

package/dist-cjs/index.cjs

@@ -96,6 +96,7 @@ __export(index_exports, {
   constantDuration: () => constantDuration,
   conversionFactorOf: () => conversionFactorOf,
   counterfactualAt: () => counterfactualAt,
+  criterionSaysNothing: () => criterionSaysNothing,
   demandWindowStart: () => demandWindowStart,
   deriveAttentions: () => deriveAttentions,
   documentPath: () => documentPath,
@@ -142,10 +143,12 @@ __export(index_exports, {
   monteCarloForecastAsync: () => monteCarloForecastAsync,
   objectEvent: () => objectEvent,
   objectUri: () => objectUri,
+  observationAt: () => observationAt,
   offCalendarAt: () => offCalendarAt,
   offCalendarReasonAt: () => offCalendarReasonAt,
   operationalKindOf: () => operationalKindOf,
   operationsCapabilityOf: () => operationsCapabilityOf,
+  outsideLimit: () => outsideLimit,
   parseEpc: () => parseEpc,
   parseIsoDuration: () => parseIsoDuration,
   partialFitPolicy: () => partialFitPolicy,
@@ -168,6 +171,7 @@ __export(index_exports, {
   ssccUri: () => ssccUri,
   stateFieldsOf: () => stateFieldsOf,
   subLotIdOf: () => subLotIdOf,
+  testEvidenceGaps: () => testEvidenceGaps,
   testPassedAt: () => testPassedAt,
   transactionEvent: () => transactionEvent,
   transformationEvent: () => transformationEvent,
@@ -289,6 +293,38 @@ function meetsTests(required, results, at) {
   }
   return true;
 }
+function criterionSaysNothing(c) {
+  if (c?.expression?.trim()) return false;
+  const l = c?.limit;
+  return !(typeof l?.minimum === "number" || typeof l?.maximum === "number");
+}
+function outsideLimit(criterion, observed) {
+  const l = criterion?.limit;
+  if (!l) return void 0;
+  const hasMin = typeof l.minimum === "number";
+  const hasMax = typeof l.maximum === "number";
+  if (!hasMin && !hasMax) return void 0;
+  const raw = observed?.value;
+  if (raw === void 0 || raw === null || String(raw).trim() === "") return void 0;
+  const n = Number(raw);
+  if (!Number.isFinite(n)) return void 0;
+  const lu = l.uom?.trim();
+  const ou = observed?.uom?.trim();
+  if (lu && ou && lu !== ou) return void 0;
+  if (hasMin && n < l.minimum) return true;
+  if (hasMax && n > l.maximum) return true;
+  return false;
+}
+function testEvidenceGaps(spec, result) {
+  const criteria = spec?.criteria ?? [];
+  const measurements = result?.propertyMeasurements ?? [];
+  const wanted = new Set(criteria.map((c) => c.evaluatedPropertyId).filter((k) => !!k));
+  const got = new Set(measurements.map((m) => m.testableObjectPropertyId).filter((k) => !!k));
+  return {
+    unmeasured: criteria.filter((c) => c.evaluatedPropertyId && !got.has(c.evaluatedPropertyId)).map((c) => c.id),
+    unmatched: measurements.map((m) => m.testableObjectPropertyId).filter((k) => !!k && !wanted.has(k))
+  };
+}
 function effectivityAt(p, at) {
   if (!p || !at) return void 0;
   const atMs = parsedMs(at);
@@ -521,6 +557,26 @@ function capabilityOf(r, ctx) {
   if (r.status && r.status !== "idle" && r.status !== "available") return { available: false, reason: "working" };
   return { available: true, reason: "available" };
 }
+function observationAt(observations, propertyId, at) {
+  const t = parsedMs(at);
+  if (!(t >= 0)) return void 0;
+  let best;
+  let bestStart = -1;
+  for (const o of observations ?? []) {
+    if (o.propertyId !== propertyId) continue;
+    const from = parsedMs(o.effectiveTime);
+    if (!(from >= 0) || from > t) continue;
+    if (o.effectiveEndTime) {
+      const to = parsedMs(o.effectiveEndTime);
+      if (to >= 0 && to < t) continue;
+    }
+    if (from > bestStart) {
+      best = o;
+      bestStart = from;
+    }
+  }
+  return best;
+}
 var OP_EVENT = {
   task: "task.status",
   equipment: "equipment.status",
@@ -814,13 +870,16 @@ function clockOf2(twin) {
 function monteCarloForecast(twin, opts) {
   const now = clockOf2(twin);
   const samples = [];
+  let gaps = 0;
   for (let i = 0; i < opts.runs; i++) {
     const { fc, step, target } = startRun(twin, opts, now, i);
     let guard = 0;
     while (clockOf2(fc) < target && guard++ < 1e6) fc.tick(step);
-    samples.push(opts.metric(fc.getSnapshot()));
+    const snap = fc.getSnapshot();
+    gaps = Math.max(gaps, snap.stepsWithoutMaterial ?? 0);
+    samples.push(opts.metric(snap));
   }
-  return summarize(opts.runs, samples);
+  return summarize(opts.runs, samples, gaps);
 }
 function startRun(twin, opts, nowMs, i) {
   const fc = twin.fork();
@@ -833,6 +892,7 @@ async function monteCarloForecastAsync(twin, opts) {
   const yieldFn = opts.yieldFn ?? (() => Promise.resolve());
   const everyTicks = Math.max(1, opts.yieldEveryTicks ?? 50);
   const samples = [];
+  let gaps = 0;
   for (let i = 0; i < opts.runs; i++) {
     const { fc, step, target } = startRun(twin, opts, now, i);
     let guard = 0;
@@ -844,16 +904,28 @@ async function monteCarloForecastAsync(twin, opts) {
         await yieldFn();
       }
     }
-    samples.push(opts.metric(fc.getSnapshot()));
+    const snap = fc.getSnapshot();
+    gaps = Math.max(gaps, snap.stepsWithoutMaterial ?? 0);
+    samples.push(opts.metric(snap));
     if (i < opts.runs - 1) await yieldFn();
   }
-  return summarize(opts.runs, samples);
+  return summarize(opts.runs, samples, gaps);
 }
-function summarize(runs, samples) {
+function summarize(runs, samples, stepsWithoutMaterial = 0) {
   const sorted = [...samples].sort((a, b) => a - b);
   const pct = (p) => sorted[Math.min(sorted.length - 1, Math.floor(p * sorted.length))];
   const mean = samples.reduce((a, b) => a + b, 0) / (samples.length || 1);
-  return { runs, samples, min: sorted[0], max: sorted[sorted.length - 1], mean, p50: pct(0.5), p90: pct(0.9) };
+  return {
+    runs,
+    samples,
+    min: sorted[0],
+    max: sorted[sorted.length - 1],
+    mean,
+    p50: pct(0.5),
+    p90: pct(0.9),
+    /* 0 은 싣지 않는다 — 「구멍이 없다」와 「이 축을 모른다」를 화면이 구별할 수 있게. */
+    ...stepsWithoutMaterial > 0 ? { stepsWithoutMaterial } : {}
+  };
 }
 
 // src/twin-observer.ts
@@ -3729,6 +3801,21 @@ var FlowEngine = class {
   localParams = /* @__PURE__ */ new Map();
   /** 관측 구동(P0) — 이벤트를 접는 투영기와 그 사실. tick 과 섞이지 않게 명시적으로 들고 있다. */
   observer;
+  /**
+   * 이 커널의 상태가 **관측에서 왔나** — 미러인가.
+   *
+   * 자체 구동(시뮬)과 가르는 축이다. 두 구동은 **같은 빈 값에 다른 뜻**을 갖는다: 시뮬에서 확보분이
+   * 비는 것은 결함이고, 미러에서는 원본이 말하지 않는 정상이다. 그 구분 없이 한쪽 규칙을 쓰면
+   * 시뮬의 진짜 결함이 조용해지거나 미러가 정상 상태에서 죽는다.
+   *
+   * fork 도 이 표식을 물려받는다(§`fork` — skip 목록에 없다). 예측은 미러에서 갈라져 나오므로
+   * 그것이 맞다: 예측이 든 상태는 여전히 **관측에서 온 상태**다.
+   */
+  get observationDriven() {
+    return !!this.observer;
+  }
+  /** 계보를 잇지 못한 채 넘어간 횟수 — §`StateSnapshot.stepsWithoutMaterial`. */
+  stepsWithoutMaterial = 0;
   /** 관측분이 아직 커널 상태로 옮겨지지 않았다 — 스냅샷·fork 직전에 한 번만 옮긴다. */
   /**
    * **관측 모드에서 원본과 어긋난 횟수** — 받아들였지만 사실이 맞지 않았다.
@@ -4501,6 +4588,8 @@ var FlowEngine = class {
         const u = this.observer?.snapshot?.().unhandled;
         return u?.length ? { unhandled: u } : {};
       })(),
+      /* 계보를 잇지 못한 채 넘어간 횟수 — 같은 규율(세기만 하고 내보내지 않으면 없는 것과 같다). */
+      ...this.stepsWithoutMaterial > 0 ? { stepsWithoutMaterial: this.stepsWithoutMaterial } : {},
       tasks: [...this.tasks.values()].map((t) => ({
         id: t.id,
         kind: t.kind,
@@ -7598,9 +7687,16 @@ var MesKernel = class extends FlowEngine {
     o.status = "op-" + ops[0].key;
     this.emitOrder(o);
   }
+  /**
+   * 공정 하나의 작업을 낸다.
+   *
+   * `itemEpc` 가 **비어 있을 수 있다**(빈 문자열) — 원본이 개체를 말하지 않는 미러에서 그렇다. 그때
+   * 이 작업은 「무엇을」 없이 「어디서 무엇을 한다」만 안다. 빈 값으로 두는 것이 규약이다(§1453 의
+   * `t.itemRefs?.[0] ?? ''` 와 같은 자리) — 없는 개체를 지어내지 않는다.
+   */
   emitStationDef(o, op, itemEpc) {
     const loc = this.locationByType(op.locationType);
-    const task = { id: `task-${++this.taskSeq}`, kind: op.key, status: "created", itemEpc, fromNode: loc.id, toNode: loc.id, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: op.key, fromNode: loc.id, toNode: loc.id, resourceKind: op.resourceType }, DEFAULT_CYCLE_MS), orderId: o.id, resourceType: op.resourceType, changeoverKey: o.gtin, setupMs: this.paramDuration(op.key, OP_PARAM.setupDuration) ?? DEFAULT_SETUP_MS, intent: op.intent };
+    const task = { id: `task-${++this.taskSeq}`, kind: op.key, status: "created", itemEpc: itemEpc ?? "", fromNode: loc.id, toNode: loc.id, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: op.key, fromNode: loc.id, toNode: loc.id, resourceKind: op.resourceType }, DEFAULT_CYCLE_MS), orderId: o.id, resourceType: op.resourceType, changeoverKey: o.gtin, setupMs: this.paramDuration(op.key, OP_PARAM.setupDuration) ?? DEFAULT_SETUP_MS, intent: op.intent };
     this.tasks.set(task.id, task);
     this.emitTask(task);
   }
@@ -7624,11 +7720,12 @@ var MesKernel = class extends FlowEngine {
         order.allocated = [made];
       }
       const carried = order.allocated[0];
-      if (!carried) {
+      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.`
         );
       }
+      if (!carried) this.stepsWithoutMaterial++;
       this.emitStationDef(order, next, carried);
       order.status = "op-" + next.key;
       this.emitOrder(order);
@@ -7643,6 +7740,11 @@ var MesKernel = class extends FlowEngine {
         this.emitOrder(order);
         return;
       }
+      if (this.observationDriven) {
+        order.status = "blocked-source-omits-material";
+        this.emitOrder(order);
+        return;
+      }
       throw new Error(
         `order ${order.id} at final step '${t.kind}': nothing allocated to consume \u2014 the kernel does not make a product out of nothing. Declare the recipe inputs, or the step's produced material.`
       );
@@ -9085,6 +9187,7 @@ function retiredVocabularyIn(line) {
   constantDuration,
   conversionFactorOf,
   counterfactualAt,
+  criterionSaysNothing,
   demandWindowStart,
   deriveAttentions,
   documentPath,
@@ -9131,10 +9234,12 @@ function retiredVocabularyIn(line) {
   monteCarloForecastAsync,
   objectEvent,
   objectUri,
+  observationAt,
   offCalendarAt,
   offCalendarReasonAt,
   operationalKindOf,
   operationsCapabilityOf,
+  outsideLimit,
   parseEpc,
   parseIsoDuration,
   partialFitPolicy,
@@ -9157,6 +9262,7 @@ function retiredVocabularyIn(line) {
   ssccUri,
   stateFieldsOf,
   subLotIdOf,
+  testEvidenceGaps,
   testPassedAt,
   transactionEvent,
   transformationEvent,

package/package.json

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