oh-my-knowledge 1.0.0-beta.10 → 1.0.0-beta.11

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

@@ -33,7 +33,7 @@ omk CLI 顶层命令包括：`init` / `install` / `list` / `promote` / `rollback
 
 ### 在 Codex / 支持 MCP 的客户端中
 
-Codex 是 omk 的一等 runtime。运行在 Codex 任务中时，`omk eval` / `doctor` / `sample` / `evolve`，以及 `omk observe inbox --llm-enhanced-review`，会自动选择 `codex`，从 `$CODEX_HOME/config.toml` 或 `~/.codex/config.toml` 读取顶层 `model`，默认评委沿用同一个 Codex 模型；不要额外回落到 Claude。
+Codex 是 omk 的一等 runtime。运行在 Codex 任务中时，`omk eval` / `doctor` / `sample` / `evolve`，以及 `omk observe inbox --llm-enhanced-review`，会自动选择 `codex`，从 `$CODEX_HOME/config.toml` 或 `~/.codex/config.toml` 解析模型（顶层 `profile` 指向某个 profile 时取该 profile 的 `model`，否则取顶层 `model`），默认评委沿用同一个 Codex 模型；不要额外回落到 Claude。
 
 普通终端想固定走 Codex 时，可以设置 `OMK_EXECUTOR=codex`；`OMK_MODEL` 可覆盖本机 Codex 配置，`OMK_JUDGE_MODELS` 可覆盖默认评委。逐次覆盖仍可使用 `--executor` / `--model` / `--judge-models`。Codex 不需要 Claude Code 风格的 `/omk` slash command，直接执行 CLI。
 

package/dist/cli/lib/codex-model-hint.js

@@ -1,26 +1,17 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { resolveCodexConfigModel } from '../../executors/openai/codex/config.js';
 const CODEX_MODEL_PLACEHOLDER = '<codex-model>';
-function parseTopLevelCodexModel(configText) {
-    for (const line of configText.split(/\r?\n/)) {
-        if (/^\s*\[/.test(line))
-            return null;
-        const match = line.match(/^\s*model\s*=\s*(?:"([^"]+)"|'([^']+)')\s*(?:#.*)?$/);
-        const model = match?.[1] ?? match?.[2];
-        if (model)
-            return model;
-    }
-    return null;
-}
 export function getCodexModelSuggestion(env = process.env) {
     const codexHome = env.CODEX_HOME || join(homedir(), '.codex');
     const configPath = join(codexHome, 'config.toml');
     if (existsSync(configPath)) {
         try {
-            const model = parseTopLevelCodexModel(readFileSync(configPath, 'utf-8'));
-            if (model)
-                return { model, fromConfig: true, configPath };
+            const resolution = resolveCodexConfigModel(readFileSync(configPath, 'utf-8'));
+            if (resolution.status === 'resolved') {
+                return { model: resolution.model, fromConfig: true, configPath };
+            }
         }
         catch { /* best-effort hint only */ }
     }

package/dist/cli/lib/runtime-defaults.js

@@ -68,8 +68,8 @@ export function resolveCliModel(executor, explicitModel, options = {}) {
         return suggestion.model;
     const lang = options.lang ?? 'zh';
     throw new Errors.CLIError(lang === 'zh'
-        ? `Codex 执行器需要明确模型。请用 --model <model>、设置 OMK_MODEL，或在 ${suggestion.configPath} 配置顶层 model。`
-        : `The Codex executor needs an explicit model. Pass --model <model>, set OMK_MODEL, or configure a top-level model in ${suggestion.configPath}.`, { exit: 2 });
+        ? `Codex 执行器需要明确模型。请用 --model <model>、设置 OMK_MODEL，或在 ${suggestion.configPath} 配置 model 与 profile。`
+        : `The Codex executor needs an explicit model. Pass --model <model>, set OMK_MODEL, or configure model and profile in ${suggestion.configPath}.`, { exit: 2 });
 }
 export function defaultJudgeModel(executor, taskModel) {
     return executorFamily(executor) === 'claude' ? DEFAULT_CLAUDE_JUDGE_MODEL : taskModel;

package/dist/diagnosis/lifecycle.js

@@ -6,8 +6,8 @@
  *    confirmed:目前 mapper 不产出,如果将来 producer / review-state 写出,会被一并算 inactive
  *               —— 跟 confirmed soft standard 的「已被认知、进入处理流程」语义一致。
  *
- *  抽这个 helper 是为了:Insight 投影(影响 skill 健康 / 待优化数)和 /api/observe-inbox/diagnostics
- *  的 active 列表共用同一份口径,避免「Insight 把 confirmed 算 active 但 API 不算」的口径分叉。
+ *  抽这个 helper 是为了让 Insight 投影（影响 skill 健康 / 待优化数）与 Studio 的 active 诊断列表
+ *  共用同一份口径，避免「Insight 把 confirmed 算 active 但页面不算」的口径分叉。
  */
 const ACTIVE_DIAGNOSIS_LIFECYCLES = new Set([
     'detected',

package/dist/eval-core/compiler/validation.js

@@ -632,12 +632,15 @@ export function validateDefinitionSemantics(definition, policy) {
             }
         }
     }
-    const measurementCoordinates = definition.evaluators.map((evaluator) => canonicalizeJson({
+    // Disjoint sample scopes may share an instrument/member/replicate coordinate.
+    // Only coordinates that can produce two readings on the same sample conflict.
+    const measurementCoordinates = definition.evaluators.flatMap((evaluator) => (evaluator.applicableSampleIds ?? definition.dataset.samples.map((sample) => sample.sampleId)).map((sampleId) => canonicalizeJson({
+        sampleId,
         instrumentId: evaluator.measurement.instrumentId,
         ensembleMemberId: evaluator.measurement.ensembleMemberId,
         replicateGroupId: evaluator.measurement.replicateGroupId,
         replicateIndex: evaluator.measurement.replicateIndex,
-    }));
+    })));
     assertUnique(measurementCoordinates, 'evaluator-measurement-coordinate');
     for (const comparison of definition.comparisons) {
         assertReference(targetIds, comparison.controlTargetId, `comparisons.${comparison.comparisonId}.controlTargetId`, 'Target');

package/dist/eval-runtime/builders/custom-evaluator.d.ts

@@ -0,0 +1,49 @@
+import type { JsonValue } from '../../eval-core/contracts/index.js';
+import type { RuntimeValueParser } from '../adapters/json-executor.js';
+import { type CustomEvaluator, type CustomEvaluatorInvocation, type CustomEvaluatorResult, type CustomMetricResult, type Metric } from '../custom-evaluator.js';
+type MetricValue = {
+    numeric: number;
+    boolean: boolean;
+    categorical: string;
+    text: string;
+    ranking: string[];
+};
+type MetricDeclaration<M = Metric> = M extends Metric ? {
+    [ValueType in M['valueType']]: Omit<M, 'metricId' | 'missingPolicyId' | 'valueType'> & Readonly<{
+        valueType: ValueType;
+        missingPolicyId?: 'exclude/v1';
+        schema: RuntimeValueParser<MetricValue[ValueType]>;
+    }>;
+}[M['valueType']] : never;
+/** The map key is the metricId; the parser sits beside its measurement definition. */
+export type CustomEvaluatorMetric = MetricDeclaration;
+type KeyedMetricResult<Value extends JsonValue> = (Omit<Extract<CustomMetricResult, {
+    resultKind: 'score';
+}>, 'metricId' | 'value'> & {
+    readonly value: Value;
+}) | Omit<Extract<CustomMetricResult, {
+    resultKind: 'missing';
+}>, 'metricId'> | Omit<Extract<CustomMetricResult, {
+    resultKind: 'invalid';
+}>, 'metricId'>;
+export type CustomEvaluatorScores<Metrics extends Record<string, CustomEvaluatorMetric>> = Readonly<{
+    resultKind: 'completed';
+    results: {
+        readonly [Id in keyof Metrics]: KeyedMetricResult<ReturnType<Metrics[Id]['schema']['parse']>>;
+    };
+    usage?: Extract<CustomEvaluatorResult, {
+        resultKind: 'completed';
+    }>['usage'];
+}> | Extract<CustomEvaluatorResult, {
+    resultKind: 'failed';
+}>;
+export type CreateCustomEvaluatorInput<Metrics extends Record<string, CustomEvaluatorMetric>, Bindings extends Record<string, JsonValue> = Record<string, JsonValue>, Parameters extends JsonValue | undefined = JsonValue | undefined> = Omit<CustomEvaluator<Bindings, Parameters>, 'evaluatorKind' | 'metrics' | 'implementation'> & Readonly<{
+    metrics: Metrics;
+    implementation: Omit<CustomEvaluator<Bindings, Parameters>['implementation'], 'schemas' | 'evaluate'> & Readonly<{
+        schemas: Omit<CustomEvaluator<Bindings, Parameters>['implementation']['schemas'], 'values'>;
+        evaluate: (invocation: Readonly<CustomEvaluatorInvocation<Bindings, Parameters>>) => CustomEvaluatorScores<NoInfer<Metrics>> | Promise<CustomEvaluatorScores<NoInfer<Metrics>>>;
+    }>;
+}>;
+/** Expands an ergonomic declaration into the canonical v2 Custom Evaluator contract. */
+export declare function createCustomEvaluator<const Metrics extends Record<string, CustomEvaluatorMetric>, Bindings extends Record<string, JsonValue>, Parameters extends JsonValue | undefined = JsonValue | undefined>(input: Readonly<CreateCustomEvaluatorInput<Metrics, Bindings, Parameters>>): CustomEvaluator<Bindings, Parameters>;
+export {};

package/dist/eval-runtime/builders/custom-evaluator.js

@@ -0,0 +1,67 @@
+import { captureCustomEvaluator, CustomEvaluatorDeclarationError, } from '../custom-evaluator.js';
+import { EvaluationConfigurationError } from '../evaluation/errors.js';
+/** Expands an ergonomic declaration into the canonical v2 Custom Evaluator contract. */
+export function createCustomEvaluator(input) {
+    let metricIds = [];
+    try {
+        if (input.metrics == null || typeof input.metrics !== 'object' || Array.isArray(input.metrics)) {
+            throw new CustomEvaluatorDeclarationError([{ path: ['metrics'], reasonCode: 'invalid-value' }]);
+        }
+        const entries = Object.entries(input.metrics);
+        metricIds = entries.map(([id]) => id);
+        if (input.implementation == null) {
+            throw new CustomEvaluatorDeclarationError([{ path: ['implementation'], reasonCode: 'invalid-value' }]);
+        }
+        for (const [id, metric] of entries) {
+            if (metric == null || typeof metric !== 'object' || Array.isArray(metric)) {
+                throw new CustomEvaluatorDeclarationError([{ path: ['metrics', id], reasonCode: 'invalid-value' }]);
+            }
+        }
+        const callback = input.implementation.evaluate;
+        const evaluator = {
+            ...input,
+            evaluatorKind: 'custom',
+            metrics: entries.map(([metricId, { schema: _schema, ...metric }]) => ({
+                missingPolicyId: 'exclude/v1', ...metric, metricId,
+            })),
+            implementation: {
+                ...input.implementation,
+                schemas: {
+                    ...input.implementation.schemas,
+                    values: Object.fromEntries(entries.map(([id, metric]) => [id, metric.schema])),
+                },
+                async evaluate(invocation) {
+                    const result = await callback(invocation);
+                    // Preserve malformed results for the canonical validator, including reported usage.
+                    if (result?.resultKind !== 'completed')
+                        return result;
+                    if (result.results == null || typeof result.results !== 'object' || Array.isArray(result.results)
+                        || Object.values(result.results).some((item) => item != null && typeof item === 'object' && 'metricId' in item)) {
+                        return { ...result, results: null };
+                    }
+                    return {
+                        ...result,
+                        results: Object.entries(result.results).map(([metricId, item]) => ({ ...item, metricId })),
+                    };
+                },
+            },
+        };
+        if (typeof callback !== 'function') {
+            throw new CustomEvaluatorDeclarationError([{ path: ['implementation', 'evaluate'], reasonCode: 'invalid-value' }]);
+        }
+        captureCustomEvaluator(evaluator);
+        return evaluator;
+    }
+    catch (error) {
+        throw new EvaluationConfigurationError('EVAL_RUNTIME_EVALUATOR_INVALID', 'Custom Evaluator 配置无效。请查看 issues 中的字段位置。', undefined, error instanceof CustomEvaluatorDeclarationError ? error.issues.map((issue) => {
+            const [root, index, ...rest] = issue.path;
+            if (root === 'metrics' && typeof index === 'number') {
+                return { ...issue, path: ['metrics', metricIds[index], ...rest] };
+            }
+            if (root === 'implementation' && index === 'schemas' && rest[0] === 'values' && typeof rest[1] === 'string') {
+                return { ...issue, path: ['metrics', rest[1], 'schema'] };
+            }
+            return issue;
+        }) : []);
+    }
+}

package/dist/eval-runtime/builders/rubric-evaluator.d.ts

@@ -0,0 +1,7 @@
+import type { Rubric, RubricJudgeEvaluator } from '../evaluation/contracts.js';
+/** Rubric map keys are metric IDs; all measurement choices retain the standard contract. */
+export type CreateRubricEvaluatorInput = Omit<RubricJudgeEvaluator, 'evaluatorKind' | 'rubrics'> & Readonly<{
+    rubrics: Readonly<Record<string, Rubric>>;
+}>;
+/** Validates without invoking a provider and returns a standard Rubric declaration. */
+export declare function createRubricEvaluator(input: Readonly<CreateRubricEvaluatorInput>): RubricJudgeEvaluator;

package/dist/eval-runtime/builders/rubric-evaluator.js

@@ -0,0 +1,46 @@
+import { IdentifierSchema } from '../../eval-core/contracts/index.js';
+import { captureJudge } from '../evaluation/capture-judge.js';
+import { EvaluationConfigurationError } from '../evaluation/errors.js';
+import { captureRubricDeclaration, rubricAt, rubricIssue } from '../evaluation/rubric-declaration.js';
+/** Validates without invoking a provider and returns a standard Rubric declaration. */
+export function createRubricEvaluator(input) {
+    let metricIds = [];
+    try {
+        return rubricAt(0, [], () => {
+            if (input === null || typeof input !== 'object' || Array.isArray(input))
+                rubricIssue(0, []);
+            if (Object.hasOwn(input, 'evaluatorKind'))
+                rubricIssue(0, [], 'unsupported-field');
+            const source = rubricAt(0, ['rubrics'], () => input.rubrics);
+            if (source === null || typeof source !== 'object' || Array.isArray(source))
+                rubricIssue(0, ['rubrics']);
+            metricIds = Object.keys(source);
+            // Invalid map keys are rejected at the map itself rather than copied into diagnostics.
+            if (metricIds.some((id) => !IdentifierSchema.safeParse(id).success))
+                rubricIssue(0, ['rubrics']);
+            const rubrics = metricIds.map((metricId, index) => rubricAt(0, ['rubrics', index], () => {
+                const rubric = source[metricId];
+                if (rubric === null || typeof rubric !== 'object' || Array.isArray(rubric))
+                    rubricIssue(0, ['rubrics', index]);
+                if (Object.keys(rubric).some((key) => !['criterionId', 'prompt', 'rubric'].includes(key))) {
+                    rubricIssue(0, ['rubrics', index], 'unsupported-field');
+                }
+                return { ...rubric, metricId };
+            }));
+            const evaluator = { ...input, evaluatorKind: 'rubric-judge', rubrics };
+            const { panelJudges } = captureRubricDeclaration(evaluator, 0);
+            panelJudges.forEach((member, index) => rubricAt(0, ['judges', index, 'judge'], () => captureJudge(member.judge)));
+            return evaluator;
+        });
+    }
+    catch (error) {
+        // rubricAt wraps host exceptions before their fields can enter this public error.
+        throw new EvaluationConfigurationError('EVAL_RUNTIME_EVALUATOR_INVALID', 'Rubric 评委配置无效。请查看 issues 中的字段位置。', undefined, error instanceof EvaluationConfigurationError ? error.issues.map((issue) => {
+            const [, , root, index, ...rest] = issue.path;
+            const path = root === 'rubrics' && typeof index === 'number'
+                ? ['rubrics', metricIds[index], ...rest]
+                : issue.path.slice(2);
+            return { ...issue, path };
+        }) : []);
+    }
+}

package/dist/eval-runtime/conformance/cache.js

@@ -76,12 +76,12 @@ function evaluator(onCall) {
         evaluatorKind: 'custom',
         evaluatorId: 'omk-runtime-check-cache-evaluator',
         instrumentId: 'omk.runtime-check.cache-evaluator/v1',
-        metric: {
-            metricId: 'omk-runtime-check-cache-match',
-            valueType: 'boolean',
-            direction: 'higher-is-better',
-            missingPolicyId: 'exclude/v1',
-        },
+        metrics: [{
+                metricId: 'omk-runtime-check-cache-match',
+                valueType: 'boolean',
+                direction: 'higher-is-better',
+                missingPolicyId: 'exclude/v1',
+            }],
         bindings: [
             { bindingId: 'actual', sourceKind: 'output', pointer: '' },
             { bindingId: 'expected', sourceKind: 'expected', pointer: '' },
@@ -91,13 +91,20 @@ function evaluator(onCall) {
             version: '1.0.0',
             schemas: {
                 bindings: z.object({ actual: z.string(), expected: z.string() }).strict(),
-                value: z.boolean(),
+                values: { 'omk-runtime-check-cache-match': z.boolean() },
                 fingerprintFacets: { bindings: 'two-strings/v1', value: 'boolean/v1' },
             },
             fingerprintFacets: { probe: 'omk.runtime-check.cache/v1' },
             async evaluate({ bindings }) {
                 onCall();
-                return { resultKind: 'score', value: bindings.actual === bindings.expected };
+                return {
+                    resultKind: 'completed',
+                    results: [{
+                            metricId: 'omk-runtime-check-cache-match',
+                            resultKind: 'score',
+                            value: bindings.actual === bindings.expected,
+                        }],
+                };
             },
         },
     };

package/dist/eval-runtime/conformance/evaluator.d.ts

@@ -9,13 +9,13 @@ export interface EvaluatorConformanceProbeSources {
 export interface EvaluatorConformanceProbeInput<Bindings extends Record<string, JsonValue> = Record<string, JsonValue>, Parameters extends JsonValue | undefined = JsonValue | undefined> {
     readonly evaluator: CustomEvaluator<Bindings, Parameters>;
     readonly score: EvaluatorConformanceProbeSources & {
-        readonly expectedValue: JsonValue;
+        readonly expectedValues: Readonly<Record<string, JsonValue>>;
     };
     readonly missing: EvaluatorConformanceProbeSources & {
-        readonly expectedReasonCode: string;
+        readonly expectedReasonCodes: Readonly<Record<string, string>>;
     };
     readonly invalid: EvaluatorConformanceProbeSources & {
-        readonly expectedReasonCode: string;
+        readonly expectedReasonCodes: Readonly<Record<string, string>>;
     };
     readonly failure: EvaluatorConformanceProbeSources & {
         readonly expectedErrorCode: string;

package/dist/eval-runtime/conformance/evaluator.js

@@ -115,14 +115,25 @@ export async function runEvaluatorConformance(input) {
         return result([check('configuration', false, 'runtime-evaluator-configuration-invalid')]);
     }
     const callback = input.evaluator?.implementation?.evaluate;
+    const metricIds = Array.isArray(input.evaluator?.metrics)
+        ? input.evaluator.metrics.map((metric) => metric?.metricId).sort()
+        : [];
+    const coversMetrics = (values) => (values !== null && typeof values === 'object' && !Array.isArray(values)
+        && metricIds.length > 0
+        && new Set(metricIds).size === metricIds.length
+        && canonicalizeJson(Object.keys(values).sort()) === canonicalizeJson(metricIds));
     if (typeof callback !== 'function'
+        || metricIds.some((metricId) => !IdentifierSchema.safeParse(metricId).success)
         || !IdentifierSchema.safeParse(input.probeNamespace).success
         || !validSources(input.score)
-        || !JsonValueSchema.safeParse(input.score.expectedValue).success
+        || !z.record(IdentifierSchema, JsonValueSchema).safeParse(input.score.expectedValues).success
+        || !coversMetrics(input.score.expectedValues)
         || !validSources(input.missing)
-        || !IdentifierSchema.safeParse(input.missing.expectedReasonCode).success
+        || !z.record(IdentifierSchema, IdentifierSchema).safeParse(input.missing.expectedReasonCodes).success
+        || !coversMetrics(input.missing.expectedReasonCodes)
         || !validSources(input.invalid)
-        || !IdentifierSchema.safeParse(input.invalid.expectedReasonCode).success
+        || !z.record(IdentifierSchema, IdentifierSchema).safeParse(input.invalid.expectedReasonCodes).success
+        || !coversMetrics(input.invalid.expectedReasonCodes)
         || !validSources(input.failure)
         || !IdentifierSchema.safeParse(input.failure.expectedErrorCode).success
         || !validSources(input.cancellation)) {
@@ -247,18 +258,18 @@ export async function runEvaluatorConformance(input) {
             && Object.keys(scoreInvocation.bindings).sort().join(',')
                 === input.evaluator.bindings.map((binding) => binding.bindingId).sort().join(','), 'runtime-evaluator-binding-mismatch'),
         check('score-contract', scoreRecord?.evaluationStatus === 'completed'
-            && scoreRecord.observations.length === 1
-            && scoreRecord.observations[0]?.observationStatus === 'observed'
-            && canonicalizeJson(scoreRecord.observations[0].value)
-                === canonicalizeJson(input.score.expectedValue), 'runtime-evaluator-score-contract-invalid'),
+            && scoreRecord.observations.length === metricIds.length
+            && scoreRecord.observations.every((observation) => (observation.observationStatus === 'observed'
+                && canonicalizeJson(observation.value)
+                    === canonicalizeJson(input.score.expectedValues[observation.metricId]))), 'runtime-evaluator-score-contract-invalid'),
         check('missing-contract', missingRecord?.evaluationStatus === 'completed'
-            && missingRecord.observations.length === 1
-            && missingRecord.observations[0]?.observationStatus === 'missing'
-            && missingRecord.observations[0].reasonCode === input.missing.expectedReasonCode, 'runtime-evaluator-missing-contract-invalid'),
+            && missingRecord.observations.length === metricIds.length
+            && missingRecord.observations.every((observation) => (observation.observationStatus === 'missing'
+                && observation.reasonCode === input.missing.expectedReasonCodes[observation.metricId])), 'runtime-evaluator-missing-contract-invalid'),
         check('invalid-contract', invalidRecord?.evaluationStatus === 'completed'
-            && invalidRecord.observations.length === 1
-            && invalidRecord.observations[0]?.observationStatus === 'invalid'
-            && invalidRecord.observations[0].reasonCode === input.invalid.expectedReasonCode, 'runtime-evaluator-invalid-contract-invalid'),
+            && invalidRecord.observations.length === metricIds.length
+            && invalidRecord.observations.every((observation) => (observation.observationStatus === 'invalid'
+                && observation.reasonCode === input.invalid.expectedReasonCodes[observation.metricId])), 'runtime-evaluator-invalid-contract-invalid'),
         check('failure-contract', failureRecord?.evaluationStatus === 'failed'
             && failureRecord.error.code === input.failure.expectedErrorCode, 'runtime-evaluator-failure-contract-invalid'),
         check('cancellation-contract', runs[4]?.status === 'cancelled'
@@ -269,10 +280,10 @@ export async function runEvaluatorConformance(input) {
             && concurrentRun.artifacts.evaluation.records.length === 2
             && maximumEvaluatorInvocationsInFlight >= 2
             && concurrentRun.artifacts.evaluation.records.every((record) => (record.evaluationStatus === 'completed'
-                && record.observations.length === 1
-                && record.observations[0]?.observationStatus === 'observed'
-                && canonicalizeJson(record.observations[0].value)
-                    === canonicalizeJson(input.score.expectedValue))), 'runtime-evaluator-concurrency-invalid'),
+                && record.observations.length === metricIds.length
+                && record.observations.every((observation) => (observation.observationStatus === 'observed'
+                    && canonicalizeJson(observation.value)
+                        === canonicalizeJson(input.score.expectedValues[observation.metricId]))))), 'runtime-evaluator-concurrency-invalid'),
         check('telemetry-contract', allUsageValid, 'runtime-evaluator-telemetry-invalid'),
         check('core-roundtrip', runs.length === 5
             && runs.slice(0, 4).every((run) => run.status === 'completed')

package/dist/eval-runtime/conformance/judge.js

@@ -72,12 +72,11 @@ function evaluationInput(namespace, phase, cases, model, judge) {
         evaluators: [{
                 evaluatorKind: 'rubric-judge',
                 evaluatorId: 'runtime-check-judge',
-                metricId: 'runtime-check-judge-score',
-                rubric: {
-                    criterionId: `runtime-check-${phase}`,
-                    prompt: `OMK Runtime Judge behavioral probe: ${phase}.`,
-                    rubric: 'Return a numeric score from 1 through 5 using the required JSON shape.',
-                },
+                rubrics: [{ metricId: 'runtime-check-judge-score',
+                        criterionId: `runtime-check-${phase}`,
+                        prompt: `OMK Runtime Judge behavioral probe: ${phase}.`,
+                        rubric: 'Return a numeric score from 1 through 5 using the required JSON shape.',
+                    }],
                 judges: [{ memberId: 'primary', model, judge }],
                 aggregation: { method: 'mean', missing: 'require-complete' },
             }],

package/dist/eval-runtime/conformance/runtime.d.ts

@@ -31,7 +31,7 @@ export type WorkspaceProviderRuntimeCheckResult = Readonly<RuntimeCheckResultEnv
 export type EvaluatorRuntimeCheckInput<Bindings extends Record<string, JsonValue> = Record<string, JsonValue>, Parameters extends JsonValue | undefined = JsonValue | undefined> = Readonly<{
     readonly runtimeKind: 'evaluator';
 } & EvaluatorConformanceProbeInput<Bindings, Parameters>>;
-export type EvaluatorRuntimeCheckResult = Readonly<RuntimeCheckResultEnvelope<'evaluator', 'omk.runtime-check.custom-evaluator/v1'> & EvaluatorConformanceResult>;
+export type EvaluatorRuntimeCheckResult = Readonly<RuntimeCheckResultEnvelope<'evaluator', 'omk.runtime-check.custom-evaluator/v2'> & EvaluatorConformanceResult>;
 export type JudgeRuntimeCheckInput = Readonly<{
     readonly runtimeKind: 'judge';
 } & JudgeConformanceProbeInput>;

package/dist/eval-runtime/conformance/runtime.js

@@ -103,7 +103,7 @@ export async function checkRuntime(input) {
             cancellation: input.cancellation,
             probeNamespace: input.probeNamespace,
             ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
-        }).then((result) => envelope('evaluator', 'omk.runtime-check.custom-evaluator/v1', requireConfigured(result, ['configuration'], 'Evaluator runtime check declaration 无效。')));
+        }).then((result) => envelope('evaluator', 'omk.runtime-check.custom-evaluator/v2', requireConfigured(result, ['configuration'], 'Evaluator runtime check declaration 无效。')));
     }
     if (input.runtimeKind === 'judge') {
         if (!hasOnlyKeys(input, [

package/dist/eval-runtime/custom-evaluator.d.ts

@@ -1,6 +1,7 @@
 import { type EvaluatorDefinition, type JsonValue, type MetricDefinition, type UsageRecord } from '../eval-core/contracts/index.js';
 import { type EvaluationEvaluator } from '../eval-core/evaluation/index.js';
 import type { RuntimeValueParser } from './adapters/json-executor.js';
+import type { EvaluationConfigurationIssue } from './evaluation/errors.js';
 interface MetricBase {
     readonly metricId: string;
     readonly unit?: string;
@@ -32,21 +33,26 @@ export interface CustomEvaluatorContent {
     readonly classification: 'public' | 'sensitive' | 'secret' | 'gold';
     readonly mediaType?: string;
 }
-export type CustomEvaluatorResult = Readonly<{
+export type CustomMetricResult = Readonly<{
+    metricId: string;
     resultKind: 'score';
     value: JsonValue;
     evidence?: CustomEvaluatorContent;
-    usage?: UsageRecord;
 }> | Readonly<{
+    metricId: string;
     resultKind: 'missing';
     reasonCode: string;
     evidence?: CustomEvaluatorContent;
-    usage?: UsageRecord;
 }> | Readonly<{
+    metricId: string;
     resultKind: 'invalid';
     reasonCode: string;
     invalidValue?: CustomEvaluatorContent;
     evidence?: CustomEvaluatorContent;
+}>;
+export type CustomEvaluatorResult = Readonly<{
+    resultKind: 'completed';
+    results: readonly CustomMetricResult[];
     usage?: UsageRecord;
 }> | Readonly<{
     resultKind: 'failed';
@@ -69,7 +75,7 @@ export interface CustomEvaluator<Bindings extends Record<string, JsonValue> = Re
     readonly evaluatorKind: 'custom';
     readonly evaluatorId: string;
     readonly instrumentId: string;
-    readonly metric: Metric;
+    readonly metrics: readonly Metric[];
     readonly bindings: readonly CustomEvaluatorBinding[];
     readonly parameters?: Parameters;
     readonly implementation: Readonly<{
@@ -77,7 +83,7 @@ export interface CustomEvaluator<Bindings extends Record<string, JsonValue> = Re
         version: string;
         schemas: Readonly<{
             bindings: RuntimeValueParser<Bindings>;
-            value: RuntimeValueParser<JsonValue>;
+            values: Readonly<Record<string, RuntimeValueParser<JsonValue>>>;
             fingerprintFacets: JsonValue;
         }>;
         providerCost?: Readonly<{
@@ -93,13 +99,14 @@ export interface CustomEvaluator<Bindings extends Record<string, JsonValue> = Re
 }
 export interface CapturedCustomEvaluator {
     readonly definition: EvaluatorDefinition;
-    readonly metric: MetricDefinition;
+    readonly metrics: readonly MetricDefinition[];
     readonly port: EvaluationEvaluator;
     readonly implementationId: string;
     readonly version: string;
 }
 export declare class CustomEvaluatorDeclarationError extends TypeError {
-    constructor();
+    readonly issues: readonly EvaluationConfigurationIssue[];
+    constructor(issues?: readonly EvaluationConfigurationIssue[]);
 }
 /** Captures one canonical custom declaration and adapts it to the Core Evaluator port. */
 export declare function captureCustomEvaluator(value: Readonly<CustomEvaluator>): Readonly<CapturedCustomEvaluator>;