@operato/twin-kernel 0.1.0 → 0.2.1

package/dist/flow-engine.js

@@ -9,8 +9,10 @@
  * 통합 타입은 도메인 필드를 옵셔널로 넓혀(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) {
     let a = seed >>> 0;
@@ -116,19 +118,41 @@ export class FlowEngine {
     nodes = new Map();
     items = new Map();
     movers = new Map();
+    /** 사람 — 선언하지 않으면 빈 맵(인원 제약 없는 트윈, 기존 거동). */
+    persons = new Map();
+    /** 물리 자산 — 선언하지 않으면 빈 맵(자산 제약 없는 트윈, 기존 거동). */
+    assets = new Map();
     tasks = new Map();
     orders = new Map();
     revision = 0;
     clockMs = 0;
     rng = mulberry32(1);
     policy;
-    /** duration 시임(선택) — 미주입 시 도메인 상수. 씬/보드 바인딩이 거리·속도 기반 estimator 주입. */
+    /** duration 시임(선택) — 미주입 시 명세, 명세도 없으면 도메인 상수. 이력 보정 추정기가 여기 들어온다. */
     durationEstimator;
+    /**
+     * 오퍼레이션 명세(선택) — 작업 종류(`FlowTask.kind` = `OperationDef.key`) → 소요·변동·모수.
+     * 도메인 정의에서 실어 온다(`loadOperations`). 없으면 커널 기본값을 쓰고 그 사실을 `specCoverage()` 가 밝힌다.
+     */
+    operationSpecs = new Map();
+    /** 관측 구동(P0) — 이벤트를 접는 투영기와 그 사실. tick 과 섞이지 않게 명시적으로 들고 있다. */
+    observer;
+    /** 관측분이 아직 커널 상태로 옮겨지지 않았다 — 스냅샷·fork 직전에 한 번만 옮긴다. */
+    observedDirty = false;
+    observeMode = false;
+    /** 관측 구동이 투영기를 세울 때 필요한 원본 보드(구조는 이벤트가 아니라 마스터에서 온다). */
+    boardDef;
+    /** 명세 소비 기록 — 무엇을 선언값으로, 무엇을 기본값으로 계산했나(정직한 자기보고). */
+    specUse = new Map();
     epcSeq = 0;
     taskSeq = 0;
     orderSeq = 0;
     soSeq = 0;
     handlers = [];
+    /** 구독자 접근(관측 재방출) — emit 과 같은 목록을 쓴다(두 경로가 갈리지 않게). */
+    handlersRef() {
+        return this.handlers;
+    }
     gens = [];
     generating = false;
     speed = 1;
@@ -139,10 +163,15 @@ 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, occupancy: 0, status: 'idle', parentId: n.parentId });
+            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 ?? [])
+            this.persons.set(p.id, { id: p.id, personnelClass: p.personnelClass, status: 'idle', taskId: null, window: p.window });
+        for (const a of def.assets ?? [])
+            this.assets.set(a.id, { id: a.id, assetClass: a.assetClass, location: a.homeNode, status: 'idle', taskId: null });
         for (const m of def.movers) {
-            const mover = { id: m.id, kind: m.kind, location: m.homeNode, status: 'idle', taskId: null, runMs: 0, setupMs: 0, downMs: 0, goodCount: 0, scrapCount: 0 };
+            const mover = { id: m.id, kind: m.kind, location: m.homeNode, status: 'idle', taskId: null, runMs: 0, setupMs: 0, downMs: 0, goodCount: 0, scrapCount: 0, window: m.window };
             if (m.mtbfMs !== undefined) {
                 mover.mtbfMs = m.mtbfMs;
                 mover.mttrMs = m.mttrMs;
@@ -174,13 +203,91 @@ export class FlowEngine {
      * 진행 중 개별 task 의 내부 상태는 관측만으론 복원 불가 → 재계획에 맡김(정직한 한계).
      */
     hydrateObserved(snap, orders = []) {
-        for (const n of snap.nodes)
-            this.nodes.set(n.id, { id: n.id, type: n.type, capacity: n.capacity ?? 0, occupancy: n.occupancy ?? 0, status: 'idle', parentId: n.parentId });
+        /* **관측된 것을 버리지 않는다.** 예전에는 노드·무버 상태를 'idle' 로, OEE 누적을 0 으로 덮고
+         * 물품의 로트·단위·소속·마스터데이터를 떨어뜨렸다. 씨앗이 잃은 것은 **예측도 모른다** —
+         * 고장 난 설비를 정상으로, 진행 중인 일을 없는 것으로 놓고 미래를 굴리면 답이 낙관 쪽으로 치우친다. */
+        for (const n of snap.nodes) {
+            this.nodes.set(n.id, { id: n.id, type: n.type, capacity: n.capacity ?? 0, parallelism: n.parallelism, occupancy: n.occupancy ?? 0, status: n.status ?? 'idle', parentId: n.parentId });
+        }
         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, qty: it.qty ?? 1 });
-        for (const m of snap.movers)
-            this.movers.set(m.id, { id: m.id, kind: m.kind, location: m.location ?? '', status: 'idle', taskId: null, runMs: 0, setupMs: 0, downMs: 0, goodCount: 0, scrapCount: 0 });
+        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, 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) {
+            /*
+             * 관측된 계측을 이어받는다 — **없어서 0 이었던 게 아니라 잘못 읽어서 0 이었다.**
+             * `OeeMetrics` 의 이름은 `runMs`·`setupMs`·`downMs`·`goodCount`·`scrapCount` 인데 예전 코드가
+             * `oee.good`·`oee.scrap`(존재하지 않는 키)을 읽어 항상 0 으로 떨어졌고, 시간 누적은 아예 0 으로
+             * 시작했다. 그래서 씨앗이 "가동 이력이 전혀 없는 설비" 로 출발해 예측의 OEE 가 리셋됐다.
+             *
+             * 라이브(미러)에서 이 값의 출처: 원 시스템이 시간 누적을 보내 주는 것이 아니라, 호스트가
+             * `equipment.status` 전이 구간을 적분하고 `quality.output` 카운터를 모아 파생한다. 그 파생에는
+             * 한계가 있다 — busy 를 가동으로 근사하고 **셋업을 분리하지 못해 0** 으로 둔다. 여기서는 받은
+             * 값을 그대로 이어받고, 없으면 0 에서 시작한다(꾸미지 않는다).
+             */
+            const oee = m.oee;
+            this.movers.set(m.id, {
+                id: m.id, kind: m.kind, location: m.location ?? '', status: m.status ?? 'idle', taskId: null,
+                runMs: oee?.runMs ?? 0, setupMs: oee?.setupMs ?? 0, downMs: oee?.downMs ?? 0,
+                goodCount: oee?.goodCount ?? 0, scrapCount: oee?.scrapCount ?? 0
+            });
+        }
+        /* 사람을 이어 붙인다 — **없으면 인원 요구가 영원히 채워지지 않는다.** 관측 상태에 사람이 있는데
+         * 씨앗이 버리면, 인원을 요구하는 공정의 작업이 하나도 시작되지 못하고 예측이 멈춘다(0 명 < 2 명).
+         * 배정 상태(busy/taskId)는 아래 작업 복원이 다시 세우므로 여기서는 등급·교대만 살린다. */
+        for (const p of snap.persons ?? []) {
+            this.persons.set(p.id, { id: p.id, personnelClass: p.personnelClass, status: 'idle', taskId: null });
+        }
+        /* 자산도 같다 — 잃으면 자산을 요구하는 작업이 영원히 못 나간다(빈 팔레트 0개 < 1개). */
+        for (const a of snap.assets ?? []) {
+            this.assets.set(a.id, { id: a.id, assetClass: a.assetClass, location: a.location, status: 'idle', taskId: null, carrying: a.carrying });
+        }
+        /* 진행 중이던 작업을 이어 붙인다 — 없으면 예측이 "일이 하나도 없는 현장" 에서 출발한다.
+         * 남은 시간을 모르면 **진척을 꾸미지 않고** 미착수(created)로 되돌린다: 그 일이 남아 있다는 사실은
+         * 지키면서, 얼마나 진행됐는지는 모른다고 말하는 쪽이 정직하다(커널이 다시 배정해 굴린다). */
+        for (const t of snap.tasks ?? []) {
+            if (t.status === 'completed')
+                continue;
+            const known = typeof t.remainingMs === 'number' && Number.isFinite(t.remainingMs);
+            this.tasks.set(t.id, {
+                id: t.id, kind: t.kind,
+                status: known && t.status === 'in-progress' ? 'in-progress' : 'created',
+                itemEpc: t.itemRefs?.[0] ?? '',
+                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
+            });
+            /* 진행 중으로 살린 작업은 그 자원을 점유한 상태여야 한다(자원이 동시에 다른 일을 받지 않게). */
+            if (known && t.status === 'in-progress' && t.resourceRef) {
+                const mv = this.movers.get(t.resourceRef);
+                if (mv) {
+                    mv.status = 'busy';
+                    mv.taskId = t.id;
+                }
+            }
+            /* 사람도 같다 — 진행 중이던 작업에 투입돼 있던 사람은 여전히 묶여 있어야 한다. */
+            if (known && t.status === 'in-progress') {
+                const restored = this.tasks.get(t.id);
+                if (restored)
+                    restored.personnel = t.personnel ? [...t.personnel] : undefined;
+                for (const id of t.personnel ?? []) {
+                    const pp = this.persons.get(id);
+                    if (pp) {
+                        pp.status = 'busy';
+                        pp.taskId = t.id;
+                    }
+                }
+            }
+        }
         for (const o of orders) {
             const lines = (o.lines ?? []).map(l => ({ gtin: l.gtin, requested: l.requested - (l.fulfilled ?? 0) })).filter(l => l.requested > 0);
             const remaining = lines.reduce((s, l) => s + l.requested, 0);
@@ -326,7 +433,7 @@ export class FlowEngine {
                 return;
             this.generating = true;
             for (const g of this.gens)
-                g.nextMs = this.clockMs + this.intervalMs(g.spec);
+                g.nextMs = this.nextFireMs(g.spec, this.clockMs);
         },
         pause: () => { this.generating = false; },
         reset: () => { this.generating = false; this.gens = []; },
@@ -342,19 +449,50 @@ 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 };
+                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 };
                 return s;
             }),
-            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 })),
+            assets: [...this.assets.values()].map(a => {
+                const st = { id: a.id, assetClass: a.assetClass, location: a.location, status: a.status, taskId: a.taskId ?? undefined };
+                if (a.carrying)
+                    st.carrying = a.carrying;
+                return st;
+            }),
+            persons: [...this.persons.values()].map(p => {
+                const st = { id: p.id, personnelClass: p.personnelClass, status: p.status, taskId: p.taskId ?? undefined };
+                if (this.personOffShift(p))
+                    st.offShift = true;
+                return st;
+            }),
+            /* 스냅샷이 **델타보다 가난하면 안 된다** — 예전에는 소요·남은 시간을 빼고 내보내서, 이 스냅샷으로
+             * 다른 커널을 심으면(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()
         };
@@ -381,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.
@@ -398,14 +537,197 @@ export class FlowEngine {
         }
         clone.rng.state = this.rng.state; // RNG 연속성 → 생성 포함 결정적 분기
         clone.durationEstimator = this.durationEstimator; // 무상태 시임 — 참조 공유(policy 와 동형)
+        /* 명세는 불변(정의) → 참조 공유. 사용 기록은 fork 자기 것(무엇을 기본값으로 굴렸는지 fork 별로 다르다). */
+        clone.operationSpecs = this.operationSpecs;
+        clone.specUse = new Map([...this.specUse.entries()].map(([k, u]) => [k, { duration: u.duration, variability: u.variability, params: new Set(u.params) }]));
         return clone;
     }
     // ── 보호 헬퍼 (도메인 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)); }
-    /** task 소요 산출 — estimator 주입 시 그 값, 미주입/undefined 시 도메인 상수(fallback). "얼마"만 소비, "경로"는 씬. */
+    /**
+     * 관측 구동(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 를 다시 실으면 덮어쓴다(정의가 권위).
+     */
+    loadOperations(ops = []) {
+        for (const o of ops)
+            if (o?.key)
+                this.operationSpecs.set(o.key, o);
+    }
+    /**
+     * task 소요 산출 — 우선순위: **① 추정기(이력 보정) → ② 명세(ISA-95 Duration + 변동) → ③ 도메인 상수.**
+     *
+     * 이 순서인 이유: 실측에서 배운 값이 선언값을 이기고, 선언값이 우리가 코드에 박아 둔 상수를 이긴다.
+     * 셋 중 무엇을 썼는지는 `specCoverage()` 로 드러낸다 — 상수를 쓴 것이 조용히 넘어가지 않게.
+     * "얼마"만 소비하고 "경로"는 씬이 소유한다(좌표-free 유지).
+     */
     durationOf(ctx, fallbackMs) {
-        return this.durationEstimator?.estimate(ctx) ?? fallbackMs;
+        const estimated = this.durationEstimator?.estimate(ctx);
+        /* 추정기가 답한 것은 **실측·계산에서 온 값**이므로 선언값과 구별해 기록한다 — "현장이 선언했다" 와
+         * "이력에서 배웠다" 는 예측의 자격이 다르다(후자가 더 강하다). 뭉개면 그 차이가 사라진다. */
+        if (typeof estimated === 'number') {
+            this.noteSpecUse(ctx.kind, 'measured');
+            return estimated;
+        }
+        if (estimated) {
+            /* 분포까지 아는 추정치 — **관측된 퍼짐**으로 흔든다. 평균만 쓰면 변동이 0 이라 줄이 생기지 않는다. */
+            this.noteSpecUse(ctx.kind, 'measured', estimated.spread?.distribution);
+            return this.sampleSpread(estimated.meanMs, estimated.spread);
+        }
+        const spec = this.operationSpecs.get(ctx.kind);
+        const declared = parseIsoDuration(spec?.duration);
+        if (declared === undefined) {
+            this.noteSpecUse(ctx.kind, 'default');
+            return fallbackMs;
+        }
+        this.noteSpecUse(ctx.kind, 'declared');
+        return this.applyVariability(declared, spec?.variability);
+    }
+    /**
+     * 소요시간 변동 표본 — **엔진 난수원으로만** 뽑는다(fork 결정성). 표준 밖 확장이므로 미지정이면 상수.
+     * 모수가 모자라면(uniform 에 min/max 없음 등) 변동을 발명하지 않고 평균을 그대로 쓴다.
+     */
+    applyVariability(meanMs, v) {
+        if (!v || v.distribution === 'constant')
+            return meanMs;
+        if (v.distribution === 'exponential')
+            return -Math.log(1 - this.rng()) * meanMs;
+        const minMs = parseIsoDuration(v.min);
+        const maxMs = parseIsoDuration(v.max);
+        if (minMs === undefined || maxMs === undefined)
+            return meanMs;
+        return this.sampleSpread(meanMs, { distribution: v.distribution, minMs, maxMs, modeMs: parseIsoDuration(v.mode) });
+    }
+    /**
+     * 퍼짐 표본 — **엔진 난수원으로만** 뽑는다(fork 결정성). 선언 명세(ISO 표기)와 실측 분포(ms)가
+     * 같은 수식을 쓴다: 한쪽만 고치면 두 경로가 다른 답을 낸다.
+     * 모수가 모자라거나 뒤집혀 있으면 **퍼짐을 발명하지 않고** 평균을 그대로 쓴다.
+     */
+    sampleSpread(meanMs, spread) {
+        if (!spread)
+            return meanMs;
+        const { minMs, maxMs } = spread;
+        if (!Number.isFinite(minMs) || !Number.isFinite(maxMs) || maxMs < minMs)
+            return meanMs;
+        if (spread.distribution === 'uniform')
+            return minMs + this.rng() * (maxMs - minMs);
+        // triangular — 최빈값 미지정이면 평균을 최빈값으로 본다(구간 밖이면 안으로 클램프).
+        const mode = Math.min(maxMs, Math.max(minMs, spread.modeMs ?? meanMs));
+        const u = this.rng();
+        const span = maxMs - minMs;
+        if (span <= 0)
+            return minMs;
+        const c = (mode - minMs) / span;
+        return u < c ? minMs + Math.sqrt(u * span * (mode - minMs)) : maxMs - Math.sqrt((1 - u) * span * (maxMs - mode));
+    }
+    /** 명세 모수(숫자) — 선언 없으면 undefined(0 으로 꾸미지 않는다). 소비처가 기본값을 정한다. */
+    paramNumber(opKey, id) {
+        const p = this.operationSpecs.get(opKey)?.parameters?.find(x => x.id === id);
+        if (!p)
+            return undefined;
+        const n = Number(p.value);
+        if (!Number.isFinite(n))
+            return undefined;
+        this.noteParamUse(opKey, id);
+        return n;
+    }
+    /** 명세 모수(기간) — ISO 8601 문자열을 밀리초로. 선언 없으면 undefined. */
+    paramDuration(opKey, id) {
+        const p = this.operationSpecs.get(opKey)?.parameters?.find(x => x.id === id);
+        const ms = parseIsoDuration(p?.value);
+        if (ms !== undefined)
+            this.noteParamUse(opKey, id);
+        return ms;
+    }
+    noteSpecUse(kind, duration, variability) {
+        const cur = this.specUse.get(kind);
+        if (cur) {
+            cur.duration = duration;
+            if (variability)
+                cur.variability = variability;
+            return;
+        }
+        this.specUse.set(kind, { duration, ...(variability ? { variability } : {}), params: new Set() });
+    }
+    noteParamUse(kind, id) {
+        const cur = this.specUse.get(kind);
+        if (cur)
+            cur.params.add(id);
+        else
+            this.specUse.set(kind, { duration: 'default', params: new Set([id]) });
+    }
+    /**
+     * 시뮬 명세 자기보고 — **어디까지 데이터로 말했고 어디부터 우리가 박아 둔 상수인가.**
+     *
+     * 시뮬레이션 결과를 받는 쪽이 이걸 봐야 한다: 소요시간이 전부 기본값이면 그 예측으로 말할 수 있는 것은
+     * "같은 조건에서의 상대 비교" 뿐이고 "몇 시에 끝난다" 는 근거가 없다. 그 구분을 숫자로 드러낸다.
+     */
+    specCoverage() {
+        const operations = [...this.specUse.entries()].map(([kind, u]) => {
+            const spec = this.operationSpecs.get(kind);
+            /* 실측 분포를 쓴 경우가 우선 — 선언 명세의 변동보다 실제로 굴린 것이 사실이다. */
+            const variability = u.variability ?? spec?.variability?.distribution;
+            return {
+                kind,
+                duration: u.duration,
+                ...(variability ? { variability } : {}),
+                parameters: [...u.params].sort()
+            };
+        });
+        return {
+            operations,
+            measuredDurations: operations.filter(o => o.duration === 'measured').length,
+            declaredDurations: operations.filter(o => o.duration === 'declared').length,
+            defaultDurations: operations.filter(o => o.duration === 'default').length
+        };
     }
     /** skuMix 에서 weight 로 gtin 선택(rng) — 도착/오더 자극의 품목 결정. */
     pickGtin(mix) {
@@ -455,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 + 제거).
@@ -473,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;
         }
     }
     /**
@@ -482,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) {
@@ -534,13 +916,259 @@ export class FlowEngine {
         for (const h of this.handlers)
             h(e);
     }
-    emitTask(t) { this.emitOp(OP_EVENT.task, { taskId: t.id, orderId: t.orderId, kind: t.kind, status: t.status, fromNode: t.fromNode, toNode: t.toNode, itemRefs: [t.itemEpc], resourceRef: t.resource ?? undefined }); }
-    emitMover(m, motion) { this.emitOp(OP_EVENT.equipment, { moverId: m.id, kind: m.kind, status: m.status, location: m.location, motion }); }
+    /**
+     * 작업 전이 방출 — **커널이 아는 것을 미러도 알게** 한다.
+     *
+     * 예전에는 진척·남은 시간·의도를 싣지 않아, 미러 상태를 씨앗으로 한 예측이 "진행 중인 일이 없는
+     * 현장" 에서 출발했고, 소비처는 무자원 체류를 기록 누락으로 오해할 수밖에 없었다.
+     * 진척은 진행 중일 때만 뜻이 있으므로 그때만 싣는다(생성·완료 시점의 0/1 은 노이즈).
+     */
+    emitTask(t) {
+        const inProgress = t.status === 'in-progress';
+        const done = Math.max(0, (t.durationMs ?? 0) - (t.remainingMs ?? 0));
+        this.emitOp(OP_EVENT.task, {
+            taskId: t.id, orderId: t.orderId, kind: t.kind, status: t.status,
+            fromNode: t.fromNode, toNode: t.toNode, itemRefs: [t.itemEpc], resourceRef: t.resource ?? undefined,
+            intent: t.intent,
+            ...(t.personnel?.length ? { personnel: t.personnel.slice() } : {}),
+            ...(t.assets?.length ? { assets: t.assets.slice() } : {}),
+            ...(t.durationMs ? { durationMs: t.durationMs } : {}),
+            ...(inProgress ? { remainingMs: t.remainingMs, startedAtSimMs: t.startedAtSimMs, progress: t.durationMs ? done / t.durationMs : undefined } : {})
+        });
+    }
+    /** 사람 상태 전이 — 설비와 별개 채널(어휘가 다르다: 고장이 아니라 교대·투입). */
+    emitAsset(a) {
+        this.emitOp(OP_EVENT.asset, { assetId: a.id, assetClass: a.assetClass, status: a.status, location: a.location, taskId: a.taskId ?? undefined, carrying: a.carrying });
+    }
+    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 } : {}) });
+    }
+    /** 설비 상태 전이 — `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 ─────────────────────────────────────────────────────────
+    /**
+     * 자극 간격 — **계약이 선언한 네 분포를 실제로 판정한다.**
+     *
+     * 예전에는 `poisson` 만 구현하고 나머지는 전부 상수로 떨어졌다. 계약이 `uniform`·`profile` 을
+     * 선언하고 있었으므로, 그것을 지정한 사람은 자기가 요청한 분포로 도는 줄 알았다 — **조용한 거짓**이다.
+     *
+     *  constant  간격이 일정(평균 그대로)
+     *  poisson   무기억 도착(지수 간격) — 평균 유지
+     *  uniform   0..2×평균 균등 — 평균을 유지하면서 흔들린다(교과서적 U(0,2μ))
+     *  profile   시간대별 배율(`profile[시]`)로 도착률을 조절 — 하루 안의 수요 곡선
+     */
     intervalMs(spec) {
-        const base = 3_600_000 / spec.rate.meanPerHour;
-        return spec.rate.distribution === 'poisson' ? -Math.log(1 - this.rng()) * base : base;
+        const perHour = spec.rate.meanPerHour * this.profileFactor(spec.rate);
+        if (!(perHour > 0))
+            return Number.POSITIVE_INFINITY; // 그 시간대엔 도착이 없다(0 을 1/0=∞ 로 정직하게)
+        const base = 3_600_000 / perHour;
+        switch (spec.rate.distribution) {
+            case 'poisson':
+                return -Math.log(1 - this.rng()) * base;
+            case 'uniform':
+                return this.rng() * 2 * base;
+            case 'profile':
+            case 'constant':
+            default:
+                return base;
+        }
+    }
+    /**
+     * 시간대 배율 — `profile[시]`. `profile` 분포일 때만 적용하며, 배열이 짧으면 **순환**한다
+     * (24개면 하루, 8개면 8시간 주기). 미지정·다른 분포면 1(무영향).
+     * 시(hour)는 **시뮬 시각 자신의 프레임**(BASE_EPOCH 기준 UTC)이다 — 계약에 표준시가 없으므로
+     * 현지 시간대 해석은 아직 하지 않는다(꾸미지 않는다).
+     */
+    /**
+     * 다음 발화 시각 — **발화가 없는 시간대를 영원한 침묵으로 만들지 않는다.**
+     *
+     * 배율 0(그 시간대 도착 없음)이면 간격이 무한이 된다. 그것을 그대로 예약하면 이후 어떤 시간대가
+     * 와도 깨어나지 않는다 — 그래서 **다음 정시로 미뤄 다시 판정**한다(시간대가 바뀌면 배율도 바뀐다).
+     * 시나리오 시작과 구동 루프가 같은 규칙을 쓰도록 한 곳에 둔다(예전에는 시작 경로만 따로였다).
+     */
+    nextFireMs(spec, from) {
+        const interval = this.intervalMs(spec);
+        if (Number.isFinite(interval))
+            return from + interval;
+        const hourMs = 3_600_000;
+        return Math.floor(from / hourMs) * hourMs + hourMs; // 다음 정시에 재판정
+    }
+    profileFactor(rate) {
+        if (rate.distribution !== 'profile')
+            return 1;
+        const p = rate.profile;
+        if (!p?.length)
+            return 1;
+        const f = p[this.hourOfDay() % p.length];
+        return Number.isFinite(f) && f >= 0 ? f : 1;
+    }
+    /**
+     * 필요 물리 자산을 확보한다 — 인원과 **같은 규칙**(등급으로 요구, 부분 투입 없음, 확정은 나중).
+     * 자산은 사람과 달리 교대가 없고 **자리**가 있다(빈 팔레트가 어디 있는지가 다음 문제이지만,
+     * 지금은 자리를 따지지 않는다 — 따지려면 자산 이송 작업이 먼저 있어야 한다).
+     */
+    claimAssets(t) {
+        const need = this.operationSpecs.get(t.kind)?.physicalAssetSpecification;
+        if (!need?.length)
+            return [];
+        const picked = [];
+        for (const req of need) {
+            const want = Math.max(0, Math.floor(req.quantity ?? 0));
+            if (!want)
+                continue;
+            const avail = [...this.assets.values()].filter(a => a.status === 'idle' && !picked.includes(a.id) && (req.assetClass === undefined || a.assetClass === req.assetClass));
+            if (avail.length < want)
+                return null;
+            for (let i = 0; i < want; i++)
+                picked.push(avail[i].id);
+        }
+        return picked;
+    }
+    /** 확보한 자산을 작업에 묶는다 — 싣는 물류단위(SSCC)가 있으면 연결한다(GRAI ↔ SSCC). */
+    assignAssets(t, gear) {
+        if (!gear.length)
+            return;
+        t.assets = gear;
+        for (const id of gear) {
+            const a = this.assets.get(id);
+            if (!a)
+                continue;
+            a.status = 'in-use';
+            a.taskId = t.id;
+            if (t.itemEpc) {
+                a.carrying = t.itemEpc;
+                /* 반대 방향도 맺는다 — 계약이 두 축을 다 정의했으므로 한쪽만 채우면 소비처가 물품에서
+                 * 자산을 못 찾는다(자산 목록을 뒤져야 한다). */
+                const it = this.items.get(t.itemEpc);
+                if (it)
+                    it.carriedBy = a.id;
+            }
+            this.emitAsset(a);
+        }
+    }
+    /**
+     * 작업이 끝나면 자산을 놓아 준다 — **사람과 다른 점: 자산은 도착 자리에 남는다**(물건이므로).
+     * 싣고 있던 것은 놓는다(빈 팔레트로 돌아간다 — 회수·재사용의 출발점).
+     */
+    releaseAssets(t) {
+        for (const id of t.assets ?? []) {
+            const a = this.assets.get(id);
+            if (!a)
+                continue;
+            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);
+        }
+    }
+    /**
+     * 필요 인원을 확보한다 — **등급으로 요구하고 등급으로 고른다**(특정인 지목이 아니다).
+     * 요구가 없으면 빈 배열, 모자라면 `null`(작업은 기다린다 — **부분 투입으로 시작하지 않는다**).
+     * 여기서는 고르기만 하고 잡지 않는다: 설비까지 확보된 뒤 `assignCrew` 가 확정한다
+     * (반쯤 잡고 실패하면 사람이 아무 일도 못 하면서 묶인다).
+     */
+    claimPersonnel(t) {
+        const need = this.operationSpecs.get(t.kind)?.personnelSpecification;
+        if (!need?.length)
+            return [];
+        const picked = [];
+        for (const req of need) {
+            const want = Math.max(0, Math.floor(req.quantity ?? 0));
+            if (!want)
+                continue;
+            const avail = [...this.persons.values()].filter(p => p.status === 'idle' &&
+                !picked.includes(p.id) &&
+                !this.personOffShift(p) &&
+                (req.personnelClass === undefined || p.personnelClass === req.personnelClass));
+            if (avail.length < want)
+                return null; // 한 등급이라도 모자라면 시작하지 않는다
+            for (let i = 0; i < want; i++)
+                picked.push(avail[i].id);
+        }
+        return picked;
+    }
+    /** 확보한 사람을 작업에 묶는다(설비까지 확정된 뒤). */
+    assignCrew(t, crew) {
+        if (!crew.length)
+            return;
+        t.personnel = crew;
+        for (const id of crew) {
+            const p = this.persons.get(id);
+            if (!p)
+                continue;
+            p.status = 'busy';
+            p.taskId = t.id;
+            this.emitPerson(p);
+        }
+    }
+    /** 작업이 끝나면 사람을 놓아 준다 — 설비 해제와 별개 경로. */
+    releaseCrew(t) {
+        for (const id of t.personnel ?? []) {
+            const p = this.persons.get(id);
+            if (!p)
+                continue;
+            p.status = 'idle';
+            p.taskId = null;
+            this.emitPerson(p);
+        }
+    }
+    /** 사람의 교대 판정 — 자원(offShift)과 같은 규칙. */
+    personOffShift(p) {
+        const w = p.window;
+        if (!w)
+            return false;
+        const h = this.hourOfDay();
+        return !(w.startHour <= w.endHour ? h >= w.startHour && h < w.endHour : h >= w.startHour || h < w.endHour);
+    }
+    /**
+     * 이 자리가 동시 처리 한도에 찼는가 — `parallelism` 을 선언한 자리만 판정한다(미선언=제약 없음).
+     * 세는 대상은 **그 자리에서 진행 중인 작업**(`toNode` 기준, in-progress). 대기 중인 작업은 세지 않는다.
+     */
+    stationFull(nodeId) {
+        if (!nodeId)
+            return false;
+        const limit = this.nodes.get(nodeId)?.parallelism;
+        if (!(typeof limit === 'number' && limit > 0))
+            return false;
+        let running = 0;
+        for (const t of this.tasks.values())
+            if (t.status === 'in-progress' && t.toNode === nodeId)
+                running++;
+        return running >= limit;
+    }
+    /** 교대 밖인가 — 자원이 지금 일하지 않는 이유 중 고장·계획정지와 구별되는 세 번째. */
+    offShift(m) {
+        const w = m.window;
+        if (!w)
+            return false;
+        const h = this.hourOfDay();
+        return !(w.startHour <= w.endHour ? h >= w.startHour && h < w.endHour : h >= w.startHour || h < w.endHour);
+    }
+    /** 시뮬 시각의 시(0..23) — 운영시간·시간대 배율의 기준. */
+    hourOfDay() {
+        return new Date(BASE_EPOCH + this.clockMs).getUTCHours();
+    }
+    /**
+     * 운영시간 안인가 — `window {startHour, endHour}`. **선언만 되고 소비처가 없던 필드**를 판정한다.
+     * `startHour <= endHour` 면 같은 날 구간, 넘어가면 자정을 가로지르는 구간(야간 교대: 22→6).
+     * 미지정이면 언제나 참(24시간 가동).
+     */
+    inWindow(spec) {
+        const w = spec.window;
+        if (!w)
+            return true;
+        const h = this.hourOfDay();
+        return w.startHour <= w.endHour ? h >= w.startHour && h < w.endHour : h >= w.startHour || h < w.endHour;
     }
     /** 지수분포 표본(고장/수리 간격) — mean 을 평균으로 하는 무기억 프로세스. */
     sampleExp(meanMs) { return -Math.log(1 - this.rng()) * meanMs; }
@@ -578,10 +1206,51 @@ 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) {
             while (this.clockMs >= g.nextMs) {
+                const next = this.nextFireMs(g.spec, g.nextMs);
+                /* 배율 0(도착 없는 시간대) — 발화하지 않고 다음 정시에 다시 판정한다. */
+                if (this.intervalMs(g.spec) === Number.POSITIVE_INFINITY) {
+                    g.nextMs = next;
+                    continue;
+                }
+                /* 운영시간 밖이면 **자극을 만들지 않고 다음 슬롯으로 넘긴다** — 문을 닫은 시간에 트럭이 오지
+                 * 않는다. 예전에는 window 를 아무도 보지 않아 24시간 가동으로만 굴렀다. */
+                if (!this.inWindow(g.spec)) {
+                    g.nextMs = next;
+                    continue;
+                }
                 // 자극 클래스(공급/수요)로 hook 분기 — 도메인 kind 라벨이 아니라 stimulus 로 라우팅(무방언).
                 // stimulus 미지정 시 레거시 kind 로 추론(하위호환). 도메인은 kind 를 자유 명명하고 stimulus 로 분류.
                 const stimulus = g.spec.stimulus ?? (g.spec.kind === 'outbound-order' ? 'order' : 'arrival');
@@ -589,7 +1258,7 @@ export class FlowEngine {
                     this.onOrder(g.spec);
                 else
                     this.onArrival(g.spec);
-                g.nextMs += this.intervalMs(g.spec);
+                g.nextMs = next;
             }
         }
     }
@@ -598,19 +1267,46 @@ 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;
-            if (t.intent === 'dwell') { // 무자원 체류 — 자원 배정 없이 즉시 진행
+            /* 필요 인원 — 오퍼레이션 명세가 요구하면 등급별로 사람을 잡는다. 모자라면 **기다린다**
+             * (설비가 놀아도 사람이 없으면 일이 안 된다 — 그 줄이 현장의 실제 병목인 경우가 많다). */
+            const crew = this.claimPersonnel(t);
+            if (crew === null)
+                continue; // 인원 부족 → 다음 작업(다른 등급은 가능할 수 있다)
+            /* 필요 물리 자산 — 빈 팔레트가 없으면 출고가 못 나간다. 인원과 같은 규칙(부분 투입 없음). */
+            const gear = this.claimAssets(t);
+            if (gear === null)
+                continue;
+            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);
                 continue;
             }
-            // resourceType 있으면 그 kind 무버만; 없으면 아무 유휴 무버.
-            const mover = [...this.movers.values()].find(m => m.status === 'idle' && !m.held && (t.resourceType === undefined || m.kind === t.resourceType));
+            /* 자리의 동시 처리 수를 넘지 않는다 — 자원이 남아도 스테이션이 한 대씩만 깎으면 줄을 선다.
+             * 이 제약이 없으면 대기가 생기지 않아 병목이 사라지고 예측이 낙관 쪽으로 치우친다. */
+            if (this.stationFull(t.toNode))
+                continue;
+            // resourceType 있으면 그 kind 무버만; 없으면 아무 유휴 무버. 교대 밖 자원은 배정하지 않는다.
+            const mover = [...this.movers.values()].find(m => m.status === 'idle' && !m.held && !this.offShift(m) && (t.resourceType === undefined || m.kind === t.resourceType));
             if (!mover)
                 continue; // 맞는 유휴 자원 없음 → 다음 task(break 아님: 다른 타입은 가용할 수 있음)
             // 체인지오버: task 의 changeoverKey 가 무버 직전 키와 다르면 셋업 부착(첫 작업은 셋업 없음).
@@ -625,6 +1321,9 @@ 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);
             // process: 제자리 변환(모션 없음). transport: 이동 모션 방출.
             if (t.intent === 'process')
@@ -632,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;
@@ -643,6 +1344,8 @@ export class FlowEngine {
                 continue;
             this.onTaskComplete(t);
             t.status = 'completed';
+            this.releaseCrew(t); // 사람은 설비와 별개로 해제한다(dwell 도 사람은 잡고 있었을 수 있다)
+            this.releaseAssets(t); // 자산도 같다 — 자산은 도착 자리에 남는다(사람과 달리 물건이므로)
             if (!t.resource) {
                 this.emitTask(t);
                 continue;