@operato/twin-kernel 0.2.0 → 0.2.1

package/dist/contract.d.ts

@@ -8,6 +8,20 @@ export interface CanonicalEnvelope<T = unknown> {
     data: T;
 }
 export type TaskStatus = 'created' | 'assigned' | 'in-progress' | 'completed';
+/**
+ * 자리의 상태 — **포화도에서 파생한다.** 저장하는 값이 아니다.
+ *
+ * 예전에는 시뮬이 `'idle'` 로 두고 한 번도 바꾸지 않았고(변경 지점 0), 미러에는 노드 상태 채널이
+ * 없어 비어 있었다. 화면은 그 값을 그대로 보여 주고 있었다 — **정보처럼 보이는데 정보가 아니었다.**
+ *
+ * 문턱은 병목 주목(`deriveAttentions`)이 쓰는 것과 **같다**: 90% 이상이면 임박, 100% 이상이면 포화.
+ * 규칙이 둘이면 화면과 주목이 다른 말을 한다. 용량을 모르면 상태도 모른다(undefined — 꾸미지 않는다).
+ */
+export declare const NODE_SATURATION_NEAR = 0.9;
+export declare function nodeStatusOf(n: {
+    occupancy?: number;
+    capacity?: number;
+}): 'available' | 'near-full' | 'full' | undefined;
 export interface NodeState {
     id: string;
     type: string;
@@ -29,6 +43,7 @@ export interface NodeState {
      */
     parallelism?: number;
     occupancy: number;
+    /** 포화도 파생 상태 — `nodeStatusOf` 가 낸다(두 구동이 같은 함수를 쓴다). 용량 미상이면 없다. */
     status?: string;
     parentId?: string;
     /**
@@ -182,9 +197,18 @@ export interface TaskState {
     resourceRef?: string;
     orderId?: string;
     progress?: number;
-    /** 남은 시간·총 소요(ms) — 진행 중인 작업을 이어서 굴리는 데 필요(씨앗의 충실도). */
+    /**
+     * 남은 시간·총 소요(ms) — 진행 중인 작업을 이어서 굴리는 데 필요(씨앗의 충실도).
+     * `remainingMs` 는 **마지막 전이 시점의 값**이다. 델타는 매 tick 오지 않으므로(설계) 미러가 든 값은
+     * 그때의 것이고, 지금 값은 `startedAtSimMs` 로 보간한다 — 모션(MoverMotion)과 같은 규율.
+     */
     remainingMs?: number;
     durationMs?: number;
+    /**
+     * 착수 시각(절대 sim-clock) — **보간 앵커.** 이것이 없으면 미러는 "그때 얼마 남았었나" 만 알고
+     * "지금 얼마 남았나" 를 못 낸다. progress = (now − startedAtSimMs) / durationMs.
+     */
+    startedAtSimMs?: number;
     /** 작업 의도 — 무자원이 설계인지(체류) 기록 누락인지 구별하는 근거. */
     intent?: 'transport' | 'process' | 'dwell';
     /**
@@ -380,6 +404,8 @@ export interface QualityDelta {
 }
 export interface TaskStatusDelta {
     taskId: string;
+    /** 착수 시각(절대 sim-clock) — 보간 앵커. TaskState 와 같은 뜻. */
+    startedAtSimMs?: number;
     /** 투입된 사람들 — 미러가 인원 배정을 그대로 비추려면 델타에 실려야 한다. */
     personnel?: string[];
     /** 투입된 물리 자산(팔레트 등). */
@@ -414,6 +440,8 @@ export interface EquipmentStatusDelta {
     kind: string;
     status: string;
     location?: string;
+    /** 지금 붙어 있는 작업 — 사람·자산 델타와 같은 자리. 없으면 미러가 작업↔자원 연결을 모른다. */
+    taskId?: string;
     motion?: MoverMotion;
 }
 /** 관측된 오더 라인(SKU 데맨드) — 실 시스템 오더는 품목 라인을 가짐. 이행 예측(남은 데맨드 재계획)에 필요. */

package/dist/contract.js

@@ -2,6 +2,23 @@
  * Face 1 — 3채널 계약 (walking skeleton 범위).
  * 설계 SoT: operato-twin/design/integration/face1-contract.md
  */
+/**
+ * 자리의 상태 — **포화도에서 파생한다.** 저장하는 값이 아니다.
+ *
+ * 예전에는 시뮬이 `'idle'` 로 두고 한 번도 바꾸지 않았고(변경 지점 0), 미러에는 노드 상태 채널이
+ * 없어 비어 있었다. 화면은 그 값을 그대로 보여 주고 있었다 — **정보처럼 보이는데 정보가 아니었다.**
+ *
+ * 문턱은 병목 주목(`deriveAttentions`)이 쓰는 것과 **같다**: 90% 이상이면 임박, 100% 이상이면 포화.
+ * 규칙이 둘이면 화면과 주목이 다른 말을 한다. 용량을 모르면 상태도 모른다(undefined — 꾸미지 않는다).
+ */
+export const NODE_SATURATION_NEAR = 0.9;
+export function nodeStatusOf(n) {
+    const cap = n.capacity;
+    if (!(typeof cap === 'number' && cap > 0))
+        return undefined;
+    const r = (n.occupancy ?? 0) / cap;
+    return r >= 1 ? 'full' : r >= NODE_SATURATION_NEAR ? 'near-full' : 'available';
+}
 // ── 운영 델타(비-EPCIS) — State 채널의 나머지 절반 ──────────────────────────
 // EPCIS 이벤트는 재고/위치만 재구성 가능. tasks·movers(equipment)·orders 의 운영 상태는
 // 이 델타로 미러한다. envelope.eventType = 'task.status' | 'equipment.status' | 'order.status'.

package/dist/flow-engine.d.ts

@@ -1,4 +1,4 @@
-import type { Attention, BoardDef, Command, CommandAck, EventHandler, MoverMotion, OeeMetrics, AssetState, GeneratorSpec, PersonState, ScenarioControl, StateSnapshot, TwinKernel, Unsubscribe, NodeState, ItemState, MoverState, OrderStatusDelta, TaskState } from './contract.ts';
+import type { Attention, BoardDef, CanonicalEnvelope, Command, CommandAck, EventHandler, MoverMotion, OeeMetrics, AssetState, GeneratorSpec, PersonState, ScenarioControl, StateSnapshot, TwinKernel, Unsubscribe, NodeState, ItemState, MoverState, OrderStatusDelta, TaskState } from './contract.ts';
 import type { EpcisEvent, BizTransactionElement } from './epcis.ts';
 import type { AllocationPolicy, SlotView } from './allocation-policy.ts';
 import type { DurationEstimator, DurationContext } from './duration-estimator.ts';
@@ -12,13 +12,29 @@ export interface FlowNode {
     status: string;
     parentId?: string;
 }
+/**
+ * 시뮬이 들고 있는 물품 — **계약(ItemState)을 축소하지 않는다.**
+ *
+ * 미러(투영기)는 로트·단위·소속·마스터데이터까지 들고 있는데 시뮬은 여섯 필드뿐이었다. 그래서 같은
+ * 사실을 두 구동이 다르게 말했다(파리티 테스트가 잡았다). 여기서 갖는 것은 **보유해야 하는 상태**다 —
+ * 품번 키·로트처럼 식별자에서 순수하게 나오는 값은 저장하지 않고 스냅샷에서 파생한다(둘을 다 저장하면
+ * 어긋날 수 있다).
+ */
 export interface FlowItem {
     epc: string;
     location: string;
     disposition: string;
     gtin?: string;
     qty?: number;
+    /** 수량 단위(UN/CEFACT). 개수면 없다 — 없는 것을 'EA' 로 꾸미지 않는다. */
+    uom?: string;
+    /** 소속 물류단위(팔레트 SSCC 등) — 조립으로 맺어진다. 3D 적재 표현의 재료. */
+    parent?: string;
+    /** 이 물류단위를 싣고 있는 반복사용 자산(GRAI) — `parent` 와 다른 축. */
+    carriedBy?: string;
     expiry?: number;
+    /** 개체·로트 마스터데이터 원문 — 생겨날 때 정해지고 뒤 이벤트가 지우지 않는다. */
+    ilmd?: Record<string, unknown>;
 }
 /** 물리 자산 — 반복사용(팔레트·랙·용기). 설비도 물품도 아니다(GRAI vs SSCC 구분은 계약 주석 참조). */
 export interface FlowAsset {
@@ -73,6 +89,8 @@ export interface FlowTask {
     fromNode: string;
     toNode: string;
     resource: string | null;
+    /** 착수 시각(절대 sim-clock) — 보간 앵커(모션과 같은 규율). */
+    startedAtSimMs?: number;
     /** 이 작업에 투입된 사람들 — 설비와 별개 축(설비 1대 + 작업자 2명이 동시에 잡힌다). */
     personnel?: string[];
     /** 이 작업에 투입된 물리 자산(팔레트 등). */
@@ -178,6 +196,13 @@ export declare abstract class FlowEngine implements TwinKernel {
      * 도메인 정의에서 실어 온다(`loadOperations`). 없으면 커널 기본값을 쓰고 그 사실을 `specCoverage()` 가 밝힌다.
      */
     protected operationSpecs: Map<string, OperationDef>;
+    /** 관측 구동(P0) — 이벤트를 접는 투영기와 그 사실. tick 과 섞이지 않게 명시적으로 들고 있다. */
+    private observer?;
+    /** 관측분이 아직 커널 상태로 옮겨지지 않았다 — 스냅샷·fork 직전에 한 번만 옮긴다. */
+    private observedDirty;
+    private observeMode;
+    /** 관측 구동이 투영기를 세울 때 필요한 원본 보드(구조는 이벤트가 아니라 마스터에서 온다). */
+    protected boardDef?: BoardDef;
     /** 명세 소비 기록 — 무엇을 선언값으로, 무엇을 기본값으로 계산했나(정직한 자기보고). */
     private specUse;
     protected epcSeq: number;
@@ -185,6 +210,8 @@ export declare abstract class FlowEngine implements TwinKernel {
     protected orderSeq: number;
     protected soSeq: number;
     private handlers;
+    /** 구독자 접근(관측 재방출) — emit 과 같은 목록을 쓴다(두 경로가 갈리지 않게). */
+    private handlersRef;
     private gens;
     private generating;
     private speed;
@@ -260,6 +287,29 @@ export declare abstract class FlowEngine implements TwinKernel {
     fork(tenantId?: string): this;
     protected now(): string;
     protected randInt(min: number, max: number): number;
+    /**
+     * 관측 구동(P0 스파이크) — **이벤트로 커널을 굴린다.**
+     *
+     * 상태를 만드는 구동이 둘인데(시뮬 `tick` / 미러 `apply`) 지금은 **모델도 둘**이라 한쪽만 고치면
+     * 갈라진다(2026-08-01 하루에 아홉 곳). 근본 해법은 **한 상태 모델 두 구동**이고, 이것은 그 실현
+     * 가능성을 재는 스파이크다(design/plans/kernel-unification-live-observe.md P0).
+     *
+     * 여기서는 **이미 검증된 조각을 조립**한다: 투영기가 이벤트를 접고, 그 결과를 씨앗 경로
+     * (`hydrateObserved`)로 커널 상태에 심는다. 그래서 관측으로 굴린 커널을 그대로 `fork`·`tick` 할 수
+     * 있다 — "미러에서 예측한다" 가 별도 배관 없이 성립하는지가 이 스파이크의 질문이다.
+     *
+     * **비용은 정직하게**: 이벤트마다 전체를 다시 심으므로 O(상태 크기)다. P1 에서 반영 로직을 순수
+     * reduce 모듈로 추출해 투영기와 공유하면 사라진다. 지금은 계약이 성립하는지만 본다.
+     *
+     * `tick` 과 섞어 쓰지 않는다 — 섞으면 무엇이 진실인지 알 수 없다(관측이 시뮬을 덮어쓴다).
+     */
+    apply(envelope: CanonicalEnvelope): void;
+    /** 관측분을 커널 상태로 옮긴다 — 필요할 때 한 번만(같은 규칙, 같은 씨앗 경로). */
+    private settleObserved;
+    /** 구독자 목록 — 관측 재방출용(private handlers 에 접근). */
+    private observedHandlers;
+    /** 관측 구동으로 굴러가는 중인가 — 소비처가 "이 커널의 진실이 어디서 오나" 를 물을 수 있게. */
+    get observing(): boolean;
     /**
      * 오퍼레이션 명세를 싣는다 — 도메인 정의(ISA-95 OperationsSegment)의 시뮬 명세를 커널이 소비하는 입구.
      * 같은 key 를 다시 실으면 덮어쓴다(정의가 권위).
@@ -335,6 +385,30 @@ export declare abstract class FlowEngine implements TwinKernel {
         bizLocation?: string;
         bizTransactionList?: BizTransactionElement[];
     }): void;
+    /**
+     * 할당(예약) — **처분 변화를 이벤트로 낸다.**
+     *
+     * 예전에는 네 곳(WMS·YMS·MES 두 경로)이 각자 `disposition = reserved` 로 상태만 바꾸고 거래
+     * 이벤트(TransactionEvent)만 냈다. 거래 이벤트는 **처분을 싣지 않으므로** 미러는 그 물건이 잡혔다는
+     * 사실을 영영 알 수 없었다(적합성 하네스가 잡았다). 저널로 복원해도, 예측 씨앗에도 안 실린다.
+     *
+     * 관측 이벤트로 낸다 — 표준이 처분 변화를 표현하는 자리다(ObjectEvent OBSERVE + disposition).
+     * 물건이 여러 자리에 흩어져 있으면 **자리별로 나눠** 낸다(한 이벤트에 한 readPoint 가 맞다).
+     *
+     * `bizStep` 은 **호출부가 정한다.** 할당 자체를 가리키는 CBV 단계(reserving)를 1차 출처로 확인하지
+     * 못했으므로 어휘를 발명하지 않고, 그 할당이 속한 업무 단계를 그대로 쓴다.
+     */
+    protected reserve(epcs: string[], bizStep: string): void;
+    /**
+     * 처분 변화 관측 — **상태와 이벤트를 한 번에.** 둘을 따로 쓰면 반드시 갈라진다.
+     *
+     * 실제로 양쪽으로 갈라져 있었다: 할당은 상태만 바꾸고 이벤트를 안 냈고(미러가 모름), 야드 도크
+     * 도착은 이벤트만 내고 상태를 안 바꿨다(이벤트와 상태가 다른 말). 적합성 하네스가 둘 다 잡았다.
+     *
+     * 물건이 여러 자리에 있으면 자리별로 나눠 낸다(한 이벤트에 한 readPoint 가 맞다).
+     * 이미 그 처분이면 아무 일도 하지 않는다(같은 사실을 두 번 말하지 않는다).
+     */
+    protected observeDisposition(epcs: string[], disposition: string, bizStep: string, at?: string): void;
     /**
      * containment 조립(EPCIS AggregationEvent ADD) — 자식들을 부모(용기)로 집約.
      * consume 지정 시 자식이 컨테이너로 흡수되며 독립 아이템에서 이탈(dematerialize: ObjectEvent DELETE + 제거).
@@ -382,6 +456,8 @@ export declare abstract class FlowEngine implements TwinKernel {
     /** 사람 상태 전이 — 설비와 별개 채널(어휘가 다르다: 고장이 아니라 교대·투입). */
     protected emitAsset(a: FlowAsset): void;
     protected emitPerson(p: FlowPerson): void;
+    /** 설비 상태 전이 — `taskId` 를 함께 싣는다(사람·자산 델타와 같은 규칙). 없으면 미러가 "이 설비가
+     *  무슨 일을 하는 중인가" 를 알 수 없어 작업↔자원 연결이 한쪽에서만 성립한다. */
     protected emitMover(m: FlowMover, motion?: MoverMotion): void;
     protected emitOrder(o: FlowOrder): void;
     /**
@@ -460,9 +536,27 @@ export declare abstract class FlowEngine implements TwinKernel {
      * down 중 무버는 배정 불가 + 진행중 task 동결(processTasks 가 skip) → OEE Availability 손실.
      */
     private processFailures;
+    /**
+     * 물품 상태 산출 — **보유값 + 식별자에서 나오는 파생값.**
+     *
+     * 품번 키(`gtinKey`)·로트(`lot`)는 식별자의 순수 함수라 저장하지 않고 여기서 낸다. 투영기와 **같은
+     * 규칙**(`parseEpc`)을 쓴다 — 두 구동이 같은 식별자를 다르게 뜯으면 같은 사실이 다르게 보인다.
+     * 로트는 LGTIN 이면 식별자 안에 있고, 직렬 개체는 마스터데이터(`ilmd`)에 실려 온다.
+     */
+    protected itemState(i: FlowItem): ItemState;
     protected progressOf(t: FlowTask): number;
     private generate;
     private processOrders;
+    /**
+     * 작업 진행 — **진행을 먼저, 배정을 나중에.**
+     *
+     * 예전에는 배정을 먼저 하고 같은 tick 에서 곧바로 dt 만큼 깎았다. 그래서 이제 막 시작한 작업이
+     * 시작하자마자 한 스텝 진행된 것으로 계산됐고, **방출한 모션 앵커(startedAtSimMs)와 스냅샷이 한
+     * tick 어긋났다**(적합성 하네스가 잡았다). 스텝이 커질수록 오차도 커진다.
+     */
     private processTasks;
+    private assignTasks;
+    /** in-progress 진행/완료 — 상태 효과는 전부 도메인(onTaskComplete). base 는 자원 해제·델타만. */
+    private advanceTasks;
 }
 export {};

package/dist/flow-engine.js

@@ -9,8 +9,9 @@
  * 통합 타입은 도메인 필드를 옵셔널로 넓혀(FlowItem.gtin?, FlowOrder.shipmentEpc? 등) 두 도메인을 담는다.
  * (roadmap Phase5 발견 → 추출. [[project_flow_single_base_vision]] FlowNode 단일 base 방향과 정합.)
  */
-import { OP_EVENT, CMD } from "./contract.js";
-import { transformationEvent, aggregationEvent, objectEvent, DISP } from "./epcis.js";
+import { OP_EVENT, CMD, nodeStatusOf } from "./contract.js";
+import { ObservedReducer } from "./observed-reducer.js";
+import { transformationEvent, aggregationEvent, objectEvent, parseEpc, DISP, ILMD_ATTR } from "./epcis.js";
 import { parseIsoDuration } from "./iso-duration.js";
 const BASE_EPOCH = Date.parse('2026-01-01T00:00:00Z');
 function mulberry32(seed) {
@@ -134,6 +135,13 @@ export class FlowEngine {
      * 도메인 정의에서 실어 온다(`loadOperations`). 없으면 커널 기본값을 쓰고 그 사실을 `specCoverage()` 가 밝힌다.
      */
     operationSpecs = new Map();
+    /** 관측 구동(P0) — 이벤트를 접는 투영기와 그 사실. tick 과 섞이지 않게 명시적으로 들고 있다. */
+    observer;
+    /** 관측분이 아직 커널 상태로 옮겨지지 않았다 — 스냅샷·fork 직전에 한 번만 옮긴다. */
+    observedDirty = false;
+    observeMode = false;
+    /** 관측 구동이 투영기를 세울 때 필요한 원본 보드(구조는 이벤트가 아니라 마스터에서 온다). */
+    boardDef;
     /** 명세 소비 기록 — 무엇을 선언값으로, 무엇을 기본값으로 계산했나(정직한 자기보고). */
     specUse = new Map();
     epcSeq = 0;
@@ -141,6 +149,10 @@ export class FlowEngine {
     orderSeq = 0;
     soSeq = 0;
     handlers = [];
+    /** 구독자 접근(관측 재방출) — emit 과 같은 목록을 쓴다(두 경로가 갈리지 않게). */
+    handlersRef() {
+        return this.handlers;
+    }
     gens = [];
     generating = false;
     speed = 1;
@@ -151,6 +163,7 @@ export class FlowEngine {
     }
     // ── TwinKernel (mechanics, 도메인 무관) ───────────────────────────────────
     loadBoard(def) {
+        this.boardDef = def;
         for (const n of def.nodes)
             this.nodes.set(n.id, { id: n.id, type: n.type, capacity: n.capacity, parallelism: n.parallelism, occupancy: 0, status: 'idle', parentId: n.parentId });
         for (const p of def.persons ?? [])
@@ -199,9 +212,10 @@ export class FlowEngine {
         this.items.clear();
         for (const it of snap.items) {
             this.items.set(it.epc, {
+                /* 품번 키·로트는 식별자에서 파생되므로 심지 않는다(스냅샷이 다시 낸다 — 두 벌을 두면 어긋난다). */
                 epc: it.epc, location: it.location, disposition: it.disposition ?? DISP.sellable,
-                gtin: it.gtin, gtinKey: it.gtinKey, lot: it.lot, qty: it.qty ?? 1, uom: it.uom,
-                parent: it.parent, expiry: it.expiry, ilmd: it.ilmd
+                gtin: it.gtin, qty: it.qty ?? 1, uom: it.uom,
+                parent: it.parent, carriedBy: it.carriedBy, expiry: it.expiry, ilmd: it.ilmd
             });
         }
         for (const m of snap.movers) {
@@ -247,6 +261,7 @@ export class FlowEngine {
                 fromNode: t.fromNode ?? '', toNode: t.toNode ?? '',
                 resource: known && t.status === 'in-progress' ? (t.resourceRef ?? null) : null,
                 remainingMs: known ? t.remainingMs : (t.durationMs ?? 0),
+                startedAtSimMs: t.startedAtSimMs,
                 durationMs: t.durationMs ?? (known ? t.remainingMs : 0),
                 orderId: t.orderId,
                 intent: t.intent
@@ -434,13 +449,21 @@ export class FlowEngine {
         this.processTasks(dt);
     }
     getSnapshot() {
+        this.settleObserved();
         return {
             revision: this.revision,
             simClockMs: this.clockMs,
-            nodes: [...this.nodes.values()].map(n => ({ ...n })),
-            items: [...this.items.values()].map(i => ({ epc: i.epc, gtin: i.gtin, qty: i.qty, location: i.location, disposition: i.disposition, expiry: i.expiry })),
+            /* 출처 표시 — 보드(마스터)에서 온 자리다. 미러는 관측으로 알게 된 자리를 'observed' 로 구별하는데,
+             * 시뮬이 아무 표시도 안 하면 소비처가 두 스냅샷을 같은 규칙으로 읽지 못한다. */
+            nodes: [...this.nodes.values()].map(n => {
+                const { status, ...rest } = n;
+                /* 상태는 저장값이 아니라 포화도 파생 — 미러와 **같은 함수**를 쓴다(규칙이 둘이면 갈라진다). */
+                const derived = nodeStatusOf(n);
+                return { ...rest, ...(derived ? { status: derived } : {}), origin: 'master' };
+            }),
+            items: [...this.items.values()].map(i => this.itemState(i)),
             movers: [...this.movers.values()].map(m => {
-                const s = { id: m.id, kind: m.kind, location: m.location, status: m.status, taskId: m.taskId ?? undefined, oee: this.oeeOf(m), held: m.held, ...(this.offShift(m) ? { offShift: true } : {}) };
+                const s = { id: m.id, kind: m.kind, location: m.location, status: m.status, taskId: m.taskId ?? undefined, oee: this.oeeOf(m), held: m.held, origin: 'master', ...(this.offShift(m) ? { offShift: true } : {}) };
                 const t = m.taskId ? this.tasks.get(m.taskId) : undefined;
                 if (t && t.status === 'in-progress' && t.intent !== 'process')
                     s.motion = { fromNode: t.fromNode, toNode: t.toNode, startedAtSimMs: this.clockMs - (t.durationMs - t.remainingMs), durationMs: t.durationMs, progress: this.progressOf(t), elapsedMs: t.durationMs - t.remainingMs };
@@ -458,7 +481,18 @@ export class FlowEngine {
                     st.offShift = true;
                 return st;
             }),
-            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, progress: t.status === 'in-progress' ? this.progressOf(t) : undefined, ...(t.personnel?.length ? { personnel: t.personnel.slice() } : {}) })),
+            /* 스냅샷이 **델타보다 가난하면 안 된다** — 예전에는 소요·남은 시간을 빼고 내보내서, 이 스냅샷으로
+             * 다른 커널을 심으면(hydrateObserved) 진행 중이던 작업을 이어 굴릴 수 없었다(미러 스냅샷은
+             * 델타에서 왔으므로 갖고 있었다 — 같은 계약을 두 구동이 다르게 채우던 자리). */
+            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,
+                ...(t.intent ? { intent: t.intent } : {}),
+                ...(t.durationMs ? { durationMs: t.durationMs } : {}),
+                ...(t.status === 'in-progress' ? { remainingMs: t.remainingMs, startedAtSimMs: t.startedAtSimMs, progress: this.progressOf(t) } : {}),
+                ...(t.personnel?.length ? { personnel: t.personnel.slice() } : {}),
+                ...(t.assets?.length ? { assets: t.assets.slice() } : {})
+            })),
             orders: [...this.orders.values()].map(o => ({ id: o.id, kind: o.kind, status: o.status, progress: o.requested ? o.fulfilled / o.requested : 0, held: o.held })),
             attentions: this.computeAttentions()
         };
@@ -485,6 +519,7 @@ export class FlowEngine {
      * rng 는 fork 의 시나리오 load 시 재시드(드레인 예측은 생성 없어 rng 무관·결정적).
      */
     fork(tenantId = this.tenantId) {
+        this.settleObserved(); // 관측으로 굴러온 커널을 fork 하려면 먼저 상태로 옮겨야 한다
         const Ctor = this.constructor;
         const clone = new Ctor(tenantId, this.policy);
         // 상태·시나리오(gens/generating)·시퀀스 전부 복제 → 원본의 완전한 continuation.
@@ -510,6 +545,54 @@ export class FlowEngine {
     // ── 보호 헬퍼 (도메인 hook 에서 사용) ──────────────────────────────────────
     now() { return new Date(BASE_EPOCH + this.clockMs).toISOString(); }
     randInt(min, max) { return max <= min ? min : min + Math.floor(this.rng() * (max - min + 1)); }
+    /**
+     * 관측 구동(P0 스파이크) — **이벤트로 커널을 굴린다.**
+     *
+     * 상태를 만드는 구동이 둘인데(시뮬 `tick` / 미러 `apply`) 지금은 **모델도 둘**이라 한쪽만 고치면
+     * 갈라진다(2026-08-01 하루에 아홉 곳). 근본 해법은 **한 상태 모델 두 구동**이고, 이것은 그 실현
+     * 가능성을 재는 스파이크다(design/plans/kernel-unification-live-observe.md P0).
+     *
+     * 여기서는 **이미 검증된 조각을 조립**한다: 투영기가 이벤트를 접고, 그 결과를 씨앗 경로
+     * (`hydrateObserved`)로 커널 상태에 심는다. 그래서 관측으로 굴린 커널을 그대로 `fork`·`tick` 할 수
+     * 있다 — "미러에서 예측한다" 가 별도 배관 없이 성립하는지가 이 스파이크의 질문이다.
+     *
+     * **비용은 정직하게**: 이벤트마다 전체를 다시 심으므로 O(상태 크기)다. P1 에서 반영 로직을 순수
+     * reduce 모듈로 추출해 투영기와 공유하면 사라진다. 지금은 계약이 성립하는지만 본다.
+     *
+     * `tick` 과 섞어 쓰지 않는다 — 섞으면 무엇이 진실인지 알 수 없다(관측이 시뮬을 덮어쓴다).
+     */
+    apply(envelope) {
+        if (!this.observer) {
+            this.observer = new ObservedReducer(this.boardDef ?? { nodes: [], movers: [] });
+            this.observeMode = true;
+        }
+        this.observer.apply(envelope);
+        /* **구독자에게 그대로 흘린다** — 호스트가 시뮬·관측 두 모드에서 같은 배선을 쓰게 하기 위해서다
+         * (`onEvent` 하나로 저널·방송이 붙는다). 관측 모드에서 이것은 **재방출**이지 새 사실이 아니다:
+         * 원천이 이미 그 이벤트를 갖고 있으므로, 호스트가 인입과 재방출을 **둘 다 저널에 적으면 중복**이
+         * 된다. 저널은 인입에서 한 번만 적는다. */
+        for (const h of this.observedHandlers())
+            h(envelope);
+        /* **이벤트마다 상태를 통째로 옮기지 않는다.** 옮기는 비용은 O(상태 크기)라, 이벤트 하나에 그것을
+         * 치르면 유입이 늘수록 감당이 안 된다. 필요해지는 순간(스냅샷·fork)에 **한 번만** 옮긴다. */
+        this.observedDirty = true;
+        this.revision++;
+    }
+    /** 관측분을 커널 상태로 옮긴다 — 필요할 때 한 번만(같은 규칙, 같은 씨앗 경로). */
+    settleObserved() {
+        if (!this.observedDirty || !this.observer)
+            return;
+        this.observedDirty = false;
+        this.hydrateObserved(this.observer.snapshot());
+    }
+    /** 구독자 목록 — 관측 재방출용(private handlers 에 접근). */
+    observedHandlers() {
+        return this.handlersRef();
+    }
+    /** 관측 구동으로 굴러가는 중인가 — 소비처가 "이 커널의 진실이 어디서 오나" 를 물을 수 있게. */
+    get observing() {
+        return this.observeMode;
+    }
     /**
      * 오퍼레이션 명세를 싣는다 — 도메인 정의(ISA-95 OperationsSegment)의 시뮬 명세를 커널이 소비하는 입구.
      * 같은 key 를 다시 실으면 덮어쓴다(정의가 권위).
@@ -694,6 +777,52 @@ export class FlowEngine {
             bizTransactionList: opts.bizTransactionList
         }));
     }
+    /**
+     * 할당(예약) — **처분 변화를 이벤트로 낸다.**
+     *
+     * 예전에는 네 곳(WMS·YMS·MES 두 경로)이 각자 `disposition = reserved` 로 상태만 바꾸고 거래
+     * 이벤트(TransactionEvent)만 냈다. 거래 이벤트는 **처분을 싣지 않으므로** 미러는 그 물건이 잡혔다는
+     * 사실을 영영 알 수 없었다(적합성 하네스가 잡았다). 저널로 복원해도, 예측 씨앗에도 안 실린다.
+     *
+     * 관측 이벤트로 낸다 — 표준이 처분 변화를 표현하는 자리다(ObjectEvent OBSERVE + disposition).
+     * 물건이 여러 자리에 흩어져 있으면 **자리별로 나눠** 낸다(한 이벤트에 한 readPoint 가 맞다).
+     *
+     * `bizStep` 은 **호출부가 정한다.** 할당 자체를 가리키는 CBV 단계(reserving)를 1차 출처로 확인하지
+     * 못했으므로 어휘를 발명하지 않고, 그 할당이 속한 업무 단계를 그대로 쓴다.
+     */
+    reserve(epcs, bizStep) {
+        this.observeDisposition(epcs, DISP.reserved, bizStep);
+    }
+    /**
+     * 처분 변화 관측 — **상태와 이벤트를 한 번에.** 둘을 따로 쓰면 반드시 갈라진다.
+     *
+     * 실제로 양쪽으로 갈라져 있었다: 할당은 상태만 바꾸고 이벤트를 안 냈고(미러가 모름), 야드 도크
+     * 도착은 이벤트만 내고 상태를 안 바꿨다(이벤트와 상태가 다른 말). 적합성 하네스가 둘 다 잡았다.
+     *
+     * 물건이 여러 자리에 있으면 자리별로 나눠 낸다(한 이벤트에 한 readPoint 가 맞다).
+     * 이미 그 처분이면 아무 일도 하지 않는다(같은 사실을 두 번 말하지 않는다).
+     */
+    observeDisposition(epcs, disposition, bizStep, at) {
+        const byLocation = new Map();
+        for (const epc of epcs) {
+            const it = this.items.get(epc);
+            if (!it || it.disposition === disposition)
+                continue;
+            it.disposition = disposition;
+            const where = at ?? it.location ?? '';
+            const bin = byLocation.get(where);
+            if (bin)
+                bin.push(epc);
+            else
+                byLocation.set(where, [epc]);
+        }
+        for (const [where, list] of byLocation) {
+            this.emit(objectEvent({
+                eventTime: this.now(), action: 'OBSERVE', bizStep, disposition,
+                epcList: list, ...(where ? { readPoint: where, bizLocation: where } : {})
+            }));
+        }
+    }
     /**
      * containment 조립(EPCIS AggregationEvent ADD) — 자식들을 부모(용기)로 집約.
      * consume 지정 시 자식이 컨테이너로 흡수되며 독립 아이템에서 이탈(dematerialize: ObjectEvent DELETE + 제거).
@@ -712,6 +841,14 @@ export class FlowEngine {
                     this.items.delete(c);
                 }
             }
+            return;
+        }
+        /* 흡수하지 않는 조립 — 자식은 독립 물품으로 남되 **소속을 상태에도 남긴다.**
+         * 예전에는 이벤트만 내고 상태를 안 바꿔서, 미러는 소속을 알고 시뮬은 몰랐다(같은 사실, 다른 답). */
+        for (const c of children) {
+            const it = this.items.get(c);
+            if (it)
+                it.parent = parent;
         }
     }
     /**
@@ -721,6 +858,12 @@ export class FlowEngine {
      */
     disaggregate(parent, children, opts) {
         this.emit(aggregationEvent({ eventTime: this.now(), action: 'DELETE', bizStep: opts.bizStep, parentID: parent, childEPCs: children.slice(), readPoint: opts.readPoint }));
+        /* 분해 — 소속이 끊어진다(자식이 독립으로 남든 새로 등장하든). */
+        for (const c of children) {
+            const it = this.items.get(c);
+            if (it)
+                it.parent = undefined;
+        }
         if (opts.materialize) {
             const m = opts.materialize;
             for (const c of children) {
@@ -790,7 +933,7 @@ export class FlowEngine {
             ...(t.personnel?.length ? { personnel: t.personnel.slice() } : {}),
             ...(t.assets?.length ? { assets: t.assets.slice() } : {}),
             ...(t.durationMs ? { durationMs: t.durationMs } : {}),
-            ...(inProgress ? { remainingMs: t.remainingMs, progress: t.durationMs ? done / t.durationMs : undefined } : {})
+            ...(inProgress ? { remainingMs: t.remainingMs, startedAtSimMs: t.startedAtSimMs, progress: t.durationMs ? done / t.durationMs : undefined } : {})
         });
     }
     /** 사람 상태 전이 — 설비와 별개 채널(어휘가 다르다: 고장이 아니라 교대·투입). */
@@ -800,7 +943,11 @@ export class FlowEngine {
     emitPerson(p) {
         this.emitOp(OP_EVENT.person, { personId: p.id, personnelClass: p.personnelClass, status: p.status, taskId: p.taskId ?? undefined, ...(this.personOffShift(p) ? { offShift: true } : {}) });
     }
-    emitMover(m, motion) { this.emitOp(OP_EVENT.equipment, { moverId: m.id, kind: m.kind, status: m.status, location: m.location, motion }); }
+    /** 설비 상태 전이 — `taskId` 를 함께 싣는다(사람·자산 델타와 같은 규칙). 없으면 미러가 "이 설비가
+     *  무슨 일을 하는 중인가" 를 알 수 없어 작업↔자원 연결이 한쪽에서만 성립한다. */
+    emitMover(m, motion) {
+        this.emitOp(OP_EVENT.equipment, { moverId: m.id, kind: m.kind, status: m.status, location: m.location, taskId: m.taskId ?? undefined, motion });
+    }
     emitOrder(o) { this.emitOp(OP_EVENT.order, { orderId: o.id, kind: o.kind, status: o.status, requested: o.requested, fulfilled: o.fulfilled, held: o.held }); }
     // ── 내부 mechanics ─────────────────────────────────────────────────────────
     /**
@@ -892,8 +1039,14 @@ export class FlowEngine {
                 continue;
             a.status = 'in-use';
             a.taskId = t.id;
-            if (t.itemEpc)
+            if (t.itemEpc) {
                 a.carrying = t.itemEpc;
+                /* 반대 방향도 맺는다 — 계약이 두 축을 다 정의했으므로 한쪽만 채우면 소비처가 물품에서
+                 * 자산을 못 찾는다(자산 목록을 뒤져야 한다). */
+                const it = this.items.get(t.itemEpc);
+                if (it)
+                    it.carriedBy = a.id;
+            }
             this.emitAsset(a);
         }
     }
@@ -909,6 +1062,11 @@ export class FlowEngine {
             a.status = 'idle';
             a.taskId = null;
             a.location = t.toNode || a.location;
+            if (a.carrying) {
+                const it = this.items.get(a.carrying);
+                if (it)
+                    it.carriedBy = undefined;
+            }
             a.carrying = undefined;
             this.emitAsset(a);
         }
@@ -1048,6 +1206,35 @@ export class FlowEngine {
             }
         }
     }
+    /**
+     * 물품 상태 산출 — **보유값 + 식별자에서 나오는 파생값.**
+     *
+     * 품번 키(`gtinKey`)·로트(`lot`)는 식별자의 순수 함수라 저장하지 않고 여기서 낸다. 투영기와 **같은
+     * 규칙**(`parseEpc`)을 쓴다 — 두 구동이 같은 식별자를 다르게 뜯으면 같은 사실이 다르게 보인다.
+     * 로트는 LGTIN 이면 식별자 안에 있고, 직렬 개체는 마스터데이터(`ilmd`)에 실려 온다.
+     */
+    itemState(i) {
+        const parsedClass = i.gtin ? parseEpc(i.gtin) : undefined;
+        const parsedSelf = parseEpc(i.epc);
+        const lot = parsedClass?.lot ??
+            parsedSelf.lot ??
+            (typeof i.ilmd?.[ILMD_ATTR.lot] === 'string' ? i.ilmd[ILMD_ATTR.lot] : undefined);
+        const gtinKey = parsedClass?.gtinKey ?? parsedSelf.gtinKey;
+        return {
+            epc: i.epc,
+            ...(i.gtin ? { gtin: i.gtin } : {}),
+            ...(gtinKey ? { gtinKey } : {}),
+            ...(lot ? { lot } : {}),
+            location: i.location,
+            ...(i.disposition ? { disposition: i.disposition } : {}),
+            ...(i.parent ? { parent: i.parent } : {}),
+            ...(i.carriedBy ? { carriedBy: i.carriedBy } : {}),
+            ...(i.qty !== undefined ? { qty: i.qty } : {}),
+            ...(i.uom ? { uom: i.uom } : {}),
+            ...(i.expiry !== undefined ? { expiry: i.expiry } : {}),
+            ...(i.ilmd ? { ilmd: i.ilmd } : {})
+        };
+    }
     progressOf(t) { return t.durationMs <= 0 ? 1 : Math.min(1, Math.max(0, (t.durationMs - t.remainingMs) / t.durationMs)); }
     generate() {
         for (const g of this.gens) {
@@ -1080,8 +1267,19 @@ export class FlowEngine {
             if (o.status === 'created' && !o.held)
                 this.allocate(o);
     }
+    /**
+     * 작업 진행 — **진행을 먼저, 배정을 나중에.**
+     *
+     * 예전에는 배정을 먼저 하고 같은 tick 에서 곧바로 dt 만큼 깎았다. 그래서 이제 막 시작한 작업이
+     * 시작하자마자 한 스텝 진행된 것으로 계산됐고, **방출한 모션 앵커(startedAtSimMs)와 스냅샷이 한
+     * tick 어긋났다**(적합성 하네스가 잡았다). 스텝이 커질수록 오차도 커진다.
+     */
     processTasks(dt) {
-        // 1) created → in-progress. dwell(무자원)은 즉시 진행, transport/process 는 가용 자원 배정.
+        this.advanceTasks(dt);
+        this.assignTasks();
+    }
+    assignTasks() {
+        // created → in-progress. dwell(무자원)은 즉시 진행, transport/process 는 가용 자원 배정.
         for (const t of this.tasks.values()) {
             if (t.status !== 'created')
                 continue;
@@ -1097,6 +1295,7 @@ export class FlowEngine {
             if (t.intent === 'dwell') { // 무설비 체류 — 설비 배정 없이 진행(인원 요구가 있으면 위에서 확보됨)
                 t.status = 'in-progress';
                 t.remainingMs = t.durationMs;
+                t.startedAtSimMs = this.clockMs;
                 this.assignCrew(t, crew);
                 this.assignAssets(t, gear);
                 this.emitTask(t);
@@ -1122,6 +1321,7 @@ export class FlowEngine {
             t.status = 'in-progress';
             t.resource = mover.id;
             t.remainingMs = t.durationMs;
+            t.startedAtSimMs = this.clockMs;
             this.assignCrew(t, crew);
             this.assignAssets(t, gear);
             this.emitTask(t);
@@ -1131,7 +1331,9 @@ export class FlowEngine {
             else
                 this.emitMover(mover, { fromNode: t.fromNode, toNode: t.toNode, startedAtSimMs: this.clockMs, durationMs: t.durationMs, progress: 0, elapsedMs: 0 });
         }
-        // 2) in-progress 진행/완료 — 상태 효과는 전부 도메인(onTaskComplete). base 는 자원 해제·델타만.
+    }
+    /** in-progress 진행/완료 — 상태 효과는 전부 도메인(onTaskComplete). base 는 자원 해제·델타만. */
+    advanceTasks(dt) {
         for (const t of this.tasks.values()) {
             if (t.status !== 'in-progress')
                 continue;

package/dist/index.d.ts

@@ -12,6 +12,7 @@ export * from './domain-catalog.ts';
 export * from './allocation-policy.ts';
 export * from './duration-estimator.ts';
 export * from './iso-duration.ts';
+export * from './observed-reducer.ts';
 export * from './state-projector.ts';
 export * from './task-fold.ts';
 export * from './face2-adapter.ts';

package/dist/index.js

@@ -12,6 +12,7 @@ export * from "./domain-catalog.js";
 export * from "./allocation-policy.js";
 export * from "./duration-estimator.js";
 export * from "./iso-duration.js";
+export * from "./observed-reducer.js";
 export * from "./state-projector.js";
 export * from "./task-fold.js";
 export * from "./face2-adapter.js";