@operato/twin-kernel 0.6.6 → 0.6.8

package/dist/contract.d.ts

@@ -216,6 +216,45 @@ export declare function testPassedAt(r: TestResult, at?: ISOTime): boolean;
  * 없는 것으로 막지 않는다). 결과가 있으면 그것이 유효한 합격이어야 한다.
  */
 export declare function meetsTests(required: readonly string[], results: readonly TestResult[] | undefined, at?: ISOTime): boolean;
+/**
+ * 자원이 **지금 쓰일 수 있나, 아니면 왜 못 쓰이나** — ISA-95 `PersonnelCapability`/`EquipmentCapability`.
+ *
+ * ── 왜 계약이 이것을 소유해야 하나 ────────────────────────────────────────────
+ * 커널은 배정할 때 이미 이 판정을 한다(교대·고장·보류·유효기간·시험 만료). 그런데 그 규칙이 **엔진 안의
+ * 필터 조건으로만** 있어서, 화면은 같은 판정을 자기 코드로 다시 만들었다(`reasonOf`). 규칙이 두 벌이면
+ * 반드시 갈라진다 — 배정은 막는데 화면은 "가용" 이라 말하는 순간이 온다. 그 어긋남은 조용하다.
+ *
+ * 그래서 **이유까지 계약이 낸다.** 화면·예측·AI 가 같은 낱말로 말하고, 새 이유가 생기면(시험 만료가
+ * 그랬다) 한 곳만 늘어난다.
+ *
+ * ── 이유의 순서가 뜻이다 ──────────────────────────────────────────────────────
+ * 여러 이유가 겹칠 수 있다(폐기한 설비가 고장 상태로 남아 있는 것). **먼저 오는 것을 답한다** —
+ * "이미 모델 밖" 이 "고장" 보다 앞선다(폐기한 설비의 고장은 고칠 일이 아니다).
+ */
+export type CapabilityReason = 
+/** 유효기간 전 — 아직 없는 자원(도입 예정). 기다릴 일이다. */
+'not-yet'
+/** 유효기간 후 — 이미 없는 자원(폐기·퇴사). 지울 일이다. */
+ | 'retired'
+/** 사람이 막았다(`held`) — 지시로 보류. */
+ | 'held'
+/** 고장 — 설비만. 고칠 일이다. */
+ | 'down'
+/** 근무·가동 시간 밖(교대 사이) — 기다리면 돌아온다. */
+ | 'off-shift'
+/** 근무일이 아니다(휴일) — 하루 통째로 쉰다. `off-shift` 와 기다릴 시간이 다르다. */
+ | 'resting'
+/** 요구된 시험의 결과가 만료·불합격 — 자격이 성립하지 않는다(§TestResult). */
+ | 'test-expired'
+/** 지금 다른 일을 하고 있다 — 능력은 있고 여유가 없다. */
+ | 'working'
+/** 쓸 수 있다. */
+ | 'available';
+/** 가용 여부와 그 이유 — `available` 이면 `reason: 'available'`. */
+export interface Capability {
+    available: boolean;
+    reason: CapabilityReason;
+}
 export interface TestSpecification {
     /** 표준 `ID` — 자원의 `testSpecificationIds` 가 이 값을 가리킨다. */
     id: string;
@@ -578,6 +617,36 @@ export declare function offCalendarAt(r: {
     };
     workCalendar?: WorkCalendarEntry[];
 }, ms: number, utcOffsetMinutes?: number): boolean;
+/**
+ * 이 자원에게 **필수인 시험 목록** — 등급 상속을 타고 닫아 모은다.
+ *
+ * 요구는 등급이 말하고(`ResourceClassDef.testSpecificationIds`) 기록은 개체가 든다(`testResults`).
+ * 그 사이를 잇는 이 수집이 계약에 있는 이유: **두 구동이 같은 답을 내야 한다.** 시뮬과 미러가 각자
+ * 모으면 "이 사람에게 무엇이 필수인가" 가 갈리고, 같은 자원을 한쪽은 막고 다른 쪽은 통과시킨다.
+ */
+export declare function requiredTestsFor(directIds: readonly string[] | undefined, defs: readonly ResourceClassDef[] | undefined, at?: ISOTime): string[];
+/**
+ * 자원의 **가용 능력을 판정한다** — 하나의 규칙, 하나의 자리.
+ *
+ * 부르는 쪽이 시각과 시간대를 준다(커널은 `now()`·`utcOffsetMinutes`, 호스트는 관측 시각). 주지 않으면
+ * 시각에 달린 판정(유효기간·교대·시험 만료)은 **하지 않는다** — 모르면 판단하지 않는다는 규율이다.
+ *
+ * `requiredTests` 는 부르는 쪽이 등급에서 모아 넘긴다(등급 정의를 아는 것은 부르는 쪽이다).
+ */
+export declare function capabilityOf(r: {
+    status?: string;
+    held?: boolean;
+    window?: {
+        startHour: number;
+        endHour: number;
+    };
+    workCalendar?: WorkCalendarEntry[];
+    testResults?: TestResult[];
+} & EffectivePeriod, ctx?: {
+    at?: ISOTime;
+    utcOffsetMinutes?: number;
+    requiredTests?: readonly string[];
+}): Capability;
 export interface LocationState {
     id: string;
     type: string;
@@ -796,6 +865,18 @@ export interface EquipmentState extends EffectivePeriod {
      * 없으면 판정하지 않는다(없는 것으로 막으면 자격자가 전부 사라진다).
      */
     testResults?: TestResult[];
+    /**
+     * **왜 지금 쓰일 수 없나** — 판정과 사유를 계약이 낸다(`capabilityOf` · `CapabilityReason`).
+     *
+     * 상태에 실어 보내는 이유: 이 판정은 **시각과 등급 정의를 함께 알아야** 나온다(유효기간·교대·자격
+     * 만료). 소비처는 그 둘을 갖고 있지 않다 — 화면은 시뮬 시각을 모르고, 호스트는 등급 상속을 타고
+     * 필수 시험을 모으는 규칙을 모른다. 그래서 예전에는 소비처가 플래그를 보고 짐작했고, 자격이 만료된
+     * 사람이 `대기` 로 보였다. 놀고 있는 것은 맞지만 **쓸 수 있는 것은 아니다** — "대기 7명" 이 조용히
+     * 틀린 숫자가 됐다.
+     *
+     * 배정이 쓰는 판정과 **같은 함수의 결과**다(규칙 한 벌). 사유의 순서도 계약이 정한다.
+     */
+    capability?: Capability;
 }
 /**
  * 사람 — **ISA-95 `Person`.** 설비와 다른 자원 종류다.
@@ -861,6 +942,18 @@ export interface PersonState extends EffectivePeriod {
      * 없으면 판정하지 않는다(없는 것으로 막으면 자격자가 전부 사라진다).
      */
     testResults?: TestResult[];
+    /**
+     * **왜 지금 쓰일 수 없나** — 판정과 사유를 계약이 낸다(`capabilityOf` · `CapabilityReason`).
+     *
+     * 상태에 실어 보내는 이유: 이 판정은 **시각과 등급 정의를 함께 알아야** 나온다(유효기간·교대·자격
+     * 만료). 소비처는 그 둘을 갖고 있지 않다 — 화면은 시뮬 시각을 모르고, 호스트는 등급 상속을 타고
+     * 필수 시험을 모으는 규칙을 모른다. 그래서 예전에는 소비처가 플래그를 보고 짐작했고, 자격이 만료된
+     * 사람이 `대기` 로 보였다. 놀고 있는 것은 맞지만 **쓸 수 있는 것은 아니다** — "대기 7명" 이 조용히
+     * 틀린 숫자가 됐다.
+     *
+     * 배정이 쓰는 판정과 **같은 함수의 결과**다(규칙 한 벌). 사유의 순서도 계약이 정한다.
+     */
+    capability?: Capability;
 }
 /**
  * 물리 자산 — **ISA-95 `PhysicalAsset`, GS1 `GRAI`(반복사용 자산).**
@@ -901,6 +994,10 @@ export interface AssetState extends EffectivePeriod {
      * 빠뜨리면 회수 대상 수가 실제보다 많게 잡히고, 빈 팔레트 부족이 보이지 않는다.
      */
     effectivity?: Effectivity;
+    /** 그 시험들의 결과 — 사람과 같은 뜻(§TestResult). 검사에서 떨어진 팔레트는 배정에서 빠진다. */
+    testResults?: TestResult[];
+    /** 왜 지금 쓰일 수 없나 — 사람·설비와 **같은 판정**(§PersonState.capability). */
+    capability?: Capability;
 }
 /**
  * 작업 하나의 관측 상태 — **ISA-95 `SegmentResponse`**(Part 4, 실적).

package/dist/contract.js

@@ -517,6 +517,60 @@ export function offCalendarAt(r, ms, utcOffsetMinutes) {
     const h = Math.floor(minute / 60);
     return !(w.startHour <= w.endHour ? h >= w.startHour && h < w.endHour : h >= w.startHour || h < w.endHour);
 }
+/**
+ * 이 자원에게 **필수인 시험 목록** — 등급 상속을 타고 닫아 모은다.
+ *
+ * 요구는 등급이 말하고(`ResourceClassDef.testSpecificationIds`) 기록은 개체가 든다(`testResults`).
+ * 그 사이를 잇는 이 수집이 계약에 있는 이유: **두 구동이 같은 답을 내야 한다.** 시뮬과 미러가 각자
+ * 모으면 "이 사람에게 무엇이 필수인가" 가 갈리고, 같은 자원을 한쪽은 막고 다른 쪽은 통과시킨다.
+ */
+export function requiredTestsFor(directIds, defs, at) {
+    if (!defs?.length)
+        return [];
+    const closure = classClosure(directIds, defs, at);
+    const required = [];
+    for (const d of defs)
+        if (closure.has(d.id))
+            required.push(...(d.testSpecificationIds ?? []));
+    return required;
+}
+/**
+ * 자원의 **가용 능력을 판정한다** — 하나의 규칙, 하나의 자리.
+ *
+ * 부르는 쪽이 시각과 시간대를 준다(커널은 `now()`·`utcOffsetMinutes`, 호스트는 관측 시각). 주지 않으면
+ * 시각에 달린 판정(유효기간·교대·시험 만료)은 **하지 않는다** — 모르면 판단하지 않는다는 규율이다.
+ *
+ * `requiredTests` 는 부르는 쪽이 등급에서 모아 넘긴다(등급 정의를 아는 것은 부르는 쪽이다).
+ */
+export function capabilityOf(r, ctx) {
+    const at = ctx?.at;
+    /* 순서가 뜻이다 — "이미 모델 밖" 이 "고장" 보다 앞선다(폐기한 설비의 고장은 고칠 일이 아니다). */
+    const eff = effectivityAt(r, at);
+    if (eff === 'not-yet')
+        return { available: false, reason: 'not-yet' };
+    if (eff === 'expired')
+        return { available: false, reason: 'retired' };
+    if (r.held)
+        return { available: false, reason: 'held' };
+    if (r.status === 'down')
+        return { available: false, reason: 'down' };
+    if (at) {
+        const ms = Date.parse(at);
+        if (Number.isFinite(ms)) {
+            const why = offCalendarReasonAt(r, ms, ctx?.utcOffsetMinutes);
+            if (why === 'non-working')
+                return { available: false, reason: 'resting' };
+            if (why === 'off-hours')
+                return { available: false, reason: 'off-shift' };
+        }
+    }
+    /* 자격은 **결과가 선언됐을 때만** 제약이다(§meetsTests) — 없는 것으로 막으면 라인이 굶는다. */
+    if (ctx?.requiredTests?.length && !meetsTests(ctx.requiredTests, r.testResults, at))
+        return { available: false, reason: 'test-expired' };
+    if (r.status && r.status !== 'idle' && r.status !== 'available')
+        return { available: false, reason: 'working' };
+    return { available: true, reason: 'available' };
+}
 // ── 운영 델타(비-EPCIS) — State 채널의 나머지 절반 ──────────────────────────
 // EPCIS 이벤트는 재고/위치만 재구성 가능. tasks·equipment·orders 의 운영 상태는
 // 이 델타로 미러한다. envelope.eventType = 'task.status' | 'equipment.status' | 'order.status'.

package/dist/flow-engine.d.ts

@@ -56,6 +56,13 @@ export interface FlowAsset extends EffectivePeriod {
     properties?: ResourceProperty[];
     /** 적격을 검증한 시험 명세들 — 표준 `TestSpecificationID`. */
     testSpecificationIds?: string[];
+    /**
+     * 그 시험들의 **결과** — 자격이 성립하는지는 이것이 말한다(§TestResult).
+     *
+     * 사람에게만 두었다가 **설비·자산의 결과는 커널이 받아서 버렸다** — 선언은 들어오는데 자리가
+     * 없으니 배정 판정에서 아예 읽히지 않았다(검사에서 떨어진 도장 부스가 계속 배정됐다).
+     */
+    testResults?: TestResult[];
 }
 /** 사람 — 설비와 별개 자원(고장·OEE 가 아니라 등급·교대로 산다). */
 export interface FlowPerson extends EffectivePeriod {
@@ -96,6 +103,8 @@ export interface FlowEquipment extends EffectivePeriod {
     properties?: ResourceProperty[];
     /** 적격을 검증한 시험 명세들 — 표준 `TestSpecificationID`. */
     testSpecificationIds?: string[];
+    /** 그 시험들의 **결과** — 사람과 같은 뜻(§FlowAsset.testResults). 없으면 판정하지 않는다. */
+    testResults?: TestResult[];
     /** 교대(가동시간) — 지정 시 이 시간대에만 배정된다. 미지정=24시간 가용. */
     window?: {
         startHour: number;
@@ -809,7 +818,19 @@ export declare abstract class FlowEngine implements TwinKernel {
      * 판정 규칙은 계약이 소유한다(`meetsTests`) — 여기서 다시 적으면 규칙이 두 곳이 되고, 한쪽이 만료를
      * 조용히 통과시킨다.
      */
-    private qualifiedByTests;
+    /**
+     * 이 사람이 속한 등급들이 **요구하는 시험 목록** — 판정은 계약이 한다(`capabilityOf`).
+     *
+     * 상속을 타고 닫은 등급 전부의 요구를 모은다: 상위 등급이 요구하는 시험도 자격의 조건이다.
+     */
+    /**
+     * 자원 하나의 **가용 능력** — 계약의 판정에 이 커널의 시각·시간대·필수 시험을 채워 넘긴다.
+     *
+     * 배정도 스냅샷도 이 자리를 지난다. 예전에는 배정이 조건을 늘어놓고 화면이 플래그를 보고 짐작해서,
+     * **자격이 만료된 사람이 화면에서는 `대기` 로 보였다**(놀고 있는 것은 맞지만 쓸 수 있는 것은 아니다).
+     * 판정에 필요한 둘(시각·등급 상속)을 아는 것은 커널뿐이므로, 답도 커널이 낸다.
+     */
+    private capabilityOfResource;
     private claimPersonnel;
     /**
      * 필요 설비를 고른다 — **인원·자산과 같은 규칙**(등급으로 요구, 부분 확보 없이 전량 아니면 대기).

package/dist/flow-engine.js

@@ -9,7 +9,7 @@
  * 통합 타입은 도메인 필드를 옵셔널로 넓혀(FlowItem.gtin?, FlowOrder.shipmentEpc? 등) 두 도메인을 담는다.
  * (roadmap Phase5 발견 → 추출. [[project_flow_single_base_vision]] FlowLocation 단일 base 방향과 정합.)
  */
-import { OP_EVENT, CMD, locationStatusOf, readBoardEquipment, readBoardLocations, readBoardAssets, classClosure, meetsTests, priorityRank, dueStatusOf, effectivityAt, offCalendarAt, offCalendarReasonAt, minuteOfDayAt, activeShiftAt, subLotIdOf, itemKeyOf } from "./contract.js";
+import { OP_EVENT, CMD, locationStatusOf, readBoardEquipment, readBoardLocations, readBoardAssets, classClosure, capabilityOf, requiredTestsFor, priorityRank, dueStatusOf, effectivityAt, offCalendarAt, offCalendarReasonAt, minuteOfDayAt, activeShiftAt, subLotIdOf, itemKeyOf } from "./contract.js";
 import { ObservedReducer } from "./observed-reducer.js";
 import { transformationEvent, aggregationEvent, objectEvent, parseEpc, DISP, ILMD_ATTR, CBV_BIZSTEP } from "./epcis.js";
 import { parseIsoDuration } from "./iso-duration.js";
@@ -285,11 +285,11 @@ export class FlowEngine {
     }
     buildPerson(p) {
         return { id: p.id, personnelClassIds: p.personnelClassIds, status: 'idle', taskId: null, window: p.window, ...(p.workCalendar ? { workCalendar: p.workCalendar } : {}), ...(p.homeLocation ? { location: p.homeLocation } : {}), ...(p.properties ? { properties: p.properties } : {}),
-            ...(p.testResults ? { testResults: p.testResults } : {}), ...(p.testSpecificationIds ? { testSpecificationIds: p.testSpecificationIds } : {}), ...(p.testResults ? { testResults: p.testResults } : {}), ...effectiveOnly(p) };
+            ...(p.testSpecificationIds ? { testSpecificationIds: p.testSpecificationIds } : {}), ...(p.testResults ? { testResults: p.testResults } : {}), ...effectiveOnly(p) };
     }
     buildAsset(a) {
         return { id: a.id, assetClassIds: a.assetClassIds, location: a.homeLocation, status: 'idle', taskId: null, ...(a.properties ? { properties: a.properties } : {}),
-            ...(a.testResults ? { testResults: a.testResults } : {}), ...(a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {}), ...(a.testResults ? { testResults: a.testResults } : {}), ...effectiveOnly(a) };
+            ...(a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {}), ...(a.testResults ? { testResults: a.testResults } : {}), ...effectiveOnly(a) };
     }
     /**
      * 이 커널이 **관측으로 구동된다**고 선언한다 — 미러가 첫 이벤트를 받기 전에도 그렇다.
@@ -369,7 +369,7 @@ export class FlowEngine {
         };
     }
     buildEquipment(m) {
-        const eq = { id: m.id, kind: m.kind, location: m.homeLocation, homeLocation: m.homeLocation, ...(m.properties ? { properties: m.properties } : {}), ...(m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}), status: 'idle', taskId: null, runMs: 0, setupMs: 0, downMs: 0, goodCount: 0, scrapCount: 0, window: m.window, ...(m.workCalendar ? { workCalendar: m.workCalendar } : {}), ...effectiveOnly(m) };
+        const eq = { id: m.id, kind: m.kind, location: m.homeLocation, homeLocation: m.homeLocation, ...(m.properties ? { properties: m.properties } : {}), ...(m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}), ...(m.testResults ? { testResults: m.testResults } : {}), status: 'idle', taskId: null, runMs: 0, setupMs: 0, downMs: 0, goodCount: 0, scrapCount: 0, window: m.window, ...(m.workCalendar ? { workCalendar: m.workCalendar } : {}), ...effectiveOnly(m) };
         if (m.mtbfMs !== undefined) {
             eq.mtbfMs = m.mtbfMs;
             eq.mttrMs = m.mttrMs;
@@ -384,7 +384,7 @@ export class FlowEngine {
     addEquipment(m) {
         if (this.equipment.has(m.id))
             return;
-        const eq = { id: m.id, kind: m.kind, location: m.homeLocation, homeLocation: m.homeLocation, ...(m.properties ? { properties: m.properties } : {}), ...(m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}), status: 'idle', taskId: null, runMs: 0, setupMs: 0, downMs: 0, goodCount: 0, scrapCount: 0 };
+        const eq = { id: m.id, kind: m.kind, location: m.homeLocation, homeLocation: m.homeLocation, ...(m.properties ? { properties: m.properties } : {}), ...(m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}), ...(m.testResults ? { testResults: m.testResults } : {}), status: 'idle', taskId: null, runMs: 0, setupMs: 0, downMs: 0, goodCount: 0, scrapCount: 0 };
         if (m.mtbfMs !== undefined) {
             eq.mtbfMs = m.mtbfMs;
             eq.mttrMs = m.mttrMs;
@@ -469,6 +469,8 @@ export class FlowEngine {
                 /* 관측 스냅샷이 들고 있는 것은 관측을 따른다(미러가 보드에서 읽어 실어 온다). */
                 ...(m.properties ? { properties: m.properties } : {}),
                 ...(m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}),
+                /* 결과도 이어받는다 — 잃으면 예측이 **자격 만료를 모르는 현장**에서 출발한다(낙관 쪽으로 치우친다). */
+                ...(m.testResults ? { testResults: m.testResults } : {}),
                 ...effectiveOnly(m)
             });
         }
@@ -483,6 +485,8 @@ export class FlowEngine {
                 ...(p.location ? { location: p.location } : {}),
                 ...(p.properties ? { properties: p.properties } : {}),
                 ...(p.testSpecificationIds ? { testSpecificationIds: p.testSpecificationIds } : {}),
+                /* 결과도 이어받는다 — 잃으면 예측이 **자격 만료를 모르는 현장**에서 출발한다(낙관 쪽으로 치우친다). */
+                ...(p.testResults ? { testResults: p.testResults } : {}),
                 ...effectiveOnly(p)
             });
         }
@@ -494,6 +498,8 @@ export class FlowEngine {
                 id: a.id, assetClassIds: a.assetClassIds ?? prev?.assetClassIds, location: a.location, status: 'idle', taskId: null, carrying: a.carrying,
                 ...(a.properties ? { properties: a.properties } : {}),
                 ...(a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {}),
+                /* 결과도 이어받는다 — 잃으면 예측이 **자격 만료를 모르는 현장**에서 출발한다(낙관 쪽으로 치우친다). */
+                ...(a.testResults ? { testResults: a.testResults } : {}),
                 ...effectiveOnly(a)
             });
         }
@@ -812,7 +818,7 @@ export class FlowEngine {
             }),
             items: [...this.items.values()].map(i => this.itemState(i)),
             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 } : {}), origin: 'master', ...(this.offShift(m) ? { offShift: true, ...this.offReason(m) } : {}), ...this.effectivePart(m), ...(this.shiftOf(m) ? { shift: this.shiftOf(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) } : {}) };
                 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 };
@@ -826,7 +832,10 @@ export class FlowEngine {
                     st.properties = a.properties;
                 if (a.testSpecificationIds)
                     st.testSpecificationIds = a.testSpecificationIds;
+                if (a.testResults)
+                    st.testResults = a.testResults;
                 Object.assign(st, this.effectivePart(a));
+                st.capability = this.capabilityOfResource(a, a.assetClassIds, this.classDefs.asset);
                 return st;
             }),
             persons: [...this.persons.values()].map(p => {
@@ -837,6 +846,10 @@ export class FlowEngine {
                     st.properties = p.properties;
                 if (p.testSpecificationIds)
                     st.testSpecificationIds = p.testSpecificationIds;
+                /* 결과도 함께 낸다 — 참조만 보내면 소비처는 "무엇으로 검증하는가" 까지만 알고 "지금 유효한가" 를
+                   물을 수 없다(사실은 자기 집에서 나온다). 판정은 아래 `capability` 가 이미 답한다. */
+                if (p.testResults)
+                    st.testResults = p.testResults;
                 if (this.personOffShift(p)) {
                     st.offShift = true;
                     Object.assign(st, this.offReason(p));
@@ -845,6 +858,7 @@ export class FlowEngine {
                 if (sh)
                     st.shift = sh;
                 Object.assign(st, this.effectivePart(p));
+                st.capability = this.capabilityOfResource(p, p.personnelClassIds, this.classDefs.personnel);
                 return st;
             }),
             /* 스냅샷이 **델타보다 가난하면 안 된다** — 예전에는 소요·남은 시간을 빼고 내보내서, 이 스냅샷으로
@@ -1567,9 +1581,8 @@ export class FlowEngine {
                 continue;
             const avail = [...this.assets.values()].filter(
             /* 인원과 같은 규칙 — 상속을 타고 닫아 판정하고 유효기간 밖은 제외한다. 요구는 등급 하나+수량. */
-            a => a.status === 'idle' &&
+            a => this.capabilityOfResource(a, a.assetClassIds, this.classDefs.asset).available &&
                 !picked.includes(a.id) &&
-                !this.outOfEffect(a) && // 폐기한 팔레트는 풀에서 빠진다
                 (req.assetClass === undefined ||
                     classClosure(a.assetClassIds, this.classDefs.asset, this.now()).has(req.assetClass)));
             if (avail.length < want)
@@ -1854,16 +1867,24 @@ export class FlowEngine {
      * 판정 규칙은 계약이 소유한다(`meetsTests`) — 여기서 다시 적으면 규칙이 두 곳이 되고, 한쪽이 만료를
      * 조용히 통과시킨다.
      */
-    qualifiedByTests(p) {
-        const defs = this.classDefs.personnel;
-        if (!defs?.length)
-            return true;
-        const closure = classClosure(p.personnelClassIds, defs, this.now());
-        const required = [];
-        for (const d of defs)
-            if (closure.has(d.id))
-                required.push(...(d.testSpecificationIds ?? []));
-        return meetsTests(required, p.testResults, this.now());
+    /**
+     * 이 사람이 속한 등급들이 **요구하는 시험 목록** — 판정은 계약이 한다(`capabilityOf`).
+     *
+     * 상속을 타고 닫은 등급 전부의 요구를 모은다: 상위 등급이 요구하는 시험도 자격의 조건이다.
+     */
+    /**
+     * 자원 하나의 **가용 능력** — 계약의 판정에 이 커널의 시각·시간대·필수 시험을 채워 넘긴다.
+     *
+     * 배정도 스냅샷도 이 자리를 지난다. 예전에는 배정이 조건을 늘어놓고 화면이 플래그를 보고 짐작해서,
+     * **자격이 만료된 사람이 화면에서는 `대기` 로 보였다**(놀고 있는 것은 맞지만 쓸 수 있는 것은 아니다).
+     * 판정에 필요한 둘(시각·등급 상속)을 아는 것은 커널뿐이므로, 답도 커널이 낸다.
+     */
+    capabilityOfResource(r, directClassIds, defs) {
+        return capabilityOf(r, {
+            at: this.now(),
+            utcOffsetMinutes: this.boardDef?.utcOffsetMinutes,
+            requiredTests: requiredTestsFor(directClassIds, defs, this.now())
+        });
     }
     claimPersonnel(t) {
         const need = this.operationSpecs.get(t.kind)?.personnelSpecification;
@@ -1874,24 +1895,19 @@ export class FlowEngine {
             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) &&
-                !this.outOfEffect(p) && // 입사 전·퇴사 후는 이 시각의 모델에 없다
-                /* 자격은 **상속을 타고 닫아** 판정한다 — 사람은 여러 등급에 속할 수 있고(표준), 등급은
-                   다른 등급을 상속한다. "생산직 2명" 요구를 "용접 자격자" 가 만족해야 한다.
-                   유효기간 밖의 등급은 닫힘에서 빠진다(만료된 자격으로 배정되지 않는다). */
-                (req.personnelClass === undefined ||
-                    classClosure(p.personnelClassIds, this.classDefs.personnel, this.now()).has(req.personnelClass)) &&
+            const avail = [...this.persons.values()].filter(p => !picked.includes(p.id) &&
                 /*
-                 * **요구된 시험을 만족하나** — 등급이 요구하고(`testSpecificationIds`) 사람이 결과를 든다
-                 * (`testResults`). 만료·불합격이면 그 자격은 성립하지 않는다.
+                 * **판정은 한 벌이다**(`capabilityOf`). 예전에는 이 자리에 조건을 늘어놓았고 화면은 같은
+                 * 판정을 자기 코드로 다시 만들었다 — 규칙이 두 벌이면 갈라지고, 배정은 막는데 화면은
+                 * "가용" 이라 말하는 순간이 온다(그 어긋남은 조용하다).
                  *
-                 * 결과가 **아예 없으면 막지 않는다**: 없는 것으로 막으면 자격자가 전부 사라져 라인이 영구히
-                 * 굶고, 원본이 결과를 주지 않는 현장에서는 그 제약이 선언되지 않은 것이다("선언한 것만
-                 * 제약이 된다" — 이 커널의 규율).
+                 * 요구된 시험은 등급에서 모아 넘긴다 — 등급 정의를 아는 것은 이쪽이다.
                  */
-                this.qualifiedByTests(p));
+                this.capabilityOfResource(p, p.personnelClassIds, this.classDefs.personnel).available &&
+                /* 자격은 **상속을 타고 닫아** 판정한다 — 사람은 여러 등급에 속할 수 있고(표준), 등급은
+                   다른 등급을 상속한다. "생산직 2명" 요구를 "용접 자격자" 가 만족해야 한다. */
+                (req.personnelClass === undefined ||
+                    classClosure(p.personnelClassIds, this.classDefs.personnel, this.now()).has(req.personnelClass)));
             if (avail.length < want)
                 return null; // 한 등급이라도 모자라면 시작하지 않는다
             for (let i = 0; i < want; i++)
@@ -1905,10 +1921,10 @@ export class FlowEngine {
      * 여기서는 고르기만 한다 — 확정은 호출부가 다른 자원까지 확보한 뒤에 한다.
      */
     claimEquipment(t) {
-        const free = (kind, picked = []) => [...this.equipment.values()].filter(m => m.status === 'idle' &&
-            !m.held &&
-            !this.offShift(m) &&
-            !this.outOfEffect(m) && // 도입 전·폐기 후는 이 시각의 모델에 없다
+        const free = (kind, picked = []) => [...this.equipment.values()].filter(m => 
+        /* 사람과 **같은 판정**(§capabilityOfResource) — 예전에는 이 자리에 조건을 늘어놓아서
+           설비의 검사 결과는 배정에서 아예 읽히지 않았다(사람만 자격을 봤다). */
+        this.capabilityOfResource(m, m.kind ? [m.kind] : [], this.classDefs.equipment).available &&
             !picked.includes(m.id) &&
             /* 설비의 소속은 아직 단수(`kind`)다 — 저널에 기록이 쌓여 복수화를 별도 작업으로 두었다.
                다만 등급 정의가 있으면 **상속은 지금도 탄다**: 'welder-6axis' 가 'welder' 를 상속하면

package/dist/observed-reducer.d.ts

@@ -70,6 +70,13 @@ export declare class ObservedReducer {
      * 갈라진다(적합성 하네스가 `mirrorOnly` 로 잡는다). 이것은 **판정의 입력**이고, 나가는 것은 판정뿐이다.
      */
     private shifts;
+    /**
+     * 자원 **등급 정의** — 교대 선언과 같은 성격의 *판정 입력*이다(상태로 내보내지 않는다).
+     *
+     * 이것이 없으면 미러는 "이 사람에게 어떤 시험이 필수인가" 를 모른다. 시뮬은 막는데 미러는
+     * 통과시키는 어긋남이 생기고, 그 어긋남은 조용하다.
+     */
+    private classDefs;
     /** 시각 해석 기준(보드 선언) — 없으면 UTC. 캘린더의 `HH:MM` 이 어느 기준인지 정한다. */
     private utcOffsetMinutes?;
     constructor(board: TwinModelDef);
@@ -164,5 +171,12 @@ export declare class ObservedReducer {
     private offShiftPart;
     /** 유효 기간 밖이면 그 이유를 붙인다 — 미러의 시각 기준은 `observedAtMs`(마지막으로 들은 시점). */
     private effectivityPart;
+    /**
+     * **왜 지금 쓰일 수 없나** — 시뮬과 **같은 함수**로 낸다(`capabilityOf`).
+     *
+     * 델타로 받지 않고 여기서 파생하는 이유는 `effectivity`·`shift` 와 같다: 자격 만료와 교대 경계는
+     * **이벤트 없이 시각만으로** 넘어간다. 델타로 받아 두면 만료된 자격이 영원히 유효하게 남는다.
+     */
+    private capabilityPart;
     snapshot(): ProjectedState;
 }

package/dist/observed-reducer.js

@@ -19,7 +19,7 @@
  *  - 운영 델타(task/equipment/order.status) → tasks·equipment·orders (EPCIS 로 재구성 불가한 절반)
  * 마스터(로케이션)는 board 초기화 + applyMaster 로 갱신(마스터 동기).
  */
-import { OP_EVENT, locationStatusOf, readBoardEquipment, readBoardLocations, readBoardAssets, effectivityAt, offCalendarAt, offCalendarReasonAt, activeShiftAt } from "./contract.js";
+import { OP_EVENT, capabilityOf, requiredTestsFor, locationStatusOf, readBoardEquipment, readBoardLocations, readBoardAssets, effectivityAt, offCalendarAt, offCalendarReasonAt, activeShiftAt } from "./contract.js";
 import { ILMD_ATTR, parseEpc } from "./epcis.js";
 /**
  * 투영이 들고 있는 물품 — **계약(ItemState)을 축소하지 않는다.**
@@ -62,18 +62,26 @@ export class ObservedReducer {
      * 갈라진다(적합성 하네스가 `mirrorOnly` 로 잡는다). 이것은 **판정의 입력**이고, 나가는 것은 판정뿐이다.
      */
     shifts = new Map();
+    /**
+     * 자원 **등급 정의** — 교대 선언과 같은 성격의 *판정 입력*이다(상태로 내보내지 않는다).
+     *
+     * 이것이 없으면 미러는 "이 사람에게 어떤 시험이 필수인가" 를 모른다. 시뮬은 막는데 미러는
+     * 통과시키는 어긋남이 생기고, 그 어긋남은 조용하다.
+     */
+    classDefs = {};
     /** 시각 해석 기준(보드 선언) — 없으면 UTC. 캘린더의 `HH:MM` 이 어느 기준인지 정한다. */
     utcOffsetMinutes;
     constructor(board) {
         this.utcOffsetMinutes = board.utcOffsetMinutes;
+        this.classDefs = { personnel: board.personnelClasses, equipment: board.equipmentClasses, asset: board.assetClasses };
         for (const n of readBoardLocations(board))
             this.master.set(n.id, { id: n.id, type: n.type, capacity: n.capacity, parallelism: n.parallelism, parentId: n.parentId, origin: 'master' });
         // 설비 기준선(마스터) — equipment.status 델타로 갱신됨.
         for (const m of readBoardEquipment(board))
-            this.equipment.set(m.id, { id: m.id, kind: m.kind, status: 'idle', location: m.homeLocation, homeLocation: m.homeLocation, ...(m.properties ? { properties: m.properties } : {}), ...(m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}), ...effectiveOf(m), origin: 'master' });
+            this.equipment.set(m.id, { id: m.id, kind: m.kind, status: 'idle', location: m.homeLocation, homeLocation: m.homeLocation, ...(m.properties ? { properties: m.properties } : {}), ...(m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}), ...(m.testResults ? { testResults: m.testResults } : {}), ...effectiveOf(m), origin: 'master' });
         // 사람 기준선(마스터) — person.status 델타로 갱신됨.
         for (const p of board.persons ?? [])
-            this.persons.set(p.id, { id: p.id, personnelClassIds: p.personnelClassIds, status: 'idle', ...(p.homeLocation ? { location: p.homeLocation } : {}), ...(p.properties ? { properties: p.properties } : {}), ...(p.testSpecificationIds ? { testSpecificationIds: p.testSpecificationIds } : {}), ...effectiveOf(p) });
+            this.persons.set(p.id, { id: p.id, personnelClassIds: p.personnelClassIds, status: 'idle', ...(p.homeLocation ? { location: p.homeLocation } : {}), ...(p.properties ? { properties: p.properties } : {}), ...(p.testSpecificationIds ? { testSpecificationIds: p.testSpecificationIds } : {}), ...(p.testResults ? { testResults: p.testResults } : {}), ...effectiveOf(p) });
         /* 교대 선언은 **미러도 들고 있어야 한다** — 설비 델타에는 `offShift` 자리조차 없어서, 그것 없이는
            미러의 설비가 점심 휴게 중에도 "대기" 로 보였다. */
         for (const m of readBoardEquipment(board))
@@ -81,7 +89,7 @@ export class ObservedReducer {
         for (const p of board.persons ?? [])
             this.rememberShift(`person:${p.id}`, p);
         for (const a of readBoardAssets(board))
-            this.assets.set(a.id, { id: a.id, assetClassIds: a.assetClassIds, location: a.homeLocation, status: 'idle', ...(a.properties ? { properties: a.properties } : {}), ...(a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {}), ...effectiveOf(a) });
+            this.assets.set(a.id, { id: a.id, assetClassIds: a.assetClassIds, location: a.homeLocation, status: 'idle', ...(a.properties ? { properties: a.properties } : {}), ...(a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {}), ...(a.testResults ? { testResults: a.testResults } : {}), ...effectiveOf(a) });
     }
     /**
      * **구조를 갈아탄다** — 관측된 사실은 지키고 토폴로지만 새 선언으로 바꾼다.
@@ -138,17 +146,17 @@ export class ObservedReducer {
         const assetsDropped = dropMissing(this.assets, assets);
         for (const m of equipment) {
             if (!this.equipment.has(m.id))
-                this.equipment.set(m.id, { id: m.id, kind: m.kind, status: 'idle', location: m.homeLocation, homeLocation: m.homeLocation, ...(m.properties ? { properties: m.properties } : {}), ...(m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}), ...effectiveOf(m), origin: 'master' });
+                this.equipment.set(m.id, { id: m.id, kind: m.kind, status: 'idle', location: m.homeLocation, homeLocation: m.homeLocation, ...(m.properties ? { properties: m.properties } : {}), ...(m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}), ...(m.testResults ? { testResults: m.testResults } : {}), ...effectiveOf(m), origin: 'master' });
             this.rememberShift(`eq:${m.id}`, m);
         }
         for (const p of persons) {
             if (!this.persons.has(p.id))
-                this.persons.set(p.id, { id: p.id, personnelClassIds: p.personnelClassIds, status: 'idle', ...(p.homeLocation ? { location: p.homeLocation } : {}), ...(p.properties ? { properties: p.properties } : {}), ...(p.testSpecificationIds ? { testSpecificationIds: p.testSpecificationIds } : {}), ...effectiveOf(p) });
+                this.persons.set(p.id, { id: p.id, personnelClassIds: p.personnelClassIds, status: 'idle', ...(p.homeLocation ? { location: p.homeLocation } : {}), ...(p.properties ? { properties: p.properties } : {}), ...(p.testSpecificationIds ? { testSpecificationIds: p.testSpecificationIds } : {}), ...(p.testResults ? { testResults: p.testResults } : {}), ...effectiveOf(p) });
             this.rememberShift(`person:${p.id}`, p);
         }
         for (const a of assets)
             if (!this.assets.has(a.id))
-                this.assets.set(a.id, { id: a.id, assetClassIds: a.assetClassIds, location: a.homeLocation, status: 'idle', ...(a.properties ? { properties: a.properties } : {}), ...(a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {}), ...effectiveOf(a) });
+                this.assets.set(a.id, { id: a.id, assetClassIds: a.assetClassIds, location: a.homeLocation, status: 'idle', ...(a.properties ? { properties: a.properties } : {}), ...(a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {}), ...(a.testResults ? { testResults: a.testResults } : {}), ...effectiveOf(a) });
         return { locationsAdded, locationsDropped, equipmentDropped, personsDropped, assetsDropped };
     }
     /** 마스터 동기 — 로케이션 추가/변경/제거. */
@@ -571,6 +579,19 @@ export class ObservedReducer {
         const e = effectivityAt(r, new Date(this.observedAtMs).toISOString());
         return e ? { effectivity: e } : {};
     }
+    /**
+     * **왜 지금 쓰일 수 없나** — 시뮬과 **같은 함수**로 낸다(`capabilityOf`).
+     *
+     * 델타로 받지 않고 여기서 파생하는 이유는 `effectivity`·`shift` 와 같다: 자격 만료와 교대 경계는
+     * **이벤트 없이 시각만으로** 넘어간다. 델타로 받아 두면 만료된 자격이 영원히 유효하게 남는다.
+     */
+    capabilityPart(r, key, directClassIds, defs) {
+        const at = this.observedAtMs === undefined ? undefined : new Date(this.observedAtMs).toISOString();
+        const decl = this.shifts.get(key);
+        return {
+            capability: capabilityOf({ ...r, ...(decl?.window ? { window: decl.window } : {}), ...(decl?.workCalendar ? { workCalendar: decl.workCalendar } : {}) }, { at, utcOffsetMinutes: this.utcOffsetMinutes, requiredTests: requiredTestsFor(directClassIds, defs, at) })
+        };
+    }
     snapshot() {
         const occ = new Map();
         for (const it of this.items.values())
@@ -595,10 +616,10 @@ export class ObservedReducer {
             items: [...this.items.values()].map(i => ({ ...i })),
             /* 유효 기간 판정은 **저장하지 않고 여기서 낸다** — 시뮬과 **같은 함수**(`effectivityAt`)를 부른다.
                만료는 이벤트 없이 시각만으로 일어나므로, 델타로 받아 두면 유휴 자원이 영원히 유효하게 남는다. */
-            persons: [...this.persons.values()].map(p => ({ ...p, ...this.effectivityPart(p), ...this.offShiftPart(`person:${p.id}`) })),
-            assets: [...this.assets.values()].map(a => ({ ...a, ...this.effectivityPart(a) })),
+            persons: [...this.persons.values()].map(p => ({ ...p, ...this.effectivityPart(p), ...this.offShiftPart(`person:${p.id}`), ...this.capabilityPart(p, `person:${p.id}`, p.personnelClassIds, this.classDefs.personnel) })),
+            assets: [...this.assets.values()].map(a => ({ ...a, ...this.effectivityPart(a), ...this.capabilityPart(a, `asset:${a.id}`, a.assetClassIds, this.classDefs.asset) })),
             tasks: [...this.tasks.values()].map(t => ({ ...t })),
-            equipment: [...this.equipment.values()].map(m => ({ ...m, ...this.effectivityPart(m), ...this.offShiftPart(`eq:${m.id}`) })),
+            equipment: [...this.equipment.values()].map(m => ({ ...m, ...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 })),
             acked: [...this.acked]
         };

package/dist-cjs/index.cjs

@@ -73,6 +73,7 @@ __export(index_exports, {
   axisInfo: () => axisInfo,
   axisSource: () => axisSource,
   capabilitiesForType: () => capabilitiesForType,
+  capabilityOf: () => capabilityOf,
   classClosure: () => classClosure,
   compareStates: () => compareStates,
   computeOee: () => computeOee,
@@ -118,6 +119,7 @@ __export(index_exports, {
   relationsTo: () => relationsTo,
   replay: () => replay,
   replaySegments: () => replaySegments,
+  requiredTestsFor: () => requiredTestsFor,
   retiredVocabularyIn: () => retiredVocabularyIn,
   sgtinClass: () => sgtinClass,
   sgtinUri: () => sgtinUri,
@@ -409,6 +411,33 @@ function offCalendarAt(r, ms2, utcOffsetMinutes) {
   const h = Math.floor(minute / 60);
   return !(w.startHour <= w.endHour ? h >= w.startHour && h < w.endHour : h >= w.startHour || h < w.endHour);
 }
+function requiredTestsFor(directIds, defs, at) {
+  if (!defs?.length) return [];
+  const closure = classClosure(directIds, defs, at);
+  const required = [];
+  for (const d of defs) if (closure.has(d.id)) required.push(...d.testSpecificationIds ?? []);
+  return required;
+}
+function capabilityOf(r, ctx) {
+  const at = ctx?.at;
+  const eff = effectivityAt(r, at);
+  if (eff === "not-yet") return { available: false, reason: "not-yet" };
+  if (eff === "expired") return { available: false, reason: "retired" };
+  if (r.held) return { available: false, reason: "held" };
+  if (r.status === "down") return { available: false, reason: "down" };
+  if (at) {
+    const ms2 = Date.parse(at);
+    if (Number.isFinite(ms2)) {
+      const why = offCalendarReasonAt(r, ms2, ctx?.utcOffsetMinutes);
+      if (why === "non-working") return { available: false, reason: "resting" };
+      if (why === "off-hours") return { available: false, reason: "off-shift" };
+    }
+  }
+  if (ctx?.requiredTests?.length && !meetsTests(ctx.requiredTests, r.testResults, at))
+    return { available: false, reason: "test-expired" };
+  if (r.status && r.status !== "idle" && r.status !== "available") return { available: false, reason: "working" };
+  return { available: true, reason: "available" };
+}
 var OP_EVENT = {
   task: "task.status",
   equipment: "equipment.status",
@@ -954,16 +983,24 @@ var ObservedReducer = class {
    * 갈라진다(적합성 하네스가 `mirrorOnly` 로 잡는다). 이것은 **판정의 입력**이고, 나가는 것은 판정뿐이다.
    */
   shifts = /* @__PURE__ */ new Map();
+  /**
+   * 자원 **등급 정의** — 교대 선언과 같은 성격의 *판정 입력*이다(상태로 내보내지 않는다).
+   *
+   * 이것이 없으면 미러는 "이 사람에게 어떤 시험이 필수인가" 를 모른다. 시뮬은 막는데 미러는
+   * 통과시키는 어긋남이 생기고, 그 어긋남은 조용하다.
+   */
+  classDefs = {};
   /** 시각 해석 기준(보드 선언) — 없으면 UTC. 캘린더의 `HH:MM` 이 어느 기준인지 정한다. */
   utcOffsetMinutes;
   constructor(board) {
     this.utcOffsetMinutes = board.utcOffsetMinutes;
+    this.classDefs = { personnel: board.personnelClasses, equipment: board.equipmentClasses, asset: board.assetClasses };
     for (const n of readBoardLocations(board)) this.master.set(n.id, { id: n.id, type: n.type, capacity: n.capacity, parallelism: n.parallelism, parentId: n.parentId, origin: "master" });
-    for (const m of readBoardEquipment(board)) this.equipment.set(m.id, { id: m.id, kind: m.kind, status: "idle", location: m.homeLocation, homeLocation: m.homeLocation, ...m.properties ? { properties: m.properties } : {}, ...m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}, ...effectiveOf(m), origin: "master" });
-    for (const p of board.persons ?? []) this.persons.set(p.id, { id: p.id, personnelClassIds: p.personnelClassIds, status: "idle", ...p.homeLocation ? { location: p.homeLocation } : {}, ...p.properties ? { properties: p.properties } : {}, ...p.testSpecificationIds ? { testSpecificationIds: p.testSpecificationIds } : {}, ...effectiveOf(p) });
+    for (const m of readBoardEquipment(board)) this.equipment.set(m.id, { id: m.id, kind: m.kind, status: "idle", location: m.homeLocation, homeLocation: m.homeLocation, ...m.properties ? { properties: m.properties } : {}, ...m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}, ...m.testResults ? { testResults: m.testResults } : {}, ...effectiveOf(m), origin: "master" });
+    for (const p of board.persons ?? []) this.persons.set(p.id, { id: p.id, personnelClassIds: p.personnelClassIds, status: "idle", ...p.homeLocation ? { location: p.homeLocation } : {}, ...p.properties ? { properties: p.properties } : {}, ...p.testSpecificationIds ? { testSpecificationIds: p.testSpecificationIds } : {}, ...p.testResults ? { testResults: p.testResults } : {}, ...effectiveOf(p) });
     for (const m of readBoardEquipment(board)) this.rememberShift(`eq:${m.id}`, m);
     for (const p of board.persons ?? []) this.rememberShift(`person:${p.id}`, p);
-    for (const a of readBoardAssets(board)) this.assets.set(a.id, { id: a.id, assetClassIds: a.assetClassIds, location: a.homeLocation, status: "idle", ...a.properties ? { properties: a.properties } : {}, ...a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {}, ...effectiveOf(a) });
+    for (const a of readBoardAssets(board)) this.assets.set(a.id, { id: a.id, assetClassIds: a.assetClassIds, location: a.homeLocation, status: "idle", ...a.properties ? { properties: a.properties } : {}, ...a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {}, ...a.testResults ? { testResults: a.testResults } : {}, ...effectiveOf(a) });
   }
   /**
    * **구조를 갈아탄다** — 관측된 사실은 지키고 토폴로지만 새 선언으로 바꾼다.
@@ -1015,17 +1052,17 @@ var ObservedReducer = class {
     const assetsDropped = dropMissing(this.assets, assets);
     for (const m of equipment) {
       if (!this.equipment.has(m.id))
-        this.equipment.set(m.id, { id: m.id, kind: m.kind, status: "idle", location: m.homeLocation, homeLocation: m.homeLocation, ...m.properties ? { properties: m.properties } : {}, ...m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}, ...effectiveOf(m), origin: "master" });
+        this.equipment.set(m.id, { id: m.id, kind: m.kind, status: "idle", location: m.homeLocation, homeLocation: m.homeLocation, ...m.properties ? { properties: m.properties } : {}, ...m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}, ...m.testResults ? { testResults: m.testResults } : {}, ...effectiveOf(m), origin: "master" });
       this.rememberShift(`eq:${m.id}`, m);
     }
     for (const p of persons) {
       if (!this.persons.has(p.id))
-        this.persons.set(p.id, { id: p.id, personnelClassIds: p.personnelClassIds, status: "idle", ...p.homeLocation ? { location: p.homeLocation } : {}, ...p.properties ? { properties: p.properties } : {}, ...p.testSpecificationIds ? { testSpecificationIds: p.testSpecificationIds } : {}, ...effectiveOf(p) });
+        this.persons.set(p.id, { id: p.id, personnelClassIds: p.personnelClassIds, status: "idle", ...p.homeLocation ? { location: p.homeLocation } : {}, ...p.properties ? { properties: p.properties } : {}, ...p.testSpecificationIds ? { testSpecificationIds: p.testSpecificationIds } : {}, ...p.testResults ? { testResults: p.testResults } : {}, ...effectiveOf(p) });
       this.rememberShift(`person:${p.id}`, p);
     }
     for (const a of assets)
       if (!this.assets.has(a.id))
-        this.assets.set(a.id, { id: a.id, assetClassIds: a.assetClassIds, location: a.homeLocation, status: "idle", ...a.properties ? { properties: a.properties } : {}, ...a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {}, ...effectiveOf(a) });
+        this.assets.set(a.id, { id: a.id, assetClassIds: a.assetClassIds, location: a.homeLocation, status: "idle", ...a.properties ? { properties: a.properties } : {}, ...a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {}, ...a.testResults ? { testResults: a.testResults } : {}, ...effectiveOf(a) });
     return { locationsAdded, locationsDropped, equipmentDropped, personsDropped, assetsDropped };
   }
   /** 마스터 동기 — 로케이션 추가/변경/제거. */
@@ -1378,6 +1415,22 @@ var ObservedReducer = class {
     const e = effectivityAt(r, new Date(this.observedAtMs).toISOString());
     return e ? { effectivity: e } : {};
   }
+  /**
+   * **왜 지금 쓰일 수 없나** — 시뮬과 **같은 함수**로 낸다(`capabilityOf`).
+   *
+   * 델타로 받지 않고 여기서 파생하는 이유는 `effectivity`·`shift` 와 같다: 자격 만료와 교대 경계는
+   * **이벤트 없이 시각만으로** 넘어간다. 델타로 받아 두면 만료된 자격이 영원히 유효하게 남는다.
+   */
+  capabilityPart(r, key, directClassIds, defs) {
+    const at = this.observedAtMs === void 0 ? void 0 : new Date(this.observedAtMs).toISOString();
+    const decl = this.shifts.get(key);
+    return {
+      capability: capabilityOf(
+        { ...r, ...decl?.window ? { window: decl.window } : {}, ...decl?.workCalendar ? { workCalendar: decl.workCalendar } : {} },
+        { at, utcOffsetMinutes: this.utcOffsetMinutes, requiredTests: requiredTestsFor(directClassIds, defs, at) }
+      )
+    };
+  }
   snapshot() {
     const occ = /* @__PURE__ */ new Map();
     for (const it of this.items.values()) occ.set(it.location, (occ.get(it.location) ?? 0) + 1);
@@ -1403,10 +1456,10 @@ var ObservedReducer = class {
       items: [...this.items.values()].map((i) => ({ ...i })),
       /* 유효 기간 판정은 **저장하지 않고 여기서 낸다** — 시뮬과 **같은 함수**(`effectivityAt`)를 부른다.
          만료는 이벤트 없이 시각만으로 일어나므로, 델타로 받아 두면 유휴 자원이 영원히 유효하게 남는다. */
-      persons: [...this.persons.values()].map((p) => ({ ...p, ...this.effectivityPart(p), ...this.offShiftPart(`person:${p.id}`) })),
-      assets: [...this.assets.values()].map((a) => ({ ...a, ...this.effectivityPart(a) })),
+      persons: [...this.persons.values()].map((p) => ({ ...p, ...this.effectivityPart(p), ...this.offShiftPart(`person:${p.id}`), ...this.capabilityPart(p, `person:${p.id}`, p.personnelClassIds, this.classDefs.personnel) })),
+      assets: [...this.assets.values()].map((a) => ({ ...a, ...this.effectivityPart(a), ...this.capabilityPart(a, `asset:${a.id}`, a.assetClassIds, this.classDefs.asset) })),
       tasks: [...this.tasks.values()].map((t) => ({ ...t })),
-      equipment: [...this.equipment.values()].map((m) => ({ ...m, ...this.effectivityPart(m), ...this.offShiftPart(`eq:${m.id}`) })),
+      equipment: [...this.equipment.values()].map((m) => ({ ...m, ...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 })),
       acked: [...this.acked]
     };
@@ -2420,7 +2473,6 @@ var FlowEngine = class {
       ...p.workCalendar ? { workCalendar: p.workCalendar } : {},
       ...p.homeLocation ? { location: p.homeLocation } : {},
       ...p.properties ? { properties: p.properties } : {},
-      ...p.testResults ? { testResults: p.testResults } : {},
       ...p.testSpecificationIds ? { testSpecificationIds: p.testSpecificationIds } : {},
       ...p.testResults ? { testResults: p.testResults } : {},
       ...effectiveOnly(p)
@@ -2434,7 +2486,6 @@ var FlowEngine = class {
       status: "idle",
       taskId: null,
       ...a.properties ? { properties: a.properties } : {},
-      ...a.testResults ? { testResults: a.testResults } : {},
       ...a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {},
       ...a.testResults ? { testResults: a.testResults } : {},
       ...effectiveOnly(a)
@@ -2504,7 +2555,7 @@ var FlowEngine = class {
     };
   }
   buildEquipment(m) {
-    const eq = { id: m.id, kind: m.kind, location: m.homeLocation, homeLocation: m.homeLocation, ...m.properties ? { properties: m.properties } : {}, ...m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}, status: "idle", taskId: null, runMs: 0, setupMs: 0, downMs: 0, goodCount: 0, scrapCount: 0, window: m.window, ...m.workCalendar ? { workCalendar: m.workCalendar } : {}, ...effectiveOnly(m) };
+    const eq = { id: m.id, kind: m.kind, location: m.homeLocation, homeLocation: m.homeLocation, ...m.properties ? { properties: m.properties } : {}, ...m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}, ...m.testResults ? { testResults: m.testResults } : {}, status: "idle", taskId: null, runMs: 0, setupMs: 0, downMs: 0, goodCount: 0, scrapCount: 0, window: m.window, ...m.workCalendar ? { workCalendar: m.workCalendar } : {}, ...effectiveOnly(m) };
     if (m.mtbfMs !== void 0) {
       eq.mtbfMs = m.mtbfMs;
       eq.mttrMs = m.mttrMs;
@@ -2518,7 +2569,7 @@ var FlowEngine = class {
    */
   addEquipment(m) {
     if (this.equipment.has(m.id)) return;
-    const eq = { id: m.id, kind: m.kind, location: m.homeLocation, homeLocation: m.homeLocation, ...m.properties ? { properties: m.properties } : {}, ...m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}, status: "idle", taskId: null, runMs: 0, setupMs: 0, downMs: 0, goodCount: 0, scrapCount: 0 };
+    const eq = { id: m.id, kind: m.kind, location: m.homeLocation, homeLocation: m.homeLocation, ...m.properties ? { properties: m.properties } : {}, ...m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}, ...m.testResults ? { testResults: m.testResults } : {}, status: "idle", taskId: null, runMs: 0, setupMs: 0, downMs: 0, goodCount: 0, scrapCount: 0 };
     if (m.mtbfMs !== void 0) {
       eq.mtbfMs = m.mtbfMs;
       eq.mttrMs = m.mttrMs;
@@ -2594,6 +2645,8 @@ var FlowEngine = class {
         /* 관측 스냅샷이 들고 있는 것은 관측을 따른다(미러가 보드에서 읽어 실어 온다). */
         ...m.properties ? { properties: m.properties } : {},
         ...m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {},
+        /* 결과도 이어받는다 — 잃으면 예측이 **자격 만료를 모르는 현장**에서 출발한다(낙관 쪽으로 치우친다). */
+        ...m.testResults ? { testResults: m.testResults } : {},
         ...effectiveOnly(m)
       });
     }
@@ -2608,6 +2661,8 @@ var FlowEngine = class {
         ...p.location ? { location: p.location } : {},
         ...p.properties ? { properties: p.properties } : {},
         ...p.testSpecificationIds ? { testSpecificationIds: p.testSpecificationIds } : {},
+        /* 결과도 이어받는다 — 잃으면 예측이 **자격 만료를 모르는 현장**에서 출발한다(낙관 쪽으로 치우친다). */
+        ...p.testResults ? { testResults: p.testResults } : {},
         ...effectiveOnly(p)
       });
     }
@@ -2623,6 +2678,8 @@ var FlowEngine = class {
         carrying: a.carrying,
         ...a.properties ? { properties: a.properties } : {},
         ...a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {},
+        /* 결과도 이어받는다 — 잃으면 예측이 **자격 만료를 모르는 현장**에서 출발한다(낙관 쪽으로 치우친다). */
+        ...a.testResults ? { testResults: a.testResults } : {},
         ...effectiveOnly(a)
       });
     }
@@ -2908,7 +2965,7 @@ var FlowEngine = class {
       }),
       items: [...this.items.values()].map((i) => this.itemState(i)),
       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 } : {}, origin: "master", ...this.offShift(m) ? { offShift: true, ...this.offReason(m) } : {}, ...this.effectivePart(m), ...this.shiftOf(m) ? { shift: this.shiftOf(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) } : {} };
         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 };
         return s;
@@ -2918,7 +2975,9 @@ var FlowEngine = class {
         if (a.carrying) st.carrying = a.carrying;
         if (a.properties) st.properties = a.properties;
         if (a.testSpecificationIds) st.testSpecificationIds = a.testSpecificationIds;
+        if (a.testResults) st.testResults = a.testResults;
         Object.assign(st, this.effectivePart(a));
+        st.capability = this.capabilityOfResource(a, a.assetClassIds, this.classDefs.asset);
         return st;
       }),
       persons: [...this.persons.values()].map((p) => {
@@ -2926,6 +2985,7 @@ var FlowEngine = class {
         if (p.location) st.location = p.location;
         if (p.properties) st.properties = p.properties;
         if (p.testSpecificationIds) st.testSpecificationIds = p.testSpecificationIds;
+        if (p.testResults) st.testResults = p.testResults;
         if (this.personOffShift(p)) {
           st.offShift = true;
           Object.assign(st, this.offReason(p));
@@ -2933,6 +2993,7 @@ var FlowEngine = class {
         const sh = this.shiftOf(p);
         if (sh) st.shift = sh;
         Object.assign(st, this.effectivePart(p));
+        st.capability = this.capabilityOfResource(p, p.personnelClassIds, this.classDefs.personnel);
         return st;
       }),
       /* 스냅샷이 **델타보다 가난하면 안 된다** — 예전에는 소요·남은 시간을 빼고 내보내서, 이 스냅샷으로
@@ -3602,8 +3663,7 @@ var FlowEngine = class {
       if (!want) continue;
       const avail = [...this.assets.values()].filter(
         /* 인원과 같은 규칙 — 상속을 타고 닫아 판정하고 유효기간 밖은 제외한다. 요구는 등급 하나+수량. */
-        (a) => a.status === "idle" && !picked.includes(a.id) && !this.outOfEffect(a) && // 폐기한 팔레트는 풀에서 빠진다
-        (req.assetClass === void 0 || classClosure(a.assetClassIds, this.classDefs.asset, this.now()).has(req.assetClass))
+        (a) => this.capabilityOfResource(a, a.assetClassIds, this.classDefs.asset).available && !picked.includes(a.id) && (req.assetClass === void 0 || classClosure(a.assetClassIds, this.classDefs.asset, this.now()).has(req.assetClass))
       );
       if (avail.length < want) return null;
       for (let i = 0; i < want; i++) picked.push(avail[i].id);
@@ -3849,13 +3909,24 @@ var FlowEngine = class {
    * 판정 규칙은 계약이 소유한다(`meetsTests`) — 여기서 다시 적으면 규칙이 두 곳이 되고, 한쪽이 만료를
    * 조용히 통과시킨다.
    */
-  qualifiedByTests(p) {
-    const defs = this.classDefs.personnel;
-    if (!defs?.length) return true;
-    const closure = classClosure(p.personnelClassIds, defs, this.now());
-    const required = [];
-    for (const d of defs) if (closure.has(d.id)) required.push(...d.testSpecificationIds ?? []);
-    return meetsTests(required, p.testResults, this.now());
+  /**
+   * 이 사람이 속한 등급들이 **요구하는 시험 목록** — 판정은 계약이 한다(`capabilityOf`).
+   *
+   * 상속을 타고 닫은 등급 전부의 요구를 모은다: 상위 등급이 요구하는 시험도 자격의 조건이다.
+   */
+  /**
+   * 자원 하나의 **가용 능력** — 계약의 판정에 이 커널의 시각·시간대·필수 시험을 채워 넘긴다.
+   *
+   * 배정도 스냅샷도 이 자리를 지난다. 예전에는 배정이 조건을 늘어놓고 화면이 플래그를 보고 짐작해서,
+   * **자격이 만료된 사람이 화면에서는 `대기` 로 보였다**(놀고 있는 것은 맞지만 쓸 수 있는 것은 아니다).
+   * 판정에 필요한 둘(시각·등급 상속)을 아는 것은 커널뿐이므로, 답도 커널이 낸다.
+   */
+  capabilityOfResource(r, directClassIds, defs) {
+    return capabilityOf(r, {
+      at: this.now(),
+      utcOffsetMinutes: this.boardDef?.utcOffsetMinutes,
+      requiredTests: requiredTestsFor(directClassIds, defs, this.now())
+    });
   }
   claimPersonnel(t) {
     const need = this.operationSpecs.get(t.kind)?.personnelSpecification;
@@ -3865,19 +3936,16 @@ var FlowEngine = class {
       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) && !this.outOfEffect(p) && // 입사 전·퇴사 후는 이 시각의 모델에 없다
-        /* 자격은 **상속을 타고 닫아** 판정한다 — 사람은 여러 등급에 속할 수 있고(표준), 등급은
-           다른 등급을 상속한다. "생산직 2명" 요구를 "용접 자격자" 가 만족해야 한다.
-           유효기간 밖의 등급은 닫힘에서 빠진다(만료된 자격으로 배정되지 않는다). */
-        (req.personnelClass === void 0 || classClosure(p.personnelClassIds, this.classDefs.personnel, this.now()).has(req.personnelClass)) && /*
-         * **요구된 시험을 만족하나** — 등급이 요구하고(`testSpecificationIds`) 사람이 결과를 든다
-         * (`testResults`). 만료·불합격이면 그 자격은 성립하지 않는다.
+        (p) => !picked.includes(p.id) && /*
+         * **판정은 한 벌이다**(`capabilityOf`). 예전에는 이 자리에 조건을 늘어놓았고 화면은 같은
+         * 판정을 자기 코드로 다시 만들었다 — 규칙이 두 벌이면 갈라지고, 배정은 막는데 화면은
+         * "가용" 이라 말하는 순간이 온다(그 어긋남은 조용하다).
          *
-         * 결과가 **아예 없으면 막지 않는다**: 없는 것으로 막으면 자격자가 전부 사라져 라인이 영구히
-         * 굶고, 원본이 결과를 주지 않는 현장에서는 그 제약이 선언되지 않은 것이다("선언한 것만
-         * 제약이 된다" — 이 커널의 규율).
+         * 요구된 시험은 등급에서 모아 넘긴다 — 등급 정의를 아는 것은 이쪽이다.
          */
-        this.qualifiedByTests(p)
+        this.capabilityOfResource(p, p.personnelClassIds, this.classDefs.personnel).available && /* 자격은 **상속을 타고 닫아** 판정한다 — 사람은 여러 등급에 속할 수 있고(표준), 등급은
+           다른 등급을 상속한다. "생산직 2명" 요구를 "용접 자격자" 가 만족해야 한다. */
+        (req.personnelClass === void 0 || classClosure(p.personnelClassIds, this.classDefs.personnel, this.now()).has(req.personnelClass))
       );
       if (avail.length < want) return null;
       for (let i = 0; i < want; i++) picked.push(avail[i].id);
@@ -3891,11 +3959,14 @@ var FlowEngine = class {
    */
   claimEquipment(t) {
     const free = (kind, picked2 = []) => [...this.equipment.values()].filter(
-      (m) => m.status === "idle" && !m.held && !this.offShift(m) && !this.outOfEffect(m) && // 도입 전·폐기 후는 이 시각의 모델에 없다
-      !picked2.includes(m.id) && /* 설비의 소속은 아직 단수(`kind`)다 — 저널에 기록이 쌓여 복수화를 별도 작업으로 두었다.
-         다만 등급 정의가 있으면 **상속은 지금도 탄다**: 'welder-6axis' 가 'welder' 를 상속하면
-         'welder' 요구를 만족한다. 단수/복수와 상속은 다른 축이므로 하나를 기다리지 않는다. */
-      (kind === void 0 || classClosure(m.kind ? [m.kind] : [], this.classDefs.equipment, this.now()).has(kind))
+      (m) => (
+        /* 사람과 **같은 판정**(§capabilityOfResource) — 예전에는 이 자리에 조건을 늘어놓아서
+           설비의 검사 결과는 배정에서 아예 읽히지 않았다(사람만 자격을 봤다). */
+        this.capabilityOfResource(m, m.kind ? [m.kind] : [], this.classDefs.equipment).available && !picked2.includes(m.id) && /* 설비의 소속은 아직 단수(`kind`)다 — 저널에 기록이 쌓여 복수화를 별도 작업으로 두었다.
+           다만 등급 정의가 있으면 **상속은 지금도 탄다**: 'welder-6axis' 가 'welder' 를 상속하면
+           'welder' 요구를 만족한다. 단수/복수와 상속은 다른 축이므로 하나를 기다리지 않는다. */
+        (kind === void 0 || classClosure(m.kind ? [m.kind] : [], this.classDefs.equipment, this.now()).has(kind))
+      )
     );
     const need = this.operationSpecs.get(t.kind)?.equipmentSpecification;
     if (!need?.length) {
@@ -5159,6 +5230,7 @@ function retiredVocabularyIn(line) {
   axisInfo,
   axisSource,
   capabilitiesForType,
+  capabilityOf,
   classClosure,
   compareStates,
   computeOee,
@@ -5204,6 +5276,7 @@ function retiredVocabularyIn(line) {
   relationsTo,
   replay,
   replaySegments,
+  requiredTestsFor,
   retiredVocabularyIn,
   sgtinClass,
   sgtinUri,

package/package.json

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