@things-factory/headless-twin 10.0.5 → 10.0.7

package/dist-server/engine/kpi-target.d.ts

@@ -0,0 +1,141 @@
+import type { KpiResult } from './kpi-fold.js';
+/**
+ * 지표 어휘 — **이름을 한 곳에서 정한다.**
+ *
+ * 목표와 사실이 서로 다른 이름을 쓰면 그 사이에 매핑 표가 생기고, 그 표가 곧 방언이 된다. 그래서
+ * 목표가 가리킬 수 있는 지표는 여기 열거된 것뿐이고, 값을 꺼내는 방법도 여기 함께 있다.
+ *
+ * **`direction` 은 지표의 성질이지 사용자의 선택이 아니다.** 처리량은 높을수록 좋고 대기시간은 낮을수록
+ * 좋다 — 이것을 입력으로 받으면 반대로 적은 목표가 만들어지고, 그 뒤 판정이 전부 뒤집힌다.
+ */
+export declare const TWIN_METRIC: {
+    readonly 'throughput.tasks': {
+        readonly direction: "higher";
+        readonly unit: "count";
+        readonly of: (k: KpiResult) => number;
+    };
+    readonly 'throughput.orders': {
+        readonly direction: "higher";
+        readonly unit: "count";
+        readonly of: (k: KpiResult) => number;
+    };
+    readonly 'leadTime.p50Ms': {
+        readonly direction: "lower";
+        readonly unit: "ms";
+        readonly of: (k: KpiResult) => number;
+    };
+    readonly 'leadTime.p90Ms': {
+        readonly direction: "lower";
+        readonly unit: "ms";
+        readonly of: (k: KpiResult) => number;
+    };
+    readonly 'workTime.p50Ms': {
+        readonly direction: "lower";
+        readonly unit: "ms";
+        readonly of: (k: KpiResult) => number;
+    };
+    readonly 'waitTime.p50Ms': {
+        readonly direction: "lower";
+        readonly unit: "ms";
+        readonly of: (k: KpiResult) => number;
+    };
+    /** 자원 점유 — 개별 자원이 아니라 **창 전체의 평균 비율**(자원별은 관점 축의 일이다). */
+    readonly 'utilization.ratio': {
+        readonly direction: "higher";
+        readonly unit: "ratio";
+        readonly of: (k: KpiResult) => number;
+    };
+};
+export type TwinMetricId = keyof typeof TWIN_METRIC;
+export declare const isTwinMetric: (id: string) => id is TwinMetricId;
+/**
+ * 저장된 목표 행에서 **이 범위에 걸린 목표**를 고른다 — 좁은 선언이 넓은 선언을 덮는다.
+ *
+ * **왜 순수 함수인가**: 이 규칙(공간 목표 위에 인스턴스 목표를 얹는다)은 지금까지 DB 접근 뒤에 숨어
+ * 있어서 **화면을 눌러 봐야만** 확인할 수 있었다. 그런데 이 프로젝트는 로그인 뒤 화면을 자동으로
+ * 검증할 방법이 없어, 실제로 여러 기능이 "실화면 미검증" 으로 쌓였다. 규칙을 밖으로 빼면 테스트가
+ * 값싸진다 — 조회는 행을 가져오기만 하고, **판단은 여기서** 한다.
+ */
+/**
+ * 축 목표까지 담은 목록 — 전체 목표와 **축의 한 값**에 걸린 목표를 함께 든다.
+ *
+ * 축 목표는 전체 목표를 **덮지 않는다.** 다른 질문이기 때문이다: "현장 전체가 100건" 과
+ * "용접 구역이 30건" 은 동시에 참일 수 있다. 덮게 만들면 축 하나에 목표를 거는 순간 전체 판정이
+ * 사라져 사용자가 "목표를 지웠나?" 를 묻게 된다.
+ */
+export interface ScopedTargets {
+    /** 창 전체에 걸린 목표. */
+    overall: TwinTargetSpec[];
+    /** 축 → (그 축의 값 → 목표들). 요청한 축만 채운다. */
+    byAxisKey: Record<string, TwinTargetSpec[]>;
+}
+/**
+ * 축의 각 값에 대해 목표 대비 판정 — **그룹 항목에 그대로 붙일 형태.**
+ *
+ * 그룹의 지표는 전체보다 좁다(주문 수·자원 점유는 축 단위로 뜻이 다르거나 없다). 없는 지표에 목표가
+ * 걸려 있으면 **판정하지 않는다** — 여기서 0 으로 읽으면 시간 지표가 "완벽 달성" 으로 뒤집힌다
+ * (전체 판정에서 이미 겪은 결함이다).
+ */
+export declare function judgeGroupTargets(group: {
+    key: string;
+    tasks: number;
+    leadTime: {
+        count: number;
+        p50Ms: number;
+    };
+    workTime: {
+        count: number;
+        p50Ms: number;
+    };
+    waitTime: {
+        count: number;
+        p50Ms: number;
+    };
+}, targets: readonly TwinTargetSpec[] | undefined): TargetVerdict[];
+export declare function mergeTargets(rows: readonly TargetRow[], scope: {
+    spaceId?: string;
+    instanceIds: readonly string[];
+    axis?: string;
+}): TwinTargetSpec[];
+/** 저장된 목표 행 — 판단에 필요한 것만(엔티티 전체를 요구하지 않는다: 테스트가 값싸진다). */
+export interface TargetRow {
+    metric: string;
+    target: number;
+    spaceId?: string | null;
+    instanceId?: string | null;
+    axis?: string | null;
+    axisKey?: string | null;
+}
+/** 전체 목표와 축 목표를 함께 고른다 — 좁은 선언(인스턴스)이 넓은 선언(공간)을 덮는 규칙은 양쪽 같다. */
+export declare function scopedTargets(rows: readonly TargetRow[], scope: {
+    spaceId?: string;
+    instanceIds: readonly string[];
+    axis?: string;
+}): ScopedTargets;
+/** 목표 하나 — 어느 지표를, 얼마로. 방향은 지표가 안다(§TWIN_METRIC). */
+export interface TwinTargetSpec {
+    metric: TwinMetricId;
+    target: number;
+}
+export interface TargetVerdict {
+    metric: TwinMetricId;
+    /** 이 구간의 실제 값. */
+    actual: number;
+    target: number;
+    direction: 'higher' | 'lower';
+    /** 목표를 만족했나. */
+    met: boolean;
+    /**
+     * 목표 대비 비율 — **항상 "1 이상이면 좋다"** 로 정규화한다(방향이 다른 지표를 한 화면에서 비교할 수
+     * 있게). 처리량은 `actual/target`, 시간은 `target/actual`.
+     */
+    ratio: number;
+}
+/**
+ * 목표 대비 판정 — **목표가 없는 지표는 판정하지 않는다.**
+ *
+ * 값이 없는 지표(그 구간에 기록이 없어 `undefined`)도 판정하지 않는다. 없는 것을 0 으로 놓으면
+ * "목표 크게 미달" 이라는 **없는 사실**이 만들어지고, 사용자는 멈춘 적 없는 라인을 고치러 간다.
+ * 목표를 0 으로 준 경우도 비율을 내지 않는다(0 으로 나누지 않는다) — 만족 여부만 답한다.
+ */
+export declare function judgeTargets(kpi: KpiResult, targets: readonly TwinTargetSpec[] | undefined): TargetVerdict[];

package/dist-server/engine/kpi-target.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTwinMetric = exports.TWIN_METRIC = void 0;
+exports.judgeGroupTargets = judgeGroupTargets;
+exports.mergeTargets = mergeTargets;
+exports.scopedTargets = scopedTargets;
+exports.judgeTargets = judgeTargets;
+/** 측정된 기록이 있을 때만 값으로 인정한다 — 없으면 모름(0 이 아니다). */
+const measured = (k, v) => (k.eventsInWindow > 0 ? v : undefined);
+/** 분위수는 표본이 있을 때만 값이다 — `count === 0` 의 `p50Ms: 0` 은 "0 밀리초" 가 아니라 "없음" 이다. */
+const statOf = (s, pick) => s.count > 0 ? pick(s) : undefined;
+/**
+ * 지표 어휘 — **이름을 한 곳에서 정한다.**
+ *
+ * 목표와 사실이 서로 다른 이름을 쓰면 그 사이에 매핑 표가 생기고, 그 표가 곧 방언이 된다. 그래서
+ * 목표가 가리킬 수 있는 지표는 여기 열거된 것뿐이고, 값을 꺼내는 방법도 여기 함께 있다.
+ *
+ * **`direction` 은 지표의 성질이지 사용자의 선택이 아니다.** 처리량은 높을수록 좋고 대기시간은 낮을수록
+ * 좋다 — 이것을 입력으로 받으면 반대로 적은 목표가 만들어지고, 그 뒤 판정이 전부 뒤집힌다.
+ */
+exports.TWIN_METRIC = {
+    /* 기록이 없는 구간은 처리량 0 이 아니라 **모름**이다 — `eventsInWindow` 가 그것을 가른다.
+       0 으로 판정하면 "측정 못 한 구간" 이 "일을 안 한 구간" 으로 보고된다. */
+    'throughput.tasks': { direction: 'higher', unit: 'count', of: (k) => measured(k, k.throughput.tasks) },
+    'throughput.orders': { direction: 'higher', unit: 'count', of: (k) => measured(k, k.throughput.orders) },
+    /* 소요시간 분위수는 `count === 0` 이면 **0 이 아니라 없다.** 이것을 0 으로 읽으면 시간 지표는
+       "낮을수록 좋다" 라서 **일이 없던 구간이 목표를 완벽히 달성한 것으로** 보고된다 — 미달을 놓치는
+       것보다 나쁘다(고칠 곳이 있는데 잘하고 있다고 말한다). 테스트가 이것을 잡았다. */
+    'leadTime.p50Ms': { direction: 'lower', unit: 'ms', of: (k) => statOf(k.leadTime, d => d.p50Ms) },
+    'leadTime.p90Ms': { direction: 'lower', unit: 'ms', of: (k) => statOf(k.leadTime, d => d.p90Ms) },
+    'workTime.p50Ms': { direction: 'lower', unit: 'ms', of: (k) => statOf(k.workTime, d => d.p50Ms) },
+    'waitTime.p50Ms': { direction: 'lower', unit: 'ms', of: (k) => statOf(k.waitTime, d => d.p50Ms) },
+    /** 자원 점유 — 개별 자원이 아니라 **창 전체의 평균 비율**(자원별은 관점 축의 일이다). */
+    'utilization.ratio': {
+        direction: 'higher',
+        unit: 'ratio',
+        of: (k) => k.utilization.length ? k.utilization.reduce((s, u) => s + u.ratio, 0) / k.utilization.length : undefined
+    }
+};
+const isTwinMetric = (id) => id in exports.TWIN_METRIC;
+exports.isTwinMetric = isTwinMetric;
+/**
+ * 축의 각 값에 대해 목표 대비 판정 — **그룹 항목에 그대로 붙일 형태.**
+ *
+ * 그룹의 지표는 전체보다 좁다(주문 수·자원 점유는 축 단위로 뜻이 다르거나 없다). 없는 지표에 목표가
+ * 걸려 있으면 **판정하지 않는다** — 여기서 0 으로 읽으면 시간 지표가 "완벽 달성" 으로 뒤집힌다
+ * (전체 판정에서 이미 겪은 결함이다).
+ */
+function judgeGroupTargets(group, targets) {
+    const value = (metric) => {
+        switch (metric) {
+            case 'throughput.tasks':
+                return group.tasks;
+            case 'leadTime.p50Ms':
+                return group.leadTime.count > 0 ? group.leadTime.p50Ms : undefined;
+            case 'workTime.p50Ms':
+                return group.workTime.count > 0 ? group.workTime.p50Ms : undefined;
+            case 'waitTime.p50Ms':
+                return group.waitTime.count > 0 ? group.waitTime.p50Ms : undefined;
+            default:
+                return undefined; // 축 단위로 뜻이 없는 지표(주문 수·자원 점유) — 지어내지 않는다
+        }
+    };
+    const out = [];
+    for (const t of targets ?? []) {
+        const spec = exports.TWIN_METRIC[t.metric];
+        const actual = value(t.metric);
+        if (!spec || typeof actual !== 'number' || !Number.isFinite(actual) || !Number.isFinite(t.target))
+            continue;
+        out.push(verdictOf(t.metric, actual, t.target, spec.direction));
+    }
+    return out;
+}
+function mergeTargets(rows, scope) {
+    return scopedTargets(rows, scope).overall;
+}
+/** 전체 목표와 축 목표를 함께 고른다 — 좁은 선언(인스턴스)이 넓은 선언(공간)을 덮는 규칙은 양쪽 같다. */
+function scopedTargets(rows, scope) {
+    /* 같은 자리(지표 또는 축값+지표)에 공간·인스턴스 목표가 함께 있으면 인스턴스가 이긴다. */
+    const pick = new Map();
+    for (const r of rows) {
+        if (!(0, exports.isTwinMetric)(r.metric) || typeof r.target !== 'number' || !Number.isFinite(r.target))
+            continue;
+        const inSpace = !!scope.spaceId && r.spaceId === scope.spaceId;
+        const inInstance = !!r.instanceId && scope.instanceIds.includes(r.instanceId);
+        if (!inSpace && !inInstance)
+            continue;
+        if (r.axis) {
+            if (!scope.axis || r.axis !== scope.axis || !r.axisKey)
+                continue; // 지금 보는 축만
+        }
+        const slot = `${r.axis ?? ''}\u0000${r.axisKey ?? ''}\u0000${r.metric}`;
+        const prev = pick.get(slot);
+        if (prev?.fromInstance && !inInstance)
+            continue; // 인스턴스 선언을 공간 선언이 덮지 않는다
+        pick.set(slot, { target: r.target, fromInstance: inInstance, axisKey: r.axisKey ?? undefined, metric: r.metric });
+    }
+    const overall = [];
+    const byAxisKey = {};
+    for (const [slot, v] of pick) {
+        const spec = { metric: v.metric, target: v.target };
+        if (slot.startsWith('\u0000'))
+            overall.push(spec);
+        else
+            (byAxisKey[v.axisKey] ??= []).push(spec);
+    }
+    return { overall, byAxisKey };
+}
+/**
+ * 목표 대비 판정 — **목표가 없는 지표는 판정하지 않는다.**
+ *
+ * 값이 없는 지표(그 구간에 기록이 없어 `undefined`)도 판정하지 않는다. 없는 것을 0 으로 놓으면
+ * "목표 크게 미달" 이라는 **없는 사실**이 만들어지고, 사용자는 멈춘 적 없는 라인을 고치러 간다.
+ * 목표를 0 으로 준 경우도 비율을 내지 않는다(0 으로 나누지 않는다) — 만족 여부만 답한다.
+ */
+function judgeTargets(kpi, targets) {
+    const out = [];
+    for (const t of targets ?? []) {
+        const spec = exports.TWIN_METRIC[t.metric];
+        if (!spec)
+            continue; // 모르는 지표 이름 — 짐작해 매핑하지 않는다
+        const actual = spec.of(kpi);
+        if (typeof actual !== 'number' || !Number.isFinite(actual))
+            continue; // 값이 없다 ≠ 값이 0
+        if (!Number.isFinite(t.target))
+            continue;
+        out.push(verdictOf(t.metric, actual, t.target, spec.direction));
+    }
+    return out;
+}
+/** 판정 산수 한 곳 — 전체 판정과 축 판정이 **같은 규칙**을 쓴다(두 벌이면 갈라진다). */
+function verdictOf(metric, actual, target, direction) {
+    const met = direction === 'higher' ? actual >= target : actual <= target;
+    const ratio = direction === 'higher' ? (target > 0 ? actual / target : Number.NaN) : actual > 0 ? target / actual : Number.NaN;
+    return { metric, actual, target, direction, met, ratio };
+}
+//# sourceMappingURL=kpi-target.js.map

package/dist-server/engine/kpi-target.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kpi-target.js","sourceRoot":"","sources":["../../server/engine/kpi-target.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * 성과 목표 — **숫자를 판단으로 바꾸는 층.**\n *\n * ── 왜 필요한가 ─────────────────────────────────────────────────────────────\n * 화면과 AI 는 \"처리량 345건 · 작업시간 29초\" 를 정확히 말한다. 그런데 **그것이 좋은지 나쁜지는 말할 수\n * 없다.** 판단 근거가 앞 구간 비교뿐이라 \"어제보다 나아졌다\" 까지가 한계이고, 어제도 나빴으면 그 말은\n * 쓸모가 없다. 목표가 붙는 순간 같은 숫자가 **정보에서 판단으로** 바뀐다.\n *\n * ── 층을 섞지 않는다 ────────────────────────────────────────────────────────\n * 폴드(`kpi-fold`)는 **사실만** 낸다 — 목표를 모른다. 목표를 아는 순간 \"사실을 세는 규칙\" 과 \"잘했나\n * 판정하는 규칙\" 이 한 함수에 섞이고, 목표가 바뀔 때마다 사실 계산을 건드리게 된다. 그래서 판정은\n * 여기, **순수 함수**로 따로 둔다(폴드처럼 테스트가 값싸다).\n *\n * ── 목표의 집 (사용자 결정 2026-08-02) ──────────────────────────────────────\n * **트윈은 운영 목표를 갖고, `@things-factory/kpi` 는 경영 목표를 갖는다.** 경계:\n *\n *   트윈(TwinTarget)          이 구간·이 교대·이 공간의 **즉시 판단**. 현장 관리자가 트윈 화면에서 고친다.\n *                             값은 저널 폴드에서 **그때그때 계산**된다(저장된 값을 읽지 않는다).\n *   packages/kpi              **기간 평가**(조직·분기·점수·가중치·알림). 값은 저장돼 있어야 한다.\n *\n * 이 경계를 지키는 규칙 하나: **트윈은 목표를 복제하지 않는다.** 경영 목표가 필요하면 트윈의 사실을\n * 내보내 그쪽이 소비하고, 그쪽 목표를 여기로 베껴 오지 않는다 — 베끼는 순간 두 개의 진실이 된다.\n */\n/*\n * ── 운영 임계(커널 attention)와의 경계 ─────────────────────────────────────\n *\n * **attention 은 개체 하나의 지금 상태**다 — 앵커(설비·자리·오더)와 할 수 있는 조치를 갖는다.\n * **target(여기)은 구간의 집계**다 — 앵커도 조치도 없고 추세를 판단한다.\n *\n * 그래서 창 단위 집계 판정을 attention 으로 넣지 않는다: \"가동률 저하\"(창 평균) attention 을 만들면\n * `utilization.ratio` 목표와 **같은 사실을 두 층이 다른 임계로 판정**하게 된다.\n * (design/map/performance.md §5.0-4 — 현재 다섯 attention 과 이 어휘는 겹치지 않는다.)\n */\nimport type { DurationStats, KpiResult } from './kpi-fold.js'\n\n/** 측정된 기록이 있을 때만 값으로 인정한다 — 없으면 모름(0 이 아니다). */\nconst measured = (k: KpiResult, v: number): number | undefined => (k.eventsInWindow > 0 ? v : undefined)\n\n/** 분위수는 표본이 있을 때만 값이다 — `count === 0` 의 `p50Ms: 0` 은 \"0 밀리초\" 가 아니라 \"없음\" 이다. */\nconst statOf = (s: DurationStats, pick: (d: DurationStats) => number): number | undefined =>\n  s.count > 0 ? pick(s) : undefined\n\n/**\n * 지표 어휘 — **이름을 한 곳에서 정한다.**\n *\n * 목표와 사실이 서로 다른 이름을 쓰면 그 사이에 매핑 표가 생기고, 그 표가 곧 방언이 된다. 그래서\n * 목표가 가리킬 수 있는 지표는 여기 열거된 것뿐이고, 값을 꺼내는 방법도 여기 함께 있다.\n *\n * **`direction` 은 지표의 성질이지 사용자의 선택이 아니다.** 처리량은 높을수록 좋고 대기시간은 낮을수록\n * 좋다 — 이것을 입력으로 받으면 반대로 적은 목표가 만들어지고, 그 뒤 판정이 전부 뒤집힌다.\n */\nexport const TWIN_METRIC = {\n  /* 기록이 없는 구간은 처리량 0 이 아니라 **모름**이다 — `eventsInWindow` 가 그것을 가른다.\n     0 으로 판정하면 \"측정 못 한 구간\" 이 \"일을 안 한 구간\" 으로 보고된다. */\n  'throughput.tasks': { direction: 'higher', unit: 'count', of: (k: KpiResult) => measured(k, k.throughput.tasks) },\n  'throughput.orders': { direction: 'higher', unit: 'count', of: (k: KpiResult) => measured(k, k.throughput.orders) },\n  /* 소요시간 분위수는 `count === 0` 이면 **0 이 아니라 없다.** 이것을 0 으로 읽으면 시간 지표는\n     \"낮을수록 좋다\" 라서 **일이 없던 구간이 목표를 완벽히 달성한 것으로** 보고된다 — 미달을 놓치는\n     것보다 나쁘다(고칠 곳이 있는데 잘하고 있다고 말한다). 테스트가 이것을 잡았다. */\n  'leadTime.p50Ms': { direction: 'lower', unit: 'ms', of: (k: KpiResult) => statOf(k.leadTime, d => d.p50Ms) },\n  'leadTime.p90Ms': { direction: 'lower', unit: 'ms', of: (k: KpiResult) => statOf(k.leadTime, d => d.p90Ms) },\n  'workTime.p50Ms': { direction: 'lower', unit: 'ms', of: (k: KpiResult) => statOf(k.workTime, d => d.p50Ms) },\n  'waitTime.p50Ms': { direction: 'lower', unit: 'ms', of: (k: KpiResult) => statOf(k.waitTime, d => d.p50Ms) },\n  /** 자원 점유 — 개별 자원이 아니라 **창 전체의 평균 비율**(자원별은 관점 축의 일이다). */\n  'utilization.ratio': {\n    direction: 'higher',\n    unit: 'ratio',\n    of: (k: KpiResult) =>\n      k.utilization.length ? k.utilization.reduce((s, u) => s + u.ratio, 0) / k.utilization.length : undefined\n  }\n} as const\n\nexport type TwinMetricId = keyof typeof TWIN_METRIC\nexport const isTwinMetric = (id: string): id is TwinMetricId => id in TWIN_METRIC\n\n/**\n * 저장된 목표 행에서 **이 범위에 걸린 목표**를 고른다 — 좁은 선언이 넓은 선언을 덮는다.\n *\n * **왜 순수 함수인가**: 이 규칙(공간 목표 위에 인스턴스 목표를 얹는다)은 지금까지 DB 접근 뒤에 숨어\n * 있어서 **화면을 눌러 봐야만** 확인할 수 있었다. 그런데 이 프로젝트는 로그인 뒤 화면을 자동으로\n * 검증할 방법이 없어, 실제로 여러 기능이 \"실화면 미검증\" 으로 쌓였다. 규칙을 밖으로 빼면 테스트가\n * 값싸진다 — 조회는 행을 가져오기만 하고, **판단은 여기서** 한다.\n */\n/**\n * 축 목표까지 담은 목록 — 전체 목표와 **축의 한 값**에 걸린 목표를 함께 든다.\n *\n * 축 목표는 전체 목표를 **덮지 않는다.** 다른 질문이기 때문이다: \"현장 전체가 100건\" 과\n * \"용접 구역이 30건\" 은 동시에 참일 수 있다. 덮게 만들면 축 하나에 목표를 거는 순간 전체 판정이\n * 사라져 사용자가 \"목표를 지웠나?\" 를 묻게 된다.\n */\nexport interface ScopedTargets {\n  /** 창 전체에 걸린 목표. */\n  overall: TwinTargetSpec[]\n  /** 축 → (그 축의 값 → 목표들). 요청한 축만 채운다. */\n  byAxisKey: Record<string, TwinTargetSpec[]>\n}\n\n/**\n * 축의 각 값에 대해 목표 대비 판정 — **그룹 항목에 그대로 붙일 형태.**\n *\n * 그룹의 지표는 전체보다 좁다(주문 수·자원 점유는 축 단위로 뜻이 다르거나 없다). 없는 지표에 목표가\n * 걸려 있으면 **판정하지 않는다** — 여기서 0 으로 읽으면 시간 지표가 \"완벽 달성\" 으로 뒤집힌다\n * (전체 판정에서 이미 겪은 결함이다).\n */\nexport function judgeGroupTargets(\n  group: { key: string; tasks: number; leadTime: { count: number; p50Ms: number }; workTime: { count: number; p50Ms: number }; waitTime: { count: number; p50Ms: number } },\n  targets: readonly TwinTargetSpec[] | undefined\n): TargetVerdict[] {\n  const value = (metric: TwinMetricId): number | undefined => {\n    switch (metric) {\n      case 'throughput.tasks':\n        return group.tasks\n      case 'leadTime.p50Ms':\n        return group.leadTime.count > 0 ? group.leadTime.p50Ms : undefined\n      case 'workTime.p50Ms':\n        return group.workTime.count > 0 ? group.workTime.p50Ms : undefined\n      case 'waitTime.p50Ms':\n        return group.waitTime.count > 0 ? group.waitTime.p50Ms : undefined\n      default:\n        return undefined // 축 단위로 뜻이 없는 지표(주문 수·자원 점유) — 지어내지 않는다\n    }\n  }\n  const out: TargetVerdict[] = []\n  for (const t of targets ?? []) {\n    const spec = TWIN_METRIC[t.metric]\n    const actual = value(t.metric)\n    if (!spec || typeof actual !== 'number' || !Number.isFinite(actual) || !Number.isFinite(t.target)) continue\n    out.push(verdictOf(t.metric, actual, t.target, spec.direction))\n  }\n  return out\n}\n\nexport function mergeTargets(\n  rows: readonly TargetRow[],\n  scope: { spaceId?: string; instanceIds: readonly string[]; axis?: string }\n): TwinTargetSpec[] {\n  return scopedTargets(rows, scope).overall\n}\n\n/** 저장된 목표 행 — 판단에 필요한 것만(엔티티 전체를 요구하지 않는다: 테스트가 값싸진다). */\nexport interface TargetRow {\n  metric: string\n  target: number\n  spaceId?: string | null\n  instanceId?: string | null\n  axis?: string | null\n  axisKey?: string | null\n}\n\n/** 전체 목표와 축 목표를 함께 고른다 — 좁은 선언(인스턴스)이 넓은 선언(공간)을 덮는 규칙은 양쪽 같다. */\nexport function scopedTargets(\n  rows: readonly TargetRow[],\n  scope: { spaceId?: string; instanceIds: readonly string[]; axis?: string }\n): ScopedTargets {\n  /* 같은 자리(지표 또는 축값+지표)에 공간·인스턴스 목표가 함께 있으면 인스턴스가 이긴다. */\n  const pick = new Map<string, { target: number; fromInstance: boolean; axisKey?: string; metric: TwinMetricId }>()\n  for (const r of rows) {\n    if (!isTwinMetric(r.metric) || typeof r.target !== 'number' || !Number.isFinite(r.target)) continue\n    const inSpace = !!scope.spaceId && r.spaceId === scope.spaceId\n    const inInstance = !!r.instanceId && scope.instanceIds.includes(r.instanceId)\n    if (!inSpace && !inInstance) continue\n    if (r.axis) {\n      if (!scope.axis || r.axis !== scope.axis || !r.axisKey) continue // 지금 보는 축만\n    }\n    const slot = `${r.axis ?? ''}\\u0000${r.axisKey ?? ''}\\u0000${r.metric}`\n    const prev = pick.get(slot)\n    if (prev?.fromInstance && !inInstance) continue // 인스턴스 선언을 공간 선언이 덮지 않는다\n    pick.set(slot, { target: r.target, fromInstance: inInstance, axisKey: r.axisKey ?? undefined, metric: r.metric })\n  }\n  const overall: TwinTargetSpec[] = []\n  const byAxisKey: Record<string, TwinTargetSpec[]> = {}\n  for (const [slot, v] of pick) {\n    const spec = { metric: v.metric, target: v.target }\n    if (slot.startsWith('\\u0000')) overall.push(spec)\n    else (byAxisKey[v.axisKey as string] ??= []).push(spec)\n  }\n  return { overall, byAxisKey }\n}\n\n/** 목표 하나 — 어느 지표를, 얼마로. 방향은 지표가 안다(§TWIN_METRIC). */\nexport interface TwinTargetSpec {\n  metric: TwinMetricId\n  target: number\n}\n\nexport interface TargetVerdict {\n  metric: TwinMetricId\n  /** 이 구간의 실제 값. */\n  actual: number\n  target: number\n  direction: 'higher' | 'lower'\n  /** 목표를 만족했나. */\n  met: boolean\n  /**\n   * 목표 대비 비율 — **항상 \"1 이상이면 좋다\"** 로 정규화한다(방향이 다른 지표를 한 화면에서 비교할 수\n   * 있게). 처리량은 `actual/target`, 시간은 `target/actual`.\n   */\n  ratio: number\n}\n\n/**\n * 목표 대비 판정 — **목표가 없는 지표는 판정하지 않는다.**\n *\n * 값이 없는 지표(그 구간에 기록이 없어 `undefined`)도 판정하지 않는다. 없는 것을 0 으로 놓으면\n * \"목표 크게 미달\" 이라는 **없는 사실**이 만들어지고, 사용자는 멈춘 적 없는 라인을 고치러 간다.\n * 목표를 0 으로 준 경우도 비율을 내지 않는다(0 으로 나누지 않는다) — 만족 여부만 답한다.\n */\nexport function judgeTargets(kpi: KpiResult, targets: readonly TwinTargetSpec[] | undefined): TargetVerdict[] {\n  const out: TargetVerdict[] = []\n  for (const t of targets ?? []) {\n    const spec = TWIN_METRIC[t.metric]\n    if (!spec) continue // 모르는 지표 이름 — 짐작해 매핑하지 않는다\n    const actual = spec.of(kpi)\n    if (typeof actual !== 'number' || !Number.isFinite(actual)) continue // 값이 없다 ≠ 값이 0\n    if (!Number.isFinite(t.target)) continue\n    out.push(verdictOf(t.metric, actual, t.target, spec.direction))\n  }\n  return out\n}\n\n/** 판정 산수 한 곳 — 전체 판정과 축 판정이 **같은 규칙**을 쓴다(두 벌이면 갈라진다). */\nfunction verdictOf(metric: TwinMetricId, actual: number, target: number, direction: 'higher' | 'lower'): TargetVerdict {\n  const met = direction === 'higher' ? actual >= target : actual <= target\n  const ratio = direction === 'higher' ? (target > 0 ? actual / target : Number.NaN) : actual > 0 ? target / actual : Number.NaN\n  return { metric, actual, target, direction, met, ratio }\n}\n"]}

package/dist-server/engine/live-attentions.d.ts

@@ -1,6 +1,8 @@
 export declare function withLiveAttentions<S extends {
-    movers?: any[];
-    nodes?: any[];
+    equipment?: any[];
+    locations?: any[];
     orders?: any[];
+    tasks?: any[];
     attentions?: any[];
+    nowTime?: string;
 }>(state: S): S;

package/dist-server/engine/live-attentions.js

@@ -13,7 +13,11 @@ function withLiveAttentions(state) {
         return state;
     return {
         ...state,
-        attentions: (0, twin_kernel_1.deriveAttentions)({ movers: state.movers ?? [], nodes: state.nodes ?? [], orders: state.orders ?? [] })
+        /*
+         * 입력을 **시뮬 쪽과 똑같이** 넣는다. 한쪽만 빠지면 같은 공장이 한쪽에서만 막힌 것처럼 보이고,
+         * 그 어긋남은 규칙이 아니라 배선 때문이라 아무 데서도 안 잡힌다(`tasks` 를 빠뜨려 실제로 그럴 뻔했다).
+         */
+        attentions: (0, twin_kernel_1.deriveAttentions)({ equipment: state.equipment ?? [], locations: state.locations ?? [], orders: state.orders ?? [], tasks: state.tasks ?? [] }, undefined, state.nowTime)
     };
 }
 //# sourceMappingURL=live-attentions.js.map

package/dist-server/engine/live-attentions.js.map

@@ -1 +1 @@
-{"version":3,"file":"live-attentions.js","sourceRoot":"","sources":["../../server/engine/live-attentions.ts"],"names":[],"mappings":";;AAQA,gDAMC;AAdD;;;;;GAKG;AACH,sDAAuD;AAEvD,SAAgB,kBAAkB,CAAkF,KAAQ;IAC1H,IAAI,CAAC,KAAK;QAAE,OAAO,KAAK,CAAA;IACxB,OAAO;QACL,GAAG,KAAK;QACR,UAAU,EAAE,IAAA,8BAAgB,EAAC,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,IAAI,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,IAAI,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,IAAI,EAAE,EAAE,CAAC;KACnH,CAAA;AACH,CAAC","sourcesContent":["/*\n * live State attention 보강 — projector 미러 State(관측)에 커널 deriveAttentions(계산)를 채운다.\n * live 스냅샷이 sim 동형(attentions 포함)이 되어 attention 질의/스트림이 live 에서도 신호를 준다.\n * 순수(입력 불변). face2-inbound-live §1.1 \"State-순수 파생\"(입력이 미러 State 에 있어 재적용 가능).\n * deriveAttentions 는 커널 공유 공식(sim/live 동일 임계값·규칙).\n */\nimport { deriveAttentions } from '@operato/twin-kernel'\n\nexport function withLiveAttentions<S extends { movers?: any[]; nodes?: any[]; orders?: any[]; attentions?: any[] }>(state: S): S {\n  if (!state) return state\n  return {\n    ...state,\n    attentions: deriveAttentions({ movers: state.movers ?? [], nodes: state.nodes ?? [], orders: state.orders ?? [] })\n  }\n}\n"]}
+{"version":3,"file":"live-attentions.js","sourceRoot":"","sources":["../../server/engine/live-attentions.ts"],"names":[],"mappings":";;AAQA,gDAgBC;AAxBD;;;;;GAKG;AACH,sDAAuD;AAEvD,SAAgB,kBAAkB,CAChC,KAAQ;IAER,IAAI,CAAC,KAAK;QAAE,OAAO,KAAK,CAAA;IACxB,OAAO;QACL,GAAG,KAAK;QACR;;;WAGG;QACH,UAAU,EAAE,IAAA,8BAAgB,EAC1B,EAAE,SAAS,EAAE,KAAK,CAAC,SAAS,IAAI,EAAE,EAAE,SAAS,EAAE,KAAK,CAAC,SAAS,IAAI,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,IAAI,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,IAAI,EAAE,EAAE,EAC5H,SAAS,EACT,KAAK,CAAC,OAAO,CACd;KACF,CAAA;AACH,CAAC","sourcesContent":["/*\n * live State attention 보강 — projector 미러 State(관측)에 커널 deriveAttentions(계산)를 채운다.\n * live 스냅샷이 sim 동형(attentions 포함)이 되어 attention 질의/스트림이 live 에서도 신호를 준다.\n * 순수(입력 불변). face2-inbound-live §1.1 \"State-순수 파생\"(입력이 미러 State 에 있어 재적용 가능).\n * deriveAttentions 는 커널 공유 공식(sim/live 동일 임계값·규칙).\n */\nimport { deriveAttentions } from '@operato/twin-kernel'\n\nexport function withLiveAttentions<S extends { equipment?: any[]; locations?: any[]; orders?: any[]; tasks?: any[]; attentions?: any[]; nowTime?: string }>(\n  state: S\n): S {\n  if (!state) return state\n  return {\n    ...state,\n    /*\n     * 입력을 **시뮬 쪽과 똑같이** 넣는다. 한쪽만 빠지면 같은 공장이 한쪽에서만 막힌 것처럼 보이고,\n     * 그 어긋남은 규칙이 아니라 배선 때문이라 아무 데서도 안 잡힌다(`tasks` 를 빠뜨려 실제로 그럴 뻔했다).\n     */\n    attentions: deriveAttentions(\n      { equipment: state.equipment ?? [], locations: state.locations ?? [], orders: state.orders ?? [], tasks: state.tasks ?? [] },\n      undefined,\n      state.nowTime\n    )\n  }\n}\n"]}

package/dist-server/engine/measured-estimator.d.ts

@@ -0,0 +1,50 @@
+/** 커널 `DurationEstimate` 와 같은 모양(커널 타입에 의존하지 않기 위해 구조로 맞춘다). */
+export interface MeasuredEstimate {
+    meanMs: number;
+    spread?: {
+        distribution: 'triangular';
+        minMs: number;
+        maxMs: number;
+        modeMs: number;
+    };
+}
+export interface MeasuredEstimatorResult {
+    estimator?: {
+        estimate(ctx: {
+            kind: string;
+            fromNode: string;
+            toNode: string;
+            resourceKind?: string;
+        }): MeasuredEstimate | undefined;
+    };
+    /** 작업 종류 → 실측 소요(ms). 추정기가 답하는 종류들. */
+    learned: Record<string, number>;
+    /** 퍼짐까지 배운 종류 — 평균만 배운 것과 구별한다(변동 없는 소요는 대기를 과소평가한다). */
+    spreads: Record<string, {
+        minMs: number;
+        maxMs: number;
+    }>;
+    /** 표본이 모자라 쓰지 않은 종류와 그 건수 — 배우지 못한 것을 밝힌다. */
+    skipped: {
+        kind: string;
+        count: number;
+    }[];
+    minSamples: number;
+}
+/** 기본 표본 하한 — 이보다 적으면 그 종류는 배우지 않는다(작은 표본의 p50 을 현장 값으로 승격 금지). */
+export declare const DEFAULT_MIN_SAMPLES = 5;
+/**
+ * 작업 종류별 KPI 그룹에서 추정기를 만든다(순수 — DB·커널 모름).
+ * `groups` 는 `computeTwinKpi({ groupBy: 'taskKind' })` 의 `groups.items` 를 그대로 넘긴다.
+ */
+export declare function buildMeasuredEstimator(groups: {
+    key: string;
+    workTime?: {
+        count: number;
+        p10Ms?: number;
+        p50Ms: number;
+        p90Ms?: number;
+    };
+}[] | undefined, opts?: {
+    minSamples?: number;
+}): MeasuredEstimatorResult;

package/dist-server/engine/measured-estimator.js

@@ -0,0 +1,78 @@
+"use strict";
+/*
+ * 실측 소요 추정기 — **이력에서 배운 값이 상수·선언값을 이긴다.**
+ *
+ * 배경(operato-twin design/plans/simulation-spec.md §5-4): 소요시간을 명세로 받을 수 있게 됐지만
+ * 명세는 선언이다 — 그 현장에서 실제로 얼마 걸리는지는 저널이 안다. `gap-analytics` 는 지표 수준의
+ * 편향만 배웠고(예측값 보정), **공정별 소요를 추정기로 되먹이는 경로는 없었다.**
+ *
+ * 여기서 하는 일: KPI 폴드가 작업 종류별로 낸 **작업시간(착수→완료) p50** 을 그 종류의 소요로 쓴다.
+ * 리드타임(생성→완료)이 아니라 작업시간을 쓰는 이유: 리드타임에는 **대기가 섞여 있고**, 대기는
+ * 시뮬레이션이 자원 경합으로 스스로 만들어야 하는 값이다. 대기를 소요에 넣으면 이중 계산이 된다.
+ *
+ * **평균만 배우면 대기와 병목을 과소평가한다.** 소요가 늘 정확히 같으면 줄이 생기지 않는다 — 현장의
+ * 줄은 흔들림에서 나온다. 그래서 p50 만이 아니라 **관측된 퍼짐(p10..p90)** 을 함께 넘기고, 표본은
+ * 커널이 자기 난수로 뽑는다(fork 결정성). 양쪽 꼬리를 다 관측에서 가져오는 이유: p90 만 있으면
+ * 아래쪽을 위쪽에서 거울처럼 베껴야 하는데 그건 발명이다.
+ *
+ * 정직 규율:
+ *  - 표본이 적으면 쓰지 않는다(`minSamples`). 한두 건의 p50 은 그 현장의 값이 아니다.
+ *  - 'unknown' 축은 쓰지 않는다 — 종류를 모르는 기록을 특정 종류의 근거로 삼을 수 없다.
+ *  - 퍼짐이 성립하지 않으면(p10 ≥ p90, 또는 0) **퍼짐 없이 평균만** 넘긴다. 없는 흔들림을 만들지 않는다.
+ *  - 무엇을 배웠고 무엇을 표본 부족으로 버렸는지 함께 낸다(조용히 일부만 반영하지 않는다).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MIN_SAMPLES = void 0;
+exports.buildMeasuredEstimator = buildMeasuredEstimator;
+/** 기본 표본 하한 — 이보다 적으면 그 종류는 배우지 않는다(작은 표본의 p50 을 현장 값으로 승격 금지). */
+exports.DEFAULT_MIN_SAMPLES = 5;
+/**
+ * 작업 종류별 KPI 그룹에서 추정기를 만든다(순수 — DB·커널 모름).
+ * `groups` 는 `computeTwinKpi({ groupBy: 'taskKind' })` 의 `groups.items` 를 그대로 넘긴다.
+ */
+function buildMeasuredEstimator(groups, opts = {}) {
+    const minSamples = opts.minSamples ?? exports.DEFAULT_MIN_SAMPLES;
+    const learned = {};
+    const spreads = {};
+    const estimates = {};
+    const skipped = [];
+    for (const g of groups ?? []) {
+        if (!g?.key || g.key === 'unknown')
+            continue;
+        const w = g.workTime;
+        const count = w?.count ?? 0;
+        const p50 = w?.p50Ms ?? 0;
+        if (count < minSamples || !(p50 > 0)) {
+            skipped.push({ kind: g.key, count });
+            continue;
+        }
+        const mean = Math.round(p50);
+        learned[g.key] = mean;
+        /* 퍼짐은 **관측된 두 꼬리**로만 만든다. 한쪽이라도 없거나 구간이 성립하지 않으면 평균만 넘긴다. */
+        const lo = w?.p10Ms;
+        const hi = w?.p90Ms;
+        if (typeof lo === 'number' && typeof hi === 'number' && lo > 0 && hi > lo) {
+            const minMs = Math.round(lo);
+            const maxMs = Math.round(hi);
+            spreads[g.key] = { minMs, maxMs };
+            estimates[g.key] = { meanMs: mean, spread: { distribution: 'triangular', minMs, maxMs, modeMs: mean } };
+        }
+        else {
+            estimates[g.key] = { meanMs: mean };
+        }
+    }
+    if (!Object.keys(learned).length)
+        return { learned, spreads, skipped, minSamples };
+    return {
+        learned,
+        spreads,
+        skipped,
+        minSamples,
+        estimator: {
+            estimate(ctx) {
+                return estimates[ctx.kind];
+            }
+        }
+    };
+}
+//# sourceMappingURL=measured-estimator.js.map

package/dist-server/engine/measured-estimator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"measured-estimator.js","sourceRoot":"","sources":["../../server/engine/measured-estimator.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;;;AA4BH,wDAyCC;AAhDD,mEAAmE;AACtD,QAAA,mBAAmB,GAAG,CAAC,CAAA;AAEpC;;;GAGG;AACH,SAAgB,sBAAsB,CACpC,MAAkH,EAClH,OAAgC,EAAE;IAElC,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,IAAI,2BAAmB,CAAA;IACzD,MAAM,OAAO,GAA2B,EAAE,CAAA;IAC1C,MAAM,OAAO,GAAqD,EAAE,CAAA;IACpE,MAAM,SAAS,GAAqC,EAAE,CAAA;IACtD,MAAM,OAAO,GAAsC,EAAE,CAAA;IACrD,KAAK,MAAM,CAAC,IAAI,MAAM,IAAI,EAAE,EAAE,CAAC;QAC7B,IAAI,CAAC,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC,GAAG,KAAK,SAAS;YAAE,SAAQ;QAC5C,MAAM,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAA;QACpB,MAAM,KAAK,GAAG,CAAC,EAAE,KAAK,IAAI,CAAC,CAAA;QAC3B,MAAM,GAAG,GAAG,CAAC,EAAE,KAAK,IAAI,CAAC,CAAA;QACzB,IAAI,KAAK,GAAG,UAAU,IAAI,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,EAAE,CAAC;YAAC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,GAAG,EAAE,KAAK,EAAE,CAAC,CAAC;YAAC,SAAQ;QAAC,CAAC;QACxF,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;QAC5B,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,IAAI,CAAA;QACrB,6DAA6D;QAC7D,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,CAAA;QACnB,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,CAAA;QACnB,IAAI,OAAO,EAAE,KAAK,QAAQ,IAAI,OAAO,EAAE,KAAK,QAAQ,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC;YAC1E,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAA;YAC5B,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAA;YAC5B,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,CAAA;YACjC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,CAAA;QACzG,CAAC;aAAM,CAAC;YACN,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,CAAA;QACrC,CAAC;IACH,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,MAAM;QAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,CAAA;IAClF,OAAO;QACL,OAAO;QACP,OAAO;QACP,OAAO;QACP,UAAU;QACV,SAAS,EAAE;YACT,QAAQ,CAAC,GAAG;gBACV,OAAO,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;YAC5B,CAAC;SACF;KACF,CAAA;AACH,CAAC","sourcesContent":["/*\n * 실측 소요 추정기 — **이력에서 배운 값이 상수·선언값을 이긴다.**\n *\n * 배경(operato-twin design/plans/simulation-spec.md §5-4): 소요시간을 명세로 받을 수 있게 됐지만\n * 명세는 선언이다 — 그 현장에서 실제로 얼마 걸리는지는 저널이 안다. `gap-analytics` 는 지표 수준의\n * 편향만 배웠고(예측값 보정), **공정별 소요를 추정기로 되먹이는 경로는 없었다.**\n *\n * 여기서 하는 일: KPI 폴드가 작업 종류별로 낸 **작업시간(착수→완료) p50** 을 그 종류의 소요로 쓴다.\n * 리드타임(생성→완료)이 아니라 작업시간을 쓰는 이유: 리드타임에는 **대기가 섞여 있고**, 대기는\n * 시뮬레이션이 자원 경합으로 스스로 만들어야 하는 값이다. 대기를 소요에 넣으면 이중 계산이 된다.\n *\n * **평균만 배우면 대기와 병목을 과소평가한다.** 소요가 늘 정확히 같으면 줄이 생기지 않는다 — 현장의\n * 줄은 흔들림에서 나온다. 그래서 p50 만이 아니라 **관측된 퍼짐(p10..p90)** 을 함께 넘기고, 표본은\n * 커널이 자기 난수로 뽑는다(fork 결정성). 양쪽 꼬리를 다 관측에서 가져오는 이유: p90 만 있으면\n * 아래쪽을 위쪽에서 거울처럼 베껴야 하는데 그건 발명이다.\n *\n * 정직 규율:\n *  - 표본이 적으면 쓰지 않는다(`minSamples`). 한두 건의 p50 은 그 현장의 값이 아니다.\n *  - 'unknown' 축은 쓰지 않는다 — 종류를 모르는 기록을 특정 종류의 근거로 삼을 수 없다.\n *  - 퍼짐이 성립하지 않으면(p10 ≥ p90, 또는 0) **퍼짐 없이 평균만** 넘긴다. 없는 흔들림을 만들지 않는다.\n *  - 무엇을 배웠고 무엇을 표본 부족으로 버렸는지 함께 낸다(조용히 일부만 반영하지 않는다).\n */\n\n/** 커널 `DurationEstimate` 와 같은 모양(커널 타입에 의존하지 않기 위해 구조로 맞춘다). */\nexport interface MeasuredEstimate {\n  meanMs: number\n  spread?: { distribution: 'triangular'; minMs: number; maxMs: number; modeMs: number }\n}\n\nexport interface MeasuredEstimatorResult {\n  estimator?: {\n    estimate(ctx: { kind: string; fromNode: string; toNode: string; resourceKind?: string }): MeasuredEstimate | undefined\n  }\n  /** 작업 종류 → 실측 소요(ms). 추정기가 답하는 종류들. */\n  learned: Record<string, number>\n  /** 퍼짐까지 배운 종류 — 평균만 배운 것과 구별한다(변동 없는 소요는 대기를 과소평가한다). */\n  spreads: Record<string, { minMs: number; maxMs: number }>\n  /** 표본이 모자라 쓰지 않은 종류와 그 건수 — 배우지 못한 것을 밝힌다. */\n  skipped: { kind: string; count: number }[]\n  minSamples: number\n}\n\n/** 기본 표본 하한 — 이보다 적으면 그 종류는 배우지 않는다(작은 표본의 p50 을 현장 값으로 승격 금지). */\nexport const DEFAULT_MIN_SAMPLES = 5\n\n/**\n * 작업 종류별 KPI 그룹에서 추정기를 만든다(순수 — DB·커널 모름).\n * `groups` 는 `computeTwinKpi({ groupBy: 'taskKind' })` 의 `groups.items` 를 그대로 넘긴다.\n */\nexport function buildMeasuredEstimator(\n  groups: { key: string; workTime?: { count: number; p10Ms?: number; p50Ms: number; p90Ms?: number } }[] | undefined,\n  opts: { minSamples?: number } = {}\n): MeasuredEstimatorResult {\n  const minSamples = opts.minSamples ?? DEFAULT_MIN_SAMPLES\n  const learned: Record<string, number> = {}\n  const spreads: Record<string, { minMs: number; maxMs: number }> = {}\n  const estimates: Record<string, MeasuredEstimate> = {}\n  const skipped: { kind: string; count: number }[] = []\n  for (const g of groups ?? []) {\n    if (!g?.key || g.key === 'unknown') continue\n    const w = g.workTime\n    const count = w?.count ?? 0\n    const p50 = w?.p50Ms ?? 0\n    if (count < minSamples || !(p50 > 0)) { skipped.push({ kind: g.key, count }); continue }\n    const mean = Math.round(p50)\n    learned[g.key] = mean\n    /* 퍼짐은 **관측된 두 꼬리**로만 만든다. 한쪽이라도 없거나 구간이 성립하지 않으면 평균만 넘긴다. */\n    const lo = w?.p10Ms\n    const hi = w?.p90Ms\n    if (typeof lo === 'number' && typeof hi === 'number' && lo > 0 && hi > lo) {\n      const minMs = Math.round(lo)\n      const maxMs = Math.round(hi)\n      spreads[g.key] = { minMs, maxMs }\n      estimates[g.key] = { meanMs: mean, spread: { distribution: 'triangular', minMs, maxMs, modeMs: mean } }\n    } else {\n      estimates[g.key] = { meanMs: mean }\n    }\n  }\n  if (!Object.keys(learned).length) return { learned, spreads, skipped, minSamples }\n  return {\n    learned,\n    spreads,\n    skipped,\n    minSamples,\n    estimator: {\n      estimate(ctx) {\n        return estimates[ctx.kind]\n      }\n    }\n  }\n}\n"]}

package/dist-server/engine/model-basis.d.ts

@@ -0,0 +1,23 @@
+/** 같은 모델로 볼 상대 허용오차 — 이 비율 안의 변화는 드리프트, 넘으면 다른 모델. */
+export declare const BASIS_TOLERANCE = 0.1;
+export interface ModelBasis {
+    /** 작업 종류 → 실측 소요(ms). `buildMeasuredEstimator().learned`. */
+    measured?: Record<string, number>;
+    /** 자원 종류 → 속도(m/s). `buildTravelEstimator().speedsByKind`. */
+    speeds?: Record<string, number>;
+    /** 선언된 공정 소요 — key + ISO 8601 원문(문자열은 그대로 비교한다: 선언이 바뀌면 다른 모델). */
+    declared?: {
+        key: string;
+        duration?: string;
+    }[];
+}
+/**
+ * 모델이 달라졌는가 — 보정을 적용하기 전의 관문.
+ * 한쪽 근거를 모르면 **판정하지 않는다**(false) — 모르는 것을 근거로 학습을 끊지 않는다.
+ */
+export declare function modelBasisChanged(before?: ModelBasis, after?: ModelBasis, tol?: number): boolean;
+/**
+ * 사람이 읽는 근거 요약 — **로그·진단용**(비교의 근거가 아니다).
+ * 지문으로 같음을 판정하지 않는 이유는 위 주석 참조. 두 근거가 왜 달라졌는지 눈으로 보려면 이것을 찍는다.
+ */
+export declare function describeModelBasis(basis?: ModelBasis): string;

package/dist-server/engine/model-basis.js

@@ -0,0 +1,100 @@
+"use strict";
+/*
+ * 모델 근거 — **배운 모델에만 보정을 적용하기 위한 비교.**
+ *
+ * 예측 출력 보정(P3.2 `twinLearnCalibration`)은 "우리 모델이 늘 이만큼 적게 본다" 를 배워 결과를
+ * 밀어 준다. 그 학습은 **그때의 모델**을 전제로 한다. 그런데 소요시간 추정기(실측·거리계산)와 공정
+ * 명세가 들어오면서 모델 자체가 바뀔 수 있게 됐다 — 모델이 이미 그 편향을 잃었는데 보정이 또 밀어
+ * 주면 **이중 보정**이 되어 정확도가 나빠진다. 학습 시점의 accAfter 도 더는 유효하지 않다.
+ *
+ * 그래서 보정 기록에 **그때 모델의 근거**를 함께 남기고, 적용 전에 지금 근거와 비교한다. 달라졌으면
+ * 적용하지 않고 **그 사실을 응답에 싣는다**(조용히 사라지면 사용자는 학습이 왜 안 듣는지 모른다).
+ *
+ * 비교는 **상대 허용오차**로 한다(양자화 지문이 아니라). 실측 p50 은 새 기록이 쌓일 때마다 1~2초씩
+ * 흔들리는데, 값을 버킷으로 뭉개 비교하면 버킷 경계에 걸린 값이 1초 드리프트로도 달라져 버린다 —
+ * "작은 드리프트로 학습을 무효화하지 않는다" 는 목적을 경계에서 못 지킨다. 비율로 비교하면 어디서든
+ * 같은 규칙이 성립한다: 10% 이내는 같은 모델, 30초→47초(57%)는 다른 모델.
+ *
+ * 재료는 호스트가 아는 것들이다(커널 API 에 의존하지 않아 발행 상태와 무관하게 동작한다):
+ *  ① 실측으로 배운 작업 종류별 소요 ② 자원 종류별 속도 ③ 선언된 공정 소요.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BASIS_TOLERANCE = void 0;
+exports.modelBasisChanged = modelBasisChanged;
+exports.describeModelBasis = describeModelBasis;
+/** 같은 모델로 볼 상대 허용오차 — 이 비율 안의 변화는 드리프트, 넘으면 다른 모델. */
+exports.BASIS_TOLERANCE = 0.1;
+/** 뜻 있는 수만 남긴다 — 0·음수·NaN 은 모델이 아니다. */
+function clean(map) {
+    const out = {};
+    for (const [k, v] of Object.entries(map ?? {}))
+        if (Number.isFinite(v) && v > 0)
+            out[k] = v;
+    return out;
+}
+function declaredMap(list) {
+    const out = {};
+    for (const o of list ?? [])
+        if (o?.key && o.duration)
+            out[o.key] = o.duration;
+    return out;
+}
+/** 두 수치 지도가 실질적으로 다른가 — 키 집합이 다르거나, 값이 허용오차를 넘어 다르면 다르다. */
+function numericChanged(a, b, tol) {
+    const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+    for (const k of keys) {
+        const x = a[k];
+        const y = b[k];
+        if (x === undefined || y === undefined)
+            return true; // 새로 배운 종류·사라진 종류 = 다른 모델
+        const base = Math.max(Math.abs(x), Math.abs(y));
+        if (base > 0 && Math.abs(x - y) / base > tol)
+            return true;
+    }
+    return false;
+}
+/**
+ * 모델이 달라졌는가 — 보정을 적용하기 전의 관문.
+ * 한쪽 근거를 모르면 **판정하지 않는다**(false) — 모르는 것을 근거로 학습을 끊지 않는다.
+ */
+function modelBasisChanged(before, after, tol = exports.BASIS_TOLERANCE) {
+    if (!before || !after)
+        return false;
+    if (numericChanged(clean(before.measured), clean(after.measured), tol))
+        return true;
+    if (numericChanged(clean(before.speeds), clean(after.speeds), tol))
+        return true;
+    const da = declaredMap(before.declared);
+    const db = declaredMap(after.declared);
+    const keys = new Set([...Object.keys(da), ...Object.keys(db)]);
+    for (const k of keys)
+        if (da[k] !== db[k])
+            return true;
+    return false;
+}
+/**
+ * 사람이 읽는 근거 요약 — **로그·진단용**(비교의 근거가 아니다).
+ * 지문으로 같음을 판정하지 않는 이유는 위 주석 참조. 두 근거가 왜 달라졌는지 눈으로 보려면 이것을 찍는다.
+ */
+function describeModelBasis(basis) {
+    if (!basis)
+        return 'unknown';
+    const seg = [];
+    const m = Object.entries(clean(basis.measured))
+        .map(([k, v]) => `${k}=${Math.round(v / 1000)}s`)
+        .sort();
+    if (m.length)
+        seg.push(`measured(${m.join(',')})`);
+    const s = Object.entries(clean(basis.speeds))
+        .map(([k, v]) => `${k}=${Math.round(v * 10) / 10}m/s`)
+        .sort();
+    if (s.length)
+        seg.push(`speed(${s.join(',')})`);
+    const d = Object.entries(declaredMap(basis.declared))
+        .map(([k, v]) => `${k}=${v}`)
+        .sort();
+    if (d.length)
+        seg.push(`declared(${d.join(',')})`);
+    return seg.length ? seg.join(' ') : 'kernel defaults only';
+}
+//# sourceMappingURL=model-basis.js.map