oh-my-knowledge 0.45.0 → 0.46.0

package/dist/server/skill-index.js

@@ -475,6 +475,8 @@ function projectEvalStage(graph, path, entry) {
     const nodesById = graphNodeMap(graph);
     const projectedNodeIds = new Set([variantNode.id]);
     const projectedEdgeIds = new Set();
+    const sampleStatusByNodeId = new Map();
+    const assertionStatusByNodeId = new Map();
     if (skillNode)
         projectedNodeIds.add(skillNode.id);
     const addEdge = (edge) => {
@@ -485,6 +487,9 @@ function projectEvalStage(graph, path, entry) {
     for (const edge of graph.edges) {
         if (edge.fromNodeId === variantNode.id && (edge.edgeKind === 'evaluates' || edge.edgeKind === 'derived_from')) {
             addEdge(edge);
+            const to = nodesById.get(edge.toNodeId);
+            if (edge.status && to?.nodeKind === 'sample')
+                sampleStatusByNodeId.set(to.id, edge.status);
         }
     }
     const evalResultNodes = graph.edges
@@ -501,6 +506,7 @@ function projectEvalStage(graph, path, entry) {
         }
     }
     const declaredCoverageStableKeys = new Set();
+    const declaredCoverageEdges = [];
     let coverageEdges = 0;
     for (const edge of graph.edges) {
         if (edge.edgeKind !== 'covers')
@@ -517,6 +523,17 @@ function projectEvalStage(graph, path, entry) {
         coverageEdges += 1;
         if (to.stableKey)
             declaredCoverageStableKeys.add(to.stableKey);
+        if (to.stableKey) {
+            const sampleStatus = sampleStatusByNodeId.get(from.id);
+            declaredCoverageEdges.push({
+                ...(from.stableKey ? { sampleStableKey: from.stableKey } : {}),
+                sampleLabel: from.label,
+                ...(sampleStatus ? { sampleStatus } : {}),
+                targetStableKey: to.stableKey,
+                targetNodeKind: to.nodeKind,
+                targetLabel: to.label,
+            });
+        }
     }
     const sampleIds = new Set();
     const assertionIds = new Set();
@@ -541,13 +558,31 @@ function projectEvalStage(graph, path, entry) {
             diagnosticIds.add(to.id);
         if (edge.edgeKind === 'fails')
             failedAssertionEdges += 1;
+        if ((edge.edgeKind === 'passes' || edge.edgeKind === 'fails') && edge.status) {
+            if (from?.nodeKind === 'assertion')
+                assertionStatusByNodeId.set(from.id, edge.status);
+            if (to?.nodeKind === 'assertion')
+                assertionStatusByNodeId.set(to.id, edge.status);
+        }
     }
     const measurementNodes = graphNodePreviews(graph, [
         'sample',
         'assertion',
         'eval_result',
         'diagnostic',
-    ], projectedNodeIds);
+    ], projectedNodeIds).map((node) => {
+        if (!node.stableKey)
+            return node;
+        const sourceNode = [...nodesById.values()].find((candidate) => candidate.stableKey === node.stableKey);
+        if (!sourceNode)
+            return node;
+        const status = sourceNode.nodeKind === 'sample'
+            ? sampleStatusByNodeId.get(sourceNode.id)
+            : sourceNode.nodeKind === 'assertion'
+                ? assertionStatusByNodeId.get(sourceNode.id)
+                : undefined;
+        return status ? { ...node, status } : node;
+    });
     return {
         stage: {
             sourceKind: 'eval',
@@ -565,6 +600,7 @@ function projectEvalStage(graph, path, entry) {
             measurementNodes,
             coverageEdges,
             declaredCoverageStableKeys: [...declaredCoverageStableKeys].sort(),
+            declaredCoverageEdges: declaredCoverageEdges.sort((a, b) => a.sampleLabel.localeCompare(b.sampleLabel) || a.targetStableKey.localeCompare(b.targetStableKey)),
         },
         ...(artifactHash ? { artifactHash } : {}),
         ...(sourceLocator ? { sourceLocator } : {}),

package/dist/shared/llm-prompts/registry.js

@@ -65,5 +65,6 @@ export const PROMPT_REGISTRY = [
     { promptId: 'sample-fixer', purpose: '坏用例修复', module: 'src/authoring/sample-fixer.ts', measurementInvariant: false },
     { promptId: 'skill-improve', purpose: 'skill 迭代改进(evolve)', module: 'src/authoring/evolver.ts', measurementInvariant: false },
     { promptId: 'doctor-fixer', purpose: 'doctor 健康项修复向导', module: 'src/doctor/fixer.ts', measurementInvariant: false },
-    { promptId: 'skill-health', purpose: 'skill 健康检查打分', module: 'src/shared/llm-prompts/skill-health.ts', measurementInvariant: false },
+    { promptId: 'skill-health', purpose: 'skill 健康度审计(仅 CLI doctor,不进 eval 评分门禁)', module: 'src/shared/llm-prompts/skill-health.ts', measurementInvariant: false },
+    { promptId: 'skill-health-merge', purpose: '多采样 finding 同根因归并(doctor 多采样默认 llm 归并)', module: 'src/shared/llm-prompts/skill-health-merge.ts', measurementInvariant: false },
 ];

package/dist/shared/llm-prompts/skill-health-merge.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 多采样 finding 归并 prompt(option C:LLM 合并 pass)。
+ *
+ * 健康度体检跑 N 次后,同一个根因问题常被不同次用**不同措辞**描述。纯字符串键
+ * 去重(consensus.ts findingKey)对"措辞/引用写法不同"会漏并 —— 把同一问题拆成
+ * 多条低支持度 finding。本 prompt 让 LLM 做一次跨采样聚类,把同根因 + 同修复方向
+ * 的 finding 归到一组,框架再据此算 support(k/n)。
+ *
+ * 关键契约:
+ *   - 只在维度内部并(不跨 dim_id),保持维度归属稳定。
+ *   - 每个输入 finding 必须且只属于一个 cluster;无法并的自成一组。
+ *   - 宁可不并,也不要把两个不同问题错并(over-merge 会藏掉真问题,比漏并更糟)。
+ *   - LLM 只负责"哪些 id 归一组 + 合并后文案",**支持度 k/n 由框架算**(不信 LLM 算术)。
+ */
+import type { HealthDimensionSpec, HealthFinding } from '../../doctor/health/dimension-spec.js';
+/** 一条带稳定 id 的采样 finding(来自第 sampleIdx 次采样、dimId 维度)。 */
+export interface TaggedFindingView {
+    id: string;
+    dimId: string;
+    finding: HealthFinding;
+}
+export declare function buildHealthMergePrompt(dims: HealthDimensionSpec[], tagged: TaggedFindingView[]): string;

package/dist/shared/llm-prompts/skill-health-merge.js

@@ -0,0 +1,79 @@
+/**
+ * 多采样 finding 归并 prompt(option C:LLM 合并 pass)。
+ *
+ * 健康度体检跑 N 次后,同一个根因问题常被不同次用**不同措辞**描述。纯字符串键
+ * 去重(consensus.ts findingKey)对"措辞/引用写法不同"会漏并 —— 把同一问题拆成
+ * 多条低支持度 finding。本 prompt 让 LLM 做一次跨采样聚类,把同根因 + 同修复方向
+ * 的 finding 归到一组,框架再据此算 support(k/n)。
+ *
+ * 关键契约:
+ *   - 只在维度内部并(不跨 dim_id),保持维度归属稳定。
+ *   - 每个输入 finding 必须且只属于一个 cluster;无法并的自成一组。
+ *   - 宁可不并,也不要把两个不同问题错并(over-merge 会藏掉真问题,比漏并更糟)。
+ *   - LLM 只负责"哪些 id 归一组 + 合并后文案",**支持度 k/n 由框架算**(不信 LLM 算术)。
+ */
+export function buildHealthMergePrompt(dims, tagged) {
+    // 按维度分组,只列出有 finding 的维度。
+    const byDim = new Map();
+    for (const t of tagged) {
+        if (!byDim.has(t.dimId))
+            byDim.set(t.dimId, []);
+        byDim.get(t.dimId).push(t);
+    }
+    const sections = [];
+    for (const dim of dims) {
+        const items = byDim.get(dim.id);
+        if (!items || items.length === 0)
+            continue;
+        const lines = items.map((t) => {
+            const f = t.finding;
+            const sug = f.suggestion ? ` sug="${oneLine(f.suggestion)}"` : '';
+            return `- [${t.id}] level=${f.level} desc="${oneLine(f.description ?? '')}"${sug}`;
+        });
+        sections.push(`## 维度 dim_id=\`${dim.id}\`\n${lines.join('\n')}`);
+    }
+    const allIds = tagged.map((t) => `\`${t.id}\``).join(', ');
+    return `你在归并一个 skill 健康度体检的**多次采样结果**。下面是同一个 skill 跑了多次体检、各次产出的 finding(问题),按维度分组。同一个根因问题在不同次可能用**不同措辞**描述、引用文件名写法也可能不同。
+
+# 任务
+
+把**同根因 + 同修复方向**的 finding 归并成一组(cluster)。
+
+# 规则
+
+- **只在同一维度(dim_id)内部归并**,绝不跨维度合并。
+- "同根因"判定:指向同一处缺陷、修复动作本质相同。措辞不同、引用文件名写法不同(如 \`templates/01-x.tmpl.md\` vs \`templates/<NN>-<name>.tmpl.md\`)**不影响**判定。
+- **每个输入 finding 必须且只能属于一个 cluster**。和谁都并不了的,自成一个单元素 cluster。
+- **宁可不并,也不要把两个不同的问题错并成一组** —— 错并会藏掉真问题,比漏并更糟。
+- 每个 cluster 给一句最准确的合并后 \`description\` 和一条合并后 \`suggestion\`;\`level\` 取该组最严重的(错误 > 警告)。
+
+# 输入
+
+${sections.join('\n\n')}
+
+# 输出 JSON schema
+
+输出**必须是单一合法 JSON 对象**。第一字符 \`{\`,最后 \`}\`,**不要**用 \`\`\`json\`\`\` 围栏,**不要**寒暄。
+
+{
+  "clusters": [
+    {
+      "dim_id": "<该组所属维度 id>",
+      "finding_ids": ["<本组包含的输入 finding id>"],
+      "level": "错误 | 警告",
+      "description": "<合并后一句话讲清这个根因>",
+      "suggestion": "<合并后的统一修改建议>"
+    }
+  ]
+}
+
+# 约束
+
+- 所有输入 id(${allIds})必须出现且仅出现一次,分布在各 cluster 的 \`finding_ids\` 里。
+- \`finding_ids\` 同组的所有 finding 必须是**同一个 dim_id**。
+- \`level\` 用精确中文(错误 / 警告),不要英文或别名。`;
+}
+function oneLine(s) {
+    // 截断:防恶意/超长 SKILL.md 内容原样 ×N 灌进 merge prompt(无界膨胀 + 注入面)。
+    return s.replace(/\s+/g, ' ').replace(/"/g, "'").trim().slice(0, 300);
+}

package/dist/shared/llm-prompts/skill-health.js

@@ -92,7 +92,7 @@ function renderBlock3CommonRules() {
   - 缺少显式声明但从上下文可合理推断的信息
 - \`建议\`:**不要输出建议级别的 finding**。如果问题不够格做警告,就不要报。
 
-**数量控制:每个维度最多 2 条 finding。优先报错误,其次警告。宁可漏报也不要凑数。**
+**完整性:把该维度下**所有**够格(错误 / 警告)的真实问题都列出来,不要因为"已经报了几条"就漏掉同样真实的问题。同时严守上面的 level 门槛 —— 不够格的不要为了凑数硬塞。优先级:错误 > 警告。**
 
 # 维度 level 派生规则
 

package/dist/types/doctor.d.ts

@@ -74,11 +74,25 @@ export interface DoctorContext {
     lang: 'zh' | 'en';
     timeoutMs: number;
     effort?: 'low' | 'medium' | 'high' | 'xhigh' | 'max';
-    /** 深度健康检查(LLM-judge,多维度)开关。CLI doctor 默认 true,`--static-only`
-     *  会过滤 composer rule;programmatic API 默认 false,只跑静态 rule。true 时
-     *  skill_health composer 才真正调 LLM。composer 不在 BUILTIN_RULES,必须先
-     *  import './doctor/health/register.js' 让 registerRule 副作用生效。 */
+    /** 深度健康检查(LLM-judge,多维度)开关。CLI `omk doctor` 默认 true,并与
+     *  静态 rule 一起运行;`--static-only` 置 false。programmatic API 默认 false,
+     *  eval preflight 走静态 rule 路径。true 时 skill_health composer 才真正调 LLM。
+     *  composer 不在 BUILTIN_RULES,必须先 import './doctor/health/register.js'
+     *  让 registerRule 副作用生效。 */
     runHealthCheck?: boolean;
+    /** 健康度体检的采样次数(self-consistency)。composer 跑 N 次 LLM(默认并行),把各次
+     *  finding 取并集去重,每条标注支持度 k/N(N 次里出现 k 次)。默认 1 = 单次采样;注意
+     *  即便 N=1 也走统一归并路径,框架重算 dim level / overall(不再保留 LLM 自报值,
+     *  与历史单次路径在"LLM 自报 level 与 finding 矛盾"时会有差异)。N>1 压低采样方差。 */
+    healthSamples?: number;
+    /** 多采样 finding 归并策略。`string`(默认)= 反引号锚点 / 归一化文本字符串键去重,
+     *  便宜无额外 LLM 调用,但同根因不同措辞可能漏并。`llm` = 多跑一次 LLM 聚类
+     *  (skill-health-merge prompt),跨措辞归并最准,代价是 +1 次 LLM 调用;失败回退
+     *  string。仅 healthSamples>1 时生效。 */
+    healthMerge?: 'string' | 'llm';
+    /** 多采样并发数。默认 = healthSamples(全并行,样本相互独立)。设 1 = 串行。
+     *  并发只压墙钟时间,不改成本(调用次数不变),但会抬高瞬时并发(rate-limit 敏感时调小)。 */
+    healthConcurrency?: number;
 }
 export interface DoctorRule {
     id: string;
@@ -86,8 +100,9 @@ export interface DoctorRule {
     /** i18n key,terminal 渲染时用作 rule 标题。 */
     labelKey: string;
     /** true = 需要外部 I/O(网络 / LLM)的"在线"检查,跟 skill_health composer 同档:
-     *  默认 `omk doctor` 会跑,`--static-only` 离线模式跳过。endpoint 自定义维度置 true。
-     *  缺省(undefined/false)= 纯静态低成本检查(内置 4 条),静态模式才跑。 */
+     *  CLI `omk doctor` 默认会跑(endpoint 自定义维度置 true),`--static-only` 会跳过。
+     *  缺省(undefined/false)= 纯静态低成本检查(内置 4 条),由默认 doctor、
+     *  `--static-only` 与 eval preflight 共同复用。 */
     external?: boolean;
     check(ctx: DoctorContext): Promise<DoctorRuleCheckOutcome>;
 }
@@ -168,9 +183,18 @@ export interface DoctorRunOptions {
      *  既可以是普通 DoctorRule,也可以是 ComposerRule(健康度体检走这条)。 */
     rules?: DoctorRuleLike[];
     /** 深度健康检查(7 维 LLM-judge)。透传给 DoctorContext.runHealthCheck。
-     *  CLI doctor 默认开启;`--static-only` 通过过滤 composer rule 切到离线静态模式。
-     *  programmatic API 默认 false。 */
+     *  CLI `omk doctor` 默认 true;`--static-only` 置 false。programmatic API 默认 false
+     *  (eval preflight 只跑静态 rule)。 */
     runHealthCheck?: boolean;
+    /** 健康度体检采样次数(self-consistency)。透传给 DoctorContext.healthSamples。
+     *  默认 1(单次,行为与历史一致)。CLI 用 `--repeat` 暴露。 */
+    healthSamples?: number;
+    /** 多采样 finding 归并策略,透传给 DoctorContext.healthMerge。programmatic 默认 `string`;
+     *  CLI(`omk doctor`)恒传 `llm`(不暴露开关)。 */
+    healthMerge?: 'string' | 'llm';
+    /** 多采样并发数,透传给 DoctorContext.healthConcurrency。默认 = healthSamples(全并行)。
+     *  CLI 用 `--concurrency` 暴露。 */
+    healthConcurrency?: number;
     effort?: 'low' | 'medium' | 'high' | 'xhigh' | 'max';
     /** 批量体检进度回调(per-skill)。CLI 非 gate 模式注入、写 stderr;eval 内嵌
      *  调用不传(eval 有自己的进度体系,不应冒出 doctor 进度)。 */

package/dist/types/skill-index.d.ts

@@ -57,6 +57,15 @@ export interface SkillGraphNodePreview {
     label: string;
     status?: string;
     coverage?: 'declared' | 'undeclared';
+    coveredBySamples?: string[];
+}
+export interface SkillGraphCoverageEdgePreview {
+    sampleStableKey?: string;
+    sampleLabel: string;
+    sampleStatus?: string;
+    targetStableKey: string;
+    targetNodeKind: string;
+    targetLabel: string;
 }
 export interface SkillGraphSnapshot {
     /** Studio 聚合 graph sidecar 时实际采用的绑定强度。 */
@@ -80,6 +89,7 @@ export interface SkillGraphSnapshot {
         measurementNodes: SkillGraphNodePreview[];
         coverageEdges: number;
         declaredCoverageStableKeys: string[];
+        declaredCoverageEdges: SkillGraphCoverageEdgePreview[];
     };
 }
 export interface SkillIndexEntry {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-knowledge",
-  "version": "0.45.0",
+  "version": "0.46.0",
   "packageManager": "yarn@4.16.0",
   "description": "Evaluation framework for LLM knowledge inputs — prompts, RAG corpora, skills, agent workflows. Fix the model, vary the artifact. Built-in statistical rigor: bootstrap CI, Krippendorff α, length-debias, saturation curves.",
   "type": "module",
@@ -26,6 +26,7 @@
     "docs:preview": "vitepress preview docs",
     "typecheck": "tsc --noEmit",
     "lint": "eslint 'src/**/*.ts' 'test/**/*.ts' --cache --cache-location node_modules/.cache/eslint/ --max-warnings 0",
+    "lint-staged": "lint-staged",
     "test": "vitest run",
     "ci": "run-s lint typecheck build build:docs:check test",
     "prepublishOnly": "run-s clean build",
@@ -111,11 +112,11 @@
     "@types/node": "^25.5.0",
     "eslint": "^10.1.0",
     "husky": "^9.1.7",
-    "lint-staged": "^17.0.4",
+    "lint-staged": "17.0.7",
     "npm-run-all2": "^9.0.1",
     "typescript": "^6.0.2",
     "typescript-eslint": "^8.58.0",
     "vitepress": "^1.6.4",
-    "vitest": "^4.1.3"
+    "vitest": "4.1.8"
   }
 }