oh-my-knowledge 0.44.0 → 0.46.0

package/README.md

@@ -102,7 +102,7 @@ RAG-specific evals: see RAGAS (separate niche, complementary to omk). Full compa
 | **30+ assertion types** | substring, regex, JSON Schema, ROUGE/BLEU/Levenshtein similarity, agent tool-call assertions, semantic similarity, custom JS |
 | **Statistical rigor** | Bootstrap CI / length-debias / saturation curve on by default; Krippendorff α auto-computed with a gold set. [Details →](docs/explanation/statistical-rigor.md) |
 | **RAG metrics** | `faithfulness` / `answer_relevancy` / `context_recall` — anti-hallucination + answer relevance + context coverage |
-| **LLM health audit** | `omk doctor` grades 7 builtin dimensions; `--static-only` runs offline without an LLM |
+| **LLM health audit** | `omk doctor` grades 7 builtin dimensions; repeats the audit (`--repeat`) and merges findings by k/n consensus |
 | **Production observability** | parse Claude Code session JSONL traces; measure per-skill failure rate / latency / cost / knowledge-gap signals |
 | **Knowledge-gap detection** | severity-weighted signals quantify risk exposure instead of claiming completeness |
 | **Construct-validity isolation** | `--strict-baseline` (default ON) cuts three contamination channels so baseline doesn't silently see the skill it's being compared against |

package/README.zh.md

@@ -102,7 +102,7 @@ RAG 专项评测请看 RAGAS（独立 niche，跟 omk 互补）。完整对比
 | **30+ 种断言** | 包含子串、正则、JSON Schema、ROUGE/BLEU/Levenshtein 相似度、Agent 工具调用、语义相似度、自定义函数等 |
 | **统计严谨性** | Bootstrap CI / 长度去偏 / 饱和曲线默认开，Krippendorff α 提供 gold 集即自动计算。[详情 →](docs/zh/explanation/statistical-rigor.md) |
 | **RAG metrics** | `faithfulness` / `answer_relevancy` / `context_recall` 三 metric — 反幻觉 + 切题度 + context 覆盖 |
-| **LLM 健康度审计** | `omk doctor` 给 7 个内置维度独立打分；`--static-only` 可离线无 LLM 调用 |
+| **LLM 健康度审计** | `omk doctor` 给 7 个内置维度独立打分；重复采样（`--repeat`）+ k/n 共识归并 |
 | **线上 session 观测** | 解析 Claude Code session JSONL，测量各 skill 的失败率、耗时、token 成本、知识缺口信号 |
 | **知识缺口识别** | 严重度加权的信号量化风险敞口，不宣称完备性 |
 | **用例隔离 (construct validity)** | `--strict-baseline`（默认开）三堵 baseline 拿到被测 skill 的污染路径 |

package/dist/artifact-graph/doctor.js

@@ -506,7 +506,7 @@ export function renderDoctorEvidenceCard(graph, skill, lang) {
         ];
     const hiddenStructure = renderStructureDetails(graph, lang);
     return [
-        `## ${zh ? 'Skill Evidence Card' : 'Skill Evidence Card'}：${skill.skillName}`,
+        `## ${zh ? '知识图谱摘要' : 'Skill Map Summary'}${zh ? '：' : ': '}${skill.skillName}`,
         '',
         statusSentence,
         '',

package/dist/artifact-graph/eval.js

@@ -133,8 +133,73 @@ function sampleAttrs(snapshot) {
         display.tripwire = true;
     if (snapshot.assertions?.length)
         display.assertionCount = snapshot.assertions.length;
+    if (snapshot.covers?.length)
+        display.declaredCoverageTargetCount = snapshot.covers.length;
     return Object.keys(display).length > 0 ? { display } : undefined;
 }
+const COVERAGE_TARGET_NODE_KIND = {
+    skill: 'skill',
+    skill_file: 'skill_file',
+    frontmatter: 'frontmatter',
+    reference: 'reference',
+    script: 'script',
+    hard_rule: 'hard_rule',
+    workflow: 'workflow',
+    workflow_node: 'workflow_node',
+};
+function normalizeCoverageRef(target) {
+    const raw = target.ref.trim().replaceAll('\\', '/');
+    if (target.targetKind === 'reference' || target.targetKind === 'script' || target.targetKind === 'skill_file') {
+        return raw.replace(/^\/+/, '').replace(/^\.\//, '');
+    }
+    return raw;
+}
+function coverageTargetStableKey(target, artifactHash) {
+    const ref = normalizeCoverageRef(target);
+    switch (target.targetKind) {
+        case 'skill':
+            return `v1:skill:${artifactHash}`;
+        case 'skill_file':
+            return `v1:skill-file:${artifactHash}:${ref || 'SKILL.md'}`;
+        case 'frontmatter':
+            return `v1:frontmatter:${artifactHash}`;
+        case 'reference':
+            return `v1:reference:${artifactHash}:${ref}`;
+        case 'script':
+            return `v1:script:${artifactHash}:${ref}`;
+        case 'hard_rule':
+            return `v1:hard-rule:${artifactHash}:${ref}`;
+        case 'workflow':
+            return `v1:workflow:${artifactHash}:${ref}`;
+        case 'workflow_node':
+            return `v1:workflow-node:${artifactHash}:${ref}`;
+    }
+}
+function coverageTargetLabel(target) {
+    const ref = normalizeCoverageRef(target);
+    switch (target.targetKind) {
+        case 'skill':
+            return ref && ref !== 'skill' ? ref : 'SKILL.md';
+        case 'skill_file':
+            return ref || 'SKILL.md';
+        case 'frontmatter':
+            return 'frontmatter';
+        default:
+            return ref;
+    }
+}
+function coverageEvidence(report, sampleId, targetIndex, target) {
+    return [{
+            sourceKind: 'sample',
+            sourceId: sampleId,
+            selector: {
+                selectorKind: 'json-pointer',
+                value: `/sampleSnapshots/${jsonPointerToken(sampleId)}/covers/${targetIndex}`,
+            },
+            contentHash: report.meta.sampleHashes?.[sampleId],
+            label: `${sampleId} covers ${target.targetKind}:${normalizeCoverageRef(target)}`,
+        }];
+}
 export function evalGraphDirForReportOutput(reportOutputDir) {
     return basename(reportOutputDir) === 'reports'
         ? join(dirname(reportOutputDir), 'graphs', 'eval')
@@ -147,6 +212,16 @@ export function buildEvalArtifactGraph(options) {
     const edges = [];
     const nodeIdsByStableKey = new Map();
     const configs = variantConfigByName(report);
+    const skillArtifacts = report.meta.variants
+        .map((variant) => ({
+        variant,
+        artifactHash: report.meta.artifactHashes?.[variant],
+        config: configs.get(variant),
+    }))
+        .filter((item) => item.config?.artifactKind === 'skill'
+        && typeof item.artifactHash === 'string'
+        && item.artifactHash.length > 0
+        && item.artifactHash !== 'no-skill');
     const addNode = (stableKey, nodeKind, nodeRole, label, extra = {}) => {
         const existing = nodeIdsByStableKey.get(stableKey);
         if (existing)
@@ -175,6 +250,50 @@ export function buildEvalArtifactGraph(options) {
             ...extra,
         });
     };
+    const addCoverageEdges = (sampleId, sampleNodeId, snapshot) => {
+        if (!snapshot.covers?.length || skillArtifacts.length === 0)
+            return;
+        const seen = new Set();
+        snapshot.covers.forEach((target, targetIndex) => {
+            const targetRef = normalizeCoverageRef(target);
+            if (!targetRef && target.targetKind !== 'skill' && target.targetKind !== 'frontmatter')
+                return;
+            for (const artifact of skillArtifacts) {
+                const stableKey = coverageTargetStableKey(target, artifact.artifactHash);
+                const dedupeKey = `${sampleNodeId}|${stableKey}`;
+                if (seen.has(dedupeKey))
+                    continue;
+                seen.add(dedupeKey);
+                const evidenceRefs = coverageEvidence(report, sampleId, targetIndex, target);
+                const targetNodeId = addNode(stableKey, COVERAGE_TARGET_NODE_KIND[target.targetKind], 'entity', coverageTargetLabel(target), {
+                    binding: { bindingStrength: 'content-hash', keys: { artifactHash: artifact.artifactHash } },
+                    attrs: {
+                        display: {
+                            targetKind: target.targetKind,
+                            ref: targetRef,
+                            variant: artifact.variant,
+                            sourceLocator: artifact.config.locator,
+                        },
+                    },
+                    evidenceRefs,
+                });
+                addEdge(sampleNodeId, targetNodeId, 'covers', {
+                    confidence: 1,
+                    binding: {
+                        bindingStrength: 'explicit',
+                        keys: {
+                            sampleId,
+                            targetKind: target.targetKind,
+                            targetRef,
+                            artifactHash: artifact.artifactHash,
+                        },
+                    },
+                    attrs: { producer: { source: 'sample.covers' } },
+                    evidenceRefs,
+                });
+            }
+        });
+    };
     const variantNodeIds = new Map();
     for (const variant of report.meta.variants) {
         const artifactHash = report.meta.artifactHashes?.[variant];
@@ -241,6 +360,7 @@ export function buildEvalArtifactGraph(options) {
             });
             addEdge(sampleNodeId, assertionNodeId, 'contains');
         });
+        addCoverageEdges(sampleId, sampleNodeId, snapshot);
     }
     for (const [resultIndex, result] of report.results.entries()) {
         const sampleNodeId = addNode(sampleStableKey(report, result.sample_id), 'sample', 'entity', result.sample_id, {

package/dist/assets/agent-skills/omk/SKILL.md

@@ -121,11 +121,11 @@ omk sample --batch
 ### 体检 skill 写法
 
 ```bash
-# 全量体检（含 LLM-judge 维度）
+# 健康度审计（默认 --repeat 2 采样 + k/n 共识归并）
 omk doctor
 
-# 只跑静态检查不调 LLM
-omk doctor --static-only
+# 单次快检（不采样、不归并，最省）
+omk doctor --repeat 1
 
 # 针对单 skill
 omk doctor skills/my-skill.md

package/dist/assets/agent-skills/omk/references/commands.md

@@ -6,7 +6,7 @@
 
 ## omk doctor
 
-体检 omk 工作目录，检查 skill 配置 / 依赖 / executor 连通性。
+体检 omk 工作目录：先跑静态规则，再对 skill 做多维度 LLM 健康度审计（默认 --repeat 2 采样 + 共识归并）。
 
 **用法:**
 
@@ -20,6 +20,7 @@ omk doctor [target] [flags]
 
 **Flags:**
 
+- `--concurrency` `option`:多次采样的并发数。默认 = --repeat（全并行，各遍相互独立，压墙钟时间）。设 1 = 串行。成本不变，只抬高瞬时并发（rate-limit 敏感时调小）。
 - `--dimensions` `option`:自定义维度配置文件（YAML），追加到内置 7 维度之后。每条维度二选一：promptSection（走 LLM 体检）或 endpoint（POST skill 快照给接口判定）。注意：endpoint 会把 SKILL.md 全文 + 子文件发到该地址，仅对可信配置/可信地址启用。
 - `--effort` `option`:LLM 推理 effort：low / medium / high / xhigh / max。
 - `--executor` `option`:执行器名，默认 claude。指定为测试 fixture 路径可在测试里跑（同 omk doctor）。
@@ -30,25 +31,31 @@ omk doctor [target] [flags]
 - `--lang` `option` (默认 `zh`):输出语言 zh|en，优先级 CLI > OMK_LANG env > zh。
 - `--model` `option`:LLM model 名，默认 sonnet。
 - `--output-dir` `option`:报告输出目录，默认项目级 .omk/doctors（--global 写全局）。
-- `--samples` `option`:用例文件路径（.json/.yaml）。不传则按 target / cwd 顺序自动发现。
-- `--static-only` `boolean`:离线静态模式，只跑 4 条静态 rule(skill_readable / skill_metadata / dependencies_present / samples_contract_aligned），不调 LLM。
+- `--repeat` `option`:健康度体检重复采样次数（self-consistency）。默认 2：并行跑 2 遍、finding 取并集并用 LLM 聚类归并同根因、标注支持度 k/N，压低单次采样方差。设 1 = 单次快速体检（不采样、不归并，最省）。
+- `--static-only` `boolean`:只跑静态检测（不调 LLM、不读 samples.json）：skill 可读性 / frontmatter 合法性 / 正文引用的脚本·CLI·文件·env 是否存在。CI 无 LLM 凭证或断网时用。
 - `--timeout` `option`:单次 LLM 会话超时秒数，默认 600(10 分钟）。
 
 **示例:**
 
-> 默认模式跑 LLM 健康度审计(7 内置维度）。
+> 默认模式跑静态规则 + LLM 健康度审计（7 内置维度）。
 
 ```bash
 omk doctor
 ```
 
-> 离线静态模式，只跑 4 条静态 rule，不调 LLM,CI 无 LLM 凭证时用。
+> 单次快速体检（不采样、不归并，最省）。
+
+```bash
+omk doctor --repeat 1
+```
+
+> 只跑静态检测（不调 LLM、不读 samples）：结构 + 正文依赖检查。
 
 ```bash
 omk doctor --static-only
 ```
 
-> JSON 输出 + 写 HTML 报告，给 CI 抓 exit code 同时人看。
+> JSON 输出 + 静默 gate，给 CI 抓 exit code 同时人看。
 
 ```bash
 omk doctor --json --gate

package/dist/cli/commands/doctor.d.ts

@@ -14,14 +14,15 @@ export default class Doctor extends BaseCommand {
         gate: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         executor: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         model: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        samples: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         timeout: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'output-dir': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         global: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         dimensions: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        'static-only': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         fix: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         effort: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        repeat: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        concurrency: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'static-only': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }

package/dist/cli/commands/doctor.js

@@ -3,7 +3,7 @@ import { join, resolve } from 'node:path';
 import { Args, Flags } from '@oclif/core';
 import { LANG_FLAG, bilingual } from '../oclif/i18n.js';
 import { BaseCommand } from '../oclif/base-command.js';
-import { numberStringParser } from '../oclif/parsers.js';
+import { enumStringParser, integerStringParser, numberStringParser } from '../oclif/parsers.js';
 import { CliExit } from '../lib/cli-exit.js';
 import { tCli } from '../lib/i18n.js';
 import { makeDoctorProgress } from '../lib/progress.js';
@@ -12,32 +12,38 @@ import { indexDoctorWrite, removeDoctorCard } from '../../eval-core/artifact-ind
 import { doctorReportFileStem, isReportFileName, reportFilePath } from '../../eval-core/artifact-file-names.js';
 import { migrateLegacyReportFiles } from '../../eval-core/report-file-migration.js';
 import { projectDoctorsDir, globalDoctorsDir } from '../../eval-core/measurement-dirs.js';
-import { findDoctorDeprecatedSamplesHint, findDoctorSamplesPath } from '../../inputs/sample-locator.js';
 import { persistDoctorGraphSidecars, removeDoctorGraphSidecars } from '../../artifact-graph/doctor.js';
 export default class Doctor extends BaseCommand {
     static description = bilingual({
-        zh: '体检 omk 工作目录，检查 skill 配置 / 依赖 / executor 连通性。',
-        en: 'Preflight health checks for omk workdir: skill config / deps / executor connectivity.',
+        zh: '体检 omk 工作目录：先跑静态规则，再对 skill 做多维度 LLM 健康度审计（默认 --repeat 2 采样 + 共识归并）。',
+        en: 'Preflight health checks for omk workdir: static rules plus multi-dimension LLM health audit of your skills (default --repeat 2 sampling + consensus merge).',
     });
     static examples = [
         {
             description: bilingual({
-                zh: '默认模式跑 LLM 健康度审计(7 内置维度）。',
-                en: 'Default mode runs LLM-driven health audit (7 built-in dimensions).',
+                zh: '默认模式跑静态规则 + LLM 健康度审计（7 内置维度）。',
+                en: 'Default mode runs static rules plus LLM-driven health audit (7 built-in dimensions).',
             }),
             command: '<%= config.bin %> doctor',
         },
         {
             description: bilingual({
-                zh: '离线静态模式，只跑 4 条静态 rule，不调 LLM,CI 无 LLM 凭证时用。',
-                en: 'Offline static mode, only 4 static rules, no LLM call. Use when CI lacks LLM credentials.',
+                zh: '单次快速体检（不采样、不归并，最省）。',
+                en: 'Single quick pass (no sampling/merge, cheapest).',
+            }),
+            command: '<%= config.bin %> doctor --repeat 1',
+        },
+        {
+            description: bilingual({
+                zh: '只跑静态检测（不调 LLM、不读 samples）：结构 + 正文依赖检查。',
+                en: 'Static checks only (no LLM, no samples): structural + body-dependency checks.',
             }),
             command: '<%= config.bin %> doctor --static-only',
         },
         {
             description: bilingual({
-                zh: 'JSON 输出 + 写 HTML 报告，给 CI 抓 exit code 同时人看。',
-                en: 'JSON output + HTML report, for CI exit code + human review.',
+                zh: 'JSON 输出 + 静默 gate，给 CI 抓 exit code 同时人看。',
+                en: 'JSON output + silent gate, for CI exit code + human review.',
             }),
             command: '<%= config.bin %> doctor --json --gate',
         },
@@ -79,12 +85,6 @@ export default class Doctor extends BaseCommand {
                 en: 'LLM model name, default sonnet.',
             }),
         }),
-        samples: Flags.string({
-            description: bilingual({
-                zh: '用例文件路径（.json/.yaml）。不传则按 target / cwd 顺序自动发现。',
-                en: 'Samples file path (.json/.yaml). Auto-detects from target / cwd if omitted.',
-            }),
-        }),
         timeout: Flags.string({
             description: bilingual({
                 zh: '单次 LLM 会话超时秒数，默认 600(10 分钟）。',
@@ -110,13 +110,6 @@ export default class Doctor extends BaseCommand {
                 en: 'Custom dimensions config file (YAML), appended after builtin 7. Each is either promptSection (LLM audit) or endpoint (POST skill snapshot to your service). Note: endpoint sends the full SKILL.md + sub-files to that URL — only enable for trusted configs/URLs.',
             }),
         }),
-        'static-only': Flags.boolean({
-            description: bilingual({
-                zh: '离线静态模式，只跑 4 条静态 rule(skill_readable / skill_metadata / dependencies_present / samples_contract_aligned），不调 LLM。',
-                en: 'Offline static mode: only 4 static rules, no LLM call.',
-            }),
-            default: false,
-        }),
         fix: Flags.boolean({
             description: bilingual({
                 zh: '交互式修复：根据 doctor 报告问题，用 LLM agent 修复 skill。',
@@ -129,6 +122,28 @@ export default class Doctor extends BaseCommand {
                 zh: 'LLM 推理 effort：low / medium / high / xhigh / max。',
                 en: 'LLM reasoning effort: low / medium / high / xhigh / max.',
             }),
+            parse: enumStringParser('--effort', ['low', 'medium', 'high', 'xhigh', 'max']),
+        }),
+        repeat: Flags.string({
+            description: bilingual({
+                zh: '健康度体检重复采样次数（self-consistency）。默认 2：并行跑 2 遍、finding 取并集并用 LLM 聚类归并同根因、标注支持度 k/N，压低单次采样方差。设 1 = 单次快速体检（不采样、不归并，最省）。',
+                en: 'Health-check repeat count (self-consistency). Default 2: runs 2 passes in parallel, unions findings, merges same root cause via an LLM pass, tags k/N support. Set 1 for a single quick pass (no sampling/merge, cheapest).',
+            }),
+            parse: integerStringParser('--repeat', { min: 1, max: 10 }),
+        }),
+        concurrency: Flags.string({
+            description: bilingual({
+                zh: '多次采样的并发数。默认 = --repeat（全并行，各遍相互独立，压墙钟时间）。设 1 = 串行。成本不变，只抬高瞬时并发（rate-limit 敏感时调小）。',
+                en: 'Concurrency across the repeated passes. Default = --repeat (full parallel; passes are independent, cuts wall-clock). Set 1 for serial. Cost unchanged; only raises peak concurrency (lower it if rate-limited).',
+            }),
+            parse: integerStringParser('--concurrency', { min: 1, max: 10 }),
+        }),
+        'static-only': Flags.boolean({
+            description: bilingual({
+                zh: '只跑静态检测（不调 LLM、不读 samples.json）：skill 可读性 / frontmatter 合法性 / 正文引用的脚本·CLI·文件·env 是否存在。CI 无 LLM 凭证或断网时用。',
+                en: 'Static checks only (no LLM, no samples.json): readability / frontmatter / existence of scripts·CLI·files·env referenced in the skill body. For CI without LLM creds / offline.',
+            }),
+            default: false,
         }),
     };
     async run() {
@@ -138,39 +153,21 @@ export default class Doctor extends BaseCommand {
             const target = args.target ?? null;
             const executorName = flags.executor ?? 'claude';
             const model = flags.model ?? 'sonnet';
-            // 默认 LLM 健康度审计(7 内置维度 + 用户注册的自定义维度);--static-only 切到
-            // 离线静态模式:只跑 4 条静态 rule,不调 LLM。CI 节点没装 claude/codex、本地断网
-            // 调试等场景。
-            const staticOnly = flags['static-only'];
-            const runHealthCheck = !staticOnly;
+            // omk doctor 默认 = 静态规则 + LLM 健康度审计(7 内置维度 + 用户注册的自定义维度);
+            // --static-only = 只跑静态检测(readable / metadata / 正文依赖,不调 LLM、不读 samples)。
+            // samples_contract_aligned 仍只归 eval preflight(它要 samples.json,与离线解耦)。
+            // 健康度体检重复采样次数(CLI flag --repeat → 内部 healthSamples 字段):默认 2,
+            // 设 1 = 单次快检。合法范围由 oclif parser 拦截。
+            const healthSamples = flags.repeat != null ? Number(flags.repeat) : 2;
+            // 归并策略:CLI 恒用 llm(硬逻辑,不暴露开关);samples=1 时 composer 自动跳过归并。
+            // 失败回退 string 仍在 composer 内兜底。programmatic runDoctor 默认仍是 string。
+            const healthMerge = 'llm';
+            // 并发数(--concurrency → healthConcurrency):默认不传(composer 取 = healthSamples 全并行);显式 ≥1 才覆盖。
+            const healthConcurrency = flags.concurrency != null ? Number(flags.concurrency) : undefined;
             const defaultTimeoutSec = 600;
             const timeoutSec = flags.timeout != null ? Number(flags.timeout) : defaultTimeoutSec;
             const timeoutMs = Math.max(1000, Math.floor((Number.isFinite(timeoutSec) ? timeoutSec : defaultTimeoutSec) * 1000));
             const cwd = process.cwd();
-            const samplesPath = flags.samples ? resolve(flags.samples) : findDoctorSamplesPath(target, cwd);
-            const deprecatedSamplesHint = !flags.samples && !samplesPath
-                ? findDoctorDeprecatedSamplesHint(target, cwd)
-                : null;
-            if (deprecatedSamplesHint) {
-                process.stderr.write(tCli('cli.common.deprecated_skill_samples_path', lang, {
-                    oldPath: deprecatedSamplesHint.oldPath,
-                    newPath: deprecatedSamplesHint.newPath,
-                }));
-            }
-            let samples;
-            let requires;
-            if (samplesPath) {
-                try {
-                    const { loadSamples } = await import('../../inputs/load-samples.js');
-                    const loaded = loadSamples(samplesPath);
-                    samples = loaded.samples;
-                    requires = loaded.requires;
-                }
-                catch (err) {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    process.stderr.write(tCli('cli.common.warn_load_samples_failed', lang, { path: samplesPath, message: msg }));
-                }
-            }
             // 副作用 import: 注册 7 内置维度 spec + skill_health composer rule。
             await import('../../doctor/health/register.js');
             if (flags.dimensions) {
@@ -184,15 +181,22 @@ export default class Doctor extends BaseCommand {
             const { renderDoctorReportText, renderDoctorReportJson } = await import('../../doctor/renderer.js');
             const { getRegisteredRules } = await import('../../doctor/rules.js');
             const { isComposerRule } = await import('../../types/doctor.js');
-            // 在线检查(LLM health composer + endpoint 自定义维度)默认跑;--static-only
-            // 离线模式只跑纯静态的内置 rule(无网络 / LLM)。endpoint rule 标了 external=true。
+            // 默认:静态规则 + 在线检查(LLM health composer + endpoint 自定义维度 external=true)。
+            // --static-only:只跑静态检测(纯静态内置 rule),但排除 samples_contract_aligned
+            // (那条要 samples.json,与离线解耦) → 且不加载 samples,依赖检查只扫 skill 正文。
+            const staticOnly = flags['static-only'];
             const isOnline = (r) => isComposerRule(r) || r.external === true;
             const rulesOverride = staticOnly
-                ? getRegisteredRules().filter((r) => !isOnline(r))
-                : getRegisteredRules().filter(isOnline);
+                ? getRegisteredRules().filter((r) => !isOnline(r) && r.id !== 'samples_contract_aligned')
+                : getRegisteredRules().filter((r) => r.id !== 'samples_contract_aligned');
             // 批量体检进度(per-skill,写 stderr)。--gate 是静默模式,不报进度;
             // --json 进度走 stderr 不污染 stdout 的 JSON。
             const onProgress = flags.gate ? undefined : makeDoctorProgress(lang);
+            // --effort 合法性由 oclif parser 拦截。这里仅做窄化后透传给健康审计。
+            const validEfforts = ['low', 'medium', 'high', 'xhigh', 'max'];
+            const effort = flags.effort && validEfforts.includes(flags.effort)
+                ? flags.effort
+                : undefined;
             let report;
             try {
                 report = await runDoctor({
@@ -202,10 +206,12 @@ export default class Doctor extends BaseCommand {
                     model,
                     timeoutMs,
                     lang,
-                    runHealthCheck,
+                    runHealthCheck: !staticOnly,
+                    healthSamples,
+                    healthMerge,
+                    healthConcurrency,
+                    effort,
                     rules: rulesOverride,
-                    samples,
-                    requires,
                     onProgress,
                 });
             }
@@ -233,9 +239,6 @@ export default class Doctor extends BaseCommand {
                 }
             }
             else {
-                if (samplesPath && samples) {
-                    process.stderr.write(tCli('cli.doctor.samples_detected', lang, { path: samplesPath }) + '\n');
-                }
                 renderDoctorReportText(report, lang);
             }
             persistDoctorReport(report, flags['output-dir']
@@ -248,7 +251,7 @@ export default class Doctor extends BaseCommand {
                     throw new CliExit(0);
                 }
                 const { runDoctorFix } = await import('../../doctor/fixer.js');
-                const changed = await runDoctorFix({ report: existing, executorName, model, timeoutMs });
+                const changed = await runDoctorFix({ report: existing, executorName, model, timeoutMs, effort });
                 throw new CliExit(changed ? 0 : (existing.outcome === 'failed' ? 1 : 0));
             }
             throw new CliExit(report.outcome === 'failed' ? 1 : 0);

package/dist/cli/lib/cmd-flags.d.ts

@@ -58,11 +58,12 @@ export interface DoctorFlags {
     gate: boolean;
     executor?: string;
     model?: string;
-    samples?: string;
     timeout?: string;
     'output-dir'?: string;
     dimensions?: string;
-    'static-only': boolean;
+    repeat?: string;
+    concurrency?: string;
+    effort?: string;
 }
 export type EvalArgs = Record<string, never>;
 export interface EvalFlags {

package/dist/cli/lib/i18n-dict/common.d.ts

@@ -1,3 +1,3 @@
 import type { CliMessage } from './types.js';
-export type CommonMessageKey = 'cli.common.unknown_domain' | 'cli.common.error_prefix' | 'cli.common.skill_dir_not_found' | 'cli.common.skill_file_not_found' | 'cli.common.skill_dir_no_skill_md' | 'cli.common.report_not_found' | 'cli.common.no_judge_model' | 'cli.common.judge_models_single_only' | 'cli.common.warn_load_samples_failed' | 'cli.common.deprecated_skill_samples_path' | 'cli.common.samples_not_found' | 'cli.update.new_version_available' | 'cli.update.box_title' | 'cli.update.box_version_line' | 'cli.update.box_upgrade_line' | 'cli.update.box_silence_line' | 'cli.observe.view_hint' | 'cli.observe.observation_recorded' | 'cli.observe.production_gap' | 'cli.studio.started' | 'cli.studio.stop_hint' | 'cli.studio.open_failed' | 'cli.doctor.no_skill_found' | 'cli.doctor.samples_detected' | 'cli.doctor.progress_skill_start' | 'cli.doctor.progress_skill_done';
+export type CommonMessageKey = 'cli.common.unknown_domain' | 'cli.common.error_prefix' | 'cli.common.skill_dir_not_found' | 'cli.common.skill_file_not_found' | 'cli.common.skill_dir_no_skill_md' | 'cli.common.report_not_found' | 'cli.common.no_judge_model' | 'cli.common.judge_models_single_only' | 'cli.common.warn_load_samples_failed' | 'cli.common.deprecated_skill_samples_path' | 'cli.common.samples_not_found' | 'cli.update.new_version_available' | 'cli.update.box_title' | 'cli.update.box_version_line' | 'cli.update.box_upgrade_line' | 'cli.update.box_silence_line' | 'cli.observe.view_hint' | 'cli.observe.observation_recorded' | 'cli.observe.production_gap' | 'cli.studio.started' | 'cli.studio.stop_hint' | 'cli.studio.open_failed' | 'cli.doctor.no_skill_found' | 'cli.doctor.progress_skill_start' | 'cli.doctor.progress_skill_done';
 export declare const commonDict: Record<CommonMessageKey, CliMessage>;

package/dist/cli/lib/i18n-dict/common.js

@@ -91,10 +91,6 @@ export const commonDict = {
         zh: '未在 {path} 下发现 skill 文件。\n  doctor 期望 .md 文件、目录(包含 .md 或 SKILL.md)或 cwd 下的 skills/ 子目录。',
         en: 'No skills found at {path}.\n  doctor expects a .md file, a directory (containing .md or SKILL.md), or skills/ under cwd.',
     },
-    'cli.doctor.samples_detected': {
-        zh: '✓ 使用评测用例文件：{path}',
-        en: '✓ Using eval samples file: {path}',
-    },
     'cli.doctor.progress_skill_start': {
         zh: '{prefix}{skill} ⏳ 体检中...\n',
         en: '{prefix}{skill} ⏳ checking...\n',

package/dist/doctor/endpoint-rule.js

@@ -222,7 +222,7 @@ export function makeEndpointRule(spec, fetchFn = fetch) {
         severity: spec.severity,
         // 自定义 key 不在 DOCTOR_MESSAGES 字典里,renderer 会 fallback 到 ruleId(=spec.id)。
         labelKey: `cli.doctor.endpoint.${spec.id}`,
-        // 网络检查,与 health composer 同档:默认跑,--static-only 跳过。
+        // 网络检查,与 health composer 同档:CLI doctor 默认跑(在线检查)。
         external: true,
         async check(ctx) {
             // SSRF 防护(defense-in-depth):endpoint 会收到 skill 完整快照,且响应