oh-my-knowledge 0.48.0 → 0.49.0

package/dist/analysis/coverage-analyzer.js

@@ -2,8 +2,11 @@
  * Knowledge coverage analyzer.
  * Computes coverage rates by comparing consumed knowledge against the full index.
  */
-import { basename, join, resolve } from 'node:path';
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { basename, isAbsolute, join, relative, resolve, } from 'node:path';
+import { existsSync, readdirSync, readFileSync, realpathSync, statSync, } from 'node:fs';
+import { ownRecordValue, setOwnRecordValue, } from '../shared/record-count.js';
+import { toolCallQuery } from '../shared/tool-search.js';
+import { isToolCallSuccess } from '../shared/tool-call-status.js';
 function classifyEntry(path) {
     if (/principle/i.test(path))
         return 'principle';
@@ -20,16 +23,24 @@ function classifyEntry(path) {
 export function extractReferencedPaths(artifactContent) {
     const paths = new Set();
     const pathPatterns = [
-        /\.claude\/[a-zA-Z0-9_/.-]+\.md/g,
-        /\.claude\/[a-zA-Z0-9_/.-]+\.sh/g,
+        /\.(?:agents|claude|codex|gemini)\/[a-zA-Z0-9_/.-]+\.(?:md|sh)/g,
         /repos\/[a-zA-Z0-9_/-]+/g,
+        /(?<![a-zA-Z0-9:/])((?:\.{1,2}\/)?(?:[a-zA-Z0-9_.-]+\/)+[a-zA-Z0-9_.-]+\.(?:md|sh))\b/g,
     ];
     for (const pattern of pathPatterns) {
         for (const match of artifactContent.matchAll(pattern)) {
-            paths.add(match[0]);
+            paths.add(match[1] ?? match[0]);
         }
     }
-    for (const match of artifactContent.matchAll(/\b([a-zA-Z0-9_-]+\.md)\b/g)) {
+    for (const match of artifactContent.matchAll(/\]\(([^)\s]+)\)/g)) {
+        const target = match[1].split('#', 1)[0];
+        if (target
+            && !/^[a-z][a-z0-9+.-]*:/i.test(target)
+            && /\.(?:md|sh)$/i.test(target)) {
+            paths.add(target);
+        }
+    }
+    for (const match of artifactContent.matchAll(/(?<![/\\])\b([a-zA-Z0-9_-]+\.md)\b/g)) {
         const name = match[1];
         if (/^(README|CHANGELOG|LICENSE|package)\.md$/i.test(name))
             continue;
@@ -37,27 +48,50 @@ export function extractReferencedPaths(artifactContent) {
     }
     return [...paths];
 }
-function scanKnowledgeDir(dir, prefix = '') {
+function scanKnowledgeDir(dir, prefix = '', visitedDirectories = new Set()) {
     if (!existsSync(dir))
         return [];
+    let realDir;
+    try {
+        realDir = realpathSync(dir);
+        if (!statSync(realDir).isDirectory())
+            return [];
+    }
+    catch {
+        return [];
+    }
+    if (visitedDirectories.has(realDir))
+        return [];
+    visitedDirectories.add(realDir);
     const entries = [];
-    for (const name of readdirSync(dir)) {
+    for (const name of readdirSync(dir).sort()) {
         if (name.startsWith('.'))
             continue;
         const fullPath = join(dir, name);
         const relativePath = prefix ? `${prefix}/${name}` : name;
-        const stat = statSync(fullPath);
+        let stat;
+        try {
+            stat = statSync(fullPath);
+        }
+        catch {
+            continue;
+        }
         if (stat.isDirectory()) {
-            entries.push(...scanKnowledgeDir(fullPath, relativePath));
+            entries.push(...scanKnowledgeDir(fullPath, relativePath, visitedDirectories));
         }
         else if (/\.(md|sh)$/.test(name)) {
             let lineCount;
+            let realPath;
             try {
+                realPath = realpathSync(fullPath);
                 lineCount = readFileSync(fullPath, 'utf-8').split('\n').length;
             }
-            catch { }
+            catch {
+                continue;
+            }
             entries.push({
                 path: relativePath,
+                realPath,
                 type: classifyEntry(relativePath),
                 lineCount,
             });
@@ -67,22 +101,41 @@ function scanKnowledgeDir(dir, prefix = '') {
 }
 export function buildKnowledgeIndex(cwd) {
     const knowledgeDirs = [
+        { dir: join(cwd, '.agents', 'skills'), prefix: '.agents/skills' },
         { dir: join(cwd, '.claude', 'knowledge'), prefix: '.claude/knowledge' },
         { dir: join(cwd, '.claude', 'skills'), prefix: '.claude/skills' },
+        { dir: join(cwd, '.codex', 'skills'), prefix: '.codex/skills' },
+        { dir: join(cwd, '.gemini', 'skills'), prefix: '.gemini/skills' },
     ];
-    const entries = [];
+    const entriesByRealPath = new Map();
     for (const { dir, prefix } of knowledgeDirs) {
-        entries.push(...scanKnowledgeDir(dir, prefix));
+        for (const entry of scanKnowledgeDir(dir, prefix)) {
+            const existing = entriesByRealPath.get(entry.realPath);
+            if (existing) {
+                existing.aliases = [...new Set([...(existing.aliases ?? []), entry.path])];
+                continue;
+            }
+            const { realPath, ...knowledgeEntry } = entry;
+            void realPath;
+            entriesByRealPath.set(entry.realPath, knowledgeEntry);
+        }
     }
-    const claudeMd = join(cwd, 'CLAUDE.md');
-    if (existsSync(claudeMd)) {
+    for (const instructionFile of ['AGENTS.md', 'CLAUDE.md', 'GEMINI.md']) {
+        const instructionPath = join(cwd, instructionFile);
+        if (!existsSync(instructionPath))
+            continue;
         let lineCount;
         try {
-            lineCount = readFileSync(claudeMd, 'utf-8').split('\n').length;
+            lineCount = readFileSync(instructionPath, 'utf-8').split('\n').length;
         }
         catch { }
-        entries.push({ path: 'CLAUDE.md', type: 'principle', lineCount });
+        entriesByRealPath.set(realpathSync(instructionPath), {
+            path: instructionFile,
+            type: 'principle',
+            lineCount,
+        });
     }
+    const entries = [...entriesByRealPath.values()];
     const totalLines = entries.reduce((sum, entry) => sum + (entry.lineCount || 0), 0);
     return {
         entries,
@@ -92,48 +145,35 @@ export function buildKnowledgeIndex(cwd) {
 }
 export function buildFullKnowledgeIndex(artifactContent, cwd) {
     const entriesMap = new Map();
-    if (artifactContent) {
-        if (cwd) {
-            const knowledgeDir = join(cwd, '.claude', 'knowledge');
-            for (const entry of scanKnowledgeDir(knowledgeDir, '.claude/knowledge')) {
-                entriesMap.set(entry.path, entry);
-            }
-            const claudeMd = join(cwd, 'CLAUDE.md');
-            if (existsSync(claudeMd)) {
-                let lineCount;
-                try {
-                    lineCount = readFileSync(claudeMd, 'utf-8').split('\n').length;
-                }
-                catch { }
-                entriesMap.set('CLAUDE.md', { path: 'CLAUDE.md', type: 'principle', lineCount });
-            }
+    if (cwd) {
+        const dirIndex = buildKnowledgeIndex(cwd);
+        for (const entry of dirIndex.entries) {
+            entriesMap.set(entry.path, entry);
         }
+    }
+    if (artifactContent) {
         const refPaths = extractReferencedPaths(artifactContent);
         for (const path of refPaths) {
             if (!entriesMap.has(path)) {
-                const existing = [...entriesMap.values()].find((entry) => entry.path.endsWith('/' + path) || entry.path === path);
+                const existing = [...entriesMap.values()].find((entry) => [entry.path, ...(entry.aliases ?? [])].some((candidate) => candidate.endsWith('/' + path) || candidate === path));
                 if (!existing) {
                     let lineCount;
                     if (cwd) {
-                        const fullPath = resolve(cwd, path);
+                        const fullPath = resolveInside(cwd, path);
                         try {
-                            if (existsSync(fullPath) && statSync(fullPath).isFile()) {
+                            if (fullPath && existsSync(fullPath) && statSync(fullPath).isFile()) {
                                 lineCount = readFileSync(fullPath, 'utf-8').split('\n').length;
                             }
                         }
                         catch { }
                     }
-                    entriesMap.set(path, { path, type: classifyEntry(path), lineCount });
+                    if (!cwd || resolveInside(cwd, path)) {
+                        entriesMap.set(path, { path, type: classifyEntry(path), lineCount });
+                    }
                 }
             }
         }
     }
-    else if (cwd) {
-        const dirIndex = buildKnowledgeIndex(cwd);
-        for (const entry of dirIndex.entries) {
-            entriesMap.set(entry.path, entry);
-        }
-    }
     const entries = [...entriesMap.values()];
     const totalLines = entries.reduce((sum, entry) => sum + (entry.lineCount || 0), 0);
     return {
@@ -142,18 +182,28 @@ export function buildFullKnowledgeIndex(artifactContent, cwd) {
         totalLines,
     };
 }
+function resolveInside(root, path) {
+    const absoluteRoot = resolve(root);
+    const candidate = resolve(absoluteRoot, path);
+    const relativePath = relative(absoluteRoot, candidate);
+    return relativePath === ''
+        || (!relativePath.startsWith('..') && !isAbsolute(relativePath))
+        ? candidate
+        : null;
+}
 export function extractKnowledgeConsumption(toolCalls) {
     const filesRead = [];
     const grepPatterns = [];
     const bashGrepPatterns = [];
     for (const toolCall of toolCalls) {
-        const input = toolCall.input;
-        if (!input)
-            continue;
+        const input = toolCall.input && typeof toolCall.input === 'object'
+            ? toolCall.input
+            : {};
+        const legacyInput = typeof toolCall.input === 'string' ? toolCall.input : undefined;
         switch (toolCall.tool) {
             case 'Read': {
-                const filePath = input.file_path;
-                if (filePath)
+                const filePath = typeof input.file_path === 'string' ? input.file_path : legacyInput;
+                if (filePath && isToolCallSuccess(toolCall))
                     filesRead.push(filePath);
                 break;
             }
@@ -165,9 +215,12 @@ export function extractKnowledgeConsumption(toolCalls) {
                 break;
             }
             case 'Bash': {
-                const command = input.command;
+                const command = typeof input.command === 'string' ? input.command : legacyInput;
                 if (!command)
                     break;
+                const readPath = toolCallQuery(toolCall).path;
+                if (readPath && isToolCallSuccess(toolCall))
+                    filesRead.push(readPath);
                 const grepMatch = command.match(/(?:grep|rg)\s+(?:-[a-zA-Z]+\s+)*["']?([^"'\s|]+)["']?\s+([^\s|>]+)/);
                 if (grepMatch) {
                     bashGrepPatterns.push({ pattern: grepMatch[1], path: grepMatch[2] });
@@ -179,17 +232,27 @@ export function extractKnowledgeConsumption(toolCalls) {
     return { filesRead: [...new Set(filesRead)], grepPatterns, bashGrepPatterns };
 }
 export function normalizeKnowledgePath(filePath, cwd) {
-    if (cwd && filePath.startsWith(cwd)) {
-        const relative = filePath.slice(cwd.endsWith('/') ? cwd.length : cwd.length + 1);
-        return relative;
+    if (cwd) {
+        const relativePath = relative(resolve(cwd), resolve(cwd, filePath));
+        if (relativePath === ''
+            || (!relativePath.startsWith('..') && !isAbsolute(relativePath))) {
+            return relativePath.replaceAll('\\', '/');
+        }
     }
-    const patterns = ['.claude/knowledge/', '.claude/skills/'];
+    const normalized = filePath.replaceAll('\\', '/');
+    const patterns = [
+        '.agents/skills/',
+        '.claude/knowledge/',
+        '.claude/skills/',
+        '.codex/skills/',
+        '.gemini/skills/',
+    ];
     for (const pattern of patterns) {
-        const index = filePath.indexOf(pattern);
+        const index = normalized.indexOf(pattern);
         if (index !== -1)
-            return filePath.slice(index);
+            return normalized.slice(index);
     }
-    return basename(filePath);
+    return basename(normalized);
 }
 /**
  * Compute knowledge coverage for a single variant across all samples.
@@ -207,13 +270,13 @@ export function computeCoverage(results, variant, index, cwd) {
     const consumedNormalized = new Set(consumption.filesRead.map((f) => normalizeKnowledgePath(f, cwd)));
     // Match index entries against consumed files
     const entries = index.entries.map((entry) => {
-        // Check if this entry was accessed — match by exact path or by filename
-        const accessed = consumedNormalized.has(entry.path) ||
-            [...consumedNormalized].some((consumed) => consumed.endsWith('/' + entry.path) || consumed.endsWith(entry.path));
+        const paths = [entry.path, ...(entry.aliases ?? [])];
+        const accessed = paths.some((path) => consumedNormalized.has(path)
+            || [...consumedNormalized].some((consumed) => consumed.endsWith('/' + path)));
         const accessCount = accessed
             ? consumption.filesRead.filter((f) => {
                 const norm = normalizeKnowledgePath(f, cwd);
-                return norm === entry.path || norm.endsWith('/' + entry.path) || norm.endsWith(entry.path);
+                return paths.some((path) => norm === path || norm.endsWith('/' + path));
             }).length
             : 0;
         return {
@@ -249,13 +312,13 @@ export function computeCoverage(results, variant, index, cwd) {
 export function computeReportCoverage(report, artifactContents, cwds) {
     const coverageMap = {};
     for (const variant of report.meta.variants) {
-        const content = artifactContents[variant] || null;
-        const cwd = cwds[variant] || null;
+        const content = ownRecordValue(artifactContents, variant) || null;
+        const cwd = ownRecordValue(cwds, variant) || null;
         // Build knowledge index for this variant
         const index = buildFullKnowledgeIndex(content, cwd);
         if (index.totalFiles === 0)
             continue;
-        coverageMap[variant] = computeCoverage(report.results, variant, index, cwd);
+        setOwnRecordValue(coverageMap, variant, computeCoverage(report.results, variant, index, cwd));
     }
     return coverageMap;
 }

package/dist/analysis/failure-clusterer.js

@@ -38,6 +38,7 @@
  * a categorization task, not a quality scoring task, so the length-debias
  * directive is inapplicable.
  */
+import { isToolCallFailure } from '../shared/tool-call-status.js';
 const DEFAULT_MAX_CLUSTERS = 5;
 const DEFAULT_FAILURE_THRESHOLD = 3;
 const DEFAULT_MAX_FED = 50;
@@ -159,7 +160,7 @@ function describeFailure(entry, variant, r) {
     if (r.llmReason)
         parts.push(`judge_reason="${truncate(r.llmReason, 200)}"`);
     // Tool failures (agent traces).
-    const toolFailures = (r.toolCalls ?? []).filter((tc) => !tc.success).slice(0, 3);
+    const toolFailures = (r.toolCalls ?? []).filter(isToolCallFailure).slice(0, 3);
     if (toolFailures.length > 0) {
         parts.push(`failed_tools=[${toolFailures.map((tc) => `${tc.tool}: ${truncate(String(tc.output ?? ''), 80)}`).join('; ')}]`);
     }

package/dist/analysis/gap-analyzer.d.ts

@@ -105,7 +105,7 @@ export declare function computeReportGapRates(results: ResultEntry[], variants:
  * 失败降级在 classifier 层:单批失败 → 该 batch 全部 isUncertainty=true (保守保留)。
  * 调用方拿到的 report 永远是合法的,不会因 classifier 失败而崩。
  */
-export declare function applyHedgingClassifier(report: GapReport, executor: ExecutorFn, opts?: ClassifyOptions): Promise<{
+export declare function applyHedgingClassifier(report: GapReport, executor: ExecutorFn, opts: ClassifyOptions): Promise<{
     report: GapReport;
     costUSD: number;
     truncated: boolean;
@@ -114,7 +114,7 @@ export declare function applyHedgingClassifier(report: GapReport, executor: Exec
  * 批量为一组 variant 的 gap reports 跑 classifier。
  * 串行(不并行)避免 rate limit + 让 cache hit 在第一批后被后续 batch 复用。
  */
-export declare function applyHedgingClassifierToReports(reports: Record<string, GapReport>, executor: ExecutorFn, opts?: ClassifyOptions): Promise<{
+export declare function applyHedgingClassifierToReports(reports: Record<string, GapReport>, executor: ExecutorFn, opts: ClassifyOptions): Promise<{
     reports: Record<string, GapReport>;
     costUSD: number;
 }>;

package/dist/analysis/gap-analyzer.js

@@ -17,6 +17,8 @@
  */
 import { classifyHedgingCandidates } from './hedging-classifier.js';
 import { isFailedSearchToolCall, toolCallQuery } from '../shared/tool-search.js';
+import { setOwnRecordValue } from '../shared/record-count.js';
+import { toolCallStatus } from '../shared/tool-call-status.js';
 // ---------- Pattern tables ----------
 const EXPLICIT_MARKER_PATTERNS = [
     /【推断】/g,
@@ -98,7 +100,15 @@ export function extractFailedSearchSignals(toolCalls) {
             sampleId: '',
             type: 'failed_search',
             context,
-            evidence: { tool: tc.tool, pattern, path, success: tc.success },
+            evidence: {
+                tool: tc.tool,
+                pattern,
+                path,
+                status: toolCallStatus(tc),
+                statusSource: tc.statusSource ?? 'unknown',
+                // Retained for readers of pre-four-state reports.
+                success: tc.success,
+            },
             weight: SIGNAL_WEIGHTS.failed_search,
         });
     }
@@ -366,7 +376,7 @@ export function computeGapReport(results, variant) {
 export function computeReportGapRates(results, variants) {
     const out = {};
     for (const v of variants) {
-        out[v] = computeGapReport(results, v);
+        setOwnRecordValue(out, v, computeGapReport(results, v));
     }
     return out;
 }
@@ -463,7 +473,7 @@ export async function applyHedgingClassifierToReports(reports, executor, opts) {
     let totalCost = 0;
     for (const [variant, report] of Object.entries(reports)) {
         const result = await applyHedgingClassifier(report, executor, opts);
-        out[variant] = result.report;
+        setOwnRecordValue(out, variant, result.report);
         totalCost += result.costUSD;
     }
     return { reports: out, costUSD: totalCost };

package/dist/analysis/hedging-classifier.d.ts

@@ -16,8 +16,8 @@ export interface HedgingCandidate {
     context: string;
 }
 export interface ClassifyOptions {
+    model: string;
     maxCandidates?: number;
-    model?: string;
     batchSize?: number;
 }
 export interface ClassifyResult {
@@ -30,4 +30,4 @@ export declare function clearHedgingCache(): void;
  * 对一批 candidate 做分类判定。返回与 input 等长的 verdicts。
  * 失败降级:单批 LLM 调用 / 解析失败 → 该 batch 全部 isUncertainty=true (保守保留)。
  */
-export declare function classifyHedgingCandidates(candidates: HedgingCandidate[], executor: ExecutorFn, opts?: ClassifyOptions): Promise<ClassifyResult>;
+export declare function classifyHedgingCandidates(candidates: HedgingCandidate[], executor: ExecutorFn, opts: ClassifyOptions): Promise<ClassifyResult>;

package/dist/analysis/hedging-classifier.js

@@ -12,7 +12,6 @@
 import { createHash } from 'node:crypto';
 const DEFAULT_MAX_CANDIDATES = 50;
 const DEFAULT_BATCH_SIZE = 10;
-const DEFAULT_MODEL = 'claude-haiku-4-5';
 // in-memory cache,进程内复用。key = sha256(sentence)。
 const verdictCache = new Map();
 export function clearHedgingCache() {
@@ -75,9 +74,9 @@ function fallbackVerdict(reason) {
  * 失败降级:单批 LLM 调用 / 解析失败 → 该 batch 全部 isUncertainty=true (保守保留)。
  */
 export async function classifyHedgingCandidates(candidates, executor, opts) {
-    const max = opts?.maxCandidates ?? DEFAULT_MAX_CANDIDATES;
-    const batchSize = opts?.batchSize ?? DEFAULT_BATCH_SIZE;
-    const model = opts?.model ?? DEFAULT_MODEL;
+    const max = opts.maxCandidates ?? DEFAULT_MAX_CANDIDATES;
+    const batchSize = opts.batchSize ?? DEFAULT_BATCH_SIZE;
+    const model = opts.model;
     const truncated = candidates.length > max;
     const work = candidates.slice(0, max);
     const verdicts = new Array(candidates.length);

package/dist/analysis/report-diagnostics.js

@@ -3,6 +3,8 @@
  */
 import { normalizeCapability } from './sample-diagnostics.js';
 import { analyzeJudgeIndependence } from '../eval-core/judge-independence.js';
+import { isToolCallFailure } from '../shared/tool-call-status.js';
+import { incrementRecordCount, setOwnRecordValue } from '../shared/record-count.js';
 /**
  * Analyze an evaluation report and produce structured insights.
  */
@@ -111,7 +113,7 @@ export function buildSampleQualityAggregate(samples) {
                 if (seen.has(cap))
                     continue; // 同 sample 内同 capability 重复声明只计 1
                 seen.add(cap);
-                capabilityCoverage[cap] = (capabilityCoverage[cap] || 0) + 1;
+                incrementRecordCount(capabilityCoverage, cap);
             }
         }
         // difficulty
@@ -125,18 +127,18 @@ export function buildSampleQualityAggregate(samples) {
         // construct (free-form)
         if (sample.construct) {
             withConstruct++;
-            constructDistribution[sample.construct] = (constructDistribution[sample.construct] || 0) + 1;
+            incrementRecordCount(constructDistribution, sample.construct);
         }
         else {
-            constructDistribution.unspecified = (constructDistribution.unspecified || 0) + 1;
+            incrementRecordCount(constructDistribution, 'unspecified');
         }
         // provenance
         if (sample.provenance) {
             withProvenance++;
-            provenanceBreakdown[sample.provenance] = (provenanceBreakdown[sample.provenance] || 0) + 1;
+            incrementRecordCount(provenanceBreakdown, sample.provenance);
         }
         else {
-            provenanceBreakdown.unspecified = (provenanceBreakdown.unspecified || 0) + 1;
+            incrementRecordCount(provenanceBreakdown, 'unspecified');
         }
         // rubric length(only counted if present, NaN-safe)
         if (sample.rubric) {
@@ -192,7 +194,7 @@ export function buildRepresentativeness(aggregate) {
     const declaredConstruct = {};
     for (const [k, v] of Object.entries(aggregate.constructDistribution)) {
         if (k !== 'unspecified')
-            declaredConstruct[k] = v;
+            setOwnRecordValue(declaredConstruct, k, v);
     }
     const consTotal = Object.values(declaredConstruct).reduce((a, b) => a + b, 0);
     const [dominantConstruct, constructConcentration] = dominantShare(declaredConstruct, consTotal);
@@ -715,7 +717,7 @@ function detectToolPermissionIssues(results, variants, insights) {
         for (const variant of variants) {
             const calls = result.variants?.[variant]?.toolCalls || [];
             for (const call of calls) {
-                if (call.success)
+                if (!isToolCallFailure(call))
                     continue;
                 const output = String(call.output || '');
                 if (/EACCES|permission denied/i.test(output)) {

package/dist/analysis/sample-diagnostics.js

@@ -24,6 +24,7 @@
  * sorted by severity then by sample_id so the report is stable across runs.
  */
 import { rougeN } from '../grading/assertions.js';
+import { ownRecordValue, setOwnRecordValue, } from '../shared/record-count.js';
 const DEFAULTS = {
     duplicateRouge: 0.7,
     ambiguousStddev: 1.0,
@@ -193,10 +194,9 @@ export function diagnoseSamples(report, options = {}) {
                     if (seenCaps.has(cap))
                         continue;
                     seenCaps.add(cap);
-                    if (!capabilityCount[cap])
-                        capabilityCount[cap] = { count: 0, sampleIds: [] };
-                    capabilityCount[cap].count++;
-                    capabilityCount[cap].sampleIds.push(sample.sample_id);
+                    const info = ownRecordValue(capabilityCount, cap) ?? setOwnRecordValue(capabilityCount, cap, { count: 0, sampleIds: [] });
+                    info.count++;
+                    info.sampleIds.push(sample.sample_id);
                 }
             }
             for (const [cap, info] of Object.entries(capabilityCount)) {
@@ -247,9 +247,9 @@ function emptyReport(samples) {
 function scoresMap(entry, variants) {
     const out = {};
     for (const v of variants) {
-        const r = entry.variants?.[v];
+        const r = entry.variants ? ownRecordValue(entry.variants, v) : undefined;
         if (r && typeof r.compositeScore === 'number') {
-            out[v] = Number(r.compositeScore.toFixed(2));
+            setOwnRecordValue(out, v, Number(r.compositeScore.toFixed(2)));
         }
     }
     return out;

package/dist/artifact-graph/doctor.js

@@ -3,12 +3,14 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSy
 import { basename, dirname, join, relative, resolve, sep } from 'node:path';
 import { cardFileName, graphFileName, safeArtifactFileStem } from '../eval-core/artifact-file-names.js';
 import { hashArtifactSource } from '../inputs/content-hash.js';
+import { parseArtifactGraphDocument } from '../shared/artifact-graph.js';
+import { writeJsonFileAtomic } from '../shared/atomic-json.js';
 import { extractMarkdownStepWorkflows, extractSkillHardRules, extractSkillWorkflows, parseSkillFrontmatter, } from '../shared/hard-rules.js';
 function shortHash(input) {
     return createHash('sha256').update(input).digest('hex').slice(0, 12);
 }
-function safeFileName(id) {
-    return safeArtifactFileStem(id);
+function isCanonicalFileStem(id) {
+    return id.length > 0 && safeArtifactFileStem(id) === id;
 }
 export function doctorGraphDirForDoctorOutput(doctorOutputDir) {
     return basename(doctorOutputDir) === 'doctors'
@@ -547,20 +549,26 @@ export function renderDoctorEvidenceCard(graph, skill, lang) {
 export function persistDoctorGraphSidecars(options) {
     const dir = doctorGraphDirForDoctorOutput(options.outputDir);
     mkdirSync(dir, { recursive: true });
-    const graph = buildDoctorArtifactGraph(options);
-    const fileStem = safeFileName(options.fileStem);
+    if (!isCanonicalFileStem(options.fileStem)) {
+        throw new Error('invalid doctor graph file stem');
+    }
+    const graph = parseArtifactGraphDocument(buildDoctorArtifactGraph(options));
+    if (!graph)
+        throw new Error('invalid doctor artifact graph');
+    const fileStem = options.fileStem;
     const graphPath = join(dir, graphFileName(fileStem));
     const evidenceCardPath = join(dir, cardFileName(fileStem));
-    writeFileSync(graphPath, JSON.stringify(graph, null, 2), 'utf8');
+    writeJsonFileAtomic(graphPath, graph);
     writeFileSync(evidenceCardPath, renderDoctorEvidenceCard(graph, options.skill, options.lang), 'utf8');
     return { graphPath, evidenceCardPath };
 }
 export function removeDoctorGraphSidecars(doctorOutputDir, fileStem) {
+    if (!isCanonicalFileStem(fileStem))
+        return;
     const dir = doctorGraphDirForDoctorOutput(doctorOutputDir);
-    const safeStem = safeFileName(fileStem);
     for (const ext of ['graph.json', 'card.md']) {
         try {
-            unlinkSync(join(dir, `${safeStem}.${ext}`));
+            unlinkSync(join(dir, `${fileStem}.${ext}`));
         }
         catch {
             // best-effort cleanup only