@sanity/ailf 4.0.7 → 4.1.0

package/dist/_vendor/ailf-core/types/api-requests.d.ts

@@ -0,0 +1,159 @@
+/**
+ * API Service Gateway request envelope types.
+ *
+ * These types describe the HTTP request bodies the API gateway accepts on
+ * its public-facing routes. They live in core (not in packages/api/src/) so
+ * the gateway's Zod validators can `satisfies z.ZodType<...>` against them
+ * — making the parse-output → domain-type contract a compile-time gate
+ * rather than a runtime assumption (D0045 / W0187).
+ *
+ * The shapes here are intentionally a LOOSE subset of the canonical domain
+ * types they relate to:
+ *
+ *   - `ValidateConfigRequest.config` overlaps with `ModelsConfig`, but the
+ *     API surface accepts string[] for modes (not branded EvalMode[]) and
+ *     all fields are optional. This is a deliberate gateway contract — the
+ *     route's job is to validate the user's input, not to require a fully
+ *     domain-shaped payload.
+ *   - `ValidateTaskDef` overlaps with `GeneralizedTaskDefinition` but uses
+ *     the older flat shape (`featureArea`, `canonicalDocs`) instead of the
+ *     mode-discriminated union. Harmonizing these is tracked separately —
+ *     out of scope for W0187.
+ *
+ * Any fields not on these types are rejected by the gateway's validators
+ * and won't reach domain code; the satisfies clause is what pins that
+ * contract in place.
+ */
+/**
+ * POST /v1/validate/config — request envelope.
+ * @see packages/api/src/schemas/validate-requests.ts
+ */
+export interface ValidateConfigRequest {
+    config: {
+        defaults?: Record<string, unknown>;
+        grader?: {
+            id: string;
+            label?: string;
+        };
+        maxConcurrency?: number;
+        models?: {
+            config?: Record<string, unknown>;
+            id: string;
+            label?: string;
+            modes?: string[];
+        }[];
+    };
+}
+/**
+ * Canonical doc reference used inside `ValidateTaskDef.canonicalDocs`.
+ * Mirrors the four shapes the API gateway accepts.
+ */
+export type ValidateTaskCanonicalDocRef = {
+    reason?: string;
+    slug: string;
+} | {
+    path: string;
+    reason?: string;
+} | {
+    id: string;
+    path?: string;
+    reason?: string;
+    slug?: string;
+} | {
+    perspective: string;
+    reason?: string;
+};
+/**
+ * Assertion definition accepted by the API gateway's task validator.
+ * Either an `llm-rubric` shape with explicit fields, or a generic
+ * type+value pair for non-LLM assertions.
+ */
+export type ValidateTaskAssertionDef = {
+    criteria: string[];
+    template: string;
+    type: "llm-rubric";
+    weight?: number;
+} | {
+    type: string;
+    value?: unknown;
+    weight?: number;
+};
+/**
+ * The "task definition" shape accepted by POST /v1/validate/task.
+ *
+ * Distinct from `GeneralizedTaskDefinition` (the mode-discriminated
+ * canonical task type): this is the older flat shape preserved at the
+ * API surface. Harmonization tracked separately.
+ */
+export interface ValidateTaskDef {
+    assertions: ValidateTaskAssertionDef[];
+    baseline?: {
+        enabled?: boolean;
+        rubric?: "abbreviated" | "full" | "none";
+    };
+    canonicalDocs: ValidateTaskCanonicalDocRef[];
+    description: string;
+    docCoverage: boolean;
+    extraVars?: Record<string, unknown>;
+    featureArea: string;
+    id: string;
+    referenceSolution: string;
+    taskPrompt: string;
+}
+/**
+ * POST /v1/validate/task — request envelope.
+ * @see packages/api/src/schemas/validate-requests.ts
+ */
+export interface ValidateTaskRequest {
+    strict: boolean;
+    tasks: ValidateTaskDef[];
+}
+/**
+ * POST /v1/validate/source — request envelope.
+ * @see packages/api/src/schemas/validate-requests.ts
+ */
+export interface ValidateSourceRequest {
+    source: {
+        baseUrl?: string;
+        dataset?: string;
+        projectId?: string;
+        token?: string;
+    };
+}
+/**
+ * POST /v1/lookup-doc — request envelope.
+ * @see packages/api/src/schemas/lookup-request.ts
+ */
+export interface LookupDocRequest {
+    keyword: string;
+    limit: number;
+    source: string;
+}
+/**
+ * Inline-score-or-report-id reference used by `CompareRequest`.
+ *
+ * Either:
+ *   - A partial inline score summary (used by the gateway's compare()
+ *     endpoint without a Content Lake round-trip), with `passthrough`
+ *     extra fields preserved, or
+ *   - A string report ID (the gateway fetches the corresponding
+ *     `ScoreSummary` from Content Lake before comparing).
+ */
+export type CompareScoreSummaryRef = string | {
+    [extra: string]: unknown;
+    features?: Record<string, unknown>;
+    overall: {
+        [extra: string]: unknown;
+        areaCount: number;
+        avgScore: number;
+    };
+};
+/**
+ * POST /v1/compare — request envelope.
+ * @see packages/api/src/schemas/compare-request.ts
+ */
+export interface CompareRequest {
+    baseline: CompareScoreSummaryRef;
+    experiment: CompareScoreSummaryRef;
+    threshold: number;
+}

package/dist/_vendor/ailf-core/types/api-requests.js

@@ -0,0 +1,27 @@
+/**
+ * API Service Gateway request envelope types.
+ *
+ * These types describe the HTTP request bodies the API gateway accepts on
+ * its public-facing routes. They live in core (not in packages/api/src/) so
+ * the gateway's Zod validators can `satisfies z.ZodType<...>` against them
+ * — making the parse-output → domain-type contract a compile-time gate
+ * rather than a runtime assumption (D0045 / W0187).
+ *
+ * The shapes here are intentionally a LOOSE subset of the canonical domain
+ * types they relate to:
+ *
+ *   - `ValidateConfigRequest.config` overlaps with `ModelsConfig`, but the
+ *     API surface accepts string[] for modes (not branded EvalMode[]) and
+ *     all fields are optional. This is a deliberate gateway contract — the
+ *     route's job is to validate the user's input, not to require a fully
+ *     domain-shaped payload.
+ *   - `ValidateTaskDef` overlaps with `GeneralizedTaskDefinition` but uses
+ *     the older flat shape (`featureArea`, `canonicalDocs`) instead of the
+ *     mode-discriminated union. Harmonizing these is tracked separately —
+ *     out of scope for W0187.
+ *
+ * Any fields not on these types are rejected by the gateway's validators
+ * and won't reach domain code; the satisfies clause is what pins that
+ * contract in place.
+ */
+export {};

package/dist/_vendor/ailf-core/types/index.d.ts

@@ -23,6 +23,9 @@ export { evalModeType } from "./eval-mode-config.js";
 export type { DependencyEdge, ResolvedFixture, TaskGraph, TaskNode, } from "./task-graph.js";
 export type { VariableDeclaration, VariableEnvelope, VariableProvenance, VariableSource, } from "./variable-envelope.js";
 export type { EvalTrace, ToolCallCategory, ToolCallRecord, TraceEvent, TraceSpan, TraceTokenUsage, } from "./trace.js";
+export type { CompareRequest, CompareScoreSummaryRef, LookupDocRequest, ValidateConfigRequest, ValidateSourceRequest, ValidateTaskAssertionDef, ValidateTaskCanonicalDocRef, ValidateTaskDef, ValidateTaskRequest, } from "./api-requests.js";
+export type { AilfEvalWorkflow, AilfEvalWorkflowJob, AilfEvalWorkflowStep, RepoAgenticConfig, RepoArtifactsConfig, RepoConfig, RepoExecutionConfig, RepoOutputConfig, RepoOwnerConfig, RepoPublishConfig, RepoReportStoreConfig, RepoSourceConfig, RepoTaskSourceConfig, RepoTriggersConfig, ScheduleTriggerConfig, TriggerConfig, TriggerMode, } from "./repo-config.js";
+export type { PipelineRequest, PipelineRequestCallback, PipelineRequestCallerExecutor, PipelineRequestCallerGit, PipelineRequestCallerOwner, PipelineRequestDebug, PipelineRequestTaskSource, } from "./pipeline-request.js";
 export type { ArtifactId, AssociationAxis, AssociationValues, Brand, EntryKey, Err, FixtureId, IdValidationError, NewReportId, Ok, ProviderId, PromptId, Result, ResultId, RubricId, RunFingerprint, RunId, SuiteId, TaskId, TaskSlug, TraceId, } from "./branded-ids.js";
 export { err, fixtureId, generateRunId, ok, providerId, resultId, runId, suiteId, taskId, traceId, } from "./branded-ids.js";
 export type { AgentHarnessTaskDefinition, ContentLakeAuthorableMode, ContentLakeAuthorableTask, CustomTaskDefinition, GeneralizedAssertionDefinition, GeneralizedDocRef, GeneralizedTaskDefinition, GeneralizedTemplatedAssertion, GeneralizedValueAssertion, IdDocRef, KnowledgeProbeTaskDefinition, LiteracyTaskDefinition, MCPServerTaskDefinition, PathDocRef, PerspectiveDocRef, RubricRef, SlugDocRef, TaskCommonFields, TaskDifficulty, TaskOptions, TaskProviderConfig, TaskStatus, } from "./generalized-task.js";

package/dist/_vendor/ailf-core/types/pipeline-request.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Pipeline-request domain types.
+ *
+ * Authored independently of `PipelineRequestSchema` in
+ * `packages/core/src/schemas/pipeline-request.ts` so the schema can
+ * `satisfies z.ZodType<PipelineRequest>` against this type — making
+ * schema/type drift a compile error rather than a silent regression
+ * (D0045 / W0187).
+ *
+ * `PipelineRequestSchema` is the universal pipeline invocation contract,
+ * shared between the API gateway (POST /v1/pipeline), the CLI (`--config`
+ * flag), and GitHub Actions workflows (`repository_dispatch` payload).
+ *
+ * Names here are prefixed `PipelineRequest*` to avoid colliding with the
+ * existing `DebugOptions` in `core/types/index.ts`, which has a stricter
+ * (required `enabled`) shape used by other pipeline code.
+ */
+import type { LiteracyVariant, RawEvalMode, RunClassification, RunExecutorSurface } from "../../ailf-shared/index.d.ts";
+/** Debug-mode options as accepted on the wire (looser than core's `DebugOptions`). */
+export interface PipelineRequestDebug {
+    enabled?: boolean;
+    firstN?: number;
+    pattern?: string;
+    sample?: number;
+}
+/** Webhook callback target for API-triggered evaluations. */
+export interface PipelineRequestCallback {
+    headers?: Record<string, string>;
+    url: string;
+}
+/**
+ * Git context from the *calling* repository (not the AILF runner repo).
+ * Carries provenance across cross-repo dispatches.
+ */
+export interface PipelineRequestCallerGit {
+    branch?: string;
+    prNumber?: number;
+    repo: string;
+    sha?: string;
+}
+/**
+ * Caller-side `RunOwner` payload (D0037). Team is required; individual
+ * optional.
+ */
+export interface PipelineRequestCallerOwner {
+    individual?: string;
+    team: string;
+}
+/**
+ * Caller-side executor payload — user variant only. System executors are
+ * always server-detected; the wire format excludes them. The Zod schema
+ * is `.strict()` to reject any unknown key (PII guard).
+ */
+export interface PipelineRequestCallerExecutor {
+    githubActor?: string;
+    name?: string;
+    surface: RunExecutorSurface;
+    type: "user";
+}
+/** Task-source override (W0077 Phase 6h) — mirrors `RepoConfig.taskSource`. */
+export interface PipelineRequestTaskSource {
+    repoTasksPath?: string;
+    type?: "content-lake" | "repo";
+}
+/**
+ * The universal pipeline invocation contract.
+ *
+ * The Zod schema at `packages/core/src/schemas/pipeline-request.ts`
+ * (`PipelineRequestSchema`) asserts `satisfies z.ZodType<PipelineRequest>`
+ * against this type. Field set must match the schema exactly.
+ */
+export interface PipelineRequest {
+    allowedOrigins?: string[];
+    areas?: string[];
+    backend?: "cloud-run" | "github-actions";
+    callback?: PipelineRequestCallback;
+    callerGit?: PipelineRequestCallerGit;
+    changedDocs?: string[];
+    classification?: RunClassification;
+    compare?: boolean;
+    compareBaseline?: string;
+    compareThreshold?: number;
+    concurrency?: number;
+    dataset?: string;
+    debug?: PipelineRequestDebug | boolean;
+    executor?: PipelineRequestCallerExecutor;
+    gapAnalysis?: boolean;
+    graderReplications?: number;
+    headers?: Record<string, string>;
+    inlineTasks?: Record<string, unknown>[];
+    jobId?: string;
+    labels?: string[];
+    mode?: RawEvalMode;
+    noAutoScope?: boolean;
+    noCache?: boolean;
+    noRemoteCache?: boolean;
+    owner?: PipelineRequestCallerOwner;
+    perspective?: string;
+    presets?: string[];
+    projectId?: string;
+    publish?: boolean;
+    publishTag?: string;
+    purpose?: string;
+    searchMode?: "off" | "open" | "origin-only";
+    source?: string;
+    sourceReportId?: string;
+    taskMode?: "content-lake" | "inline";
+    taskSource?: PipelineRequestTaskSource;
+    tasks?: string[];
+    urls?: string[];
+    variant?: LiteracyVariant;
+}

package/dist/_vendor/ailf-core/types/pipeline-request.js

@@ -0,0 +1,18 @@
+/**
+ * Pipeline-request domain types.
+ *
+ * Authored independently of `PipelineRequestSchema` in
+ * `packages/core/src/schemas/pipeline-request.ts` so the schema can
+ * `satisfies z.ZodType<PipelineRequest>` against this type — making
+ * schema/type drift a compile error rather than a silent regression
+ * (D0045 / W0187).
+ *
+ * `PipelineRequestSchema` is the universal pipeline invocation contract,
+ * shared between the API gateway (POST /v1/pipeline), the CLI (`--config`
+ * flag), and GitHub Actions workflows (`repository_dispatch` payload).
+ *
+ * Names here are prefixed `PipelineRequest*` to avoid colliding with the
+ * existing `DebugOptions` in `core/types/index.ts`, which has a stricter
+ * (required `enabled`) shape used by other pipeline code.
+ */
+export {};

package/dist/_vendor/ailf-core/types/repo-config.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Repo-level configuration types for the AI Literacy Framework.
+ *
+ * These describe `.ailf/config.yaml` (`RepoConfig`) and the structural
+ * contract on `.github/workflows/ailf-eval.yml` (`AilfEvalWorkflow`) used
+ * by `ailf init` and the Tier 1 init contract test.
+ *
+ * Authored independently of the Zod schemas in
+ * `packages/eval/src/adapters/task-sources/repo-schemas.ts` so the schemas
+ * can `satisfies z.ZodType<...>` against them — making schema/type drift a
+ * compile error rather than a silent regression (D0045 / W0187).
+ *
+ * Note on optionality: schema fields declared with `.optional()` produce
+ * `T | undefined` from `z.infer`; we mirror that with `?:` properties.
+ * Top-level `RepoConfig` itself has all optional groups because a
+ * `.ailf/config.yaml` may legitimately omit any of them.
+ */
+/** Mode of an evaluation trigger — drives whether the run executes or just validates. */
+export type TriggerMode = "validate-only" | "eval";
+export interface TriggerConfig {
+    blocking?: boolean;
+    compare?: boolean;
+    mode: TriggerMode;
+    notify?: boolean;
+    paths?: string[];
+}
+export interface ScheduleTriggerConfig extends TriggerConfig {
+    cron: string;
+}
+/** Documentation source — which Sanity project's docs the eval reads. */
+export interface RepoSourceConfig {
+    baseUrl?: string;
+    dataset?: string;
+    projectId?: string;
+    studioOrigin?: string;
+}
+/** Report-store destination — which Sanity project receives `ailf.report` documents. */
+export interface RepoReportStoreConfig {
+    dataset: string;
+    projectId: string;
+}
+/** Publish policy — when `ailf run` writes a report without an explicit flag. */
+export interface RepoPublishConfig {
+    auto?: "always" | "full-runs" | "never";
+    tag?: string;
+}
+/** Execution-tier knobs — replaces the retired `--concurrency` / `--api-url` flags. */
+export interface RepoExecutionConfig {
+    apiUrl?: string;
+    concurrency?: number;
+    gapAnalysis?: boolean;
+    graderReplications?: number;
+}
+/** Where the pipeline writes results (replaces `--output-dir`). */
+export interface RepoOutputConfig {
+    dir?: string;
+}
+/** Run-attribution defaults (replaces `--owner-team` / `--owner-individual`). */
+export interface RepoOwnerConfig {
+    individual?: string;
+    team?: string;
+}
+/** Agentic-mode runtime config (replaces `--header` / `--allowed-origin`). */
+export interface RepoAgenticConfig {
+    allowedOrigins?: string[];
+    headers?: Record<string, string>;
+}
+/** Artifact-writer config (replaces `--no-artifacts` / `--artifacts-dir` / `--artifacts-exclude`). */
+export interface RepoArtifactsConfig {
+    dir?: string;
+    enabled?: boolean;
+    exclude?: string[];
+}
+/** Task-source config (replaces `--task-source` / `--repo-tasks-path`). */
+export interface RepoTaskSourceConfig {
+    repoTasksPath?: string;
+    type?: "content-lake" | "repo";
+}
+/** Trigger overrides keyed by trigger name. */
+export interface RepoTriggersConfig {
+    main?: TriggerConfig;
+    pr?: TriggerConfig;
+    "pr-task-change"?: TriggerConfig;
+    schedule?: ScheduleTriggerConfig;
+}
+/**
+ * Parsed shape of `.ailf/config.yaml`.
+ *
+ * Every field is optional at the top level because a config file may omit
+ * any group. The Zod schema at `packages/eval/src/adapters/task-sources/repo-schemas.ts`
+ * (`RepoConfigSchema`) asserts `satisfies z.ZodType<RepoConfig>` against
+ * this type.
+ */
+export interface RepoConfig {
+    agentic?: RepoAgenticConfig;
+    artifacts?: RepoArtifactsConfig;
+    execution?: RepoExecutionConfig;
+    output?: RepoOutputConfig;
+    owner?: RepoOwnerConfig;
+    publish?: RepoPublishConfig;
+    reportStore?: RepoReportStoreConfig;
+    source?: RepoSourceConfig;
+    taskSource?: RepoTaskSourceConfig;
+    triggers?: RepoTriggersConfig;
+}
+/**
+ * One step inside a GitHub Actions workflow job. Loose by design — this is
+ * a structural contract, not a literal-byte one. Extra fields are accepted.
+ */
+export interface AilfEvalWorkflowStep {
+    [extra: string]: unknown;
+    env?: Record<string, unknown>;
+    id?: string;
+    if?: string;
+    name?: string;
+    run?: string;
+    uses?: string;
+    with?: Record<string, unknown>;
+}
+/**
+ * One job entry inside a GitHub Actions workflow. Loose by design.
+ */
+export interface AilfEvalWorkflowJob {
+    [extra: string]: unknown;
+    name?: string;
+    permissions?: Record<string, unknown>;
+    "runs-on": string | string[];
+    steps: AilfEvalWorkflowStep[];
+}
+/**
+ * Structural shape of the `ailf-eval.yml` workflow template emitted by
+ * `ailf init`. Validates the consumer-visible contract: a workflow with a
+ * non-empty `name`, an `on` trigger spec, and at least one job. The
+ * literal YAML body is intentionally not pinned — comments, step
+ * ordering, and option flags can shift without breaking consumers.
+ *
+ * The Zod schema at `packages/eval/src/adapters/task-sources/repo-schemas.ts`
+ * (`AilfEvalWorkflowSchema`) asserts `satisfies z.ZodType<AilfEvalWorkflow>`
+ * against this type.
+ */
+export interface AilfEvalWorkflow {
+    [extra: string]: unknown;
+    jobs: Record<string, AilfEvalWorkflowJob>;
+    name: string;
+    on: unknown;
+}

package/dist/_vendor/ailf-core/types/repo-config.js

@@ -0,0 +1,18 @@
+/**
+ * Repo-level configuration types for the AI Literacy Framework.
+ *
+ * These describe `.ailf/config.yaml` (`RepoConfig`) and the structural
+ * contract on `.github/workflows/ailf-eval.yml` (`AilfEvalWorkflow`) used
+ * by `ailf init` and the Tier 1 init contract test.
+ *
+ * Authored independently of the Zod schemas in
+ * `packages/eval/src/adapters/task-sources/repo-schemas.ts` so the schemas
+ * can `satisfies z.ZodType<...>` against them — making schema/type drift a
+ * compile error rather than a silent regression (D0045 / W0187).
+ *
+ * Note on optionality: schema fields declared with `.optional()` produce
+ * `T | undefined` from `z.infer`; we mirror that with `?:` properties.
+ * Top-level `RepoConfig` itself has all optional groups because a
+ * `.ailf/config.yaml` may legitimately omit any of them.
+ */
+export {};

package/dist/_vendor/ailf-shared/index.d.ts

@@ -9,11 +9,13 @@
  * from @sanity/ailf-core, @sanity/ailf, or
  * @sanity/ailf-studio. It is the leaf of the dependency graph.
  *
- * Re-exports are explicit (named) rather than `export *` so that the studio
- * tsup DTS bundle can statically resolve each symbol's canonical owner —
- * `export *` chains across many modules trip rollup-plugin-dts's "Ambiguous
- * external namespace resolution" warning even when no symbol actually
- * collides. See W0124.
+ * Barrel hygiene rule (D0045): re-exports are explicit (named) rather than
+ * `export *`. `export *` chains across many modules trip rollup-plugin-dts's
+ * "Ambiguous external namespace resolution" warning even when no symbol
+ * actually collides, and worse — silently change which module's runtime
+ * symbol downstream consumers receive. The regression caught by W0124 was
+ * generalized to the whole barrel under W0186; `barrel.test.ts` locks the
+ * surface against future regressions.
  */
 export { computeCanaryDrift, type CanaryDriftReport, type CanaryReportSlim, type DriftEntry, type DriftThresholds, type DriftVerdict, } from "./canary-drift.js";
 export { type DocumentRef } from "./document-ref.js";

package/dist/_vendor/ailf-shared/index.js

@@ -9,11 +9,13 @@
  * from @sanity/ailf-core, @sanity/ailf, or
  * @sanity/ailf-studio. It is the leaf of the dependency graph.
  *
- * Re-exports are explicit (named) rather than `export *` so that the studio
- * tsup DTS bundle can statically resolve each symbol's canonical owner —
- * `export *` chains across many modules trip rollup-plugin-dts's "Ambiguous
- * external namespace resolution" warning even when no symbol actually
- * collides. See W0124.
+ * Barrel hygiene rule (D0045): re-exports are explicit (named) rather than
+ * `export *`. `export *` chains across many modules trip rollup-plugin-dts's
+ * "Ambiguous external namespace resolution" warning even when no symbol
+ * actually collides, and worse — silently change which module's runtime
+ * symbol downstream consumers receive. The regression caught by W0124 was
+ * generalized to the whole barrel under W0186; `barrel.test.ts` locks the
+ * surface against future regressions.
  */
 export { computeCanaryDrift, } from "./canary-drift.js";
 export { FEATURE_FLAGS, } from "./feature-flags.js";

package/dist/adapters/api-client/types.d.ts

@@ -11,6 +11,8 @@
  * @see packages/api/src/routes/pipeline.ts — POST /v1/pipeline response
  * @see packages/api/src/routes/jobs.ts — GET /v1/jobs/:id response
  */
+import type { ValidationIssue } from "../../_vendor/ailf-core/index.d.ts";
+export type { ValidationIssue } from "../../_vendor/ailf-core/index.d.ts";
 /** Standard envelope fields present on every API response. */
 export interface ApiEnvelope {
     object: string;
@@ -59,11 +61,6 @@ export interface SubmitResponse extends ApiEnvelope {
     estimatedDurationMs?: number;
     runUrl?: string;
 }
-export interface ValidationIssue {
-    severity: string;
-    source: string;
-    message: string;
-}
 export interface ValidationResponse extends ApiEnvelope {
     object: "validation";
     valid: boolean;

package/dist/adapters/task-sources/content-lake-task-source.d.ts

@@ -16,9 +16,66 @@
  * @see docs/decisions/D0038-content-lake-authorable-task-modes.md
  */
 import type { SanityClient } from "@sanity/client";
-import type { FilterOptions, GeneralizedTaskDefinition, TaskSource } from "../../_vendor/ailf-core/index.d.ts";
+import type { ContentLakeAuthorableTask, FilterOptions, GeneralizedTaskDefinition, TaskSource, TaskStatus } from "../../_vendor/ailf-core/index.d.ts";
+/** Shape of a single ailf.task document as returned by the GROQ query. */
+export interface ContentLakeTask {
+    areaId?: string;
+    assertions?: ContentLakeAssertion[];
+    baseline?: {
+        enabled?: boolean;
+        rubric?: string;
+    };
+    contextDocs?: ContentLakeCanonicalDoc[];
+    description?: string;
+    docCoverage?: boolean;
+    promptText?: string;
+    rawAssert?: {
+        threshold?: number;
+        type?: string;
+        value?: string;
+    }[];
+    referenceSolutionTitle?: string;
+    status?: TaskStatus;
+    tags?: string[];
+    taskId?: string;
+    title?: string;
+}
+/**
+ * Context doc ref shape from the Content Lake.
+ * The GROQ query projects refType + all possible value fields.
+ * Only the field matching refType will have a value.
+ */
+interface ContentLakeCanonicalDoc {
+    docId?: string;
+    docRefId?: string;
+    path?: string;
+    perspective?: string;
+    reason?: string;
+    refType?: string;
+    sectionSlug?: string;
+    slug?: string;
+}
+/** Assertion shape from the Content Lake (mirrors the Studio schema). */
+interface ContentLakeAssertion {
+    criteria?: string[];
+    template?: string;
+    threshold?: number;
+    type?: string;
+    value?: string;
+    weight?: number;
+}
 export declare class ContentLakeTaskSource implements TaskSource {
     private readonly client;
     constructor(client: SanityClient);
     loadTasks(filter?: FilterOptions): Promise<GeneralizedTaskDefinition[]>;
 }
+/**
+ * Map a Content Lake ailf.task document to a `ContentLakeAuthorableTask`.
+ *
+ * Returns null if the document is missing required fields (taskId,
+ * title, areaId, promptText). These are required by the
+ * Studio schema, but defensive coding handles edge cases (drafts,
+ * partially-created documents, etc.).
+ */
+export declare function mapToAuthorableTask(raw: ContentLakeTask): ContentLakeAuthorableTask | null;
+export {};

package/dist/adapters/task-sources/content-lake-task-source.js

@@ -148,7 +148,7 @@ function buildGroqParams(filter) {
  * Studio schema, but defensive coding handles edge cases (drafts,
  * partially-created documents, etc.).
  */
-function mapToAuthorableTask(raw) {
+export function mapToAuthorableTask(raw) {
     // Required fields — skip malformed documents
     if (!raw.taskId || !raw.title || !raw.areaId || !raw.promptText) {
         return null;

package/dist/adapters/task-sources/index.d.ts

@@ -3,5 +3,5 @@ export { ContentLakeTaskSource } from "./content-lake-task-source.js";
 export { AilfEvalWorkflowSchema, CanonicalTaskFileSchema, CanonicalTaskSchema, ContentLakeAuthorableTaskSchema, CURATED_ASSERTION_TYPES, detectLegacyFieldNames, parseAilfEvalWorkflow, parseCanonicalTaskFile, parseRepoConfig, RepoConfigSchema, RUBRIC_TEMPLATE_NAMES, type AilfEvalWorkflow, type CanonicalTask, type ContentLakeAuthorableTaskParsed, type CuratedAssertionType, type RepoConfig, type RubricTemplateName, } from "./repo-schemas.js";
 export { RepoTaskSource } from "./repo-task-source.js";
 export { detectTriggerContext, resolveTrigger, type ResolvedTrigger, type TriggerContext, } from "./repo-trigger.js";
-export { formatValidationResult, validateCanonicalTasks, type ValidationMessage, type ValidationResult, } from "./repo-validation.js";
+export { formatRepoValidationResult, validateCanonicalTasks, type RepoValidationMessage, type RepoValidationResult, } from "./repo-validation.js";
 export { discoverTsTaskFiles, loadAllTsTaskFiles, loadTsTaskFile, loadTsTaskFileSync, } from "./task-file-loader.js";

package/dist/adapters/task-sources/index.js

@@ -3,5 +3,5 @@ export { ContentLakeTaskSource } from "./content-lake-task-source.js";
 export { AilfEvalWorkflowSchema, CanonicalTaskFileSchema, CanonicalTaskSchema, ContentLakeAuthorableTaskSchema, CURATED_ASSERTION_TYPES, detectLegacyFieldNames, parseAilfEvalWorkflow, parseCanonicalTaskFile, parseRepoConfig, RepoConfigSchema, RUBRIC_TEMPLATE_NAMES, } from "./repo-schemas.js";
 export { RepoTaskSource } from "./repo-task-source.js";
 export { detectTriggerContext, resolveTrigger, } from "./repo-trigger.js";
-export { formatValidationResult, validateCanonicalTasks, } from "./repo-validation.js";
+export { formatRepoValidationResult, validateCanonicalTasks, } from "./repo-validation.js";
 export { discoverTsTaskFiles, loadAllTsTaskFiles, loadTsTaskFile, loadTsTaskFileSync, } from "./task-file-loader.js";