@huicai/cli 2026.712.80880 → 2026.721.0

package/skills/eng-observability/scripts/slo-calc.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+# SLO 错误预算计算器（eng-observability SLO/燃烧率纪律的可执行版）。python3 stdlib,零依赖。
+# 用法:
+#   python3 slo-calc.py budget --slo 99.9 [--window-days 30]
+#       # SLO→允许的不可用时长与错误预算
+#   python3 slo-calc.py burn --slo 99.9 --total 2600000 --errors 4100 [--window-days 30 --elapsed-days 12]
+#       # 已消耗预算/燃烧率/按当前速度何时烧尽
+#   python3 slo-calc.py alert --slo 99.9
+#       # 双窗口燃烧率告警阈值建议(1h 急/6h 缓)
+#   python3 slo-calc.py --selftest
+import argparse
+import sys
+
+
+def cmd_budget(a):
+    frac = 1 - a.slo / 100
+    mins = a.window_days * 24 * 60 * frac
+    print(f"SLO {a.slo}% @ {a.window_days} 天窗口:")
+    print(f"  错误预算 = {frac:.4%} ≈ 不可用 {mins:.0f} 分钟({mins / 60:.1f} 小时)")
+    for s in (99.0, 99.5, 99.9, 99.95, 99.99):
+        m = a.window_days * 24 * 60 * (1 - s / 100)
+        cur = "  <== 当前" if abs(s - a.slo) < 1e-9 else ""
+        print(f"  参考: {s}% → {m:.0f} 分钟/{a.window_days}天{cur}")
+    print("纪律: SLO 从历史数据定(先观测 1–3 个月),别拍'四个九'再倒推;对外 SLA=SLO 打一档折。")
+
+
+def cmd_burn(a):
+    frac = 1 - a.slo / 100
+    budget = a.total * frac
+    used = a.errors / budget * 100 if budget else 0
+    elapsed_share = a.elapsed_days / a.window_days * 100
+    rate = used / elapsed_share if elapsed_share else 0
+    print(f"窗口 {a.window_days} 天已过 {a.elapsed_days} 天({elapsed_share:.0f}%);总请求 {a.total:,},失败 {a.errors:,}")
+    print(f"  错误预算 = {a.total:,} × {frac:.4%} = {budget:,.0f} 次失败额度")
+    print(f"  已消耗 {used:.1f}%  燃烧率 = 消耗{used:.1f}% ÷ 时间{elapsed_share:.0f}% = {rate:.2f}")
+    if rate > 0:
+        days_left = (100 - used) / (used / a.elapsed_days) if used > 0 else float("inf")
+        print(f"  按当前速度: 约 {days_left:.1f} 天后烧尽(窗口还剩 {a.window_days - a.elapsed_days} 天)")
+    if rate >= 2:
+        print("  判定: [红] 燃烧率≥2 —— 值班介入,查错误来源(变更嫌疑第一问)")
+    elif rate > 1:
+        print("  判定: [黄] 燃烧率>1 —— 烧得比时间快,盯紧趋势")
+    elif used >= 100:
+        print("  判定: [红] 预算已烧尽 —— 冻结特性发布只保稳定性修复(eng-release 联动,业务提前签认)")
+    else:
+        print("  判定: 预算健康(燃烧率≤1)")
+
+
+def cmd_alert(a):
+    frac = 1 - a.slo / 100
+    print(f"双窗口燃烧率告警建议(SLO {a.slo}%,月窗口):")
+    fast = 0.02 * 30 * 24  # 1h 烧掉月预算 2% → 燃烧率
+    slow = 0.05 * 30 * 24 / 6
+    print(f"  急(page): 1 小时窗口燃烧率 > {fast:.0f}(=1h 烧掉月预算 2%) → 电话叫人")
+    print(f"  缓(工单): 6 小时窗口燃烧率 > {slow:.0f}(=6h 烧掉月预算 5%) → 次日处理")
+    print(f"  换算成错误率阈值: 急={fast * frac:.3%} 缓={slow * frac:.3%}(该服务的瞬时失败率)")
+    print("纪律: 告警三问过了才配上通道;燃烧率告警替代'错误率>x 持续 y 分钟'的拍脑袋阈值。")
+
+
+def selftest():
+    ns = argparse.Namespace
+    cmd_budget(ns(slo=99.9, window_days=30))
+    cmd_burn(ns(slo=99.9, total=2600000, errors=4100, window_days=30, elapsed_days=12))
+    cmd_alert(ns(slo=99.9))
+    print("\nselftest ok")
+    return 0
+
+
+def main():
+    if "--selftest" in sys.argv:
+        sys.exit(selftest())
+    p = argparse.ArgumentParser(description="SLO 错误预算与燃烧率")
+    sub = p.add_subparsers(dest="cmd", required=True)
+    b = sub.add_parser("budget"); b.add_argument("--slo", type=float, required=True); b.add_argument("--window-days", type=int, default=30)
+    r = sub.add_parser("burn"); r.add_argument("--slo", type=float, required=True); r.add_argument("--total", type=int, required=True); r.add_argument("--errors", type=int, required=True); r.add_argument("--window-days", type=int, default=30); r.add_argument("--elapsed-days", type=float, default=15)
+    al = sub.add_parser("alert"); al.add_argument("--slo", type=float, required=True)
+    a = p.parse_args()
+    {"budget": cmd_budget, "burn": cmd_burn, "alert": cmd_alert}[a.cmd](a)
+
+
+if __name__ == "__main__":
+    main()

package/skills/eng-ops/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: eng-ops
+description: 运维链（事件 P1-P4 分级响应→作战通道与指挥官→oncall 轮值升级→变更管理三类→问题管理与 Postmortem 闭环→容量成本水位→备份恢复演练→SLA/SLO 联动）。工程链运维环节深耕:建值班体系、线上事件处置、复盘、变更管控、备份演练时载入。工单与 ITIL 细则由 itsm-ops 承接。
+version: 1.0.0
+---
+
+# 运维链
+
+engineering-chain 的运维环节子链。两条铁律:**恢复优先于根因**;**一切操作留痕**。
+分工:事前的容错设计/混沌演练/韧性评审走 **eng-reliability**,本链管事中响应与事后闭环;
+系统层排障(CPU/内存/IO/网络四棵决策树/容器特供)载 **ops-linux**;智能运维(告警聚类/Runbook 问答/排障 Copilot 纪律)载 **ai-aiops**;批量主机运维(金丝雀分批/补丁编排/systemd 规范/CMDB)载 **ops-fleet**。
+
+## 事件分级与响应 SLA
+
+| 级别 | 定义 | 响应 | 升级 |
+|---|---|---|---|
+| P1 | 核心业务不可用/数据损坏/资损进行中 | 5 分钟接手,战时状态 | 30 分钟未恢复→管理层知悉;逢 P1 必拉作战通道 |
+| P2 | 核心功能降级/大面积体验劣化 | 15 分钟接手 | 2 小时未恢复→升 P1 处理规格 |
+| P3 | 次要功能异常/单客户阻塞 | 当日处理 | 重复出现 3 次→开问题单 |
+| P4 | 体验瑕疵/优化建议 | 排期 | — |
+
+**分级看业务影响,不看技术原因**(一台机器挂了但用户无感=P4;一行配置错但全站白屏=P1)。
+
+## 事件处置动作序
+
+1. **止血四板斧先试**:回滚(最近变更嫌疑第一)→切流(摘节点/切机房)→扩容(资源饱和型)→降级(开关预案,eng-release 运营开关);
+2. 作战通道:拉群、指定**指挥官**(唯一决策人,可以不是最资深但必须唯一)、分工(操作手/联络人/记录员);
+3. **15 分钟一次进展播报**,哪怕内容是"无进展,正在排查 X"——沉默比坏消息更消耗信任;
+4. 证据保全先于恢复操作:现场快照(线程栈/内存/日志段/监控截图)再动手,否则根因永远"疑似";
+5. 恢复确认用业务指标(下单成功率回升),不是"服务起来了";
+6. 根因排查转 debug-root-cause(假设-验证法,**变更嫌疑第一问:刚才谁改了什么**——七成事件答案在这)。
+
+## oncall 轮值
+
+主备双人(主 15 分钟无响应自动升备);交接清单:未关事件/近 3 天变更/已知风险与预案位置;
+升级路径写死并演练:15min 无进展→备份介入,30min→Lead,P1 立即;
+新人先跟班两轮再独立值班;oncall 工作量计入绩效与调休——**白嫖值班的团队留不住人**。
+
+## 变更管理（事件之母)
+
+- 三类分治:**普通变更**(评审+窗口+回滚方案);**标准变更**(预批准模板:证书轮换/白名单调整等低风险高频项,免评审但留痕);**紧急变更**(先做后补审批,24h 内补票);
+- 变更三要素缺一不批:实施方案/验证方法/回滚方案;
+- 高危变更(动生产数据/动网络/动权限)**四眼原则**:一人操作一人复核,逐条念出来再回车;
+- 变更日历全团队可见:冲突检测(同窗口动同一系统)、冻结期(大促/月结)标红;
+- 变更单关联监控:观察期内告警自动关联最近变更单(eng-observability 事件线)。
+
+## 问题管理与 Postmortem
+
+- 事件→问题升级判据:P1/P2 必开问题单;P3 同模式 3 次必开;
+- Postmortem 模板:时间线到分钟(发现/响应/止血/恢复各时刻)、五问法根因(问到系统与流程层,禁止停在"某人失误"——**人会重复失误,系统要拦得住**)、影响量化(时长/用户数/损失)、Action 清单(每条有 Owner/期限/验收标准);**作业包**:`references/postmortem-template.md`(直接复制填写,含三回写确认清单与 oncall 交接清单附件);
+- 无指责文化 ≠ 无责任闭环:不追究个人,但 Action 超期升级到管理层月度清账;
+- 复盘会 48h 内开(记忆保鲜),对事故当事人友善,对流程漏洞狠。
+
+## 容量与成本水位
+
+月度水位报告:CPU/内存/磁盘/连接数 TOP10 实例 + 增长斜率外推(**斜率打到 85% 的日期提前 3 个月扩容立项**);
+僵尸资源季度清理(无流量服务/无主磁盘/超保留期快照);成本异动(环比>20%)当月归因——账单是最诚实的架构评审。
+
+## 备份与恢复演练
+
+3-2-1 原则:3 份副本、2 种介质、1 份异地;
+**备份的有效性=最近一次恢复演练的结果**,不是备份任务的绿灯——季度演练:真恢复、计时、比对数据完整性,RTO/RPO 实测值回填灾备等级表(eng-infra);
+恢复手册要"新人照着能做":恐慌时刻没人记得住口口相传的步骤。
+
+## SLA/SLO 联动
+
+对外 SLA=对内 SLO 打一档折(内部 99.95% 才敢对外承诺 99.9%);
+SLO 与错误预算机制见 **eng-observability**;预算烧尽→冻结特性发布只保稳定性修复(eng-release 联动)——**这条要提前和业务讲好,烧尽时才有执行力**。
+
+## 使用纪律
+
+生产操作留痕(谁/何时/何命令/为何)+高危四眼;例行操作先脚本化再自动化(office-automation 例程:巡检/清理/报告);
+每次事件复盘三回写:根因模式入库、缺的告警补上、能自动化的止血动作做成预案开关。
+**运维的成熟度=无聊的程度:例行的都自动化了,剩下的才配叫事件。**

package/skills/eng-ops/references/postmortem-template.md

@@ -0,0 +1,67 @@
+# Postmortem 复盘模板（eng-ops 问题管理的落笔件）
+
+> 使用纪律:事件恢复后 48h 内开复盘会(记忆保鲜);对人友善,对流程狠;时间线到分钟、根因到系统层、Action 可验收。
+> 本模板直接复制成 `postmortem-YYYYMMDD-事件短名.md` 填写,归档进事件库(eng-docs 知识回写)。
+
+## 1. 元信息
+
+| 项 | 内容 |
+|---|---|
+| 事件编号/级别 | INC-____ / P_ |
+| 标题(一句话) | 例:支付回调堆积导致订单状态延迟 2 小时 |
+| 发生时间 → 恢复时间 | ____-__-__ __:__ → __:__(总时长 __ 分钟) |
+| 影响量化 | 影响用户 __ 人/订单 __ 笔/损失 __ 元/SLO 预算消耗 __%(拍不准就给区间,不许空着) |
+| 发现方式 | 告警 / 用户投诉 / 内部发现 ← **投诉先于告警=监控欠账,第 6 节必须有 Action** |
+| 参与人 | 指挥官:__ 操作:__ 记录:__ |
+
+## 2. 时间线（到分钟;含"决策点"不只"动作"）
+
+| 时刻 | 事件/动作 | 备注 |
+|---|---|---|
+| __:__ | 首个异常信号(哪个指标/告警) | |
+| __:__ | 值班响应,初判为 __ | 初判错了也要记——错的初判是流程改进素材 |
+| __:__ | 止血动作:回滚/切流/扩容/降级 __ | 为什么选这个,当时依据什么 |
+| __:__ | 业务指标恢复(以 __ 指标回升为准) | 恢复确认用业务指标,不是"服务起来了" |
+| __:__ | 根因确认 | |
+
+## 3. 根因（五问法,问到系统与流程层）
+
+- 直接原因:__(什么坏了)
+- 为什么 1:__ → 为什么 2:__ → 为什么 3:__ → 为什么 4/5:__
+- **停在"某人失误"=没问完**:人会重复失误,要问"什么样的防线本可拦住这次失误"(门禁/评审/预案/告警)。
+- 根因分类(勾选,进模式库统计): □ 变更引入 □ 容量/性能 □ 依赖故障 □ 配置错误 □ 代码缺陷 □ 数据问题 □ 基础设施 □ 流程缺失
+
+## 4. 做得好的(保持项)
+
+- 例:止血 8 分钟(四板斧先回滚);播报节奏 15 分钟一报没有断。
+
+## 5. 暴露的问题(不指名,指环节)
+
+- 例:告警晚于用户投诉 12 分钟;回滚预案文档过期,实际步骤靠回忆。
+
+## 6. Action 清单（每条三要素齐才许关会）
+
+| # | Action | Owner | 期限 | 验收标准(可判定) | 类型 |
+|---|---|---|---|---|---|
+| 1 | 例:支付回调堆积量告警(阈值=常态×3) | __ | __-__ | 告警上线且演练触发一次 | 监控补位 |
+| 2 | 例:回滚 Runbook 重写并演练 | __ | __-__ | 新值班照 Runbook 独立完成演练 | 预案 |
+| 3 | 例:同模式风险面横扫(其余回调接口) | __ | __-__ | 横扫清单+整改工单挂出 | 防复发 |
+
+> Action 纪律:有 Owner 有期限有验收标准;超期升级管理层月度清账;
+> **三必查**:缺的告警补了吗(eng-observability)/暴露的容错缺口进混沌清单了吗(eng-reliability)/该自动化的止血做成预案开关了吗(eng-automation)。
+
+## 7. 三回写确认（工程链复利,勾了才算闭环）
+
+- [ ] 根因模式入库(eng-ops 模式统计)
+- [ ] 本可更早发现的信号已补(eng-observability"哪个信号本可以更早")
+- [ ] 相关链的坑清单/判据表已增补(具体链:______)
+
+---
+
+# 附:oncall 交接清单模板（每次换班 5 分钟过一遍）
+
+- 未关事件: INC-__ 状态/下一步/联系人
+- 近 3 天变更: __(变更日历链接)——变更嫌疑第一问的弹药
+- 已知风险与预案位置: __(如"明晨月结批量,失败预案见 Runbook-x")
+- 特殊值守要求: __(灰度观察中的服务/客户升级窗口 env-private-deploy)
+- 工具确认: 告警通道收得到/VPN 与跳板可登/一键体检脚本可用(ops-linux quick-triage)

package/skills/eng-performance/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: eng-performance
+description: 性能链（性能口径 P99/RT/QPS→基准测试纪律→压测方案判据(阶梯/浸泡/尖峰/全链路)→RED/USE 瓶颈定位路径→分层优化手段表→容量水位规划→性能回归防线）。工程链性能环节深耕:接口慢、压测立项、容量评估、大促备战、性能劣化排查时载入。画像工具与调优细节由 perf-optimize、慢 SQL 由 sql-tuning 承接。
+version: 1.0.0
+---
+
+# 性能链
+
+engineering-chain 的性能环节子链。铁律一句话:**无度量不优化,无基线不谈劣化**。
+
+## 口径先行（口径错,全错）
+
+- 四件套一起看:RT 分布(P50/P95/P99)、吞吐(QPS/TPS)、错误率、饱和度(资源余量)——只看平均 RT=没看(长尾才是投诉来源);
+- 换算关系:QPS ≈ 并发数 ÷ 平均 RT(秒),混淆并发与 QPS 是压测方案第一错;
+- 性能目标写法(进验收标准,eng-requirements):"P99<300ms @ 1000QPS,错误率<0.1%,持续 30 分钟"——四要素缺一不可判定;
+- 区分吞吐型(批处理,看单位时间处理量)与延迟型(在线接口,看分位数),优化手段常互斥(攒批提吞吐会伤延迟)。
+
+## 基准测试纪律
+
+同机器/同数据规模/同参数才可比;预热剔除(JIT/缓存爬坡期不计入);多轮取分布(P99 波动>20% 先查环境再下结论);
+记录环境快照(版本/配置/数据量/依赖状态)——**没有环境快照的基准数据三个月后就是垃圾数字**。
+
+## 压测方案判据
+
+| 类型 | 目的 | 要点 |
+|---|---|---|
+| 阶梯加压 | 找容量拐点 | 逐级加压观察 RT 拐点与错误率抬头;拐点×0.7=安全水位 |
+| 浸泡(4h+) | 找泄漏与劣化 | 恒定中压;盯内存/连接数/句柄斜率,斜率>0=有泄漏 |
+| 尖峰 | 验突发弹性 | 瞬时 N 倍;看限流降级是否按预案动作、恢复时间 |
+| 全链路 | 大促合练 | 影子流量+数据隔离(影子表/标记透传);**压测数据污染生产=事故** |
+
+环境纪律:等比环境直接压;缩容环境标折算系数并写明局限(缓存命中率与连接池行为不等比缩放)。
+
+## 瓶颈定位路径（先服务后资源,逐层下钻）
+
+1. **RED 看服务**:哪个服务的请求率/错误率/时延异常——先锁定层;
+2. **USE 看资源**:该层的 CPU/内存/磁盘 IO/网络的利用率、饱和度、错误——CPU 高看火焰图,CPU 不高看等待(锁/IO/下游);
+3. 常见瓶颈签名速查:线程池满+CPU 低=下游慢或锁;GC 频繁=分配率高或堆小;DB 连接池满=慢查询占坑(sql-tuning);
+   RT 齐刷刷抬升=共享资源饱和;只有 P99 差=长尾(GC 停顿/缓存未命中路径/热点键);
+4. **一次只改一个变量**,改前留基线,改后对照——同时改三处=不知道哪个起效,下次还得瞎猜。
+
+## 分层优化手段表（症状→手段→代价）
+
+| 层 | 手段 | 代价/风险 |
+|---|---|---|
+| 应用 | 池化(连接/线程/对象)、异步化、批量化、本地缓存 | 异步化提吞吐不降单次延迟;本地缓存有一致性窗口 |
+| 运行时 | JVM/GC 调优(dev-java)、GOMEMLIMIT(dev-go)等 | 参数复制别人的=刻舟求剑,要配自己的画像 |
+| 数据库 | 索引/慢查/N+1 治理(sql-tuning)、读写分离 | 索引写放大;读写分离有复制延迟 |
+| 缓存 | 引入判据读写比>10:1;穿透(空值缓存)/击穿(单飞)/雪崩(过期打散)三防(工程细则 **db-redis**) | 一致性复杂度;三防缺一个=事故预定 |
+| 网络 | 连接复用/压缩/CDN/就近接入 | 压缩耗 CPU;CDN 缓存键设计错=窜数据 |
+| 前端 | 首屏与资源优化(dev-frontend Core Web Vitals) | — |
+| 架构 | 削峰队列/降级预案/单元化(eng-architecture) | 复杂度跳变,走架构评审 |
+
+**优化 ROI 先算再动手**(Amdahl 定律:占总耗时 20% 的环节优化到零也只快 25%)——火焰图上最宽的块才值得动。
+
+## 容量规划
+
+安全水位=压测拐点×0.7;扩容触发线=水位 70% 持续一周(给采购/扩容留提前量);
+大促容量=日常峰值×业务给的系数×1.5 安全余量,**系数要业务签字**(技术自己拍=背锅);
+容量台账季度复核,扩完回填实测(eng-ops 水位月报衔接)。
+
+## 性能回归防线
+
+核心接口基线入 CI/发布门禁:对比基线劣化>10% 报警、>30% 阻断(阈值按业务调);
+每版本出性能对照表(发布清单项,eng-release);依赖升级(dependency-upgrade)后必跑基准——**性能是被一次次"没多大影响"的提交吃掉的**。
+
+**作业包**:`scripts/perf-baseline.py`(延迟样本分位数报告与基线对比,P99 劣化超阈值退出码 1——接 CI 即性能门禁)。
+
+## 使用纪律
+
+无 profile 不动手(perf-optimize 承接画像取证);优化 PR 必附前后对照数据与压测条件;
+过早优化是万恶之源,但**容量估算不是优化,是设计**(eng-architecture 公式);
+每次性能事故回写:瓶颈签名入速查表、缺的监控补上(eng-observability)。

package/skills/eng-performance/scripts/perf-baseline.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+# 性能基线对比器（eng-performance 回归防线的可执行版):两份延迟样本→分位数对比→劣化判定。
+# python3 stdlib,零依赖。样本文件=每行一个延迟值(ms),压测/日志/埋点导出皆可。
+# 用法:
+#   python3 perf-baseline.py report samples.txt                       # 单份样本出分位数报告
+#   python3 perf-baseline.py compare baseline.txt current.txt [--p99-limit 10] [--p50-limit 15]
+#   python3 perf-baseline.py --selftest
+# 退出码: 0=无劣化 1=劣化超阈值(接 CI 即性能门禁,cicd-pipeline) 2=输入错误。
+# 纪律: 同机器同数据同参数才可比(基准纪律);样本 <200 条置信度差,报告会标注。
+import sys
+
+
+def load(path):
+    vals = []
+    try:
+        with open(path, encoding="utf-8") as f:
+            for ln in f:
+                ln = ln.strip().rstrip("ms").strip()
+                if not ln or ln.startswith("#"):
+                    continue
+                try:
+                    vals.append(float(ln))
+                except ValueError:
+                    pass
+    except OSError as e:
+        print(f"[错误] {path}: {e}")
+        sys.exit(2)
+    if not vals:
+        print(f"[错误] {path} 无有效样本(每行一个毫秒数)")
+        sys.exit(2)
+    return sorted(vals)
+
+
+def pct(vs, p):
+    if not vs:
+        return 0.0
+    k = (len(vs) - 1) * p / 100
+    lo, hi = int(k), min(int(k) + 1, len(vs) - 1)
+    return vs[lo] + (vs[hi] - vs[lo]) * (k - lo)
+
+
+def stats(vs):
+    return {
+        "n": len(vs), "mean": sum(vs) / len(vs), "min": vs[0], "max": vs[-1],
+        "P50": pct(vs, 50), "P90": pct(vs, 90), "P95": pct(vs, 95), "P99": pct(vs, 99),
+    }
+
+
+def show(name, s):
+    warn = "  [!] 样本<200,置信度差(多轮取分布,eng-performance 基准纪律)" if s["n"] < 200 else ""
+    print(f"{name}: n={s['n']}{warn}")
+    print(f"  P50={s['P50']:.1f}  P90={s['P90']:.1f}  P95={s['P95']:.1f}  P99={s['P99']:.1f}  "
+          f"mean={s['mean']:.1f}  max={s['max']:.1f}")
+
+
+def cmd_report(path):
+    show(path, stats(load(path)))
+    print("提醒: 只看平均值=没看;长尾(P99)才是用户体验与投诉来源。")
+    return 0
+
+
+def cmd_compare(base_p, cur_p, p99_limit, p50_limit):
+    b, c = stats(load(base_p)), stats(load(cur_p))
+    show("基线", b)
+    show("当前", c)
+    print("---- 对比(正=劣化) ----")
+    rc = 0
+    for k, limit in (("P50", p50_limit), ("P95", None), ("P99", p99_limit)):
+        if b[k] <= 0:
+            continue
+        d = (c[k] - b[k]) * 100 / b[k]
+        mark = ""
+        if limit is not None and d > limit:
+            mark = f"  <== 超阈值 {limit}%,阻断"
+            rc = 1
+        elif d > 5:
+            mark = "  (关注)"
+        print(f"  {k}: {b[k]:.1f} → {c[k]:.1f}  ({d:+.1f}%){mark}")
+    if rc:
+        print("判定: 劣化超阈值 —— 阻断合入/发布;火焰图定位后再来(无 profile 不优化)。")
+    else:
+        print("判定: 无显著劣化(阈值内波动;环境噪音大时多轮复测再下结论)。")
+    return rc
+
+
+def selftest():
+    import tempfile, os, random
+    random.seed(7)
+    with tempfile.TemporaryDirectory() as d:
+        b, c = os.path.join(d, "b.txt"), os.path.join(d, "c.txt")
+        open(b, "w").write("\n".join(str(random.gauss(100, 10)) for _ in range(500)))
+        open(c, "w").write("\n".join(str(random.gauss(130, 30)) for _ in range(500)))
+        assert cmd_compare(b, c, 10, 15) == 1, "应判劣化"
+        assert cmd_compare(b, b, 10, 15) == 0, "自比应通过"
+    print("selftest ok: 分位数/劣化判定/退出码正常")
+    return 0
+
+
+if __name__ == "__main__":
+    a = sys.argv[1:]
+    if "--selftest" in a:
+        sys.exit(selftest())
+    if len(a) >= 2 and a[0] == "report":
+        sys.exit(cmd_report(a[1]))
+    if len(a) >= 3 and a[0] == "compare":
+        p99 = float(a[a.index("--p99-limit") + 1]) if "--p99-limit" in a else 10.0
+        p50 = float(a[a.index("--p50-limit") + 1]) if "--p50-limit" in a else 15.0
+        sys.exit(cmd_compare(a[1], a[2], p99, p50))
+    print(__doc__ or "用法见文件头注释")
+    sys.exit(2)

package/skills/eng-planning/SKILL.md

@@ -0,0 +1,79 @@
+---
+name: eng-planning
+description: 需求排期子链（WBS 拆解→三点/故事点估算→依赖与关键路径→资源拉平→关键链缓冲→里程碑验收→燃尽追踪→延期三案→估时校准库）。工程链排期环节深耕:出项目计划、迭代规划、被问"什么时候能上线"、项目延期救火时载入。工时表与甘特模板由 project-management 承接。
+version: 1.0.0
+---
+
+# 需求排期子链
+
+engineering-chain 的排期环节子链。输入:需求基线(eng-requirements)+架构方案(eng-architecture,决定任务结构);
+产物:WBS、里程碑计划、依赖矩阵、风险登记册、燃尽基线。
+
+## WBS 拆解
+
+- 粒度:拆到 **≤3 人天**;>3 天的任务=还没想清楚,继续拆或标注不确定性研究(spike,时间盒)。
+- 动词开头(“实现 XX 接口”“迁移 XX 表”),交付物可验证。
+- **100% 规则漏项清单**(计划总在这些地方漏):环境搭建、测试数据准备、联调(按接口数×0.5 天起)、
+  代码评审与返工、部署与配置、埋点、文档、bug 修复期(开发工时×20–30%)、上线值守、需求答疑损耗。
+- 使能任务(重构/升级)进 WBS 并占容量,不许"顺手做"——顺手=延期之源。
+
+## 估算方法判据
+
+| 方法 | 适用 | 要点 |
+|---|---|---|
+| 三点法 PERT | 单任务工时 | (乐观+4×最可能+悲观)÷6;悲观值要真悲观(联调对方没空/环境坏两天) |
+| 故事点 | 迭代制团队 | 斐波那契相对估;锚定 2–3 个基准故事;点数不跨团队比较 |
+| 类比法 | 有历史相似项 | 查估时校准库,乘个人/模块系数 |
+
+纪律:**谁干活谁估**(替估必偏乐观);集体估(planning poker 式)暴露理解分歧——分歧本身比数字值钱;
+估算给区间不给单点;对外承诺用 **P80** 不用 P50。
+
+## 依赖与关键路径
+
+- 依赖矩阵:任务×任务标 FS/SS/FF;外部依赖(其他团队/采购/审批)单独成表,**每条挂确认人与承诺日期**——外部依赖是延期第一杀手。
+- 关键路径上的任务:每日站会必问、资源优先保、风险预案必备;非关键路径任务有浮动时间,别用最紧资源。
+- 并行度检查:纸面并行≠实际并行(同一个人/同一环境/同一接口方=串行)。
+
+## 资源与容量
+
+- 人均可用工时打折:会议/支撑/答疑扣 20–30%;新人系数 0.5–0.7(前两月);跨项目的人按实际投入比折算,**"他有空的时候做"=没有排期**。
+- 迭代容量=近 3 个迭代实际完成速率均值(不是理想值);预留 10–20% 给技术债与突发(eng-architecture 债台账、线上问题)。
+
+## 缓冲策略（关键链法）
+
+- 单任务估算里的私藏缓冲挤掉(用激进估算),**项目级缓冲统一放末尾**,大小=关键路径的 15–20%;
+- 追踪看两个比率:缓冲消耗率 vs 进度完成率——缓冲烧得比进度快=黄灯,快一倍=红灯启动延期三案;
+- 里程碑之间不共享缓冲(防止前松后紧)。
+
+## 里程碑定义
+
+里程碑=可验收的交付物,不是百分比:"登录链路可演示""压测报告出炉"是里程碑,"完成 80%"不是。
+每个里程碑挂验收人+验收标准(来自 eng-requirements);里程碑前一周做前置检查:DoD 逐项预核,来不及的提前暴露。
+
+## 进度追踪
+
+- 燃尽/燃起图每日更新;**偏差>15% 触发重排**,不许"后面赶一赶"糊弄——历史上"赶一赶"从未发生过。
+- 状态只有三种:完成(过验收标准)/未开始/进行中——"完成 90%"按未完成对待(最后 10% 消耗 50% 时间是常态)。
+- 风险登记册每周过:概率×影响排序,TOP3 必须有应对动作(不是"关注")。
+
+## 延期三案（提前给,别等爆雷）
+
+| 方案 | 操作 | 代价明说 |
+|---|---|---|
+| 砍范围 | MoSCoW 的 Could/Won't 先砍,Should 谈判 | 功能少;**默认首选,伤害最小** |
+| 顺延时间 | 关键路径重算给新 P80 日期 | 商务/市场承诺违约成本 |
+| 加资源 | 只对可并行块有效 | Brooks 定律:新人上手期反拖慢;沟通成本平方增长 |
+
+三案都给数字和代价,**让业务方选,不替业务方选**;技术方案降级(临时方案上、重构后补)算第四案,必须同时立还债任务进台账,否则就是永久方案。
+
+## 估时校准库（排期的复利所在）
+
+结项后回写:每任务 实际/估算 比、偏差原因归类(漏项/依赖延误/需求变更/低估复杂度)、个人与模块系数。
+下次排期先查库:同类任务历史偏差×1.2 起步。**没有校准库,每次排期都是第一次排期。**
+
+**作业包**:`scripts/schedule-calc.py`(pert/project/velocity 三算:三点估算、项目 P50/P80、迭代速率预测——承诺口径 P80、缓冲放末尾)。
+
+## 使用纪律
+
+无 WBS 不承诺日期;外部依赖必有确认人;承诺 P80;偏差>15% 重排并同步干系人;
+结项必回写校准库。**排期的目的不是"排出好看的表",是让延期在第一周而不是最后一周暴露。**

package/skills/eng-planning/scripts/schedule-calc.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+# 排期计算器（eng-planning 三点估算/关键链缓冲/速率预测的可执行版）。python3 stdlib,零依赖。
+# 用法:
+#   python3 schedule-calc.py pert --o 3 --m 5 --p 12                    # 单任务三点估算
+#   python3 schedule-calc.py project --csv tasks.csv [--buffer 0.18]    # 项目级:CSV=任务,乐观,最可能,悲观
+#   python3 schedule-calc.py velocity --history 12,15,10,14 --backlog 60  # 迭代速率预测
+#   python3 schedule-calc.py --selftest
+# 纪律输出:承诺用 P80 不用 P50;缓冲统一放末尾不摊到单任务(关键链法)。
+import argparse
+import csv
+import math
+import sys
+
+
+def pert_one(o, m, p):
+    e = (o + 4 * m + p) / 6
+    sd = (p - o) / 6
+    return e, sd
+
+
+def cmd_pert(a):
+    e, sd = pert_one(a.o, a.m, a.p)
+    print(f"E=(乐观{a.o}+4×最可能{a.m}+悲观{a.p})÷6 = {e:.1f}  σ=(悲观-乐观)÷6 = {sd:.1f}")
+    print(f"P50≈{e:.1f}  P80≈{e + 0.84 * sd:.1f}  P95≈{e + 1.65 * sd:.1f}")
+    print("对外承诺口径=P80(eng-planning 纪律);悲观值要真悲观(联调对方没空/环境坏两天)。")
+    if a.p < a.m * 1.5:
+        print("[提醒] 悲观值 <1.5×最可能 —— 悲观得不够悲观的嫌疑,复核一下")
+
+
+def cmd_project(a):
+    rows = []
+    with open(a.csv, encoding="utf-8") as f:
+        for ln in csv.reader(f):
+            if not ln or ln[0].startswith("#") or ln[0] in ("任务", "name"):
+                continue
+            if len(ln) < 4:
+                print(f"[跳过] 列不足: {ln}")
+                continue
+            rows.append((ln[0], float(ln[1]), float(ln[2]), float(ln[3])))
+    if not rows:
+        print("[错误] CSV 无有效行(格式: 任务,乐观,最可能,悲观)")
+        return 2
+    total_e, var = 0.0, 0.0
+    print(f"{'任务':<20} {'E':>6} {'σ':>5}")
+    for name, o, m, p in rows:
+        e, sd = pert_one(o, m, p)
+        total_e += e
+        var += sd * sd
+        big = "  <== >3 人天,继续拆(WBS 粒度纪律)" if e > 3 and a.unit == "day" else ""
+        print(f"{name:<20} {e:>6.1f} {sd:>5.1f}{big}")
+    sd_t = math.sqrt(var)
+    buf = total_e * a.buffer
+    print(f"\n合计 E={total_e:.1f}  项目σ={sd_t:.1f}(√Σσ²,独立假设——强依赖任务实际更差)")
+    print(f"统计口径: P50={total_e:.1f}  P80={total_e + 0.84 * sd_t:.1f}  P95={total_e + 1.65 * sd_t:.1f}")
+    print(f"关键链口径: 激进估算 {total_e:.1f} + 项目缓冲 {buf:.1f}({a.buffer:.0%},统一放末尾) = {total_e + buf:.1f}")
+    print("追踪: 缓冲消耗率 vs 进度完成率——烧得比进度快=黄灯,快一倍=红灯启动延期三案。")
+
+
+def cmd_velocity(a):
+    hist = [float(x) for x in a.history.split(",") if x.strip()]
+    n = len(hist)
+    mean = sum(hist) / n
+    sd = math.sqrt(sum((x - mean) ** 2 for x in hist) / (n - 1)) if n > 1 else 0
+    print(f"近 {n} 迭代速率: 均值 {mean:.1f}  σ {sd:.1f}(用近 3 个迭代实际值,不是理想值)")
+    usable = mean * (1 - a.reserve)
+    print(f"可用容量 = {mean:.1f} × (1-还债预留{a.reserve:.0%}) = {usable:.1f}/迭代")
+    if usable > 0:
+        p50 = a.backlog / usable
+        lo = a.backlog / (usable + 0.84 * sd * (1 - a.reserve)) if sd else p50
+        hi = a.backlog / max(usable - 0.84 * sd * (1 - a.reserve), 0.1) if sd else p50
+        print(f"待办 {a.backlog} → 预计 {p50:.1f} 个迭代(P50);区间 {lo:.1f} ~ {hi:.1f}(±0.84σ)")
+        print(f"对外口径取上限 {math.ceil(hi)} 个迭代(P80 精神)。")
+
+
+def selftest():
+    ns = argparse.Namespace
+    cmd_pert(ns(o=3, m=5, p=12))
+    import tempfile, os
+    with tempfile.TemporaryDirectory() as d:
+        f = os.path.join(d, "t.csv")
+        open(f, "w", encoding="utf-8").write("任务,乐观,最可能,悲观\n接口开发,2,3,6\n联调,1,2,5\n压测,1,1,3\n")
+        cmd_project(ns(csv=f, buffer=0.18, unit="day"))
+    cmd_velocity(ns(history="12,15,10,14", backlog=60, reserve=0.15))
+    print("\nselftest ok")
+    return 0
+
+
+def main():
+    if "--selftest" in sys.argv:
+        sys.exit(selftest())
+    p = argparse.ArgumentParser(description="排期计算(承诺 P80,缓冲放末尾)")
+    sub = p.add_subparsers(dest="cmd", required=True)
+    q = sub.add_parser("pert"); q.add_argument("--o", type=float, required=True); q.add_argument("--m", type=float, required=True); q.add_argument("--p", type=float, required=True)
+    j = sub.add_parser("project"); j.add_argument("--csv", required=True); j.add_argument("--buffer", type=float, default=0.18); j.add_argument("--unit", default="day")
+    v = sub.add_parser("velocity"); v.add_argument("--history", required=True); v.add_argument("--backlog", type=float, required=True); v.add_argument("--reserve", type=float, default=0.15)
+    a = p.parse_args()
+    sys.exit({"pert": cmd_pert, "project": cmd_project, "velocity": cmd_velocity}[a.cmd](a) or 0)
+
+
+if __name__ == "__main__":
+    main()