@operato/twin-kernel 0.7.49 → 0.7.51

package/dist/contract.js

@@ -1,6 +1,36 @@
 /*
  * Face 1 — 3채널 계약 (walking skeleton 범위).
  * 설계 SoT: operato-twin/design/integration/face1-contract.md
+ *
+ * ── 이 계약을 넓히려는 사람이 먼저 읽을 것 (2026-08-23) ──────────────────────
+ *
+ * 사실은 두 종류이고, 종류가 그 자리를 정한다.
+ *
+ *   **파생** — 시각만으로 넘어가는 판정. 근무 밖 · 교대 · 능력 · 자리 상태 · 납기 대비 · 진척.
+ *     · **저장하지 않는다.** 저장하면 장부가 둘이 되고, 시각이 지나도 옛 값이 남는다.
+ *     · **입력으로 받지 않는다.** 원본이 단정하면 답이 둘이 되고 커널이 어느 쪽을 믿을지 정해야 한다.
+ *     · 계산할 수 없으면 **답하지 않는다.** 모르는 값을 숫자로 만들면 화면이 그것을 사실로 그린다
+ *       (`dueStatusOf` 가 그 규율을 먼저 적었다: 납기가 없으면 「늦지 않았다」가 아니라 「판단할 수 없다」).
+ *     · 파생이 **불가능할 때만** 원본의 단정을 쓴다. 그 순서가 선언돼 있어야 한다(`offShift`·`progress`).
+ *
+ *   **누적** — 열린 구간에 쌓이는 값. 가동·준비·고장 시간 · 양품/불량 수 · 조건이 성립한 시각.
+ *     · **다시 계산할 수 없다.** 원천은 「이번 창에서 지금까지 얼마」를 모른다.
+ *     · 그래서 **재기동을 넘어 이어받는다.** 잃으면 오류 없이 값이 작아진다 — 가장 비싼 종류의 침묵이다.
+ *
+ * 그리고 **자리를 늘리는 조건은 하나다: 전이로 표현할 수 없는 사실.**
+ *
+ * 「자리가 없다」와 「담을 수 없다」는 다르다. 전자는 대개 이미 있는 축을 못 찾은 것이다 — 작업의
+ * 실제 착수·완료·대기는 **전이의 `eventTime`** 이 말하고(`task-fold`), 대기는 그것으로 계산된다
+ * (`kpi-fold`: `waitMs = startedMs − createdMs`). 원본이 전이를 놓쳐 보내면 **놓친 전이를 그 시각으로
+ * 함께 내는 것**이 답이고, 속성을 새로 여는 것이 아니다.
+ *
+ * 그러므로 원본을 붙이는 사람이 물어야 하는 것은 「이 컬럼을 실을 자리가 있나」가 아니라
+ * **「원본이 말하는 이 사실을 커널의 어휘로 어떻게 옮기나」**다. 컬럼 단위로 물으면 원본이 열이면
+ * 축도 열이 된다 — 2026-08-23 에 축 다섯을 열었다가 그 이유로 되돌렸다.
+ *
+ * 열지 않기로 한 것과 그 조건은 `design/04-decisions.md` ADR-0039 에 있다. 넓히기 전에 그 표를 본다.
+ * 지키는 하네스: `derived-not-input` · `actuals-come-from-transitions` · `accumulators-survive-restart` ·
+ * `purpose-conformance`.
  */
 /**
  * 자리의 상태 — **포화도에서 파생한다.** 저장하는 값이 아니다.

package/dist/flow-engine.d.ts

@@ -1,4 +1,4 @@
-import type { TestResult, ISOTime, MaterialQuantity, WorkCalendarEntry, EffectivePeriod, Effectivity, OffCalendarReason, ResourceProperty, ResourceClassDef, MaterialDefinition, Attention, TwinModelDef, CanonicalEnvelope, Command, CommandAck, EventHandler, EquipmentMotion, OeeMetrics, AssetState, GeneratorSpec, InterventionOutcome, OrderState, PersonState, ScenarioControl, ScenarioOverride, StateSnapshot, TwinKernel, Unsubscribe, LocationState, ItemState, EquipmentState, OrderStatusDelta, TaskState, StructureShift, IdentityGroundingView, IdentityDeclaration } from './contract.ts';
+import type { TestResult, ISOTime, MaterialQuantity, WorkCalendarEntry, EffectivePeriod, Effectivity, OffCalendarReason, ResourceProperty, ResourceClassDef, MaterialDefinition, Attention, TwinModelDef, CanonicalEnvelope, Command, CommandAck, EventHandler, EquipmentMotion, OeeMetrics, AssetState, GeneratorSpec, InterventionOutcome, OrderState, PersonState, ScenarioControl, ScenarioOverride, StateSnapshot, TwinKernel, Unsubscribe, LocationState, ItemState, EquipmentState, OrderStatusDelta, TaskState, TaskStatus, StructureShift, IdentityGroundingView, IdentityDeclaration } 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';
@@ -78,6 +78,15 @@ export interface FlowPerson extends EffectivePeriod {
     };
     /** 근무 캘린더 — 표준 `WorkCalendarEntry`(복수). 있으면 `window` 보다 이것을 본다. */
     workCalendar?: WorkCalendarEntry[];
+    /**
+     * **원본이 말한 근무 밖 표시** — 캘린더가 없을 때만 쓰는 값이다.
+     *
+     * 캘린더가 있으면 시각으로 판정한다(`offCalendar`) — 저장값을 함께 보면 교대 안으로 돌아왔을 때 옛
+     * `true` 가 남는다. 그런데 근무 캘린더를 주지 않는 원본이 실 시스템에 흔하고, 그때 이것이 **유일한
+     * 답**이다. 리듀서가 이미 그 규율로 이 값을 지키고 있었는데(§`observed-reducer` offShift) 커널 상태에
+     * 자리가 없어 옮기는 자리에서 잃고 있었다.
+     */
+    offShift?: boolean;
     /** 지금 어디에 있나 — 표준 `Person.OperationalLocation`. 커널은 사람을 움직이지 않는다(마스터·관측이 말한다). */
     location?: string;
     /** 자원 속성 — 표준 `PersonProperty`. */
@@ -130,7 +139,18 @@ export interface FlowEquipment extends EffectivePeriod {
 export interface FlowTask {
     id: string;
     kind: string;
-    status: 'created' | 'in-progress' | 'completed';
+    /**
+     * **작업 상태 — 어휘는 하나다**(`TaskStatus`: created · assigned · in-progress · completed).
+     *
+     * 예전에는 여기만 셋이었다(`assigned` 없음). 시뮬레이션은 배정과 착수를 한 번에 하므로 그것으로
+     * 충분했지만, **미러는 원본이 말한 것을 그대로 들고 있어야 한다** — 그리고 주의 계산은 이미
+     * `assigned` 를 기다리고 있었다(§`collectAttentions`: `status === 'created' || status === 'assigned'`).
+     * 즉 그 자리는 영원히 오지 않는 값을 기다렸다.
+     *
+     * 시뮬 경로의 거동은 바뀌지 않는다: 시뮬은 `assigned` 를 만들지 않고, 배정 루프는 `created` 만
+     * 집는다(§`assign`). 넓힌 것은 **관측이 말한 사실을 담을 자리**다.
+     */
+    status: TaskStatus;
     /**
      * **실제로 들어가고 나온 자재** — ISA-95 `JobResponse.MaterialActual`.
      *
@@ -154,6 +174,15 @@ export interface FlowTask {
     /** 예정 창 — 표준 `JobOrder.StartTime`/`EndTime`. 실제 착수와 다른 축. */
     startTime?: string;
     endTime?: string;
+    /**
+     * **원본이 말한 진척** — 커널이 계산할 수 없을 때만 쓰는 값이다(§`progressOf`).
+     *
+     * 파생이 가능하면(소요를 알면) 파생이 이긴다. 이 자리는 파생을 대신하는 것이 아니라 **파생이
+     * 불가능할 때 침묵하지 않기 위한 것**이다 — 사람 교대(`offShift`)가 세워 둔 규율과 같다.
+     *
+     * 관측에서만 채운다. 시뮬은 자기 소요를 알므로 이 값을 쓸 일이 없다.
+     */
+    progress?: number;
     /** 이 작업에 투입된 사람들 — 설비와 별개 축(설비 1대 + 작업자 2명이 동시에 잡힌다). */
     personnel?: string[];
     /** 이 작업에 투입된 물리 자산(팔레트 등). */
@@ -700,7 +729,26 @@ export declare abstract class FlowEngine implements TwinKernel {
             id: string;
             since: string;
         }[];
-    }, orders?: OrderStatusDelta[]): void;
+    }, orders?: OrderStatusDelta[], 
+    /**
+     * **무엇을 하러 심나** — 기본은 씨앗이다(외부 호출자 전부가 그것이다).
+     *
+     * ── 왜 이 구별이 생겼나 (2026-08-22 실측) ─────────────────────────────────
+     * 이 함수는 원래 **스냅샷으로 커널을 세우는 문**이다(웜스타트·fork·예측). 그 목적에서는 딛고 설
+     * 물품·오더가 없는 작업을 빼는 것이 옳다 — 굴릴 수 없는 작업을 심으면 첫 틱에서 없는 자리를
+     * 가리킨다.
+     *
+     * 그런데 `settleObserved()` 가 **미러 자신의 관측을 옮길 때도** 같은 함수를 쓴다. 목적이 다르다:
+     * 미러는 그 작업을 굴리지 않는다 — **들은 것을 말할 뿐이다.** 그런데 규칙이 하나였으므로 관측된
+     * 사실이 씨앗 규칙에 걸려 사라졌다.
+     *
+     * 실측: 포천 미러의 저널에 `task.status` 5,786건이 있고 투영기로 접으면 작업 2,881건인데
+     * `getSnapshot().tasks` 는 **0** 이었다. 화면은 「아직 하나도 없습니다」라고 말했고 사용자가
+     * 반나절을 찾았다. 재현하면 관측기 5건 → 커널 0건이고, 걸린 조건은 오더였다.
+     *
+     * 그래서 규칙을 둘로 쪼개지 않고 **목적을 밝힌다.** 같은 함수, 같은 주입 경로, 다른 판정 하나다.
+     */
+    purpose?: 'seed' | 'observe'): void;
     /**
      * what-if 구성 변주 — **선언을 덮어쓴다**(fork 대상). 바꿨으면 true.
      *
@@ -1529,7 +1577,25 @@ export declare abstract class FlowEngine implements TwinKernel {
      * 로트는 LGTIN 이면 식별자 안에 있고, 직렬 개체는 마스터데이터(`ilmd`)에 실려 온다.
      */
     protected itemState(i: FlowItem): ItemState;
-    protected progressOf(t: FlowTask): number;
+    /**
+     * 진척 — **모르면 답하지 않는다.**
+     *
+     * ── 무엇이 틀려 있었나 (2026-08-23 실측) ───────────────────────────────────
+     * 예전에는 `durationMs <= 0` 이면 `1` 을 돌려줬다. 시뮬에서는 그것이 맞다(소요 0 = 즉시 끝나는 일).
+     * 그런데 **미러에서 `durationMs` 0 은 「즉시」가 아니라 「모른다」다** — 원본이 소요를 말해 주지
+     * 않으면 씨앗 경로가 0 으로 메우고, 그러면 이 함수가 **진행 중인 작업을 100% 라고 말한다.**
+     *
+     * 실측: 소요를 주지 않는 원본의 진행 중 작업이 `progress: 1` 로 나왔다. 「모름」을 「완료」로 말하는
+     * 것이고, 화면은 그것을 사실로 그린다.
+     *
+     * 시뮬에서는 이 반환이 바뀌지 않는다: 소요 0 인 작업은 배정된 tick 안에서 끝나므로 **진행 중으로
+     * 관측되지 않는다**(`status = 'in-progress'; remainingMs = durationMs` → 다음 진행에서 즉시 완료).
+     * 즉 `durationMs <= 0` 이면서 진행 중인 작업은 미러 경로에서만 나온다.
+     *
+     * 모를 때 원본이 진척을 말해 주었다면 그 값을 쓴다 — 그 규칙은 부르는 쪽에 있다(§`getSnapshot`).
+     * 이 함수는 **커널이 계산할 수 있나**만 답한다.
+     */
+    protected progressOf(t: FlowTask): number | undefined;
     private generate;
     private processOrders;
     /**

package/dist/flow-engine.js

@@ -832,7 +832,26 @@ export class FlowEngine {
         this.seedDanglingRefs += dropped;
         return { kept, dropped };
     }
-    hydrateObserved(snap, orders = []) {
+    hydrateObserved(snap, orders = [], 
+    /**
+     * **무엇을 하러 심나** — 기본은 씨앗이다(외부 호출자 전부가 그것이다).
+     *
+     * ── 왜 이 구별이 생겼나 (2026-08-22 실측) ─────────────────────────────────
+     * 이 함수는 원래 **스냅샷으로 커널을 세우는 문**이다(웜스타트·fork·예측). 그 목적에서는 딛고 설
+     * 물품·오더가 없는 작업을 빼는 것이 옳다 — 굴릴 수 없는 작업을 심으면 첫 틱에서 없는 자리를
+     * 가리킨다.
+     *
+     * 그런데 `settleObserved()` 가 **미러 자신의 관측을 옮길 때도** 같은 함수를 쓴다. 목적이 다르다:
+     * 미러는 그 작업을 굴리지 않는다 — **들은 것을 말할 뿐이다.** 그런데 규칙이 하나였으므로 관측된
+     * 사실이 씨앗 규칙에 걸려 사라졌다.
+     *
+     * 실측: 포천 미러의 저널에 `task.status` 5,786건이 있고 투영기로 접으면 작업 2,881건인데
+     * `getSnapshot().tasks` 는 **0** 이었다. 화면은 「아직 하나도 없습니다」라고 말했고 사용자가
+     * 반나절을 찾았다. 재현하면 관측기 5건 → 커널 0건이고, 걸린 조건은 오더였다.
+     *
+     * 그래서 규칙을 둘로 쪼개지 않고 **목적을 밝힌다.** 같은 함수, 같은 주입 경로, 다른 판정 하나다.
+     */
+    purpose = 'seed') {
         /* 확인 처리를 먼저 이어받는다 — 아래에서 상태를 주입하면 곧바로 주목 신호가 계산되므로, 늦게
          * 이어받으면 그 한 번은 확인 안 된 것으로 계산된다(화면이 잠깐 빨개진다). */
         for (const id of snap.acked ?? [])
@@ -882,7 +901,15 @@ export class FlowEngine {
             const prev = this.equipment.get(m.id);
             this.equipment.set(m.id, {
                 ...(prev ?? {}),
-                id: m.id, kind: m.kind, location: m.location ?? '', ...(m.homeLocation ? { homeLocation: m.homeLocation } : {}), status: m.status ?? 'idle', taskId: null,
+                /*
+                 * `taskId` — **관측이면 원본이 말한 값이다.**
+                 *
+                 * 씨앗에서는 `null` 로 두고 작업 복원이 다시 세운다(작업이 함께 오지 않으면 그 자원이 영원히
+                 * 잡혀 있게 되므로). 그런데 관측에서는 `equipment.status` 가 이 값을 **직접 실어 온다** —
+                 * 상태(busy)는 그 축에서 받고 묶임은 작업에서 되세우면, 같은 사실의 두 조각이 서로 다른 축에서
+                 * 오게 되고 한쪽만 도착한 순간 어긋난다.
+                 */
+                id: m.id, kind: m.kind, location: m.location ?? '', ...(m.homeLocation ? { homeLocation: m.homeLocation } : {}), status: m.status ?? 'idle', taskId: purpose === 'observe' ? (m.taskId ?? null) : null,
                 runMs: oee?.runMs ?? 0, setupMs: oee?.setupMs ?? 0, downMs: oee?.downMs ?? 0,
                 goodCount: oee?.goodCount ?? 0, scrapCount: oee?.scrapCount ?? 0,
                 /*
@@ -915,7 +942,19 @@ export class FlowEngine {
             const prev = this.persons.get(p.id);
             this.persons.set(p.id, {
                 ...(prev ?? {}),
-                id: p.id, personnelClassIds: p.personnelClassIds ?? prev?.personnelClassIds, status: 'idle', taskId: null,
+                /* 설비와 같은 규율 — 관측이면 원본이 말한 상태·묶임을 지킨다(씨앗이면 작업 복원이 세운다). */
+                id: p.id, personnelClassIds: p.personnelClassIds ?? prev?.personnelClassIds,
+                status: purpose === 'observe' ? (p.status ?? 'idle') : 'idle',
+                taskId: purpose === 'observe' ? (p.taskId ?? null) : null,
+                /*
+                 * 원본이 말한 근무 밖 표시 — **관측일 때만, 그리고 선언이 없을 때만 쓰인다.**
+                 *
+                 * 이 규율의 원본 자리는 리듀서다(§`offShift`: 「선언이 없을 때만 받는다 — 선언이 있으면
+                 * `snapshot()` 이 시각으로 판정하고, 저장값을 함께 두면 교대 안으로 돌아왔을 때 옛 `true` 가
+                 * 남는다」). 그런데 이 자리가 그 값을 **떨어뜨리고 있었다** — 리듀서가 지킨 것을 여기서 잃었다.
+                 * 근무 캘린더가 없는 원본(실 시스템에 흔하다)에서는 그것이 유일한 답이다.
+                 */
+                ...(purpose === 'observe' && p.offShift ? { offShift: true } : {}),
                 ...(p.location ? { location: p.location } : {}),
                 ...(p.properties ? { properties: p.properties } : {}),
                 ...(p.testSpecificationIds ? { testSpecificationIds: p.testSpecificationIds } : {}),
@@ -929,7 +968,10 @@ export class FlowEngine {
             const prev = this.assets.get(a.id);
             this.assets.set(a.id, {
                 ...(prev ?? {}),
-                id: a.id, assetClassIds: a.assetClassIds ?? prev?.assetClassIds, location: a.location, status: 'idle', taskId: null, carrying: a.carrying,
+                /* 설비·사람과 같은 규율 — 관측이면 원본이 말한 상태·묶임을 지킨다. */
+                id: a.id, assetClassIds: a.assetClassIds ?? prev?.assetClassIds, location: a.location,
+                status: purpose === 'observe' ? (a.status ?? 'idle') : 'idle',
+                taskId: purpose === 'observe' ? (a.taskId ?? null) : null, carrying: a.carrying,
                 ...(a.properties ? { properties: a.properties } : {}),
                 ...(a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {}),
                 /* 결과도 이어받는다 — 잃으면 예측이 **자격 만료를 모르는 현장**에서 출발한다(낙관 쪽으로 치우친다). */
@@ -993,11 +1035,35 @@ export class FlowEngine {
             const remaining = lines.length
                 ? lines.reduce((s, l) => s + l.requested, 0)
                 : Math.max(0, (o.requested ?? 0) - (o.fulfilled ?? 0));
-            if (remaining <= 0)
-                continue; // 이미 이행 완료 → 예측 대상 아님
+            /*
+             * ── **씨앗은 남은 데맨드로, 미러는 들은 그대로** (2026-08-23) ──────────────
+             *
+             * 아래 세 값(`status`·`requested`·`fulfilled`)은 씨앗의 규약이다: 씨앗은 「무엇이 남았나」로
+             * 미래를 굴리므로 요청 10·이행 4 를 **요청 6·이행 0·상태 created** 로 다시 표현한다. 그리고 이미
+             * 이행된 오더는 예측 대상이 아니므로 건너뛴다.
+             *
+             * **미러에는 전부 틀렸다.** 미러는 굴리지 않고 들은 것을 말한다. 실측(포천 미러):
+             *
+             *   원본이 말한 것   picking · 요청 10 · 이행 4 · 진척 0.4
+             *   커널이 낸 것     created · 요청  6 · 이행 0 · 진척 0     ← 40% 된 오더가 0% 로 보였다
+             *
+             * 그리고 이행 완료된 오더는 **상태에서 아예 사라졌다** — 원본이 그 오더가 있다고 말하는데
+             * 트윈은 없다고 말한다. 오더의 상태 낱말은 계약이 도메인에 넘긴 것인데(`picking`·`shipped`…)
+             * 씨앗 규약이 그것을 커널 낱말로 덮고 있었다.
+             *
+             * 이것은 작업에서 고친 것과 **같은 결함의 세 번째 사례**다(§`purpose`): 한 함수가 두 목적을 겸하고
+             * 씨앗 규약이 관측에 새어 나온다.
+             */
+            const observing = purpose === 'observe';
+            if (!observing && remaining <= 0)
+                continue; // 씨앗: 이미 이행 완료 → 예측 대상 아님
             const resolved = this.resolvedAllocated(o.allocated);
             this.orders.set(o.orderId, {
-                id: o.orderId, kind: o.kind, status: 'created', requested: remaining, fulfilled: 0,
+                id: o.orderId,
+                kind: o.kind,
+                status: observing ? (o.status ?? 'created') : 'created',
+                requested: observing ? (o.requested ?? 0) : remaining,
+                fulfilled: observing ? (o.fulfilled ?? 0) : 0,
                 /* **확보해 둔 것과 거래번호를 이어받는다.** 비우면 되살아난 오더가 아무것도 안 잡은 것처럼
                    보이고, 그 오더의 진행 중 작업이 완료될 때 계보가 입력 없이 나간다. 상태가 말해 주지
                    않으면(옛 저널) 그때는 비는 것이 사실이다 — 없는 것을 지어내지 않는다. */
@@ -1006,7 +1072,9 @@ export class FlowEngine {
                 /* 레시피도 함께 — 품목만 이어받으면 되살아난 오더가 「무엇으로」를 모르고, 그 오더의
                    남은 공정·소요가 다른 레시피 기준으로 계산된다(같은 품목에 대체 레시피가 있다). */
                 ...(o.recipeKey ? { recipeKey: o.recipeKey } : {}),
-                bizTransaction: o.bizTransaction ?? '', allocated: resolved.kept, picked: [], shipmentEpc: null, lines,
+                bizTransaction: o.bizTransaction ?? '', allocated: resolved.kept, picked: [], shipmentEpc: null,
+                /* 라인도 같다 — 씨앗은 남은 양만 남기고, 미러는 원본이 말한 요청·이행을 그대로 든다. */
+                lines: observing ? (o.lines ?? []).map(l => ({ ...l })) : lines,
                 ...(resolved.dropped ? { seedIncomplete: true } : {}),
                 /* **보류를 이어받는다** — 잃으면 씨앗이 사람이 일부러 멈춘 오더를 다시 계획해 내보낸다.
                    씨앗 왕복 대조가 이것을 잡았다(그 전에는 사람이 코드를 읽어야만 알 수 있었다). */
@@ -1022,38 +1090,88 @@ export class FlowEngine {
         }
         /* 작업이 딛고 설 오더를 먼저 세운다 — 순서가 뒤바뀌면 아래 확인이 언제나 "없다" 로 답한다. */
         const seededOrderIds = new Set(this.orders.keys());
-        let orphaned = 0;
+        /*
+         * **떨어뜨린 이유를 따로 센다** — 예전에는 하나로 세고 「whose item is no longer in state」라고
+         * 말했다. 그런데 오더에 걸린 경우도 같은 문장을 썼고, 그것을 본 사람이 물품 쪽을 반나절 뒤졌다.
+         * 원인을 지어내는 문장은 없는 것보다 나쁘다.
+         */
+        let droppedNoItem = 0;
+        let droppedNoOrder = 0;
+        let droppedCompleted = 0;
+        /*
+         * **씨앗이냐 관측 정착이냐** — 아래 셋을 거를지 말지가 여기서 갈린다(§`purpose`).
+         *
+         *   씨앗(seed)      굴릴 수 없는 작업은 뺀다. 심으면 첫 틱에서 없는 자리를 가리킨다.
+         *   관측(observe)   **거르지 않는다.** 미러는 그 작업을 굴리지 않고, 들은 것을 말한다.
+         */
+        const filtering = purpose === 'seed';
         for (const t of snap.tasks ?? []) {
-            if (t.status === 'completed')
+            if (filtering && t.status === 'completed') {
+                droppedCompleted++;
                 continue;
+            }
             const ref = t.itemRefs?.[0];
-            if (ref && !this.itemByRef(ref)) {
-                orphaned++;
+            if (filtering && ref && !this.itemByRef(ref)) {
+                droppedNoItem++;
                 continue;
             }
             /* 오더도 같다 — 이미 이행된 오더는 주입하지 않으므로(위 `remaining <= 0`), 그 오더에 딸린 작업만
                남으면 완료 시점에 없는 오더를 딛는다. 주입 단계에서 함께 뺀다. */
-            if (t.orderId && !seededOrderIds.has(t.orderId)) {
-                orphaned++;
+            if (filtering && t.orderId && !seededOrderIds.has(t.orderId)) {
+                droppedNoOrder++;
                 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',
+                /*
+                 * **관측이면 들은 상태를 그대로 둔다.** 씨앗이면 굴릴 수 있는 모양으로 맞춘다(남은 시간을
+                 * 모르는 작업을 `in-progress` 로 심으면 끝나지 않는다).
+                 *
+                 * 예전에는 관측 경로에서도 이 줄이 상태를 다시 썼다 — 원본이 `completed` 라고 말한 작업이
+                 * `created` 로, `assigned` 도 `created` 로 바뀌었다. 공정 타임라인·현장 성과·주의 목록이
+                 * 모두 이 축을 읽으므로, 여기서 뭉개면 그 셋이 함께 거짓이 된다.
+                 */
+                status: purpose === 'observe' ? t.status : known && t.status === 'in-progress' ? 'in-progress' : 'created',
                 /* 이미 일어난 자재 이동은 **씨앗에도 남는다** — 잃으면 실적이 재기동마다 지워진다. */
                 ...(t.materialActual?.length ? { materialActual: t.materialActual.map(r => ({ ...r })) } : {}),
                 itemEpc: t.itemRefs?.[0] ?? '',
                 fromNode: t.fromNode ?? '', toNode: t.toNode ?? '',
-                resource: known && t.status === 'in-progress' ? (t.resourceRef ?? null) : null,
+                /*
+                 * 자원 참조는 **작업 자신의 사실**이다. 씨앗에서는 굴릴 수 있는 작업만 자원을 잡게 하지만
+                 * (남은 시간을 모르면 배정 루프가 다시 잡아야 한다), 관측에서는 원본이 말한 참조를 지운 이유가
+                 * 없다 — 지우면 「어느 설비가 이 일을 하고 있나」가 화면에서 사라진다.
+                 */
+                resource: purpose === 'observe' ? (t.resourceRef ?? null) : 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
+                intent: t.intent,
+                /*
+                 * 원본이 말한 진척 — **관측일 때만, 그리고 커널이 계산할 수 없을 때 쓰인다**(§`progressOf`).
+                 * 씨앗 경로에서는 싣지 않는다: 씨앗은 굴러가면서 자기 소요로 진척을 만든다.
+                 */
+                ...(purpose === 'observe' && typeof t.progress === 'number' ? { progress: t.progress } : {})
             });
-            /* 진행 중으로 살린 작업은 그 자원을 점유한 상태여야 한다(자원이 동시에 다른 일을 받지 않게). */
-            if (known && t.status === 'in-progress' && t.resourceRef) {
+            /*
+             * 투입 인원은 **작업이 들고 있는 사실**이므로 관측에서도 그대로 옮긴다(위 `set` 에서 빠져 있어
+             * 아래에서 채운다 — 씨앗 시절 진행 중인 작업에만 필요했던 자리다).
+             */
+            if (purpose === 'observe' && t.personnel?.length) {
+                const restored = this.tasks.get(t.id);
+                if (restored)
+                    restored.personnel = [...t.personnel];
+            }
+            /*
+             * **자원의 상태는 여기서 정하지 않는다 — 관측일 때는.**
+             *
+             * 씨앗에서는 필요하다: 진행 중인 작업을 심었으면 그 설비가 다른 일을 또 받으면 안 되므로 점유를
+             * 표시한다. 그런데 미러에서는 설비·사람의 상태가 **자기 관측 축**(`equipment.status`,
+             * `person.status`)에서 온다. 작업 하나로 그것을 덮으면 원본이 「유휴」라고 말한 설비를 트윈이
+             * 「바쁘다」고 말한다 — 축이 둘이 되고, 어느 쪽이 사실인지 알 수 없게 된다.
+             */
+            if (purpose === 'seed' && known && t.status === 'in-progress' && t.resourceRef) {
                 const mv = this.equipment.get(t.resourceRef);
                 if (mv) {
                     mv.status = 'busy';
@@ -1061,7 +1179,7 @@ export class FlowEngine {
                 }
             }
             /* 사람도 같다 — 진행 중이던 작업에 투입돼 있던 사람은 여전히 점유되어 있어야 한다. */
-            if (known && t.status === 'in-progress') {
+            if (purpose === 'seed' && known && t.status === 'in-progress') {
                 const restored = this.tasks.get(t.id);
                 if (restored)
                     restored.personnel = t.personnel ? [...t.personnel] : undefined;
@@ -1074,9 +1192,21 @@ export class FlowEngine {
                 }
             }
         }
-        if (orphaned) {
-            console.warn(`[twin-kernel] seed skipped ${orphaned} in-flight task(s) whose item is no longer in state — ` +
-                'they cannot be continued (the item was consumed/shipped, or the observation did not carry it).');
+        /*
+         * **무엇을 왜 뺐는지 그대로 말한다.** 씨앗에서만 나온다(관측은 빼지 않는다).
+         *
+         * 예전 문장은 셋을 하나로 뭉쳐 「whose item is no longer in state」라고 했다. 오더에 걸린 것을
+         * 물품 탓으로 말했고, 그 문장을 읽은 사람이 물품 쪽을 뒤졌다. 원인을 지어내는 문장은 침묵보다 나쁘다.
+         */
+        const droppedTotal = droppedNoItem + droppedNoOrder + droppedCompleted;
+        if (droppedTotal) {
+            const why = [
+                droppedNoItem ? `${droppedNoItem} whose item is not in state` : '',
+                droppedNoOrder ? `${droppedNoOrder} whose order is not in state` : '',
+                droppedCompleted ? `${droppedCompleted} already completed` : ''
+            ].filter(Boolean).join(' · ');
+            console.warn(`[twin-kernel] seed skipped ${droppedTotal} task(s) — ${why}. ` +
+                'They cannot be continued by a simulation. (A mirror keeps them: hydrateObserved(…, …, "observe").)');
         }
     }
     /**
@@ -1335,8 +1465,13 @@ export class FlowEngine {
             equipment: [...this.equipment.values()].map(m => {
                 const s = { id: m.id, kind: m.kind, location: m.location, ...(m.homeLocation ? { homeLocation: m.homeLocation } : {}), status: m.status, taskId: m.taskId ?? undefined, oee: this.oeeOf(m), held: m.held, ...(m.properties ? { properties: m.properties } : {}), ...(m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}), ...(m.testResults ? { testResults: m.testResults } : {}), capability: this.capabilityOfResource(m, m.kind ? [m.kind] : [], this.classDefs.equipment), origin: 'master', ...(this.offShift(m) ? { offShift: true, ...this.offReason(m) } : {}), ...this.effectivePart(m), ...(this.shiftOf(m) ? { shift: this.shiftOf(m) } : {}), ...energyFieldsOf(m) };
                 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 };
+                /*
+                 * 이동 구간은 **소요를 알 때만** 낸다. 모르면 아래 산수가 전부 0 이나 음수가 되고, 화면은 「제자리에서
+                 * 다 끝난 이동」을 그린다 — 원본이 소요를 주지 않는 미러에서 실제로 그랬다(§`progressOf`).
+                 */
+                const motionProgress = t && t.status === 'in-progress' && t.intent !== 'process' ? this.progressOf(t) : undefined;
+                if (t && motionProgress !== undefined)
+                    s.motion = { fromNode: t.fromNode, toNode: t.toNode, startedAtSimMs: this.clockMs - (t.durationMs - t.remainingMs), durationMs: t.durationMs, progress: motionProgress, elapsedMs: t.durationMs - t.remainingMs };
                 return s;
             }),
             assets: [...this.assets.values()].map(a => {
@@ -1365,10 +1500,17 @@ export class FlowEngine {
                    물을 수 없다(사실은 자기 집에서 나온다). 판정은 아래 `capability` 가 이미 답한다. */
                 if (p.testResults)
                     st.testResults = p.testResults;
+                /*
+                 * 근무 밖 판정 — **선언이 있으면 선언이 이기고, 없을 때만 원본이 말한 값을 쓴다.**
+                 * 진척(`progressOf`)과 같은 순서다. 선언이 있는데 저장값을 함께 보면 교대 안으로 돌아왔을 때
+                 * 옛 `true` 가 남는다(리듀서가 그 이유를 적어 두었다).
+                 */
                 if (this.personOffShift(p)) {
                     st.offShift = true;
                     Object.assign(st, this.offReason(p));
                 }
+                else if (p.offShift && !p.workCalendar?.length)
+                    st.offShift = true;
                 const sh = this.shiftOf(p);
                 if (sh)
                     st.shift = sh;
@@ -1389,7 +1531,26 @@ export class FlowEngine {
                 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) } : {}),
+                /*
+                 * 진척은 **커널이 계산한 값이 먼저, 못 하면 원본이 말한 값**이다(§`progressOf`).
+                 *
+                 * 이 순서는 사람 교대(`offShift`)가 세워 둔 규율과 같다: 파생이 가능하면 파생이 이기고, 파생이
+                 * 불가능할 때만 원본의 단정을 쓴다. 둘 다 없으면 **싣지 않는다** — 「모른다」를 숫자로 만들지 않는다.
+                 *
+                 * 예전에는 원본이 진척을 말해도 조용히 버렸다(문이 받아 놓고 파생이 덮었다). 넣었는데 사라지는
+                 * 것이 이 시스템에서 가장 비싼 침묵이다.
+                 */
+                ...(t.status === 'in-progress'
+                    ? {
+                        remainingMs: t.remainingMs,
+                        startedAtSimMs: t.startedAtSimMs,
+                        ...(() => {
+                            const derived = this.progressOf(t);
+                            const p = derived ?? t.progress;
+                            return p === undefined ? {} : { progress: p };
+                        })()
+                    }
+                    : {}),
                 ...(t.personnel?.length ? { personnel: t.personnel.slice() } : {}),
                 ...(t.assets?.length ? { assets: t.assets.slice() } : {}),
                 ...(t.resources?.length ? { resources: t.resources.slice() } : {}),
@@ -1723,7 +1884,14 @@ export class FlowEngine {
         if (!this.observedDirty || !this.observer)
             return;
         this.observedDirty = false;
-        this.hydrateObserved(this.observer.snapshot());
+        /*
+         * **목적을 밝힌다 — 이것은 씨앗이 아니라 관측 정착이다**(§`hydrateObserved` 의 `purpose`).
+         *
+         * 이 한 낱말이 없던 동안 미러의 작업이 씨앗 규칙에 걸려 사라졌다: 포천 미러의 저널에
+         * `task.status` 5,786건이 있는데 `getSnapshot().tasks` 는 0 이었고, 화면은 「아직 하나도
+         * 없습니다」라고 말했다. 미러는 그 작업을 굴리지 않는다 — 들은 것을 말할 뿐이다.
+         */
+        this.hydrateObserved(this.observer.snapshot(), [], 'observe');
     }
     /** 구독자 목록 — 관측 재방출용(private handlers 에 접근). */
     observedHandlers() {
@@ -3321,7 +3489,29 @@ export class FlowEngine {
             ...(i.ilmd ? { ilmd: i.ilmd } : {})
         };
     }
-    progressOf(t) { return t.durationMs <= 0 ? 1 : Math.min(1, Math.max(0, (t.durationMs - t.remainingMs) / t.durationMs)); }
+    /**
+     * 진척 — **모르면 답하지 않는다.**
+     *
+     * ── 무엇이 틀려 있었나 (2026-08-23 실측) ───────────────────────────────────
+     * 예전에는 `durationMs <= 0` 이면 `1` 을 돌려줬다. 시뮬에서는 그것이 맞다(소요 0 = 즉시 끝나는 일).
+     * 그런데 **미러에서 `durationMs` 0 은 「즉시」가 아니라 「모른다」다** — 원본이 소요를 말해 주지
+     * 않으면 씨앗 경로가 0 으로 메우고, 그러면 이 함수가 **진행 중인 작업을 100% 라고 말한다.**
+     *
+     * 실측: 소요를 주지 않는 원본의 진행 중 작업이 `progress: 1` 로 나왔다. 「모름」을 「완료」로 말하는
+     * 것이고, 화면은 그것을 사실로 그린다.
+     *
+     * 시뮬에서는 이 반환이 바뀌지 않는다: 소요 0 인 작업은 배정된 tick 안에서 끝나므로 **진행 중으로
+     * 관측되지 않는다**(`status = 'in-progress'; remainingMs = durationMs` → 다음 진행에서 즉시 완료).
+     * 즉 `durationMs <= 0` 이면서 진행 중인 작업은 미러 경로에서만 나온다.
+     *
+     * 모를 때 원본이 진척을 말해 주었다면 그 값을 쓴다 — 그 규칙은 부르는 쪽에 있다(§`getSnapshot`).
+     * 이 함수는 **커널이 계산할 수 있나**만 답한다.
+     */
+    progressOf(t) {
+        if (!(t.durationMs > 0))
+            return undefined;
+        return Math.min(1, Math.max(0, (t.durationMs - t.remainingMs) / t.durationMs));
+    }
     generate() {
         for (const g of this.gens) {
             while (this.clockMs >= g.nextMs) {

package/dist-cjs/index.cjs

@@ -3964,7 +3964,7 @@ var FlowEngine = class {
     this.seedDanglingRefs += dropped;
     return { kept, dropped };
   }
-  hydrateObserved(snap, orders = []) {
+  hydrateObserved(snap, orders = [], purpose = "seed") {
     for (const id of snap.acked ?? []) this._acked.add(id);
     for (const e of snap.attentionSince ?? []) if (e?.id && e.since) this._attentionSince.set(e.id, e.since);
     for (const n of snap.locations) {
@@ -3994,12 +3994,20 @@ var FlowEngine = class {
       const prev = this.equipment.get(m.id);
       this.equipment.set(m.id, {
         ...prev ?? {},
+        /*
+         * `taskId` — **관측이면 원본이 말한 값이다.**
+         *
+         * 씨앗에서는 `null` 로 두고 작업 복원이 다시 세운다(작업이 함께 오지 않으면 그 자원이 영원히
+         * 잡혀 있게 되므로). 그런데 관측에서는 `equipment.status` 가 이 값을 **직접 실어 온다** —
+         * 상태(busy)는 그 축에서 받고 묶임은 작업에서 되세우면, 같은 사실의 두 조각이 서로 다른 축에서
+         * 오게 되고 한쪽만 도착한 순간 어긋난다.
+         */
         id: m.id,
         kind: m.kind,
         location: m.location ?? "",
         ...m.homeLocation ? { homeLocation: m.homeLocation } : {},
         status: m.status ?? "idle",
-        taskId: null,
+        taskId: purpose === "observe" ? m.taskId ?? null : null,
         runMs: oee?.runMs ?? 0,
         setupMs: oee?.setupMs ?? 0,
         downMs: oee?.downMs ?? 0,
@@ -4030,10 +4038,20 @@ var FlowEngine = class {
       const prev = this.persons.get(p.id);
       this.persons.set(p.id, {
         ...prev ?? {},
+        /* 설비와 같은 규율 — 관측이면 원본이 말한 상태·묶임을 지킨다(씨앗이면 작업 복원이 세운다). */
         id: p.id,
         personnelClassIds: p.personnelClassIds ?? prev?.personnelClassIds,
-        status: "idle",
-        taskId: null,
+        status: purpose === "observe" ? p.status ?? "idle" : "idle",
+        taskId: purpose === "observe" ? p.taskId ?? null : null,
+        /*
+         * 원본이 말한 근무 밖 표시 — **관측일 때만, 그리고 선언이 없을 때만 쓰인다.**
+         *
+         * 이 규율의 원본 자리는 리듀서다(§`offShift`: 「선언이 없을 때만 받는다 — 선언이 있으면
+         * `snapshot()` 이 시각으로 판정하고, 저장값을 함께 두면 교대 안으로 돌아왔을 때 옛 `true` 가
+         * 남는다」). 그런데 이 자리가 그 값을 **떨어뜨리고 있었다** — 리듀서가 지킨 것을 여기서 잃었다.
+         * 근무 캘린더가 없는 원본(실 시스템에 흔하다)에서는 그것이 유일한 답이다.
+         */
+        ...purpose === "observe" && p.offShift ? { offShift: true } : {},
         ...p.location ? { location: p.location } : {},
         ...p.properties ? { properties: p.properties } : {},
         ...p.testSpecificationIds ? { testSpecificationIds: p.testSpecificationIds } : {},
@@ -4046,11 +4064,12 @@ var FlowEngine = class {
       const prev = this.assets.get(a.id);
       this.assets.set(a.id, {
         ...prev ?? {},
+        /* 설비·사람과 같은 규율 — 관측이면 원본이 말한 상태·묶임을 지킨다. */
         id: a.id,
         assetClassIds: a.assetClassIds ?? prev?.assetClassIds,
         location: a.location,
-        status: "idle",
-        taskId: null,
+        status: purpose === "observe" ? a.status ?? "idle" : "idle",
+        taskId: purpose === "observe" ? a.taskId ?? null : null,
         carrying: a.carrying,
         ...a.properties ? { properties: a.properties } : {},
         ...a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {},
@@ -4084,14 +4103,15 @@ var FlowEngine = class {
     for (const o of observedOrders) {
       const lines = (o.lines ?? []).map((l) => ({ gtin: l.gtin, requested: l.requested - (l.fulfilled ?? 0) })).filter((l) => l.requested > 0);
       const remaining = lines.length ? lines.reduce((s, l) => s + l.requested, 0) : Math.max(0, (o.requested ?? 0) - (o.fulfilled ?? 0));
-      if (remaining <= 0) continue;
+      const observing = purpose === "observe";
+      if (!observing && remaining <= 0) continue;
       const resolved = this.resolvedAllocated(o.allocated);
       this.orders.set(o.orderId, {
         id: o.orderId,
         kind: o.kind,
-        status: "created",
-        requested: remaining,
-        fulfilled: 0,
+        status: observing ? o.status ?? "created" : "created",
+        requested: observing ? o.requested ?? 0 : remaining,
+        fulfilled: observing ? o.fulfilled ?? 0 : 0,
         /* **확보해 둔 것과 거래번호를 이어받는다.** 비우면 되살아난 오더가 아무것도 안 잡은 것처럼
            보이고, 그 오더의 진행 중 작업이 완료될 때 계보가 입력 없이 나간다. 상태가 말해 주지
            않으면(옛 저널) 그때는 비는 것이 사실이다 — 없는 것을 지어내지 않는다. */
@@ -4104,7 +4124,8 @@ var FlowEngine = class {
         allocated: resolved.kept,
         picked: [],
         shipmentEpc: null,
-        lines,
+        /* 라인도 같다 — 씨앗은 남은 양만 남기고, 미러는 원본이 말한 요청·이행을 그대로 든다. */
+        lines: observing ? (o.lines ?? []).map((l) => ({ ...l })) : lines,
         ...resolved.dropped ? { seedIncomplete: true } : {},
         /* **보류를 이어받는다** — 잃으면 씨앗이 사람이 일부러 멈춘 오더를 다시 계획해 내보낸다.
            씨앗 왕복 대조가 이것을 잡았다(그 전에는 사람이 코드를 읽어야만 알 수 있었다). */
@@ -4119,43 +4140,71 @@ var FlowEngine = class {
       });
     }
     const seededOrderIds = new Set(this.orders.keys());
-    let orphaned = 0;
+    let droppedNoItem = 0;
+    let droppedNoOrder = 0;
+    let droppedCompleted = 0;
+    const filtering = purpose === "seed";
     for (const t of snap.tasks ?? []) {
-      if (t.status === "completed") continue;
+      if (filtering && t.status === "completed") {
+        droppedCompleted++;
+        continue;
+      }
       const ref = t.itemRefs?.[0];
-      if (ref && !this.itemByRef(ref)) {
-        orphaned++;
+      if (filtering && ref && !this.itemByRef(ref)) {
+        droppedNoItem++;
         continue;
       }
-      if (t.orderId && !seededOrderIds.has(t.orderId)) {
-        orphaned++;
+      if (filtering && t.orderId && !seededOrderIds.has(t.orderId)) {
+        droppedNoOrder++;
         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",
+        /*
+         * **관측이면 들은 상태를 그대로 둔다.** 씨앗이면 굴릴 수 있는 모양으로 맞춘다(남은 시간을
+         * 모르는 작업을 `in-progress` 로 심으면 끝나지 않는다).
+         *
+         * 예전에는 관측 경로에서도 이 줄이 상태를 다시 썼다 — 원본이 `completed` 라고 말한 작업이
+         * `created` 로, `assigned` 도 `created` 로 바뀌었다. 공정 타임라인·현장 성과·주의 목록이
+         * 모두 이 축을 읽으므로, 여기서 뭉개면 그 셋이 함께 거짓이 된다.
+         */
+        status: purpose === "observe" ? t.status : known && t.status === "in-progress" ? "in-progress" : "created",
         /* 이미 일어난 자재 이동은 **씨앗에도 남는다** — 잃으면 실적이 재기동마다 지워진다. */
         ...t.materialActual?.length ? { materialActual: t.materialActual.map((r) => ({ ...r })) } : {},
         itemEpc: t.itemRefs?.[0] ?? "",
         fromNode: t.fromNode ?? "",
         toNode: t.toNode ?? "",
-        resource: known && t.status === "in-progress" ? t.resourceRef ?? null : null,
+        /*
+         * 자원 참조는 **작업 자신의 사실**이다. 씨앗에서는 굴릴 수 있는 작업만 자원을 잡게 하지만
+         * (남은 시간을 모르면 배정 루프가 다시 잡아야 한다), 관측에서는 원본이 말한 참조를 지운 이유가
+         * 없다 — 지우면 「어느 설비가 이 일을 하고 있나」가 화면에서 사라진다.
+         */
+        resource: purpose === "observe" ? t.resourceRef ?? null : 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
+        intent: t.intent,
+        /*
+         * 원본이 말한 진척 — **관측일 때만, 그리고 커널이 계산할 수 없을 때 쓰인다**(§`progressOf`).
+         * 씨앗 경로에서는 싣지 않는다: 씨앗은 굴러가면서 자기 소요로 진척을 만든다.
+         */
+        ...purpose === "observe" && typeof t.progress === "number" ? { progress: t.progress } : {}
       });
-      if (known && t.status === "in-progress" && t.resourceRef) {
+      if (purpose === "observe" && t.personnel?.length) {
+        const restored = this.tasks.get(t.id);
+        if (restored) restored.personnel = [...t.personnel];
+      }
+      if (purpose === "seed" && known && t.status === "in-progress" && t.resourceRef) {
         const mv = this.equipment.get(t.resourceRef);
         if (mv) {
           mv.status = "busy";
           mv.taskId = t.id;
         }
       }
-      if (known && t.status === "in-progress") {
+      if (purpose === "seed" && known && t.status === "in-progress") {
         const restored = this.tasks.get(t.id);
         if (restored) restored.personnel = t.personnel ? [...t.personnel] : void 0;
         for (const id of t.personnel ?? []) {
@@ -4167,9 +4216,15 @@ var FlowEngine = class {
         }
       }
     }
-    if (orphaned) {
+    const droppedTotal = droppedNoItem + droppedNoOrder + droppedCompleted;
+    if (droppedTotal) {
+      const why = [
+        droppedNoItem ? `${droppedNoItem} whose item is not in state` : "",
+        droppedNoOrder ? `${droppedNoOrder} whose order is not in state` : "",
+        droppedCompleted ? `${droppedCompleted} already completed` : ""
+      ].filter(Boolean).join(" \xB7 ");
       console.warn(
-        `[twin-kernel] seed skipped ${orphaned} in-flight task(s) whose item is no longer in state \u2014 they cannot be continued (the item was consumed/shipped, or the observation did not carry it).`
+        `[twin-kernel] seed skipped ${droppedTotal} task(s) \u2014 ${why}. They cannot be continued by a simulation. (A mirror keeps them: hydrateObserved(\u2026, \u2026, "observe").)`
       );
     }
   }
@@ -4397,7 +4452,8 @@ var FlowEngine = class {
       equipment: [...this.equipment.values()].map((m) => {
         const s = { id: m.id, kind: m.kind, location: m.location, ...m.homeLocation ? { homeLocation: m.homeLocation } : {}, status: m.status, taskId: m.taskId ?? void 0, oee: this.oeeOf(m), held: m.held, ...m.properties ? { properties: m.properties } : {}, ...m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}, ...m.testResults ? { testResults: m.testResults } : {}, capability: this.capabilityOfResource(m, m.kind ? [m.kind] : [], this.classDefs.equipment), origin: "master", ...this.offShift(m) ? { offShift: true, ...this.offReason(m) } : {}, ...this.effectivePart(m), ...this.shiftOf(m) ? { shift: this.shiftOf(m) } : {}, ...energyFieldsOf(m) };
         const t = m.taskId ? this.tasks.get(m.taskId) : void 0;
-        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 };
+        const motionProgress = t && t.status === "in-progress" && t.intent !== "process" ? this.progressOf(t) : void 0;
+        if (t && motionProgress !== void 0) s.motion = { fromNode: t.fromNode, toNode: t.toNode, startedAtSimMs: this.clockMs - (t.durationMs - t.remainingMs), durationMs: t.durationMs, progress: motionProgress, elapsedMs: t.durationMs - t.remainingMs };
         return s;
       }),
       assets: [...this.assets.values()].map((a) => {
@@ -4419,7 +4475,7 @@ var FlowEngine = class {
         if (this.personOffShift(p)) {
           st.offShift = true;
           Object.assign(st, this.offReason(p));
-        }
+        } else if (p.offShift && !p.workCalendar?.length) st.offShift = true;
         const sh = this.shiftOf(p);
         if (sh) st.shift = sh;
         Object.assign(st, this.effectivePart(p));
@@ -4445,7 +4501,24 @@ var FlowEngine = class {
         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) } : {},
+        /*
+         * 진척은 **커널이 계산한 값이 먼저, 못 하면 원본이 말한 값**이다(§`progressOf`).
+         *
+         * 이 순서는 사람 교대(`offShift`)가 세워 둔 규율과 같다: 파생이 가능하면 파생이 이기고, 파생이
+         * 불가능할 때만 원본의 단정을 쓴다. 둘 다 없으면 **싣지 않는다** — 「모른다」를 숫자로 만들지 않는다.
+         *
+         * 예전에는 원본이 진척을 말해도 조용히 버렸다(문이 받아 놓고 파생이 덮었다). 넣었는데 사라지는
+         * 것이 이 시스템에서 가장 비싼 침묵이다.
+         */
+        ...t.status === "in-progress" ? {
+          remainingMs: t.remainingMs,
+          startedAtSimMs: t.startedAtSimMs,
+          ...(() => {
+            const derived = this.progressOf(t);
+            const p = derived ?? t.progress;
+            return p === void 0 ? {} : { progress: p };
+          })()
+        } : {},
         ...t.personnel?.length ? { personnel: t.personnel.slice() } : {},
         ...t.assets?.length ? { assets: t.assets.slice() } : {},
         ...t.resources?.length ? { resources: t.resources.slice() } : {},
@@ -4752,7 +4825,7 @@ var FlowEngine = class {
   settleObserved() {
     if (!this.observedDirty || !this.observer) return;
     this.observedDirty = false;
-    this.hydrateObserved(this.observer.snapshot());
+    this.hydrateObserved(this.observer.snapshot(), [], "observe");
   }
   /** 구독자 목록 — 관측 재방출용(private handlers 에 접근). */
   observedHandlers() {
@@ -6147,8 +6220,27 @@ var FlowEngine = class {
       ...i.ilmd ? { ilmd: i.ilmd } : {}
     };
   }
+  /**
+   * 진척 — **모르면 답하지 않는다.**
+   *
+   * ── 무엇이 틀려 있었나 (2026-08-23 실측) ───────────────────────────────────
+   * 예전에는 `durationMs <= 0` 이면 `1` 을 돌려줬다. 시뮬에서는 그것이 맞다(소요 0 = 즉시 끝나는 일).
+   * 그런데 **미러에서 `durationMs` 0 은 「즉시」가 아니라 「모른다」다** — 원본이 소요를 말해 주지
+   * 않으면 씨앗 경로가 0 으로 메우고, 그러면 이 함수가 **진행 중인 작업을 100% 라고 말한다.**
+   *
+   * 실측: 소요를 주지 않는 원본의 진행 중 작업이 `progress: 1` 로 나왔다. 「모름」을 「완료」로 말하는
+   * 것이고, 화면은 그것을 사실로 그린다.
+   *
+   * 시뮬에서는 이 반환이 바뀌지 않는다: 소요 0 인 작업은 배정된 tick 안에서 끝나므로 **진행 중으로
+   * 관측되지 않는다**(`status = 'in-progress'; remainingMs = durationMs` → 다음 진행에서 즉시 완료).
+   * 즉 `durationMs <= 0` 이면서 진행 중인 작업은 미러 경로에서만 나온다.
+   *
+   * 모를 때 원본이 진척을 말해 주었다면 그 값을 쓴다 — 그 규칙은 부르는 쪽에 있다(§`getSnapshot`).
+   * 이 함수는 **커널이 계산할 수 있나**만 답한다.
+   */
   progressOf(t) {
-    return t.durationMs <= 0 ? 1 : Math.min(1, Math.max(0, (t.durationMs - t.remainingMs) / t.durationMs));
+    if (!(t.durationMs > 0)) return void 0;
+    return Math.min(1, Math.max(0, (t.durationMs - t.remainingMs) / t.durationMs));
   }
   generate() {
     for (const g of this.gens) {

package/package.json

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