@operato/twin-kernel 0.7.61 → 0.7.63

package/dist/contract.js

@@ -944,6 +944,27 @@ export const OP_EVENT = {
      * 없고, 미러가 이어받지 못한다(§상태 ⊆ 이벤트).
      */
     test: 'test.result',
+    /**
+     * **이 목록이 전부다** — 연결된 시스템이 현재 목록을 한 바퀴 다 보낸 뒤 그것을 알린다.
+     *
+     * ── 왜 필요한가 (2026-08-25 실측) ────────────────────────────────────────
+     * 연결된 시스템은 매 주기 현재 재고를 전부 보낸다. 그런데 트윈은 그것을 낱낱의 관측으로 받아
+     * **더하기만 했다.** 「그리고 이것 말고는 없다」를 받는 곳이 없어서, 목록에서 빠진 줄은 아무 말도
+     * 오지 않은 것이 되고 트윈에 영원히 남았다.
+     *
+     * 실측: 실제 재고 1,704건인데 트윈이 10,038건을 갖고 있었다.
+     *
+     * ── 왜 「사라진 것을 알려 주기」가 아니라 이 방식인가 ──────────────────────
+     * 연결 쪽이 앞 주기와 비교해 사라진 줄을 찾아 알리는 방법도 있다. 그런데 그것은 **하나 빠뜨리면
+     * 그 줄이 영원히 남는다.** 이 방식은 주기마다 스스로 바로잡는다 — 이미 잘못 쌓인 것도 다음 주기에
+     * 사라진다.
+     *
+     * ── 보내는 쪽이 지킬 것 ─────────────────────────────────────────────────
+     * **끝까지 읽었을 때만 보낸다.** 읽다가 끊긴 주기에 이것을 보내면 **살아 있는 재고를 지운다.**
+     * 그리고 `since` 는 그 주기를 **시작한** 시각이다(끝낸 시각이 아니다) — 주기 도중에 들어온 관측이
+     * 지워지지 않아야 한다.
+     */
+    complete: 'axis.complete',
     /**
      * 주목 신호 확인(ack) — **사람이 한 행위**라 파생될 수 없다.
      *
@@ -1040,25 +1061,25 @@ export const CMD = {
 };
 // ── 보드 청사진 바인딩 (최소) ──────────────────────────────────────────────
 /**
- * **저장된 보드를 읽는 단 하나의 입구.**
+ * **저장된 트윈 모델을 읽는 단 하나의 입구.**
  *
- * `equipment` 로 개명하기 전에 저장된 보드는 `movers` 키를 갖고 있다(개명 시점 23개 인스턴스).  (vocabulary-guard: allow — 읽기 호환 설명)
+ * `equipment` 로 개명하기 전에 저장된 트윈 모델은 `movers` 키를 갖고 있다(개명 시점 23개 인스턴스).  (vocabulary-guard: allow — 읽기 호환 설명)
  * 저장물을 다시 쓰지 않고 **읽을 때 흡수**한다 — 마이그레이션은 되돌리기 어렵고, 읽기 호환은 값싸다.
  *
  * 규율 둘:
  *  - 이 함수를 **거치지 않고** `def.equipment` 를 직접 읽는 코드를 두지 않는다. 하나라도 남으면
- *    그 경로에서만 옛 보드의 설비가 조용히 사라진다(빈 배열).
+ *    그 경로에서만 옛 트윈 모델의 설비가 조용히 사라진다(빈 배열).
  *  - **쓸 때는 새 이름만** 쓴다. 두 이름으로 쓰기 시작하면 저장물에 두 벌이 영구히 섞인다.
  *
- * 제거 시점: 저장된 보드가 모두 `equipment` 키로 바뀐 것이 확인되면(운영 데이터 점검 후) 이 함수는
+ * 제거 시점: 저장된 트윈 모델이 모두 `equipment` 키로 바뀐 것이 확인되면(운영 데이터 점검 후) 이 함수는
  * 사라진다. 그때까지 남겨 두는 이유를 여기 적어 두는 것이 주석의 일이다.
  */
 /**
- * **저장된 보드의 자리를 읽는 단 하나의 입구.** `readBoardEquipment` 와 같은 규율.
+ * **저장된 트윈 모델의 자리를 읽는 단 하나의 입구.** `readBoardEquipment` 와 같은 규율.
  *
- * `nodes` → `locations` 개명(2026-08-01) 전에 저장된 보드는 `nodes` 키를 갖고 있다(개명 시점 23개).  (vocabulary-guard: allow — 읽기 호환 설명)
+ * `nodes` → `locations` 개명(2026-08-01) 전에 저장된 트윈 모델은 `nodes` 키를 갖고 있다(개명 시점 23개).  (vocabulary-guard: allow — 읽기 호환 설명)
  * 이 함수를 거치지 않고 `def.locations` 를 직접 읽는 코드를 두지 않는다 — 하나라도 남으면 그 경로에서만
- * 옛 보드의 자리가 조용히 사라진다(빈 배열 = 자리 없는 트윈 = 아무 일도 일어나지 않는다).
+ * 옛 트윈 모델의 자리가 조용히 사라진다(빈 배열 = 자리 없는 트윈 = 아무 일도 일어나지 않는다).
  */
 export function readBoardLocations(def) {
     const d = def; // vocabulary-guard: allow — 옛 키 캐스트
@@ -1066,12 +1087,12 @@ export function readBoardLocations(def) {
 }
 export function readBoardEquipment(def) {
     /* `movers` 는 개명 **이전의 이름**이다(movers → equipmentList → equipment). 저장된 보드에는 세 세대가
-       섞여 있어(실측: 23개 중 13개가 `movers`) 하나라도 빠뜨리면 그 보드는 **설비가 0인 공장**으로 읽힌다 —
+       섞여 있어(실측: 23개 중 13개가 `movers`) 하나라도 빠뜨리면 그 트윈 모델은 **설비가 0인 공장**으로 읽힌다 —
        오류 없이. 실제로 그랬다: 화면의 설비 수가 0이고, 용량 판정에 자원이 없고, 카탈로그 통합 테스트가
        "완제품 0" 으로 떨어졌다. 셋 다 원인이 이 한 줄이었다. */
     const d = def; // vocabulary-guard: allow — 옛 키를 읽어야 하는 자리
     const list = d.equipment ?? d.equipmentList ?? d.movers ?? []; // vocabulary-guard: allow — 옛 키 흡수
-    /* 소속 자리 키도 함께 정규화한다 — `homeNode → homeLocation` 개명 전 보드가 23개 있다.  (vocabulary-guard: allow — 옛 키 정규화 설명)
+    /* 소속 자리 키도 함께 정규화한다 — `homeNode → homeLocation` 개명 전 트윈 모델이 23개 있다.  (vocabulary-guard: allow — 옛 키 정규화 설명)
        배열만 흡수하고 안쪽 키를 놓치면 설비는 나타나지만 **소속이 전부 비어** 롤업이 통째로 사라진다. */
     return list.map(e => normalizeHomeLocation(e));
 }
@@ -1083,7 +1104,7 @@ function normalizeHomeLocation(entry) {
     const { homeNode: _drop, ...rest } = entry; // vocabulary-guard: allow — 옛 키 제거
     return { ...rest, homeLocation: legacy };
 }
-/** 저장된 보드의 반복사용 자산 — 설비와 같은 정규화를 거친다. */
+/** 저장된 트윈 모델의 반복사용 자산 — 설비와 같은 정규화를 거친다. */
 export function readBoardAssets(def) {
     const list = (def.assets ?? []);
     return list.map(a => normalizeHomeLocation(a));

package/dist/domain-catalog.d.ts

@@ -86,7 +86,7 @@ export interface TwinAxisInfo {
      * 현장이 낳는 사실이고, 그 집은 커널 상태와 저널이다(ISA-95 Part 4).
      *
      * 이 칸이 없으면 축만 늘려도 소비처가 board 에서 찾다가 **언제나 0 을 답한다** — 오류 없이,
-     * 그냥 빈 공장처럼. 이 프로젝트가 이미 그 모양으로 한 번 무너졌다(옛 어휘 보드가 자리 0·설비 0).
+     * 그냥 빈 공장처럼. 이 프로젝트가 이미 그 모양으로 한 번 무너졌다(옛 어휘 트윈 모델이 자리 0·설비 0).
      *
      *  · `document` — 저장된 트윈 모델 안. `path` 가 그 자리를 말한다
      *  · `state`    — 커널 상태. **지금의 사실**이고 커널이 돌 때만 있다(멈추면 `null`, 0 이 아니다)

package/dist/event-journal.d.ts

@@ -41,7 +41,7 @@ export declare function replayWithCheckpoint(model: TwinModelDef, events: readon
 /**
  * 한 구조 아래에서 일어난 이벤트들 — 재생의 한 마디.
  *
- * 필드 이름이 `model` 인 이유: 이 값의 정체는 **트윈 모델**이다(`TwinModelDef`). 보드는 그것을 그리는
+ * 필드 이름이 `model` 인 이유: 이 값의 정체는 **트윈 모델**이다(`TwinModelDef`). 트윈 모델은 그것을 그리는
  * 표현 중 하나일 뿐이고, 소비처는 이미 전부 `model` 로 옮겼다. 그동안 호스트가 넘길 때마다 `model` 을
  * `board` 키로 되돌려 담는 **어휘 번역기**가 경계에 끼어 있었다 — 조용히 `model` 로 넘기면 커널이
  * `undefined` 를 읽고 재생이 통째로 죽던 자리다. 이름을 맞추면 그 브릿지가 사라진다.

package/dist/flow-engine.d.ts

@@ -635,7 +635,7 @@ export declare abstract class FlowEngine implements TwinKernel {
     private materialSpecCrossKeyOverlaps;
     private observedDirty;
     private observeMode;
-    /** 관측 구동이 투영기를 세울 때 필요한 원본 보드(구조는 이벤트가 아니라 마스터에서 온다). */
+    /** 관측 구동이 투영기를 세울 때 필요한 원본 트윈 모델(구조는 이벤트가 아니라 마스터에서 온다). */
     protected boardDef?: TwinModelDef;
     /** 명세 소비 기록 — 무엇을 선언값으로, 무엇을 기본값으로 계산했나(정직한 자기보고). */
     private specUse;
@@ -1598,7 +1598,7 @@ export declare abstract class FlowEngine implements TwinKernel {
     /**
      * 시뮬 시각의 분(0..1439) — 캘린더 판정의 기준.
      *
-     * **보드가 선언한 기준으로 읽는다**(`utcOffsetMinutes`). 예전에는 UTC 로 읽어서 Rosarito(UTC−7)의
+     * **트윈 모델이 선언한 기준으로 읽는다**(`utcOffsetMinutes`). 예전에는 UTC 로 읽어서 Rosarito(UTC−7)의
      * 06시 교대가 7시간 틀렸다 — 시각대만 적고 기준을 안 적으면 반드시 이렇게 된다.
      */
     protected minuteOfDay(): number;

package/dist/flow-engine.js

@@ -705,7 +705,7 @@ export class FlowEngine {
     materialSpecCrossKeyOverlaps = 0;
     observedDirty = false;
     observeMode = false;
-    /** 관측 구동이 투영기를 세울 때 필요한 원본 보드(구조는 이벤트가 아니라 마스터에서 온다). */
+    /** 관측 구동이 투영기를 세울 때 필요한 원본 트윈 모델(구조는 이벤트가 아니라 마스터에서 온다). */
     boardDef;
     /** 명세 소비 기록 — 무엇을 선언값으로, 무엇을 기본값으로 계산했나(정직한 자기보고). */
     specUse = new Map();
@@ -1035,7 +1035,7 @@ export class FlowEngine {
                 /* 계획 정지를 이어받는다 — 잃으면 씨앗이 **정비 중인 설비를 가용으로 놓고** 미래를 시뮬레이션한다
                    (예측이 낙관 쪽으로 치우친다). 씨앗 왕복 대조가 이것을 잡았다. */
                 ...(m.held ? { held: true } : {}),
-                /* 관측 스냅샷이 들고 있는 것은 관측을 따른다(미러가 보드에서 읽어 실어 온다). */
+                /* 관측 스냅샷이 들고 있는 것은 관측을 따른다(미러가 트윈 모델에서 읽어 실어 온다). */
                 ...(m.properties ? { properties: m.properties } : {}),
                 ...(m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}),
                 /* 결과도 이어받는다 — 잃으면 예측이 **자격 만료를 모르는 현장**에서 출발한다(낙관 쪽으로 치우친다). */
@@ -1561,7 +1561,7 @@ export class FlowEngine {
                         ...(this.materialSpecCrossKeyOverlaps ? { materialSpecCrossKeyOverlaps: this.materialSpecCrossKeyOverlaps } : {})
                     } }
                 : {}),
-            /* 출처 표시 — 보드(마스터)에서 온 자리다. 미러는 관측으로 알게 된 자리를 'observed' 로 구별하는데,
+            /* 출처 표시 — 트윈 모델(마스터)에서 온 자리다. 미러는 관측으로 알게 된 자리를 'observed' 로 구별하는데,
              * 시뮬이 아무 표시도 안 하면 소비처가 두 스냅샷을 같은 규칙으로 읽지 못한다. */
             locations: [...this.locations.values()].map(n => {
                 const { status, ...rest } = n;
@@ -3532,7 +3532,7 @@ export class FlowEngine {
     /**
      * 시뮬 시각의 분(0..1439) — 캘린더 판정의 기준.
      *
-     * **보드가 선언한 기준으로 읽는다**(`utcOffsetMinutes`). 예전에는 UTC 로 읽어서 Rosarito(UTC−7)의
+     * **트윈 모델이 선언한 기준으로 읽는다**(`utcOffsetMinutes`). 예전에는 UTC 로 읽어서 Rosarito(UTC−7)의
      * 06시 교대가 7시간 틀렸다 — 시각대만 적고 기준을 안 적으면 반드시 이렇게 된다.
      */
     minuteOfDay() {

package/dist/observed-reducer.d.ts

@@ -18,6 +18,14 @@ interface ProjItem {
     expiry?: number;
     /** 이 로트의 시험 결과 — **명세당 최신 하나**(상태가 계측 주기로 자라지 않게). */
     testResults?: TestResult[];
+    /**
+     * **마지막으로 관측된 시각**(ms) — 「이 목록이 전부다」를 받았을 때 무엇을 지울지 가리는 값.
+     *
+     * 물품 안에 두는 이유: 순서 판정에 쓰는 시각(`lastAt`)은 **중간 저장본에 들어가지 않는다.**
+     * 그것에 기대면 재기동 직후 첫 신호가 재고를 전부 지운다(본 적이 없는 것으로 보이므로).
+     * 물품은 중간 저장본에 들어가므로 이 값도 함께 살아남는다.
+     */
+    seenAtMs?: number;
 }
 /**
  * 마스터 동기 — 선언적 로케이션 upsert/remove.
@@ -179,7 +187,7 @@ export declare class ObservedReducer {
     private corrections;
     /** 반영하지 못한 사건의 종류별 집계 — 원문은 쌓지 않는다(저널에 이미 있다). */
     private unhandled;
-    /** 선언된 판정 기준(보드에서 한 번 읽는다) — 판정은 선언한 것에만 걸린다. */
+    /** 선언된 판정 기준(트윈 모델에서 한 번 읽는다) — 판정은 선언한 것에만 걸린다. */
     private testSpecs;
     /**
      * 자원별 **교대 선언** — 미러가 "지금 근무 중인가" 를 스스로 판정하기 위한 재료.
@@ -195,7 +203,7 @@ export declare class ObservedReducer {
      * 통과시키는 어긋남이 생기고, 그 어긋남은 조용하다.
      */
     private classDefs;
-    /** 시각 해석 기준(보드 선언) — 없으면 UTC. 캘린더의 `HH:MM` 이 어느 기준인지 정한다. */
+    /** 시각 해석 기준(트윈 모델 선언) — 없으면 UTC. 캘린더의 `HH:MM` 이 어느 기준인지 정한다. */
     private utcOffsetMinutes?;
     constructor(model: TwinModelDef);
     /**
@@ -228,7 +236,7 @@ export declare class ObservedReducer {
      * 종류는 모르므로 `unknown`, **용량은 비워 둔다**(발명하지 않는다), 출처는 `observed`.
      *
      * 출처를 표시하는 이유: 소비처가 "마스터가 말한 자리" 와 "관측으로 알게 된 자리" 를 구별해야 한다
-     * (보드에 좌표가 없고, 용량을 채워야 계획에 참여한다). 마스터 동기가 오면 `master` 로 승격된다.
+     * (트윈 모델에 좌표가 없고, 용량을 채워야 계획에 참여한다). 마스터 동기가 오면 `master` 로 승격된다.
      */
     private touchLocation;
     /**

package/dist/observed-reducer.js

@@ -68,7 +68,7 @@ export class ObservedReducer {
     corrections = [];
     /** 반영하지 못한 사건의 종류별 집계 — 원문은 쌓지 않는다(저널에 이미 있다). */
     unhandled = new Map();
-    /** 선언된 판정 기준(보드에서 한 번 읽는다) — 판정은 선언한 것에만 걸린다. */
+    /** 선언된 판정 기준(트윈 모델에서 한 번 읽는다) — 판정은 선언한 것에만 걸린다. */
     testSpecs = new Map();
     /**
      * 자원별 **교대 선언** — 미러가 "지금 근무 중인가" 를 스스로 판정하기 위한 재료.
@@ -84,7 +84,7 @@ export class ObservedReducer {
      * 통과시키는 어긋남이 생기고, 그 어긋남은 조용하다.
      */
     classDefs = {};
-    /** 시각 해석 기준(보드 선언) — 없으면 UTC. 캘린더의 `HH:MM` 이 어느 기준인지 정한다. */
+    /** 시각 해석 기준(트윈 모델 선언) — 없으면 UTC. 캘린더의 `HH:MM` 이 어느 기준인지 정한다. */
     utcOffsetMinutes;
     constructor(model) {
         this.utcOffsetMinutes = model.utcOffsetMinutes;
@@ -209,7 +209,7 @@ export class ObservedReducer {
      * 종류는 모르므로 `unknown`, **용량은 비워 둔다**(발명하지 않는다), 출처는 `observed`.
      *
      * 출처를 표시하는 이유: 소비처가 "마스터가 말한 자리" 와 "관측으로 알게 된 자리" 를 구별해야 한다
-     * (보드에 좌표가 없고, 용량을 채워야 계획에 참여한다). 마스터 동기가 오면 `master` 로 승격된다.
+     * (트윈 모델에 좌표가 없고, 용량을 채워야 계획에 참여한다). 마스터 동기가 오면 `master` 로 승격된다.
      */
     touchLocation(id) {
         if (!id || this.master.has(id))
@@ -271,6 +271,32 @@ export class ObservedReducer {
                  * 예측을 이어 굴릴 수 있고, 무자원이 설계인지(체류) 구별할 수 있다. */
                 this.touchLocation(d.fromNode);
                 this.touchLocation(d.toNode);
+                /*
+                 * ── ★ **일어난 일은 다시 말하지 않아도 지우지 않는다** (2026-08-24) ────────
+                 *
+                 * 이 자리는 매번 **새 객체를 짓는다.** 그래서 뒤에 온 전이가 앞의 필드를 조용히 지웠다 — 물품은
+                 * 오래전부터 병합하는데(`mergeItem`: 「아는 것을 잃지 않는다」) **작업만 그 규율 밖에 있었다.**
+                 *
+                 * 실측(포천): 작업 하나가 전이 여러 건으로 온다((로트,공정) 76짝 중 52짝이 2건 이상). 완료
+                 * 전이에 투입 실적을 실으면 **그 뒤 어떤 전이도 그것을 지웠다.**
+                 *
+                 * ── 그런데 **통째 병합은 반대 방향으로 틀린다** ────────────────────────────
+                 * 어떤 필드는 **일부러 사라진다**: `remainingMs`·`progress`·`startedAtSimMs` 는 진행 중일 때만
+                 * 실리고(§`emitTask`), 자원 참조는 놓으면 빠진다. 그것을 지키면 끝난 작업이 남은 시간을 들고
+                 * 놓은 자원을 계속 쥔 것으로 보인다.
+                 *
+                 * ── 그래서 선을 이렇게 긋는다 ──────────────────────────────────────────
+                 *   **과거의 사실**은 다시 말하지 않아도 지우지 않는다 — 일어난 일은 안 일어난 일이 될 수 없다
+                 *   **지금의 값**은 말하지 않으면 없는 것이다 — 그것이 「지금」의 뜻이다
+                 *
+                 * 지금 이 규율이 걸리는 것은 `materialActual`(무엇을 얼마나 썼나) 하나다 — 상태가 드는 것 중
+                 * 「일어난 일」이 그것뿐이다(`outcome` 은 상태 계약에 아직 없다). 명시로 지우려면 원천이
+                 * **빈 배열**을 보낸다(`materialActual: []`) — 그때는 말한 것이다.
+                 *
+                 * 늘릴 때는 「이 필드가 사라지는 것이 사실일 수 있나」를 먼저 물어야 한다. 그렇다면 넣지 않는다.
+                 */
+                const prevTask = this.tasks.get(d.taskId);
+                const keptActual = d.materialActual === undefined ? prevTask?.materialActual : undefined;
                 this.tasks.set(d.taskId, {
                     id: d.taskId, kind: d.kind, status: d.status, fromNode: d.fromNode, toNode: d.toNode,
                     itemRefs: d.itemRefs, resourceRef: d.resourceRef, orderId: d.orderId,
@@ -279,8 +305,13 @@ export class ObservedReducer {
                     ...(d.personnel?.length ? { personnel: d.personnel.slice() } : {}),
                     ...(d.assets?.length ? { assets: d.assets.slice() } : {}),
                     ...(d.resources?.length ? { resources: d.resources.slice() } : {}),
-                    /* 실제 자재 이동 — 인원·설비와 같은 채널로 온다(실적을 한 곳에서 읽는다). */
-                    ...(d.materialActual?.length ? { materialActual: d.materialActual.map(r => ({ ...r })) } : {}),
+                    /* 실제 자재 이동 — 인원·설비와 같은 채널로 온다(실적을 한 곳에서 읽는다).
+                       말하지 않았으면 **앞의 것을 지킨다**(위 주석) — 빈 배열은 「지웠다」로 말한 것이다. */
+                    ...(d.materialActual?.length
+                        ? { materialActual: d.materialActual.map(r => ({ ...r })) }
+                        : keptActual?.length
+                            ? { materialActual: keptActual.map(r => ({ ...r })) }
+                            : {}),
                     ...(d.priority !== undefined ? { priority: d.priority } : {}),
                     ...(d.startTime ? { startTime: d.startTime } : {}),
                     ...(d.endTime ? { endTime: d.endTime } : {})
@@ -404,6 +435,44 @@ export class ObservedReducer {
                 item.testResults = [...kept, next];
                 break;
             }
+            case OP_EVENT.complete: {
+                /*
+                 * ── ★ **이 목록이 전부다** (2026-08-25) ────────────────────────────────
+                 *
+                 * 연결된 시스템이 현재 목록을 한 바퀴 다 보낸 뒤 그것을 알린다. 이 주기에 오지 않은 것은
+                 * **그 시스템에 더 이상 없는 것**이므로 지운다.
+                 *
+                 * 이것이 없던 동안 트윈은 받은 것을 **더하기만 했다** — 목록에서 빠진 줄은 아무 말도 오지 않은
+                 * 것이 되어 영원히 남았다(실측: 실제 1,704건인데 트윈이 10,038건).
+                 *
+                 * ── 아무것도 못 들은 주기에는 지우지 않는다 ────────────────────────────
+                 * 그 주기에 관측이 **한 건도** 없었다면 그것은 「다 없어졌다」가 아니라 **우리가 못 들은 것**이다.
+                 * 그때 지우면 살아 있는 재고가 사라진다 — 이 저장소가 여러 번 거절한 모양이다(결측 ≠ 없음).
+                 *
+                 * 보내는 쪽의 규율은 계약에 적었다: **끝까지 읽었을 때만 보낸다.** 읽다가 끊긴 주기에 보내면
+                 * 살아 있는 재고를 지운다. 그 판단은 보내는 쪽만 할 수 있다.
+                 *
+                 * 지운 수를 `unhandled` 로 세지 않는다 — 그것은 반영하지 못한 사건을 세는 자리다. 여기서 지운
+                 * 것은 **정상적으로 반영한 결과**다.
+                 */
+                const d = e.data;
+                if (d?.completeAxis !== 'items')
+                    break;
+                const since = Date.parse(String(d.since ?? ''));
+                if (!Number.isFinite(since))
+                    break;
+                let heard = 0;
+                for (const it of this.items.values())
+                    if ((it.seenAtMs ?? -1) >= since)
+                        heard++;
+                if (!heard)
+                    break;
+                for (const [key, it] of [...this.items.entries()]) {
+                    if ((it.seenAtMs ?? -1) < since)
+                        this.remove(key);
+                }
+                break;
+            }
             case OP_EVENT.attentionAck: {
                 /* 확인한 사실만 담는다 — 그 신호가 지금도 성립하는지는 상태가 답한다(여기서 판단하지 않는다). */
                 const d = e.data;
@@ -601,6 +670,45 @@ export class ObservedReducer {
         if (ev.action === 'DELETE') {
             for (const epc of ev.epcList)
                 this.remove(epc);
+            /*
+             * ── ★ **수량으로 온 물품도 없어질 수 있어야 한다** (2026-08-25 실측) ────────
+             *
+             * 여기는 `epcList` 만 봤다. 그래서 **낱개 번호가 없는 현장에서는 재고를 지울 방법이 하나도
+             * 없었다** — 승화푸드는 모든 재고가 수량으로 오는 현장이다.
+             *
+             * 결과: 한 번 본 재고가 영원히 남았다. 연결된 시스템의 목록에서 그 줄이 없어져도 우리는
+             * 「없어졌다」를 들을 길이 없었다(있는 것만 오고, 없어진 것은 아무 말도 오지 않는다).
+             * 실측으로 실제 재고 1,704건인데 트윈이 10,038건을 갖고 있었다.
+             *
+             * ── 무엇을 지우는지는 말한 범위대로 ────────────────────────────────────
+             *   자리를 함께 말했다   그 자리의 그 로트만 지운다 (꺼내 가서 그 칸이 빈 경우)
+             *   자리를 말하지 않았다  그 로트를 모든 자리에서 지운다 (그 로트가 통째로 없어진 경우)
+             *
+             * 짐작이 아니라 **진술의 범위를 읽는 것**이다. 자리를 말했으면 그 자리를 말한 것이고,
+             * 말하지 않았으면 자리를 가리지 않고 말한 것이다.
+             *
+             * 순서 판정을 함께 지난다: 늦게 온 옛 「없어졌다」가 그 뒤에 다시 들어온 재고를 지우면 안 된다.
+             * 열쇠는 관측과 같은 것을 쓴다 — 같은 대상의 두 방향이므로 한 열쇠로 재야 한다.
+             */
+            const goneAt = ev.readPoint?.id;
+            for (const qe of ev.quantityList ?? []) {
+                if (!qe?.epcClass)
+                    continue;
+                if (goneAt) {
+                    const key = `${qe.epcClass}@${goneAt}`;
+                    if (envelope && this.stale(`item:${key}`, envelope))
+                        continue;
+                    this.remove(key);
+                    continue;
+                }
+                for (const key of [...this.items.keys()]) {
+                    if (!key.startsWith(`${qe.epcClass}@`))
+                        continue;
+                    if (envelope && this.stale(`item:${key}`, envelope))
+                        continue;
+                    this.remove(key);
+                }
+            }
             return;
         }
         const loc = ev.readPoint?.id;
@@ -615,7 +723,9 @@ export class ObservedReducer {
             /* 물품별 순서 판정 — 늦게 온 옛 관측이 최신 위치를 덮지 않게. */
             if (envelope && this.stale(`item:${epc}`, envelope))
                 continue;
-            this.items.set(epc, this.mergeItem(epc, { location: loc, disposition: ev.disposition, ilmd: ev.ilmd }, q, all));
+            const seen = this.mergeItem(epc, { location: loc, disposition: ev.disposition, ilmd: ev.ilmd }, q, all);
+            const atSeen = Date.parse(String(envelope?.eventTime ?? ''));
+            this.items.set(itemKeyOf(seen), Number.isFinite(atSeen) ? { ...seen, seenAtMs: atSeen } : seen);
         }
         /* 개체 없이 수량만 오는 입고(비직렬 자재) — 표준이 허용하고 검증기도 유효로 판정한다.
          * 이 경우 클래스 식별자 자체가 물품의 키다(로트 관리 자재는 LGTIN 이라 로트별로 갈린다). */
@@ -652,7 +762,9 @@ export class ObservedReducer {
                  */
                 if (envelope && this.stale(`item:${subLotId}`, envelope))
                     continue;
-                this.items.set(subLotId, this.mergeItem(qe.epcClass, { location: loc, disposition: ev.disposition, ilmd: ev.ilmd }, qe, mine, subLotId));
+                const seenQty = this.mergeItem(qe.epcClass, { location: loc, disposition: ev.disposition, ilmd: ev.ilmd }, qe, mine, subLotId);
+                const atQty = Date.parse(String(envelope?.eventTime ?? ''));
+                this.items.set(subLotId, Number.isFinite(atQty) ? { ...seenQty, seenAtMs: atQty } : seenQty);
             }
         }
     }
@@ -905,8 +1017,16 @@ export class ObservedReducer {
                     origin: n.origin
                 };
             }),
-            /* 들고 있는 것을 전부 내보낸다 — 축소하면 그 자리에서 정보가 사라진다. */
-            items: [...this.items.values()].map(i => ({ ...i })),
+            /*
+             * 갖고 있는 것을 전부 내보낸다 — 줄이면 그 자리에서 정보가 사라진다.
+             *
+             * **`seenAtMs` 는 뺀다.** 그것은 물품에 대한 사실이 아니라 **우리가 언제 들었나**이고, 「이 목록이
+             * 전부다」를 받았을 때 무엇을 지울지 가리는 데만 쓴다. 화면이 알 필요가 없고, 상태에 내보내면
+             * 자체 구동에는 없는 값이라 두 구동이 어긋난다(적합성 검사가 그것을 잡았다).
+             *
+             * 중간 저장본에는 남는다 — 재기동 뒤에도 무엇을 지울지 가릴 수 있어야 한다.
+             */
+            items: [...this.items.values()].map(({ seenAtMs: _seen, ...i }) => ({ ...i })),
             /* 유효 기간 판정은 **저장하지 않고 여기서 낸다** — 시뮬과 **같은 함수**(`effectivityAt`)를 부른다.
                만료는 이벤트 없이 시각만으로 일어나므로, 델타로 받아 두면 유휴 자원이 영원히 유효하게 남는다. */
             persons: [...this.persons.values()].map(p => ({ ...p, ...this.effectivityPart(p), ...this.offShiftPart(`person:${p.id}`), ...this.capabilityPart(p, `person:${p.id}`, p.personnelClassIds, this.classDefs.personnel) })),

package/dist/operational-ingest.d.ts

@@ -1,6 +1,6 @@
 import type { IngestResult } from './face2-adapter.ts';
 /** 이 문이 받는 여섯 가지 — 리듀서가 접는 것과 같은 목록(주목 확인은 우리 안의 행위라 제외). */
-export type OperationalKind = 'task' | 'equipment' | 'person' | 'asset' | 'order' | 'quality' | 'test';
+export type OperationalKind = 'task' | 'equipment' | 'person' | 'asset' | 'order' | 'quality' | 'test' | 'observation' | 'complete';
 /**
  * 정규 운영 레코드 — **델타의 필드 이름 + 시각(`at`)**.
  *

package/dist/operational-ingest.js

@@ -140,6 +140,40 @@ const SPECS = {
             derived: 'boolean', propertyMeasurements: 'object[]', recordTime: 'string'
         },
         enums: { result: ['pass', 'fail'] }
+    },
+    /*
+     * **자리의 물리 관측** — 어느 자리의 어느 속성을 언제 얼마로 쟀나.
+     *
+     * 값에 **단위를 함께** 받는다(`ValueType`). 단위 없는 물리량은 판정의 재료가 못 된다 — 3 이 섭씨인지
+     * 화씨인지 모르면 어떤 기준으로도 판정할 수 없다. 다만 **요구하지는 않는다**: 단위를 비우는 실 원본이
+     * 흔하고, 요구하면 그 원본의 관측을 아예 담지 못한다(그때 판정은 커널이 거부한다 — `outsideLimit`).
+     *
+     * `effectiveTime` 도 요구하지 않는다. 없으면 봉투의 시각이 그 자리를 대신한다(§`resolve`) — 원본이
+     * 시각을 말하지 않는 수기 점검이 실재하고, 그때 지어낸 시각보다 폴링 시각이 정직하다.
+     */
+    /*
+     * **이 목록이 전부다** — 연결된 시스템이 현재 목록을 한 바퀴 다 보낸 뒤 알린다.
+     *
+     * 둘 다 요구한다: 어느 목록인지와 그 주기를 **시작한** 시각. 시각이 없으면 무엇을 지울지 가릴 수
+     * 없고, 그때 지우면 전부 지운다 — 받지 않는 것이 옳다.
+     */
+    complete: {
+        eventType: OP_EVENT.complete,
+        identity: 'completeAxis',
+        required: ['completeAxis', 'since'],
+        fields: { completeAxis: 'string', since: 'string', recordTime: 'string' }
+    },
+    observation: {
+        eventType: OP_EVENT.observation,
+        identity: 'locationId',
+        /* 자리와 속성 — 둘 중 하나가 없으면 그 관측은 아무 데도 붙지 못한다. */
+        required: ['locationId', 'propertyId'],
+        fields: {
+            locationId: 'string', propertyId: 'string',
+            value: 'string', dataType: 'string', uom: 'string',
+            effectiveTime: 'string', effectiveEndTime: 'string', recordTime: 'string',
+            source: 'string', derived: 'boolean'
+        }
     }
 };
 /**
@@ -187,6 +221,23 @@ export function operationalKindOf(record) {
      */
     if (has('testableObjectId'))
         return 'test';
+    /*
+     * ── ★ **채널을 열고 또 길을 내지 않았다** (2026-08-24) ──────────────────────
+     * `OP_EVENT.observation`(`location.measured`)을 내고 상태(`LocationState.observations`)와 조회
+     * (`observationAt`)까지 붙였는데 **이 라우팅이 `locationId` 를 보지 않았다.** 커넥터가 방의 온습도를
+     * 실어 보내면 「어느 운영 사실인지 모른다」로 거부됐다.
+     *
+     * 같은 부류를 하루에 일곱 번 만났다. 다만 이번엔 **거부되고 이유가 남았다** — 시험 결과 때는 어느
+     * 통도 아니어서 조용히 사라졌다. 그 차이가 이것을 5분 만에 찾게 했다(§`isOperationalRecord`).
+     *
+     * **둘을 함께 요구한다.** `locationId` 만으로는 자리를 말하는 다른 사실과 섞인다. 관측은 「어느
+     * 자리의 **무엇**을 쟀나」이므로 속성 없이는 담을 곳이 없다 — 그때는 받지 않는 것이 옳다.
+     */
+    if (has('locationId') && has('propertyId'))
+        return 'observation';
+    /* 「이 목록이 전부다」 — 어느 목록인지를 스스로 말하므로 다른 사실과 섞이지 않는다. */
+    if (has('completeAxis'))
+        return 'complete';
     return undefined;
 }
 /** 이 레코드가 운영 사실인가 — 호스트의 라우팅이 묻는 자리. */

package/dist/vocabulary.js

@@ -34,13 +34,13 @@ export const VOCABULARY_EXCEPTIONS = [
     { token: 'moverId', why: 'journal wire field — renaming would mix two keys for one fact across history' },
     { token: 'fromNode', why: 'journal wire field (task.status payload)' },
     { token: 'toNode', why: 'journal wire field (task.status payload)' },
-    /* ── 보드의 옛 세대 키 — 저장된 데이터라 읽어는 줘야 한다 ────────────────
+    /* ── 트윈 모델의 옛 세대 키 — 저장된 데이터라 읽어는 줘야 한다 ────────────────
      * 설비 배열의 이름은 세 세대를 거쳤다(movers → equipmentList → equipment). 저장된 보드에는
-     * 셋이 섞여 있고(실측 23개 중 13개가 `movers`), 하나라도 안 읽으면 그 보드는 **설비가 0인 공장**
+     * 셋이 섞여 있고(실측 23개 중 13개가 `movers`), 하나라도 안 읽으면 그 트윈 모델은 **설비가 0인 공장**
      * 으로 조용히 읽힌다 — 화면의 설비 수가 0이 되고 용량 판정에서 자원이 사라진다. 쓰는 곳은
      * `readBoardEquipment` 한 곳뿐이고, 거기서 새 이름으로 정규화해 내보낸다. */
     { token: 'movers', why: 'legacy board key (movers → equipmentList → equipment); read-only normalization in readBoardEquipment, 13 stored boards still use it' },
-    /* ── 씬 컴포넌트 타입 — 보드에 저장된 값이고, 뜻이 어긋나지도 않는다 ──────
+    /* ── 씬 컴포넌트 타입 — 트윈 모델에 저장된 값이고, 뜻이 어긋나지도 않는다 ──────
      * 보드 7개가 이 타입으로 컴포넌트를 담고 있어 개명하면 그 컴포넌트가 조용히 안 그려진다.
      * 그리고 씬에서 이 이름은 자원이 아니라 **움직임 표현**을 가리킨다(표준과 충돌 아님). */
     { token: 'twin-mover', why: 'scene component type persisted in boards; names a motion representation, not a resource' },