oh-my-knowledge 0.47.0 → 0.49.0

package/dist/shared/tool-identity.js

@@ -0,0 +1,84 @@
+const BUILTIN_ALIASES = new Map([
+    ['bash', 'Bash'],
+    ['shell', 'Bash'],
+    ['exec_command', 'Bash'],
+    ['command_execution', 'Bash'],
+    ['read', 'Read'],
+    ['file_read', 'Read'],
+    ['grep', 'Grep'],
+    ['edit', 'Edit'],
+    ['apply_patch', 'Edit'],
+    ['file_change', 'Edit'],
+    ['write', 'Write'],
+    ['file_write', 'Write'],
+    ['view_image', 'ViewImage'],
+    ['viewimage', 'ViewImage'],
+    ['write_stdin', 'WriteStdin'],
+    ['writestdin', 'WriteStdin'],
+    ['web_search', 'WebSearch'],
+    ['websearch', 'WebSearch'],
+]);
+/**
+ * Normalize runtime-specific tool labels into one comparison namespace while
+ * retaining source identity for audit and future protocol migrations.
+ */
+export function normalizeToolIdentity(input) {
+    const sourceName = input.sourceName.trim() || 'unknown';
+    const namespace = nonEmpty(input.namespace) ?? inferredMcpNamespace(sourceName);
+    const authoritativeName = nonEmpty(input.authoritativeName);
+    const isMcp = Boolean(authoritativeName
+        || sourceName.startsWith('mcp__')
+        || namespace?.startsWith('mcp__'));
+    if (isMcp) {
+        const sourceLeaf = sourceName.split('__').filter(Boolean).at(-1) ?? sourceName;
+        const leaf = authoritativeName ?? sourceLeaf;
+        const provider = nonEmpty(input.provider) ?? providerFromNamespace(namespace);
+        const name = provider && !leaf.startsWith(`${provider}.`)
+            ? `${provider}.${leaf}`
+            : leaf;
+        return {
+            name,
+            ...(sourceName !== name ? { sourceName } : {}),
+            ...(namespace ? { namespace } : {}),
+            ...(provider ? { provider } : {}),
+            displayName: name,
+        };
+    }
+    if (namespace) {
+        const name = sourceName.startsWith(`${namespace}.`)
+            ? sourceName
+            : `${namespace}.${sourceName}`;
+        return {
+            name,
+            ...(sourceName !== name ? { sourceName } : {}),
+            namespace,
+            provider: nonEmpty(input.provider) ?? namespace,
+            displayName: name,
+        };
+    }
+    const name = BUILTIN_ALIASES.get(sourceName.toLowerCase()) ?? sourceName;
+    return {
+        name,
+        ...(sourceName !== name ? { sourceName } : {}),
+    };
+}
+function inferredMcpNamespace(sourceName) {
+    const parts = sourceName.split('__').filter(Boolean);
+    return parts[0] === 'mcp' && parts.length > 2
+        ? parts.slice(0, -1).join('__')
+        : undefined;
+}
+function providerFromNamespace(namespace) {
+    if (!namespace)
+        return undefined;
+    const parts = namespace.replace(/^mcp__/, '').split('__').filter(Boolean);
+    // codex_apps is a transport namespace; the following component is the
+    // actual connector/provider and matches Codex MCP end-event metadata.
+    if (parts[0] === 'codex_apps' && parts.length > 1)
+        parts.shift();
+    return parts.length > 0 ? parts.join('.') : undefined;
+}
+function nonEmpty(value) {
+    const normalized = value?.trim();
+    return normalized ? normalized : undefined;
+}

package/dist/shared/tool-search.js

@@ -1,11 +1,19 @@
+import { isToolCallCancelled, isToolCallFailure, isToolCallSuccess } from './tool-call-status.js';
 export function toolCallQuery(tc) {
     const input = (tc.input && typeof tc.input === 'object') ? tc.input : {};
+    const legacyInput = typeof tc.input === 'string' ? tc.input : undefined;
     if (tc.tool === 'Grep')
         return { query: String(input.pattern ?? ''), path: String(input.path ?? '') };
     if (tc.tool === 'Read')
-        return { path: String(input.file_path ?? '') };
+        return { path: String(input.file_path ?? legacyInput ?? '') };
     if (tc.tool === 'Bash')
-        return bashStructuredQuery(String(input.command ?? ''));
+        return bashStructuredQuery(String(input.command ?? legacyInput ?? ''));
+    if (isWebSearchTool(tc.tool)) {
+        return {
+            query: typeof input.query === 'string' ? input.query : legacyInput,
+            path: typeof input.url === 'string' ? input.url : undefined,
+        };
+    }
     return {};
 }
 /**
@@ -57,15 +65,46 @@ function bashStructuredQuery(command) {
     const findName = /\bfind\b[^|;&]*?-(?:i?name|path|wholename)\s+['"]?([^'"\s]+)/.exec(command);
     if (findName)
         return { query: findName[1] };
-    // ls / cat / test / head / tail / wc / file / stat / du / tree → path-only。
-    // 路径首字符限制 [\w./~]:
-    //   - 排除 flag (`-` 开头) 防 `npm run test --watch` 把 `--watch` 当 path
-    //   - 允许字母/数字/`.`/`/`/`~` 开头的 path token (foo / ./foo / /foo / ~/foo)
-    const pathOnly = /\b(?:ls|cat|test|head|tail|wc|file|stat|du|tree)\b\s+(?:-\w+\s+)*([\w./~][^\s|;&]*)/.exec(command);
-    if (pathOnly)
-        return { path: pathOnly[1] };
+    const path = shellReaderPath(command);
+    if (path)
+        return { path };
     return {};
 }
+function shellReaderPath(command) {
+    const match = /\b(ls|cat|test|head|tail|wc|file|stat|du|tree|sed|awk|less|more|bat)\b\s+([^|;&]+)/.exec(command);
+    if (!match)
+        return undefined;
+    const tool = match[1];
+    const tokens = shellWords(match[2]);
+    const positional = [];
+    for (let index = 0; index < tokens.length; index += 1) {
+        const token = tokens[index];
+        if (!token.startsWith('-') || token === '-') {
+            positional.push(token);
+            continue;
+        }
+        if ((tool === 'head' || tool === 'tail')
+            && (token === '-n' || token === '-c')
+            && index + 1 < tokens.length) {
+            index += 1;
+            continue;
+        }
+        if (tool === 'sed' && (token === '-e' || token === '-f') && index + 1 < tokens.length) {
+            index += 1;
+        }
+    }
+    const candidate = tool === 'sed' || tool === 'awk'
+        ? positional.at(-1)
+        : positional[0];
+    if (!candidate || /^\d+$/.test(candidate))
+        return undefined;
+    return /^[\w./~]/.test(candidate) ? candidate : undefined;
+}
+function shellWords(value) {
+    return [...value.matchAll(/"((?:\\.|[^"])*)"|'((?:\\.|[^'])*)'|([^\s]+)/g)]
+        .map((match) => match[1] ?? match[2] ?? match[3])
+        .filter((token) => Boolean(token));
+}
 export function bashSearchOrProbeCommand(command) {
     if (/\b(grep|rg|find)\b/.test(command))
         return true;
@@ -76,28 +115,46 @@ export function bashSearchOrProbeCommand(command) {
 export function isSearchToolCall(tc) {
     if (tc.tool === 'Read' || tc.tool === 'Grep')
         return true;
+    if (isWebSearchTool(tc.tool))
+        return true;
     if (tc.tool !== 'Bash')
         return false;
     const input = (tc.input && typeof tc.input === 'object') ? tc.input : {};
-    return bashSearchOrProbeCommand(String(input.command ?? ''));
+    const command = input.command ?? (typeof tc.input === 'string' ? tc.input : '');
+    return bashSearchOrProbeCommand(String(command));
 }
 export function isFailedSearchToolCall(tc) {
     const output = typeof tc.output === 'string' ? tc.output : String(tc.output ?? '');
-    const emptyOutput = output.trim() === '' || /No matches found/i.test(output);
+    // Runtime cancellation is authoritative. Some runtimes retain partial or
+    // stale output text on cancellation; it must not become knowledge-gap evidence.
+    if (isToolCallCancelled(tc))
+        return false;
+    const explicitlyEmpty = /No matches found/i.test(output);
+    // An unresolved call also has an empty output. That is missing evidence,
+    // not evidence that a search completed with zero matches.
+    const completedEmpty = output.trim() === '' && isToolCallSuccess(tc);
     if (tc.tool === 'Read') {
-        return tc.success === false;
+        return isToolCallFailure(tc);
     }
     if (tc.tool === 'Grep') {
-        if (tc.success === false)
+        if (isToolCallFailure(tc))
             return true;
-        return emptyOutput;
+        return explicitlyEmpty || completedEmpty;
+    }
+    if (isWebSearchTool(tc.tool)) {
+        return isToolCallFailure(tc);
     }
     if (tc.tool === 'Bash') {
         if (!isSearchToolCall(tc))
             return false;
-        if (tc.success === false)
+        if (isToolCallFailure(tc))
             return true;
-        return emptyOutput;
+        return explicitlyEmpty || completedEmpty;
     }
     return false;
 }
+function isWebSearchTool(tool) {
+    // `WebSearch` is the Trace IR canonical identity. Keep the old persisted spelling
+    // readable because report schemas before v5 could contain runtime-native names.
+    return tool === 'WebSearch' || tool === 'web_search';
+}

package/dist/shared/trace-projection.d.ts

@@ -0,0 +1,5 @@
+import type { ToolCallInfo, TurnInfo } from '../types/index.js';
+export declare const MAX_PERSISTED_TURN_CONTENT = 2000;
+export declare const MAX_PERSISTED_TOOL_OUTPUT = 1000;
+export declare function truncateToolCallsForPersistence(toolCalls: ToolCallInfo[]): ToolCallInfo[];
+export declare function truncateTurnsForPersistence(turns: TurnInfo[]): TurnInfo[];

package/dist/shared/trace-projection.js

@@ -0,0 +1,20 @@
+import { safeSliceForJson } from '../util/safe-slice.js';
+export const MAX_PERSISTED_TURN_CONTENT = 2000;
+export const MAX_PERSISTED_TOOL_OUTPUT = 1000;
+export function truncateToolCallsForPersistence(toolCalls) {
+    return toolCalls.map((toolCall) => ({
+        ...toolCall,
+        output: typeof toolCall.output === 'string'
+            ? safeSliceForJson(toolCall.output, MAX_PERSISTED_TOOL_OUTPUT)
+            : toolCall.output,
+    }));
+}
+export function truncateTurnsForPersistence(turns) {
+    return turns.map((turn) => ({
+        ...turn,
+        content: safeSliceForJson(turn.content, MAX_PERSISTED_TURN_CONTENT),
+        ...(turn.toolCalls && {
+            toolCalls: truncateToolCallsForPersistence(turn.toolCalls),
+        }),
+    }));
+}

package/dist/shared/trace-source-kind.d.ts

@@ -0,0 +1,3 @@
+import type { TraceSourceKind } from '../types/trace.js';
+/** Runtime validator for the persisted Trace IR source identity protocol. */
+export declare function isTraceSourceKind(value: unknown): value is TraceSourceKind;

package/dist/shared/trace-source-kind.js

@@ -0,0 +1,12 @@
+const TRACE_SOURCE_KINDS = new Set([
+    'claude',
+    'codex',
+    'openclaw',
+    'markdown_log',
+    'unknown',
+]);
+/** Runtime validator for the persisted Trace IR source identity protocol. */
+export function isTraceSourceKind(value) {
+    return typeof value === 'string'
+        && TRACE_SOURCE_KINDS.has(value);
+}

package/dist/types/diagnosis.d.ts

@@ -12,6 +12,7 @@ export interface DiagnosisScope {
     primary: 'skill' | 'definition' | 'session' | 'sample';
     refs: {
         skillName: string;
+        traceId?: string;
         sessionId?: string;
         invocationId?: string;
         sampleId?: string;
@@ -23,6 +24,7 @@ export interface DiagnosisScope {
 export interface DiagnosisEvidenceRef {
     id: string;
     kind: string;
+    traceId?: string;
     sourceTrace?: string;
     sessionId?: string;
     messageIndex?: number;

package/dist/types/eval.d.ts

@@ -305,6 +305,10 @@ export interface EvaluationRequest {
     strictBaseline?: boolean;
     /** Reasoning effort for executor LLM。透传到 ExecutorInput.effort。 */
     effort?: 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+    /** 每个执行任务失败后的最大重试次数。缺省 / 0 表示不重试。 */
+    retry?: number;
+    /** true 时关闭 assertion 失败后的诊断 LLM 调用。缺省等价于 false。 */
+    noDiagnostic?: boolean;
 }
 export type EvaluationJobStatus = 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled';
 export type EvaluationErrorCategory = 'user' | 'executor' | 'judge' | 'system';

package/dist/types/executor.d.ts

@@ -1,19 +1,35 @@
+import type { TraceSourceKind } from './trace.js';
+export type ToolCallStatus = 'success' | 'failure' | 'cancelled' | 'unknown';
+export type ToolCallStatusSource = 'runtime' | 'tool-output' | 'inferred' | 'unknown';
 export interface ToolCallInfo {
+    /** Source-neutral tool identity used by assertions and aggregate reports. */
     tool: string;
+    /** Runtime-native identity retained when `tool` was normalized. */
+    sourceTool?: string;
+    toolNamespace?: string;
+    toolProvider?: string;
     input: unknown;
     output: unknown;
+    /**
+     * Source-neutral completion state. Older reports only have `success`; readers
+     * must fall back to that boolean when this field is absent.
+     */
+    status?: ToolCallStatus;
+    statusSource?: ToolCallStatusSource;
     success: boolean;
     messageIndex?: number;
     messageUuid?: string;
+    /** Source-neutral identity for one concrete call occurrence. */
+    callInstanceId?: string;
     toolUseId?: string;
     timestamp?: string;
     sourceTrace?: string;
-    sourceKind?: 'claude' | 'openclaw' | 'markdown_log' | 'unknown';
+    sourceKind?: TraceSourceKind;
     traceRole?: 'standalone' | 'main' | 'subagent';
     traceLabel?: string;
 }
 export interface TurnInfo {
-    role: 'assistant' | 'tool';
+    role: 'user' | 'assistant' | 'tool';
     content: string;
     toolCalls?: ToolCallInfo[];
     durationMs?: number;
@@ -27,14 +43,23 @@ export interface ExecResult {
     outputTokens: number;
     cacheReadTokens: number;
     cacheCreationTokens: number;
+    /**
+     * Whether the token counters came from the underlying runtime.
+     * `false` means the numeric fields are compatibility placeholders and must
+     * not be treated as measured zero. Missing/true preserves legacy executors.
+     */
+    tokenUsageReportedByExecutor?: boolean;
     costUSD: number;
     /** Whether the underlying executor binary/SDK reported a USD cost figure.
-     *  - undefined / true : `costUSD` is authoritative (default — Anthropic SDK / OpenAI API / etc 都报)
-     *  - false            : executor 不报 cost,`costUSD` 是占位 0,renderer 应显示「未报告」/「—」。
-     *  目前只有 codex-cli executor 设 false (codex 0.125 binary 不输出 cost)。 */
+     *  - undefined / true : `costUSD` is authoritative
+     *  - false            : executor 不报 cost，`costUSD` 是占位 0，renderer 应显示「未报告」/「—」。 */
     costReportedByExecutor?: boolean;
     stopReason: string;
     numTurns: number;
+    /** Number of executor attempts represented by this result. Missing means one.
+     *  Output, token counters, and trace come from the final attempt; costUSD
+     *  includes every attempt because all of them may have incurred spend. */
+    attemptCount?: number;
     fullNumTurns?: number;
     numSubAgents?: number;
     error?: string;
@@ -138,6 +163,8 @@ export interface ExecutorRuntimeBinary {
     source: 'path' | 'bundled' | 'none' | 'unknown';
     version?: string;
     path?: string;
+    /** Content identity for local script/custom executor inputs. */
+    contentHash?: string;
     package?: ExecutorRuntimePackage;
     error?: string;
 }

package/dist/types/index.d.ts

@@ -1,4 +1,5 @@
 export * from './shared.js';
+export * from './trace.js';
 export * from './executor.js';
 export * from './judge.js';
 export * from './eval.js';

package/dist/types/index.js

@@ -1,4 +1,5 @@
 export * from './shared.js';
+export * from './trace.js';
 export * from './executor.js';
 export * from './judge.js';
 export * from './eval.js';

package/dist/types/judge.d.ts

@@ -118,6 +118,8 @@ export interface DiagnosticResult {
     };
     /** Diagnostic 自身花费(USD)。 */
     costUSD?: number;
+    /** False 表示底层 executor 没有报告 diagnostic 的真实 USD 成本。 */
+    costReportedByExecutor?: boolean;
     /** Diagnostic 是否成功(LLM JSON parse 失败时为 false,fallback 显示原始文本)。 */
     ok: boolean;
     /** Diagnostic 失败时的错误信息(ok=false 时使用)。 */