@sanity/ailf 4.0.7 → 4.2.0

package/dist/adapters/doc-fetchers/sanity-doc-fetcher.js

@@ -18,8 +18,9 @@ import { join } from "path";
 import { canonicalDocRefLabel, isIdRef, isPathRef, isPerspectiveRef, isSlugRef, } from "../../_vendor/ailf-core/index.js";
 import { fetchUrlContent, } from "../../pipeline/fetch-url-content.js";
 import { createPerspectiveClient, createPublishedClient, getSanityClient, } from "../../sanity/client.js";
+import { renderDocument, } from "../../sanity/document-renderers.js";
 import { toMarkdown } from "../../sanity/portable-text.js";
-import { ALL_ARTICLES_QUERY, ALL_FEATURE_AREAS, ARTICLE_BY_ID_QUERY, ARTICLE_BY_SLUG_QUERY, ARTICLE_BY_SLUG_WITH_PERSPECTIVE_QUERY, ARTICLE_SLUG_BY_PATH_QUERY, ARTICLE_SLUG_BY_SECTION_PATH_QUERY, ARTICLES_IN_RELEASE_QUERY, ARTICLES_METADATA_BY_SLUGS_QUERY, FEATURE_AREA_QUERIES, } from "../../sanity/queries.js";
+import { ALL_ARTICLES_QUERY, ALL_FEATURE_AREAS, ARTICLE_BY_ID_QUERY, ARTICLE_BY_SLUG_QUERY, ARTICLE_BY_SLUG_WITH_PERSPECTIVE_QUERY, ARTICLE_SLUG_BY_PATH_QUERY, ARTICLE_SLUG_BY_SECTION_PATH_QUERY, ARTICLES_IN_RELEASE_QUERY, ARTICLES_METADATA_BY_SLUGS_QUERY, DOCS_BY_IDS_QUERY, FEATURE_AREA_QUERIES, } from "../../sanity/queries.js";
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -99,9 +100,11 @@ export class SanityDocFetcher {
                 }
             }
         }
-        // Resolve ID refs → slugs via batch query
-        const idToSlug = await this.resolveIdRefsToSlugs(idRefs, source);
-        for (const slug of idToSlug.values()) {
+        // Resolve ID refs. Articles get added to allSlugs (legacy slug-flow takes
+        // over for fetch + render). Non-articles render directly via the renderer
+        // registry and bypass the slug-keyed content map.
+        const idResolution = await this.resolveIdRefs(idRefs, source);
+        for (const slug of idResolution.idToSlug.values()) {
             allSlugs.add(slug);
         }
         // Resolve path refs → slugs
@@ -118,8 +121,14 @@ export class SanityDocFetcher {
             }
         }
         const metadata = {};
-        // 2. Fetch document manifest (traceability metadata)
+        // 2. Fetch document manifest (traceability metadata). Articles flow
+        // through fetchManifest; non-article id-refs contribute their own
+        // entries from the resolution we already did above.
         const manifest = await this.fetchManifest(allSlugs, source);
+        for (const extra of idResolution.extraManifest) {
+            manifest.push(extra);
+        }
+        manifest.sort((a, b) => a.slug.localeCompare(b.slug));
         if (manifest.length > 0) {
             metadata.manifest = manifest;
         }
@@ -232,12 +241,22 @@ export class SanityDocFetcher {
                     }
                     continue;
                 }
+                // Non-article id-refs bypass the slug-keyed content map: their
+                // rendered Markdown was produced by `resolveIdRefs` and is cached
+                // by document `_id`. Article id-refs continue to go through the
+                // slug-flow below (consistent with overlay/perspective handling).
+                if (isIdRef(ref) && idResolution.contentById.has(ref.id)) {
+                    const entry = idResolution.contentById.get(ref.id);
+                    parts.push(entry.content);
+                    slugs.push(entry.slug);
+                    continue;
+                }
                 let slug;
                 if (isSlugRef(ref)) {
                     slug = ref.slug;
                 }
                 else if (isIdRef(ref)) {
-                    slug = idToSlug.get(ref.id);
+                    slug = idResolution.idToSlug.get(ref.id);
                 }
                 else if (isPathRef(ref)) {
                     slug = pathToSlug.get(ref.path);
@@ -289,40 +308,125 @@ export class SanityDocFetcher {
             .sort((a, b) => a.slug.localeCompare(b.slug));
     }
     // -----------------------------------------------------------------------
-    // Private: Resolve ID refs to slugs
+    // Private: Resolve ID refs (type-agnostic)
     // -----------------------------------------------------------------------
     /**
-     * Batch-resolve document ID refs to their article slugs.
+     * Batch-resolve document ID refs without filtering on `_type`.
+     *
+     * Articles are routed back into the slug-flow (so manifest, perspective
+     * diffing, and overlay handling continue to work unchanged). Non-articles
+     * are rendered eagerly via the renderer registry — `typesReference` gets
+     * a high-fidelity formatter; anything else falls through to the default
+     * walker so authors can pin marketing pages, glossary entries, etc.
+     * without an AILF code change.
      *
-     * This bridges IdDocRef entries into the slug-based fetch pipeline.
-     * Articles are queried by _id and their slugs are returned for use
-     * in the existing slug-based content map.
+     * Three log shapes:
+     *   - `info` — doc rendered with the default formatter (suggests a
+     *     dedicated renderer would improve fidelity)
+     *   - `warn` — registered renderer produced empty content (W0195 AC#3)
+     *   - `warn` — id had no matching document (existed/wrong tenant/typo)
      */
-    async resolveIdRefsToSlugs(idRefs, source) {
-        const result = new Map();
+    async resolveIdRefs(idRefs, source) {
+        const idToSlug = new Map();
+        const contentById = new Map();
+        const extraManifest = [];
         if (idRefs.length === 0)
-            return result;
+            return { idToSlug, contentById, extraManifest };
         const uniqueIds = [...new Set(idRefs.map((r) => r.id))];
+        const taskByRef = new Map();
+        for (const { id, taskId } of idRefs) {
+            const existing = taskByRef.get(id) ?? [];
+            existing.push(taskId);
+            taskByRef.set(id, existing);
+        }
         const client = source?.perspective
             ? createPerspectiveClient(source.perspective, source)
             : getSanityClient(toSanityOverrides(source));
-        // Batch query: fetch slug for each document ID
-        const articles = await client.fetch(`*[_type == "article" && _id in $ids] { _id, "slug": slug.current }`, { ids: uniqueIds });
-        const idToSlugMap = new Map(articles.map((a) => [a._id, a.slug]));
-        for (const { id, taskId } of idRefs) {
-            const slug = idToSlugMap.get(id);
-            if (slug) {
-                result.set(id, slug);
+        const docs = await client.fetch(DOCS_BY_IDS_QUERY, {
+            ids: uniqueIds,
+        });
+        const docsById = new Map(docs.map((d) => [d._id, d]));
+        let articleCount = 0;
+        let highFidelity = 0;
+        let defaultFidelity = 0;
+        for (const id of uniqueIds) {
+            const taskIds = taskByRef.get(id) ?? [];
+            const doc = docsById.get(id);
+            if (!doc) {
+                console.warn(`    [warn] doc "${id}" not found (referenced by task(s): ${taskIds.join(", ")})`);
+                continue;
+            }
+            // Article id-refs flow back into the slug-keyed pipeline so manifest,
+            // perspective diff, and document overlay continue to work. The slug
+            // projection in DOCS_BY_IDS_QUERY mirrors ARTICLE_PROJECTION.
+            if (doc._type === "article") {
+                const slug = doc.slug;
+                if (typeof slug === "string" && slug.length > 0) {
+                    idToSlug.set(id, slug);
+                    articleCount += 1;
+                }
+                else {
+                    console.warn(`    [warn] article "${id}" has no slug (referenced by task(s): ${taskIds.join(", ")})`);
+                }
+                continue;
+            }
+            const rendered = await renderDocument(doc, {
+                fetchUrl: this.fetchAttachmentBody,
+            });
+            if (!rendered.content) {
+                console.warn(`    [warn] doc "${id}" resolved as "${doc._type}" but produced empty context (referenced by task(s): ${taskIds.join(", ")})`);
+                continue;
+            }
+            contentById.set(id, {
+                content: rendered.content,
+                slug: rendered.slug,
+                type: doc._type,
+            });
+            const _rev = doc._rev;
+            const title = doc.title;
+            extraManifest.push({
+                _id: doc._id,
+                _rev: typeof _rev === "string" ? _rev : "",
+                slug: rendered.slug,
+                title: typeof title === "string" ? title : `(${doc._type})`,
+            });
+            if (rendered.fidelity === "default") {
+                console.log(`    [info] doc "${id}" rendered with default formatter — a dedicated renderer for "${doc._type}" would likely improve grader fidelity`);
+                defaultFidelity += 1;
             }
             else {
-                console.warn(`    [warn] No article found for document ID "${id}" (referenced by task "${taskId}")`);
+                highFidelity += 1;
             }
         }
-        if (result.size > 0) {
-            console.log(`  Resolved ${result.size} document ID ref(s) to slugs`);
+        if (articleCount > 0) {
+            console.log(`  Resolved ${articleCount} article id ref(s) to slugs`);
         }
-        return result;
+        if (highFidelity + defaultFidelity > 0) {
+            console.log(`  Resolved ${highFidelity + defaultFidelity} non-article id ref(s) (${highFidelity} high-fidelity, ${defaultFidelity} default)`);
+        }
+        return { idToSlug, contentById, extraManifest };
     }
+    /**
+     * Fetch the raw body of a Sanity file asset URL, used by the
+     * `typesReference` renderer to inline typedoc JSON. Returns `null`
+     * on any HTTP/network failure rather than throwing — the renderer
+     * surfaces a placeholder so the rest of the context still renders.
+     */
+    fetchAttachmentBody = async (url) => {
+        try {
+            const response = await fetch(url);
+            if (!response.ok) {
+                console.warn(`    [warn] attachment fetch failed for ${url}: HTTP ${response.status}`);
+                return null;
+            }
+            return await response.text();
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.warn(`    [warn] attachment fetch failed for ${url}: ${msg}`);
+            return null;
+        }
+    };
     // -----------------------------------------------------------------------
     // Private: Resolve path refs to slugs
     // -----------------------------------------------------------------------

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";

package/dist/adapters/task-sources/repo-schemas.d.ts

@@ -16,6 +16,7 @@
  * @see docs/archive/exec-plans/tasks-as-content/phase-4-repo-based-tasks.md
  */
 import { z } from "zod";
+import type { AilfEvalWorkflow, RepoConfig } from "../../_vendor/ailf-core/index.d.ts";
 /**
  * The set of assertion types allowed in task files.
  *
@@ -1424,6 +1425,22 @@ export declare function parseCanonicalTaskFile(raw: unknown, filename: string):
  * GeneralizedTaskDefinition shape.
  */
 export declare function detectLegacyFieldNames(raw: unknown, filename: string): string[];
+interface MigrationResult {
+    migrated: unknown;
+    warnings: string[];
+}
+/**
+ * Pre-process legacy `prompt.vars.{task,docs,__featureArea}` into the
+ * canonical shape. Backwards-compatible: legacy-shape tasks continue to
+ * load, but a deprecation warning is emitted per affected task.
+ *
+ *   Legacy:    prompt: { vars: { task: "...", docs: "file://..." } }
+ *   Canonical: prompt: { text: "..." }
+ *
+ * Applies to every task regardless of mode. Per-task dedup: at most one
+ * warning per task per call, listing every reserved key that was present.
+ */
+export declare function migratePromptShape(raw: unknown, filename: string): MigrationResult;
 /**
  * Zod schema for .ailf/config.yaml — controls documentation source,
  * report destination, and trigger behavior for evaluations from an
@@ -1521,7 +1538,7 @@ export declare const RepoConfigSchema: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-export type RepoConfig = z.infer<typeof RepoConfigSchema>;
+export type { RepoConfig } from "../../_vendor/ailf-core/index.d.ts";
 /**
  * Parse and validate .ailf/config.yaml content. Returns typed config or throws.
  */
@@ -1551,7 +1568,7 @@ export declare const AilfEvalWorkflowSchema: z.ZodObject<{
         }, z.core.$loose>>;
     }, z.core.$loose>>;
 }, z.core.$loose>;
-export type AilfEvalWorkflow = z.infer<typeof AilfEvalWorkflowSchema>;
+export type { AilfEvalWorkflow } from "../../_vendor/ailf-core/index.d.ts";
 /**
  * Parse and validate a `.github/workflows/ailf-eval.yml` payload (already
  * loaded from YAML). Throws with a Zod-formatted message on failure.

package/dist/adapters/task-sources/repo-schemas.js

@@ -141,11 +141,30 @@ const AssertionSchema = z.union([
 // ---------------------------------------------------------------------------
 // Shared field schemas — building blocks reused across mode variants
 // ---------------------------------------------------------------------------
+/**
+ * Variable keys reserved by the AILF compilers — populated automatically
+ * from canonical task fields (`prompt.text`, `context.docs`, `area`).
+ * Mirrors `ReservedPromptVarKey` in `@sanity/ailf-core`; the `satisfies`
+ * clause makes drift a build error.
+ */
+const RESERVED_PROMPT_VAR_KEYS = [
+    "task",
+    "docs",
+    "__featureArea",
+];
 const TaskPromptSchema = z.object({
     template: z.string().optional(),
     text: z.string().optional(),
     systemMessage: z.string().optional(),
-    vars: z.record(z.string(), z.unknown()).optional(),
+    vars: z
+        .record(z.string(), z.unknown())
+        .refine((vars) => !RESERVED_PROMPT_VAR_KEYS.some((key) => key in vars), {
+        message: `prompt.vars contains a reserved key. Reserved keys: ` +
+            RESERVED_PROMPT_VAR_KEYS.join(", ") +
+            `. Use prompt.text for the prompt body and context.docs for ` +
+            `documentation references.`,
+    })
+        .optional(),
 });
 const RubricRefSchema = z.union([
     z.object({ ref: z.string().min(1) }),
@@ -334,7 +353,9 @@ export const ContentLakeAuthorableTaskSchema = LiteracyTaskSchema;
  * Schema for an array of canonical tasks — what a single .ailf/tasks/*.yaml
  * file contains. Each file must define at least one task.
  */
-export const CanonicalTaskFileSchema = z.array(CanonicalTaskSchema).min(1);
+export const CanonicalTaskFileSchema = z
+    .array(CanonicalTaskSchema)
+    .min(1);
 /**
  * Pre-process raw task entries before discriminated-union parsing: when
  * `mode` is missing, default it to `"literacy"`. Zod cannot default a
@@ -414,6 +435,64 @@ export function detectLegacyFieldNames(raw, filename) {
     }
     return warnings;
 }
+/**
+ * Pre-process legacy `prompt.vars.{task,docs,__featureArea}` into the
+ * canonical shape. Backwards-compatible: legacy-shape tasks continue to
+ * load, but a deprecation warning is emitted per affected task.
+ *
+ *   Legacy:    prompt: { vars: { task: "...", docs: "file://..." } }
+ *   Canonical: prompt: { text: "..." }
+ *
+ * Applies to every task regardless of mode. Per-task dedup: at most one
+ * warning per task per call, listing every reserved key that was present.
+ */
+export function migratePromptShape(raw, filename) {
+    if (!Array.isArray(raw))
+        return { migrated: raw, warnings: [] };
+    const warnings = [];
+    const migrated = raw.map((entry, i) => {
+        if (typeof entry !== "object" || entry === null)
+            return entry;
+        const obj = entry;
+        const prompt = obj.prompt;
+        if (typeof prompt !== "object" || prompt === null)
+            return entry;
+        const promptObj = prompt;
+        const vars = promptObj.vars;
+        if (typeof vars !== "object" || vars === null)
+            return entry;
+        const varsObj = vars;
+        // Detect which reserved keys are present
+        const presentReserved = RESERVED_PROMPT_VAR_KEYS.filter((key) => key in varsObj);
+        if (presentReserved.length === 0)
+            return entry;
+        const taskId = typeof obj.id === "string" ? obj.id : `task[${i}]`;
+        // Build migrated prompt + vars
+        const newPrompt = { ...promptObj };
+        const newVars = { ...varsObj };
+        for (const key of presentReserved) {
+            if (key === "task" && newPrompt.text === undefined) {
+                // Move the prompt body to prompt.text only if the canonical slot
+                // is unset; an explicit prompt.text always wins.
+                newPrompt.text = newVars.task;
+            }
+            delete newVars[key];
+        }
+        // Drop empty vars to keep the migrated shape minimal
+        if (Object.keys(newVars).length === 0) {
+            delete newPrompt.vars;
+        }
+        else {
+            newPrompt.vars = newVars;
+        }
+        warnings.push(`[${filename}] ${taskId}: deprecated prompt.vars keys ` +
+            `(${presentReserved.join(", ")}) — migrated to canonical shape ` +
+            `(prompt.text + context.docs). Update the task source to silence ` +
+            `this warning.`);
+        return { ...obj, prompt: newPrompt };
+    });
+    return { migrated, warnings };
+}
 // ---------------------------------------------------------------------------
 // Config schemas — specific to the eval pipeline
 // ---------------------------------------------------------------------------

package/dist/adapters/task-sources/repo-task-source.js

@@ -22,7 +22,7 @@ import { existsSync, readdirSync, readFileSync } from "fs";
 import { resolve } from "path";
 import { load } from "js-yaml";
 import { CANONICAL_EVAL_MODES } from "../../_vendor/ailf-shared/index.js";
-import { detectLegacyFieldNames, parseCanonicalTaskFile, } from "./repo-schemas.js";
+import { detectLegacyFieldNames, migratePromptShape, parseCanonicalTaskFile, } from "./repo-schemas.js";
 import { discoverTsTaskFiles, loadTsTaskFile } from "./task-file-loader.js";
 /** Set of canonical mode names for O(1) lookup */
 const KNOWN_MODES = new Set(CANONICAL_EVAL_MODES);
@@ -69,10 +69,19 @@ export class RepoTaskSource {
                     legacyWarnings.join("\n") +
                     "\n\nSee contributing-tasks.md for the canonical task format.");
             }
+            // W0193: pre-migrate legacy prompt.vars.{task,docs,__featureArea}
+            // to the canonical prompt.text + context.docs shape. Mode-agnostic —
+            // every mode's TaskPromptSchema rejects reserved keys, so the shim
+            // unblocks legacy tasks regardless of mode. Per-task deprecation
+            // warning fires on stderr.
+            const { migrated, warnings: deprecationWarnings } = migratePromptShape(parsed, file);
+            for (const warning of deprecationWarnings) {
+                console.warn(warning);
+            }
             // Validate through canonical Zod schema
             let validated;
             try {
-                validated = parseCanonicalTaskFile(parsed, file);
+                validated = parseCanonicalTaskFile(migrated, file);
             }
             catch (err) {
                 const msg = err instanceof Error ? err.message : String(err);

package/dist/adapters/task-sources/repo-validation.d.ts

@@ -15,12 +15,12 @@
  * has been eliminated — all validation logic now lives here.
  */
 import { type CanonicalTask } from "./repo-schemas.js";
-export interface ValidationResult {
+export interface RepoValidationResult {
     valid: boolean;
-    errors: ValidationMessage[];
-    warnings: ValidationMessage[];
+    errors: RepoValidationMessage[];
+    warnings: RepoValidationMessage[];
 }
-export interface ValidationMessage {
+export interface RepoValidationMessage {
     taskId: string;
     field: string;
     message: string;
@@ -32,8 +32,8 @@ export interface ValidationMessage {
  * areas, unresolved slugs) and errors for issues that would cause pipeline
  * failures (completely missing required fields — though Zod catches most).
  */
-export declare function validateCanonicalTasks(tasks: CanonicalTask[]): ValidationResult;
+export declare function validateCanonicalTasks(tasks: CanonicalTask[]): RepoValidationResult;
 /**
  * Format validation results for console output.
  */
-export declare function formatValidationResult(result: ValidationResult): string;
+export declare function formatRepoValidationResult(result: RepoValidationResult): string;

package/dist/adapters/task-sources/repo-validation.js

@@ -110,7 +110,7 @@ export function validateCanonicalTasks(tasks) {
 /**
  * Format validation results for console output.
  */
-export function formatValidationResult(result) {
+export function formatRepoValidationResult(result) {
     const lines = [];
     if (result.errors.length > 0) {
         lines.push("Errors:");

package/dist/agent-observer/agentic-provider.d.ts

@@ -63,6 +63,7 @@ export default class AgenticProvider {
     private docBaseUrl;
     private docsUrlPattern;
     private llmsTxtUrl;
+    private parsedConfig;
     private priorityDomain;
     private recorder;
     private searchMode;