@dailephd/my-dev-kit-lab 0.2.0

package/dist/src/evaluation/parseAgentAnswer.js

@@ -0,0 +1,230 @@
+export function parseAgentAnswer(args) {
+    const text = args.text.trim();
+    const warnings = [];
+    if (!text) {
+        return emptyParsedAnswer("failed", ["Agent answer was empty."], args.tokenUsage);
+    }
+    const jsonParsed = parseJsonAnswer(text, args.tokenUsage);
+    if (jsonParsed) {
+        return enrichFacts(jsonParsed, text, args.answerKey);
+    }
+    const fields = collectFieldValues(text);
+    const parsed = {
+        answerText: fields.get("answer")?.join("\n")?.trim() || text,
+        relevantFiles: splitListValues(fields.get("relevantfiles") ?? fields.get("files")),
+        relevantSymbols: splitListValues(fields.get("relevantsymbols") ?? fields.get("symbols")),
+        expectedFactsFound: splitListValues(fields.get("expectedfactsfound") ?? fields.get("facts") ?? fields.get("factids")),
+        confidence: firstValue(fields.get("confidence")),
+        commandsRun: splitListValues(fields.get("commandsrun") ?? fields.get("commands")),
+        selectedContext: splitListValues(fields.get("selectedcontext") ?? fields.get("context")),
+        fullFileReads: splitListValues(fields.get("fullfilereads")),
+        fullFileReadJustifications: splitListValues(fields.get("fullfilereadjustifications")),
+        parseStatus: "parsed",
+        warnings,
+        tokenUsage: args.tokenUsage
+    };
+    if (parsed.relevantFiles.length === 0) {
+        parsed.relevantFiles = parseMarkdownSection(text, ["Relevant Files", "Files"]);
+    }
+    if (parsed.relevantSymbols.length === 0) {
+        parsed.relevantSymbols = parseMarkdownSection(text, ["Relevant Symbols", "Symbols"]);
+    }
+    if (parsed.expectedFactsFound.length === 0) {
+        parsed.expectedFactsFound = parseMarkdownSection(text, ["Expected Facts Found", "Facts Found", "Facts"]);
+    }
+    if (parsed.commandsRun.length === 0) {
+        parsed.commandsRun = parseMarkdownSection(text, ["Commands Run", "Commands"]);
+    }
+    parsed.expectedFactsFound = normalizeFactMatches(parsed.expectedFactsFound, text, args.answerKey);
+    if (parsed.answerText.length === 0 || (parsed.relevantFiles.length === 0 && parsed.relevantSymbols.length === 0 && parsed.expectedFactsFound.length === 0)) {
+        parsed.parseStatus = parsed.answerText.length > 0 ? "partial" : "failed";
+        warnings.push("Agent answer did not include enough structured fields for full parsing.");
+    }
+    return parsed;
+}
+function parseJsonAnswer(text, tokenUsage) {
+    const candidates = collectJsonCandidates(text);
+    for (const candidate of candidates) {
+        try {
+            const value = JSON.parse(candidate);
+            if (!value || typeof value !== "object" || Array.isArray(value)) {
+                continue;
+            }
+            return {
+                answerText: readString(value, "answer", "answerText", "finalAnswer") ?? "",
+                relevantFiles: readStringArray(value, "relevantFiles", "files"),
+                relevantSymbols: readStringArray(value, "relevantSymbols", "symbols"),
+                expectedFactsFound: readStringArray(value, "expectedFactsFound", "facts", "factIds"),
+                confidence: readString(value, "confidence"),
+                commandsRun: readStringArray(value, "commandsRun", "commands"),
+                selectedContext: readStringArray(value, "selectedContext", "context"),
+                fullFileReads: readStringArray(value, "fullFileReads"),
+                fullFileReadJustifications: readStringArray(value, "fullFileReadJustifications"),
+                parseStatus: "parsed",
+                warnings: [],
+                tokenUsage
+            };
+        }
+        catch {
+            // Mixed markdown often contains fenced non-JSON blocks; ignore malformed candidates.
+        }
+    }
+    return undefined;
+}
+function collectJsonCandidates(text) {
+    const candidates = [];
+    const trimmed = text.trim();
+    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+        candidates.push(trimmed);
+    }
+    for (const match of text.matchAll(/```(?:json)?\s*([\s\S]*?)```/gi)) {
+        const body = match[1]?.trim();
+        if (body?.startsWith("{")) {
+            candidates.push(body);
+        }
+    }
+    return candidates;
+}
+function collectFieldValues(text) {
+    const fields = new Map();
+    let currentKey;
+    for (const line of text.split(/\r?\n/)) {
+        const fieldMatch = line.match(/^\s*(?:[-*]\s*)?(?:[*_`]{0,2})([A-Za-z][A-Za-z0-9 _-]{1,40})(?:[*_`]{0,2})\s*:\s*(.*)$/);
+        if (fieldMatch) {
+            currentKey = normalizeKey(fieldMatch[1]);
+            const current = fields.get(currentKey) ?? [];
+            current.push(stripMarkupOnlyValue(fieldMatch[2] ?? ""));
+            fields.set(currentKey, current);
+            continue;
+        }
+        if (currentKey && (/^\s+[-*]?\s*\S/.test(line) || /^\s*[-*]\s+\S/.test(line))) {
+            fields.get(currentKey)?.push(line.trim().replace(/^[-*]\s*/, ""));
+        }
+    }
+    return fields;
+}
+function parseMarkdownSection(text, headings) {
+    const lines = text.split(/\r?\n/);
+    const values = [];
+    let inSection = false;
+    for (const line of lines) {
+        const heading = line.match(/^\s*#{1,6}\s*(.+?)\s*$/);
+        if (heading) {
+            inSection = headings.some((candidate) => normalizeKey(candidate) === normalizeKey(heading[1]));
+            continue;
+        }
+        if (!inSection) {
+            continue;
+        }
+        if (/^\s*#{1,6}\s+/.test(line)) {
+            break;
+        }
+        const bullet = line.match(/^\s*[-*]\s+(.+)$/);
+        if (bullet) {
+            values.push(bullet[1].trim());
+        }
+        else if (line.includes(",")) {
+            values.push(...splitListValues([line]));
+        }
+    }
+    return unique(values);
+}
+function enrichFacts(parsed, text, answerKey) {
+    parsed.expectedFactsFound = normalizeFactMatches(parsed.expectedFactsFound, text, answerKey);
+    if (parsed.answerText.length === 0) {
+        parsed.answerText = text;
+    }
+    if (parsed.relevantFiles.length === 0 && parsed.relevantSymbols.length === 0 && parsed.expectedFactsFound.length === 0) {
+        parsed.parseStatus = "partial";
+        parsed.warnings.push("JSON agent answer did not include scoring fields.");
+    }
+    return parsed;
+}
+function normalizeFactMatches(values, fullText, answerKey) {
+    if (!answerKey) {
+        return unique(values.map(cleanListItem).filter(Boolean));
+    }
+    const normalizedValues = new Set(values.map(normalizeMatchText));
+    const normalizedFullText = normalizeMatchText(fullText);
+    const matches = [];
+    for (const fact of answerKey.expectedFacts) {
+        const normalizedFactText = normalizeMatchText(fact.text);
+        if (normalizedValues.has(normalizeMatchText(fact.id)) ||
+            normalizedValues.has(normalizedFactText) ||
+            normalizedFullText.includes(normalizeMatchText(fact.id)) ||
+            (normalizedFactText.length > 20 && normalizedFullText.includes(normalizedFactText))) {
+            matches.push(fact.id);
+        }
+    }
+    return unique([...matches, ...values.map(cleanListItem).filter(Boolean)]);
+}
+function splitListValues(values) {
+    if (!values) {
+        return [];
+    }
+    return unique(values
+        .flatMap((value) => value.split(/,|\n/))
+        .map(cleanListItem)
+        .filter(Boolean));
+}
+function cleanListItem(value) {
+    const codeSpan = value.match(/`([^`]+)`/);
+    const cleaned = (codeSpan?.[1] ?? value)
+        .trim()
+        .replace(/^[-*]\s*/, "")
+        .replace(/^["'`]+|["'`.]+$/g, "")
+        .replace(/\s+[--]\s+.*$/g, "")
+        .replace(/\s+[-–—]\s+.*$/g, "")
+        .trim();
+    return cleaned;
+}
+function stripMarkupOnlyValue(value) {
+    return /^[*_`\s]+$/.test(value) ? "" : value;
+}
+function normalizeKey(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+function normalizeMatchText(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+}
+function firstValue(values) {
+    return values?.find((value) => value.trim().length > 0)?.trim();
+}
+function readString(value, ...keys) {
+    for (const key of keys) {
+        if (typeof value[key] === "string") {
+            return value[key];
+        }
+    }
+    return undefined;
+}
+function readStringArray(value, ...keys) {
+    for (const key of keys) {
+        const field = value[key];
+        if (Array.isArray(field)) {
+            return field.filter((item) => typeof item === "string");
+        }
+        if (typeof field === "string") {
+            return splitListValues([field]);
+        }
+    }
+    return [];
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+function emptyParsedAnswer(parseStatus, warnings, tokenUsage) {
+    return {
+        answerText: "",
+        relevantFiles: [],
+        relevantSymbols: [],
+        expectedFactsFound: [],
+        commandsRun: [],
+        selectedContext: [],
+        fullFileReads: [],
+        fullFileReadJustifications: [],
+        parseStatus,
+        warnings,
+        tokenUsage
+    };
+}

package/dist/src/evaluation/projectComplexity.js

@@ -0,0 +1,126 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+export const PROJECT_COMPLEXITY_FORMULA = {
+    id: "benchmark-project-complexity-v1",
+    description: "Weighted score using capped normalized source files, source lines, language count, internal imports, max file lines, expected relevant files, and expected relevant symbols.",
+    scoreRange: [0, 100],
+    normalizedValue: "min(value / cap, 1)",
+    weights: {
+        sourceFileCount: 0.2,
+        sourceLinesOfCode: 0.2,
+        languageCount: 0.15,
+        internalImportCount: 0.15,
+        maxFileLines: 0.1,
+        expectedRelevantFilesAverage: 0.1,
+        expectedRelevantSymbolsAverage: 0.1
+    },
+    caps: {
+        sourceFileCount: 20,
+        sourceLinesOfCode: 2000,
+        languageCount: 4,
+        internalImportCount: 50,
+        maxFileLines: 300,
+        expectedRelevantFilesAverage: 10,
+        expectedRelevantSymbolsAverage: 20
+    }
+};
+export function calculateProjectComplexityScore(metrics) {
+    const { weights, caps } = PROJECT_COMPLEXITY_FORMULA;
+    const normalizedScore = weights.sourceFileCount * normalize(metrics.sourceFileCount, caps.sourceFileCount) +
+        weights.sourceLinesOfCode * normalize(metrics.sourceLinesOfCode, caps.sourceLinesOfCode) +
+        weights.languageCount * normalize(metrics.languageCount, caps.languageCount) +
+        weights.internalImportCount * normalize(metrics.internalImportCount, caps.internalImportCount) +
+        weights.maxFileLines * normalize(metrics.maxFileLines, caps.maxFileLines) +
+        weights.expectedRelevantFilesAverage * normalize(metrics.expectedRelevantFilesAverage, caps.expectedRelevantFilesAverage) +
+        weights.expectedRelevantSymbolsAverage * normalize(metrics.expectedRelevantSymbolsAverage, caps.expectedRelevantSymbolsAverage);
+    return Math.round(normalizedScore * 100);
+}
+export function computeProjectComplexityMetrics(projectRoot, fileTree, taskStats) {
+    const fileEntries = fileTree.entries.filter((entry) => entry.kind === "file");
+    const codeEntries = fileEntries.filter((entry) => entry.role === "source" || entry.role === "test");
+    const sourceEntries = fileEntries.filter((entry) => entry.role === "source");
+    const testEntries = fileEntries.filter((entry) => entry.role === "test");
+    const languages = new Set(codeEntries.map((entry) => entry.language).filter((language) => Boolean(language)));
+    const codeLineCounts = new Map();
+    for (const entry of codeEntries) {
+        codeLineCounts.set(entry.path, countApproximateCodeLines(path.join(projectRoot, entry.path)));
+    }
+    const totalLinesOfCode = sum([...codeLineCounts.values()]);
+    const sourceLinesOfCode = sum(sourceEntries.map((entry) => codeLineCounts.get(entry.path) ?? 0));
+    const testLinesOfCode = sum(testEntries.map((entry) => codeLineCounts.get(entry.path) ?? 0));
+    const fileLineCounts = codeEntries.map((entry) => entry.lines ?? 0);
+    const metrics = {
+        fileCount: fileEntries.length,
+        sourceFileCount: sourceEntries.length,
+        testFileCount: testEntries.length,
+        totalLinesOfCode,
+        sourceLinesOfCode,
+        testLinesOfCode,
+        languageCount: languages.size,
+        dependencyFileCount: fileEntries.filter((entry) => isDependencyFile(entry.path)).length,
+        internalImportCount: sum(sourceEntries.map((entry) => countInternalImports(path.join(projectRoot, entry.path)))),
+        exportedSymbolEstimate: sum(sourceEntries.map((entry) => countExportedSymbols(path.join(projectRoot, entry.path)))),
+        taskCount: taskStats.taskCount,
+        expectedRelevantFilesAverage: roundToTwo(taskStats.expectedRelevantFilesAverage),
+        expectedRelevantSymbolsAverage: roundToTwo(taskStats.expectedRelevantSymbolsAverage),
+        maxFileLines: fileLineCounts.length > 0 ? Math.max(...fileLineCounts) : 0,
+        averageFileLines: fileLineCounts.length > 0 ? roundToTwo(sum(fileLineCounts) / fileLineCounts.length) : 0,
+        packageDependencyCount: sum(fileEntries.map((entry) => countPackageDependencies(path.join(projectRoot, entry.path)))),
+        functionOrClassEstimate: sum(sourceEntries.map((entry) => countFunctionsOrClasses(path.join(projectRoot, entry.path))))
+    };
+    return metrics;
+}
+function normalize(value, cap) {
+    return Math.min(value / cap, 1);
+}
+function roundToTwo(value) {
+    return Math.round(value * 100) / 100;
+}
+function sum(values) {
+    return values.reduce((total, value) => total + value, 0);
+}
+function readLines(filePath) {
+    return readFileSync(filePath, "utf8").split(/\r?\n/);
+}
+function countApproximateCodeLines(filePath) {
+    return readLines(filePath).filter((line) => {
+        const trimmed = line.trim();
+        return trimmed.length > 0 && !trimmed.startsWith("//") && !trimmed.startsWith("#") && !trimmed.startsWith("*");
+    }).length;
+}
+function countInternalImports(filePath) {
+    return readLines(filePath).filter((line) => {
+        const trimmed = line.trim();
+        return (/^import\s+.*from\s+["']\./.test(trimmed) ||
+            /^import\s+["']\./.test(trimmed) ||
+            /require\(["']\./.test(trimmed) ||
+            /^from\s+\./.test(trimmed) ||
+            /^from\s+(task_|task|src|python)/.test(trimmed));
+    }).length;
+}
+function countExportedSymbols(filePath) {
+    const lines = readLines(filePath);
+    return lines.filter((line) => {
+        const trimmed = line.trim();
+        return (/^export\s+(function|class|const|let|var|type|interface)/.test(trimmed) ||
+            /^module\.exports\s*=/.test(trimmed) ||
+            /^exports\./.test(trimmed) ||
+            /^__all__\s*=/.test(trimmed) ||
+            /^(def|class)\s+\w+/.test(trimmed));
+    }).length;
+}
+function countFunctionsOrClasses(filePath) {
+    return readLines(filePath).filter((line) => /^(export\s+)?(async\s+)?function\s+\w+|^(export\s+)?class\s+\w+|^\s*(def|class)\s+\w+/.test(line.trim()))
+        .length;
+}
+function isDependencyFile(relativePath) {
+    const basename = path.posix.basename(relativePath);
+    return ["package.json", "package-lock.json", "requirements.txt", "pyproject.toml"].includes(basename);
+}
+function countPackageDependencies(filePath) {
+    if (path.basename(filePath) !== "package.json") {
+        return 0;
+    }
+    const parsed = JSON.parse(readFileSync(filePath, "utf8"));
+    return Object.keys(parsed.dependencies ?? {}).length + Object.keys(parsed.devDependencies ?? {}).length;
+}

package/dist/src/evaluation/projectFileTree.js

@@ -0,0 +1,83 @@
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+const EXCLUDED_SEGMENTS = new Set(["node_modules", "dist", "build", "coverage", "lab-output", ".git", "__pycache__"]);
+export function isExcludedProjectPath(relativePath) {
+    return relativePath.split(/[\\/]/).some((segment) => EXCLUDED_SEGMENTS.has(segment));
+}
+export function inferFileLanguage(filePath) {
+    const extension = path.extname(filePath).toLowerCase();
+    if (extension === ".ts")
+        return "typescript";
+    if (extension === ".js")
+        return "javascript";
+    if (extension === ".py")
+        return "python";
+    if (extension === ".json")
+        return "json";
+    if (extension === ".md")
+        return "markdown";
+    return undefined;
+}
+export function inferFileRole(relativePath, kind) {
+    const normalized = relativePath.replace(/\\/g, "/");
+    const basename = path.posix.basename(normalized).toLowerCase();
+    if (/(^|\/)(tests?|__tests__)(\/|$)/.test(normalized) || /\.test\.[tj]s$/.test(basename) || basename.startsWith("test_")) {
+        return "test";
+    }
+    if (/(^|\/)(src|python|py)(\/|$)/.test(normalized)) {
+        return "source";
+    }
+    if (basename === "readme.md" || basename.endsWith(".md")) {
+        return "docs";
+    }
+    if (["package.json", "package-lock.json", "tsconfig.json", "vitest.config.ts", "vitest.config.js", "requirements.txt", "pyproject.toml"].includes(basename)) {
+        return "config";
+    }
+    if (normalized.includes("contracts/")) {
+        return "contract";
+    }
+    return kind === "directory" ? "other" : "other";
+}
+export function countFileLines(filePath) {
+    const content = readFileSync(filePath, "utf8");
+    if (content.length === 0) {
+        return 0;
+    }
+    return content.split(/\r?\n/).length;
+}
+export function buildProjectFileTree(projectRoot) {
+    const root = path.resolve(projectRoot);
+    const entries = [];
+    function walk(currentDir) {
+        const dirEntries = readdirSync(currentDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of dirEntries) {
+            const fullPath = path.join(currentDir, entry.name);
+            const relativePath = path.relative(root, fullPath).replace(/\\/g, "/");
+            if (isExcludedProjectPath(relativePath)) {
+                continue;
+            }
+            if (entry.isDirectory()) {
+                entries.push({
+                    path: relativePath,
+                    kind: "directory",
+                    role: inferFileRole(relativePath, "directory")
+                });
+                walk(fullPath);
+                continue;
+            }
+            if (!entry.isFile()) {
+                continue;
+            }
+            entries.push({
+                path: relativePath,
+                kind: "file",
+                role: inferFileRole(relativePath, "file"),
+                language: inferFileLanguage(relativePath),
+                lines: countFileLines(fullPath)
+            });
+        }
+    }
+    statSync(root);
+    walk(root);
+    return { entries };
+}

package/dist/src/evaluation/readEvaluationCases.js

@@ -0,0 +1,59 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { resolveWithinRoot } from "../core/pathSafety.js";
+import { validateAnswerKey } from "./benchmarkMetadata.js";
+export async function readEvaluationCases(casesPath, repoRoot = process.cwd(), options = {}) {
+    let parsed;
+    try {
+        parsed = JSON.parse(await readFile(casesPath, "utf8"));
+    }
+    catch (error) {
+        throw new Error(`Failed to parse evaluation cases: ${error.message}`);
+    }
+    if (!Array.isArray(parsed)) {
+        throw new Error("Evaluation cases file must contain an array.");
+    }
+    const ids = new Set();
+    return parsed.map((value, index) => {
+        if (!value || typeof value !== "object") {
+            throw new Error(`Invalid evaluation case at index ${index}.`);
+        }
+        const candidate = value;
+        const requiredStringFields = ["id", "title", "benchmarkProject", "targetRoot", "query"];
+        for (const field of requiredStringFields) {
+            if (typeof candidate[field] !== "string" || candidate[field] === "") {
+                throw new Error(`Missing required field: ${field}`);
+            }
+        }
+        const requiredArrayFields = ["sourceRoots", "expectedFiles", "expectedSymbols", "rawIncludeGlobs"];
+        for (const field of requiredArrayFields) {
+            if (!Array.isArray(candidate[field])) {
+                throw new Error(`Missing required field: ${field}`);
+            }
+        }
+        const input = candidate;
+        if (ids.has(input.id)) {
+            throw new Error(`Duplicate evaluation case id: ${input.id}`);
+        }
+        ids.add(input.id);
+        if (candidate.answerKey !== undefined) {
+            const answerKeyErrors = validateAnswerKey(candidate.answerKey, `evaluation case ${input.id}`);
+            if (answerKeyErrors.length > 0) {
+                throw new Error(answerKeyErrors.join("\n"));
+            }
+        }
+        if (options.requireProjectProfileRef === true) {
+            if (typeof input.projectProfileRef !== "string" || input.projectProfileRef.length === 0) {
+                throw new Error(`evaluation case ${input.id}: missing projectProfileRef.`);
+            }
+            const profileIds = new Set((options.projectProfiles ?? []).map((profile) => profile.projectId));
+            if (!profileIds.has(input.projectProfileRef)) {
+                throw new Error(`evaluation case ${input.id}: unknown projectProfileRef ${input.projectProfileRef}.`);
+            }
+        }
+        return {
+            ...input,
+            absoluteTargetRoot: resolveWithinRoot(path.resolve(repoRoot), input.targetRoot)
+        };
+    });
+}

package/dist/src/evaluation/renderTokenSavingsReportInput.js

@@ -0,0 +1,55 @@
+export function renderTokenSavingsReportInput(options) {
+    return {
+        reportId: "token-savings-report",
+        title: "Token savings evaluation",
+        projectName: "my-dev-kit-lab",
+        benchmarkProject: "multiple",
+        workflowName: "raw full-file context vs my-dev-kit retrieval",
+        summary: "Estimated token comparison using static context size. Token counts use estimated_chars_div_4. This is not provider billing telemetry, and Codex and Claude telemetry are future work.",
+        steps: [
+            {
+                id: "load-cases",
+                label: "Load evaluation cases",
+                command: `--cases ${options.commandConfig.casesPath}`,
+                status: "pass",
+                notes: `${options.summary.caseCount} cases loaded.`
+            },
+            {
+                id: "run-raw-baseline",
+                label: "Run raw full-file baseline",
+                status: "pass",
+                notes: "Collected deterministic full-file context for each benchmark case."
+            },
+            {
+                id: "run-my-dev-kit",
+                label: "Run external my-dev-kit retrieval",
+                command: options.commandConfig.kitCommand,
+                status: options.summary.skippedCaseCount > 0 ? "skipped" : "pass",
+                notes: `${options.summary.completedCaseCount} completed, ${options.summary.skippedCaseCount} skipped.`
+            }
+        ],
+        metrics: [
+            { id: "token-count-method", label: "Token count method", value: options.summary.tokenCountMethod },
+            { id: "case-count", label: "Case count", value: options.summary.caseCount },
+            { id: "completed-case-count", label: "Completed case count", value: options.summary.completedCaseCount },
+            { id: "skipped-case-count", label: "Skipped case count", value: options.summary.skippedCaseCount },
+            { id: "average-raw-tokens", label: "Average raw tokens", value: options.summary.averageRawTokens.toFixed(2) },
+            { id: "average-my-dev-kit-tokens", label: "Average my-dev-kit tokens", value: options.summary.averageMyDevKitTokens.toFixed(2) },
+            { id: "average-tokens-saved", label: "Average tokens saved", value: options.summary.averageTokensSaved.toFixed(2) },
+            { id: "average-percent-saved", label: "Average percent saved", value: options.summary.averagePercentSaved.toFixed(2), unit: "%" },
+            { id: "total-commands-run", label: "Total commands run", value: options.summary.totalCommandsRun }
+        ],
+        artifacts: [
+            { id: "summary-json", label: "Token savings summary JSON", path: options.artifactPaths.summaryPath, kind: "json" },
+            { id: "runs-json", label: "Token savings runs JSON", path: options.artifactPaths.runsPath, kind: "json" },
+            { id: "report-html", label: "Token savings report HTML", path: options.artifactPaths.htmlPath, kind: "html" }
+        ],
+        warnings: [
+            "Token counts are estimated using estimated_chars_div_4.",
+            "This is a static context comparison.",
+            "This is not provider billing telemetry.",
+            "Codex and Claude telemetry are future work.",
+            ...options.warnings
+        ]
+    };
+}