@operato/twin-kernel 0.11.24 → 0.11.26

package/dist/flow-engine.d.ts

@@ -4,6 +4,7 @@ import type { VocabularyElement } from '@operato/ops-contract';
 import type { ReducerCheckpoint } from './observed-reducer.ts';
 import type { EpcisEvent, BizTransactionElement } from '@operato/ops-contract';
 import type { AllocationPolicy, SlotView } from './allocation-policy.ts';
+import { type FoldedOrders, type OrderFoldPolicy } from '@operato/ops-contract';
 import type { DurationEstimator, DurationContext } from './duration-estimator.ts';
 import type { OperationDef, IsoDuration, OpMaterialSpecification } from '@operato/ops-contract';
 import { type CapacityAnalysis } from '@operato/ops-contract';
@@ -290,6 +291,8 @@ export interface FlowOrder {
     picked: string[];
     gtin?: string;
     shipmentEpc?: string | null;
+    /** 언제 끝났나(ms) — 끝났다고 사건을 낸 시각. 끝난 오더를 접는 경계가 이 값으로 잰다(ADR-0092). */
+    terminalAtMs?: number;
     lines?: OrderLine[];
     held?: boolean;
     dockDoor?: string;
@@ -568,6 +571,10 @@ export declare abstract class FlowEngine implements TwinKernel {
     assets: Map<string, FlowAsset>;
     tasks: Map<string, FlowTask>;
     orders: Map<string, FlowOrder>;
+    /** 접힌 오더(ADR-0092) — 세는 수와 경계만 든다. 미러는 리듀서가 들고 이것은 옮겨 받는다(§`hydrateObserved`). */
+    protected foldedOrders: FoldedOrders;
+    /** 끝난 오더를 언제 접나 — 모델의 `orderFold` 선언. 없으면 기본(24시간 · 1,000건). */
+    protected orderFoldPolicy: OrderFoldPolicy;
     revision: number;
     clockMs: number;
     /**
@@ -633,6 +640,16 @@ export declare abstract class FlowEngine implements TwinKernel {
      *
      * 관측 구동이 아니면 `undefined` — 시뮬은 리듀서를 갖지 않는다(저장할 것이 없다).
      */
+    /**
+     * **끝난 오더를 접는다**(ADR-0092) — 접은 수를 돌려준다.
+     *
+     * 부르는 것은 호스트다 — 체크포인트(미러는 `observedCheckpoint`, 시뮬은 상태 스냅샷)를 쓰기 직전에 부른다. 그래야
+     * 접힌 쪽이 씨앗과 같은 때에 적힌다. 커널이 스스로 접지 않는 것은, 접힌 목록을 읽는 쪽(예측 · 화면)이 그 뜻에
+     * 맞춰진 뒤에 호스트가 부르게 하려는 것이다.
+     *
+     * 미러는 원천인 리듀서에서 접고 옮겨 받는다 — 이 목록에서만 지우면 다음 옮김이 되살린다.
+     */
+    foldFinishedOrders(nowMs?: number): number;
     observedCheckpoint(): ReducerCheckpoint | undefined;
     /**
      * **재개점에서 관측 리듀서를 되세운다** — 저널을 0부터 다시 집계하지 않게.
@@ -837,6 +854,8 @@ export declare abstract class FlowEngine implements TwinKernel {
         assets?: AssetState[];
         tasks?: TaskState[];
         orders?: OrderState[];
+        /** 접힌 오더(ADR-0092) — 세는 수와 경계. 이어받지 않으면 재기동 · fork 뒤에 끝난 오더의 수를 잃는다. */
+        foldedOrders?: FoldedOrders;
         /** 확인해 둔 주목 신호 id — 계산으로 되살릴 수 없어 스냅샷에서 이어받는다. */
         acked?: string[];
         /** 주목 신호가 처음 성립한 시각 — 이어받지 않으면 지속된 조건이 「방금」으로 되살아난다. */

package/dist/flow-engine.js

@@ -17,6 +17,7 @@ import { resolveSubject } from '@operato/ops-contract';
 import { WMS_ORDER_KIND } from '@operato/ops-contract';
 import { transformationEvent, aggregationEvent, objectEvent, parseEpc, DISP, ILMD_ATTR, CBV_BIZSTEP, objectUri, bizTransactionUri, gdtiUri } from '@operato/ops-contract';
 import { allocationPolicyOf } from "./allocation-policy.js";
+import { ORDER_FOLD_DEFAULT, emptyFoldedOrders, foldOrdersInto, foldedOrderCount, pruneFoldedHours, orderFoldPolicyOf, planOrderFold } from '@operato/ops-contract';
 import { OP_PARAM } from '@operato/ops-contract';
 import { parseIsoDuration } from '@operato/ops-contract';
 import { analyzeCapacity } from '@operato/ops-contract';
@@ -630,6 +631,10 @@ export class FlowEngine {
     assets = new Map();
     tasks = new Map();
     orders = new Map();
+    /** 접힌 오더(ADR-0092) — 세는 수와 경계만 든다. 미러는 리듀서가 들고 이것은 옮겨 받는다(§`hydrateObserved`). */
+    foldedOrders = emptyFoldedOrders();
+    /** 끝난 오더를 언제 접나 — 모델의 `orderFold` 선언. 없으면 기본(24시간 · 1,000건). */
+    orderFoldPolicy = ORDER_FOLD_DEFAULT;
     revision = 0;
     clockMs = 0;
     /**
@@ -695,6 +700,35 @@ export class FlowEngine {
      *
      * 관측 구동이 아니면 `undefined` — 시뮬은 리듀서를 갖지 않는다(저장할 것이 없다).
      */
+    /**
+     * **끝난 오더를 접는다**(ADR-0092) — 접은 수를 돌려준다.
+     *
+     * 부르는 것은 호스트다 — 체크포인트(미러는 `observedCheckpoint`, 시뮬은 상태 스냅샷)를 쓰기 직전에 부른다. 그래야
+     * 접힌 쪽이 씨앗과 같은 때에 적힌다. 커널이 스스로 접지 않는 것은, 접힌 목록을 읽는 쪽(예측 · 화면)이 그 뜻에
+     * 맞춰진 뒤에 호스트가 부르게 하려는 것이다.
+     *
+     * 미러는 원천인 리듀서에서 접고 옮겨 받는다 — 이 목록에서만 지우면 다음 옮김이 되살린다.
+     */
+    foldFinishedOrders(nowMs) {
+        if (this.observeMode && this.observer) {
+            const n = this.observer.foldFinishedOrders(nowMs);
+            if (n) {
+                this.observedDirty = true;
+                this.settleObserved();
+            }
+            return n;
+        }
+        const ids = planOrderFold([...this.orders.values()], nowMs ?? this.nowMs(), this.orderFoldPolicy);
+        if (!ids.length)
+            return 0;
+        /* 창 밖 시간 칸은 접을 때 버린다 — 칸 수가 T/1h 를 넘지 않게(ADR-0092 결정 2 보탬). */
+        const now = nowMs ?? this.nowMs();
+        this.foldedOrders = pruneFoldedHours(foldOrdersInto(this.foldedOrders, ids.map(id => this.orders.get(id)).filter(Boolean)), now, this.orderFoldPolicy);
+        for (const id of ids)
+            this.orders.delete(id);
+        this.revision++;
+        return ids.length;
+    }
     observedCheckpoint() {
         /*
          * 관측 구동인데 리듀서가 아직 없으면 만든다 (2026-08-27).
@@ -825,6 +859,11 @@ export class FlowEngine {
          */
         if (def.allocationPolicy)
             this.policy = allocationPolicyOf(def.allocationPolicy);
+        /* 끝난 오더를 접는 경계 — 0 · 무한은 거절한다. 접지 않는 선언은 끝난 오더가 끝없이 쌓이던 때로 돌아간다(ADR-0092). */
+        const fold = orderFoldPolicyOf(def.orderFold);
+        if ('error' in fold)
+            throw new Error(fold.error);
+        this.orderFoldPolicy = fold.policy;
         /*
          * **생산 선언은 어느 커널이든 싣는다.** 예전에는 MES 커널만 생성자에서 이것을 실었고(그 시절
          * 이름은 `mesSpec` 이었다), 그래서 창고 트윈은 "자재를 소비해 자재를 산출하는 공정" 을 선언할
@@ -1281,6 +1320,19 @@ export class FlowEngine {
          *
          * 지어내지 않는다 — 없는 물품을 만들어 채우면 그 뒤 계보와 재고가 전부 거짓 위에 선다.
          */
+        /* 접힌 쪽과 종결 시각을 이어받는다(ADR-0092). 종결 시각은 델타에 없으므로 스냅샷의 오더에서 찾는다. */
+        this.foldedOrders = snap.foldedOrders ? structuredClone(snap.foldedOrders) : emptyFoldedOrders();
+        const terminalAtOf = new Map((snap.orders ?? []).map(o => [o.id, o.terminalAtMs]));
+        /*
+         * **관측이면 원천에 없는 오더를 지운다.** 이 목록은 리듀서에서 옮겨 받는 것이라, 리듀서가 접은 오더를 여기 남기면
+         * 다시는 사라지지 않는다. 씨앗(웜스타트 · fork)은 새로 세우는 커널이라 지울 것이 없다.
+         */
+        if (purpose === 'observe') {
+            const present = new Set(observedOrders.map(o => o.orderId));
+            for (const id of [...this.orders.keys()])
+                if (!present.has(id))
+                    this.orders.delete(id);
+        }
         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);
             /* **라인이 없는 오더를 조용히 빼지 않는다.** 예전에는 남은 양을 라인에서만 셌으므로, 품목 라인
@@ -1341,7 +1393,9 @@ export class FlowEngine {
                 /* 약속해 둔 자리·시각창을 이어받는다 — 없으면 도메인이 「정해 뒀다」고 믿는 것을 잃는다.
                    사실이 말해 주지 않으면(옛 저널) 비는 것이 사실이다 — 지어내지 않는다. */
                 ...(o.dockDoor ? { dockDoor: o.dockDoor } : {}),
-                ...(o.windowStartMs !== undefined ? { windowStartMs: o.windowStartMs } : {})
+                ...(o.windowStartMs !== undefined ? { windowStartMs: o.windowStartMs } : {}),
+                /* 언제 끝났나 — 관측만 이어받는다(씨앗은 끝난 오더를 심지 않는다). */
+                ...(observing && terminalAtOf.get(o.orderId) !== undefined ? { terminalAtMs: terminalAtOf.get(o.orderId) } : {})
             });
         }
         /* 작업이 딛고 설 오더를 먼저 세운다 — 순서가 뒤바뀌면 아래 확인이 언제나 "없다" 로 답한다. */
@@ -1831,8 +1885,11 @@ export class FlowEngine {
                 ...(t.startTime ? { startTime: t.startTime } : {}),
                 ...(t.endTime ? { endTime: t.endTime } : {})
             })),
+            /* 접힌 오더 — 접은 것이 없으면 싣지 않는다(ADR-0092). */
+            ...(foldedOrderCount(this.foldedOrders) ? { foldedOrders: structuredClone(this.foldedOrders) } : {}),
             orders: [...this.orders.values()].map(o => ({
                 id: o.id, kind: o.kind, status: o.status,
+                ...(o.terminalAtMs !== undefined ? { terminalAtMs: o.terminalAtMs } : {}),
                 progress: o.requested ? o.fulfilled / o.requested : 0,
                 requested: o.requested, fulfilled: o.fulfilled,
                 /*
@@ -3007,6 +3064,15 @@ export class FlowEngine {
     }
     /** 오더 델타 — **라인까지 싣는다.** 라인이 빠지면 미러가 남은 데맨드를 라인별로 재계획할 수 없다. */
     emitOrder(o) {
+        /*
+         * **언제 끝났나를 여기서 적는다** — 오더의 상태를 바꾸는 자리는 여럿이지만 사건을 내는 문은 이것 하나다.
+         * 끝났던 오더는 처음 끝난 시각을 지키고, 다시 열리면 지운다. 미러는 같은 값을 그 사건의 `eventTime` 에서
+         * 되세운다(델타에 싣지 않는다 — 두 구동이 같은 시각을 든다).
+         */
+        if (isOrderTerminal(o))
+            o.terminalAtMs ??= this.nowMs();
+        else
+            delete o.terminalAtMs;
         this.emitOp(OP_EVENT.order, {
             orderId: o.id, kind: o.kind, status: o.status, requested: o.requested, fulfilled: o.fulfilled, held: o.held,
             ...(o.priority !== undefined ? { priority: o.priority } : {}),

package/dist/observed-reducer.d.ts

@@ -1,4 +1,5 @@
 import type { AssetState, TestResult, MaterialQuantity, TwinModelDef, CanonicalEnvelope, LocationState, ItemState, LocationObservation, EquipmentState, PersonState, TaskState, OrderState, StructureShift, DispositionFact } from '@operato/ops-contract';
+import { type FoldedOrders } from '@operato/ops-contract';
 import type { MaterialLotUse } from '@operato/ops-contract';
 import { type VocabularyElement } from '@operato/ops-contract';
 interface ProjItem {
@@ -103,6 +104,8 @@ export interface ProjectedState {
     tasks: TaskState[];
     equipment: EquipmentState[];
     orders: OrderState[];
+    /** 접힌 오더(ADR-0092) — 접은 것이 없으면 없다. */
+    foldedOrders?: FoldedOrders;
     /**
      * 사람이 확인(ack)해 둔 주목 신호 id — **파생될 수 없는 유일한 축**이라 저널에서 되살린다.
      *
@@ -159,6 +162,8 @@ export interface ReducerCheckpoint {
     persons: PersonState[];
     assets: AssetState[];
     orders: OrderState[];
+    /** 접힌 오더(ADR-0092) — 옛 저장본에는 없다(없으면 접은 것이 없는 것이다). */
+    foldedOrders?: FoldedOrders;
     acked: string[];
     corrections: {
         declaredAt: string;
@@ -267,6 +272,8 @@ export declare class ObservedReducer {
     private persons;
     private assets;
     private orders;
+    private foldedOrders;
+    private orderFoldPolicy;
     /** 확인해 둔 주목 신호 id — `attention.acked` 이벤트로만 들어온다(계산으로 만들지 않는다). */
     private acked;
     revision: number;
@@ -518,6 +525,14 @@ export declare class ObservedReducer {
      * 모델에서 오는 판정 입력(교대·등급·시간대)은 생성자가 이미 세웠으므로 건드리지 않는다.
      */
     restore(cp: ReducerCheckpoint): void;
+    /**
+     * **끝난 오더를 접는다**(ADR-0092) — 접은 수를 돌려준다.
+     *
+     * 부르는 것은 호스트다: 체크포인트를 쓰기 직전에 부른다. 그래야 접힌 쪽이 씨앗과 같은 때에 적혀 재기동 동치
+     * (`재개점 + 꼬리 == 0부터 접기`)가 선다. 「지금」은 트윈의 지금(마지막으로 들은 시각)이다 — 벽시계가 아니다.
+     * 아직 아무것도 못 들었으면 접지 않는다.
+     */
+    foldFinishedOrders(nowMs?: number | undefined): number;
     snapshot(): ProjectedState;
 }
 export {};

package/dist/observed-reducer.js

@@ -22,6 +22,7 @@
 import { computeOee, isWorkShiftExecutionBasis } from '@operato/ops-contract';
 import { OP_EVENT, capabilityOf, itemKeyOf, judgeAgainstSpec, requiredTestsFor, locationStatusOf, readBoardEquipment, readBoardLocations, readBoardAssets, effectivityAt, offCalendarAt, offCalendarReasonAt, activeShiftAt } from '@operato/ops-contract';
 import { ILMD_ATTR, parseEpc } from '@operato/ops-contract';
+import { emptyFoldedOrders, foldOrdersInto, foldedOrderCount, pruneFoldedHours, isOrderTerminal, orderFoldPolicyOf, planOrderFold, standsNewOrderRow } from '@operato/ops-contract';
 import { expiryFromAttributes, lotFromAttributes } from '@operato/ops-contract';
 /* 클래스 마스터 표는 상태를 들므로 커널에 있다(§`class-master-table`). */
 import { ClassMasterTable } from "./class-master-table.js";
@@ -86,6 +87,12 @@ export class ObservedReducer {
     persons = new Map();
     assets = new Map();
     orders = new Map();
+    /*
+     * **접힌 오더** — 끝나서 뜨거운 목록에서 걷힌 것의 세는 수와 경계(ADR-0092). 접는 때는 호스트가 정한다
+     * (체크포인트를 쓰기 직전에 `foldFinishedOrders` 를 부른다). 경계는 모델의 `orderFold` 선언이다.
+     */
+    foldedOrders = emptyFoldedOrders();
+    orderFoldPolicy;
     /** 확인해 둔 주목 신호 id — `attention.acked` 이벤트로만 들어온다(계산으로 만들지 않는다). */
     acked = new Set();
     revision = 0;
@@ -119,6 +126,11 @@ export class ObservedReducer {
     /** 시각 해석 기준(트윈 모델 선언) — 없으면 UTC. 캘린더의 `HH:MM` 이 어느 기준인지 정한다. */
     utcOffsetMinutes;
     constructor(model) {
+        /* 접지 않는 선언(0 · 무한)은 거절한다 — 기본값으로 조용히 바꾸면 선언한 사람은 자기 값이 쓰이는 줄 안다. */
+        const fold = orderFoldPolicyOf(model.orderFold);
+        if ('error' in fold)
+            throw new Error(fold.error);
+        this.orderFoldPolicy = fold.policy;
         this.utcOffsetMinutes = model.utcOffsetMinutes;
         this.classDefs = { personnel: model.personnelClasses, equipment: model.equipmentClasses, asset: model.assetClasses };
         /* 선언된 판정 기준 — 원천이 판정하지 않은 결과를 커널이 판정할 때 쓴다(§`judgeAgainstSpec`). */
@@ -711,11 +723,26 @@ export class ObservedReducer {
                 const d = e.data;
                 if (this.stale(`order:${d.orderId}`, e))
                     return;
+                const prev = this.orders.get(d.orderId);
+                const at = Date.parse(String(e.eventTime ?? ''));
+                /*
+                 * **접힌 오더의 옛 종결이 다시 오면 줄을 세우지 않는다**(ADR-0092 결정 2). 폴링 원본은 같은 종결을 다시
+                 * 보낸다 — 줄을 세우면 다음 경계에서 또 접혀 세는 수가 두 번 는다. 레코드 자신의 시각으로 가른다(도착
+                 * 시각이 아니다). 순서 판정에 적힌 이 오더의 시각도 지운다 — 남기면 그 맵이 오더 수만큼 다시 자란다.
+                 */
+                if (!prev && !standsNewOrderRow(d, Number.isFinite(at) ? at : undefined, this.foldedOrders)) {
+                    this.lastAt.delete(`order:${d.orderId}`);
+                    return;
+                }
+                /* 언제 끝났나 — 끝났던 오더는 처음 끝난 시각을 지킨다. 끝나지 않았으면(재개 포함) 없다. */
+                const terminal = isOrderTerminal({ status: d.status, requested: d.requested, fulfilled: d.fulfilled });
+                const terminalAtMs = terminal ? (prev?.terminalAtMs ?? (Number.isFinite(at) ? at : undefined)) : undefined;
                 /* **진척으로 압축하지 않는다.** 예전에는 progress 만 남겨서, 미러에서 예측을 세우려면 저널을
                  * 따로 읽어 오더 원값을 되찾아야 했다. 진척은 요청·이행에서 나오는 파생이다 — 파생을 남기고
                  * 원본을 버리면 남은 데맨드를 재계획할 수 없다. */
                 this.orders.set(d.orderId, {
                     id: d.orderId, kind: d.kind, status: d.status,
+                    ...(terminalAtMs !== undefined ? { terminalAtMs } : {}),
                     progress: d.requested ? d.fulfilled / d.requested : 0,
                     requested: d.requested, fulfilled: d.fulfilled,
                     ...(d.lines?.length ? { lines: d.lines.map(l => ({ ...l })) } : {}),
@@ -1332,6 +1359,8 @@ export class ObservedReducer {
             persons: [...this.persons.values()].map(x => ({ ...x })),
             assets: [...this.assets.values()].map(x => ({ ...x })),
             orders: [...this.orders.values()].map(o => ({ ...o })),
+            /* 접힌 쪽도 재개점에 든다 — 없으면 재기동 뒤에 끝난 오더의 수를 잃는다(ADR-0092). 접은 것이 없으면 싣지 않는다. */
+            ...(foldedOrderCount(this.foldedOrders) ? { foldedOrders: structuredClone(this.foldedOrders) } : {}),
             acked: [...this.acked],
             corrections: this.corrections.map(c => ({ ...c })),
             unhandled: [...this.unhandled.entries()].map(([eventType, v]) => ({ eventType, ...v })),
@@ -1375,10 +1404,34 @@ export class ObservedReducer {
         this.persons = new Map((cp?.persons ?? []).map(x => [x.id, { ...x }]));
         this.assets = new Map((cp?.assets ?? []).map(x => [x.id, { ...x }]));
         this.orders = new Map((cp?.orders ?? []).map(o => [o.id, { ...o }]));
+        this.foldedOrders = cp?.foldedOrders ? structuredClone(cp.foldedOrders) : emptyFoldedOrders();
         this.acked = new Set(cp?.acked ?? []);
         this.corrections = (cp?.corrections ?? []).map(c => ({ ...c }));
         this.unhandled = new Map((cp?.unhandled ?? []).map(({ eventType, ...v }) => [eventType, { ...v }]));
     }
+    /**
+     * **끝난 오더를 접는다**(ADR-0092) — 접은 수를 돌려준다.
+     *
+     * 부르는 것은 호스트다: 체크포인트를 쓰기 직전에 부른다. 그래야 접힌 쪽이 씨앗과 같은 때에 적혀 재기동 동치
+     * (`재개점 + 꼬리 == 0부터 접기`)가 선다. 「지금」은 트윈의 지금(마지막으로 들은 시각)이다 — 벽시계가 아니다.
+     * 아직 아무것도 못 들었으면 접지 않는다.
+     */
+    foldFinishedOrders(nowMs = this.observedAtMs) {
+        if (nowMs === undefined || !Number.isFinite(nowMs))
+            return 0;
+        const ids = planOrderFold([...this.orders.values()], nowMs, this.orderFoldPolicy);
+        if (!ids.length)
+            return 0;
+        const rows = ids.map(id => this.orders.get(id)).filter(Boolean);
+        /* 창 밖 시간 칸은 접을 때 버린다 — 칸 수가 T/1h 를 넘지 않게(ADR-0092 결정 2 보탬). */
+        this.foldedOrders = pruneFoldedHours(foldOrdersInto(this.foldedOrders, rows), nowMs, this.orderFoldPolicy);
+        for (const id of ids) {
+            this.orders.delete(id);
+            this.lastAt.delete(`order:${id}`);
+        }
+        this.revision++;
+        return ids.length;
+    }
     snapshot() {
         const occ = new Map();
         for (const it of this.items.values())
@@ -1425,6 +1478,7 @@ export class ObservedReducer {
             tasks: [...this.tasks.values()].map(t => structuredClone(t)),
             equipment: [...this.equipment.values()].map(m => ({ ...m, ...this.oeePart(m.id), ...this.effectivityPart(m), ...this.offShiftPart(`eq:${m.id}`), ...this.capabilityPart(m, `eq:${m.id}`, m.kind ? [m.kind] : [], this.classDefs.equipment) })),
             orders: [...this.orders.values()].map(o => ({ ...o })),
+            ...(foldedOrderCount(this.foldedOrders) ? { foldedOrders: structuredClone(this.foldedOrders) } : {}),
             acked: [...this.acked]
         };
     }

package/dist-cjs/index.cjs

@@ -1909,6 +1909,93 @@ function gs1KeyDigitViolation(uri) {
   return `${m[1]} \uC790\uB9AC \uC218 \uC624\uB958: ${uri} \u2014 \uD68C\uC0AC \uD504\uB9AC\uD53D\uC2A4(${prefix.length}) + \uCC38\uC870(${ref.length}) = ${got} \uC774\uC9C0\uB9CC ${want} \uC5EC\uC57C \uD55C\uB2E4(GS1 TDS). \uD504\uB9AC\uD53D\uC2A4\uB97C \uBC14\uAFB8\uBA74 \uCC38\uC870 \uC790\uB9AC \uC218\uB97C \uD568\uAED8 \uB9DE\uCDB0\uC57C \uD55C\uB2E4.`;
 }
 
+// ../ops-contract/dist/order-fold.js
+var ORDER_FOLD_HOUR_MS = 60 * 60 * 1e3;
+var ORDER_FOLD_DEFAULT = Object.freeze({ afterMs: 24 * 60 * 60 * 1e3, maxTerminal: 1e3 });
+function orderFoldPolicyOf(declared) {
+  const policy = { ...ORDER_FOLD_DEFAULT };
+  for (const key of ["afterMs", "maxTerminal"]) {
+    const v = declared?.[key];
+    if (v === void 0 || v === null)
+      continue;
+    if (typeof v !== "number" || !Number.isFinite(v) || v <= 0) {
+      return { error: `order fold ${key} must be a positive finite number, got ${String(v)} \u2014 a fold that never folds is refused (ADR-0092)` };
+    }
+    policy[key] = key === "maxTerminal" ? Math.floor(v) : v;
+  }
+  if (policy.afterMs % ORDER_FOLD_HOUR_MS !== 0) {
+    return { error: `order fold afterMs must be a whole number of hours, got ${policy.afterMs} ms \u2014 the window is counted in hour slots (ADR-0092)` };
+  }
+  if (policy.maxTerminal < 1)
+    return { error: "order fold maxTerminal must be at least 1 (ADR-0092)" };
+  return { policy };
+}
+function emptyFoldedOrders() {
+  return { counts: {}, boundaryMs: null };
+}
+function foldedOrderCount(folded) {
+  let n = 0;
+  for (const byStatus of Object.values(folded?.counts ?? {}))
+    for (const c of Object.values(byStatus))
+      n += c;
+  return n;
+}
+function planOrderFold(orders, nowMs, policy = ORDER_FOLD_DEFAULT) {
+  const candidates = orders.filter((o) => isOrderTerminal(o) && !o.held && typeof o.terminalAtMs === "number" && Number.isFinite(o.terminalAtMs)).sort((a, b) => a.terminalAtMs - b.terminalAtMs || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+  const cutoff = nowMs - policy.afterMs;
+  const byTime = candidates.filter((o) => o.terminalAtMs <= cutoff);
+  const stay = candidates.length - byTime.length;
+  const byCount = stay > policy.maxTerminal ? candidates.slice(byTime.length, byTime.length + (stay - policy.maxTerminal)) : [];
+  return [...byTime, ...byCount].map((o) => o.id);
+}
+function foldOrdersInto(folded, orders) {
+  const out = {
+    counts: Object.fromEntries(Object.entries(folded?.counts ?? {}).map(([k, v]) => [k, { ...v }])),
+    boundaryMs: folded?.boundaryMs ?? null
+  };
+  const hours = Object.fromEntries(Object.entries(folded?.hours ?? {}).map(([h, byKind]) => [h, Object.fromEntries(Object.entries(byKind).map(([k, v]) => [k, { ...v }]))]));
+  for (const o of orders) {
+    const kind = String(o.kind ?? "");
+    const status = String(o.status ?? "");
+    const byStatus = out.counts[kind] ??= {};
+    byStatus[status] = (byStatus[status] ?? 0) + 1;
+    if (typeof o.terminalAtMs === "number" && Number.isFinite(o.terminalAtMs)) {
+      out.boundaryMs = out.boundaryMs === null ? o.terminalAtMs : Math.max(out.boundaryMs, o.terminalAtMs);
+      const slot = (hours[String(hourStartOf(o.terminalAtMs))] ??= {})[kind] ??= {};
+      slot[status] = (slot[status] ?? 0) + 1;
+    }
+  }
+  if (Object.keys(hours).length)
+    out.hours = hours;
+  return out;
+}
+function standsNewOrderRow(record, eventTimeMs, folded) {
+  if (!isOrderTerminal(record))
+    return true;
+  const boundary = folded?.boundaryMs;
+  if (boundary === null || boundary === void 0)
+    return true;
+  if (typeof eventTimeMs !== "number" || !Number.isFinite(eventTimeMs))
+    return true;
+  return eventTimeMs > boundary;
+}
+function hourStartOf(ms2) {
+  return Math.floor(ms2 / ORDER_FOLD_HOUR_MS) * ORDER_FOLD_HOUR_MS;
+}
+function finishedWindowStartMs(nowMs, policy = ORDER_FOLD_DEFAULT) {
+  return hourStartOf(nowMs) - policy.afterMs;
+}
+function pruneFoldedHours(folded, nowMs, policy = ORDER_FOLD_DEFAULT) {
+  if (!folded.hours)
+    return folded;
+  const start = finishedWindowStartMs(nowMs, policy);
+  const kept = Object.fromEntries(Object.entries(folded.hours).filter(([h]) => Number(h) >= start));
+  const out = { counts: folded.counts, boundaryMs: folded.boundaryMs };
+  if (Object.keys(kept).length)
+    out.hours = kept;
+  return out;
+}
+
 // ../ops-contract/dist/iso-duration.js
 var RE = /^(-)?P(?:(\d+(?:\.\d+)?)W)?(?:(\d+(?:\.\d+)?)D)?(?:T(?:(\d+(?:\.\d+)?)H)?(?:(\d+(?:\.\d+)?)M)?(?:(\d+(?:\.\d+)?)S)?)?$/;
 function parseIsoDuration(text) {
@@ -2833,6 +2920,12 @@ var ObservedReducer = class {
   persons = /* @__PURE__ */ new Map();
   assets = /* @__PURE__ */ new Map();
   orders = /* @__PURE__ */ new Map();
+  /*
+   * **접힌 오더** — 끝나서 뜨거운 목록에서 걷힌 것의 세는 수와 경계(ADR-0092). 접는 때는 호스트가 정한다
+   * (체크포인트를 쓰기 직전에 `foldFinishedOrders` 를 부른다). 경계는 모델의 `orderFold` 선언이다.
+   */
+  foldedOrders = emptyFoldedOrders();
+  orderFoldPolicy;
   /** 확인해 둔 주목 신호 id — `attention.acked` 이벤트로만 들어온다(계산으로 만들지 않는다). */
   acked = /* @__PURE__ */ new Set();
   revision = 0;
@@ -2866,6 +2959,9 @@ var ObservedReducer = class {
   /** 시각 해석 기준(트윈 모델 선언) — 없으면 UTC. 캘린더의 `HH:MM` 이 어느 기준인지 정한다. */
   utcOffsetMinutes;
   constructor(model) {
+    const fold = orderFoldPolicyOf(model.orderFold);
+    if ("error" in fold) throw new Error(fold.error);
+    this.orderFoldPolicy = fold.policy;
     this.utcOffsetMinutes = model.utcOffsetMinutes;
     this.classDefs = { personnel: model.personnelClasses, equipment: model.equipmentClasses, asset: model.assetClasses };
     for (const sp of model.testSpecifications ?? []) this.testSpecs.set(sp.id, sp);
@@ -3260,10 +3356,19 @@ var ObservedReducer = class {
       case OP_EVENT.order: {
         const d = e.data;
         if (this.stale(`order:${d.orderId}`, e)) return;
+        const prev = this.orders.get(d.orderId);
+        const at = Date.parse(String(e.eventTime ?? ""));
+        if (!prev && !standsNewOrderRow(d, Number.isFinite(at) ? at : void 0, this.foldedOrders)) {
+          this.lastAt.delete(`order:${d.orderId}`);
+          return;
+        }
+        const terminal = isOrderTerminal({ status: d.status, requested: d.requested, fulfilled: d.fulfilled });
+        const terminalAtMs = terminal ? prev?.terminalAtMs ?? (Number.isFinite(at) ? at : void 0) : void 0;
         this.orders.set(d.orderId, {
           id: d.orderId,
           kind: d.kind,
           status: d.status,
+          ...terminalAtMs !== void 0 ? { terminalAtMs } : {},
           progress: d.requested ? d.fulfilled / d.requested : 0,
           requested: d.requested,
           fulfilled: d.fulfilled,
@@ -3707,6 +3812,8 @@ var ObservedReducer = class {
       persons: [...this.persons.values()].map((x) => ({ ...x })),
       assets: [...this.assets.values()].map((x) => ({ ...x })),
       orders: [...this.orders.values()].map((o) => ({ ...o })),
+      /* 접힌 쪽도 재개점에 든다 — 없으면 재기동 뒤에 끝난 오더의 수를 잃는다(ADR-0092). 접은 것이 없으면 싣지 않는다. */
+      ...foldedOrderCount(this.foldedOrders) ? { foldedOrders: structuredClone(this.foldedOrders) } : {},
       acked: [...this.acked],
       corrections: this.corrections.map((c) => ({ ...c })),
       unhandled: [...this.unhandled.entries()].map(([eventType, v]) => ({ eventType, ...v })),
@@ -3753,10 +3860,31 @@ var ObservedReducer = class {
     this.persons = new Map((cp?.persons ?? []).map((x) => [x.id, { ...x }]));
     this.assets = new Map((cp?.assets ?? []).map((x) => [x.id, { ...x }]));
     this.orders = new Map((cp?.orders ?? []).map((o) => [o.id, { ...o }]));
+    this.foldedOrders = cp?.foldedOrders ? structuredClone(cp.foldedOrders) : emptyFoldedOrders();
     this.acked = new Set(cp?.acked ?? []);
     this.corrections = (cp?.corrections ?? []).map((c) => ({ ...c }));
     this.unhandled = new Map((cp?.unhandled ?? []).map(({ eventType, ...v }) => [eventType, { ...v }]));
   }
+  /**
+   * **끝난 오더를 접는다**(ADR-0092) — 접은 수를 돌려준다.
+   *
+   * 부르는 것은 호스트다: 체크포인트를 쓰기 직전에 부른다. 그래야 접힌 쪽이 씨앗과 같은 때에 적혀 재기동 동치
+   * (`재개점 + 꼬리 == 0부터 접기`)가 선다. 「지금」은 트윈의 지금(마지막으로 들은 시각)이다 — 벽시계가 아니다.
+   * 아직 아무것도 못 들었으면 접지 않는다.
+   */
+  foldFinishedOrders(nowMs = this.observedAtMs) {
+    if (nowMs === void 0 || !Number.isFinite(nowMs)) return 0;
+    const ids = planOrderFold([...this.orders.values()], nowMs, this.orderFoldPolicy);
+    if (!ids.length) return 0;
+    const rows = ids.map((id) => this.orders.get(id)).filter(Boolean);
+    this.foldedOrders = pruneFoldedHours(foldOrdersInto(this.foldedOrders, rows), nowMs, this.orderFoldPolicy);
+    for (const id of ids) {
+      this.orders.delete(id);
+      this.lastAt.delete(`order:${id}`);
+    }
+    this.revision++;
+    return ids.length;
+  }
   snapshot() {
     const occ = /* @__PURE__ */ new Map();
     for (const it of this.items.values()) occ.set(it.location, (occ.get(it.location) ?? 0) + 1);
@@ -3802,6 +3930,7 @@ var ObservedReducer = class {
       tasks: [...this.tasks.values()].map((t) => structuredClone(t)),
       equipment: [...this.equipment.values()].map((m) => ({ ...m, ...this.oeePart(m.id), ...this.effectivityPart(m), ...this.offShiftPart(`eq:${m.id}`), ...this.capabilityPart(m, `eq:${m.id}`, m.kind ? [m.kind] : [], this.classDefs.equipment) })),
       orders: [...this.orders.values()].map((o) => ({ ...o })),
+      ...foldedOrderCount(this.foldedOrders) ? { foldedOrders: structuredClone(this.foldedOrders) } : {},
       acked: [...this.acked]
     };
   }
@@ -4331,6 +4460,10 @@ var FlowEngine = class {
   assets = /* @__PURE__ */ new Map();
   tasks = /* @__PURE__ */ new Map();
   orders = /* @__PURE__ */ new Map();
+  /** 접힌 오더(ADR-0092) — 세는 수와 경계만 든다. 미러는 리듀서가 들고 이것은 옮겨 받는다(§`hydrateObserved`). */
+  foldedOrders = emptyFoldedOrders();
+  /** 끝난 오더를 언제 접나 — 모델의 `orderFold` 선언. 없으면 기본(24시간 · 1,000건). */
+  orderFoldPolicy = ORDER_FOLD_DEFAULT;
   revision = 0;
   clockMs = 0;
   /**
@@ -4396,6 +4529,32 @@ var FlowEngine = class {
    *
    * 관측 구동이 아니면 `undefined` — 시뮬은 리듀서를 갖지 않는다(저장할 것이 없다).
    */
+  /**
+   * **끝난 오더를 접는다**(ADR-0092) — 접은 수를 돌려준다.
+   *
+   * 부르는 것은 호스트다 — 체크포인트(미러는 `observedCheckpoint`, 시뮬은 상태 스냅샷)를 쓰기 직전에 부른다. 그래야
+   * 접힌 쪽이 씨앗과 같은 때에 적힌다. 커널이 스스로 접지 않는 것은, 접힌 목록을 읽는 쪽(예측 · 화면)이 그 뜻에
+   * 맞춰진 뒤에 호스트가 부르게 하려는 것이다.
+   *
+   * 미러는 원천인 리듀서에서 접고 옮겨 받는다 — 이 목록에서만 지우면 다음 옮김이 되살린다.
+   */
+  foldFinishedOrders(nowMs) {
+    if (this.observeMode && this.observer) {
+      const n = this.observer.foldFinishedOrders(nowMs);
+      if (n) {
+        this.observedDirty = true;
+        this.settleObserved();
+      }
+      return n;
+    }
+    const ids = planOrderFold([...this.orders.values()], nowMs ?? this.nowMs(), this.orderFoldPolicy);
+    if (!ids.length) return 0;
+    const now = nowMs ?? this.nowMs();
+    this.foldedOrders = pruneFoldedHours(foldOrdersInto(this.foldedOrders, ids.map((id) => this.orders.get(id)).filter(Boolean)), now, this.orderFoldPolicy);
+    for (const id of ids) this.orders.delete(id);
+    this.revision++;
+    return ids.length;
+  }
   observedCheckpoint() {
     if (!this.observer && this.observeMode) {
       this.observer = new ObservedReducer(this.boardDef ?? { locations: [], equipment: [] });
@@ -4504,6 +4663,9 @@ var FlowEngine = class {
   loadTwinModel(def) {
     this.boardDef = def;
     if (def.allocationPolicy) this.policy = allocationPolicyOf(def.allocationPolicy);
+    const fold = orderFoldPolicyOf(def.orderFold);
+    if ("error" in fold) throw new Error(fold.error);
+    this.orderFoldPolicy = fold.policy;
     if (def.productionSpec?.definition?.operations?.length) this.loadOperations(def.productionSpec.definition.operations);
     for (const n of readBoardLocations(def)) this.locations.set(n.id, this.buildLocation(n));
     this.classDefs = { personnel: def.personnelClasses, equipment: def.equipmentClasses, asset: def.assetClasses, material: def.materialClasses };
@@ -4881,6 +5043,12 @@ var FlowEngine = class {
       ...o.dockDoor ? { dockDoor: o.dockDoor } : {},
       ...o.windowStartMs !== void 0 ? { windowStartMs: o.windowStartMs } : {}
     }));
+    this.foldedOrders = snap.foldedOrders ? structuredClone(snap.foldedOrders) : emptyFoldedOrders();
+    const terminalAtOf = new Map((snap.orders ?? []).map((o) => [o.id, o.terminalAtMs]));
+    if (purpose === "observe") {
+      const present = new Set(observedOrders.map((o) => o.orderId));
+      for (const id of [...this.orders.keys()]) if (!present.has(id)) this.orders.delete(id);
+    }
     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));
@@ -4919,7 +5087,9 @@ var FlowEngine = class {
         /* 약속해 둔 자리·시각창을 이어받는다 — 없으면 도메인이 「정해 뒀다」고 믿는 것을 잃는다.
            사실이 말해 주지 않으면(옛 저널) 비는 것이 사실이다 — 지어내지 않는다. */
         ...o.dockDoor ? { dockDoor: o.dockDoor } : {},
-        ...o.windowStartMs !== void 0 ? { windowStartMs: o.windowStartMs } : {}
+        ...o.windowStartMs !== void 0 ? { windowStartMs: o.windowStartMs } : {},
+        /* 언제 끝났나 — 관측만 이어받는다(씨앗은 끝난 오더를 심지 않는다). */
+        ...observing && terminalAtOf.get(o.orderId) !== void 0 ? { terminalAtMs: terminalAtOf.get(o.orderId) } : {}
       });
     }
     const seededOrderIds = new Set(this.orders.keys());
@@ -5319,10 +5489,13 @@ var FlowEngine = class {
         ...t.startTime ? { startTime: t.startTime } : {},
         ...t.endTime ? { endTime: t.endTime } : {}
       })),
+      /* 접힌 오더 — 접은 것이 없으면 싣지 않는다(ADR-0092). */
+      ...foldedOrderCount(this.foldedOrders) ? { foldedOrders: structuredClone(this.foldedOrders) } : {},
       orders: [...this.orders.values()].map((o) => ({
         id: o.id,
         kind: o.kind,
         status: o.status,
+        ...o.terminalAtMs !== void 0 ? { terminalAtMs: o.terminalAtMs } : {},
         progress: o.requested ? o.fulfilled / o.requested : 0,
         requested: o.requested,
         fulfilled: o.fulfilled,
@@ -6358,6 +6531,8 @@ var FlowEngine = class {
   }
   /** 오더 델타 — **라인까지 싣는다.** 라인이 빠지면 미러가 남은 데맨드를 라인별로 재계획할 수 없다. */
   emitOrder(o) {
+    if (isOrderTerminal(o)) o.terminalAtMs ??= this.nowMs();
+    else delete o.terminalAtMs;
     this.emitOp(OP_EVENT.order, {
       orderId: o.id,
       kind: o.kind,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@operato/twin-kernel",
-  "version": "0.11.24",
+  "version": "0.11.26",
   "type": "module",
   "description": "Twin Domain Kernel — framework-agnostic, zero-dep (domain + sim + 3-channel contract). WMS/YMS/MES, EPCIS 2.0 · ISA-95.",
   "publishConfig": {
@@ -28,6 +28,6 @@
     "test": "node --test test/*.test.ts"
   },
   "dependencies": {
-    "@operato/ops-contract": "^0.9.35"
+    "@operato/ops-contract": "^0.9.37"
   }
 }