oh-my-knowledge 0.43.0 → 0.45.0

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.d.ts

@@ -0,0 +1,16 @@
+import type { ArtifactGraphDocument, EvaluationReport } from '../types/index.js';
+export interface BuildEvalGraphOptions {
+    report: EvaluationReport;
+    sourcePath: string;
+    generatedAt?: string;
+}
+export interface PersistEvalGraphOptions extends BuildEvalGraphOptions {
+    outputDir: string;
+    fileStem?: string;
+}
+export interface PersistEvalGraphResult {
+    graphPath: string;
+}
+export declare function evalGraphDirForReportOutput(reportOutputDir: string): string;
+export declare function buildEvalArtifactGraph(options: BuildEvalGraphOptions): ArtifactGraphDocument;
+export declare function persistEvalGraphSidecar(options: PersistEvalGraphOptions): PersistEvalGraphResult;

package/dist/artifact-graph/eval.js

@@ -0,0 +1,471 @@
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { graphFileName } from '../eval-core/artifact-file-names.js';
+function shortHash(input) {
+    return createHash('sha256').update(input).digest('hex').slice(0, 12);
+}
+function jsonPointerToken(value) {
+    return value.replaceAll('~', '~0').replaceAll('/', '~1');
+}
+function sampleSetHash(sampleHashes) {
+    if (!sampleHashes || Object.keys(sampleHashes).length === 0)
+        return undefined;
+    const canonical = Object.entries(sampleHashes)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([id, hash]) => `${id}:${hash}`)
+        .join('|');
+    return shortHash(canonical);
+}
+function statusFromScore(score) {
+    // Display band only. This is not the verdict gate and intentionally does not
+    // reference DEFAULT_GATE_THRESHOLD or statistical significance decisions.
+    if (score === undefined || !Number.isFinite(score))
+        return 'unknown';
+    if (score >= 4)
+        return 'ok';
+    if (score >= 3)
+        return 'warning';
+    return 'failed';
+}
+function assertionStatus(result) {
+    // Assertion topology status only. Pure LLM-scored samples have no assertion
+    // pass/fail edge, so they stay unknown here even when compositeScore is high.
+    if (result.error || !result.ok)
+        return 'failed';
+    const details = result.assertions?.details;
+    if (!details || details.length === 0)
+        return 'unknown';
+    return details.every((detail) => detail.passed) ? 'ok' : 'failed';
+}
+function artifactBinding(variant, hash) {
+    if (hash && hash !== 'no-skill') {
+        return { bindingStrength: 'content-hash', keys: { artifactHash: hash } };
+    }
+    return { bindingStrength: 'name-only', keys: { variantName: variant } };
+}
+function sampleBinding(sampleId, hash) {
+    if (hash) {
+        return { bindingStrength: 'content-hash', keys: { sampleHash: hash } };
+    }
+    return { bindingStrength: 'name-only', keys: { sampleId } };
+}
+function variantConfigByName(report) {
+    return new Map((report.meta.variantConfigs ?? []).map((config) => [config.variant, config]));
+}
+function scopeArtifactKind(report) {
+    const kinds = new Set((report.meta.variantConfigs ?? [])
+        .map((config) => config.artifactKind)
+        .filter((kind) => kind !== 'baseline'));
+    return kinds.size === 1 ? [...kinds][0] : undefined;
+}
+function sampleEvidence(report, sampleId) {
+    return [{
+            sourceKind: 'sample',
+            sourceId: sampleId,
+            selector: { selectorKind: 'sample-id', value: sampleId },
+            contentHash: report.meta.sampleHashes?.[sampleId],
+            label: sampleId,
+        }];
+}
+function evalResultEvidence(report, resultIndex, variant) {
+    return [{
+            sourceKind: 'eval-report',
+            sourceId: report.id,
+            selector: {
+                selectorKind: 'json-pointer',
+                value: `/results/${resultIndex}/variants/${jsonPointerToken(variant)}`,
+            },
+            label: `${variant} result`,
+        }];
+}
+function assertionEvidence(report, sampleId, index, resultIndex, variant) {
+    if (report.sampleSnapshots?.[sampleId]?.assertions?.[index]) {
+        return [{
+                sourceKind: 'sample',
+                sourceId: sampleId,
+                selector: {
+                    selectorKind: 'json-pointer',
+                    value: `/sampleSnapshots/${jsonPointerToken(sampleId)}/assertions/${index}`,
+                },
+                contentHash: report.meta.sampleHashes?.[sampleId],
+                label: `assertion ${index + 1}`,
+            }];
+    }
+    if (resultIndex !== undefined && variant !== undefined) {
+        return [{
+                sourceKind: 'eval-report',
+                sourceId: report.id,
+                selector: {
+                    selectorKind: 'json-pointer',
+                    value: `/results/${resultIndex}/variants/${jsonPointerToken(variant)}/assertions/details/${index}`,
+                },
+                label: `${variant} assertion ${index + 1}`,
+            }];
+    }
+    return [{
+            sourceKind: 'sample',
+            sourceId: sampleId,
+            contentHash: report.meta.sampleHashes?.[sampleId],
+            label: `assertion ${index + 1}`,
+        }];
+}
+function sampleStableKey(report, sampleId) {
+    const hash = report.meta.sampleHashes?.[sampleId];
+    return hash ? `v1:sample:${hash}` : `v1:sample:${report.id}:${sampleId}`;
+}
+function assertionStableKey(report, sampleId, index) {
+    return `${sampleStableKey(report, sampleId)}:assertion:${index}`;
+}
+function sampleAttrs(snapshot) {
+    if (!snapshot)
+        return undefined;
+    const display = {};
+    if (snapshot.capability?.length)
+        display.capability = snapshot.capability;
+    if (snapshot.construct)
+        display.construct = snapshot.construct;
+    if (snapshot.difficulty)
+        display.difficulty = snapshot.difficulty;
+    if (snapshot.provenance)
+        display.provenance = snapshot.provenance;
+    if (snapshot.tripwire)
+        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')
+        : join(reportOutputDir, 'graphs', 'eval');
+}
+export function buildEvalArtifactGraph(options) {
+    const { report, sourcePath } = options;
+    const generatedAt = options.generatedAt ?? new Date().toISOString();
+    const nodes = [];
+    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)
+            return existing;
+        const id = `node:${shortHash(stableKey)}`;
+        nodeIdsByStableKey.set(stableKey, id);
+        nodes.push({
+            id,
+            stableKey,
+            nodeKind,
+            nodeRole,
+            layer: 'measurement',
+            label,
+            ...extra,
+        });
+        return id;
+    };
+    const addEdge = (fromNodeId, toNodeId, edgeKind, extra = {}) => {
+        const id = `edge:${shortHash(`${fromNodeId}|${edgeKind}|${toNodeId}|${edges.length}`)}`;
+        edges.push({
+            id,
+            fromNodeId,
+            toNodeId,
+            edgeKind,
+            layer: 'measurement',
+            ...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];
+        const config = configs.get(variant);
+        const variantNodeId = addNode(`v1:variant:${report.id}:${variant}`, 'variant', 'entity', variant, {
+            status: statusFromScore(report.summary?.[variant]?.avgCompositeScore),
+            binding: artifactBinding(variant, artifactHash),
+            metrics: {
+                ...(report.summary?.[variant]?.avgCompositeScore !== undefined
+                    ? { avgCompositeScore: report.summary[variant].avgCompositeScore }
+                    : {}),
+                ...(report.summary?.[variant]?.totalSamples !== undefined
+                    ? { totalSamples: report.summary[variant].totalSamples }
+                    : {}),
+            },
+            attrs: {
+                display: {
+                    ...(config ? {
+                        artifactKind: config.artifactKind,
+                        artifactSource: config.artifactSource,
+                        experimentRole: config.experimentRole,
+                        executionStrategy: config.executionStrategy,
+                    } : {}),
+                },
+            },
+            evidenceRefs: [{
+                    sourceKind: 'eval-report',
+                    sourceId: report.id,
+                    selector: { selectorKind: 'json-pointer', value: `/summary/${jsonPointerToken(variant)}` },
+                    label: `${variant} summary`,
+                }],
+        });
+        variantNodeIds.set(variant, variantNodeId);
+        if (config?.artifactKind === 'skill' && artifactHash && artifactHash !== 'no-skill') {
+            const skillNodeId = addNode(`v1:skill:${artifactHash}`, 'skill', 'entity', variant, {
+                binding: { bindingStrength: 'content-hash', keys: { artifactHash } },
+                attrs: {
+                    display: {
+                        variant,
+                        sourceLocator: config.locator,
+                    },
+                },
+                evidenceRefs: [{
+                        sourceKind: 'eval-report',
+                        sourceId: report.id,
+                        selector: { selectorKind: 'json-pointer', value: `/meta/artifactHashes/${jsonPointerToken(variant)}` },
+                        contentHash: artifactHash,
+                        label: `${variant} artifact hash`,
+                    }],
+            });
+            addEdge(variantNodeId, skillNodeId, 'derived_from');
+        }
+    }
+    for (const [sampleId, snapshot] of Object.entries(report.sampleSnapshots ?? {})) {
+        const sampleNodeId = addNode(sampleStableKey(report, sampleId), 'sample', 'entity', sampleId, {
+            binding: sampleBinding(sampleId, report.meta.sampleHashes?.[sampleId]),
+            attrs: sampleAttrs(snapshot),
+            evidenceRefs: sampleEvidence(report, sampleId),
+        });
+        snapshot.assertions?.forEach((assertion, index) => {
+            const assertionNodeId = addNode(assertionStableKey(report, sampleId, index), 'assertion', 'entity', `assertion: ${assertion.type}`, {
+                attrs: { display: { type: assertion.type, weight: assertion.weight ?? 1 } },
+                evidenceRefs: assertionEvidence(report, sampleId, index),
+            });
+            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, {
+            binding: sampleBinding(result.sample_id, report.meta.sampleHashes?.[result.sample_id]),
+            attrs: sampleAttrs(report.sampleSnapshots?.[result.sample_id]),
+            evidenceRefs: sampleEvidence(report, result.sample_id),
+        });
+        for (const [variant, variantResult] of Object.entries(result.variants)) {
+            const variantNodeId = variantNodeIds.get(variant);
+            if (!variantNodeId)
+                continue;
+            addEdge(variantNodeId, sampleNodeId, 'evaluates', {
+                status: assertionStatus(variantResult),
+                evidenceRefs: evalResultEvidence(report, resultIndex, variant),
+            });
+            const evalResultNodeId = addNode(`v1:eval-result:${report.id}:${variant}:${result.sample_id}`, 'eval_result', 'observation', `${variant} / ${result.sample_id}`, {
+                status: assertionStatus(variantResult),
+                metrics: {
+                    durationMs: variantResult.durationMs,
+                    costUSD: variantResult.costUSD,
+                    ...(variantResult.compositeScore !== undefined ? { compositeScore: variantResult.compositeScore } : {}),
+                    ...(variantResult.llmScore !== undefined ? { llmScore: variantResult.llmScore } : {}),
+                    ...(variantResult.assertions ? { assertionScore: variantResult.assertions.score } : {}),
+                },
+                attrs: {
+                    display: {
+                        ok: variantResult.ok,
+                        ...(variantResult.error ? { error: variantResult.error } : {}),
+                    },
+                },
+                evidenceRefs: evalResultEvidence(report, resultIndex, variant),
+            });
+            addEdge(evalResultNodeId, variantNodeId, 'derived_from');
+            addEdge(evalResultNodeId, sampleNodeId, 'evaluates');
+            variantResult.assertions?.details.forEach((detail, index) => {
+                const assertionNodeId = addNode(assertionStableKey(report, result.sample_id, index), 'assertion', 'entity', `assertion: ${detail.type}`, {
+                    attrs: { display: { type: detail.type, weight: detail.weight } },
+                    evidenceRefs: assertionEvidence(report, result.sample_id, index, resultIndex, variant),
+                });
+                addEdge(evalResultNodeId, assertionNodeId, detail.passed ? 'passes' : 'fails', {
+                    status: detail.passed ? 'ok' : 'failed',
+                    evidenceRefs: evalResultEvidence(report, resultIndex, variant),
+                });
+            });
+            for (const [dimension, dimensionResult] of Object.entries(variantResult.dimensions ?? {})) {
+                const dimensionNodeId = addNode(`v1:judge-dimension:${report.id}:${variant}:${result.sample_id}:${dimension}`, 'judge_dimension', 'observation', dimension, {
+                    status: statusFromScore(dimensionResult.score),
+                    metrics: { score: dimensionResult.score },
+                    attrs: { display: { reason: dimensionResult.reason } },
+                    evidenceRefs: evalResultEvidence(report, resultIndex, variant),
+                });
+                addEdge(dimensionNodeId, evalResultNodeId, 'derived_from');
+            }
+            if (variantResult.diagnostic) {
+                const diagnosticNodeId = addNode(`v1:diagnostic:${report.id}:${variant}:${result.sample_id}`, 'diagnostic', 'observation', `diagnostic: ${variant} / ${result.sample_id}`, {
+                    status: variantResult.diagnostic.ok ? 'warning' : 'failed',
+                    attrs: {
+                        display: {
+                            rootCause: variantResult.diagnostic.rootCause,
+                            failureModes: variantResult.diagnostic.failureModes ?? [],
+                        },
+                    },
+                    evidenceRefs: evalResultEvidence(report, resultIndex, variant),
+                });
+                addEdge(diagnosticNodeId, evalResultNodeId, 'diagnoses', {
+                    status: variantResult.diagnostic.ok ? 'warning' : 'failed',
+                });
+            }
+        }
+    }
+    return {
+        documentKind: 'artifact-graph',
+        schemaVersion: 1,
+        graphId: `eval:${report.id}`,
+        generatedAt,
+        source: {
+            sourceKind: 'eval',
+            sourceId: report.id,
+            sourcePath,
+            cliVersion: report.meta.cliVersion,
+        },
+        scope: {
+            cwd: process.cwd(),
+            artifactKind: scopeArtifactKind(report),
+            sourceLocator: report.meta.request?.samplesPath,
+            sampleSetHash: sampleSetHash(report.meta.sampleHashes),
+        },
+        nodes,
+        edges,
+        summaries: [{
+                summaryKind: 'coverage',
+                title: 'Eval measurement graph',
+                severity: report.results.some((result) => Object.values(result.variants).some((variant) => assertionStatus(variant) === 'failed'))
+                    ? 'medium'
+                    : 'info',
+            }],
+    };
+}
+export function persistEvalGraphSidecar(options) {
+    const graphDir = evalGraphDirForReportOutput(options.outputDir);
+    if (!existsSync(graphDir))
+        mkdirSync(graphDir, { recursive: true });
+    const fileStem = options.fileStem ?? options.report.id;
+    const graphPath = join(graphDir, graphFileName(fileStem));
+    const graph = buildEvalArtifactGraph(options);
+    writeFileSync(graphPath, JSON.stringify(graph, null, 2));
+    return { graphPath };
+}

package/dist/doctor/index.js

@@ -7,11 +7,14 @@
  * fatal-fail 不中断后续 rule 执行(让用户一次看到全貌),但 report.outcome='failed',
  * CLI 据此 exit 1 / abort eval。
  */
-import { existsSync, statSync } from 'node:fs';
+import { existsSync, readFileSync, statSync } from 'node:fs';
 import { basename, dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { runFileSuffix } from '../eval-core/artifact-file-names.js';
 import { discoverVariants, resolveArtifacts } from '../inputs/skill-loader.js';
 import { DOCTOR_REPORT_SCHEMA_VERSION, isComposerRule } from '../types/doctor.js';
 import { getRegisteredRules } from './rules.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
 // ---------------------------------------------------------------------------
 // Target resolution
 // ---------------------------------------------------------------------------
@@ -163,18 +166,30 @@ function inferSkillPath(artifact, baseDir) {
 // ---------------------------------------------------------------------------
 // Public entry
 // ---------------------------------------------------------------------------
-let reportIdCounter = 0;
 function nextReportId() {
-    reportIdCounter += 1;
-    const ts = new Date().toISOString().replace(/[-:.]/g, '').slice(0, 15);
-    // 进程内计数器只防同进程同秒撞;跨进程同秒(两个 omk doctor 并发 / 不同项目)仍会撞同 id,
-    // 经机器级卡片 dedup 当唯一键用时会静默并掉一份。加 4 位随机根治跨进程撞名(id 是标签非测量数)。
-    const rand = Math.random().toString(36).slice(2, 6);
-    return `doctor-${ts}-${reportIdCounter}-${rand}`;
+    return `doctor-${runFileSuffix()}`;
+}
+function findPackageJson(startDir) {
+    let dir = startDir;
+    for (let i = 0; i < 5; i += 1) {
+        const candidate = join(dir, 'package.json');
+        if (existsSync(candidate))
+            return candidate;
+        dir = dirname(dir);
+    }
+    return join(startDir, '..', 'package.json');
 }
 function readCliVersion() {
-    // 不依赖 package.json import(避免 type 解析复杂度);用环境变量或退回 'unknown'
-    return process.env.npm_package_version ?? '0.0.0';
+    const envVersion = process.env.npm_package_version;
+    if (envVersion)
+        return envVersion;
+    try {
+        const pkg = JSON.parse(readFileSync(findPackageJson(__dirname), 'utf-8'));
+        if (typeof pkg.version === 'string' && pkg.version.length > 0)
+            return pkg.version;
+    }
+    catch { /* fall through */ }
+    return '0.0.0';
 }
 export async function runDoctor(opts) {
     // 默认规则 = 内置 + registerRule() 注册的 custom。test 注入走 opts.rules。

package/dist/eval-core/artifact-file-names.d.ts

@@ -10,6 +10,6 @@ export declare function graphFileName(stem: string): string;
 export declare function cardFileName(stem: string): string;
 export declare function runTimestamp(date?: Date): string;
 export declare function randomRunToken(): string;
-export declare function runFileSuffix(counter?: number): string;
+export declare function runFileSuffix(): string;
 export declare function stripDomainPrefix(id: string, domain: string): string;
 export declare function doctorReportFileStem(skillName: string, reportId: string): string;

package/dist/eval-core/artifact-file-names.js

@@ -32,9 +32,8 @@ export function runTimestamp(date = new Date()) {
 export function randomRunToken() {
     return Math.random().toString(36).slice(2, 6);
 }
-export function runFileSuffix(counter) {
-    const middle = counter === undefined ? '' : `-${counter}`;
-    return `${runTimestamp()}${middle}-${randomRunToken()}`;
+export function runFileSuffix() {
+    return `${runTimestamp()}-${randomRunToken()}`;
 }
 export function stripDomainPrefix(id, domain) {
     const safeId = safeArtifactFileStem(id);

package/dist/eval-core/evaluation-reporting.d.ts

@@ -33,7 +33,7 @@ export interface PersistableReport {
 }
 export declare function persistReport(report: PersistableReport, outputDir: string | null): string | null;
 /**
- * run id 的时间戳后缀 `YYYYMMDD-HHmmss-rand4`。
+ * run id 的时间戳后缀 `YYYYMMDDTHHmmss-rand4`。
  * 含秒 + 4 位随机:id 是 run 标签(非测量数),但被 studio 机器级 dedup 与 managed 证据 (reportId,
  * contentHash) 去重当唯一键用。分钟级会让跨项目 / 同分钟重跑撞同 id → 索引静默顶掉一份、managed 错并一条。
  * 秒+随机根治撞名,保证每次 run 全局唯一。供 generateRunId 与 evolve 合并 id 共用,避免靠 split 反解格式。

package/dist/eval-core/evaluation-reporting.js

@@ -5,7 +5,8 @@ import { createHash } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { DEFAULT_REPORTS_DIR } from './default-dirs.js';
 import { indexReportWrite } from './artifact-index.js';
-import { reportFilePath } from './artifact-file-names.js';
+import { randomRunToken, reportFilePath, runTimestamp } from './artifact-file-names.js';
+import { persistEvalGraphSidecar } from '../artifact-graph/eval.js';
 import { buildVariantSummary } from './schema.js';
 import { buildVariantConfig, resolveExecutionStrategy } from './execution-strategy.js';
 import { getJudgePromptHash } from '../grading/judge.js';
@@ -272,10 +273,25 @@ export function aggregateReport({ runId, variants, model, judgeModel, noJudge, e
                 ...(s.difficulty ? { difficulty: s.difficulty } : {}),
                 ...(s.construct ? { construct: s.construct } : {}),
                 ...(s.provenance ? { provenance: s.provenance } : {}),
+                ...(s.covers && s.covers.length > 0 ? { covers: s.covers } : {}),
                 ...(s.tripwire ? { tripwire: true } : {}),
             }])),
     };
 }
+function isEvaluationReport(report) {
+    return report['kind'] === 'evaluation';
+}
+function persistEvalGraphSidecarSafely(report, outputDir, sourcePath) {
+    if (!isEvaluationReport(report))
+        return;
+    try {
+        persistEvalGraphSidecar({ report, outputDir, sourcePath, fileStem: report.id });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[omk] 写入 eval 图谱失败：${message}\n`);
+    }
+}
 export function persistReport(report, outputDir) {
     if (!outputDir)
         return null;
@@ -283,28 +299,32 @@ export function persistReport(report, outputDir) {
         mkdirSync(outputDir, { recursive: true });
     const filePath = reportFilePath(outputDir, report.id);
     writeFileSync(filePath, JSON.stringify(report, null, 2));
+    persistEvalGraphSidecarSafely(report, outputDir, filePath);
     // 产物发现索引:报告落项目本地后,best-effort 追加全局轻卡片,让 omk studio 跨项目聚合成机器级总览。
     // 永不抛、永不阻断报告落盘(正文是 source of truth)。
     indexReportWrite(report, filePath, outputDir);
     return filePath;
 }
 /**
- * run id 的时间戳后缀 `YYYYMMDD-HHmmss-rand4`。
+ * run id 的时间戳后缀 `YYYYMMDDTHHmmss-rand4`。
  * 含秒 + 4 位随机:id 是 run 标签(非测量数),但被 studio 机器级 dedup 与 managed 证据 (reportId,
  * contentHash) 去重当唯一键用。分钟级会让跨项目 / 同分钟重跑撞同 id → 索引静默顶掉一份、managed 错并一条。
  * 秒+随机根治撞名,保证每次 run 全局唯一。供 generateRunId 与 evolve 合并 id 共用,避免靠 split 反解格式。
  */
 export function runIdSuffix() {
-    const d = new Date();
-    const pad = (n) => String(n).padStart(2, '0');
-    const date = `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}`;
-    const time = `${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
-    const rand = Math.random().toString(36).slice(2, 6);
-    return `${date}-${time}-${rand}`;
+    return `${runTimestamp()}-${randomRunToken()}`;
+}
+function safeRunSubject(subject) {
+    const sanitized = subject
+        .replaceAll(/[\\/:]/g, '-')
+        .replaceAll(/[^a-zA-Z0-9._@-]/g, '_')
+        .replace(/^-+|-+$/g, '');
+    return sanitized || 'run';
+}
+function primaryRunSubject(variants) {
+    const nonBaseline = variants.filter((variant) => variant !== 'baseline');
+    return nonBaseline.at(-1) ?? variants.at(-1) ?? 'run';
 }
 export function generateRunId(variants) {
-    const variantPart = variants
-        .map((variant) => variant.replaceAll(/[\\/:]/g, '-').replaceAll(/[^a-zA-Z0-9._@-]/g, '_'))
-        .join('-vs-');
-    return `${variantPart}-${runIdSuffix()}`;
+    return `${safeRunSubject(primaryRunSubject(variants))}-${runIdSuffix()}`;
 }