@sanity/ailf 0.1.0

package/dist/pipeline/agent-behavior-report.d.ts

@@ -0,0 +1,53 @@
+/**
+ * pipeline/agent-behavior-report.ts
+ *
+ * Pure analysis functions for agent behavior observation reports.
+ * No I/O, no process.env, no process.argv — all data is passed in.
+ */
+import type { AgentBehaviorSummary } from "../agent-observer/types.js";
+export interface PromptfooResults {
+    results: TestResult[];
+}
+export interface PromptfooResultsEnvelope {
+    results: {
+        results: TestResult[];
+    };
+}
+export interface TestResult {
+    description: string;
+    metadata?: Record<string, unknown>;
+    response: {
+        output: string;
+    };
+    vars: Record<string, string>;
+}
+export interface TaskBehavior {
+    behavior: AgentBehaviorSummary;
+    description: string;
+    feature: string;
+    hasDocs: boolean;
+}
+export interface FeatureAnalysis {
+    allDocSlugs: string[];
+    allExternalDomains: string[];
+    allSearchQueries: string[];
+    avgDocPages: number;
+    avgNetworkMs: number;
+    avgSearches: number;
+    canonicalCoverage: number;
+    canonicalSlugs: string[];
+    feature: string;
+    tasks: TaskBehavior[];
+}
+export interface AnalysisResult {
+    features: FeatureAnalysis[];
+    hasData: boolean;
+    tasks: TaskBehavior[];
+}
+export declare const CANONICAL_DOC_MAP: Record<string, string[]>;
+export declare function detectFeatureArea(description: string): string;
+/**
+ * Analyze pre-parsed test results for agent behavior patterns.
+ * Caller is responsible for reading/parsing the file — this function is pure.
+ */
+export declare function analyzeResults(results: TestResult[]): AnalysisResult;

package/dist/pipeline/agent-behavior-report.js

@@ -0,0 +1,132 @@
+// ---------------------------------------------------------------------------
+// Canonical doc mapping
+// ---------------------------------------------------------------------------
+// Canonical doc mapping: task description patterns -> expected doc slugs
+// This maps what docs a well-informed agent *should* visit for each task
+export const CANONICAL_DOC_MAP = {
+    frameworks: [
+        "remix",
+        "nuxt",
+        "svelte",
+        "astro",
+        "gatsby",
+        "client-libraries",
+    ],
+    functions: [
+        "functions",
+        "webhooks",
+        "groq-powered-webhooks",
+        "event-driven",
+        "automations",
+    ],
+    "nextjs-live": [
+        "next-js",
+        "live-content-api",
+        "content-source-maps",
+        "app-router",
+        "groq",
+        "client-libraries",
+    ],
+    "studio-setup": [
+        "studio",
+        "schema-types",
+        "structure-builder",
+        "configuration",
+        "plugins",
+    ],
+    "visual-editing": [
+        "visual-editing",
+        "presentation",
+        "preview",
+        "overlays",
+        "loaders",
+    ],
+};
+// ---------------------------------------------------------------------------
+// Feature area detection
+// ---------------------------------------------------------------------------
+export function detectFeatureArea(description) {
+    const desc = description.toLowerCase();
+    if (desc.includes("studio"))
+        return "studio-setup";
+    if (desc.includes("visual") ||
+        desc.includes("presentation") ||
+        desc.includes("live preview"))
+        return "visual-editing";
+    if (desc.includes("function") || desc.includes("webhook"))
+        return "functions";
+    if (desc.includes("next") || desc.includes("app router"))
+        return "nextjs-live";
+    if (desc.includes("remix") ||
+        desc.includes("nuxt") ||
+        desc.includes("svelte"))
+        return "frameworks";
+    return "other";
+}
+// ---------------------------------------------------------------------------
+// Analysis
+// ---------------------------------------------------------------------------
+/**
+ * Analyze pre-parsed test results for agent behavior patterns.
+ * Caller is responsible for reading/parsing the file — this function is pure.
+ */
+export function analyzeResults(results) {
+    const tasks = [];
+    for (const result of results) {
+        const metadata = result.metadata;
+        if (!metadata?.agentBehaviorSummary)
+            continue;
+        const behavior = metadata.agentBehaviorSummary;
+        tasks.push({
+            behavior,
+            description: result.description,
+            feature: detectFeatureArea(result.description),
+            hasDocs: !!(result.vars.docs && result.vars.docs.trim().length > 0),
+        });
+    }
+    if (tasks.length === 0) {
+        return { features: [], hasData: false, tasks: [] };
+    }
+    // Group by feature
+    const byFeature = {};
+    for (const t of tasks) {
+        if (!byFeature[t.feature])
+            byFeature[t.feature] = [];
+        byFeature[t.feature].push(t);
+    }
+    const features = Object.entries(byFeature)
+        .map(([feature, featureTasks]) => {
+        const allDocSlugs = [
+            ...new Set(featureTasks.flatMap((t) => t.behavior.docSlugsVisited)),
+        ];
+        const allSearchQueries = [
+            ...new Set(featureTasks.flatMap((t) => t.behavior.uniqueSearchQueries)),
+        ];
+        const allExternalDomains = [
+            ...new Set(featureTasks.flatMap((t) => t.behavior.externalDomains)),
+        ];
+        const canonicalSlugs = CANONICAL_DOC_MAP[feature] || [];
+        const matchedCanonical = canonicalSlugs.filter((slug) => allDocSlugs.some((visited) => visited.includes(slug)));
+        const canonicalCoverage = canonicalSlugs.length > 0
+            ? matchedCanonical.length / canonicalSlugs.length
+            : 0;
+        const count = featureTasks.length || 1;
+        return {
+            allDocSlugs,
+            allExternalDomains,
+            allSearchQueries,
+            avgDocPages: featureTasks.reduce((s, t) => s + t.behavior.docPagesVisited, 0) /
+                count,
+            avgNetworkMs: featureTasks.reduce((s, t) => s + t.behavior.totalNetworkMs, 0) /
+                count,
+            avgSearches: featureTasks.reduce((s, t) => s + t.behavior.searchesPerformed, 0) /
+                count,
+            canonicalCoverage,
+            canonicalSlugs,
+            feature,
+            tasks: featureTasks,
+        };
+    })
+        .sort((a, b) => a.feature.localeCompare(b.feature));
+    return { features, hasData: true, tasks };
+}

package/dist/pipeline/attribution.d.ts

@@ -0,0 +1,47 @@
+/**
+ * pipeline/attribution.ts
+ *
+ * Per-document attribution for score changes.
+ *
+ * Given a ComparisonReport, a list of changed document slugs, and the
+ * resolved task mappings, this module classifies each task's score delta
+ * as unambiguous (one changed doc), ambiguous (multiple changed docs),
+ * or uncorrelated (no changed docs in the task's canonical set).
+ *
+ * This is Phase 1 of the hybrid attribution approach — zero additional
+ * eval cost, purely correlation-based. Phase 2 (targeted LOO) can be
+ * layered on top for ambiguous cases when higher precision is needed.
+ *
+ * @see docs/design-docs/scenario-matrix/per-document-attribution.md
+ * @see docs/exec-plans/completed/scenario-matrix-implementation/phase-2-impact-scenarios.md
+ */
+import type { AttributionReport, ComparisonReport } from "./types.js";
+import type { ResolvedMappings } from "./resolve-mappings.js";
+/**
+ * Attribute score changes to individual documents.
+ *
+ * For each area in the comparison report, cross-references the task's
+ * canonical_docs with the changed slugs to classify the attribution:
+ *
+ * - **unambiguous**: exactly 1 changed doc in the task's canonical set
+ * - **ambiguous**: 2+ changed docs in the task's canonical set
+ * - **uncorrelated**: 0 changed docs in the task's canonical set
+ *
+ * Tasks with deltas within the noise floor are still attributed but
+ * flagged as `withinNoiseFloor: true`.
+ *
+ * @param comparison - The structured comparison between before/after runs
+ * @param changedSlugs - Document slugs that changed
+ * @param mappings - Resolved task-to-canonical-docs mappings
+ * @param noiseThreshold - Deltas within ±this value are marked as noise
+ * @returns Attribution report with per-task classifications
+ */
+export declare function attributeChanges(comparison: ComparisonReport, changedSlugs: string[], mappings: ResolvedMappings, noiseThreshold: number): AttributionReport;
+/**
+ * Format an attribution report for console output.
+ */
+export declare function formatAttributionConsole(report: AttributionReport): string;
+/**
+ * Format an attribution report as markdown for PR comments.
+ */
+export declare function formatAttributionMarkdown(report: AttributionReport): string;

package/dist/pipeline/attribution.js

@@ -0,0 +1,226 @@
+/**
+ * pipeline/attribution.ts
+ *
+ * Per-document attribution for score changes.
+ *
+ * Given a ComparisonReport, a list of changed document slugs, and the
+ * resolved task mappings, this module classifies each task's score delta
+ * as unambiguous (one changed doc), ambiguous (multiple changed docs),
+ * or uncorrelated (no changed docs in the task's canonical set).
+ *
+ * This is Phase 1 of the hybrid attribution approach — zero additional
+ * eval cost, purely correlation-based. Phase 2 (targeted LOO) can be
+ * layered on top for ambiguous cases when higher precision is needed.
+ *
+ * @see docs/design-docs/scenario-matrix/per-document-attribution.md
+ * @see docs/exec-plans/completed/scenario-matrix-implementation/phase-2-impact-scenarios.md
+ */
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Attribute score changes to individual documents.
+ *
+ * For each area in the comparison report, cross-references the task's
+ * canonical_docs with the changed slugs to classify the attribution:
+ *
+ * - **unambiguous**: exactly 1 changed doc in the task's canonical set
+ * - **ambiguous**: 2+ changed docs in the task's canonical set
+ * - **uncorrelated**: 0 changed docs in the task's canonical set
+ *
+ * Tasks with deltas within the noise floor are still attributed but
+ * flagged as `withinNoiseFloor: true`.
+ *
+ * @param comparison - The structured comparison between before/after runs
+ * @param changedSlugs - Document slugs that changed
+ * @param mappings - Resolved task-to-canonical-docs mappings
+ * @param noiseThreshold - Deltas within ±this value are marked as noise
+ * @returns Attribution report with per-task classifications
+ */
+export function attributeChanges(comparison, changedSlugs, mappings, noiseThreshold) {
+    const changedSet = new Set(changedSlugs);
+    const attributions = [];
+    // Build a flat list of all tasks from the mappings
+    const taskCanonicalDocs = new Map();
+    for (const [area, config] of Object.entries(mappings.feature_areas)) {
+        for (const task of config.tasks) {
+            taskCanonicalDocs.set(task.id, {
+                area,
+                slugs: task.canonical_docs.map((d) => d.slug),
+            });
+        }
+    }
+    // For each area in the comparison, attribute the delta
+    for (const areaDelta of comparison.areas) {
+        // Find tasks in this area
+        const areaTasks = [...taskCanonicalDocs.entries()].filter(([, info]) => info.area === areaDelta.area);
+        if (areaTasks.length === 0) {
+            // Area exists in comparison but has no tasks in mappings
+            // (shouldn't happen in practice, but handle gracefully)
+            continue;
+        }
+        // For area-level attribution: check which changed docs overlap
+        // with any task's canonical docs in this area
+        const areaCanonicalSlugs = new Set(areaTasks.flatMap(([, info]) => info.slugs));
+        const matchingSlugs = changedSlugs.filter((s) => areaCanonicalSlugs.has(s));
+        // Classify each task
+        for (const [taskId, taskInfo] of areaTasks) {
+            const taskMatchingSlugs = taskInfo.slugs.filter((s) => changedSet.has(s));
+            const classification = classifyAttribution(taskMatchingSlugs.length);
+            attributions.push({
+                area: taskInfo.area,
+                attributedDocs: taskMatchingSlugs,
+                classification,
+                delta: areaDelta.delta,
+                taskId,
+                withinNoiseFloor: Math.abs(areaDelta.delta) <= noiseThreshold,
+            });
+        }
+        // If no task-level matches but area has a delta, record area-level
+        if (areaTasks.length > 0 && matchingSlugs.length === 0) {
+            // All tasks in this area are uncorrelated — already handled above
+        }
+    }
+    // Find untracked documents: changed slugs not in ANY task's canonical docs
+    const allTrackedSlugs = new Set([...taskCanonicalDocs.values()].flatMap((info) => info.slugs));
+    const untrackedDocs = changedSlugs
+        .filter((s) => !allTrackedSlugs.has(s))
+        .sort();
+    // Compute summary counts
+    const summary = {
+        ambiguous: attributions.filter((a) => a.classification === "ambiguous")
+            .length,
+        unambiguous: attributions.filter((a) => a.classification === "unambiguous")
+            .length,
+        uncorrelated: attributions.filter((a) => a.classification === "uncorrelated").length,
+        withinNoise: attributions.filter((a) => a.withinNoiseFloor).length,
+    };
+    return {
+        attributions,
+        summary,
+        untrackedDocs,
+    };
+}
+// ---------------------------------------------------------------------------
+// Formatting
+// ---------------------------------------------------------------------------
+/**
+ * Format an attribution report for console output.
+ */
+export function formatAttributionConsole(report) {
+    const lines = [];
+    lines.push("📋 PER-DOCUMENT ATTRIBUTION");
+    lines.push("");
+    // Unambiguous attributions
+    const unambiguous = report.attributions.filter((a) => a.classification === "unambiguous");
+    if (unambiguous.length > 0) {
+        lines.push(`Unambiguous (${unambiguous.length} tasks):`);
+        for (const a of unambiguous) {
+            const noiseTag = a.withinNoiseFloor ? " ⚠️ within noise" : "";
+            const deltaStr = a.delta > 0 ? `+${Math.round(a.delta)}` : String(Math.round(a.delta));
+            lines.push(`  ${a.taskId}: ${deltaStr} → ${a.attributedDocs[0]}${noiseTag}`);
+        }
+        lines.push("");
+    }
+    // Ambiguous attributions
+    const ambiguous = report.attributions.filter((a) => a.classification === "ambiguous");
+    if (ambiguous.length > 0) {
+        lines.push(`Ambiguous (${ambiguous.length} tasks):`);
+        for (const a of ambiguous) {
+            const noiseTag = a.withinNoiseFloor ? " ⚠️ within noise" : "";
+            const deltaStr = a.delta > 0 ? `+${Math.round(a.delta)}` : String(Math.round(a.delta));
+            lines.push(`  ${a.taskId}: ${deltaStr} → {${a.attributedDocs.join(", ")}}${noiseTag}`);
+        }
+        lines.push("");
+    }
+    // Uncorrelated
+    const uncorrelated = report.attributions.filter((a) => a.classification === "uncorrelated" && !a.withinNoiseFloor);
+    if (uncorrelated.length > 0) {
+        lines.push(`Uncorrelated (${uncorrelated.length} tasks):`);
+        for (const a of uncorrelated) {
+            const deltaStr = a.delta > 0 ? `+${Math.round(a.delta)}` : String(Math.round(a.delta));
+            lines.push(`  ${a.taskId}: ${deltaStr} → likely grader variance (no changed docs in canonical set)`);
+        }
+        lines.push("");
+    }
+    // Untracked documents
+    if (report.untrackedDocs.length > 0) {
+        lines.push("Untracked documents:");
+        for (const doc of report.untrackedDocs) {
+            lines.push(`  ${doc} — not in any task's canonical_docs`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+/**
+ * Format an attribution report as markdown for PR comments.
+ */
+export function formatAttributionMarkdown(report) {
+    const lines = [];
+    lines.push("### 📋 Per-Document Attribution");
+    lines.push("");
+    if (report.attributions.length === 0 && report.untrackedDocs.length === 0) {
+        lines.push("No attribution data available.");
+        lines.push("");
+        return lines.join("\n");
+    }
+    // Summary
+    const { ambiguous, unambiguous, uncorrelated, withinNoise } = report.summary;
+    const parts = [];
+    if (unambiguous > 0)
+        parts.push(`${unambiguous} unambiguous`);
+    if (ambiguous > 0)
+        parts.push(`${ambiguous} ambiguous`);
+    if (uncorrelated > 0)
+        parts.push(`${uncorrelated} uncorrelated`);
+    if (withinNoise > 0)
+        parts.push(`${withinNoise} within noise`);
+    if (parts.length > 0) {
+        lines.push(`**${parts.join(" · ")}**`);
+        lines.push("");
+    }
+    // Attribution table
+    const hasAttributions = report.attributions.some((a) => a.delta !== 0);
+    if (hasAttributions) {
+        lines.push("| Task | Area | Delta | Attribution | Documents |");
+        lines.push("|------|------|-------|-------------|-----------|");
+        for (const a of report.attributions) {
+            if (a.delta === 0 && a.classification === "uncorrelated")
+                continue;
+            const deltaStr = a.delta > 0 ? `+${Math.round(a.delta)}` : String(Math.round(a.delta));
+            const noiseIcon = a.withinNoiseFloor ? " ⚠️" : "";
+            const classIcon = a.classification === "unambiguous"
+                ? "✅"
+                : a.classification === "ambiguous"
+                    ? "🟡"
+                    : "❓";
+            const docs = a.attributedDocs.length > 0
+                ? a.attributedDocs.map((d) => `\`${d}\``).join(", ")
+                : "—";
+            lines.push(`| ${a.taskId} | ${a.area} | ${deltaStr}${noiseIcon} | ${classIcon} ${a.classification} | ${docs} |`);
+        }
+        lines.push("");
+    }
+    // Untracked documents
+    if (report.untrackedDocs.length > 0) {
+        lines.push("**Untracked documents** (not in any task's canonical_docs):");
+        lines.push("");
+        for (const doc of report.untrackedDocs) {
+            lines.push(`- \`${doc}\``);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Classify attribution based on the number of matching changed documents */
+function classifyAttribution(matchCount) {
+    if (matchCount === 0)
+        return "uncorrelated";
+    if (matchCount === 1)
+        return "unambiguous";
+    return "ambiguous";
+}

package/dist/pipeline/baseline.d.ts

@@ -0,0 +1,37 @@
+/**
+ * pipeline/baseline.ts
+ *
+ * Pure computation functions for managing historical baseline snapshots of
+ * evaluation scores. All functions accept `rootDir` as their first parameter
+ * and perform no process.env / process.argv access.
+ */
+export interface BaselineMetadata {
+    areaCount: number;
+    avgScore: number;
+    filename: string;
+    graderCost?: number;
+    tag?: string;
+    timestamp: string;
+    totalCost?: number;
+}
+export interface CompareResult {
+    comparisons?: ScoreComparison[];
+    message: string;
+    overallDelta?: number;
+    success: boolean;
+}
+export interface ScoreComparison {
+    baseline: number;
+    costBaseline?: number;
+    costCurrent?: number;
+    costDelta?: number;
+    current: number;
+    delta: number;
+    feature: string;
+}
+export declare function compareBaseline(rootDir: string, baselineFile?: string): CompareResult;
+export declare function listBaselines(rootDir: string): BaselineMetadata[];
+export declare function saveBaseline(rootDir: string, tag?: string): {
+    success: boolean;
+    message: string;
+};

package/dist/pipeline/baseline.js

@@ -0,0 +1,141 @@
+/**
+ * pipeline/baseline.ts
+ *
+ * Pure computation functions for managing historical baseline snapshots of
+ * evaluation scores. All functions accept `rootDir` as their first parameter
+ * and perform no process.env / process.argv access.
+ */
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, } from "fs";
+import { join } from "path";
+// ---------------------------------------------------------------------------
+// Compare
+// ---------------------------------------------------------------------------
+export function compareBaseline(rootDir, baselineFile) {
+    const baselinesDir = join(rootDir, "results", "baselines");
+    const scoreSummaryPath = join(rootDir, "results", "latest", "score-summary.json");
+    if (!existsSync(scoreSummaryPath)) {
+        return {
+            message: "No current score-summary.json found.",
+            success: false,
+        };
+    }
+    // Find baseline to compare against
+    const baselines = listBaselines(rootDir);
+    if (baselines.length === 0) {
+        return {
+            message: "No baselines saved yet. Run 'pnpm baseline:save' first.",
+            success: false,
+        };
+    }
+    const targetFile = baselineFile ?? baselines[0].filename;
+    const baselinePath = join(baselinesDir, targetFile);
+    if (!existsSync(baselinePath)) {
+        return {
+            message: `Baseline file not found: ${targetFile}`,
+            success: false,
+        };
+    }
+    const current = JSON.parse(readFileSync(scoreSummaryPath, "utf-8"));
+    const baseline = JSON.parse(readFileSync(baselinePath, "utf-8"));
+    const baselineMap = new Map(baseline.scores.map((s) => [s.feature, s.totalScore]));
+    const baselineCostMap = new Map(baseline.scores.map((s) => [s.feature, s.totalCost ?? 0]));
+    const comparisons = current.scores.map((s) => {
+        const baseScore = baselineMap.get(s.feature) ?? 0;
+        const currentCost = s.totalCost ?? 0;
+        const baseCost = baselineCostMap.get(s.feature) ?? 0;
+        return {
+            baseline: baseScore,
+            costBaseline: baseCost > 0 ? baseCost : undefined,
+            costCurrent: currentCost > 0 ? currentCost : undefined,
+            costDelta: currentCost > 0 || baseCost > 0 ? currentCost - baseCost : undefined,
+            current: s.totalScore,
+            delta: s.totalScore - baseScore,
+            feature: s.feature,
+        };
+    });
+    // Check for areas in baseline but not in current
+    for (const [feature, score] of baselineMap) {
+        if (!comparisons.find((c) => c.feature === feature)) {
+            comparisons.push({
+                baseline: score,
+                current: 0,
+                delta: -score,
+                feature,
+            });
+        }
+    }
+    comparisons.sort((a, b) => b.delta - a.delta);
+    const overallDelta = Math.round(current.overall.avgScore) - Math.round(baseline.overall.avgScore);
+    return {
+        comparisons,
+        message: `Compared against ${targetFile}`,
+        overallDelta,
+        success: true,
+    };
+}
+// ---------------------------------------------------------------------------
+// List
+// ---------------------------------------------------------------------------
+export function listBaselines(rootDir) {
+    const baselinesDir = join(rootDir, "results", "baselines");
+    if (!existsSync(baselinesDir)) {
+        return [];
+    }
+    const files = readdirSync(baselinesDir)
+        .filter((f) => f.endsWith(".json"))
+        .sort()
+        .reverse(); // Newest first
+    return files.map((filename) => {
+        const raw = readFileSync(join(baselinesDir, filename), "utf-8");
+        const data = JSON.parse(raw);
+        return {
+            areaCount: data.scores.length,
+            avgScore: Math.round(data.overall.avgScore),
+            filename,
+            graderCost: data.overall.cost?.graderTotal,
+            tag: data.baselineMeta?.tag,
+            timestamp: data.timestamp,
+            totalCost: data.overall.cost?.total,
+        };
+    });
+}
+// ---------------------------------------------------------------------------
+// Save
+// ---------------------------------------------------------------------------
+export function saveBaseline(rootDir, tag) {
+    const baselinesDir = join(rootDir, "results", "baselines");
+    const scoreSummaryPath = join(rootDir, "results", "latest", "score-summary.json");
+    if (!existsSync(scoreSummaryPath)) {
+        return {
+            message: "No score-summary.json found. Run 'pnpm calculate-scores' first.",
+            success: false,
+        };
+    }
+    const raw = readFileSync(scoreSummaryPath, "utf-8");
+    const summary = JSON.parse(raw);
+    mkdirSync(baselinesDir, { recursive: true });
+    // Generate filename: YYYY-MM-DD_HHmmss[_tag].json
+    const now = new Date();
+    const datePart = now
+        .toISOString()
+        .slice(0, 19)
+        .replace(/[T:]/g, "_")
+        .replace(/-/g, "");
+    const tagPart = tag
+        ? `_${tag.replace(/[^a-z0-9-]/gi, "-").toLowerCase()}`
+        : "";
+    const filename = `${datePart}${tagPart}.json`;
+    const baseline = {
+        ...summary,
+        baselineMeta: {
+            savedAt: now.toISOString(),
+            // oxlint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- empty string tag should be treated as no tag
+            tag: tag || undefined,
+        },
+    };
+    writeFileSync(join(baselinesDir, filename), JSON.stringify(baseline, null, 2));
+    return {
+        message: `Saved baseline to results/baselines/${filename} (avg: ${Math.round(summary.overall.avgScore)}, ${summary.scores.length} areas)`,
+        success: true,
+    };
+}