oh-my-knowledge 0.48.0 → 0.49.0

package/dist/executors/shared.d.ts

@@ -20,7 +20,7 @@ export interface ClaudeCliResponse {
     usage?: TokenUsage;
     total_cost_usd?: number;
     result?: string;
-    stop_reason?: string;
+    stop_reason?: string | null;
     num_turns?: number;
 }
 export interface OpenAiUsage {
@@ -34,7 +34,8 @@ export interface OpenAiResponse {
     usage?: OpenAiUsage;
     choices?: Array<{
         message?: {
-            content?: string;
+            content?: string | null;
+            refusal?: string | null;
         };
         finish_reason?: string;
     }>;
@@ -52,6 +53,7 @@ export interface GeminiResponse {
 export interface AnthropicResponse {
     usage?: TokenUsage;
     content?: Array<{
+        type?: string;
         text?: string;
     }>;
     stop_reason?: string;
@@ -99,6 +101,13 @@ export interface ClaudeSdkResultMessage extends ClaudeSdkBaseMessage {
     duration_api_ms?: number;
     duration_ms?: number;
     num_turns?: number;
+    stop_reason?: string | null;
+    modelUsage?: Record<string, {
+        inputTokens?: number;
+        outputTokens?: number;
+        cacheReadInputTokens?: number;
+        cacheCreationInputTokens?: number;
+    }>;
     subtype?: string;
     errors?: string[];
 }
@@ -130,18 +139,30 @@ export interface CodexEvent {
         results?: unknown[];
         changes?: Array<{
             path?: string;
+            changeKind?: string;
         }>;
         server?: string;
         tool?: string;
+        name?: string;
         arguments?: unknown;
         result?: unknown;
         message?: string;
+        error?: {
+            message?: string;
+        };
     };
     error?: {
         message?: string;
     };
+    message?: string;
     ts?: number;
 }
+/**
+ * Translate Codex's external event shape into omk's internal protocol model.
+ * Codex currently calls file-change discriminators `kind`; omk reserves bare
+ * `kind` for ArtifactKind, so the raw field is qualified at the boundary.
+ */
+export declare function normalizeCodexProtocolEvent(value: unknown): CodexEvent | null;
 export interface ExecutorErrorLike {
     message?: string;
     name?: string;
@@ -151,9 +172,20 @@ export interface ExecutorErrorLike {
 export declare function asErrorLike(err: unknown): ExecutorErrorLike;
 export declare function errorMessage(err: unknown, fallback?: string): string;
 export declare function parseJson<T>(content: string): T;
+export interface JsonResponseBody<T> {
+    data: T | null;
+    rawBody: string;
+}
+export declare function readJsonResponse<T>(response: Response): Promise<JsonResponseBody<T>>;
+export declare function responseBodyPreview(rawBody: string, maxLength?: number): string;
 export declare function buildExecEnv(skillDir?: string | null): NodeJS.ProcessEnv;
 export declare function timeoutExecResult(timeoutMs: number, durationMs: number): ExecResult;
 export declare function interruptedExecResult(durationMs: number): ExecResult;
+/**
+ * Register an in-process runtime (for example an SDK-owned child) with the
+ * same SIGINT coordinator used by spawned executors.
+ */
+export declare function registerSigintSubscriber(subscriber: () => void): () => void;
 export declare function __resetSigintRegistryForTest(): void;
 export interface SpawnHelperResult {
     stdout: string;
@@ -176,7 +208,7 @@ export interface SpawnHelperOptions {
     env?: NodeJS.ProcessEnv;
     /** kill child after this many ms; reject with killedByTimeout=true */
     timeoutMs?: number;
-    /** stdout overflow threshold; reject when累计超限 */
+    /** per-stream stdout/stderr byte limit; reject when either stream exceeds it */
     maxBuffer?: number;
     /** external abort signal; abort() 走跟 SIGINT 同一 grace 路径 */
     abortSignal?: AbortSignal;

package/dist/executors/shared.js

@@ -24,6 +24,37 @@ const EXECUTOR_VENDOR = {
 export function executorVendor(executor) {
     return EXECUTOR_VENDOR[executor] ?? 'unknown';
 }
+/**
+ * Translate Codex's external event shape into omk's internal protocol model.
+ * Codex currently calls file-change discriminators `kind`; omk reserves bare
+ * `kind` for ArtifactKind, so the raw field is qualified at the boundary.
+ */
+export function normalizeCodexProtocolEvent(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return null;
+    const event = value;
+    const rawItem = event.item;
+    if (typeof rawItem !== 'object' || rawItem === null || Array.isArray(rawItem)) {
+        return event;
+    }
+    const item = rawItem;
+    const rawChanges = item.changes;
+    const normalizedItem = {
+        ...item,
+        ...(Array.isArray(rawChanges) && {
+            changes: rawChanges.flatMap((change) => {
+                if (typeof change !== 'object' || change === null || Array.isArray(change))
+                    return [];
+                const rawChange = change;
+                return [{
+                        ...(typeof rawChange.path === 'string' && { path: rawChange.path }),
+                        ...(typeof rawChange.kind === 'string' && { changeKind: rawChange.kind }),
+                    }];
+            }),
+        }),
+    };
+    return { ...event, item: normalizedItem };
+}
 export function asErrorLike(err) {
     return typeof err === 'object' && err !== null ? err : {};
 }
@@ -34,6 +65,25 @@ export function errorMessage(err, fallback = 'unknown error') {
 export function parseJson(content) {
     return JSON.parse(content);
 }
+export async function readJsonResponse(response) {
+    const rawBody = await response.text();
+    if (!rawBody.trim())
+        return { data: null, rawBody };
+    try {
+        return { data: JSON.parse(rawBody), rawBody };
+    }
+    catch {
+        return { data: null, rawBody };
+    }
+}
+export function responseBodyPreview(rawBody, maxLength = 500) {
+    const normalized = rawBody.replace(/\s+/g, ' ').trim();
+    if (!normalized)
+        return '';
+    return normalized.length > maxLength
+        ? `${normalized.slice(0, maxLength)}...`
+        : normalized;
+}
 export function buildExecEnv(skillDir) {
     const proxyUrl = process.env.CCV_PROXY_URL || undefined;
     const env = proxyUrl
@@ -57,7 +107,9 @@ export function timeoutExecResult(timeoutMs, durationMs) {
         outputTokens: 0,
         cacheReadTokens: 0,
         cacheCreationTokens: 0,
+        tokenUsageReportedByExecutor: false,
         costUSD: 0,
+        costReportedByExecutor: false,
         output: null,
         stopReason: 'timeout',
         numTurns: 0,
@@ -76,7 +128,9 @@ export function interruptedExecResult(durationMs) {
         outputTokens: 0,
         cacheReadTokens: 0,
         cacheCreationTokens: 0,
+        tokenUsageReportedByExecutor: false,
         costUSD: 0,
+        costReportedByExecutor: false,
         output: null,
         stopReason: 'interrupted',
         numTurns: 0,
@@ -97,6 +151,7 @@ export function interruptedExecResult(durationMs) {
 //   立即退出(软关 → 硬关两段式)
 // - 同时支持 timeout 跟 abortSignal 两条 kill 路径,跟 SIGINT 共用 grace 逻辑
 const activeChildren = new Set();
+const sigintSubscribers = new Set();
 let sigintListenerInstalled = false;
 let shuttingDown = false;
 const SIGTERM_GRACE_MS = 500;
@@ -104,6 +159,12 @@ function broadcastShutdown() {
     if (shuttingDown)
         return;
     shuttingDown = true;
+    for (const subscriber of sigintSubscribers) {
+        try {
+            subscriber();
+        }
+        catch { /* cancellation handlers must not block shutdown */ }
+    }
     for (const child of activeChildren) {
         try {
             child.kill('SIGTERM');
@@ -119,7 +180,14 @@ function broadcastShutdown() {
     }
     // 卸载自己,re-raise SIGINT 让 host listener / default action(exit code 130)接管
     process.removeListener('SIGINT', sigintHandler);
+    sigintListenerInstalled = false;
     process.kill(process.pid, 'SIGINT');
+    // A host may intentionally intercept the re-raised signal. In that case the
+    // process remains usable and a later child/SDK registration must reinstall
+    // a functional coordinator instead of inheriting a permanently latched flag.
+    setImmediate(() => {
+        shuttingDown = false;
+    }).unref();
 }
 function sigintHandler() {
     broadcastShutdown();
@@ -130,9 +198,21 @@ function ensureSigintListener() {
     sigintListenerInstalled = true;
     process.on('SIGINT', sigintHandler);
 }
+/**
+ * Register an in-process runtime (for example an SDK-owned child) with the
+ * same SIGINT coordinator used by spawned executors.
+ */
+export function registerSigintSubscriber(subscriber) {
+    ensureSigintListener();
+    sigintSubscribers.add(subscriber);
+    return () => {
+        sigintSubscribers.delete(subscriber);
+    };
+}
 // test-only:重置模块级状态,让 vitest 之间互不污染
 export function __resetSigintRegistryForTest() {
     activeChildren.clear();
+    sigintSubscribers.clear();
     if (sigintListenerInstalled) {
         process.removeListener('SIGINT', sigintHandler);
         sigintListenerInstalled = false;
@@ -157,7 +237,9 @@ export function spawnWithSigintPropagation(command, args, options = {}) {
     activeChildren.add(child);
     let stdout = '';
     let stderr = '';
-    let bufferOverflow = false;
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    let bufferOverflowStream = null;
     let killedByTimeout = false;
     let killedBySignalReason = null;
     let graceTimer = null;
@@ -192,16 +274,31 @@ export function spawnWithSigintPropagation(command, args, options = {}) {
     if (abortSignal) {
         abortListener = () => killWithGrace('abort');
         abortSignal.addEventListener('abort', abortListener, { once: true });
+        if (abortSignal.aborted) {
+            // Defer until `done` has installed the child close/error listeners below.
+            queueMicrotask(abortListener);
+        }
     }
     child.stdout?.on('data', (chunk) => {
-        stdout += chunk.toString();
-        if (stdout.length > maxBuffer && !bufferOverflow) {
-            bufferOverflow = true;
-            // 走 killWithGrace 保证 SIGTERM trap child 也会被 500ms 后 SIGKILL 兜底
+        if (bufferOverflowStream)
+            return;
+        stdoutBytes += chunk.byteLength;
+        if (stdoutBytes > maxBuffer) {
+            bufferOverflowStream = 'stdout';
             killWithGrace('buffer');
+            return;
         }
+        stdout += chunk.toString();
     });
     child.stderr?.on('data', (chunk) => {
+        if (bufferOverflowStream)
+            return;
+        stderrBytes += chunk.byteLength;
+        if (stderrBytes > maxBuffer) {
+            bufferOverflowStream = 'stderr';
+            killWithGrace('buffer');
+            return;
+        }
         stderr += chunk.toString();
     });
     function cleanup() {
@@ -230,25 +327,26 @@ export function spawnWithSigintPropagation(command, args, options = {}) {
                 killedByTimeout,
                 killedBySignal: killedSig,
             };
-            // bufferOverflow 优先 — 数据已截断不可信,即使 child 后来 exit 0 也不能用
-            if (bufferOverflow) {
-                const e = Object.assign(new Error(`stdout maxBuffer (${maxBuffer}) exceeded`), result);
+            // Buffer overflow is authoritative: truncated output is not valid evidence,
+            // even if the child catches SIGTERM and later exits 0.
+            if (bufferOverflowStream) {
+                const e = Object.assign(new Error(`${bufferOverflowStream} maxBuffer (${maxBuffer} bytes) exceeded`), result);
                 reject(e);
                 return;
             }
-            // **code === 0 时 child 是干净完成的**:即使我们前面发了 SIGTERM(timeout / abort),
-            // child 可能 trap 信号并 graceful exit 0 完成数据写入。这种情况 stdout 是完整的,
-            // 不应该当 timeout / signal 错误 reject。优先级:exit 0 > 任何 kill reason。
-            if (code === 0) {
-                resolve(result);
-                return;
-            }
+            // Deadline / cancellation are caller-side facts. A child may catch
+            // SIGTERM, flush partial output and exit 0, but that cannot retroactively
+            // turn an over-budget or cancelled evaluation into a successful sample.
             if (killedByTimeout) {
                 const tSec = timeoutMs ? (timeoutMs / 1000).toFixed(0) : '?';
                 const e = Object.assign(new Error(`execution timed out after ${tSec}s`), result);
                 reject(e);
                 return;
             }
+            if (code === 0) {
+                resolve(result);
+                return;
+            }
             if (killedSig) {
                 const e = Object.assign(new Error(`execution interrupted by signal ${killedSig}`), result);
                 reject(e);

package/dist/grading/assertions.d.ts

@@ -1,5 +1,5 @@
 import type { Assertion, AssertionResults, ExecutorFn, Sample, ToolCallInfo } from '../types/index.js';
-export declare const ASYNC_ASSERTION_TYPES: Set<string>;
+export { ASYNC_ASSERTION_TYPES } from '../shared/assertion-types.js';
 export interface AsyncAssertionContext {
     executor: ExecutorFn;
     judgeModel: string;

package/dist/grading/assertions.js

@@ -2,18 +2,12 @@ import { resolve } from 'node:path';
 import _Ajv from 'ajv';
 import { ASSERTION_LAYER } from './layered-scores.js';
 import { buildSemanticSimilarityPrompt, SEMANTIC_SIMILARITY_SYSTEM, buildRagJudgePrompt } from '../shared/llm-prompts/judge-prompts.js';
+import { assertionContractValidationError, } from '../shared/sample-contract.js';
+import { ASYNC_ASSERTION_TYPES, SYNC_ASSERTION_TYPES, } from '../shared/assertion-types.js';
+export { ASYNC_ASSERTION_TYPES } from '../shared/assertion-types.js';
 const Ajv = _Ajv.default ?? _Ajv;
 const ajv = new Ajv();
 const CUSTOM_ASSERTION_TIMEOUT_MS = 30_000;
-export const ASYNC_ASSERTION_TYPES = new Set([
-    'semantic_similarity',
-    'custom',
-    // RAG-specific judge metrics. All three go through the LLM-judge path
-    // and inherit the same length-debias instruction as the main rubric judge.
-    'faithfulness',
-    'answer_relevancy',
-    'context_recall',
-]);
 function getErrorMessage(err) {
     return err instanceof Error ? err.message : String(err);
 }
@@ -293,6 +287,14 @@ function resolveAssertSetLayer(assertion) {
     return only === 'unknown' ? undefined : only;
 }
 export function runAssertions(output, assertions, context = {}) {
+    assertions.forEach((assertion, index) => {
+        const error = assertionContractValidationError(assertion);
+        if (error)
+            throw new TypeError(`assertions[${index}]: ${error}`);
+        if (!SYNC_ASSERTION_TYPES.has(assertion.type)) {
+            throw new TypeError(`assertions[${index}]: async assertion ${JSON.stringify(assertion.type)} requires runAsyncAssertions()`);
+        }
+    });
     const outputLower = output.toLowerCase();
     const toolCalls = context.toolCalls || [];
     const toolNames = toolCalls.map((tc) => tc.tool.toLowerCase());
@@ -324,6 +326,14 @@ export function runAssertions(output, assertions, context = {}) {
     };
 }
 export async function runAsyncAssertions(output, assertions, { executor, judgeModel, sample, samplesDir }) {
+    assertions.forEach((assertion, index) => {
+        const error = assertionContractValidationError(assertion);
+        if (error)
+            throw new TypeError(`assertions[${index}]: ${error}`);
+        if (!ASYNC_ASSERTION_TYPES.has(assertion.type)) {
+            throw new TypeError(`assertions[${index}]: sync assertion ${JSON.stringify(assertion.type)} requires runAssertions()`);
+        }
+    });
     const details = [];
     let asyncCostUSD = 0;
     let anyCostUnreported = false;

package/dist/grading/diagnostic.d.ts

@@ -9,10 +9,17 @@
  *
  * 触发条件:sample 至少有 1 条 failed assertion(全过的 sample 不需要诊断,省成本)。
  *
- * 默认走 haiku(便宜 + 够用),典型成本 ~$0.005/失败样本。
+ * 运行目标跟随首位 judge；没有 judge 配置时跟随被测 executor/model。
+ * provider-specific 的廉价默认值只在 CLI runtime resolution 中决定。
  */
-import type { ExecutorFn, ToolCallInfo, TurnInfo, Sample } from '../types/index.js';
+import type { ExecutorFn, ToolCallInfo, TurnInfo, JudgeConfig, Sample } from '../types/index.js';
 import type { AssertionDetail, DiagnosticResult, WorkflowCheck, FailureMode } from '../types/judge.js';
+export interface DiagnosticTarget {
+    executor: string;
+    model: string;
+}
+export declare function resolveDiagnosticTarget(judgeModels: JudgeConfig[], mainExecutor: string, mainModel: string): DiagnosticTarget;
+export declare function getDiagnosticPromptHash(): string;
 interface RunDiagnosticOptions {
     sample: Sample;
     skillContent: string | null;

package/dist/grading/diagnostic.js

@@ -9,9 +9,12 @@
  *
  * 触发条件:sample 至少有 1 条 failed assertion(全过的 sample 不需要诊断,省成本)。
  *
- * 默认走 haiku(便宜 + 够用),典型成本 ~$0.005/失败样本。
+ * 运行目标跟随首位 judge；没有 judge 配置时跟随被测 executor/model。
+ * provider-specific 的廉价默认值只在 CLI runtime resolution 中决定。
  */
+import { createHash } from 'node:crypto';
 import { FAILURE_MODES } from '../types/judge.js';
+import { toolCallStatus } from '../shared/tool-call-status.js';
 const SYSTEM_PROMPT = `你是 skill 评测诊断助手。基于失败用例的 expected/actual 差异,给 skill 作者具体可操作的改进建议。
 
 **诱错样本(tripwire)规则 — 只看 sample 的显式标记,不要自己识别**:
@@ -65,6 +68,15 @@ ${FAILURE_MODES.map((m, i) => `  ${i + 1}. ${m}`).join('\n')}
 全过的 sample 给空数组 []。
 
 只返回 JSON,不要其他内容。`;
+export function resolveDiagnosticTarget(judgeModels, mainExecutor, mainModel) {
+    const primaryJudge = judgeModels[0];
+    return primaryJudge
+        ? { executor: primaryJudge.executor, model: primaryJudge.model }
+        : { executor: mainExecutor, model: mainModel };
+}
+export function getDiagnosticPromptHash() {
+    return createHash('sha256').update(SYSTEM_PROMPT).digest('hex').slice(0, 12);
+}
 const TOOL_INPUT_PREVIEW_MAX = 350;
 const SKILL_CONTENT_MAX = 12000;
 const FULL_OUTPUT_MAX = 1500;
@@ -83,7 +95,11 @@ function previewToolCall(tc, idx) {
     const truncated = inputRepr.length > TOOL_INPUT_PREVIEW_MAX
         ? inputRepr.slice(0, TOOL_INPUT_PREVIEW_MAX) + '…'
         : inputRepr;
-    const status = tc.success ? '' : ' [失败]';
+    const resultStatus = toolCallStatus(tc);
+    const status = resultStatus === 'failure'
+        ? ' [失败]'
+        : resultStatus === 'cancelled' ? ' [取消]'
+            : resultStatus === 'unknown' ? ' [状态未知]' : '';
     return `[${idx + 1}] ${tc.tool}${status} → ${truncated}`;
 }
 function formatExpectedAssertion(a) {
@@ -327,6 +343,9 @@ export async function runDiagnostic(opts) {
         timeoutMs: opts.timeoutMs ?? 180_000,
         lean: true, // 诊断也是纯文本生成,不需要工具循环
     });
+    const costReporting = result.costReportedByExecutor === false
+        ? { costReportedByExecutor: false }
+        : {};
     if (!result.ok) {
         return {
             ok: false,
@@ -337,6 +356,7 @@ export async function runDiagnostic(opts) {
             rootCause: [],
             suggestion: { skill: '', sample: '', none: '' },
             costUSD: result.costUSD,
+            ...costReporting,
         };
     }
     const raw = (result.output || '').trim();
@@ -375,6 +395,7 @@ export async function runDiagnostic(opts) {
                 failureModes: salvaged.failureModes ?? [],
                 suggestion: salvaged.suggestion ?? { skill: '', sample: '', none: '' },
                 costUSD: result.costUSD,
+                ...costReporting,
             };
         }
         return {
@@ -386,6 +407,7 @@ export async function runDiagnostic(opts) {
             rootCause: [],
             suggestion: { skill: '', sample: '', none: '' },
             costUSD: result.costUSD,
+            ...costReporting,
         };
     }
     const obj = parsed;
@@ -410,6 +432,7 @@ export async function runDiagnostic(opts) {
             none: String(sug.none ?? ''),
         },
         costUSD: result.costUSD,
+        ...costReporting,
     };
 }
 function parseWorkflowChecks(raw) {

package/dist/grading/index.js

@@ -2,12 +2,18 @@
  * Mixed grading: deterministic assertions + LLM judge + multi-dimensional scoring.
  */
 import { ASYNC_ASSERTION_TYPES, ratioToScore, runAssertions, runAsyncAssertions } from './assertions.js';
+import { setOwnRecordValue } from '../shared/record-count.js';
 import { buildTraceSummary, llmJudgeEnsemble, llmJudgeRepeat } from './judge.js';
 import { computeLayeredScores } from './layered-scores.js';
+import { ownRecordValue } from '../shared/record-count.js';
+import { sampleContractValidationError } from '../shared/sample-contract.js';
 /**
  * Grade a model output against a sample's criteria.
  */
 export async function grade({ output, sample, judgeModels, judgeExecutors, allowLlmJudge = true, execMetrics = {}, samplesDir = '.', judgeRepeat = 1, lengthDebias = true }) {
+    const sampleError = sampleContractValidationError(sample);
+    if (sampleError)
+        throw new TypeError(`grade(): invalid sample contract: ${sampleError}`);
     if (!judgeModels || judgeModels.length === 0) {
         throw new Error('grade(): judgeModels must be non-empty');
     }
@@ -20,14 +26,14 @@ export async function grade({ output, sample, judgeModels, judgeExecutors, allow
     // code path that needs the executor. Sync-only samples never invoke these
     // helpers, so they can pass `judgeExecutors: {}` (or omit it entirely).
     const requirePrimaryExecutor = () => {
-        const exec = judgeExecutorMap[primaryJudge.executor];
+        const exec = ownRecordValue(judgeExecutorMap, primaryJudge.executor);
         if (!exec) {
             throw new Error(`grade(): judgeExecutors missing entry for primary judge "${primaryJudge.executor}"`);
         }
         return exec;
     };
     const executorByName = (name) => {
-        const exec = judgeExecutorMap[name];
+        const exec = ownRecordValue(judgeExecutorMap, name);
         if (!exec) {
             throw new Error(`No executor registered for "${name}"; pipeline must populate judgeExecutors for every judge`);
         }
@@ -86,9 +92,9 @@ export async function grade({ output, sample, judgeModels, judgeExecutors, allow
         results.dimensions = {};
         for (const [dim, rubric] of Object.entries(sample.dimensions)) {
             const dimOptions = { output, rubric, prompt: sample.prompt, executor: requirePrimaryExecutor(), model: judgeModel, traceSummary, lengthDebias };
-            results.dimensions[dim] = useEnsemble
+            setOwnRecordValue(results.dimensions, dim, useEnsemble
                 ? await llmJudgeEnsemble(dimOptions, judgeModels, executorByName, judgeRepeat)
-                : await llmJudgeRepeat(dimOptions, judgeRepeat);
+                : await llmJudgeRepeat(dimOptions, judgeRepeat));
         }
         const dimValues = Object.values(results.dimensions);
         const dimScores = dimValues.map((d) => d.score).filter((s) => s > 0);

package/dist/grading/judge.js

@@ -1,4 +1,6 @@
 import { buildJudgePrompt, JUDGE_SYSTEM_PROMPT } from '../shared/llm-prompts/judge-prompts.js';
+import { isToolCallCancelled, isToolCallFailure, isToolCallSuccess, isToolCallUnknown, toolCallStatus, } from '../shared/tool-call-status.js';
+import { incrementRecordCount } from '../shared/record-count.js';
 // 评分类 prompt 已收口到 shared/llm-prompts/judge-prompts.ts(单一来源 + prompt-registry 冻结)。
 // 这里 re-export 保对外 API 不破:既有消费方仍从 grading/judge.js import 这两个符号。
 export { buildJudgePrompt, getJudgePromptHash } from '../shared/llm-prompts/judge-prompts.js';
@@ -80,17 +82,23 @@ export function buildTraceSummary(turns, toolCalls) {
     const lines = [];
     if (toolCalls && toolCalls.length > 0) {
         lines.push(`共调用 ${toolCalls.length} 个工具：`);
-        const successCount = toolCalls.filter((tc) => tc.success).length;
-        const failureCount = toolCalls.length - successCount;
+        const successCount = toolCalls.filter(isToolCallSuccess).length;
+        const failureCount = toolCalls.filter(isToolCallFailure).length;
+        const cancelledCount = toolCalls.filter(isToolCallCancelled).length;
+        const unknownCount = toolCalls.filter(isToolCallUnknown).length;
         lines.push(`  成功 ${successCount}/${toolCalls.length}`);
         if (failureCount > 0)
             lines.push(`  失败 ${failureCount}/${toolCalls.length}`);
+        if (cancelledCount > 0)
+            lines.push(`  取消 ${cancelledCount}/${toolCalls.length}`);
+        if (unknownCount > 0)
+            lines.push(`  状态未知 ${unknownCount}/${toolCalls.length}`);
         const dist = {};
         for (const tc of toolCalls) {
-            dist[tc.tool] = (dist[tc.tool] || 0) + 1;
+            incrementRecordCount(dist, tc.tool);
         }
         lines.push(`  工具分布：${Object.entries(dist).map(([k, v]) => `${k}(${v})`).join(', ')}`);
-        const failedTools = toolCalls.filter((tc) => !tc.success).map((tc) => tc.tool);
+        const failedTools = toolCalls.filter(isToolCallFailure).map((tc) => tc.tool);
         if (failedTools.length > 0) {
             lines.push(`  失败工具：${[...new Set(failedTools)].join(', ')}`);
         }
@@ -100,7 +108,11 @@ export function buildTraceSummary(turns, toolCalls) {
         const detailCap = Math.min(toolCalls.length, TOOL_DETAIL_MAX_CALLS);
         for (let i = 0; i < detailCap; i++) {
             const tc = toolCalls[i];
-            const status = tc.success ? '' : ' [失败]';
+            const resultStatus = toolCallStatus(tc);
+            const status = resultStatus === 'failure'
+                ? ' [失败]'
+                : resultStatus === 'cancelled' ? ' [取消]'
+                    : resultStatus === 'unknown' ? ' [状态未知]' : '';
             lines.push(`    [${i + 1}] ${tc.tool}${status} → ${previewToolInput(tc)}`);
         }
         if (toolCalls.length > TOOL_DETAIL_MAX_CALLS) {
@@ -110,9 +122,10 @@ export function buildTraceSummary(turns, toolCalls) {
     if (turns && turns.length > 0) {
         lines.push('');
         lines.push('执行轨迹摘要：');
+        const userTurns = turns.filter((turn) => turn.role === 'user').length;
         const assistantTurns = turns.filter((turn) => turn.role === 'assistant').length;
         const toolTurns = turns.filter((turn) => turn.role === 'tool').length;
-        lines.push(`  共 ${turns.length} 步（assistant ${assistantTurns} / tool ${toolTurns}）`);
+        lines.push(`  共 ${turns.length} 步（user ${userTurns} / assistant ${assistantTurns} / tool ${toolTurns}）`);
         const maxTurns = Math.min(turns.length, 10);
         for (let i = 0; i < maxTurns; i++) {
             const t = turns[i];

package/dist/grading/layered-scores.d.ts

@@ -9,9 +9,8 @@ import type { AssertionDetail, LayeredScores } from '../types/index.js';
  * 从 fact 与 behavior 同时漏掉 —— 既不报错也不进 composite,静默丢分(曾漏掉七类:mock_hit / rouge_n_min /
  * bleu_min / levenshtein_max + RAG 三件套 faithfulness / answer_relevancy / context_recall)。叶子断言在此静态
  * 分类;组合器 `assert-set` 没有静态层,由 `assertions.ts` 的 resolveAssertSetLayer 在 grading 期按其叶子 children
- * 解析(同层→归层、混层→不计),结果落 detail.layer。`test/grading/layered-scores-exhaustiveness.test.ts` 扫
- * runner 源(evalAssertion 的 case ∪ `assertion.type ===` 组合器 ∪ ASYNC_ASSERTION_TYPES)守住:新增类型既不在本
- * 映射、又不是已知组合器,即 CI 失败。
+ * 解析(同层→归层、混层→不计),结果落 detail.layer。共享注册表 `shared/assertion-types.ts` 是支持类型的真源；
+ * `test/grading/layered-scores-exhaustiveness.test.ts` 守住新增类型必须在本映射或组合器集合中显式处理。
  */
 export declare const ASSERTION_LAYER: Record<string, 'fact' | 'behavior'>;
 interface CompositeInput {

package/dist/grading/layered-scores.js

@@ -8,9 +8,8 @@
  * 从 fact 与 behavior 同时漏掉 —— 既不报错也不进 composite,静默丢分(曾漏掉七类:mock_hit / rouge_n_min /
  * bleu_min / levenshtein_max + RAG 三件套 faithfulness / answer_relevancy / context_recall)。叶子断言在此静态
  * 分类;组合器 `assert-set` 没有静态层,由 `assertions.ts` 的 resolveAssertSetLayer 在 grading 期按其叶子 children
- * 解析(同层→归层、混层→不计),结果落 detail.layer。`test/grading/layered-scores-exhaustiveness.test.ts` 扫
- * runner 源(evalAssertion 的 case ∪ `assertion.type ===` 组合器 ∪ ASYNC_ASSERTION_TYPES)守住:新增类型既不在本
- * 映射、又不是已知组合器,即 CI 失败。
+ * 解析(同层→归层、混层→不计),结果落 detail.layer。共享注册表 `shared/assertion-types.ts` 是支持类型的真源；
+ * `test/grading/layered-scores-exhaustiveness.test.ts` 守住新增类型必须在本映射或组合器集合中显式处理。
  */
 export const ASSERTION_LAYER = {
     contains: 'fact',

package/dist/inputs/load-samples.d.ts

@@ -1,5 +1,4 @@
-import type { Sample } from '../types/index.js';
-import type { DependencyRequirements } from '../eval-core/dependency-checker.js';
+import type { DependencyRequirements, Sample } from '../types/index.js';
 export declare function parseYaml(text: string): unknown;
 export interface LoadSamplesResult {
     samples: Sample[];