@sanity/ailf 0.1.0

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

@@ -0,0 +1,30 @@
+/**
+ * Shell delegation for the fetch-docs step.
+ *
+ * Isolates the execSync call so it can be replaced when the pipeline
+ * fully migrates to the DocFetcher port.
+ */
+import { execSync } from "child_process";
+/**
+ * Run `pnpm fetch-docs` via shell.
+ *
+ * Returns a result object instead of throwing so the step can
+ * handle the failure uniformly.
+ */
+export function runFetchDocsShell(rootDir, source) {
+    try {
+        const sourceArg = source ? ` --source ${source}` : "";
+        execSync(`pnpm fetch-docs${sourceArg}`, {
+            cwd: rootDir,
+            env: process.env,
+            stdio: "inherit",
+        });
+        return { ok: true };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}

package/dist/orchestration/steps/fetch-docs-step.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Pipeline step: Fetch documentation from Sanity CMS.
+ *
+ * Uses ctx.docFetcher (the DocFetcher port) for all fetching. The adapter
+ * handles GROQ queries, perspective diffing, document overlays, and URL
+ * fetching. This step orchestrates the call and writes metadata files.
+ */
+import type { AppContext, PipelineStep, StepResult, ValidationIssue } from "../../_vendor/ailf-core/index.d.ts";
+export declare class FetchDocsStep implements PipelineStep {
+    readonly name = "fetch-docs";
+    check(): ValidationIssue[];
+    execute(ctx: AppContext): Promise<StepResult>;
+    cacheInputs(ctx: AppContext): string[];
+}

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

@@ -0,0 +1,135 @@
+/**
+ * Pipeline step: Fetch documentation from Sanity CMS.
+ *
+ * Uses ctx.docFetcher (the DocFetcher port) for all fetching. The adapter
+ * handles GROQ queries, perspective diffing, document overlays, and URL
+ * fetching. This step orchestrates the call and writes metadata files.
+ */
+import { mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import { getStepInputPaths } from "../../pipeline/cache.js";
+import { checkCanonicalContextsExist } from "../../pipeline/checks.js";
+import { loadSource } from "../../sources.js";
+import { configToSourceOverrides } from "../config-to-source-overrides.js";
+export class FetchDocsStep {
+    name = "fetch-docs";
+    check() {
+        return [];
+    }
+    async execute(ctx) {
+        if (ctx.config.skipFetch) {
+            return { status: "skipped", reason: "--skip-fetch" };
+        }
+        const start = Date.now();
+        // Precondition: at least one task has canonical doc mappings
+        const tasks = await ctx.taskSource.loadTasks(buildFilter(ctx));
+        const tasksWithDocs = tasks.filter((t) => t.canonicalDocs.length > 0);
+        if (tasksWithDocs.length === 0) {
+            return {
+                durationMs: Date.now() - start,
+                error: "No tasks with canonical_docs found. Add canonical_docs to your task definitions.",
+                status: "failed",
+            };
+        }
+        // Resolve source once with typed overrides
+        const overrides = configToSourceOverrides(ctx.config);
+        const resolvedSource = loadSource(ctx.config.source, overrides);
+        // Log source info
+        console.log(`  Source: ${resolvedSource.name}`);
+        console.log(`  Base URL: ${resolvedSource.baseUrl}`);
+        if (resolvedSource.perspective) {
+            console.log(`  Perspective: ${resolvedSource.perspective}`);
+        }
+        if (resolvedSource.documentIds && resolvedSource.documentIds.length > 0) {
+            console.log(`  Documents: ${resolvedSource.documentIds.length} document ID(s)`);
+        }
+        if (resolvedSource.urls.length > 0) {
+            console.log(`  URLs:      ${resolvedSource.urls.length} direct URL(s)`);
+        }
+        // Precondition: docFetcher must be available
+        if (!ctx.docFetcher) {
+            return {
+                durationMs: Date.now() - start,
+                error: "DocFetcher port not available. Ensure composition root wires ctx.docFetcher.",
+                status: "failed",
+            };
+        }
+        // Execute the fetch via the DocFetcher port
+        try {
+            const result = await ctx.docFetcher.fetch(tasksWithDocs, resolvedSource);
+            // Write metadata files for downstream pipeline consumption
+            if (result.metadata) {
+                writeMetadataFiles(ctx.config.rootDir, result.metadata);
+            }
+        }
+        catch (err) {
+            return {
+                durationMs: Date.now() - start,
+                error: `fetch-docs failed: ${err instanceof Error ? err.message : String(err)}`,
+                status: "failed",
+            };
+        }
+        // Postcondition: canonical context files exist for all tasks
+        const taskIds = tasksWithDocs.map((t) => t.id);
+        const contextIssues = checkCanonicalContextsExist(ctx.config.rootDir, taskIds);
+        const contextErrors = contextIssues.filter((i) => i.severity === "error");
+        if (contextErrors.length > 0) {
+            return {
+                durationMs: Date.now() - start,
+                error: `Postcondition failed: ${contextErrors.map((e) => e.message).join("; ")}`,
+                status: "failed",
+            };
+        }
+        const durationMs = Date.now() - start;
+        return {
+            durationMs,
+            status: "success",
+            summary: `Fetched canonical contexts for ${taskIds.length} tasks`,
+        };
+    }
+    cacheInputs(ctx) {
+        return getStepInputPaths(ctx.config.rootDir, "fetch-docs");
+    }
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function buildFilter(ctx) {
+    const { areas, tasks } = ctx.config;
+    if (!areas && !tasks)
+        return undefined;
+    return {
+        ...(areas ? { areas } : {}),
+        ...(tasks ? { taskIds: tasks } : {}),
+    };
+}
+/**
+ * Write metadata files returned by DocFetcher to the contexts/ directory.
+ *
+ * These files are consumed by downstream pipeline steps (scoring,
+ * comparison, reporting) for traceability and impact analysis.
+ */
+function writeMetadataFiles(rootDir, metadata) {
+    const contextsDir = join(rootDir, "contexts");
+    mkdirSync(contextsDir, { recursive: true });
+    if (metadata.manifest) {
+        const path = join(contextsDir, "document-manifest.json");
+        writeFileSync(path, JSON.stringify(metadata.manifest, null, 2));
+        console.log(`  📋 Document manifest: ${metadata.manifest.length} docs → contexts/document-manifest.json`);
+    }
+    if (metadata.releaseImpact) {
+        const path = join(contextsDir, "release-impact.json");
+        writeFileSync(path, JSON.stringify(metadata.releaseImpact, null, 2));
+        console.log("  📄 Release impact written to contexts/release-impact.json");
+    }
+    if (metadata.documentOverlay) {
+        const path = join(contextsDir, "document-overlay.json");
+        writeFileSync(path, JSON.stringify(metadata.documentOverlay, null, 2));
+        console.log("  📄 Document overlay written to contexts/document-overlay.json");
+    }
+    if (metadata.urlFetch) {
+        const path = join(contextsDir, "url-fetch.json");
+        writeFileSync(path, JSON.stringify(metadata.urlFetch, null, 2));
+        console.log("  📄 URL fetch metadata written to contexts/url-fetch.json");
+    }
+}

package/dist/orchestration/steps/gap-analysis-step.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Pipeline step: Gap analysis (failure modes + remediation plan).
+ *
+ * Wraps the inline gap-analysis logic from pipeline-action.ts behind
+ * the PipelineStep interface. This includes document manifest enrichment
+ * and low-scoring judgment extraction.
+ *
+ * This is an optional step — failure doesn't stop the pipeline.
+ */
+import type { AppContext, PipelineStep, StepResult, ValidationIssue } from "../../_vendor/ailf-core/index.d.ts";
+export declare class GapAnalysisStep implements PipelineStep {
+    readonly name = "gap-analysis";
+    readonly optional = true;
+    check(ctx: AppContext): ValidationIssue[];
+    execute(ctx: AppContext): Promise<StepResult>;
+}

package/dist/orchestration/steps/gap-analysis-step.js

@@ -0,0 +1,136 @@
+/**
+ * Pipeline step: Gap analysis (failure modes + remediation plan).
+ *
+ * Wraps the inline gap-analysis logic from pipeline-action.ts behind
+ * the PipelineStep interface. This includes document manifest enrichment
+ * and low-scoring judgment extraction.
+ *
+ * This is an optional step — failure doesn't stop the pipeline.
+ */
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join, resolve } from "path";
+export class GapAnalysisStep {
+    name = "gap-analysis";
+    optional = true;
+    check(ctx) {
+        const judgmentsPath = resolve(ctx.config.rootDir, "results", "latest", "grader-judgments.json");
+        if (!existsSync(judgmentsPath)) {
+            return [
+                {
+                    message: "No grader-judgments.json — run a full evaluation first",
+                    severity: "warning",
+                    source: "gap-analysis",
+                },
+            ];
+        }
+        return [];
+    }
+    async execute(ctx) {
+        const root = ctx.config.rootDir;
+        const start = Date.now();
+        const judgmentsPath = resolve(root, "results", "latest", "grader-judgments.json");
+        const scoreSummaryPath = resolve(root, "results", "latest", "score-summary.json");
+        if (!existsSync(judgmentsPath)) {
+            return {
+                status: "skipped",
+                reason: "No grader-judgments.json — run a full evaluation first",
+            };
+        }
+        if (!existsSync(scoreSummaryPath)) {
+            return { status: "skipped", reason: "No score-summary.json" };
+        }
+        try {
+            const { buildFailureModeReport, formatFailureModesConsole } = await import("../../pipeline/failure-modes.js");
+            const { buildGapAnalysisReport, formatGapAnalysisConsole } = await import("../../pipeline/gap-analysis.js");
+            const judgments = JSON.parse(readFileSync(judgmentsPath, "utf-8"));
+            const scoreSummary = JSON.parse(readFileSync(scoreSummaryPath, "utf-8"));
+            const failureModeReport = buildFailureModeReport(judgments, scoreSummary.scores);
+            console.log(formatFailureModesConsole(failureModeReport));
+            const gapReport = buildGapAnalysisReport(failureModeReport, scoreSummary.scores);
+            console.log(formatGapAnalysisConsole(gapReport));
+            const outDir = resolve(root, "results", "latest");
+            writeFileSync(join(outDir, "failure-modes.json"), JSON.stringify(failureModeReport, null, 2));
+            writeFileSync(join(outDir, "gap-analysis.json"), JSON.stringify(gapReport, null, 2));
+            // ── Document manifest + enrichment ─────────────────────────
+            const { resolveMappings } = await import("../../pipeline/resolve-mappings.js");
+            const mappings = resolveMappings(root);
+            const manifestPath = resolve(root, "contexts", "document-manifest.json");
+            const manifestEntries = existsSync(manifestPath)
+                ? JSON.parse(readFileSync(manifestPath, "utf-8"))
+                : [];
+            const refBySlug = new Map();
+            for (const entry of manifestEntries) {
+                refBySlug.set(entry.slug, entry);
+            }
+            const resolveRefs = (slugs) => slugs
+                .map((slug) => {
+                const m = refBySlug.get(slug);
+                return m
+                    ? {
+                        documentId: m._id,
+                        revision: m._rev,
+                        slug: m.slug,
+                        title: m.title,
+                    }
+                    : { documentId: "", slug, title: slug };
+            })
+                .filter((r) => r.documentId !== "");
+            const descToDocRefs = new Map();
+            const areaToDocRefs = new Map();
+            for (const [area, areaData] of Object.entries(mappings.feature_areas)) {
+                const areaSlugs = new Set();
+                for (const task of areaData.tasks) {
+                    const taskSlugs = task.canonical_docs.map((d) => d.slug);
+                    descToDocRefs.set(task.description, resolveRefs(taskSlugs));
+                    for (const s of taskSlugs)
+                        areaSlugs.add(s);
+                }
+                areaToDocRefs.set(area, resolveRefs([...areaSlugs]));
+            }
+            const documentManifest = resolveRefs([...refBySlug.keys()]);
+            const enrichedScores = scoreSummary.scores.map((s) => ({
+                ...s,
+                documents: areaToDocRefs.get(s.feature),
+            }));
+            // ── Low-scoring judgments ────────────────────────────────────
+            const LOW_SCORE_THRESHOLD = 70;
+            const MAX_STORED_JUDGMENTS = 50;
+            const normalizedJudgments = judgments.map((j) => ({
+                ...j,
+                score: j.score <= 1 && j.score > 0 ? Math.round(j.score * 100) : j.score,
+            }));
+            const lowScoringJudgments = normalizedJudgments
+                .filter((j) => j.score < LOW_SCORE_THRESHOLD)
+                .sort((a, b) => a.score - b.score)
+                .slice(0, MAX_STORED_JUDGMENTS)
+                .map((j) => {
+                const baseDesc = j.taskId.replace(/\s*\((gold|baseline)\)\s*$/, "");
+                const canonicalDocs = descToDocRefs.get(baseDesc);
+                return canonicalDocs ? { ...j, canonicalDocs } : j;
+            });
+            const enrichedSummary = {
+                ...scoreSummary,
+                documentManifest,
+                failureModes: failureModeReport,
+                lowScoringJudgments,
+                recommendations: gapReport,
+                scores: enrichedScores,
+            };
+            writeFileSync(scoreSummaryPath, JSON.stringify(enrichedSummary, null, 2));
+            const gapCount = gapReport.gaps.length;
+            const classRate = failureModeReport.classificationRate.toFixed(0);
+            return {
+                durationMs: Date.now() - start,
+                status: "success",
+                summary: `${failureModeReport.totalJudgments} judgments analyzed (${classRate}% classified), ${gapCount} actionable gaps identified`,
+            };
+        }
+        catch (err) {
+            return {
+                durationMs: Date.now() - start,
+                error: err instanceof Error ? err.message : String(err),
+                status: "failed",
+            };
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Pipeline step: Generate Promptfoo configuration files.
+ *
+ * Calls generateConfigs() from pipeline/generate-configs.ts with typed options
+ * derived from AppContext. No env bridge needed — source is resolved and
+ * passed directly.
+ */
+import type { AppContext, PipelineStep, StepResult, ValidationIssue } from "../../_vendor/ailf-core/index.d.ts";
+export declare class GenerateConfigsStep implements PipelineStep {
+    readonly name = "generate-configs";
+    check(ctx: AppContext): ValidationIssue[];
+    execute(ctx: AppContext): Promise<StepResult>;
+    cacheInputs(ctx: AppContext): string[];
+}

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

@@ -0,0 +1,85 @@
+/**
+ * Pipeline step: Generate Promptfoo configuration files.
+ *
+ * Calls generateConfigs() from pipeline/generate-configs.ts with typed options
+ * derived from AppContext. No env bridge needed — source is resolved and
+ * passed directly.
+ */
+import { getStepInputPaths } from "../../pipeline/cache.js";
+import { checkGeneratedConfigsExist } from "../../pipeline/checks.js";
+import { generateConfigs } from "../../pipeline/generate-configs.js";
+import { validateModelsYaml } from "../../pipeline/validate.js";
+import { loadSource } from "../../sources.js";
+import { configToSourceOverrides } from "../config-to-source-overrides.js";
+export class GenerateConfigsStep {
+    name = "generate-configs";
+    check(ctx) {
+        const issues = validateModelsYaml(ctx.config.rootDir);
+        return issues.filter((i) => i.severity === "error");
+    }
+    async execute(ctx) {
+        const start = Date.now();
+        // Resolve source once with typed overrides
+        const overrides = configToSourceOverrides(ctx.config);
+        const resolvedSource = ctx.config.source
+            ? loadSource(ctx.config.source, overrides)
+            : undefined;
+        // Load tasks via the TaskSource port — this picks up Content Lake,
+        // repo-based, and YAML tasks depending on which adapter is wired.
+        let tasks;
+        try {
+            const filter = ctx.config.areas || ctx.config.tasks
+                ? { areas: ctx.config.areas, taskIds: ctx.config.tasks }
+                : undefined;
+            tasks = await ctx.taskSource.loadTasks(filter);
+        }
+        catch (err) {
+            return {
+                durationMs: Date.now() - start,
+                error: `TaskSource.loadTasks failed: ${err instanceof Error ? err.message : String(err)}`,
+                status: "failed",
+            };
+        }
+        try {
+            generateConfigs({
+                allowedOrigins: ctx.config.allowedOrigins,
+                filter: ctx.config.areas || ctx.config.tasks
+                    ? {
+                        areas: ctx.config.areas,
+                        taskIds: ctx.config.tasks,
+                    }
+                    : undefined,
+                resolvedSource,
+                rootDir: ctx.config.rootDir,
+                searchMode: ctx.config.searchMode,
+                source: ctx.config.source,
+                tasks,
+            });
+        }
+        catch (err) {
+            return {
+                durationMs: Date.now() - start,
+                error: `generate-configs failed: ${err instanceof Error ? err.message : String(err)}`,
+                status: "failed",
+            };
+        }
+        // Postcondition: config files exist
+        const configIssues = checkGeneratedConfigsExist(ctx.config.rootDir);
+        const configErrors = configIssues.filter((i) => i.severity === "error");
+        if (configErrors.length > 0) {
+            return {
+                durationMs: Date.now() - start,
+                error: `Postcondition failed: ${configErrors.map((e) => e.message).join("; ")}`,
+                status: "failed",
+            };
+        }
+        return {
+            durationMs: Date.now() - start,
+            status: "success",
+            summary: "Generated promptfoo config files",
+        };
+    }
+    cacheInputs(ctx) {
+        return getStepInputPaths(ctx.config.rootDir, "generate-configs");
+    }
+}

package/dist/orchestration/steps/grader-consistency-step.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Pipeline step: Grader consistency analysis.
+ *
+ * Calls pipeline/grader-consistency-runner.ts directly with typed options.
+ * No env bridge needed — all parameters are passed directly.
+ */
+import type { AppContext, PipelineStep, StepResult, ValidationIssue } from "../../_vendor/ailf-core/index.d.ts";
+export declare class GraderConsistencyStep implements PipelineStep {
+    readonly name = "grader-consistency";
+    readonly optional = true;
+    check(): ValidationIssue[];
+    execute(ctx: AppContext): Promise<StepResult>;
+}

package/dist/orchestration/steps/grader-consistency-step.js

@@ -0,0 +1,64 @@
+/**
+ * Pipeline step: Grader consistency analysis.
+ *
+ * Calls pipeline/grader-consistency-runner.ts directly with typed options.
+ * No env bridge needed — all parameters are passed directly.
+ */
+import { existsSync } from "fs";
+import { resolve } from "path";
+import { checkResultsExist } from "../../pipeline/checks.js";
+import { RESULTS_FILES } from "../../pipeline/eval-constants.js";
+import { runGraderConsistency } from "../../pipeline/grader-consistency-runner.js";
+export class GraderConsistencyStep {
+    name = "grader-consistency";
+    optional = true;
+    check() {
+        return [];
+    }
+    async execute(ctx) {
+        const start = Date.now();
+        const replications = ctx.config.graderReplications ?? 5;
+        const concreteMode = ctx.config.mode === "full"
+            ? "baseline"
+            : ctx.config.mode;
+        const resultsFile = RESULTS_FILES[concreteMode];
+        // Precondition: results file exists
+        const resultsIssues = checkResultsExist(ctx.config.rootDir, resultsFile);
+        const resultsErrors = resultsIssues.filter((i) => i.severity === "error");
+        if (resultsErrors.length > 0) {
+            return {
+                durationMs: Date.now() - start,
+                error: `Results missing: ${resultsErrors.map((e) => e.message).join("; ")}. Run eval first.`,
+                status: "failed",
+            };
+        }
+        try {
+            await runGraderConsistency({
+                replications,
+                resultsPath: resolve(ctx.config.rootDir, resultsFile),
+                rootDir: ctx.config.rootDir,
+            });
+        }
+        catch (err) {
+            return {
+                durationMs: Date.now() - start,
+                error: `grader-consistency failed: ${err instanceof Error ? err.message : String(err)}`,
+                status: "failed",
+            };
+        }
+        // Postcondition: output file exists
+        const outputPath = resolve(ctx.config.rootDir, "results", "latest", "grader-consistency.json");
+        if (!existsSync(outputPath)) {
+            return {
+                durationMs: Date.now() - start,
+                error: "grader-consistency.json was not created",
+                status: "failed",
+            };
+        }
+        return {
+            durationMs: Date.now() - start,
+            status: "success",
+            summary: `Grader consistency analysis complete (${replications} replications)`,
+        };
+    }
+}

package/dist/orchestration/steps/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * PipelineStep implementations — wrappers around existing step functions.
+ *
+ * Each class delegates to the legacy step function, reading config from
+ * AppContext instead of positional parameters.
+ */
+export { CalculateScoresStep } from "./calculate-scores-step.js";
+export { CompareStep } from "./compare-step.js";
+export { DiscoveryReportStep } from "./discovery-report-step.js";
+export { FetchDocsStep } from "./fetch-docs-step.js";
+export { GapAnalysisStep } from "./gap-analysis-step.js";
+export { GenerateConfigsStep } from "./generate-configs-step.js";
+export { MirrorRepoTasksStep } from "./mirror-repo-tasks-step.js";
+export { GraderConsistencyStep } from "./grader-consistency-step.js";
+export { PublishReportStep } from "./publish-report-step.js";
+export { ReadinessStep } from "./readiness-step.js";
+export { ReportStep } from "./report-step.js";
+export { RunEvalStep } from "./run-eval-step.js";
+export { ValidateStep } from "./validate-step.js";

package/dist/orchestration/steps/index.js

@@ -0,0 +1,19 @@
+/**
+ * PipelineStep implementations — wrappers around existing step functions.
+ *
+ * Each class delegates to the legacy step function, reading config from
+ * AppContext instead of positional parameters.
+ */
+export { CalculateScoresStep } from "./calculate-scores-step.js";
+export { CompareStep } from "./compare-step.js";
+export { DiscoveryReportStep } from "./discovery-report-step.js";
+export { FetchDocsStep } from "./fetch-docs-step.js";
+export { GapAnalysisStep } from "./gap-analysis-step.js";
+export { GenerateConfigsStep } from "./generate-configs-step.js";
+export { MirrorRepoTasksStep } from "./mirror-repo-tasks-step.js";
+export { GraderConsistencyStep } from "./grader-consistency-step.js";
+export { PublishReportStep } from "./publish-report-step.js";
+export { ReadinessStep } from "./readiness-step.js";
+export { ReportStep } from "./report-step.js";
+export { RunEvalStep } from "./run-eval-step.js";
+export { ValidateStep } from "./validate-step.js";

package/dist/orchestration/steps/mirror-repo-tasks-step.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Pipeline step: Mirror repo-based tasks to the Content Lake.
+ *
+ * When --repo-tasks-path is provided, this step upserts mirror documents
+ * in the Sanity Content Lake for all repo-sourced tasks. This makes
+ * repo tasks visible in Studio with full provenance tracking.
+ *
+ * The step is optional — mirror failure does not block the pipeline.
+ * It runs after validate and before fetch-docs so mirror documents
+ * exist before evaluation begins.
+ *
+ * @see packages/eval/src/pipeline/mirror-repo-tasks.ts
+ * @see docs/exec-plans/completed/tasks-as-content/phase-5-content-lake-mirroring.md
+ */
+import type { AppContext, PipelineStep, StepResult, ValidationIssue } from "../../_vendor/ailf-core/index.d.ts";
+export declare class MirrorRepoTasksStep implements PipelineStep {
+    readonly name = "mirror-repo-tasks";
+    readonly optional = true;
+    check(_ctx: AppContext): ValidationIssue[];
+    execute(ctx: AppContext): Promise<StepResult>;
+}

package/dist/orchestration/steps/mirror-repo-tasks-step.js

@@ -0,0 +1,94 @@
+/**
+ * Pipeline step: Mirror repo-based tasks to the Content Lake.
+ *
+ * When --repo-tasks-path is provided, this step upserts mirror documents
+ * in the Sanity Content Lake for all repo-sourced tasks. This makes
+ * repo tasks visible in Studio with full provenance tracking.
+ *
+ * The step is optional — mirror failure does not block the pipeline.
+ * It runs after validate and before fetch-docs so mirror documents
+ * exist before evaluation begins.
+ *
+ * @see packages/eval/src/pipeline/mirror-repo-tasks.ts
+ * @see docs/exec-plans/completed/tasks-as-content/phase-5-content-lake-mirroring.md
+ */
+import { getSanityClient } from "../../sanity/client.js";
+import { detectGitContext, mirrorRepoTasks, } from "../../pipeline/mirror-repo-tasks.js";
+export class MirrorRepoTasksStep {
+    name = "mirror-repo-tasks";
+    optional = true;
+    check(_ctx) {
+        // This step is optional — no hard preconditions
+        // If no repo-tasks-path, it will be skipped in execute()
+        return [];
+    }
+    async execute(ctx) {
+        const start = Date.now();
+        // Skip if no repo tasks configured
+        if (!ctx.config.repoTasksPath) {
+            return { status: "skipped", reason: "No --repo-tasks-path provided" };
+        }
+        // Need a write token for mirroring
+        const token = process.env.AILF_REPORT_SANITY_API_TOKEN ?? process.env.SANITY_API_TOKEN;
+        if (!token) {
+            return {
+                status: "skipped",
+                reason: "No write token available for Content Lake mirroring",
+            };
+        }
+        try {
+            // Load repo tasks via the task source
+            // The CompositeTaskSource is already wired — but we only want
+            // the repo tasks, not the Content Lake ones. Load directly from
+            // RepoTaskSource via a fresh instance.
+            const { RepoTaskSource } = await import("../../adapters/task-sources/repo-task-source.js");
+            const repoSource = new RepoTaskSource(ctx.config.repoTasksPath);
+            const repoTasks = await repoSource.loadTasks();
+            if (repoTasks.length === 0) {
+                return {
+                    durationMs: Date.now() - start,
+                    status: "success",
+                    summary: "No repo tasks to mirror",
+                };
+            }
+            // Detect git context (from env vars or git CLI)
+            const git = await detectGitContext(ctx.config.repoTasksPath);
+            ctx.logger.info(`  Mirroring ${repoTasks.length} repo task(s) from ${git.repo}@${git.branch}`);
+            // Create a client with write access
+            const client = getSanityClient({ token });
+            // Run the mirror
+            const result = await mirrorRepoTasks({
+                client,
+                tasks: repoTasks,
+                git,
+            });
+            // Log results
+            if (result.areasCreated.length > 0) {
+                ctx.logger.info(`  Auto-created feature areas: ${result.areasCreated.join(", ")}`);
+            }
+            if (result.unresolvedSlugs.length > 0) {
+                ctx.logger.warn(`  Unresolved canonical doc slugs: ${result.unresolvedSlugs.join(", ")}`);
+            }
+            for (const err of result.errors) {
+                ctx.logger.warn(`  Mirror error: ${err}`);
+            }
+            return {
+                durationMs: Date.now() - start,
+                status: "success",
+                summary: `Mirrored ${result.upserted} task(s), skipped ${result.skipped} unchanged` +
+                    (result.errors.length > 0
+                        ? ` (${result.errors.length} error(s))`
+                        : ""),
+            };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            ctx.logger.warn(`Mirror step failed (non-blocking): ${msg}`);
+            return {
+                durationMs: Date.now() - start,
+                status: "success",
+                summary: `Mirror failed (non-blocking): ${msg}`,
+            };
+        }
+    }
+}