@operato/twin-kernel 0.7.31 → 0.7.32

package/dist/contract.d.ts

@@ -1770,6 +1770,17 @@ export interface TaskStatusDelta {
     remainingMs?: number;
     /** 이 작업의 총 소요 예상(ms) — 진척의 분모. */
     durationMs?: number;
+    /**
+     * 품질 판정 결과 — **판정이 있었던 작업만** (2026-08-19).
+     *
+     * 왜 계약에 있나: 양품/불량은 설비 누적 카운터(종류를 모른다)와 EPCIS disposition(종류를 모른다)
+     * 에만 남아서, **「이 공정의 양품률이 얼마였나」를 저널에서 되짚을 수 없었다** — 재기동하면 종류별
+     * 품질 이력이 통째로 사라졌다. 판정이 일어나는 자리(작업 완료)에서 사실을 적는다.
+     *
+     * **없음은 「양품」이 아니라 「판정하지 않았다」**다(이동·체류에는 품질 판정이 없다). 그래서 소비처는
+     * 없는 것을 세지 않는다 — 모름을 양품으로 세면 양품률이 조용히 100% 로 올라간다.
+     */
+    outcome?: 'good' | 'scrap';
     /** 우선순위 — 나가지 않으면 미러가 배정 순서의 근거를 모른다(상태⊆이벤트). */
     priority?: number;
     startTime?: ISOTime;

package/dist/flow-engine.d.ts

@@ -174,6 +174,20 @@ export interface FlowTask {
      *   dwell:     자리에서 시간만 소비(무자원 체류·큐어링 — 즉시 진행, 자원 불요).
      */
     intent?: 'transport' | 'process' | 'dwell';
+    /**
+     * 이 작업의 **품질 판정 결과** — 판정이 있었을 때만 채운다 (2026-08-19).
+     *
+     * ── 왜 작업에 적나 ────────────────────────────────────────────────────────
+     * 양품/불량은 지금까지 두 곳에만 남았다: 설비 누적 카운터(`goodCount`·`scrapCount` — 종류를 모른다)와
+     * EPCIS disposition(`sellable`/`non_sellable` — 종류를 모른다). 그래서 **「이 공정의 양품률이 얼마였나」**
+     * 를 되짚을 방법이 저널에 없었다 — 재기동하면 종류별 품질 이력이 통째로 사라진다.
+     *
+     * 판정이 일어나는 자리는 작업 완료다(그때 종류·자원·결과를 함께 안다). 그러니 그 자리에서 적는다 —
+     * 나중에 자리·업무단계로 종류를 되짚는 추론을 만들지 않는다(설비 둘이 한 자리를 쓰면 조용히 틀린다).
+     *
+     * **없음은 「양품」이 아니라 「판정하지 않았다」**다(이동·체류에는 품질 판정이 없다).
+     */
+    outcome?: 'good' | 'scrap';
 }
 /** 오더 라인(멀티SKU) — 라인별 품목·잔량. 단일 SKU 오더 = 1 라인. */
 export interface OrderLine {
@@ -245,6 +259,17 @@ export declare const ATTENTION_DEFAULTS: {
  *
  * 이 값이 얹히는 대상은 **자리·설비가 아니라 공정 종류**다(`FlowTask.kind` = `OperationDef.key`).
  */
+/**
+ * 이력에서 배운 양품률 — 종류별 비율(0..1). **모르면 `undefined`**(0 을 답하지 않는다: 0 은 「전부 불량」이다).
+ *
+ * 소요시간 추정기와 같은 모양이다(무상태 시임, fork 가 참조를 공유). 표본이 모자란 종류는 추정기가
+ * 스스로 빼야 한다 — 두 건으로 만든 비율은 근거가 아니다.
+ */
+export interface YieldEstimator {
+    estimate(ctx: {
+        kind: string;
+    }): number | undefined;
+}
 export declare const OPERATION_PROPERTY: {
     /** 그 현장에서 이 공정이 걸리는 시간 — 실측이 없을 때 상수를 대신한다. */
     readonly duration: "operation.duration";
@@ -363,6 +388,13 @@ export declare abstract class FlowEngine implements TwinKernel {
     protected policy: AllocationPolicy;
     /** duration 시임(선택) — 미주입 시 명세, 명세도 없으면 도메인 상수. 이력 보정 추정기가 여기 들어온다. */
     durationEstimator?: DurationEstimator;
+    /**
+     * 양품률 시임(선택) — **이력에서 배운 수율.** 소요시간과 같은 자리·같은 규율이다 (2026-08-19).
+     *
+     * 없으면 선언값(현장→원천), 그것도 없으면 도메인 상수. 무엇을 썼는지는 `specCoverage()` 가 밝힌다.
+     * 주입은 호스트가 한다(저널을 접는 쪽이 이력을 안다) — 커널은 시임만 든다.
+     */
+    yieldEstimator?: YieldEstimator;
     /**
      * 오퍼레이션 명세(선택) — 작업 종류(`FlowTask.kind` = `OperationDef.key`) → 소요·변동·모수.
      * 도메인 정의에서 실어 온다(`loadOperations`). 없으면 커널 기본값을 쓰고 그 사실을 `specCoverage()` 가 밝힌다.
@@ -824,6 +856,16 @@ export declare abstract class FlowEngine implements TwinKernel {
     protected paramNumber(opKey: string, id: string): number | undefined;
     /** 명세 모수(기간) — ISO 8601 문자열을 밀리초로. 선언 없으면 undefined. */
     protected paramDuration(opKey: string, id: string): number | undefined;
+    /**
+     * 이 공정의 양품률 — **실측 > 현장 선언 > 원천 명세 > 도메인 상수** (2026-08-19).
+     *
+     * 소요시간(`durationOf`)과 같은 사다리다. 도메인 커널은 이 창구만 부르고 상수는 스스로 든다
+     * (`?? DEFAULT_YIELD`) — 상수를 쓴 사실은 `specCoverage()` 의 `parameterBasis` 가 밝힌다.
+     *
+     * 범위를 벗어난 실측은 쓰지 않는다: 비율이 아닌 값(0 미만·1 초과)은 이력 계산이 틀린 것이므로,
+     * 그것으로 시뮬을 굴리면 조용히 이상한 공장이 된다.
+     */
+    protected yieldOf(kind: string): number | undefined;
     /**
      * 모수 값 한 개 — **현장이 정한 것이 원천 명세를 이긴다**(소요시간과 같은 순서: ADR-0034).
      *
@@ -832,6 +874,12 @@ export declare abstract class FlowEngine implements TwinKernel {
      */
     private paramValue;
     private noteSpecUse;
+    /**
+     * 모수를 **무엇으로** 읽었나 — id 와 근거를 함께 적는다 (2026-08-19).
+     *
+     * 예전에는 id 만 세었다. 그래서 「수율을 읽었다」는 알 수 있어도 그것이 이력에서 배운 값인지 선언값인지
+     * 코드 상수인지 구별할 수 없었다 — 예측의 자격을 말하려면 그 구별이 필요하다(소요시간은 이미 구별한다).
+     */
     private noteParamUse;
     /**
      * 시뮬 명세 자기보고 — **어디까지 데이터로 말했고 어디부터 우리가 코드에 고정한 상수인가.**
@@ -845,6 +893,8 @@ export declare abstract class FlowEngine implements TwinKernel {
             duration: 'measured' | 'declared' | 'default';
             variability?: string;
             parameters: string[];
+            /** 그 모수를 무엇으로 읽었나(`id → measured|declared`) — 없는 id 는 상수를 썼다는 뜻이다. */
+            parameterBasis?: Record<string, 'measured' | 'declared'>;
         }[];
         /** 이력·계산에서 온 소요(추정기) — 선언값보다 강한 근거. */
         measuredDurations: number;

package/dist/flow-engine.js

@@ -12,6 +12,7 @@
 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 { OP_PARAM } from "./domain-definition.js";
 import { parseIsoDuration } from "./iso-duration.js";
 import { analyzeCapacity } from "./capacity.js";
 import { operationsCapabilityOf } from "./operations-capability.js";
@@ -67,14 +68,6 @@ export const ATTENTION_PROPERTY = {
 };
 /** 선언이 없을 때 쓰는 기본값 — **드러내 둔다**(코드 안에 숨은 상수가 아니라 계약의 일부다). */
 export const ATTENTION_DEFAULTS = { congestionPct: 90, scrapPct: 15, scrapMinSamples: 10 };
-/**
- * 공정에 선언할 수 있는 것의 **어휘** — 지금은 소요시간 하나다(`declareDurations` 가 읽는다).
- *
- * 자리·설비의 속성처럼 「속성 id」로 부른다: 선언을 받는 문·화면·AI 가 같은 이름을 써야 하고, 그 이름이
- * 두 곳에 적히면 한쪽만 바뀌는 순간 값이 조용히 버려진다.
- *
- * 이 값이 얹히는 대상은 **자리·설비가 아니라 공정 종류**다(`FlowTask.kind` = `OperationDef.key`).
- */
 export const OPERATION_PROPERTY = {
     /** 그 현장에서 이 공정이 걸리는 시간 — 실측이 없을 때 상수를 대신한다. */
     duration: 'operation.duration',
@@ -327,6 +320,13 @@ export class FlowEngine {
     policy;
     /** duration 시임(선택) — 미주입 시 명세, 명세도 없으면 도메인 상수. 이력 보정 추정기가 여기 들어온다. */
     durationEstimator;
+    /**
+     * 양품률 시임(선택) — **이력에서 배운 수율.** 소요시간과 같은 자리·같은 규율이다 (2026-08-19).
+     *
+     * 없으면 선언값(현장→원천), 그것도 없으면 도메인 상수. 무엇을 썼는지는 `specCoverage()` 가 밝힌다.
+     * 주입은 호스트가 한다(저널을 접는 쪽이 이력을 안다) — 커널은 시임만 든다.
+     */
+    yieldEstimator;
     /**
      * 오퍼레이션 명세(선택) — 작업 종류(`FlowTask.kind` = `OperationDef.key`) → 소요·변동·모수.
      * 도메인 정의에서 실어 온다(`loadOperations`). 없으면 커널 기본값을 쓰고 그 사실을 `specCoverage()` 가 밝힌다.
@@ -1245,7 +1245,10 @@ export class FlowEngine {
         clone.durationEstimator = this.durationEstimator; // 무상태 시임 — 참조 공유(policy 와 동형)
         /* 명세는 불변(정의) → 참조 공유. 사용 기록은 fork 자기 것(무엇을 기본값으로 굴렸는지 fork 별로 다르다). */
         clone.operationSpecs = this.operationSpecs;
-        clone.specUse = new Map([...this.specUse.entries()].map(([k, u]) => [k, { duration: u.duration, variability: u.variability, params: new Set(u.params) }]));
+        clone.specUse = new Map([...this.specUse.entries()].map(([k, u]) => [
+            k,
+            { duration: u.duration, variability: u.variability, params: new Set(u.params), paramBasis: new Map(u.paramBasis) }
+        ]));
         return clone;
     }
     /**
@@ -1725,6 +1728,23 @@ export class FlowEngine {
             this.noteParamUse(opKey, id);
         return ms;
     }
+    /**
+     * 이 공정의 양품률 — **실측 > 현장 선언 > 원천 명세 > 도메인 상수** (2026-08-19).
+     *
+     * 소요시간(`durationOf`)과 같은 사다리다. 도메인 커널은 이 창구만 부르고 상수는 스스로 든다
+     * (`?? DEFAULT_YIELD`) — 상수를 쓴 사실은 `specCoverage()` 의 `parameterBasis` 가 밝힌다.
+     *
+     * 범위를 벗어난 실측은 쓰지 않는다: 비율이 아닌 값(0 미만·1 초과)은 이력 계산이 틀린 것이므로,
+     * 그것으로 시뮬을 굴리면 조용히 이상한 공장이 된다.
+     */
+    yieldOf(kind) {
+        const measured = this.yieldEstimator?.estimate({ kind });
+        if (typeof measured === 'number' && measured >= 0 && measured <= 1) {
+            this.noteParamUse(kind, OP_PARAM.yield, 'measured');
+            return measured;
+        }
+        return this.paramNumber(kind, OP_PARAM.yield);
+    }
     /**
      * 모수 값 한 개 — **현장이 정한 것이 원천 명세를 이긴다**(소요시간과 같은 순서: ADR-0034).
      *
@@ -1745,14 +1765,22 @@ export class FlowEngine {
                 cur.variability = variability;
             return;
         }
-        this.specUse.set(kind, { duration, ...(variability ? { variability } : {}), params: new Set() });
+        this.specUse.set(kind, { duration, ...(variability ? { variability } : {}), params: new Set(), paramBasis: new Map() });
     }
-    noteParamUse(kind, id) {
+    /**
+     * 모수를 **무엇으로** 읽었나 — id 와 근거를 함께 적는다 (2026-08-19).
+     *
+     * 예전에는 id 만 세었다. 그래서 「수율을 읽었다」는 알 수 있어도 그것이 이력에서 배운 값인지 선언값인지
+     * 코드 상수인지 구별할 수 없었다 — 예측의 자격을 말하려면 그 구별이 필요하다(소요시간은 이미 구별한다).
+     */
+    noteParamUse(kind, id, basis = 'declared') {
         const cur = this.specUse.get(kind);
-        if (cur)
+        if (cur) {
             cur.params.add(id);
-        else
-            this.specUse.set(kind, { duration: 'default', params: new Set([id]) });
+            cur.paramBasis.set(id, basis);
+            return;
+        }
+        this.specUse.set(kind, { duration: 'default', params: new Set([id]), paramBasis: new Map([[id, basis]]) });
     }
     /**
      * 시뮬 명세 자기보고 — **어디까지 데이터로 말했고 어디부터 우리가 코드에 고정한 상수인가.**
@@ -1769,7 +1797,9 @@ export class FlowEngine {
                 kind,
                 duration: u.duration,
                 ...(variability ? { variability } : {}),
-                parameters: [...u.params].sort()
+                parameters: [...u.params].sort(),
+                /* 모수를 **무엇으로** 읽었나 — 읽은 것이 있을 때만 낸다(빈 표를 만들지 않는다). */
+                ...(u.paramBasis.size ? { parameterBasis: Object.fromEntries([...u.paramBasis.entries()].sort()) } : {})
             };
         });
         return {
@@ -2008,6 +2038,8 @@ export class FlowEngine {
             /* 실제 자재 이동 — 인원·설비와 같은 채널(실적을 한 곳에서 읽는다). */
             ...(t.materialActual?.length ? { materialActual: t.materialActual.map(r => ({ ...r })) } : {}),
             ...(t.durationMs ? { durationMs: t.durationMs } : {}),
+            /* 품질 판정이 있었으면 **그 자리에서** 실어 보낸다 — 없으면 필드를 만들지 않는다(모름≠양품). */
+            ...(t.outcome ? { outcome: t.outcome } : {}),
             ...(t.priority !== undefined ? { priority: t.priority } : {}),
             ...(t.startTime ? { startTime: t.startTime } : {}),
             ...(t.endTime ? { endTime: t.endTime } : {}),

package/dist/mes-kernel.js

@@ -229,7 +229,9 @@ export class MesKernel extends FlowEngine {
         // 마지막 스테이션(조립) → 완성차 (transform 1→1, disposition 으로 수율 loss → OEE 품질)
         const fgStore = this.locationByType('fg-store');
         const wip = order.allocated[0];
-        const good = this.rng() < (this.paramNumber(t.kind, OP_PARAM.yield) ?? DEFAULT_YIELD);
+        const good = this.rng() < (this.yieldOf(t.kind) ?? DEFAULT_YIELD);
+        /* 판정을 **작업에 적는다** — 그 자리에서 적어야 저널에 종류와 함께 남고, 이력에서 수율을 배울 수 있다. */
+        t.outcome = good ? 'good' : 'scrap';
         this.recordOutput(t.resource, good); // OEE 품질(마지막 자원별 양품/불량)
         const disp = good ? DISP.sellable : DISP.non_sellable;
         const outputEpc = sgtinUri(CP, product.ref, ++this.prodSeq);
@@ -352,7 +354,8 @@ export class MesKernel extends FlowEngine {
         }
         const fgStore = this.locationByType('fg-store');
         const wip = order.allocated[0];
-        const good = this.rng() < (this.paramNumber(t.kind, OP_PARAM.yield) ?? DEFAULT_YIELD);
+        const good = this.rng() < (this.yieldOf(t.kind) ?? DEFAULT_YIELD);
+        t.outcome = good ? 'good' : 'scrap'; // 같은 규율 — 판정은 일어난 자리에서 적는다
         this.recordOutput(t.resource, good);
         const disp = good ? DISP.sellable : DISP.non_sellable;
         const outEpc = this.serialOf(rc.outputs[0].material, ++this.prodSeq);

package/dist/task-fold.d.ts

@@ -23,6 +23,16 @@ export interface TaskFacets {
     order?: string;
     /** 가장 최근 도착 지점. 진행에 따라 바뀌므로 마지막 것이 사실이다. */
     location?: string;
+    /**
+     * 품질 판정 결과 — **판정이 있었을 때만** (2026-08-19).
+     *
+     * 이 축이 없으면 「이 공정의 양품률이 얼마였나」를 저널에서 되짚을 수 없다: 양품/불량은 설비 누적
+     * 카운터(종류 모름)와 EPCIS disposition(종류 모름)에만 남아 있었다. 판정은 작업 완료에서 일어나므로
+     * 그 자리에서 적고, 여기서 그대로 접는다.
+     *
+     * **없음은 「양품」이 아니라 「판정하지 않았다」**다(이동·체류에는 품질 판정이 없다).
+     */
+    outcome?: 'good' | 'scrap';
 }
 /** 작업 하나의 이정표 — 소비처가 이것으로 구간·지표를 만든다. */
 export interface TaskRecord {

package/dist/task-fold.js

@@ -46,6 +46,9 @@ export function foldTaskRecords(rows) {
             f.kind = d.kind;
         if (f.order === undefined && d.orderId)
             f.order = d.orderId;
+        /* 품질 판정은 완료 전이에 실려 온다 — 한 번 실린 값은 바뀌지 않는다(정정이 오면 마지막 것이 사실). */
+        if (d.outcome === 'good' || d.outcome === 'scrap')
+            f.outcome = d.outcome;
         const loc = d.toNode ?? d.fromNode;
         if (loc)
             f.location = loc;

package/dist-cjs/index.cjs

@@ -2630,6 +2630,7 @@ function foldTaskRecords(rows) {
     if (f.resource === void 0 && d.resourceRef) f.resource = d.resourceRef;
     if (f.kind === void 0 && d.kind) f.kind = d.kind;
     if (f.order === void 0 && d.orderId) f.order = d.orderId;
+    if (d.outcome === "good" || d.outcome === "scrap") f.outcome = d.outcome;
     const loc = d.toNode ?? d.fromNode;
     if (loc) f.location = loc;
     if (d.status === "created") rec.createdMs = at;
@@ -3172,6 +3173,13 @@ var FlowEngine = class {
   policy;
   /** duration 시임(선택) — 미주입 시 명세, 명세도 없으면 도메인 상수. 이력 보정 추정기가 여기 들어온다. */
   durationEstimator;
+  /**
+   * 양품률 시임(선택) — **이력에서 배운 수율.** 소요시간과 같은 자리·같은 규율이다 (2026-08-19).
+   *
+   * 없으면 선언값(현장→원천), 그것도 없으면 도메인 상수. 무엇을 썼는지는 `specCoverage()` 가 밝힌다.
+   * 주입은 호스트가 한다(저널을 접는 쪽이 이력을 안다) — 커널은 시임만 든다.
+   */
+  yieldEstimator;
   /**
    * 오퍼레이션 명세(선택) — 작업 종류(`FlowTask.kind` = `OperationDef.key`) → 소요·변동·모수.
    * 도메인 정의에서 실어 온다(`loadOperations`). 없으면 커널 기본값을 쓰고 그 사실을 `specCoverage()` 가 밝힌다.
@@ -4003,7 +4011,12 @@ var FlowEngine = class {
     clone.rng.state = this.rng.state;
     clone.durationEstimator = this.durationEstimator;
     clone.operationSpecs = this.operationSpecs;
-    clone.specUse = new Map([...this.specUse.entries()].map(([k, u]) => [k, { duration: u.duration, variability: u.variability, params: new Set(u.params) }]));
+    clone.specUse = new Map(
+      [...this.specUse.entries()].map(([k, u]) => [
+        k,
+        { duration: u.duration, variability: u.variability, params: new Set(u.params), paramBasis: new Map(u.paramBasis) }
+      ])
+    );
     return clone;
   }
   /**
@@ -4437,6 +4450,23 @@ var FlowEngine = class {
     if (ms2 !== void 0) this.noteParamUse(opKey, id);
     return ms2;
   }
+  /**
+   * 이 공정의 양품률 — **실측 > 현장 선언 > 원천 명세 > 도메인 상수** (2026-08-19).
+   *
+   * 소요시간(`durationOf`)과 같은 사다리다. 도메인 커널은 이 창구만 부르고 상수는 스스로 든다
+   * (`?? DEFAULT_YIELD`) — 상수를 쓴 사실은 `specCoverage()` 의 `parameterBasis` 가 밝힌다.
+   *
+   * 범위를 벗어난 실측은 쓰지 않는다: 비율이 아닌 값(0 미만·1 초과)은 이력 계산이 틀린 것이므로,
+   * 그것으로 시뮬을 굴리면 조용히 이상한 공장이 된다.
+   */
+  yieldOf(kind) {
+    const measured = this.yieldEstimator?.estimate({ kind });
+    if (typeof measured === "number" && measured >= 0 && measured <= 1) {
+      this.noteParamUse(kind, OP_PARAM.yield, "measured");
+      return measured;
+    }
+    return this.paramNumber(kind, OP_PARAM.yield);
+  }
   /**
    * 모수 값 한 개 — **현장이 정한 것이 원천 명세를 이긴다**(소요시간과 같은 순서: ADR-0034).
    *
@@ -4455,12 +4485,22 @@ var FlowEngine = class {
       if (variability) cur.variability = variability;
       return;
     }
-    this.specUse.set(kind, { duration, ...variability ? { variability } : {}, params: /* @__PURE__ */ new Set() });
+    this.specUse.set(kind, { duration, ...variability ? { variability } : {}, params: /* @__PURE__ */ new Set(), paramBasis: /* @__PURE__ */ new Map() });
   }
-  noteParamUse(kind, id) {
+  /**
+   * 모수를 **무엇으로** 읽었나 — id 와 근거를 함께 적는다 (2026-08-19).
+   *
+   * 예전에는 id 만 세었다. 그래서 「수율을 읽었다」는 알 수 있어도 그것이 이력에서 배운 값인지 선언값인지
+   * 코드 상수인지 구별할 수 없었다 — 예측의 자격을 말하려면 그 구별이 필요하다(소요시간은 이미 구별한다).
+   */
+  noteParamUse(kind, id, basis = "declared") {
     const cur = this.specUse.get(kind);
-    if (cur) cur.params.add(id);
-    else this.specUse.set(kind, { duration: "default", params: /* @__PURE__ */ new Set([id]) });
+    if (cur) {
+      cur.params.add(id);
+      cur.paramBasis.set(id, basis);
+      return;
+    }
+    this.specUse.set(kind, { duration: "default", params: /* @__PURE__ */ new Set([id]), paramBasis: /* @__PURE__ */ new Map([[id, basis]]) });
   }
   /**
    * 시뮬 명세 자기보고 — **어디까지 데이터로 말했고 어디부터 우리가 코드에 고정한 상수인가.**
@@ -4476,7 +4516,9 @@ var FlowEngine = class {
         kind,
         duration: u.duration,
         ...variability ? { variability } : {},
-        parameters: [...u.params].sort()
+        parameters: [...u.params].sort(),
+        /* 모수를 **무엇으로** 읽었나 — 읽은 것이 있을 때만 낸다(빈 표를 만들지 않는다). */
+        ...u.paramBasis.size ? { parameterBasis: Object.fromEntries([...u.paramBasis.entries()].sort()) } : {}
       };
     });
     return {
@@ -4701,6 +4743,8 @@ var FlowEngine = class {
       /* 실제 자재 이동 — 인원·설비와 같은 채널(실적을 한 곳에서 읽는다). */
       ...t.materialActual?.length ? { materialActual: t.materialActual.map((r) => ({ ...r })) } : {},
       ...t.durationMs ? { durationMs: t.durationMs } : {},
+      /* 품질 판정이 있었으면 **그 자리에서** 실어 보낸다 — 없으면 필드를 만들지 않는다(모름≠양품). */
+      ...t.outcome ? { outcome: t.outcome } : {},
       ...t.priority !== void 0 ? { priority: t.priority } : {},
       ...t.startTime ? { startTime: t.startTime } : {},
       ...t.endTime ? { endTime: t.endTime } : {},
@@ -6163,7 +6207,8 @@ var MesKernel = class extends FlowEngine {
     }
     const fgStore = this.locationByType("fg-store");
     const wip = order.allocated[0];
-    const good = this.rng() < (this.paramNumber(t.kind, OP_PARAM.yield) ?? DEFAULT_YIELD);
+    const good = this.rng() < (this.yieldOf(t.kind) ?? DEFAULT_YIELD);
+    t.outcome = good ? "good" : "scrap";
     this.recordOutput(t.resource, good);
     const disp = good ? DISP.sellable : DISP.non_sellable;
     const outputEpc = sgtinUri(CP2, product.ref, ++this.prodSeq);
@@ -6275,7 +6320,8 @@ var MesKernel = class extends FlowEngine {
     }
     const fgStore = this.locationByType("fg-store");
     const wip = order.allocated[0];
-    const good = this.rng() < (this.paramNumber(t.kind, OP_PARAM.yield) ?? DEFAULT_YIELD);
+    const good = this.rng() < (this.yieldOf(t.kind) ?? DEFAULT_YIELD);
+    t.outcome = good ? "good" : "scrap";
     this.recordOutput(t.resource, good);
     const disp = good ? DISP.sellable : DISP.non_sellable;
     const outEpc = this.serialOf(rc.outputs[0].material, ++this.prodSeq);

package/package.json

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