@sanity/ailf-studio 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,703 @@
+import * as sanity from 'sanity';
+import { DocumentActionComponent, ReleaseActionComponent, Tool } from 'sanity';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { DocumentRef } from './document-ref.js';
+
+/**
+ * actions/GraduateToNativeAction.tsx
+ *
+ * Sanity Studio document action that "graduates" a mirrored task to
+ * a native task by removing the `origin` field.
+ *
+ * This is a one-way, irreversible operation. Once graduated:
+ * - The task becomes fully editable in Studio
+ * - Future pipeline mirror syncs will NOT overwrite it (the mirror
+ *   uses createOrReplace with the same _id, but since origin is gone,
+ *   the document-level readOnly check returns false and the task
+ *   behaves like any other native task)
+ * - The task's _id is unchanged — it keeps the mirror prefix
+ *   (ailf.task.mirror.*) but that's just an ID string, not a
+ *   behavioral marker
+ *
+ * The action only appears on ailf.task documents that have an `origin`
+ * field (i.e., mirrored tasks). Native tasks never see it.
+ *
+ * @see docs/exec-plans/active/tasks-as-content/phase-5-content-lake-mirroring.md
+ */
+
+declare const GraduateToNativeAction: DocumentActionComponent;
+
+/**
+ * components/MirrorBanner.tsx
+ *
+ * Informational banner shown at the top of mirrored task documents.
+ * Communicates that the task is managed in an external repo and links
+ * to the source file on GitHub.
+ *
+ * Paired with `SyncStatusBadge` to show both the source and freshness
+ * of the mirror.
+ *
+ * @see docs/exec-plans/active/tasks-as-content/phase-5-content-lake-mirroring.md
+ */
+interface MirrorBannerProps {
+    origin: {
+        repo?: string;
+        repoOwner?: string;
+        repoName?: string;
+        path?: string;
+        branch?: string;
+        commitSha?: string;
+        lastSyncedAt?: string;
+    };
+}
+declare function MirrorBanner({ origin }: MirrorBannerProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * components/SyncStatusBadge.tsx
+ *
+ * Displays the sync freshness of a mirrored task as a colored badge.
+ * Green = recently synced, yellow = getting stale, red = outdated.
+ *
+ * Uses the `origin.lastSyncedAt` timestamp that the pipeline sets
+ * on every mirror upsert (Phase 5a).
+ *
+ * @see docs/exec-plans/active/tasks-as-content/phase-5-content-lake-mirroring.md
+ */
+interface SyncStatusBadgeProps {
+    /** ISO 8601 timestamp from origin.lastSyncedAt */
+    lastSyncedAt: string;
+    /** Optional: show the commit SHA alongside the badge */
+    commitSha?: string;
+    /** Font size (default: 0 for compact list view) */
+    fontSize?: 0 | 1;
+}
+declare function SyncStatusBadge({ lastSyncedAt, commitSha, fontSize, }: SyncStatusBadgeProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * actions/RunEvaluationAction.tsx
+ *
+ * Sanity Studio release action that triggers an AILF evaluation
+ * for a content release. Appears as a button in the release detail
+ * page's action bar.
+ *
+ * Uses the `releases.actions` extension point (Sanity v5) — follows
+ * the same composable pattern as `document.actions`.
+ *
+ * ## Security model
+ *
+ * This component does NOT hold any secrets. Instead of calling
+ * GitHub Actions directly (which would require a PAT in the browser
+ * bundle), it creates an `ailf.evalRequest` document in the Content
+ * Lake. A server-side Sanity webhook watches for these documents and
+ * dispatches the GitHub Actions pipeline — the GitHub token lives
+ * only on the server.
+ *
+ * ## Feedback model
+ *
+ * - On mount, queries for any existing report for this perspective
+ * - If a previous result exists, shows score in the button label
+ * - After creating the request, watches the eval request doc for
+ *   status changes and polls for the resulting report
+ * - Score persists in the button label (no auto-reset)
+ * - Tooltip provides full context at every stage
+ *
+ * @see packages/eval/src/webhook/eval-request-handler.ts
+ * @see .github/workflows/external-eval.yml
+ */
+
+interface RunEvaluationActionOptions {
+    /** Evaluation mode (default: "baseline") */
+    mode?: "agentic" | "baseline" | "full" | "observed";
+}
+/**
+ * Create a release action component that requests AILF evaluations.
+ *
+ * When the user clicks the button, the action creates an `ailf.evalRequest`
+ * document in the Content Lake. A server-side Sanity webhook picks up
+ * the document and dispatches a GitHub Actions pipeline — no secrets
+ * are needed in the browser.
+ *
+ * The action automatically reads the dataset and project ID from the
+ * Studio's workspace context, so the pipeline queries the same Content
+ * Lake the editor is working in.
+ *
+ * On mount it queries for the most recent report matching this release's
+ * perspective. If one exists, the button shows the score immediately —
+ * the user can see the current AI literacy score before deciding whether
+ * to re-run.
+ *
+ * Usage in `sanity.config.ts`:
+ * ```ts
+ * import { createRunEvaluationAction } from "@sanity/ailf-studio"
+ *
+ * export default defineConfig({
+ *   // ...
+ *   releases: {
+ *     actions: (prev) => [
+ *       ...prev,
+ *       createRunEvaluationAction(),
+ *     ],
+ *   },
+ * })
+ * ```
+ */
+declare function createRunEvaluationAction(options?: RunEvaluationActionOptions): ReleaseActionComponent;
+
+/**
+ * glossary.ts
+ *
+ * Centralized tooltip descriptions for all evaluation metrics.
+ *
+ * Every user-facing metric label in the Studio dashboard should use
+ * a description from this file. This ensures consistent wording across
+ * stat cards, table headers, and comparison views.
+ *
+ * @see docs/design-docs/scenario-matrix/evaluation-ceiling.md (three reference points)
+ * @see docs/ARCHITECTURE.md (scoring model)
+ */
+declare const GLOSSARY: {
+    readonly overallScore: "A weighted average across all feature areas: Task Completion (50%), Code Correctness (25%), and Doc Coverage (25%).";
+    readonly docLift: "How much the docs help, compared to the model's training data alone. This is the score with docs minus the score without. Higher is better.";
+    readonly actualScore: "How well an AI agent scores when it has to find docs on its own through web search and page fetching. This is the real-world scenario. Only available in full mode.";
+    readonly retrievalGap: "The score lost because agents can't find or use all the relevant docs. Calculated as ceiling minus actual. Lower is better; zero means agents find everything.";
+    readonly infraEfficiency: "What percentage of the docs' potential quality actually reaches agents (actual ÷ ceiling). 100% means agents find and use all relevant docs perfectly.";
+    readonly floor: "Score without any documentation. This tells you what the model already knows from its training data.";
+    readonly ceiling: "Score with gold-standard docs injected directly into the prompt. This is the best the documentation can do.";
+    readonly actual: "Score when an AI agent finds docs on its own through web search and page fetching. This is the real-world experience.";
+    readonly retGap: "Quality lost to discoverability (ceiling minus actual). The gap between what the docs could deliver and what agents actually get.";
+    readonly efficiency: "What fraction of the docs' quality reaches agents in practice (actual ÷ ceiling, shown as a percentage).";
+    readonly invertedRetGap: "⚠️ Inverted retrieval gap: agents that can't find the docs actually score higher, because the docs hurt performance. This usually means there's a doc quality problem.";
+    readonly score: "Weighted score for this feature area: Task Completion × 50% + Code Correctness × 25% + Doc Coverage × 25%.";
+    readonly taskCompletion: "Can the LLM implement the requested feature? Graded 0–100.";
+    readonly codeCorrectness: "Is the generated code idiomatic, correct, and following best practices? Graded 0–100.";
+    readonly docCoverage: "Did the docs provide the information needed to implement the feature? Graded 0–100.";
+    readonly tests: "Number of test cases in this feature area.";
+    readonly overallDelta: "Change in overall score between the two runs. Positive means the experiment scored higher.";
+    readonly actualDelta: "Change in actual (agent-retrieved) score between runs. Positive means agents did better.";
+    readonly retGapDelta: "Change in retrieval gap between runs. Negative is good here: it means the gap shrank and agents found more relevant docs.";
+    readonly efficiencyDelta: "Change in infrastructure efficiency between runs. Positive means agents are capturing more of the docs' potential.";
+    readonly baseline: "The reference run you're comparing against.";
+    readonly experiment: "The new run you're evaluating.";
+    readonly delta: "Difference between experiment and baseline. Positive means improvement, negative means regression.";
+    readonly change: "Whether the change is meaningful: improved, regressed, or unchanged (within the noise threshold).";
+    readonly lowScoringJudgments: "The grading model's explanations for tests that scored below 70/100.";
+    readonly judgmentReason: "The grading model's natural language explanation of what went wrong.";
+    readonly recommendations: "Prioritized remediation plan from gap analysis. Each recommendation identifies a documentation problem, the affected feature area, and the estimated score lift from fixing it.";
+    readonly totalPotentialLift: "Aggregate potential score lift if all identified gaps were fixed. This is a conservative estimate — each gap targets the median of non-bottlenecked dimensions, not 100.";
+    readonly failureMode: "The type of documentation problem: missing-docs (functionality not covered), incorrect-docs (factual errors), outdated-docs (stale API/patterns), or poor-structure (hard to find/understand).";
+    readonly estimatedLift: "Estimated composite score improvement if this gap is fully fixed. Based on raising bottleneck dimensions to the median of non-bottlenecked dimensions.";
+    readonly confidence: "How confident the classifier is in this diagnosis. High = strong keyword + structural signal agreement. Medium = partial agreement. Low = weak signals only.";
+    readonly dimTaskCompletion: "Change in task completion between runs. Positive means implementations are more complete.";
+    readonly dimCodeCorrectness: "Change in code correctness between runs. Positive means better code quality.";
+    readonly dimDocCoverage: "Change in doc coverage between runs. Positive means the docs are providing more useful information.";
+};
+
+/**
+ * queries.ts
+ *
+ * GROQ queries for the AILF Studio dashboard.
+ *
+ * All dashboard views are powered by GROQ — no backend needed.
+ * These queries run directly against the Sanity Content Lake using
+ * the Studio's built-in client.
+ *
+ * @see docs/design-docs/report-store/architecture.md — Query capabilities
+ */
+/**
+ * Fetch the N most recent reports, optionally filtered by source and/or mode.
+ *
+ * Used by: LatestReports view, Dashboard overview
+ */
+declare const latestReportsQuery: string;
+/**
+ * Fetch score data points for a time range, projected into a chart-friendly shape.
+ *
+ * Used by: ScoreTimeline view
+ */
+declare const scoreTimelineQuery: string;
+/**
+ * Fetch a single report by ID with full detail.
+ *
+ * Used by: ReportDetail view
+ */
+declare const reportDetailQuery = "\n  *[_type == \"ailf.report\" && reportId == $reportId][0] {\n    _id,\n    reportId,\n    completedAt,\n    durationMs,\n    tag,\n    provenance,\n    summary,\n    comparison\n  }\n";
+/**
+ * Find all reports that evaluated a specific Sanity document or perspective.
+ *
+ * Used by: ContentImpact view (answer: "what did my edit do to scores?")
+ *
+ * Supports optional source/mode filtering via the shared filter helpers.
+ * When $documentId and $perspective are both null, the filter clause
+ * `(null in [] || ...)` evaluates to false — callers should use
+ * `recentDocumentEvalsQuery` for the browse-mode (no search) case.
+ */
+declare const contentImpactQuery: string;
+/**
+ * Browse recent reports that have document-level targeting or perspectives.
+ *
+ * Used by: ContentImpact view browse mode (no search active).
+ * Shows the most recent document-scoped evaluations to help users discover
+ * what content has been evaluated recently.
+ */
+declare const recentDocumentEvalsQuery: string;
+/** All unique targetDocuments across reports (for autocomplete) */
+declare const distinctTargetDocumentsQuery = "\n  array::unique(*[_type == \"ailf.report\" && defined(provenance.targetDocuments)].provenance.targetDocuments[])\n";
+/**
+ * Search articles by title, slug, or _id.
+ *
+ * Used by: ContentImpact document search autocomplete.
+ * Returns a lightweight projection for the dropdown — title, slug, section path, and _id.
+ * The `score()` function ranks title matches highest, then slug, then _id.
+ *
+ * Includes all document versions (published, drafts, perspectives) so the UI
+ * can show provenance badges. The `_id` prefix determines the version type:
+ * - No prefix → published (production)
+ * - `drafts.` → unpublished draft
+ * - `versions.<perspectiveId>.` → content release perspective
+ */
+declare const articleSearchQuery = "\n  *[_type == \"article\"\n    && (\n      title match $query + \"*\"\n      || slug.current match $query + \"*\"\n      || _id match $query + \"*\"\n    )\n  ] | score(\n    boost(title match $query + \"*\", 3),\n    boost(slug.current match $query + \"*\", 2),\n    boost(_id match $query + \"*\", 1)\n  ) [0...40] {\n    _id,\n    title,\n    \"slug\": slug.current,\n    \"section\": primarySection->{ \"slug\": slug.current, \"title\": title }\n  }\n";
+/** All unique perspectives across reports (for autocomplete) */
+declare const distinctPerspectivesQuery = "\n  array::unique(*[_type == \"ailf.report\" && defined(provenance.source.perspective)].provenance.source.perspective)\n";
+/**
+ * Fetch two reports by their IDs for comparison.
+ *
+ * Used by: ComparisonView — user selects two reports to compare
+ */
+declare const comparisonPairQuery = "\n  *[_type == \"ailf.report\" && reportId in [$baselineId, $experimentId]] {\n    _id,\n    reportId,\n    completedAt,\n    tag,\n    provenance,\n    summary\n  }\n";
+/** All unique source names (for filter dropdowns) */
+declare const distinctSourcesQuery = "\n  array::unique(*[_type == \"ailf.report\"].provenance.source.name)\n";
+/** All unique modes (for filter dropdowns) */
+declare const distinctModesQuery = "\n  array::unique(*[_type == \"ailf.report\"].provenance.mode)\n";
+/** All unique feature areas (for filter dropdowns) */
+declare const distinctAreasQuery = "\n  array::unique(*[_type == \"ailf.report\"].provenance.areas[])\n";
+
+/**
+ * schema/eval-request.ts
+ *
+ * Sanity document schema for `ailf.evalRequest` — an intent document that
+ * requests an evaluation pipeline run.
+ *
+ * The Studio creates this document programmatically (e.g. from the release
+ * action component). A Sanity webhook watches for new `ailf.evalRequest`
+ * documents with `status == "pending"` and dispatches a GitHub Actions
+ * workflow. The webhook handler updates `status` to "dispatched", and a
+ * callback from the pipeline sets it to "completed" or "failed".
+ *
+ * Intent documents are immutable — all fields are `readOnly: true`. The
+ * document is created once and only updated server-side by the webhook
+ * handler or pipeline callback.
+ */
+declare const evalRequestSchema: {
+    type: "document";
+    name: "ailf.evalRequest";
+} & Omit<sanity.DocumentDefinition, "preview"> & {
+    preview?: sanity.PreviewConfig<{
+        perspective: string;
+        status: string;
+    }, Record<string, unknown>> | undefined;
+};
+
+/**
+ * schema/feature-area.ts
+ *
+ * Sanity document schema for `ailf.featureArea` — a feature area that groups
+ * related evaluation tasks for score aggregation and filtering.
+ *
+ * Feature areas are lightweight metadata documents. They exist primarily to
+ * provide referential integrity (tasks reference areas by document reference
+ * instead of plain strings) and to enable Studio-based browsing/filtering.
+ *
+ * Initial areas (migrated from YAML filenames): groq, frameworks, functions,
+ * nextjs-live, studio-setup, visual-editing.
+ *
+ * @see docs/design-docs/tasks-as-content.md
+ */
+declare const featureAreaSchema: {
+    type: "document";
+    name: "ailf.featureArea";
+} & Omit<sanity.DocumentDefinition, "preview"> & {
+    preview?: sanity.PreviewConfig<{
+        areaId: string;
+        description: string;
+    }, Record<string, unknown>> | undefined;
+};
+
+/**
+ * schema/reference-solution.ts
+ *
+ * Sanity document schema for `ailf.referenceSolution` — a gold-standard
+ * implementation that demonstrates the correct approach for a task.
+ *
+ * Reference solutions contain code blocks and prose explaining why the
+ * approach is correct. They are referenced by `ailf.task` documents.
+ *
+ * @see docs/design-docs/tasks-as-content.md
+ */
+declare const referenceSolutionSchema: {
+    type: "document";
+    name: "ailf.referenceSolution";
+} & Omit<sanity.DocumentDefinition, "preview"> & {
+    preview?: sanity.PreviewConfig<{
+        language: string;
+        title: string;
+    }, Record<string, unknown>> | undefined;
+};
+
+/**
+ * schema/report.ts
+ *
+ * Sanity document schema for `ailf.report` — the persisted evaluation report.
+ *
+ * This schema defines how reports appear in Sanity Studio and enables
+ * GROQ queries for the dashboard. The document shape mirrors the
+ * `Report` type in `packages/eval/src/pipeline/types.ts`.
+ *
+ * Reports are immutable events (P1) — once created, they should not be
+ * edited. The schema uses `readOnly: true` on all fields to enforce this.
+ *
+ * @see docs/design-docs/report-store/domain-model.md
+ * @see docs/design-docs/report-store/architecture.md
+ */
+declare const reportSchema: {
+    type: "document";
+    name: "ailf.report";
+} & Omit<sanity.DocumentDefinition, "preview"> & {
+    preview?: sanity.PreviewConfig<{
+        completedAt: string;
+        mode: string;
+        overall: string;
+        tag: string;
+    }, Record<string, unknown>> | undefined;
+};
+
+/**
+ * schema/task.ts
+ *
+ * Sanity document schema for `ailf.task` — an evaluation task definition.
+ *
+ * This is the core unit of the AI Literacy Framework. A task defines:
+ * - What the LLM should implement (the task prompt)
+ * - Which docs are relevant (canonical doc references)
+ * - How to grade the output (assertions with rubric templates)
+ * - A gold-standard implementation (reference solution)
+ * - When/how the task runs (execution controls)
+ *
+ * Tasks can be authored natively in Studio or mirrored from external
+ * repositories. Mirrored tasks have a read-only `origin` block that
+ * tracks their source repo provenance.
+ *
+ * @see docs/design-docs/tasks-as-content.md
+ * @see docs/design-docs/tasks-as-content.md#decision-8-domain-specific-assertion-types-not-a-promptfoo-subset
+ */
+declare const taskSchema: {
+    type: "document";
+    name: "ailf.task";
+} & Omit<sanity.DocumentDefinition, "preview"> & {
+    preview?: sanity.PreviewConfig<{
+        area: string;
+        description: string;
+        id: string;
+        origin: string;
+    }, Record<string, unknown>> | undefined;
+};
+
+/**
+ * schema/webhook-config.ts
+ *
+ * Sanity document schema for `ailf.webhookConfig` — the "evaluate on publish"
+ * toggle and webhook-triggered evaluation settings.
+ *
+ * This is a singleton document (only one should exist) that controls
+ * whether content changes automatically trigger evaluation pipelines.
+ *
+ * @see docs/design-docs/report-store/visibility-workflows.md
+ */
+declare const webhookConfigSchema: {
+    type: "document";
+    name: "ailf.webhookConfig";
+} & Omit<sanity.DocumentDefinition, "preview"> & {
+    preview?: sanity.PreviewConfig<{
+        enabled: string;
+    }, Record<string, unknown>> | undefined;
+};
+
+/**
+ * tool.tsx
+ *
+ * Sanity Studio tool definition for the AILF dashboard.
+ *
+ * Registers as a top-level Studio tool accessible from the sidebar.
+ * Defines URL-based routing so each view is bookmarkable and
+ * supports browser back/forward navigation.
+ *
+ * Route structure:
+ *   /ai-literacy                        → Latest Reports (home)
+ *   /ai-literacy/report/:reportId       → Report Detail
+ *   /ai-literacy/timeline               → Score Timeline
+ *   /ai-literacy/compare                → Compare
+ */
+
+/**
+ * AILF Dashboard tool configuration.
+ *
+ * Add to your sanity.config.ts:
+ * ```ts
+ * import { ailfTool } from "@sanity/ailf-studio"
+ *
+ * export default defineConfig({
+ *   // ...
+ *   tools: [ailfTool()],
+ * })
+ * ```
+ */
+interface AilfToolOptions {
+    name?: string;
+    title?: string;
+}
+declare function ailfTool(options?: AilfToolOptions): Tool;
+
+/**
+ * types.ts
+ *
+ * Shared types for the AILF Studio dashboard plugin.
+ *
+ * These mirror the shapes returned by the GROQ queries in queries.ts.
+ * They're kept separate from the eval package types to avoid a build
+ * dependency — the Studio plugin reads from Sanity directly.
+ *
+ * Cross-package contract types (DocumentRef, ScoreGrade, scoreGrade) are
+ * imported from @sanity/ailf-shared — the single source of truth.
+ */
+
+/** Comparison data as stored in Sanity */
+interface ComparisonData {
+    deltas: {
+        docLift: number;
+        overall: number;
+        actualDelta?: number;
+        retrievalGapDelta?: number;
+        infrastructureEfficiencyDelta?: number;
+    };
+    generatedAt: string;
+    improved: string[];
+    noiseThreshold: number;
+    regressed: string[];
+    unchanged: string[];
+}
+/** Shape returned by contentImpactQuery and recentDocumentEvalsQuery */
+interface ContentImpactItem {
+    _id: string;
+    areas: null | string[];
+    comparisonDelta: null | number;
+    completedAt: string;
+    durationMs: number;
+    improved: null | string[];
+    mode: string;
+    models: null | string[];
+    overall: number;
+    perspective: null | string;
+    regressed: null | string[];
+    reportId: string;
+    scores: null | {
+        actualScore?: number;
+        docLift: number;
+        feature: string;
+        totalScore: number;
+    }[];
+    source: string;
+    tag: null | string;
+    targetDocuments: null | string[];
+    trigger: null | string;
+}
+/** Provenance data as stored in Sanity */
+interface ProvenanceData {
+    areas: string[];
+    contextHash?: string;
+    git?: {
+        branch: string;
+        prNumber?: number;
+        repo: string;
+        sha: string;
+    };
+    graderModel: string;
+    mode: string;
+    models: {
+        id: string;
+        label: string;
+    }[];
+    /** @deprecated Use `promptfooUrls` when available */
+    promptfooUrl?: string;
+    /** Per-mode Promptfoo share URLs (one per sub-eval) */
+    promptfooUrls?: {
+        mode: string;
+        url: string;
+    }[];
+    source: {
+        baseUrl: string;
+        dataset?: string;
+        name: string;
+        perspective?: string;
+        projectId?: string;
+    };
+    targetDocuments?: string[];
+    taskIds?: string[];
+    trigger: {
+        callerRef?: string;
+        callerRepo?: string;
+        documentId?: string;
+        runId?: string;
+        schedule?: string;
+        source?: string;
+        type: string;
+        workflow?: string;
+    };
+}
+/** Shape returned by reportDetailQuery */
+interface ReportDetail {
+    _id: string;
+    comparison: ComparisonData | null;
+    completedAt: string;
+    durationMs: number;
+    provenance: ProvenanceData;
+    reportId: string;
+    summary: SummaryData;
+    tag: null | string;
+}
+/** Shape returned by latestReportsQuery */
+interface ReportListItem {
+    _id: string;
+    actualScore?: number | null;
+    areas: string[];
+    comparisonDelta: null | number;
+    completedAt: string;
+    docLift: number;
+    durationMs: number;
+    evaluationMode?: string | null;
+    git: null | {
+        branch: string;
+        prNumber?: number;
+        repo: string;
+        sha: string;
+    };
+    improved: null | string[];
+    mode: string;
+    models: string[];
+    overall: number;
+    /** Content release perspective ID (when evaluated with --sanity-perspective) */
+    perspective?: null | string;
+    promptfooUrl: null | string;
+    promptfooUrls: null | {
+        mode: string;
+        url: string;
+    }[];
+    regressed: null | string[];
+    reportId: string;
+    retrievalGap?: number | null;
+    scores: ScoreItem[];
+    source: string;
+    tag: null | string;
+    /** Target document slugs (when evaluated with --changed-docs) */
+    targetDocuments?: null | string[];
+    trigger: string;
+}
+/** Per-area score (shared between list and detail views) */
+interface ScoreItem {
+    codeCorrectness: number;
+    docCoverage: number;
+    docLift: number;
+    /** Sanity documents used for this feature area's evaluation */
+    documents?: DocumentRef[];
+    feature: string;
+    taskCompletion: number;
+    testCount: number;
+    totalScore: number;
+    /** Score from agent-retrieved docs (only in full-mode reports) */
+    actualScore?: number;
+    /** Ceiling − actual: quality lost to discoverability (only in full-mode reports) */
+    retrievalGap?: number;
+    /** Actual / ceiling (0–1): agent effectiveness (only in full-mode reports) */
+    infrastructureEfficiency?: number | null;
+    /** True when agents outperform by not finding bad docs */
+    invertedRetrievalGap?: boolean;
+    /** Floor score — model knowledge alone */
+    floorScore?: number;
+    /** Ceiling score — gold-standard docs injected */
+    ceilingScore?: number;
+}
+/** A single gap/recommendation from gap analysis */
+interface RecommendationGap {
+    affectedTaskIds: string[];
+    area: string;
+    bottleneckDimensions: string[];
+    confidence: "high" | "low" | "medium";
+    estimatedLift: number;
+    failureMode: string;
+    priority: number;
+    remediation: string;
+}
+/** Gap analysis recommendations stored in Sanity */
+interface RecommendationsData {
+    gaps: RecommendationGap[];
+    generatedAt: string;
+    totalPotentialLift: number;
+}
+/** A single low-scoring grader judgment stored in reports */
+interface JudgmentData {
+    /** Docs the task expected the model to use */
+    canonicalDocs?: DocumentRef[];
+    dimension: string;
+    modelId: string;
+    reason: string;
+    score: number;
+    taskId: string;
+}
+/** Summary data as stored in Sanity */
+interface SummaryData {
+    belowCritical: string[];
+    /** All Sanity documents used across the entire evaluation */
+    documentManifest?: DocumentRef[];
+    evaluationMode?: string;
+    lowestArea: string;
+    lowestScore: number;
+    overall: {
+        avgDocLift: number;
+        avgScore: number;
+        avgCeilingScore?: number;
+        avgFloorScore?: number;
+        avgActualScore?: number;
+        avgRetrievalGap?: number;
+        avgInfrastructureEfficiency?: number;
+    };
+    /** Low-scoring grader judgments — the raw "red text" explaining failures */
+    lowScoringJudgments: JudgmentData[] | null;
+    /** Gap analysis recommendations (when gap analysis was run) */
+    recommendations: null | RecommendationsData;
+    scores: ScoreItem[];
+    timestamp: string;
+}
+/** Shape returned by scoreTimelineQuery */
+interface TimelineDataPoint {
+    _id: string;
+    actualScore?: number | null;
+    completedAt: string;
+    mode: string;
+    overall: number;
+    scores: {
+        feature: string;
+        totalScore: number;
+        actualScore?: number;
+    }[];
+    source: string;
+    tag: null | string;
+}
+
+/**
+ * AILF Studio plugin — registers the report schema, dashboard tool,
+ * and document actions (Graduate to Native for mirrored tasks).
+ *
+ * This is the recommended way to install the plugin. It registers
+ * schemas, the dashboard tool, and document-level actions in one call.
+ */
+declare const ailfPlugin: sanity.Plugin<void>;
+
+export { type ComparisonData, type ContentImpactItem, GLOSSARY, GraduateToNativeAction, MirrorBanner, type ProvenanceData, type ReportDetail, type ReportListItem, type RunEvaluationActionOptions, type ScoreItem, type SummaryData, SyncStatusBadge, type TimelineDataPoint, ailfPlugin, ailfTool, articleSearchQuery, comparisonPairQuery, contentImpactQuery, createRunEvaluationAction, distinctAreasQuery, distinctModesQuery, distinctPerspectivesQuery, distinctSourcesQuery, distinctTargetDocumentsQuery, evalRequestSchema, featureAreaSchema, latestReportsQuery, recentDocumentEvalsQuery, referenceSolutionSchema, reportDetailQuery, reportSchema, scoreTimelineQuery, taskSchema, webhookConfigSchema };