Files
ai-platform/src/modules/tfamd-oee/data/ontologyOee.ts
T
2026-11-19 10:09:33 +08:00

2061 lines
117 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/**
* 通富超威 · OEE 智能优化 —— 业务本体层(对象—关系—规则—动作)。
*
* 与品质那套本体**同结构、同 API**(ADR-05:类型直接 import 自 ontologyQap,不重新定义),
* 内容换成建议书 3.6 定义的 9 类对象:
* 设备 / 产线拓扑 / 批次 / 事件 / 状态段 / 损失 / 绩效 / 口径 / 改善
*
* ★ 四条不可违反的本体纪律:
* 1. **数值唯一来源是 L3 服务层**(lib/oeeService)。本文件不写死任何统计数字,
* 也不自己再跑一遍链路——这是断言②「四处读数一致」在本体层的实现方式。
* 2. **数据缺口标灰不标绿**:跑不出结果的规则一律 blocked + gap(复用 ontologyQap 模式)。
* 线体合成待 W2、改善任务待 W3-B、首件检验未接入、班次时刻是演示假设——
* 这些都如实标缺口,**绝不造实例充数**(尤其不编那"6 条改善任务")。
* 3. **P0 口径未签字不得显示为达标**:本次不安排口径工作坊,28 项 signedOff 全 false,
* P0 的 16 项 tone 用中性 info(灰),不用 success(绿)。
* 4. **三套"六"分类不混用**:六-1 损失桶(LossBucket)/ 六-2 ASLT 时间六分类 /
* 六-3 事件表归口用词(GROSS_TO_BUCKET)。本层只承载六-1 与六-3 的映射关系,
* 六-2 属 ASLT 站时间账,W2 接入 ASLT 模板时另建对象,不塞进损失桶。
*
* ★ tables 字段填**对象 id**(不是物理表名):OntologyView 的聚焦联动按 tables 匹配对象,
* 填物理表名会让高亮静默失效。建议书 3.6 示例里的 'loss_bucket' 是表名口径,此处按视图契约落地。
*/
import type {
AttrType, OntAttr, OntInstance, OntObject, OntRelation, OntRule, OntAction, OntField, Tone,
} from './ontologyQap';
import {
DEVICES, DEVICE_BY_ID, LINES, LINE_BY_ID, OEE_DEVICES, ANCHOR_DEVICE_ID, DEMO_ORDER,
SHIFT_PATTERN, SHIFT_ASSUMPTION_NOTE, deviceStats,
} from './oee/devices';
import { EVENTS_48, EVENT_BY_CODE, eventStats, MISSING_CODES } from './oee/events48';
import {
CALIBER_ITEMS, CALIBER_CONFIG, CALIBER_VERSION, SENSITIVITY_ISSUES, caliberStats,
} from './oee/calibers28';
import {
currentDay, dekDays, serviceStats, PARAMS_SIGNOFF_NOTE,
type OeeDayResult,
} from '../lib/oeeService';
import { DQ_RULES, DQ_RULE_BY_CODE, DQ_DEFAULTS } from '../lib/oee/dq';
import { defaultGapThresholdMin } from '../lib/oee/stateMachine';
import { STATE_TO_BUCKET, checkUniqueBucketAssignment } from '../lib/oee/lossBuckets';
import {
BUCKET_LABEL, BUCKET_FACTOR, LOSS_BUCKETS, STATE_LABEL, GRADE_LABEL, EVENT_STATUS_LABEL,
TEMPLATE_LABEL, ATTR_METHOD_LABEL, GROSS_TO_BUCKET, TASK_STATE_LABEL, BLOCKING_DQ, EPS,
type LossBucket, type EventGrade,
} from '../types/oee';
/** 本体版本日。与指标树 METRIC_TREE_AS_OF 同日,便于"说明与对照"页核对同源。 */
export const OEE_ONTOLOGY_AS_OF = '2026-11-12';
/** 别名:视图层只换 import 来源即可复用四栏骨架(ADR-05 的落地形式)。 */
export const ONTOLOGY_AS_OF = OEE_ONTOLOGY_AS_OF;
/** demo 沙箱固定缺口口径:本工程不接后端。 */
const REFERENCES_DEMO_SANDBOX_GAP = '本工程为 demo 沙箱,不接后端;数据来自内置合成种子,不冒充实测';
/**
* ★ 类型再导出(type-only,编译期擦除):视图层**只依赖本模块**即可拿到四层骨架的全部类型。
*
* 为什么必须走这里而不是让视图直接 import ontologyQap:
* ontologyQap.ts 自身 `import { … } from './qap'` 取的是**值**,
* 视图一旦从它 import 任何运行时符号,整套品质 JSON 就被拖进 OEE 的包。
* ADR-05 说"类型直接复用",复用的是类型不是数据——故在此收口成一个接缝。
* W4-C 删除 data/qap 时,只需把下面这一行的来源换成 types/ontology.ts,视图零改动。
*/
export type {
AttrType, OntAttr, OntInstance, OntObject, OntRelation, OntRule, OntAction, OntField,
ActionType, Tone, Severity,
} from './ontologyQap';
/* ── 取数与格式化小工具(与 ontologyQap 同形) ─────────────────────────── */
type Row = Record<string, unknown>;
const s = (v: unknown) => (v === null || v === undefined || v === '' ? '—' : String(v));
const num = (v: unknown) => (typeof v === 'number' ? v.toLocaleString('zh-CN') : s(v));
const pct2 = (v: unknown) => (typeof v === 'number' ? `${(v * 100).toFixed(2)}%` : '—');
const hhmmss = (iso: string) => iso.slice(11, 19);
const hm = (iso: string) => iso.slice(11, 16);
const filled = (v: unknown) => v !== null && v !== undefined && v !== '';
const isDate = (v: unknown) => typeof v === 'string' && /^\d{4}-\d{2}-\d{2}/.test(v);
/** 列类型靠实际值反推:全数值 → number,全日期 → date,取值 ≤6 种 → enum,其余 string */
function inferType(vals: unknown[]): AttrType {
const got = vals.filter(filled);
if (got.length === 0) return 'string';
if (got.every((v) => typeof v === 'number')) return 'number';
if (got.every(isDate)) return 'date';
if (got.every((v) => typeof v === 'string') && new Set(got).size <= 6) return 'enum';
return 'string';
}
/** 属性表就是表头:必填=该列在全部行里都非空,可空则把非空行数写进口径 */
function deriveAttrs(rows: Row[]): OntAttr[] {
if (rows.length === 0) return [];
return Object.keys(rows[0]).map((col) => {
const vals = rows.map((r) => r[col]);
const ok = vals.filter(filled).length;
return {
name: col, en: col, type: inferType(vals), required: ok === rows.length,
note: ok === rows.length ? undefined : `非空 ${ok}/${rows.length} 行`,
};
});
}
/* ── L3 取数:全部走服务层,本层不重算 ─────────────────────────────────── */
const days = (): OeeDayResult[] => dekDays();
const cur = (): OeeDayResult => currentDay();
const allEvents = () => days().flatMap((d) => d.normalize.events);
const curEvents = () => cur().normalize.events;
/** 事件实例 id → 定义。键空间必须是**实例 id**(与 lossBuckets 注入同一纪律)。 */
const defOfInstance = (id: string) => {
const e = curEvents().find((x) => x.id === id);
return e ? EVENT_BY_CODE[e.defCode] : undefined;
};
const bucketOfState = (state: string): LossBucket | undefined =>
STATE_TO_BUCKET[state as keyof typeof STATE_TO_BUCKET];
const gradeTone = (g: EventGrade): Tone =>
g === 'A' ? 'success' : g === 'B' ? 'info' : g === 'C' ? 'warning' : g === 'D' ? 'danger' : 'info';
/* ══════════════════════════════════════════════════════════════════
* 九类对象的行集(属性=表头列,实例=真实行)
* ══════════════════════════════════════════════════════════════════ */
/** ① 设备:17 台台账全量。间隙阈值/ICT/编码来源逐台如实标注。 */
function equipmentRows(): Row[] {
return DEVICES.map((d) => ({
设备编码: d.id,
设备名称: d.name,
区域: d.region,
设备类型: d.type,
所属线体: d.lineId,
工站: d.station,
信号完整度: d.capability,
有日志: d.hasLog ? '是' : '否',
间隙阈值min: d.gapThresholdMin,
公式默认阈值min: defaultGapThresholdMin(d.ictSec),
标准节拍ICT秒: d.ictSec,
计量单位: d.unit,
计算模板: TEMPLATE_LABEL[d.template],
台账编码来源: d.codeSource,
现场台数: d.pocFleetCount ?? '',
ICT来源: d.ictSource,
ICT口径说明: d.ictNote,
阈值来源: d.gapSource,
日志格式: d.logFormat,
字符编码: d.encoding,
时间轴重建策略: d.rebuildStrategy,
解析陷阱: d.adapterTraps.join(';'),
计入OEE: d.countsForOee ? '是' : '否',
主流程序号: d.mainPathSeq ?? '',
能力矩阵: d.capabilityStars
? `节拍${d.capabilityStars.cycle} Down${d.capabilityStars.down} Jam${d.capabilityStars.jam}`
+ ` 待料${d.capabilityStars.wait} 换型${d.capabilityStars.setup} 单件${d.capabilityStars.unit}`
: '',
总体评价: d.capabilityNote,
过渡采集通道: d.fallbackChannel ?? '',
Lane数: d.lanes?.length ?? '',
Site数: d.siteCount ?? '',
演示角色: d.demoRole,
}));
}
/** ② 产线拓扑:3 条线。合成引擎待 W2,故合成状态如实标"待接入"。 */
function lineRows(): Row[] {
return LINES.map((l) => {
const devs = l.deviceIds.map((id) => DEVICE_BY_ID[id]).filter(Boolean);
const path = devs.filter((d) => d.mainPathSeq !== undefined)
.sort((a, b) => (a.mainPathSeq ?? 0) - (b.mainPathSeq ?? 0))
.map((d) => `${d.mainPathSeq} ${d.station}`);
return {
线体编码: l.id,
线体名称: l.name,
区域: l.region,
计算模板: TEMPLATE_LABEL[l.template],
设备台数: devs.length,
计入OEE台数: devs.filter((d) => d.countsForOee).length,
设备清单: l.deviceIds.join(' / '),
瓶颈设备: l.bottleneckDeviceId ?? '',
主流程工站: path.join(' → '),
有日志台数: devs.filter((d) => d.hasLog).length,
合成状态: '待 W2 接入(lineSynthesis 未落地)',
口径说明: l.note,
};
});
}
/** ③ 批次:三日 lot 窗口。DEK 日志直接印 lot 号 → 设备自识别 1.00。 */
function lotRows(): Row[] {
return days().flatMap((d) => d.lots.map((w) => {
const out = w.outputQty ?? 0;
const good = w.goodQty ?? 0;
const method = w.selfIdentified ? 'SELF_IDENTIFIED' : 'UNATTRIBUTED';
return {
业务日: d.bizDate,
批次号: w.lotId,
设备: w.device,
工单号: w.workOrderId ?? '',
开始时刻: new Date(w.startEpoch * 1000).toISOString(),
结束时刻: new Date(w.endEpoch * 1000).toISOString(),
窗口时长秒: w.endEpoch - w.startEpoch,
投入数: out,
合格数: good,
批次良率: out > 0 ? good / out : '',
归因方式: ATTR_METHOD_LABEL[method],
归因置信度: w.selfIdentified ? 1.0 : 0.0,
换型窗口: w.isSetupWindow ? '是' : '否',
工程批: w.isEngineering ? '是' : '否',
计入OEE分母: w.isEngineering ? '否(C10 默认剔除 ENG 工程批)' : '是',
产出证据: out > 0 ? '有完成行锚点' : '无完成行 → 不造窗口',
};
}));
}
/**
* ④ 事件:48 条定义 + 当期业务日的事件实例(建议书 3.6「48 定义 + 实例」)。
* 定义行带现算的实例计数;实例行带原始行号与双时间字段,是断言①血缘链的落点。
*/
function eventRows(): Row[] {
const curEv = curEvents();
const allEv = allEvents();
const defs: Row[] = EVENTS_48.map((e) => ({
类别: '定义',
事件码: e.code,
事件名: e.name,
区域: e.region,
自动化等级: e.grade,
等级含义: GRADE_LABEL[e.grade],
形态: e.form,
适用状态: EVENT_STATUS_LABEL[e.status],
触发点: e.triggerPoint,
来源: e.source,
归口用词: e.grossCategory,
损失桶: e.bucket ? BUCKET_LABEL[e.bucket] : '不进六桶(计划类)',
一级因子: e.factorL1,
二级因子: e.factorL2,
采集方式: e.acquisition,
报警类: e.alarmClass ?? '',
当期实例数: curEv.filter((x) => x.defCode === e.code).length,
三日实例数: allEv.filter((x) => x.defCode === e.code).length,
实例id: '', 设备: '', 业务日: '', 原始时刻: '', 校正时刻: '',
时钟偏移秒: '', 已校正: '', 配对id: '', 配对角色: '', 配对策略: '',
原始行号: '', 文件路径: '', 摘要哈希: '', 归因批次: '', 归因置信度: '',
}));
const insts: Row[] = curEv.map((x) => {
const e = EVENT_BY_CODE[x.defCode];
return {
类别: '实例',
事件码: x.defCode,
事件名: e?.name ?? x.defCode,
区域: e?.region ?? '',
自动化等级: e?.grade ?? '',
等级含义: e ? GRADE_LABEL[e.grade] : '',
形态: x.form,
适用状态: '', 触发点: '', 来源: '',
归口用词: e?.grossCategory ?? '',
损失桶: e?.bucket ? BUCKET_LABEL[e.bucket] : '不进六桶(计划类)',
一级因子: e?.factorL1 ?? '',
二级因子: e?.factorL2 ?? '',
采集方式: e?.acquisition ?? '',
报警类: e?.alarmClass ?? '',
当期实例数: '', 三日实例数: '',
实例id: x.id,
设备: x.device,
业务日: cur().bizDate,
原始时刻: x.rawTime,
校正时刻: x.correctedTime,
时钟偏移秒: x.clockOffsetSec ?? '',
已校正: x.isCorrected ? '是' : '否',
配对id: x.pairId ?? '',
配对角色: x.pairRole ?? '',
配对策略: x.pairStrategy ?? '',
原始行号: x.evidence.lineNo,
文件路径: x.evidence.filePath,
摘要哈希: x.evidence.digest,
归因批次: x.attribution?.lotId ?? '',
归因置信度: x.attribution?.confidence ?? '',
};
});
return [...defs, ...insts];
}
/** ⑤ 状态段:当期业务日。十态抢占优先级 + 影子时长 + 间隙填充来源全部留证。 */
function segmentRows(): Row[] {
const d = cur();
return d.segments.segments.map((g) => ({
段id: g.id,
设备: g.device,
业务日: g.bizDate,
状态码: g.state,
状态名: STATE_LABEL[g.state],
抢占优先级: g.priority,
开始时刻: g.start,
结束时刻: g.end,
时长秒: g.durationSec,
班次: g.shiftId,
跨班拆分组: g.splitGroupId ?? '',
影子段: g.shadowOf ?? '',
影子时长秒: g.shadowSec ?? '',
间隙填充: g.filledByGapRule ? '是' : '否',
置信度: g.confidence,
归口损失桶: bucketOfState(g.state) ? BUCKET_LABEL[bucketOfState(g.state)!] : '不进六桶',
事件数: g.eventIds.length,
事件id清单: g.eventIds.join(' / '),
未归因池id: g.unknownPoolId ?? '',
}));
}
/** ⑥ 损失:当期六桶 + 已计时因子 + 未计时子因子。推导桶显式标注,不假装有事件证据。 */
function lossRows(): Row[] {
const d = cur();
const segs = d.segments.segments;
const buckets: Row[] = d.buckets.buckets.map((b) => ({
类别: '损失桶',
编码: `L-${b.bucket}`,
名称: BUCKET_LABEL[b.bucket],
归属因子: b.factor,
时长秒: b.durationSec,
占PPT: b.pctOfPlanTime,
推导量: b.derivedFromCycleDeviation ? '是' : '否',
事件码清单: b.eventCodes.join(' / '),
状态段数: segs.filter((g) => bucketOfState(g.state) === b.bucket).length,
事件实例数: curEvents().filter((x) => b.eventCodes.includes(x.defCode)).length,
一级因子: '', 二级因子: '',
缺口说明: b.derivedFromCycleDeviation
? '由节拍偏差/检测结果推导,无成对事件证据 → 不提供事件级下钻(数据缺口,非对账失败)'
: '',
}));
const factors: Row[] = d.buckets.factors.map((f) => ({
类别: '因子',
编码: `F-${f.factorL1}|${f.factorL2}`,
名称: `${f.factorL1} / ${f.factorL2}`,
归属因子: f.factor,
时长秒: f.durationSec,
占PPT: d.segments.totals.pptSec > 0 ? f.durationSec / d.segments.totals.pptSec : 0,
推导量: '否',
事件码清单: [...new Set(f.eventIds.map((id) => defOfInstance(id)?.code ?? ''))].filter(Boolean).join(' / '),
状态段数: f.segmentIds.length,
事件实例数: f.eventIds.length,
一级因子: f.factorL1,
二级因子: f.factorL2,
缺口说明: '',
}));
/* 未计时子因子:时长**留空**而不是填 0——缺 EA 到场时间戳就是量不出来,
填 0 会被读成"没有损失",摊一个数更是假精度。 */
const untimed: Row[] = d.buckets.untimedSubFactors.map((u) => ({
类别: '未计时子因子',
编码: `U-${u.factorL1}|${u.factorL2}`,
名称: `${u.factorL1} / ${u.factorL2}`,
归属因子: 'A',
时长秒: '',
占PPT: '',
推导量: '否',
事件码清单: [...new Set(u.eventIds.map((id) => defOfInstance(id)?.code ?? ''))].filter(Boolean).join(' / '),
状态段数: u.segmentIds.length,
事件实例数: u.eventIds.length,
一级因子: u.factorL1,
二级因子: u.factorL2,
缺口说明: '段内出现但未单独计量:缺子因子的起止时间戳,无法从父段里拆出时长。标灰不摊数。',
}));
return [...buckets, ...factors, ...untimed];
}
const TIER_LABEL = { theoretical: '理论档', planned: '计划档', actual: '实际档' } as const;
type TierKey = keyof typeof TIER_LABEL;
/** ⑦ 绩效:三日 × 三档 = 9 条。理论/计划档是口径推算,实际档才是种子实测,逐行标明。 */
function performanceRows(): Row[] {
return days().flatMap((d) => (Object.keys(TIER_LABEL) as TierKey[]).map((k) => {
const t = d.tiers[k];
const isActual = k === 'actual';
const delta = isActual ? d.tiers.deltaPlannedToActual : null;
return {
业务日: d.bizDate,
档位: TIER_LABEL[k],
范围层级: 'DEVICE',
设备: d.device.id,
口径版本: d.caliberVersion,
计算模板: TEMPLATE_LABEL[d.device.template],
数值性质: isActual ? '实测(三日合成种子日志)' : '口径推算(附录 E 默认值,待 IE 签字)',
CT秒: d.segments.totals.ctSec,
PDT秒: d.segments.totals.pdtSec,
PPT秒: d.segments.totals.pptSec,
A: t.a, P: t.p, Q: t.q, OEE: t.oee,
RT秒: t.rtSec,
产出数: isActual ? t.outputQty : '',
合格数: isActual ? t.goodQty : '',
ICT秒: t.ictSec,
六桶残差秒: isActual ? d.buckets.residualSec : '',
未归因占比: isActual ? d.buckets.unattributedPct : '',
DQ阻断: isActual ? (d.dq.blocked ? '是' : '否') : '',
阻断规则: isActual ? d.dq.blockedBy.join(' / ') : '',
对比基准: isActual ? '计划档' : '',
ΔA: delta ? delta.dA : '',
ΔP: delta ? delta.dP : '',
ΔQ: delta ? delta.dQ : '',
Δ合计: delta ? delta.total : '',
参数出处: isActual ? 'L1 种子 → L2 引擎 → L3 服务层' : PARAMS_SIGNOFF_NOTE,
};
}));
}
/** ⑧ 口径:28 项 × 当前版本。signedOff 全 false,P0 标灰不标绿。 */
function caliberRows(): Row[] {
const issuesOf = (id: string) => Object.values(SENSITIVITY_ISSUES)
.filter((v) => (v.items as readonly string[]).includes(id))
.map((v) => v.label);
return Object.values(CALIBER_ITEMS).map((c) => ({
口径编号: c.id,
口径名称: c.name,
默认值: String(c.defaultValue),
优先级: c.priority,
归口责任人: c.owner,
敏感性议题: issuesOf(c.id).join(' / '),
是敏感性关键项: c.isSensitivityKey ? '是' : '否',
已签字: c.signedOff ? '是' : '否',
签字状态: c.signedOff ? '已签字' : '待 IE 签字',
影响范围与归口: c.note,
生效版本: CALIBER_CONFIG.version,
生效起始: CALIBER_CONFIG.effectiveFrom,
}));
}
/**
* ⑨ 改善:当前只有 DQ 命中(三日)。
* ★ 改善任务实例为 0:closure 引擎与任务中心在 W3-B 落地。
* 建议书 3.6 写的"6 条任务"是**目标态**,不是现有数据——此处不编 6 条任务充数,
* 由 R-TASK-DISPATCH 规则以 blocked + gap 明示缺口。
*/
function improvementRows(): Row[] {
return days().flatMap((d) => d.dq.issues.map((i) => ({
类别: 'DQ问题',
编号: i.id,
规则码: i.code,
规则名: DQ_RULE_BY_CODE[i.code]?.name ?? i.code,
设备: i.device ?? '',
业务日: i.bizDate,
命中条件: i.condition,
是否阻断: i.blocking ? '是' : '否',
处置动作: i.action,
处理状态: i.state,
缺口说明: i.gap ?? '',
任务状态: '', 根因实体: '', 责任人: '', 期限: '', 预期收益: '', 证据链: '',
})));
}
/* ══════════════════════════════════════════════════════════════════
* ⑩-⑬ 共同分析本体:SoW 三组要求的共用底层
* ⑩ 分析问题 —— 判断顺序(A-01..A-05)+ 指标组合(M-01..M-07)
* ⑪ 因子定义 —— IE 因子清单 → 六大损失的量化标准(起止判定 + 口径约束)
* ⑫ 改善对策 —— 由损失结构触发的对策候选(SMED / TPM / 短停 / 质量)
* ⑬ 成本参数 —— 每分钟停机损失与 ROI 的参数位(费率未签字 → 不出金额)
* 这四类都是**方法论对象**,不含统计结果;命中照旧回到 L3 的损失/绩效/事件。
* ══════════════════════════════════════════════════════════════════ */
const objLabel = (id: string) => DEFS.find((d) => d.id === id)?.name ?? id;
interface CardDef {
id: string; kind: '分析逻辑' | '指标组合'; question: string;
order: string; dims: string; metrics: string; sources: string[];
trap: string; out: string; status: '可算' | '部分可算' | '缺口'; gap: string;
}
/** SoW「生产分析逻辑」五步 + 「生产指标组合」七组,原文的判断顺序与误判提醒逐条落库。 */
const CARD_DEFS: CardDef[] = [
{
id: 'A-01', kind: '分析逻辑', question: '计划完成了没有?完成后再看产出效率是否正常',
order: '① 计划达成 → ② 欠产缺口 → ③ 产出效率',
dims: '计划量 vs 实际产出、欠产数量、计划达成率',
metrics: '计划达成率、欠产数、OEE 实际档',
sources: ['performance', 'lot', 'loss'],
trap: '只看完成比例会被订单结构摊薄:小产量订单与大产量订单的比例变化会误导达成率,须同时看欠产数量与订单结构',
out: '转入 A-02 效率三因子拆解',
status: '部分可算',
gap: '排产计划量未接入:当前计划档取 IE 参数推算(C27/C28 待签字),订单结构(小单/大单比例)未接入',
},
{
id: 'A-02', kind: '分析逻辑', question: '效率异常时,先拆 OEE 判断是时间、速度还是质量损失',
order: '① A 时间损失 → ② P 速度损失 → ③ Q 质量损失',
dims: '停机/换型/短停(A)、节拍偏差(P)、良率(Q)',
metrics: 'A/P/Q 三因子、六大损失桶时长、计划档→实际档 Δ',
sources: ['performance', 'loss', 'factorDef', 'caliber'],
trap: '不要从 OEE 直接跳到根因:先定位损失桶再归因;Δ 分解顺序固定 A→P→Q,换序会换结论',
out: '分头进入 A-03(停机)或 A-04(质量)下钻',
status: '可算',
gap: '',
},
{
id: 'A-03', kind: '分析逻辑', question: '发现停机后,继续分析设备、故障类型、发生频率和产能影响',
order: '① 设备 → ② 故障类型 → ③ 发生频率 → ④ 产能影响',
dims: 'DOWN/JAM 状态段、事件码、故障类型 Pareto、重复停机设备',
metrics: '停机时长、停机次数、单次时长、瓶颈站产能损失',
sources: ['stateSegment', 'event', 'equipment', 'factorDef'],
trap: '只看总时长会漏掉高频短停:频次反映稳定性,时长反映大损失,两者要并列看',
out: '按影响程度排序,转 A-05 排优先级',
status: '部分可算',
gap: '故障类型真因(人机料法环测)依赖 D 类事件补录;缺 EA 到场/离场时间戳时无法拆分「故障」与「等维修」',
},
{
id: 'A-04', kind: '分析逻辑', question: '发现质量问题后,拆产品、产线、工单、缺陷',
order: '① 产品 → ② 产线 → ③ 工单 → ④ 缺陷',
dims: '批次良率、工单良率、缺陷分类、返工/复筛批次',
metrics: '良率、FTRD、返工率、rescreen 批次数',
sources: ['lot', 'event', 'equipment', 'lineTopology'],
trap: '最终良率高不代表生产过程稳定:一次合格率(FTRD)下降与返工持续增加,质量成本已在上升',
out: '质量损失计入 Q,转 A-05 排优先级',
status: '部分可算',
gap: '产品/工单维度需 MES 工单号贯通(lot 窗口只到批次);缺陷分类无数据源,FTRD 与返工数据未接入',
},
{
id: 'A-05', kind: '分析逻辑', question: '把异常按影响程度和产能损失排出优先级,形成整改',
order: '① 影响程度 × 产能损失 → ② 优先级 → ③ 立项 → ④ 验证',
dims: '六桶时长排名、Δ vs 计划档、占用瓶颈产能、可执行对策',
metrics: '损失占比、产能损失、对策预期收益区间',
sources: ['loss', 'performance', 'improvement'],
trap: '收益给区间不给点值;金额化须费率签字后才可测算,不允许先给金额再倒推',
out: '生成改善对策候选;四项必填齐备才派单',
status: '部分可算',
gap: '优先级权重口径未定义(影响程度与产能损失如何加权);任务中心 W3-B 未落地;金额化需成本参数签字',
},
{
id: 'M-01', kind: '指标组合', question: '计划达成(完成比例)+ 欠产数量(缺口)',
order: '先看达成比例,再拆欠产缺口',
dims: '计划量/实际产出/缺口、订单结构(小单 vs 大单)',
metrics: '计划达成率、欠产数量、订单结构占比',
sources: ['performance', 'lot'],
trap: '小产量订单与大产量订单之间的比例会误导达成率:大单占比高时比例好看,欠产绝对值仍可能很大',
out: '欠产转 M-02 看投入产出关系',
status: '部分可算',
gap: '排产计划量与订单结构未接入;计划档当前取 IE 参数推算',
},
{
id: 'M-02', kind: '指标组合', question: '产量 + 工时 + 单位工时产出',
order: '产量增长来自效率,还是来自增加投入?',
dims: '产量、工时(PPT/RT)、单位工时产出',
metrics: '产量、工时、产量/工时',
sources: ['performance', 'stateSegment', 'lot'],
trap: '如果产量增加但工时增长更快,可能效率在下降——必须看单位工时产出,而不是总产量',
out: '单位工时产出下降转 A-02 拆 OEE',
status: '可算',
gap: '',
},
{
id: 'M-03', kind: '指标组合', question: 'OEE + 三项损失',
order: '先看整体效率变化,再看三项损失来源',
dims: 'A/P/Q、六大损失桶、Δ vs 计划档',
metrics: 'OEE、A/P/Q、损失桶占比',
sources: ['performance', 'loss', 'factorDef'],
trap: '不要直接从 OEE 跳到根因分析:先看整体效率变化,再看三项损失来源,最后才做根因',
out: '损失桶排名转 A-03 / A-04 下钻',
status: '可算',
gap: '',
},
{
id: 'M-04', kind: '指标组合', question: '停机时长 + 停机次数',
order: '时长看大损失,次数看稳定性',
dims: 'DOWN/JAM 时长与次数、单次时长分布、设备排名',
metrics: '停机时长、停机次数、次均时长',
sources: ['stateSegment', 'event'],
trap: '停机时长看大损失,停机次数看稳定性;高频短停往往比偶发长停更容易被忽略',
out: '高频短停转 P-03 对策,长停机转 P-02',
status: '部分可算',
gap: 'Jam 多为 D 类人工录入,频次可信度受补录完整度影响;频次告警阈值待定',
},
{
id: 'M-05', kind: '指标组合', question: '良率 + 一次合格率(FTRD)+ 返工',
order: '最终良率 → 一次合格率 → 返工/复筛',
dims: '批次良率、FTRD、返工率、rescreen 批次',
metrics: '良率、FTRD、返工率',
sources: ['lot', 'event'],
trap: '最终良率高不代表生产过程稳定:一次合格率下降与返工持续增加,说明质量成本已经上升',
out: '质量成本上升转 P-05 质量改善',
status: '缺口',
gap: 'FTRD 与返工数据源未接入;当前只能看批次良率与 rescreen 事件定义,不能合成 FTRD',
},
{
id: 'M-06', kind: '指标组合', question: '设备利用率 + 在制品',
order: '利用率高是有效产出,还是在制品堆积/等待?',
dims: '设备开动率、在制品数量与等待时长',
metrics: '设备利用率、WIP、等待时长',
sources: ['equipment', 'stateSegment'],
trap: '设备利用率高不一定代表现场效率高:可能只是在制品堆积或工单等待把设备"撑"起来了',
out: '利用率与 WIP 背离转 A-01 查计划与齐套',
status: '缺口',
gap: '在制品(WIP)数据源未接入;利用率口径待 IE 定义(C 系列口径)',
},
{
id: 'M-07', kind: '指标组合', question: '产量 + 设备负荷 + 故障趋势',
order: '短期产量增长是否在透支设备稳定性?',
dims: '产量、设备负荷、维修次数与故障间隔趋势',
metrics: '产量、负荷率、维修次数、MTBF 趋势',
sources: ['performance', 'equipment', 'event'],
trap: '短期产量增长伴随高负荷、维修次数增加,可能在透支设备稳定性——要把故障趋势和产量放在同一时间轴上看',
out: '故障趋势恶化转 P-02 TPM 预防维护',
status: '缺口',
gap: '设备负荷与维修记录无数据源;MTBF 需维修工单接入,当前只有事件表里的停机记录',
},
];
function cardRows(): Row[] {
return CARD_DEFS.map((c) => ({
编号: c.id,
类别: c.kind,
分析问题: c.question,
判断顺序: c.order,
展开维度: c.dims,
关键指标: c.metrics,
取数对象: c.sources.map(objLabel).join('、'),
误判提醒: c.trap,
输出承接: c.out,
可达性: c.status,
缺口说明: c.gap,
}));
}
/* ── ⑪ 因子定义:IE 因子清单 → 六桶归属 + 起止判定 + 量化规则 ── */
interface QuantDef { start: string; end: string; rule: string; caliber: string }
/** 20 个二级因子组的判定口径(键=factorL2);阈值只引口径原文,不另造门槛。 */
const QUANT_DEFS: Record<string, QuantDef> = {
'PM': { start: '末 lot trackout(通知 PM 前机台清空)', end: '前三 boat 进入 reflow', rule: 'PM 窗口整段计时', caliber: '计划停机·不进六桶' },
'NPI Engineering': { start: '量产末 lot unload OTA', end: 'SMR 末 lot unload OTA', rule: '工程借用整段计时', caliber: '计划类·不进六桶' },
'SMR 借机': { start: 'SMR Leader 现场确认机台与 OTA 清空', end: '加下个产品换线理论时间', rule: '工程借用整段计时', caliber: '计划类·不进六桶' },
'PE 借机': { start: 'APS 借机时点(量产延迟取现场清空)', end: '实际起点 + 计划借机时长 − 理论换线', rule: '工程借用整段计时', caliber: '计划类·不进六桶' },
'Run Dummy': { start: '上 lot 末 boat 进 DPVS 后,空 boat 进 DPVS', end: '新 lot 开启 Datacon', rule: '工程借用整段计时', caliber: '计划类·不进六桶' },
'Lab debug': { start: '实验室调试任务开始', end: '调试任务结束', rule: '工程借用整段计时', caliber: '计划类·不进六桶' },
'Conversion': { start: '上产品材料清空、下产品材料备齐', end: '与 Setup 共用判定点(S-14 以 Setup 开始为终点)', rule: '整段计入 CHANGEOVER', caliber: 'C07 一级因子标准归属' },
'Setup': { start: 'Xray 图保存 +5min(S-15)', end: '第一盘炉后确认 +5min(S-16)', rule: '成对 INTERVAL;S-18 取 Xray 保存 −5min。±5min 是录入固定偏移,不是派生', caliber: 'C08 / C07;换型调整→CHANGEOVER' },
'Lot setup loss': { start: '上 lot 末 boat 后放隔板再 +1min', end: '新 lot 开启 Datacon', rule: '整段计入 CHANGEOVER', caliber: 'C07 一级因子标准归属' },
'换 lot': { start: 'FT 换 lot 开始(F-47 / A-55)', end: '第一个新 lot 产出(F-48 / A-56)', rule: '整段计入 CHANGEOVER', caliber: 'C07 一级因子标准归属' },
'rescreen': { start: '重测/复筛批次开始(F-49 / A-57)', end: '重测/复筛结束(F-50 / A-58)', rule: '单独计时,不并进过程不良', caliber: '质量成本来源;C07' },
'Down': { start: '按灯/通知 EA 与 MT2 Down 取最早可信时间(S-27)', end: 'EA 验证恢复(S-28);logfile 抓取 S-29', rule: '单次连续停机 >300s 归 DOWN', caliber: 'C08 / C14 按单次连续时长;C13 差异 >5min 转人核' },
'维修等待': { start: 'Down 段内开始等待 EA', end: 'EA 到场', rule: '缺 EA 到场/离场时间戳时不可拆,标未计时', caliber: '未计时子因子不摊数' },
'Jam time': { start: 'OP 口头通知 EA(S-30)', end: 'EA 验证无异常恢复(S-31)', rule: '单次连续停机 ≤300s 归 JAM', caliber: 'C08 300s 分界' },
'短停': { start: 'logfile 抓取瓶颈站 ≤5min 停机起点(S-32)', end: 'logfile 抓取停机终点', rule: '与 Jam 同桶,仅计时途径不同', caliber: 'C08 / C07' },
'待料': { start: '等待物料/上游断供起点', end: '物料到位恢复生产', rule: '非计划待料计入 IDLE_MINOR(计划待料不进六桶)', caliber: 'C07;计划/非计划待料严格分开' },
'人员等待': { start: 'OP 未到岗/交接等待起点', end: '人员到位恢复', rule: '计入 IDLE_MINOR', caliber: 'C07 一级因子标准归属' },
'关机': { start: 'APS 关机时点(结合最后 lot unload 清空)', end: 'APS 开线时点(第一个 lot load)', rule: '计划停机整段计时', caliber: '计划停机·不进六桶' },
'APS plan idle': { start: 'APS plan idle 时点且机台未生产', end: '生产恢复', rule: '计划待料整段计时', caliber: '计划待料·不进六桶' },
'5S': { start: '5S 开始', end: '5S 结束', rule: '计划类整段计时', caliber: '计划停机·不进六桶' },
};
/** 公式派生因子(无事件码):速度/过程不良/开机不良 + FT Index。 */
const DERIVED_FACTORS: { l1: string; l2: string; bucket: LossBucket; rule: string; caliber: string; status: string; gap: string }[] = [
{
l1: '速度损失', l2: '速度降低', bucket: 'SPEED',
rule: '由节拍偏差推导:P = 良品数×ICT / RT;无成对事件证据',
caliber: '推导量·不提供事件级下钻', status: '部分可算', gap: '推导量:由节拍偏差推导,无事件级证据,不能下钻到原始行号',
},
{
l1: '质量损失', l2: '过程不良', bucket: 'PROCESS_DEFECT',
rule: '由检测结果推导:Q 缺口 = 投入×(1−良率),再换算 ICT',
caliber: '推导量·不提供事件级下钻', status: '部分可算', gap: '检测明细未接入,只有批次良率;不能拆到具体缺陷类型',
},
{
l1: '质量损失', l2: '开机不良', bucket: 'STARTUP_DEFECT',
rule: '首件不良数×ICT(换型后爬坡/首件不良/rescreen 复测)',
caliber: '推导量;首检未接入时计 0 并标缺口', status: '缺口', gap: '首件检验数据未接入,三日开机不良桶均为 0——是数据缺口而不是没有开机不良',
},
{
l1: 'Index loss', l2: 'FT Index', bucket: 'SPEED',
rule: 'Index 损失 = [Index/(Index+Test)]×(1−OE Eff Loss−Jam Factor);Index 1.5s、Test 30s;GPIB 0.5s 列于输入但未进入公式',
caliber: 'P = 1 − (OE Eff Loss + Index 损失 + Jam Factor)', status: '部分可算',
gap: 'Index/Test 为方案给定参数,未在客户日志实测;UPH 推导与 GPIB 用途待确认(Q6)',
},
];
interface FactorGroup { l1: string; l2: string; bucket: LossBucket | null; codes: string[]; gross: string }
function factorGroups(): FactorGroup[] {
const m = new Map<string, FactorGroup>();
for (const e of EVENTS_48) {
const k = `${e.factorL1}|${e.factorL2}`;
const g = m.get(k);
if (g) g.codes.push(e.code);
else m.set(k, { l1: e.factorL1, l2: e.factorL2, bucket: e.bucket, codes: [e.code], gross: e.grossCategory });
}
return [...m.values()];
}
function factorRows(): Row[] {
const groups: Row[] = factorGroups().map((g, i) => {
const q = QUANT_DEFS[g.l2];
return {
因子编号: `F-${String(i + 1).padStart(2, '0')}`,
一级因子: g.l1,
二级因子: g.l2,
归口用词: g.gross,
损失桶: g.bucket ? BUCKET_LABEL[g.bucket] : '计划类·不进六桶',
事件码: g.codes.join(' / '),
事件数: g.codes.length,
判定起点: q?.start ?? '按事件触发点',
判定终点: q?.end ?? '按事件配对点',
量化规则: q?.rule ?? '整段计时',
口径约束: q?.caliber ?? 'C07 一级因子标准归属',
状态: g.bucket ? '已定义' : '计划类',
缺口说明: q ? '' : '判定口径待 IE 补充',
};
});
const derived: Row[] = DERIVED_FACTORS.map((f, i) => ({
因子编号: `F-${String(factorGroups().length + i + 1).padStart(2, '0')}`,
一级因子: f.l1,
二级因子: f.l2,
归口用词: '—(公式派生)',
损失桶: BUCKET_LABEL[f.bucket],
事件码: '—(公式派生)',
事件数: 0,
判定起点: '—',
判定终点: '—',
量化规则: f.rule,
口径约束: f.caliber,
状态: f.status,
缺口说明: f.gap,
}));
return [...groups, ...derived];
}
/* ── ⑫ 改善对策:由损失结构触发的对策候选(SMED / TPM / 短停 / 速度 / 质量) ── */
interface PlayDef {
id: string; name: string; bucket: string; trigger: string; basis: string[];
kpi: string; verify: string; gate: string; status: string; gap: string;
}
const PLAY_DEFS: PlayDef[] = [
{
id: 'P-01', name: 'SMED 快速换线', bucket: '换型调整→CHANGEOVER',
trigger: 'CHANGEOVER 占 PPT 排名居前且换型次数高(门槛待 IE 定)',
basis: ['loss', 'event', 'factorDef'], kpi: '换型时长均值、换型次数、Setup 损失占比',
verify: '改善前后同口径版本对比,收益给区间',
gate: '换型时长/次数/占比的触发门槛须由 IE 定版',
status: '规则就绪·门槛待定',
gap: '触发门槛(占比与次数)未签字;对策只出候选,不自动派单(任务中心 W3-B)',
},
{
id: 'P-02', name: 'TPM 预防维护', bucket: '故障停机→FAULT',
trigger: '故障停机次数或故障间隔(MTBF)趋势恶化,且停机器 Pareto 集中',
basis: ['stateSegment', 'event', 'equipment'], kpi: 'MTBF、MTTR、Down 损失占比',
verify: '改善前后同口径对比故障次数与时长',
gate: '维修工单/维修记录须接入才能算 MTBF',
status: '规则就绪·数据源缺口',
gap: '维修记录未接入,当前只有事件表的停机段;故障类型真因依赖 D 类补录',
},
{
id: 'P-03', name: '短停(Jam)治理', bucket: '空转短停→IDLE_MINOR',
trigger: '高频短停:停机次数排名前列但单次 <300s,时长不大易被忽略',
basis: ['stateSegment', 'event', 'factorDef'], kpi: '短停次数、次均时长、短停占比',
verify: '同一设备改善前后短停次数对比',
gate: '频次告警阈值待定;Jam 多为 D 类人工录入',
status: '规则就绪·门槛待定',
gap: '频次阈值未定义;补录完整度影响次数可信度(DQ-11 超时升级)',
},
{
id: 'P-04', name: '速度/Index 损失治理', bucket: '速度降低→SPEED',
trigger: 'P 低于计划档,且 Index 损失或节拍偏差占比高',
basis: ['performance', 'loss', 'factorDef'], kpi: 'P 因子、Index 损失、节拍偏差',
verify: '改善前后同口径 P 与单位工时产出对比',
gate: 'FT Index/Test 参数须实测确认(Q6)',
status: '规则就绪·数据源缺口',
gap: 'FT Index 为方案给定参数,未在客户日志实测;UPH 推导不明(Q6)',
},
{
id: 'P-05', name: '质量改善(FTRD/返工)', bucket: '过程不良+开机不良→PROCESS/STARTUP_DEFECT',
trigger: '最终良率高但 FTRD 下降、返工/rescreen 持续增加',
basis: ['lot', 'event', 'factorDef'], kpi: 'FTRD、返工率、质量成本、rescreen 批次',
verify: '同产品/工单改善前后良率与返工率对比',
gate: 'FTRD 与返工数据源须接入;缺陷分类须定义',
status: '规则就绪·数据源缺口',
gap: 'FTRD/返工未接入;缺陷分类无数据源,当前只能看到批次良率',
},
{
id: 'P-06', name: '排产与齐套治理', bucket: '计划待料/计划停机→不进六桶',
trigger: '计划待料、APS plan idle 或非计划待料累计时长居前',
basis: ['stateSegment', 'event', 'lot'], kpi: '计划待料时长、非计划待料时长、齐套率',
verify: '同线体前后期计划待料时长对比',
gate: 'APS 排产与齐套数据须接入',
status: '规则就绪·数据源缺口',
gap: 'APS/齐套数据未接入;计划类时间不进六桶,须单独看,不能与 OEE 损失混算',
},
];
function playRows(): Row[] {
return PLAY_DEFS.map((p) => ({
编号: p.id,
对策: p.name,
目标损失: p.bucket,
触发条件: p.trigger,
依据对象: p.basis.map(objLabel).join('、'),
度量KPI: p.kpi,
验证方式: p.verify,
落地门槛: p.gate,
状态: p.status,
缺口说明: p.gap,
}));
}
/* ── ⑬ 成本参数:每分钟停机损失与 ROI 的参数位 ── */
interface CostDef {
id: string; name: string; unit: string; use: string; formula: string; source: string; gap: string;
}
const COST_DEFS: CostDef[] = [
{ id: 'C-01', name: '设备折旧率', unit: '元/小时/台', use: '每分钟停机损失之设备占用部分', formula: '折旧率 ÷ 60 × 停机分钟数', source: '财务固定资产台账', gap: '未提供:费率与折旧年限待财务确认' },
{ id: 'C-02', name: '人工费率', unit: '元/小时/人', use: '停机/等待期间的人工成本', formula: '费率 ÷ 60 × 停机分钟数 × 在岗人数', source: '财务/HR 人工成本', gap: '未提供:直接人工与间接人工攤分口径待财务确认' },
{ id: 'C-03', name: '能源单价', unit: '元/kWh', use: '停机期间的能源基载与重启能耗', formula: '单价 × 设备功率 × 小时数', source: '动力/能源账单', gap: '未提供:分时电价与设备功率表待接入' },
{ id: 'C-04', name: '良品边际价值', unit: '元/件', use: '欠产与不良的产出损失折算', formula: '良品数缺口 × 边际价值(或按瓶颈节拍折算产能损失)', source: '财务毛利/产品定价', gap: '未提供:用边际贡献还是售价,须财务定口径' },
{ id: 'C-05', name: '返工/复筛成本', unit: '元/批(或元/件)', use: 'rescreen 与返工批次的质量成本', formula: '返工批次 × 单批返工成本', source: '财务质量成本科目', gap: '未提供:返工成本归集科目待财务确认' },
{ id: 'C-06', name: '每分钟停机损失', unit: '元/分钟', use: '损失桶 → 金额的统一换算口径', formula: '折旧/60 + 人工/60 + 能耗×功率/60 + 产出损失(瓶颈节拍折算)', source: 'C-01 ~ C-04 组合', gap: '公式已建模,参数未签字 → 拒绝输出任何金额' },
{ id: 'C-07', name: 'ROI 评估模型', unit: '比率', use: '量化系统上线后的经营效益', formula: 'ROI =(年化损失减少 + 质量成本下降 − 系统投入)÷ 系统投入', source: 'C-06 + 改善前后对比 + 项目投入清单', gap: '缺基线、费率与收益区间三者之一即拒绝测算(与 OA-BENEFIT 同一门槛)' },
];
function costRows(): Row[] {
return COST_DEFS.map((c) => ({
参数编码: c.id,
参数名: c.name,
单位: c.unit,
用途: c.use,
计算口径: c.formula,
来源: c.source,
当前值: '—(未提供)',
签字状态: '待财务签字',
缺口说明: c.gap,
}));
}
/* ══════════════════════════════════════════════════════════════════
* 对象定义:行集懒算一次就缓存,视图多处取 length 不必反复重建
* ══════════════════════════════════════════════════════════════════ */
interface OntoDef {
id: string; name: string; en: string; short: string; color: string;
desc: string; source: string;
rows: () => Row[];
present: (r: Row) => OntInstance;
}
const DEFS: OntoDef[] = [
{
id: 'equipment', name: '设备', en: 'Equipment', short: '设备台账', color: '#3b82f6',
desc: '17 台种子设备台账:沿用客户既有编码(真实编码 5 个,其余为演示占位码并标注),'
+ '含能力矩阵、按设备可配置的间隙阈值、ICT 来源与解析陷阱。无日志设备标缺口,不假装有数据。',
source: 'data/oee/devices.ts(规划书附录 D.1/D.2/D.3)',
rows: equipmentRows,
present: (r) => {
const d = DEVICE_BY_ID[s(r['设备编码'])];
const cap = d?.capability ?? 1;
const noLog = d ? !d.hasLog : false;
const excluded = d ? !d.countsForOee : false;
return {
id: s(r['设备编码']), title: s(r['设备编码']),
sub: `${s(r['设备名称'])} · ${s(r['工站'])}`,
meta: `${s(r['区域'])} · ${s(r['计算模板'])} · 阈值 ${s(r['间隙阈值min'])}min · ICT ${
d && d.ictSec > 0 ? `${d.ictSec}s/${d.unit}` : '不适用/待 IE'}`,
value: `信号 ${'★'.repeat(cap)}${'☆'.repeat(3 - cap)}`,
badge: excluded ? '不计 OEE' : noLog ? '无日志' : s(r['台账编码来源']) === 'DEMO' ? '占位码' : '有日志',
tone: excluded ? 'info' : noLog ? 'danger' : cap === 3 ? 'success' : cap === 2 ? 'info' : 'warning',
};
},
},
{
id: 'lineTopology', name: '产线拓扑', en: 'LineTopology', short: '产线拓扑', color: '#818cf8',
desc: 'SRF 串行线(缓冲解耦为主口径)/ FT 并行机群(按投入量加权)/ ASLT 12 Site(事件驱动)。'
+ '三套模板不同构,不可混用;线体合成引擎待 W2 接入,当前只呈现拓扑与瓶颈站,不出合成数字。',
source: 'data/oee/devices.ts LINES(规划书 1.1 / 4.6.1)',
rows: lineRows,
present: (r) => ({
id: s(r['线体编码']), title: s(r['线体编码']), sub: s(r['线体名称']),
meta: `${s(r['区域'])} · ${s(r['设备台数'])} 台(计入 OEE ${s(r['计入OEE台数'])} 台)· ${s(r['计算模板'])}`,
value: `瓶颈 ${s(r['瓶颈设备'])}`,
badge: '合成待接入', tone: 'warning',
}),
},
{
id: 'lot', name: '批次', en: 'Lot', short: '批次归因', color: '#22d3ee',
desc: '三日种子的 lot 窗口,由产出锚点(完成行)识别。DEK 日志直接印 lot 号 → 设备自识别,置信度 1.00。'
+ '只有开始行没有完成行的 lot 不造窗口(N=0 会让 P/Q 失去意义)。工程批按 C10 默认剔除。',
source: 'L3 oeeService → adapterDek.lotWindowsFromAnchors',
rows: lotRows,
present: (r) => ({
id: `${s(r['业务日'])}|${s(r['批次号'])}`,
title: s(r['批次号']), sub: `${s(r['业务日'])} · ${s(r['设备'])}`,
meta: `${hm(s(r['开始时刻']))}→${hm(s(r['结束时刻']))} · 投入 ${num(r['投入数'])} · 合格 ${num(r['合格数'])}`,
value: `良率 ${pct2(r['批次良率'])}`,
badge: s(r['归因方式']),
tone: r['工程批'] === '是' ? 'info' : filled(r['批次良率']) ? 'success' : 'warning',
}),
},
{
id: 'event', name: '事件', en: 'Event', short: '事件流', color: '#a78bfa',
desc: '48 条事件定义(六-3 归口用词 → 六-1 损失桶由 GROSS_TO_BUCKET 现推,20 个计划类事件不进六桶)'
+ '+当期业务日的事件实例。实例带原始/校正双时间字段与原始日志行号,是血缘下钻的终点。',
source: 'data/oee/events48.ts + L3 normalize.events',
rows: eventRows,
present: (r) => {
const isDef = r['类别'] === '定义';
const g = (s(r['自动化等级']) || 'E') as EventGrade;
return {
id: isDef ? s(r['事件码']) : s(r['实例id']),
title: isDef ? s(r['事件码']) : `${s(r['事件码'])} · ${hhmmss(s(r['校正时刻']))}`,
sub: s(r['事件名']),
meta: isDef
? `${s(r['区域'])} · ${s(r['等级含义'])} · ${s(r['损失桶'])} · 当期 ${num(r['当期实例数'])} 次`
: `${s(r['设备'])} · 行 ${num(r['原始行号'])} · ${s(r['配对角色']) || '未配对'}`,
value: isDef ? `${s(r['归口用词'])}` : s(r['已校正']) === '是' ? '已校钟' : '原始时刻',
badge: isDef ? s(r['自动化等级']) : s(r['类别']),
tone: gradeTone(g),
};
},
},
{
id: 'stateSegment', name: '状态段', en: 'StateSegment', short: '状态段', color: '#34d399',
desc: '当期业务日的设备状态段,十态抢占优先级(PLAN_STOP 1 → IDLE 10,UNKNOWN 99 不计分母)。'
+ '跨班拆分共享 splitGroupId,PM 窗口内停机保留影子双记录,间隙填充段标来源便于审计。',
source: 'L3 oeeService → stateMachine.buildSegments',
rows: segmentRows,
present: (r) => {
const st = s(r['状态码']);
const tone: Tone = st === 'RUN' ? 'success'
: st === 'UNKNOWN' ? 'danger'
: st === 'IDLE' ? 'warning'
: st === 'DOWN' || st === 'JAM' ? 'danger'
: st === 'PLAN_STOP' || st === 'PM' ? 'info' : 'warning';
return {
id: s(r['段id']),
title: `${s(r['状态名'])} ${hm(s(r['开始时刻']))}→${hm(s(r['结束时刻']))}`,
sub: `${s(r['设备'])} · ${s(r['业务日'])}`,
meta: `${num(r['时长秒'])}s · 优先级 ${s(r['抢占优先级'])} · ${s(r['班次'])} · 事件 ${num(r['事件数'])} 个`,
value: s(r['归口损失桶']),
badge: r['间隙填充'] === '是' ? '间隙填充' : st,
tone,
};
},
},
{
id: 'loss', name: '损失', en: 'Loss', short: '损失结构', color: '#f87171',
desc: '六-1 六大损失桶(互斥完备,映射 A/P/Q)+已计时因子+未计时子因子。'
+ '速度降低与两类不良由节拍偏差推导,无成对事件证据,显式标"推导量";'
+ '未计时子因子时长留空不填 0,缺什么就说什么。'
+ '当期 DEK 种子停机段只含单一子因子,故未计时子因子实例为 0(引擎路径由校验脚本合成输入验证,不造实例充数)。',
source: 'L3 oeeService → lossBuckets.mapToBuckets',
rows: lossRows,
present: (r) => {
const kind = s(r['类别']);
const sec = r['时长秒'];
return {
id: s(r['编码']), title: s(r['名称']),
sub: `${kind} · 归属 ${s(r['归属因子'])}`,
meta: `${s(r['一级因子']) || s(r['归口损失桶']) || '—'} · 状态段 ${num(r['状态段数'])} 个 · 事件 ${num(r['事件实例数'])} 个`,
value: typeof sec === 'number' ? `${num(sec)}s · ${pct2(r['占PPT'])}` : '未计量',
badge: kind === '损失桶' ? (r['推导量'] === '是' ? '推导量' : '有事件证据') : kind,
tone: kind === '未计时子因子' ? 'info' : r['推导量'] === '是' ? 'warning' : 'danger',
};
},
},
{
id: 'performance', name: '绩效', en: 'Performance', short: '三层绩效', color: '#fbbf24',
desc: '三日 × 三档(理论/计划/实际)=9 条结果,三档共用同一分母 PPT=CT−PDT−UNKNOWN。'
+ '顺序替代固定 A→P→Q;每条都带口径版本号,跨版本对比默认拒绝。'
+ '理论/计划档是附录 E 默认值推算,C27/C28 待 IE 签字,不得当作客户确认口径。',
source: 'L3 oeeService → threeTier.calcThreeTier',
rows: performanceRows,
present: (r) => {
const blocked = r['DQ阻断'] === '是';
const isActual = r['档位'] === '实际档';
return {
id: `${s(r['业务日'])}|${s(r['档位'])}`,
title: `${s(r['业务日'])} · ${s(r['档位'])}`,
sub: `${s(r['设备'])} · ${s(r['口径版本'])}`,
meta: `A ${pct2(r['A'])} · P ${pct2(r['P'])} · Q ${pct2(r['Q'])} · PPT ${num(r['PPT秒'])}s`,
value: `OEE ${pct2(r['OEE'])}`,
badge: blocked ? '结论暂缓发布' : isActual ? '可发布' : '口径推算',
tone: blocked ? 'danger' : isActual ? 'success' : 'info',
};
},
},
{
id: 'caliber', name: '口径', en: 'Caliber', short: '口径配置', color: '#94a3b8',
desc: '28 项口径 × 当前版本。priority P0/P1/P2 影响"能不能算",isSensitivityKey 影响"算出来是多少",'
+ '两者不是同一集合。本次不安排口径工作坊 → signedOff 全 false,P0 的 16 项标灰(待 IE 签字),不标绿。',
source: 'data/oee/calibers28.ts(规划书附录 E 逐条转录)',
rows: caliberRows,
present: (r) => {
const p0 = r['优先级'] === 'P0';
const signed = r['已签字'] === '是';
return {
id: s(r['口径编号']), title: s(r['口径编号']), sub: s(r['口径名称']),
meta: `${s(r['优先级'])} · 归口 ${s(r['归口责任人'])} · 默认「${s(r['默认值'])}」`,
value: s(r['签字状态']),
badge: r['是敏感性关键项'] === '是' ? `敏感性:${s(r['敏感性议题'])}` : s(r['优先级']),
// ★ P0 未签字 → 中性 info(灰),绝不 success(绿)
tone: signed ? 'success' : p0 ? 'info' : 'warning',
};
},
},
{
id: 'improvement', name: '改善', en: 'Improvement', short: '改善闭环', color: '#fb923c',
desc: '当前实例=三日 DQ 命中(12 条规则里三条阻断级:DQ-06 未归因>5% / DQ-08 主数据缺失 / DQ-12 口径版本不一致)。'
+ '改善任务与六态流转在 W3-B 落地,**当前无任务实例,不编造**;四项必填闸门与证据链要求先以规则明示。',
source: 'L3 oeeService → dq.runDq(任务中心待 W3-B)',
rows: improvementRows,
present: (r) => ({
id: s(r['编号']),
title: `${s(r['规则码'])} · ${s(r['业务日'])}`,
sub: s(r['规则名']),
meta: `${s(r['设备']) || '全设备'} · ${s(r['命中条件'])}`,
value: r['是否阻断'] === '是' ? '阻断发布' : s(r['处置动作']).slice(0, 12),
badge: s(r['处理状态']),
tone: r['是否阻断'] === '是' ? 'danger' : filled(r['缺口说明']) ? 'info' : 'warning',
}),
},
{
id: 'analysisCard', name: '分析问题', en: 'AnalysisCard', short: '分析卡', color: '#38bdf8',
desc: 'SoW 两组分析要求的共用入口:分析逻辑五步(A-01 计划达成 → A-05 排优先级)'
+ '+指标组合七组(M-01 计划达成/欠产 … M-07 产量/负荷/故障趋势)。每张卡都带判断顺序、'
+ '展开维度、取数对象和**误判提醒**(小/大订单比例误导、工时增长快于产量、不要从 OEE 直接跳根因、'
+ '高频短停易被忽略、良率高≠过程稳定、利用率高≠效率高、高负荷透支设备)。',
source: 'SoW 生产分析逻辑 / 生产指标组合(逐条转录,数字回到 L3)',
rows: cardRows,
present: (r) => {
const status = s(r['可达性']);
return {
id: s(r['编号']), title: `${s(r['编号'])} · ${s(r['类别'])}`,
sub: s(r['分析问题']),
meta: `${s(r['判断顺序'])} · 取数 ${s(r['取数对象'])}`,
value: s(r['关键指标']),
badge: status,
tone: status === '可算' ? 'success' : status === '部分可算' ? 'warning' : 'info',
};
},
},
{
id: 'factorDef', name: '因子定义', en: 'FactorDef', short: '因子定义', color: '#e879f9',
desc: 'IE 因子清单 → OEE 六大损失的量化标准:20 个二级因子组(每码唯一归口)'
+ '+4 个公式派生因子(速度/过程不良/开机不良/FT Index)。逐条写明判定起点、判定终点、'
+ '量化规则与口径约束——Setup 取 Xray 保存 +5min 至首盘炉后确认 +5min(±5min 是录入偏移不是派生)、'
+ 'Jam 与 Down 以单次连续 300s 分界(C08/C14)、Index 损失按 [Index/(Index+Test)]×(1−OE Eff Loss−Jam Factor)。',
source: 'data/oee/events48.ts(附录 C.2)+ docs/后端引擎数据结构规划书-v0.1-2026-11-18.md(FT Index)',
rows: factorRows,
present: (r) => {
const status = s(r['状态']);
const plan = s(r['损失桶']) === '计划类·不进六桶';
return {
id: s(r['因子编号']),
title: `${s(r['一级因子'])} / ${s(r['二级因子'])}`,
sub: `${s(r['损失桶'])}${s(r['归口用词']) !== '—(公式派生)' ? ` · ${s(r['归口用词'])}` : ''}`,
meta: `${s(r['事件码'])} · 判定 ${s(r['判定起点'])} → ${s(r['判定终点'])}`,
value: s(r['量化规则']),
badge: status,
tone: status === '缺口' ? 'danger' : status.startsWith('部分') ? 'warning' : plan ? 'info' : 'success',
};
},
},
{
id: 'improvePlaybook', name: '改善对策', en: 'ImprovementPlaybook', short: '改善对策', color: '#f472b6',
desc: '由损失结构触发的对策候选:SMED 快速换线(CHANGEOVER)、TPM 预防维护(FAULT)、'
+ '短停治理(IDLE_MINOR)、速度/Index 治理(SPEED)、质量改善(过程/开机不良)、排产齐套治理(计划类)。'
+ '每张对策都挂触发条件、依据对象、度量 KPI、验证方式与**落地门槛**;只出候选,'
+ '四项必填齐备才派单(任务中心 W3-B 未落地,不造任务实例)。',
source: 'SoW 改善建议逻辑规则(SMED/TPM)+ 现有损失桶/事件因子',
rows: playRows,
present: (r) => ({
id: s(r['编号']), title: `${s(r['编号'])} · ${s(r['对策'])}`, sub: s(r['目标损失']),
meta: `触发:${s(r['触发条件'])}`,
value: s(r['度量KPI']),
badge: s(r['状态']),
tone: s(r['状态']).includes('缺口') ? 'info' : 'warning',
}),
},
{
id: 'costParam', name: '成本参数', en: 'CostParam', short: '成本参数', color: '#84cc16',
desc: '损失金额化与 ROI 的**参数位**:设备折旧率、人工费率、能源单价、良品边际价值、返工成本,'
+ '以及每分钟停机损失公式与 ROI 模型。费率未由财务提供与签字前,'
+ '**当前值一律留空、拒绝输出任何金额数字**——与 OA-BENEFIT 的三期 A7 门槛一致。',
source: 'SoW 损失金额化模型(参数位建模,值待财务)',
rows: costRows,
present: (r) => ({
id: s(r['参数编码']), title: `${s(r['参数编码'])} · ${s(r['参数名'])}`, sub: s(r['单位']),
meta: `用途:${s(r['用途'])}`,
value: s(r['计算口径']),
badge: s(r['签字状态']),
tone: 'info',
}),
},
];
const rowCache = new Map<string, Row[]>();
const rowsOf = (id: string): Row[] => {
let v = rowCache.get(id);
if (!v) {
const def = DEFS.find((d) => d.id === id);
v = def ? def.rows() : [];
rowCache.set(id, v);
}
return v;
};
const instCache = new Map<string, OntInstance[]>();
/** 9 类对象。instances() 是函数,数字现算,页面不写死。 */
export const objects: OntObject[] = DEFS.map((d) => ({
id: d.id, name: d.name, en: d.en, short: d.short, desc: d.desc,
source: d.source, color: d.color,
attrs: deriveAttrs(d.rows()),
instances: () => {
let v = instCache.get(d.id);
if (!v) { v = rowsOf(d.id).map(d.present); instCache.set(d.id, v); }
return v;
},
}));
export const objectById = (id: string): OntObject | undefined => objects.find((o) => o.id === id);
/**
* 按「对象 id + 实例 id」取回该实例所在行的全部列值。
* 实例 id 有的是复合(业务日|批次号、业务日|档位),不反解 id 格式,
* 而是把每行过一遍呈现器、取 id 相符的那行,再按列顺序拉出字段。
*/
export function instanceFields(objectId: string, instId: string): OntField[] {
const def = DEFS.find((d) => d.id === objectId);
if (!def) return [];
const row = rowsOf(objectId).find((r) => def.present(r).id === instId);
if (!row) return [];
return Object.keys(row).map((col) => ({ name: col, value: s(row[col]) }));
}
/* ══════════════════════════════════════════════════════════════════
* 关系:连接键与实例数全按真实外键交集现算,不估算
* ══════════════════════════════════════════════════════════════════ */
const eqRows = () => rowsOf('equipment');
const segRows = () => rowsOf('stateSegment');
const lotRowsC = () => rowsOf('lot');
const perfRows = () => rowsOf('performance');
const impRows = () => rowsOf('improvement');
const factorRowsC = () => rowsOf('factorDef');
const playRowsC = () => rowsOf('improvePlaybook');
const costRowsC = () => rowsOf('costParam');
/** 卡片/对策的「取数对象」以对象 id 形式存定义,计数按真实引用现算,不另抄一份 */
const cardsUsing = (objectId: string) => CARD_DEFS.filter((c) => c.sources.includes(objectId)).length;
const playsUsing = (objectId: string) => PLAY_DEFS.filter((p) => p.basis.includes(objectId)).length;
const sixBucketFactorRows = () => factorRowsC().filter((r) => s(r['损失桶']) !== '计划类·不进六桶');
export const relations: OntRelation[] = [
{
id: 'eq-line', from: 'equipment', to: 'lineTopology', name: '属于', cardinality: 'N:1',
key: 'lineId', desc: '设备归属线体。17 台全部落在 3 条线上,无孤儿设备。',
count: () => eqRows().filter((r) => LINE_BY_ID[s(r['所属线体'])] !== undefined).length,
},
{
id: 'line-eq', from: 'lineTopology', to: 'equipment', name: '包含', cardinality: '1:N',
key: 'deviceIds', desc: '线体包含设备。与「属于」互为反向,两侧计数必须相等(无悬空引用)。',
count: () => LINES.reduce((a, l) => a + l.deviceIds.filter((id) => DEVICE_BY_ID[id]).length, 0),
},
{
id: 'line-bottleneck', from: 'lineTopology', to: 'equipment', name: '瓶颈站', cardinality: 'N:1',
key: 'bottleneckDeviceId',
desc: 'SRF 瓶颈指向 DCP005(751min 缺失数据 + 124min 停机〔POC〕)。'
+ 'FT/ASLT 未单列瓶颈站——不臆造,按 C15 由主数据维护瓶颈站表后补齐。',
count: () => LINES.filter((l) => l.bottleneckDeviceId && DEVICE_BY_ID[l.bottleneckDeviceId]).length,
},
{
id: 'eq-seg', from: 'equipment', to: 'stateSegment', name: '产生', cardinality: '1:N',
key: 'device', desc: '设备产生状态段。当期只有锚点设备 DEK001 贯通全链路,其余设备待 W2 接入。',
count: () => segRows().filter((r) => DEVICE_BY_ID[s(r['设备'])] !== undefined).length,
},
{
id: 'event-seg', from: 'event', to: 'stateSegment', name: '构成', cardinality: 'N:M',
key: 'eventIds',
desc: '事件实例构成状态段。★ 键空间是**实例 id**(不是事件定义码)——'
+ '传错会让归口全空且不报错,故此处按实例 id 求交集,可反查原始日志行号。',
count: () => {
const ids = new Set(curEvents().map((e) => e.id));
const used = new Set(cur().segments.segments.flatMap((g) => g.eventIds));
return [...used].filter((id) => ids.has(id)).length;
},
},
{
id: 'lot-eq', from: 'lot', to: 'equipment', name: '在制于', cardinality: 'N:1',
key: 'device', desc: '批次在制于设备。三日 lot 窗口全部落在锚点设备上。',
count: () => lotRowsC().filter((r) => DEVICE_BY_ID[s(r['设备'])] !== undefined).length,
},
{
id: 'lot-event', from: 'lot', to: 'event', name: '归因', cardinality: '1:N',
key: 'attribution.lotId',
desc: '事件按五级级联归因挂到批次。★ 当前计数为 0 是**实测事实而非对账失败**:'
+ 'DEK 只有板级 PRINT START/COMPLETE 行印 lot 号,停机/换型/关机事件行不带 lot;'
+ 'lot 窗口已由板级锚点自识别(SELF_IDENTIFIED 1.00),但事件级归因链尚未落地。'
+ '不拿窗口包含关系冒充"设备自识别",也不造归因结果充数(见 R-EVENT-ATTRIBUTION)。'
+ 'Datacon 的 Lot 字段为空才是五级归因的主战场(W2 接入)。',
count: () => {
const lots = new Set(cur().lots.map((w) => w.lotId));
return curEvents().filter((e) => e.attribution?.lotId && lots.has(e.attribution.lotId)).length;
},
},
{
id: 'seg-loss', from: 'stateSegment', to: 'loss', name: '归口', cardinality: 'N:1',
key: 'STATE_TO_BUCKET[state]',
desc: '状态段按十态→六桶映射归口。计划停机/PM/待料/未归因/未采集不进六桶,'
+ '其中未归因 IDLE 是残差的唯一合法来源。',
count: () => segRows().filter((r) => bucketOfState(s(r['状态码'])) !== undefined).length,
},
{
id: 'event-loss', from: 'event', to: 'loss', name: '唯一归口', cardinality: 'N:1',
key: 'GROSS_TO_BUCKET[grossCategory]',
desc: '六-3 归口用词 → 六-1 损失桶。48 码里 28 码落六桶、20 码属计划类映射为 null;'
+ '每码唯一归口,由 checkUniqueBucketAssignment 守住(C07)。',
count: () => EVENTS_48.filter((e) => e.bucket !== null).length,
},
{
id: 'loss-perf', from: 'loss', to: 'performance', name: '计入', cardinality: 'N:1',
key: 'bizDate', desc: '六桶时长计入当日绩效。Σ桶时长 = PPT − 有效生产时间,残差必须照实暴露。',
count: () => days().reduce((a, d) => a + d.buckets.buckets.length, 0),
},
{
id: 'perf-eq', from: 'performance', to: 'equipment', name: '绑定', cardinality: 'N:1',
key: 'device', desc: '绩效结果绑定设备。本体绩效对象当前只实例化到 DEVICE(DEK 锚点 3 日×3 档=9 行);'
+ '线体/区域合成引擎已落地(W2-A,L3 出线体/区域读数,断言④守住),本体线体/区域实例与视图待 W2-B。',
count: () => perfRows().filter((r) => DEVICE_BY_ID[s(r['设备'])] !== undefined).length,
},
{
id: 'caliber-perf', from: 'caliber', to: 'performance', name: '约束', cardinality: '1:N',
key: 'caliberVersion',
desc: '口径版本约束绩效结果。四处读数(页面/报表/智能体/导出)都带同一版本号;'
+ '混用两个版本触发 DQ-12 阻断(断言⑩)。',
count: () => perfRows().filter((r) => s(r['口径版本']) === CALIBER_VERSION).length,
},
{
id: 'caliber-event', from: 'caliber', to: 'event', name: '归口约束', cardinality: '1:N',
key: 'C07 一级因子标准归属表',
desc: 'C07(P0)约束全部 48 个事件码的一级因子归属;C08/C14 约束 Down/Jam 的 300 秒分界。',
count: () => EVENTS_48.length,
},
{
id: 'dq-eq', from: 'improvement', to: 'equipment', name: '挂设备', cardinality: 'N:1',
key: 'device', desc: 'DQ 问题挂到设备。未带设备号的是全局性问题(如口径版本不一致)。',
count: () => impRows().filter((r) => filled(r['设备']) && DEVICE_BY_ID[s(r['设备'])] !== undefined).length,
},
{
id: 'dq-loss', from: 'improvement', to: 'loss', name: '立项依据', cardinality: 'N:1',
key: 'DQ-06 → 未归因时长',
desc: 'DQ-06 未归因占比 >5% 阻断当日结论发布并派单,是改善立项的第一顺位依据。'
+ '任务实体待 W3-B 落地,当前只呈现依据不呈现派单结果。',
count: () => impRows().filter((r) => s(r['规则码']) === 'DQ-06').length,
},
/* ── 共同分析本体的 11 条关系:分析卡取数 / 因子归口 / 对策治理 / 参数金额化 ── */
{
id: 'card-loss', from: 'analysisCard', to: 'loss', name: '拆解', cardinality: '1:N',
key: 'sources ⊇ loss',
desc: '分析卡从损失对象取数:A-02 拆三因子、A-03 停机下钻、A-05 排优先级、M-03 三项损失。'
+ '取数对象按对象 id 引用(不是表名),页面聚焦联动才不会静默失效。',
count: () => cardsUsing('loss'),
},
{
id: 'card-perf', from: 'analysisCard', to: 'performance', name: '取数', cardinality: '1:N',
key: 'sources ⊇ performance',
desc: '计划达成、产量、OEE 与 Δ 分解都从三层绩效取数;跨口径版本对比一律拒绝。',
count: () => cardsUsing('performance'),
},
{
id: 'card-event', from: 'analysisCard', to: 'event', name: '下钻', cardinality: '1:N',
key: 'sources ⊇ event',
desc: '停机与质量下钻落到事件实例,再回原始日志行号(断言①血缘链)。',
count: () => cardsUsing('event'),
},
{
id: 'card-improve', from: 'analysisCard', to: 'improvement', name: '形成整改', cardinality: '1:N',
key: 'sources ⊇ improvement',
desc: 'A-05 按影响程度与产能损失排序后转改善;当前任务实例为 0(W3-B 未落地),只出依据不出派单。',
count: () => cardsUsing('improvement'),
},
{
id: 'card-factor', from: 'analysisCard', to: 'factorDef', name: '按因子拆', cardinality: '1:N',
key: 'sources ⊇ factorDef',
desc: 'A-02 / A-03 / M-03 的损失拆解落到二级因子定义(起止判定 + 量化规则),避免"拆到桶就停"。',
count: () => cardsUsing('factorDef'),
},
{
id: 'factor-loss', from: 'factorDef', to: 'loss', name: '归口', cardinality: 'N:1',
key: 'GROSS_TO_BUCKET[grossCategory]',
desc: '每个二级因子组唯一归口一个损失桶或计划类;20 组来自 48 个事件码的因子列,'
+ '另有 4 个公式派生因子(速度/过程不良/开机不良/FT Index)直接归桶。',
count: () => sixBucketFactorRows().length,
},
{
id: 'factor-event', from: 'factorDef', to: 'event', name: '由事件定义', cardinality: '1:N',
key: 'factorL1 / factorL2',
desc: '20 个有事件证据的因子组各挂若干事件码;归口用词到损失桶由 GROSS_TO_BUCKET 现推,不手写第二份映射。',
count: () => factorRowsC().filter((r) => s(r['事件码']) !== '—(公式派生)').length,
},
{
id: 'play-loss', from: 'improvePlaybook', to: 'loss', name: '针对', cardinality: 'N:1',
key: '目标损失桶',
desc: '每张对策针对一个损失归口(CHANGEOVER / FAULT / IDLE_MINOR / SPEED / 质量 / 计划类),'
+ '触发条件全部基于损失结构与事件频次,不含拍脑袋的经验阈值。',
count: () => playRowsC().length,
},
{
id: 'play-factor', from: 'improvePlaybook', to: 'factorDef', name: '治理因子', cardinality: 'N:M',
key: 'basis ⊇ factorDef',
desc: '对策落到可量化的二级因子上(SMED→Setup/Lot setup/换 lot;短停→Jam time/短停;质量→过程/开机不良)。',
count: () => playsUsing('factorDef'),
},
{
id: 'cost-loss', from: 'costParam', to: 'loss', name: '金额化', cardinality: '1:N',
key: '每分钟停机损失公式',
desc: '损失桶时长 × 每分钟停机损失 → 金额。★ 费率(折旧/人工/能源/边际价值/返工)未签字前,'
+ '参数位留空、拒绝输出金额,与 OA-BENEFIT 同一门槛。',
count: () => costRowsC().length,
},
{
id: 'cost-play', from: 'costParam', to: 'improvePlaybook', name: 'ROI 折算', cardinality: '1:N',
key: 'ROI =(损失减少 + 质量成本下降 − 投入)÷ 投入',
desc: '对策收益的 ROI 折算依赖成本参数。缺基线、费率或收益区间任一即拒绝测算(SK8 停止条件)。',
count: () => costRowsC().length,
},
];
/* ══════════════════════════════════════════════════════════════════
* 规则:阈值照口径原文,命中数按真实数据现算;跑不出结果的标 blocked + gap
* ══════════════════════════════════════════════════════════════════ */
const residualDays = () => days().filter((d) => Math.abs(d.buckets.residualSec) > EPS);
const overUnattr = () => days().filter((d) => d.buckets.unattributedPct > DQ_DEFAULTS.unattributedBlockPct);
const blockedDays = () => days().filter((d) => d.dq.blocked);
const unsignedP0 = () => Object.values(CALIBER_ITEMS).filter((c) => c.priority === 'P0' && !c.signedOff);
const gapOverrideDevices = () => DEVICES.filter((d) => d.gapThresholdMin !== defaultGapThresholdMin(d.ictSec));
const noLogDevices = () => DEVICES.filter((d) => !d.hasLog);
const notEvaluated = () => days().flatMap((d) => d.dq.notEvaluated.map((x) => ({ bizDate: d.bizDate, ...x })));
const untimedAll = () => days().flatMap((d) => d.buckets.untimedSubFactors.map((u) => ({ bizDate: d.bizDate, ...u })));
const crossVersion = () => perfRows().filter((r) => s(r['口径版本']) !== CALIBER_VERSION);
const zeroStartupDays = () => days().filter(
(d) => (d.buckets.buckets.find((b) => b.bucket === 'STARTUP_DEFECT')?.durationSec ?? 0) === 0,
);
const unknownDays = () => days().filter((d) => d.segments.totals.unknownSec > 0);
const sumStat = (f: (d: OeeDayResult) => number) => days().reduce((a, d) => a + f(d), 0);
export const rules: OntRule[] = [
{
id: 'R-BUCKET-RESIDUAL', name: '六桶残差必须照实暴露', severity: 'error', on: 'loss',
tables: ['loss', 'performance'],
expr: '残差 = PPT − 良品数×ICT − Σ六桶时长 ≡ 未归因 IDLE 时长',
desc: '残差≠0 有两个合法来源:① 未归因空档(IDLE);② 超产(N×ICT>RT)把速度桶夹到 0,此时残差为负。'
+ '两种都必须在页面显式告警,**禁止悄悄归一化抹平**——服务层若偷偷修正,断言②与 G2 门同时失效。',
hits: () => ({
n: residualDays().length, unit: '个业务日残差≠0',
targets: residualDays().map((d) => `${d.bizDate} 残差 ${d.buckets.residualSec}s`),
}),
},
{
id: 'R-UNATTRIBUTED', name: '未归因占比 >5% 阻断', severity: 'error', on: 'improvement',
tables: ['improvement', 'stateSegment', 'loss'],
expr: `unattributedPct <= ${DQ_DEFAULTS.unattributedBlockPct}`,
desc: 'DQ-06:暂停该设备当日结论发布并派单补录。分母统一为 PPT,不是 CT。'
+ '未归因(采到了但归不了因)与未采集(日志断流)严格分开,后者不计入分母。',
hits: () => ({
n: overUnattr().length, unit: '个业务日超阈值',
targets: overUnattr().map((d) => `${d.bizDate} ${(d.buckets.unattributedPct * 100).toFixed(2)}%`),
}),
},
{
id: 'R-CALIBER-SIGNOFF', name: 'P0 口径需 IE 签字', severity: 'warning', on: 'caliber',
tables: ['caliber', 'performance'],
expr: 'items.filter(P0).every(signedOff)',
desc: '16 项 P0 未签字时标灰不标绿。平台按附录 E 默认值先行落地,'
+ '参数确认后在配置中心切换并保留旧版本,不影响已采集的历史数据。',
blocked: true,
gap: '本次不安排口径工作坊,28 项 signedOff 全 false;C27/C28(三层 OEE 参数、计划损失来源)'
+ '与 4 项敏感性议题(Plan 边界 / Occ 判定 / Q 定义 / FT 的 PM 是否计入)待 IE 定版。',
hits: () => ({
n: unsignedP0().length, unit: '项 P0 待签字',
targets: unsignedP0().map((c) => `${c.id} ${c.name}`),
}),
},
{
id: 'R-EVENT-UNIQUE', name: '每事件码唯一归口', severity: 'error', on: 'event',
tables: ['event', 'loss'],
expr: 'checkUniqueBucketAssignment(EVENTS_48).ok',
desc: '一个事件码不得同时归两个损失桶,否则 Σ桶时长会重复计数、残差恒不为 0。'
+ '归口由 GROSS_TO_BUCKET 现推,不手写第二份映射表(C07)。',
hits: () => {
const r = checkUniqueBucketAssignment(EVENTS_48);
return { n: r.conflicts.length, unit: '处归口冲突', targets: r.conflicts };
},
},
{
id: 'R-GROSS-MAPPING', name: '六-3 → 六-1 映射完备', severity: 'info', on: 'event',
tables: ['event', 'loss'],
expr: '20 个计划类事件 bucket = null(不进六桶)',
desc: '事件表归口用词共 48 项,其中计划停机/计划待料/工程借用三类 20 项不属六大损失桶。'
+ '这是**口径事实而非缺陷**:把它们塞进六桶会让 OEE 严重偏低。三套"六"分类不可混用。',
hits: () => ({
n: eventStats().nullBucketEvents, unit: '个计划类事件不进六桶',
targets: (Object.keys(GROSS_TO_BUCKET) as (keyof typeof GROSS_TO_BUCKET)[])
.filter((k) => GROSS_TO_BUCKET[k] === null).map((k) => `${k}(${eventStats().gross[k] ?? 0} 项)`),
}),
},
{
id: 'R-EVENT-ATTRIBUTION', name: '事件级归因链未落地', severity: 'warning', on: 'event',
tables: ['event', 'lot'],
expr: 'event.attribution.lotId ∈ lot.lotId(五级级联:自识别→MES唯一→换型窗口→多候选→未归因)',
desc: 'lot 窗口由板级锚点自识别(SELF_IDENTIFIED 1.00)已落地;但**事件行本身不带 lot 号**,'
+ '事件挂批次须按窗口归属/MES 唯一性推导并定置信度。当前 attribution 全为空,'
+ '故 lot→event 关系计数为 0——实测事实,不拿窗口包含冒充自识别,也不造归因结果充数。'
+ '★ 识别途径(怎么认出来的)与真因 A/B/C 分类(为什么发生)是两回事,不得混用。',
blocked: true,
gap: '五级级联归因引擎待 W2 落地:DEK 事件行无 lot 字段,需按自识别 lot 窗口推导归属并显式标注置信度;'
+ 'Datacon 的 Lot 字段为空,须走 MES 唯一匹配 / 换型窗口 / 多候选三级。'
+ '多候选不得强判唯一真因,未归因如实进 UNATTRIBUTED(置信度 0.00)。',
hits: () => ({
n: curEvents().filter((e) => e.attribution?.lotId).length,
unit: '个事件已挂批次(当期)',
targets: curEvents().filter((e) => e.attribution?.lotId).map((e) => `${e.id} → ${e.attribution!.lotId}`),
}),
},
{
id: 'R-DQ-BLOCK', name: 'DQ 阻断当日结论发布', severity: 'error', on: 'improvement',
tables: ['improvement', 'performance'],
expr: `blockingDq ⊆ {${BLOCKING_DQ.join(', ')}}`,
desc: '三条阻断级规则命中即暂停发布,页面给出完整话术:结论暂缓发布 + 原因 + 补录入口。'
+ '阻断不是"算不出来",是"算出来了但不许发布"。',
hits: () => ({
n: blockedDays().length, unit: '个业务日被阻断',
targets: blockedDays().map((d) => `${d.bizDate} ${d.dq.blockedBy.join('/')}`),
}),
},
{
id: 'R-DQ-NOT-EVALUATED', name: '缺证据的 DQ 规则标灰', severity: 'warning', on: 'improvement',
tables: ['improvement'],
expr: 'notEvaluated.length 逐条列出缺什么',
desc: '12 条规则里没有证据支撑的不得标绿通过,必须列出缺失项。'
+ '治理台按"已评估 / 未评估"两栏分开呈现,避免"全绿"假象。',
hits: () => ({
n: notEvaluated().length, unit: '条规则缺证据未评估',
targets: notEvaluated().map((x) => `${x.bizDate} ${x.code} 缺 ${x.missing}`),
}),
},
{
id: 'R-DOWN-JAM-300', name: 'Down/Jam 按 300 秒分界', severity: 'info', on: 'stateSegment',
tables: ['stateSegment', 'event', 'caliber'],
expr: '单次连续停机 >300s → DOWN;≤300s → JAM',
desc: 'C08 统一 300 秒分界,C14 明确按**单次连续停机的持续时长**判定(不是累计时长)。'
+ 'C13 权威时间取最早可信时间,差异超 5 分钟转人工复核。',
hits: () => {
const segs = cur().segments.segments.filter((g) => g.state === 'DOWN' || g.state === 'JAM');
return {
n: segs.length, unit: '个停机段(当期)',
targets: segs.map((g) => `${STATE_LABEL[g.state]} ${g.durationSec}s ${g.id}`),
};
},
},
{
id: 'R-GAP-THRESHOLD', name: '间隙阈值按设备生效', severity: 'warning', on: 'equipment',
tables: ['equipment', 'stateSegment'],
expr: 'gapThresholdMin ≠ max(5, 3×ICT/60) 的设备须以台账值为准',
desc: 'kohyoung AOI 必须 15min(节拍是分钟级,用 5min 会把正常生产误判为停机)、'
+ 'Jetting 必须 3min。这两台恰好都不等于公式默认值,正是**台账值优先于公式**的证据。',
hits: () => ({
n: gapOverrideDevices().length, unit: '台阈值覆盖公式默认值',
targets: gapOverrideDevices().map(
(d) => `${d.id} 台账 ${d.gapThresholdMin}min ≠ 公式 ${defaultGapThresholdMin(d.ictSec)}min`,
),
}),
},
{
id: 'R-NO-LOG', name: '无日志设备需加装 IO', severity: 'warning', on: 'equipment',
tables: ['equipment'],
expr: 'hasLog = false → 过渡通道 IO_LIGHT / UPSTREAM_INFER',
desc: 'Loader/分轨机/绿皮机无日志输出(合计约 10 台〔POC〕),需加装 IO 三色灯/光电后才能采集;'
+ '中间缓存无独立日志,由上下游进出板时间反推占用率,且**不计 OEE**(不生产,计进去会凭空多一个分母)。',
blocked: true,
gap: '无日志设备尚未加装 IO 硬件,过渡期靠人工录入;D 类事件超时触发 DQ-11。'
+ '绿皮机的正式工站名与工艺位置待客户确认,不臆造拓扑。',
hits: () => ({
n: noLogDevices().length, unit: '台无独立日志',
targets: noLogDevices().map((d) => `${d.id} ${d.name}(${d.fallbackChannel ?? '—'})`),
}),
},
{
id: 'R-ICT-PENDING', name: 'ICT 待 IE 提供', severity: 'warning', on: 'equipment',
tables: ['equipment', 'performance'],
expr: "ictSource = 'PENDING_IE' → ictSec = 0,不编数",
desc: '回流焊/MBT/Xray/无日志三类的节拍规划书未给。ictSec=0 是**口径事实**而非数据缺失:'
+ 'FT 的 P 用「1 − 三项损失占比」不用 ICT,ASLT 按 C05 用理论工时/实际工时。'
+ '回流焊须由上下游工站事件配对推导后由 IE 确认。',
blocked: true,
gap: '规划书未给这些设备的实测节拍,须 IE 提供后才能算 P;回流焊无进出板信号,'
+ '只能走 SRF 时间分配法按上下游节拍拆分,并显式标注推导置信度。',
hits: () => ({
n: deviceStats().ictPendingIe, unit: '台节拍待 IE 提供',
targets: DEVICES.filter((d) => d.ictSource === 'PENDING_IE').map((d) => `${d.id} ${d.name}`),
}),
},
{
id: 'R-DEMO-CODE', name: '演示占位码须替换', severity: 'warning', on: 'equipment',
tables: ['equipment'],
expr: "codeSource = 'DEMO' → 接入前必须替换为客户台账编码",
desc: '沿用客户既有台账编码、不重新编号(规划书 5.1)。已知真实编码只有 5 个:'
+ 'DCP005〔POC〕、93k178/93k250/93k287〔方案〕、suzamdaslt386〔POC〕。'
+ '其余 12 台客户未给编码,用演示占位码并明示"待客户台账确认"。',
hits: () => ({
n: deviceStats().demoCode, unit: '台用演示占位码',
targets: DEVICES.filter((d) => d.codeSource === 'DEMO').map((d) => d.id),
}),
},
{
id: 'R-TASK-DISPATCH', name: '四项必填才派发', severity: 'error', on: 'improvement',
tables: ['improvement'],
expr: 'owner && dueDate && expectedBenefit && verificationResult → canDispatch',
desc: '改善任务六态(待生成→待审核→已派发→执行中→已验证→已归档);四项任一缺失即 canDispatch=false。'
+ '证据链不完整只作候选不进派单;根因只挂五实体之一,不允许多个并列首要真因;收益给区间不给点值。',
blocked: true,
gap: 'closure 引擎与任务中心在 W3-B 落地,当前**无改善任务实例**。'
+ '建议书 3.6 写的"6 条任务"是目标态而非现有数据,此处不编造任务充数。',
hits: () => ({ n: 0, unit: '条任务(引擎未落地)', targets: [] }),
},
{
id: 'R-CROSS-VERSION', name: '跨口径版本拒绝对比', severity: 'error', on: 'performance',
tables: ['performance', 'caliber'],
expr: 'compare(a, b) 要求 a.caliberVersion === b.caliberVersion',
desc: '换分母即换口径。同一报表混用两个 caliber_version 触发 DQ-12 阻断;'
+ '智能体技能 SK3/SK8 在版本不同时直接拒绝,不做"看起来能比"的拼接(断言⑩)。',
hits: () => ({
n: crossVersion().length, unit: '条结果版本不一致',
targets: crossVersion().map((r) => `${s(r['业务日'])} ${s(r['档位'])} ${s(r['口径版本'])}`),
}),
},
{
id: 'R-SHIFT-ASSUMPTION', name: '班次时刻为演示假设', severity: 'warning', on: 'stateSegment',
tables: ['stateSegment', 'equipment', 'caliber'],
expr: 'SHIFT_PATTERN = 3×8h(夜班 0–8 / 白班 8–16 / 中班 16–24)',
desc: '规划书 4.6.1 只写"3 班"未给具体时刻,此处取标准三班制作为演示假设。'
+ 'C24(P0)跨天班次归属到**事件开始时刻所在业务日**;本 pattern 下业务日=日历日,CT 窗口=00:00→24:00。',
blocked: true,
gap: SHIFT_ASSUMPTION_NOTE,
hits: () => ({
n: SHIFT_PATTERN.length, unit: '个班次(假设时刻)',
targets: SHIFT_PATTERN.map((x) => `${x.id} ${x.name} ${x.startHour}:00–${x.endHour}:00`),
}),
},
{
id: 'R-LINE-SYNTHESIS', name: '线体/区域绩效实例待接入', severity: 'warning', on: 'lineTopology',
tables: ['lineTopology', 'performance'],
expr: 'SRF 串行 A/Q 连乘、P 取瓶颈;FT 并行按投入量加权;ASLT 12 Site 使能占比',
desc: '三套模板不同构:SRF 缓冲解耦为主口径(25.50%)、零缓冲 16.02% 为理论下界,两者不可混用;'
+ 'FT 的 A 是连乘扣减式,与通用 A=RT/PPT 不同构。合成引擎已落地(W2-A,L3 出线体/区域读数,断言④守住);'
+ '本体绩效对象仍只实例化到 DEVICE(DEK 锚点),线体/区域实例与视图待 W2-B。',
blocked: true,
gap: serviceStats().coverageGap,
hits: () => ({
n: LINES.length, unit: '条线待出本体实例',
targets: LINES.map((l) => `${l.id} ${TEMPLATE_LABEL[l.template]}`),
}),
},
{
id: 'R-STARTUP-DEFECT', name: '开机不良未采集计 0 标缺口', severity: 'warning', on: 'loss',
tables: ['loss', 'event'],
expr: 'startupDefectQty 未注入 → 桶时长 0,且不得把过程不良摊进来',
desc: '开机不良=首件不良数×ICT(换型后爬坡/首件不良/rescreen 复测)。'
+ '首件检验数据未接入时计 0 并显式标缺口——**摊派会制造假精度**,让评审误以为已量到。',
blocked: true,
gap: '首件检验/首件不良数据未接入,三日开机不良桶均为 0。这是数据缺口而非"没有开机不良"。',
hits: () => ({
n: zeroStartupDays().length, unit: '个业务日开机不良为 0',
targets: zeroStartupDays().map((d) => d.bizDate),
}),
},
{
id: 'R-UNTIMED-SUBFACTOR', name: '未计时子因子标灰不摊数', severity: 'warning', on: 'loss',
tables: ['loss', 'stateSegment'],
expr: 'untimedSubFactors 时长留空(不是 0)',
desc: '段内出现但未单独计量的子因子(如 Down 段里的「维修等待」):缺 EA 到场时间戳就无法把停机'
+ '拆成「故障」与「等维修」。UI 标灰并说明缺什么,禁止摊一个数出来充精度。'
+ '★ 当期实例为 0 是种子覆盖事实:DEK 停机段只含单一子因子 S-29(Down Time/Down),'
+ '未构造同段多子因子场景;引擎路径已由校验脚本用合成输入(S-27 Down + S-28 维修等待 同段)验证。',
blocked: true,
gap: '当前 DEK 种子的停机段只含单一子因子(S-29 Down Time/Down),未计时子因子实例为 0。'
+ '引擎路径已用合成输入验证(整段归首事件因子、被跳过子因子只留证不计时);'
+ '真实场景需 EA 到场/离场时间戳才能拆分「故障」与「等维修」,待 W2 接入。',
hits: () => ({
n: untimedAll().length, unit: '个未计时子因子',
targets: untimedAll().map((u) => `${u.bizDate} ${u.factorL1}/${u.factorL2}`),
}),
},
{
id: 'R-CLOCK-BACKWARD', name: '时钟回跳自动修正留双字段', severity: 'info', on: 'event',
tables: ['event', 'improvement'],
expr: '相邻事件时间戳倒退 >60 秒 → DQ-01 自动修正',
desc: 'DEK 一日发生 4 次时钟回跳〔POC〕。修正在 L1 采集适配层完成,L2 引擎保持纯函数可重放;'
+ '原始/校正双时间字段都保留,改钟事件 31317/31318 跳过不入事件表但留证供审计。',
hits: () => ({
n: sumStat((d) => d.dq.stats.clockBackwardCount), unit: '次回跳(三日)',
targets: days().filter((d) => d.dq.stats.clockBackwardCount > 0)
.map((d) => `${d.bizDate} ${d.dq.stats.clockBackwardCount} 次 / 已校正 ${d.dq.stats.correctedCount} 条`),
}),
},
{
id: 'R-DUPLICATE', name: '重复事件丢弃并计数', severity: 'info', on: 'event',
tables: ['event', 'improvement'],
expr: 'dedup_key 命中已有记录 → DQ-09 丢弃并计数',
desc: '去重点在 L1,被丢弃的重复行必须留证上报(keptLineNo 给出血缘)。'
+ '若只在已去重的事件表上再数一遍,重复率永远是 0——治理台就看不到真实采集质量。',
hits: () => ({
n: sumStat((d) => d.dq.stats.duplicateCount), unit: '条重复被丢弃(三日)',
targets: days().filter((d) => d.dq.stats.duplicateCount > 0)
.map((d) => `${d.bizDate} ${d.dq.stats.duplicateCount} 条 / 重复率 ${(d.dq.stats.duplicateRate * 100).toFixed(2)}%`),
}),
},
{
id: 'R-UNKNOWN-SEC', name: '未采集 ≠ 无生产', severity: 'warning', on: 'stateSegment',
tables: ['stateSegment', 'performance', 'improvement'],
expr: 'UNKNOWN 段不计入分母 PPT(DQ-10 三态分开)',
desc: '日志断流窗口标"未采集",不等同于"无生产",也不计入分母。'
+ '三态(未采集 / 未归因 / 已归因)必须分开:混在一起会让 A 因子被采集缺口污染。',
hits: () => ({
n: unknownDays().length, unit: '个业务日有未采集窗口',
targets: unknownDays().map((d) => `${d.bizDate} ${d.segments.totals.unknownSec}s`),
}),
},
{
id: 'R-MISSING-CODES', name: '事件表缺失编号留证', severity: 'info', on: 'event',
tables: ['event'],
expr: '原表 60 行去重 12 行 → 48 个事件码',
desc: '缺失编号是原表事实,不补号、不猜归口。码表里没有的码在 L1 显式进 unmapped 缺口池,'
+ '不静默丢弃(DEK 96 码全表到位前,未映射码如实上报)。',
hits: () => ({
n: MISSING_CODES.length, unit: '个缺失编号',
targets: [...MISSING_CODES],
}),
},
{
id: 'R-DEMO-MODE', name: '纯 demo 数据沙箱', severity: 'warning', on: 'equipment',
tables: ['equipment', 'event', 'performance'],
expr: 'dataMode = demo(L1 读合成种子)',
desc: '本工程为纯 demo 前端:L1 读内置合成种子,不连接后端、不做任何实时直采。'
+ '采集通道接入前不得声称已支持直采;页面与导出都带来源标注(DEMO_SEED),POC 锚点数字只作参考基线。',
blocked: true,
gap: REFERENCES_DEMO_SANDBOX_GAP,
hits: () => ({
n: 1, unit: '个数据模式缺口',
targets: ['DATA_MODE=demo'],
}),
},
/* ── 共同分析本体的 6 条规则:因子口径、分析顺序、对策门槛、费率签字、质量源缺口 ── */
{
id: 'R-FACTOR-UNIQUE', name: '每个二级因子唯一归口', severity: 'error', on: 'factorDef',
tables: ['factorDef', 'event', 'loss'],
expr: 'factorGroup.bucket ∈ 六桶 ∪ {null},且组内全部事件码同桶',
desc: '一个二级因子不得同时归两个损失桶,否则 Σ桶时长重复计数。20 组由 48 个事件码的因子列现聚,'
+ '不手写第二份映射;派生因子(速度/过程不良/开机不良/FT Index)由公式归桶并标推导量。',
hits: () => ({
n: factorGroups().length, unit: '个二级因子组唯一归口',
targets: factorGroups().map((g) => `${g.l1}/${g.l2} → ${g.bucket ? BUCKET_LABEL[g.bucket] : '计划类'}`),
}),
},
{
id: 'R-ANALYSIS-ORDER', name: '分析顺序不可跳步', severity: 'info', on: 'analysisCard',
tables: ['analysisCard', 'performance', 'loss'],
expr: '计划达成 → 产出效率 → A/P/Q 拆解 → 停机/质量下钻 → 排优先级',
desc: 'SoW 要求的分析动线:先看计划有没有完成,再看产出效率;效率异常才拆 OEE;'
+ '不直接从 OEE 跳到根因。指标组合七组同样先看组合再看单项,避免单指标误判。',
hits: () => ({
n: CARD_DEFS.length, unit: '张分析卡按顺序编排',
targets: CARD_DEFS.map((c) => `${c.id} ${c.kind}:${c.question.slice(0, 18)}…`),
}),
},
{
id: 'R-SETUP-SMED', name: '换型损失触发 SMED 候选', severity: 'warning', on: 'loss',
tables: ['loss', 'factorDef', 'improvePlaybook'],
expr: 'CHANGEOVER 因子(Setup / Conversion / Lot setup / 换 lot)占 PPT 居前 → SMED 候选',
desc: 'Setup/Conversion/Lot setup/换 lot 全部归 CHANGEOVER 桶;当换型时长或次数居前时生成 SMED 对策候选。'
+ '触发门槛未定版前只提示、不自动派单。',
blocked: true,
gap: 'SMED 触发门槛(换型次数/时长/占比)待 IE 定版;对策中心与任务中心在 W3-B,'
+ '当前只出候选不派单。',
hits: () => {
const fs = cur().buckets.factors.filter((f) => f.factorL1 === 'Set up loss');
return {
n: fs.length, unit: '个换型类因子(当期)',
targets: fs.map((f) => `${f.factorL2} ${f.durationSec}s`),
};
},
},
{
id: 'R-JAM-FREQUENCY', name: '短停按次数与时长双看', severity: 'warning', on: 'event',
tables: ['event', 'stateSegment', 'factorDef'],
expr: 'Jam time / 短停:次数看稳定性,时长看大损失,不得只按总时长排名',
desc: '高频短停单次 ≤300s、总时长不显眼,但次数反映设备稳定性。'
+ '排名必须同时给次数与时长,否则高频短停会被偶发长停盖住。',
blocked: true,
gap: '频次告警阈值待定;Jam 多为 D 类人工录入,次数可信度受补录完整度影响(DQ-11 超时升级)。',
hits: () => {
const jam = curEvents().filter((e) => {
const d = EVENT_BY_CODE[e.defCode];
return d?.factorL2 === 'Jam time' || d?.factorL2 === '短停';
});
return { n: jam.length, unit: '个短停事件(当期)', targets: jam.map((e) => `${e.defCode} ${e.id}`) };
},
},
{
id: 'R-COST-SIGNOFF', name: '费率未签字拒绝金额化', severity: 'error', on: 'costParam',
tables: ['costParam', 'loss', 'improvePlaybook'],
expr: 'C-01…C-05 费率全部提供并签字 → 才允许 C-06/C-07 出金额与 ROI',
desc: '损失金额化与 ROI 的四项门槛:费率签字、基线、收益区间、同口径对比。'
+ '任一缺失即拒绝测算,**不给任何金额数字**(与 OA-BENEFIT 的三期 A7 同一门槛)。',
blocked: true,
gap: '设备折旧率/人工费率/能源单价/良品边际价值/返工成本未由财务提供与签字;'
+ '当前参数位留空,任何金额与 ROI 均不产出。',
hits: () => ({
n: COST_DEFS.length, unit: '个成本参数待签字',
targets: COST_DEFS.map((c) => `${c.id} ${c.name}(${c.unit})`),
}),
},
{
id: 'R-FTRD-GAP', name: 'FTRD/在制品/负荷数据源未接入', severity: 'warning', on: 'analysisCard',
tables: ['analysisCard', 'lot', 'event'],
expr: 'M-05 良率+FTRD+返工 / M-06 利用率+在制品 / M-07 产量+负荷+故障趋势',
desc: '三组指标组合依赖尚未接入的数据源:FTRD 与返工、在制品(WIP)、设备负荷与维修记录。'
+ '缺源时标灰说明缺什么,不拿良率冒充 FTRD、不拿运行率冒充负荷。',
blocked: true,
gap: 'FTRD/返工、WIP、维修工单与设备负荷均无数据源;'
+ '当前只能看批次良率与事件表停机,三个组合标"缺口"而非"可算"。',
hits: () => ({
n: CARD_DEFS.filter((c) => c.status === '缺口').length, unit: '个指标组合依赖未接入数据源',
targets: CARD_DEFS.filter((c) => c.status === '缺口').map((c) => `${c.id} ${c.question.slice(0, 16)}…`),
}),
},
];
/* ══════════════════════════════════════════════════════════════════
* 动作:只覆盖口径/规则里真写了的处置,不另编
* ══════════════════════════════════════════════════════════════════ */
const targetsOf = (id: string) => rules.find((r) => r.id === id)?.hits().targets ?? [];
const objName = (id: string) => DEFS.find((d) => d.id === id)?.name ?? id;
export const actions: OntAction[] = [
{
id: 'OA-TIMELINE', name: '查设备时间轴', en: 'query_device_timeline',
object: objName('stateSegment'), type: 'query', tables: ['stateSegment', 'event', 'equipment'],
trigger: '选中设备 + 业务日(三要素齐备)',
desc: '按十态抢占优先级渲染甘特,跨班拆分段共享 splitGroupId,影子时长双记录不重复扣减。'
+ '受控工具 TL2:只读,下钻必须回得到 lineNo,否则即停。',
targets: () => segRows().map((r) => s(r['段id'])),
},
{
id: 'OA-GANTT-LINENO', name: '跳转原始日志行号', en: 'jump_to_raw_line',
object: objName('event'), type: 'query', tables: ['event', 'stateSegment'],
trigger: '状态段 → 事件实例 → 原始行',
desc: '断言①血缘链的终点:指标→桶→因子→状态段→事件实例→原始日志行号。'
+ '对外只给行号与摘要哈希,全文仅内网审计链路可取。',
targets: () => curEvents().filter((e) => e.evidence.lineNo > 0).map((e) => `${e.defCode} 行 ${e.evidence.lineNo}`),
},
{
id: 'OA-CAPABILITY', name: '查能力矩阵', en: 'query_capability_matrix',
object: objName('equipment'), type: 'query', tables: ['equipment'],
trigger: '讲解六类数据可得性场景',
desc: '按附录 D.1 演示顺序(DEK→Jetting→FT Tester→Datacon→kohyoung→回流焊)逐台展开六维星级,'
+ '信号完整度单调不增,演完全部六类场景。',
targets: () => [...DEMO_ORDER],
},
{
id: 'OA-LINE-SYNTH', name: '查线体合成', en: 'query_line_synthesis',
object: objName('lineTopology'), type: 'query', tables: ['lineTopology', 'performance'],
trigger: '选中线体 + 周期',
desc: 'SRF 串行 A/Q 连乘、P 取瓶颈;FT 并行按投入量加权;ASLT 按 12 Site 使能占比。'
+ '**合成引擎待 W2 接入**,当前只呈现拓扑与口径,不出合成数字。',
targets: () => LINES.map((l) => l.id),
},
{
id: 'OA-BOTTLENECK', name: '定位瓶颈站', en: 'locate_bottleneck',
object: objName('lineTopology'), type: 'query', tables: ['lineTopology', 'equipment'],
trigger: '线体 OEE 低于目标',
desc: 'SRF 瓶颈指向 DCP005(751min 缺失数据 + 124min 停机〔POC〕),也是优先处理清单第一名。'
+ '瓶颈站按 C15 由主数据维护、按产品路线分别配置,不臆造。',
targets: () => LINES.filter((l) => l.bottleneckDeviceId).map((l) => `${l.id} → ${l.bottleneckDeviceId}`),
},
{
id: 'OA-LOT-YIELD', name: '查批次良率', en: 'query_lot_yield',
object: objName('lot'), type: 'query', tables: ['lot', 'performance'],
trigger: '选中批次号',
desc: '批次良率=合格数/投入数,由完成行锚点现算。工程批按 C10 默认剔除(影响 Q 约 2.08pp)。'
+ '无完成行的 lot 不造窗口,N=0 时 P/Q 失去意义,由 DQ 暴露缺口。',
targets: () => lotRowsC().map((r) => `${s(r['业务日'])}|${s(r['批次号'])}`),
},
{
id: 'OA-ATTR-TRACE', name: '追溯归因途径', en: 'trace_attribution',
object: objName('lot'), type: 'query', tables: ['lot', 'event'],
trigger: '事件需要挂批次',
desc: '五级级联归因:设备自识别 1.00 → MES 窗口唯一 0.95 → 换型窗口 0.90 → 多候选缩小 0.85 → 无法归因 0.00。'
+ '无法归因进未归因池,**绝不猜测**。注意这是"识别途径",与真因 A/B/C 分类是两回事。',
targets: () => curEvents().filter((e) => e.attribution).map((e) => `${e.defCode} → ${e.attribution?.lotId ?? '未归因池'}`),
},
{
id: 'OA-EVENT-STREAM', name: '查事件流', en: 'query_event_stream',
object: objName('event'), type: 'query', tables: ['event'],
trigger: '选中设备 + 业务日',
desc: '48 码字典 + 当期实例流。双时间字段并列显示(原始/校正),配对四策略'
+ '(TIGHT / MISSING_END / MISSING_START / MULTI_ALARM)逐条标注,补出的时刻不是观测值。',
targets: () => curEvents().map((e) => e.id),
},
{
id: 'OA-MANUAL-ENTRY', name: '提交 5M1E 补录', en: 'submit_manual_entry',
object: objName('event'), type: 'workflow', tables: ['event', 'improvement'],
trigger: 'D 类事件(必须人工录入)发生',
desc: '七字段:真因一级(人/机/料/法/环/测)、真因二级、原因描述≤50 字、对策、建议归口、是否计划内、'
+ '补录人/时间由系统写入不可手填。班次结束后 30 分钟未录入触发 DQ-11 升级提醒班组长。'
+ '**录入台在 W3-A 落地**,当前只登记契约。',
targets: () => EVENTS_48.filter((e) => e.grade === 'D').map((e) => `${e.code} ${e.name}`),
},
{
id: 'OA-PARETO', name: '查损失 Pareto', en: 'query_loss_pareto',
object: objName('loss'), type: 'report', tables: ['loss', 'performance'],
trigger: '当期 OEE 低于目标',
desc: '六桶按时长降序 + 占 PPT 份额。分母统一为 PPT(不是 CT,也不是日历时间)。'
+ '推导桶(速度降低/过程不良/开机不良)标"推导量",不提供事件级下钻。',
targets: () => [...cur().buckets.buckets].sort((a, b) => b.durationSec - a.durationSec)
.map((b) => `${BUCKET_LABEL[b.bucket]} ${b.durationSec}s(${b.factor})`),
},
{
id: 'OA-RESIDUAL', name: '查六桶残差', en: 'query_residual',
object: objName('loss'), type: 'report', tables: ['loss', 'stateSegment'],
trigger: '残差 ≠ 0',
desc: '残差=PPT−良品数×ICT−Σ六桶,恒等于未归因时长。第二个合法非零来源是超产把速度桶夹到 0(残差为负)。'
+ '照实暴露并给来源解释,不让评审猜,更不许归一化抹平。',
targets: () => targetsOf('R-BUCKET-RESIDUAL'),
},
{
id: 'OA-THREE-TIER', name: '查三层 OEE', en: 'query_three_tier',
object: objName('performance'), type: 'query', tables: ['performance', 'caliber'],
trigger: '选中设备 + 业务日',
desc: '理论/计划/实际三档共用同一分母 PPT=CT−PDT−UNKNOWN。'
+ '理论档 A=1−每日不可避免停机/PPT、P=1、Q=设计良率;计划档取 IE 月度目标。'
+ 'C27/C28 待 IE 签字,未签字前不得当作客户确认口径。',
targets: () => perfRows().map((r) => `${s(r['业务日'])}|${s(r['档位'])}`),
},
{
id: 'OA-DELTA', name: '顺序替代差异分解', en: 'sequential_replace_delta',
object: objName('performance'), type: 'report', tables: ['performance'],
trigger: '两档同口径结果对比',
desc: '顺序固定 A→P→Q:ΔA=(t.a−b.a)×b.p×b.q,ΔP=t.a×(t.p−b.p)×b.q,ΔQ=t.a×t.p×(t.q−b.q)。'
+ '换顺序会换结论,故顺序不可配置。跨口径版本直接拒绝(SK3 停止条件)。',
targets: () => days().map((d) => {
const x = d.tiers.deltaPlannedToActual;
return `${d.bizDate} ΔA ${(x.dA * 100).toFixed(2)}pp / ΔP ${(x.dP * 100).toFixed(2)}pp / ΔQ ${(x.dQ * 100).toFixed(2)}pp`;
}),
},
{
id: 'OA-CALIBER-SOURCE', name: '查口径出处', en: 'query_caliber_source',
object: objName('caliber'), type: 'query', tables: ['caliber', 'performance'],
trigger: '任一指标被质疑',
desc: '每个数字都能回指口径编号、默认值、归口责任人与版本号。'
+ 'P0 未签字标灰;4 项敏感性议题优先呈现(Plan 边界 / Occ 判定 / Q 定义 / FT 的 PM 是否计入)。',
targets: () => targetsOf('R-CALIBER-SIGNOFF'),
},
{
id: 'OA-VERSION-REPLAY', name: '切换口径版本回放', en: 'switch_caliber_version',
object: objName('caliber'), type: 'workflow', tables: ['caliber', 'performance'],
trigger: 'IE 定版后切换参数',
desc: '切换任一项生成新版本,旧版本结果保留可回放,不影响已采集的历史数据。'
+ '带覆盖参数时服务层不走缓存、必须真重算(断言⑩)。**配置中心在 W4-A 落地**。',
targets: () => [CALIBER_VERSION],
},
{
id: 'OA-DQ-NOTICE', name: '结论暂缓发布告警', en: 'publish_block_notice',
object: objName('improvement'), type: 'alert', tables: ['improvement', 'performance'],
trigger: 'DQ-06 / DQ-08 / DQ-12 命中',
desc: '阻断时给 UI 完整话术:结论暂缓发布 + 原因 + 补录入口。'
+ '原型只在站内提示(TL5),不接真实 OA/邮件通道。',
targets: () => blockedDays().map((d) => d.bizDate),
},
{
id: 'OA-DISPATCH', name: '派改善单', en: 'dispatch_improvement',
object: objName('improvement'), type: 'workflow', tables: ['improvement', 'loss'],
trigger: '四项必填齐备 + 证据链完整',
desc: '四项必填:责任人、期限、预期收益区间、验证方式。任一缺失 canDispatch=false,不派发。'
+ '根因只挂五实体之一(设备/模具工装/物料批次/人员班组/程序参数)。**任务中心在 W3-B 落地**。',
targets: () => targetsOf('R-UNATTRIBUTED'),
},
{
id: 'OA-SLA', name: '查 SLA 与升级', en: 'query_sla_escalation',
object: objName('improvement'), type: 'alert', tables: ['improvement'],
trigger: '任务超期未推进',
desc: '六态流转非法即拒;超期按 slaEscalatedTo 升级。D 类补录超时走 DQ-11 升级班组长,'
+ '报表以快照值出数并标注。**闭环引擎在 W3-B 落地**。',
targets: () => Object.values(TASK_STATE_LABEL),
},
{
id: 'OA-BENEFIT', name: '验证改善收益', en: 'verify_benefit',
object: objName('improvement'), type: 'report', tables: ['improvement', 'performance', 'caliber'],
trigger: '任务已闭环 + 前后期同口径',
desc: '前后对比必须同口径版本,否则拒绝(SK8 停止条件)。收益给区间不给点值。'
+ '金额化测算属三期 A7:四门槛齐备且费率签字前**拒绝测算,不给任何金额数字**。',
targets: () => targetsOf('R-CROSS-VERSION'),
},
{
id: 'OA-EXPORT', name: '导出口径对齐报表', en: 'export_caliber_aligned_report',
object: objName('performance'), type: 'report', tables: ['performance', 'caliber'],
trigger: '评审/月度复盘',
desc: '导出必带口径版本与模拟标注(DEMO_SEED);POC 锚点数字标为参考基线。'
+ '跨版本拼装拒绝(TL4 白名单约束)。**报表导出在 W4-B 落地**。',
targets: () => [`${CALIBER_VERSION} · demo`],
},
/* ── 共同分析本体的 4 个动作:按分析卡下钻 / 查因子口径 / 出对策候选 / 查金额化 ── */
{
id: 'OA-CARD-DRILL', name: '按分析卡下钻', en: 'drill_analysis_card',
object: objName('analysisCard'), type: 'query', tables: ['analysisCard', 'performance', 'loss'],
trigger: '用户问"计划完成了没有 / 效率为什么降 / 停机原因 / 质量问题"',
desc: '按 A-01→A-05 的固定动线取数:先计划达成,再产出效率,再拆 A/P/Q,再分头下钻,最后排优先级。'
+ '每张卡先亮"误判提醒"再给数,避免小/大订单比例、工时快于产量等口径陷阱。',
targets: () => CARD_DEFS.map((c) => `${c.id} ${c.question.slice(0, 16)}…`),
},
{
id: 'OA-FACTOR-QUANT', name: '查因子量化标准', en: 'query_factor_quantification',
object: objName('factorDef'), type: 'query', tables: ['factorDef', 'event', 'loss'],
trigger: '质疑某个损失怎么算(Setup / Jam / Index / 待料)',
desc: '给判定起点、判定终点、量化规则与口径编号:Setup ±5min 是录入偏移不是派生;'
+ 'Jam/Down 按单次连续 300s;Index 损失按 [Index/(Index+Test)]×(1−OE Eff Loss−Jam Factor)。',
targets: () => factorRowsC().map((r) => s(r['因子编号'])),
},
{
id: 'OA-PLAYBOOK-SUGGEST', name: '出改善对策候选', en: 'suggest_improvement_playbook',
object: objName('improvePlaybook'), type: 'workflow', tables: ['improvePlaybook', 'loss', 'improvement'],
trigger: '损失桶排名确定 + 对策触发条件满足',
desc: '按损失结构匹配 SMED / TPM / 短停 / 速度 / 质量 / 排产六类对策,输出触发条件、KPI 与验证方式。'
+ '**只出候选**:四项必填齐备才派单,任务中心 W3-B 未落地前不产生任务实例。',
targets: () => PLAY_DEFS.map((p) => `${p.id} ${p.name}`),
},
{
id: 'OA-COST-ROI', name: '查损失金额化与 ROI', en: 'query_cost_model',
object: objName('costParam'), type: 'report', tables: ['costParam', 'loss', 'improvePlaybook'],
trigger: '评审问"损失折合多少钱 / 上线 ROI 多少"',
desc: '给公式与参数位,但**不给金额**:费率未签字前当前值留空,'
+ '每分钟停机损失与 ROI 一律拒绝测算(与 OA-BENEFIT 同一门槛)。',
targets: () => COST_DEFS.map((c) => `${c.id} ${c.name}`),
},
];
/* ── 图谱:节点=对象,连线=关系 ───────────────────────────────────── */
export const graphNodes = (): { id: string; label: string; count: number; color: string }[] =>
objects.map((o) => ({ id: o.id, label: o.short, count: o.instances().length, color: o.color }));
export const graphEdges = (): { id: string; source: string; target: string; label: string }[] =>
relations.map((r) => ({ id: r.id, source: r.from, target: r.to, label: r.name }));
/* ══════════════════════════════════════════════════════════════════
* 范围披露与自检(供校验脚本与"说明与对照"页引用,数字一律现算)
* ══════════════════════════════════════════════════════════════════ */
export const ONTOLOGY_SCOPE_NOTE =
`主数据全量:设备 ${DEVICES.length} 台 / 线体 ${LINES.length} 条 / 事件定义 ${EVENTS_48.length} 码 / 口径 ${caliberStats().total} 项。`
+ `事实层取锚点设备 ${ANCHOR_DEVICE_ID} 的业务日明细(demo 三日种子;${serviceStats().dates.join('、')}):`
+ '批次与绩效覆盖三日,事件实例与状态段只取当期业务日,损失取当期六桶+因子。'
+ `线体合成待 W2、改善任务待 W3-B、实时直采通道未接入——三处均以 blocked+gap 标灰,不造实例充数。`
+ `另叠共同分析本体:分析问题 ${CARD_DEFS.length} 张(A-01~A-05 / M-01~M-07)、`
+ `因子定义 ${factorGroups().length + DERIVED_FACTORS.length} 个(20 个事件因子组+4 个公式派生)、`
+ `改善对策 ${PLAY_DEFS.length} 张、成本参数 ${COST_DEFS.length} 项;`
+ 'FTRD/返工/在制品/负荷未接入、费率未签字处一律 blocked+gap,不拿良率冒充 FTRD、不出任何金额。';
export function ontologyStats() {
const ids = new Set(objects.map((o) => o.id));
const instCounts = objects.map((o) => ({ id: o.id, n: o.instances().length }));
const nodes = graphNodes();
const edges = graphEdges();
const p0Instances = objectById('caliber')!.instances();
const p0Rows = caliberRows().filter((r) => r['优先级'] === 'P0');
return {
asOf: OEE_ONTOLOGY_AS_OF,
objectCount: objects.length,
objectIds: objects.map((o) => o.id),
instCounts,
totalInstances: instCounts.reduce((a, x) => a + x.n, 0),
attrCounts: objects.map((o) => ({ id: o.id, n: o.attrs.length })),
relationCount: relations.length,
ruleCount: rules.length,
actionCount: actions.length,
/** 图谱节点数=对象数,边数=关系数 */
graphNodeCount: nodes.length,
graphEdgeCount: edges.length,
/** 每条边的两端都必须是真实对象 id */
edgesValid: edges.every((e) => ids.has(e.source) && ids.has(e.target)),
/** 关系两端也必须是真实对象 id(与 edgesValid 同源但独立复核) */
relationEndpointsValid: relations.every((r) => ids.has(r.from) && ids.has(r.to)),
/** ★ tables 必须填对象 id,否则视图聚焦联动静默失效 */
ruleTablesValid: rules.every((r) => r.tables.length > 0 && r.tables.every((t) => ids.has(t))),
actionTablesValid: actions.every((a) => a.tables.length > 0 && a.tables.every((t) => ids.has(t))),
actionObjectsValid: actions.every((a) => objects.some((o) => o.name === a.object)),
/** blocked 规则必须给 gap,否则详情面板无话可说 */
blockedRules: rules.filter((r) => r.blocked).map((r) => r.id),
blockedWithoutGap: rules.filter((r) => r.blocked && !r.gap).map((r) => r.id),
/** 非真空守卫:不能全部规则都 0 命中(那说明 hits 根本没接上真实数据) */
rulesWithHits: rules.filter((r) => r.hits().n > 0).length,
/** 每条规则都能跑出结果且不抛错 */
hitsCallable: rules.every((r) => { const h = r.hits(); return typeof h.n === 'number' && Array.isArray(h.targets); }),
/** 每条关系的 count() 都是非负整数 */
countsCallable: relations.every((r) => Number.isInteger(r.count()) && r.count() >= 0),
/** 关系两端计数互反(属于/包含必须相等) */
belongsMatchesContains: relations.find((r) => r.id === 'eq-line')!.count()
=== relations.find((r) => r.id === 'line-eq')!.count(),
/** ★ P0 未签字不得为绿 */
p0NotGreen: p0Rows.every((r) => {
const inst = p0Instances.find((x) => x.id === s(r['口径编号']));
return inst !== undefined && inst.tone !== 'success';
}),
p0Count: p0Rows.length,
/** ★ 不编造改善任务:当前实例只能是 DQ 问题 */
noFabricatedTasks: impRows().every((r) => s(r['类别']) === 'DQ问题'),
taskInstanceCount: impRows().filter((r) => s(r['类别']) === '改善任务').length,
/** 事件对象必须同时含定义与实例(建议书 3.6「48 定义 + 实例」) */
eventDefCount: rowsOf('event').filter((r) => r['类别'] === '定义').length,
eventInstCount: rowsOf('event').filter((r) => r['类别'] === '实例').length,
/** 绩效=三日 × 三档 */
perfCount: perfRows().length,
tierCount: Object.keys(TIER_LABEL).length,
/** 血缘:每个状态段的事件 id 都能回指真实实例(键空间正确性) */
segmentEventRefsValid: cur().segments.segments
.every((g) => g.eventIds.every((id) => curEvents().some((e) => e.id === id))),
/** 血缘:每个因子的 segmentIds 都能回指真实状态段 */
factorSegmentRefsValid: cur().buckets.factors.length > 0
&& cur().buckets.factors.every((f) => f.segmentIds.length > 0
&& f.segmentIds.every((id) => cur().segments.segments.some((g) => g.id === id))),
/** ★ 事件级归因覆盖:当前为 0 是实测事实(事件行不带 lot 号),由 R-EVENT-ATTRIBUTION 标灰披露 */
attributedEventCount: curEvents().filter((e) => e.attribution?.lotId).length,
/** lot 窗口自识别数(板级锚点印 lot 号 → SELF_IDENTIFIED 1.00),与事件级归因是两件事 */
lotSelfIdentifiedCount: days().reduce((a, d) => a + d.lots.filter((w) => w.selfIdentified).length, 0),
/** ★ 未计时子因子:当期种子未覆盖同段多子因子场景,故为 0;引擎路径由校验脚本合成输入验证 */
untimedCount: days().reduce((a, d) => a + d.buckets.untimedSubFactors.length, 0),
factorCount: cur().buckets.factors.length,
caliberVersion: CALIBER_VERSION,
anchorDevice: ANCHOR_DEVICE_ID,
mode: 'demo' as const,
scopeNote: ONTOLOGY_SCOPE_NOTE,
signoffNote: PARAMS_SIGNOFF_NOTE,
/** ★ 共同分析本体:方法论对象计数(不含统计结果) */
analysisCardCount: CARD_DEFS.length,
analysisLogicCount: CARD_DEFS.filter((c) => c.kind === '分析逻辑').length,
metricComboCount: CARD_DEFS.filter((c) => c.kind === '指标组合').length,
analysisCardGapCount: CARD_DEFS.filter((c) => c.status === '缺口').length,
factorDefCount: factorRowsC().length,
factorGroupCount: factorGroups().length,
factorDerivedCount: DERIVED_FACTORS.length,
factorTimedCount: sixBucketFactorRows().length,
playbookCount: PLAY_DEFS.length,
costParamCount: COST_DEFS.length,
/** ★ 成本参数当前值必须全部留空、签字必须全部待办 → 不产出任何金额 */
costValueFilled: costRowsC().filter((r) => s(r['当前值']) !== '—(未提供)').length,
costSignedCount: costRowsC().filter((r) => s(r['签字状态']) !== '待财务签字').length,
/** 三套"六"分类的成员数,供"说明与对照"页并列展示,防混用 */
sixClassification: {
lossBuckets: LOSS_BUCKETS.length,
grossCategories: Object.keys(GROSS_TO_BUCKET).length,
grossNullKeys: eventStats().nullBucketKeys,
bucketFactorMap: { ...BUCKET_FACTOR },
dqRules: DQ_RULES.length,
blockingDq: [...BLOCKING_DQ],
taskStates: Object.keys(TASK_STATE_LABEL).length,
},
oeeDevices: OEE_DEVICES.length,
};
}