@operato/twin-kernel 0.7.53 → 0.7.54

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,40 @@ 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: string;
+    /** 표준 `Result` — 이 기준이 만족될 때 기대하는 값(현장 표기). */
+    result?: string;
+    /** 표준 `EvaluatedPropertyID` — 이 기준이 **무엇을 재어** 판정하나. 측정값과 짝을 맞추는 키다. */
+    evaluatedPropertyId?: string;
+}
 export interface TestSpecification {
     /** 표준 `ID` — 자원의 `testSpecificationIds` 가 이 값을 가리킨다. */
     id: string;
@@ -355,7 +433,56 @@ 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;
 }
+/**
+ * **이 판정에 근거가 있나** — 기준과 측정값의 짝을 맞춰 빈 곳을 돌려준다.
+ *
+ * ── 왜 커널이 이것을 답하나 ─────────────────────────────────────────────────
+ * 커널은 기준을 **평가하지 않는다**(`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`.**
  *
@@ -1557,6 +1684,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,35 @@ export function meetsTests(required, results, at) {
     }
     return true;
 }
+/**
+ * **이 판정에 근거가 있나** — 기준과 측정값의 짝을 맞춰 빈 곳을 돌려준다.
+ *
+ * ── 왜 커널이 이것을 답하나 ─────────────────────────────────────────────────
+ * 커널은 기준을 **평가하지 않는다**(`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))
+    };
+}
 /**
  * 이 시각에 유효 기간 밖인가 — **한 규칙**으로 개체·등급·설비↔자산 매핑을 모두 판정한다.
  *

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/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

@@ -168,6 +168,7 @@ __export(index_exports, {
   ssccUri: () => ssccUri,
   stateFieldsOf: () => stateFieldsOf,
   subLotIdOf: () => subLotIdOf,
+  testEvidenceGaps: () => testEvidenceGaps,
   testPassedAt: () => testPassedAt,
   transactionEvent: () => transactionEvent,
   transformationEvent: () => transformationEvent,
@@ -289,6 +290,16 @@ function meetsTests(required, results, at) {
   }
   return true;
 }
+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);
@@ -3729,6 +3740,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 +4527,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 +7626,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 +7659,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 +7679,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.`
       );
@@ -9157,6 +9198,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.54",
   "type": "module",
   "description": "Twin Domain Kernel — framework-agnostic, zero-dep (domain + sim + 3-channel contract). WMS/YMS/MES, EPCIS 2.0 · ISA-95.",
   "publishConfig": {