@sanity/ailf 2.3.0 → 2.3.1

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

@@ -28,7 +28,13 @@
  */
 const TASKS_QUERY = /* groq */ `
 *[_type == "ailf.task"
-  && (!defined($areas) || area->areaId.current in $areas)
+  && (
+    !defined($areas)
+    // Current field name
+    || area->areaId.current in $areas
+    // Legacy field name (pre-schema-rename documents)
+    || featureArea->areaId.current in $areas
+  )
   && (!defined($taskIds) || id.current in $taskIds)
   && (
     // Status-based filtering (unified — replaces execution.enabled)
@@ -39,13 +45,15 @@ const TASKS_QUERY = /* groq */ `
     || (defined($taskIds) && status != "archived")
   )
   && (!defined($tags) || count((tags)[@ in $tags]) > 0)
-] | order(area->areaId.current asc, id.current asc) {
+] | order(coalesce(area->areaId.current, featureArea->areaId.current) asc, id.current asc) {
   "taskId": id.current,
-  title,
-  "areaId": area->areaId.current,
-  promptText,
+  // Coalesce current and legacy field names so documents created before
+  // the schema rename are still readable.
+  "title": coalesce(title, description),
+  "areaId": coalesce(area->areaId.current, featureArea->areaId.current),
+  "promptText": coalesce(promptText, taskPrompt),
   docCoverage,
-  "contextDocs": contextDocs[] {
+  "contextDocs": coalesce(contextDocs, canonicalDocs)[] {
     refType,
     "slug": doc->slug.current,
     "docRefId": doc->_id,
@@ -55,7 +63,7 @@ const TASKS_QUERY = /* groq */ `
     perspective,
     reason
   },
-  assertions,
+  "assertions": coalesce(assertions, assert),
   rawAssert,
   baseline,
   tags,

package/dist/orchestration/steps/fetch-docs-step.js

@@ -29,15 +29,29 @@ export class FetchDocsStep {
             return { status: "skipped", reason: "--skip-fetch" };
         }
         const start = Date.now();
-        // Load tasks from the filesystem — the same source GenerateConfigsStep
-        // uses. This replaces ctx.taskSource (ContentLakeTaskSource) which may
-        // have no ailf.task documents, causing a mismatch where generated
-        // configs reference context files that were never fetched.
-        const allTasks = await loadPipelineTasks({
-            rootDir: ctx.config.rootDir,
-            mode: ctx.config.mode,
-            repoTasksPath: ctx.config.repoTasksPath,
-        });
+        // Load tasks — use the same source as GenerateConfigsStep to avoid
+        // a mismatch where configs reference context files that were never
+        // fetched.
+        //
+        // Content Lake path: use ctx.taskSource (ContentLakeTaskSource) which
+        // loads Studio-owned ailf.task documents via GROQ.
+        // Filesystem path: load from .task.ts files (repo/inline tasks).
+        let allTasks;
+        if (ctx.config.taskSourceType === "content-lake") {
+            const filter = {
+                ...(ctx.config.areas?.length ? { areas: ctx.config.areas } : {}),
+                ...(ctx.config.tasks?.length ? { taskIds: ctx.config.tasks } : {}),
+                ...(ctx.config.tags?.length ? { tags: ctx.config.tags } : {}),
+            };
+            allTasks = await ctx.taskSource.loadTasks(Object.keys(filter).length > 0 ? filter : undefined);
+        }
+        else {
+            allTasks = await loadPipelineTasks({
+                rootDir: ctx.config.rootDir,
+                mode: ctx.config.mode,
+                repoTasksPath: ctx.config.repoTasksPath,
+            });
+        }
         // Bridge: narrow to literacy tasks for canonical doc access
         const literacyTasks = allTasks.filter((t) => t.mode === "literacy");
         const tasksWithDocs = literacyTasks.filter((t) => (t.context?.docs?.length ?? 0) > 0);

package/dist/orchestration/steps/generate-configs-step.d.ts

@@ -18,6 +18,21 @@ export declare class GenerateConfigsStep implements PipelineStep {
     private compileLiteracyVariants;
     private compileSingleMode;
     private loadTasks;
+    /**
+     * Load tasks from the Content Lake via ctx.taskSource.
+     *
+     * The ContentLakeTaskSource adapter handles area/task/tag filtering
+     * in the GROQ query itself, so we build a FilterOptions and pass it
+     * through rather than filtering in-memory after loading.
+     */
+    private loadTasksFromContentLake;
+    /**
+     * Load tasks from filesystem .task.ts files.
+     *
+     * This is the original path used for repo-based and inline tasks.
+     * It scans tasks/{mode}/ and optionally --repo-tasks-path.
+     */
+    private loadTasksFromFilesystem;
     private applyFilters;
     /**
      * Build a descriptive error message when no tasks match the current filters.

package/dist/orchestration/steps/generate-configs-step.js

@@ -209,6 +209,50 @@ export class GenerateConfigsStep {
     // Task loading — unified for all modes
     // ---------------------------------------------------------------------------
     async loadTasks(ctx, mode, state) {
+        // Content Lake path — use ctx.taskSource (ContentLakeTaskSource) which
+        // loads ailf.task documents via GROQ. This is the only path that sees
+        // Studio-owned tasks (ownership: "studio").
+        if (ctx.config.taskSourceType === "content-lake") {
+            return this.loadTasksFromContentLake(ctx, state);
+        }
+        // Filesystem path — load from .task.ts files (repo tasks, inline tasks).
+        return this.loadTasksFromFilesystem(ctx, mode, state);
+    }
+    /**
+     * Load tasks from the Content Lake via ctx.taskSource.
+     *
+     * The ContentLakeTaskSource adapter handles area/task/tag filtering
+     * in the GROQ query itself, so we build a FilterOptions and pass it
+     * through rather than filtering in-memory after loading.
+     */
+    async loadTasksFromContentLake(ctx, state) {
+        const filter = {
+            ...(ctx.config.areas?.length ? { areas: ctx.config.areas } : {}),
+            ...(ctx.config.tasks?.length ? { taskIds: ctx.config.tasks } : {}),
+            ...(ctx.config.tags?.length ? { tags: ctx.config.tags } : {}),
+        };
+        const tasks = await ctx.taskSource.loadTasks(Object.keys(filter).length > 0 ? filter : undefined);
+        // Capture loaded IDs for error messages (same as filesystem path)
+        this.lastLoadedTaskIds = tasks
+            .map((t) => t.id)
+            .filter((id) => !!id);
+        // Release auto-scope
+        if (state.releaseAutoScope && !ctx.config.noAutoScope) {
+            const scopedIds = new Set(state.releaseAutoScope.affectedTaskIds);
+            const beforeCount = tasks.length;
+            const scoped = tasks.filter((t) => "id" in t && scopedIds.has(t.id));
+            ctx.logger.info(`  🎯 Auto-scoped to ${scoped.length} of ${beforeCount} task(s) affected by release`);
+            return scoped;
+        }
+        return tasks;
+    }
+    /**
+     * Load tasks from filesystem .task.ts files.
+     *
+     * This is the original path used for repo-based and inline tasks.
+     * It scans tasks/{mode}/ and optionally --repo-tasks-path.
+     */
+    async loadTasksFromFilesystem(ctx, mode, state) {
         const { resolve } = await import("path");
         const { discoverTsTaskFiles, loadTsTaskFile } = await import("../../adapters/task-sources/task-file-loader.js");
         const { resolveVendoredSubdir } = await import("../../pipeline/compiler/config-loader.js");

package/dist/orchestration/steps/run-eval-step.js

@@ -113,6 +113,11 @@ export class RunEvalStep {
                 // required eval modes were satisfied from the remote cache.
                 state.remoteCacheHits ??= new Set();
                 state.remoteCacheHits.add(this.mode);
+                // Carry forward Promptfoo share URLs from the cached report
+                if (remoteCacheResult.promptfooUrls?.length) {
+                    state.promptfooUrls ??= [];
+                    state.promptfooUrls.push(...remoteCacheResult.promptfooUrls);
+                }
                 // Capture the restored score-summary from remote cache
                 const cachedSummaryPath = resolve(rootDir, "results", "latest", "score-summary.json");
                 if (existsSync(cachedSummaryPath)) {
@@ -189,6 +194,14 @@ export class RunEvalStep {
                 mode: this.mode,
             });
         }
+        // Extract Promptfoo share URL from eval results (Step 3b)
+        if (ctx.evalRunner.extractShareUrl) {
+            const shareUrl = ctx.evalRunner.extractShareUrl(resolve(rootDir, resultsFileForMode(this.mode)));
+            if (shareUrl) {
+                state.promptfooUrls ??= [];
+                state.promptfooUrls.push({ mode: this.mode, url: shareUrl });
+            }
+        }
         const durationMs = Date.now() - start;
         return {
             durationMs,
@@ -224,6 +237,7 @@ async function checkRemoteCache(fingerprint, reportStore, rootDir) {
         console.log(`  ℹ️  Fingerprint: ${fingerprint.slice(0, 16)}... (${queryMs}ms)`);
         return {
             completedAt: cachedReport.completedAt,
+            promptfooUrls: cachedReport.provenance?.promptfooUrls,
             reportId: cachedReport.id,
         };
     }

package/dist/webhook/eval-request-handler.js

@@ -173,6 +173,10 @@ async function dispatchGitHubEval(repo, payload, config) {
             projectId: payload.projectId,
             publish: true,
             source: "production",
+            // Studio-initiated evals always use Content Lake as the task source.
+            // Without this, the pipeline only loads filesystem .task.ts files and
+            // Studio-owned tasks are invisible.
+            taskMode: "content-lake",
             // Release-scoped fields
             ...(hasPerspective ? { perspective: payload.perspective } : {}),
             // Task-scoped fields

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/ailf",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "private": false,
   "publishConfig": {
     "access": "public"