@sanity/ailf 0.1.0

package/dist/lib/webhook-server.js

@@ -0,0 +1,24 @@
+/**
+ * lib/webhook-server.ts — DEPRECATED re-export shim.
+ *
+ * The real implementation has moved to pipeline/webhook-server.ts.
+ * This shim preserves backward compatibility for direct CLI invocation.
+ *
+ * TODO: Update all importers to use pipeline/webhook-server.ts, then delete this file.
+ *
+ * @deprecated Import from ../pipeline/webhook-server.js instead.
+ */
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+import { startWebhookServer } from "../pipeline/webhook-server.js";
+export { startWebhookServer, } from "../pipeline/webhook-server.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, "..", "..");
+// When imported directly (e.g., `tsx src/lib/webhook-server.ts`), start the server
+startWebhookServer({
+    dailyBudget: parseInt(process.env.WEBHOOK_DAILY_BUDGET ?? "20", 10),
+    debounceMs: parseInt(process.env.WEBHOOK_DEBOUNCE_MS ?? "10000", 10),
+    githubToken: process.env.GITHUB_TOKEN ?? "",
+    port: parseInt(process.env.WEBHOOK_PORT ?? "3333", 10),
+    rootDir: ROOT,
+});

package/dist/lib/weekly-digest.d.ts

@@ -0,0 +1,24 @@
+/**
+ * weekly-digest.ts
+ *
+ * CLI script to generate and deliver a weekly evaluation digest.
+ *
+ * Queries the Sanity Content Lake for all reports within the configured
+ * lookback window, computes trend analysis, and delivers the digest
+ * via configured channels (Slack, stdout, or both).
+ *
+ * Usage:
+ *   pnpm weekly-digest                    # send to configured Slack webhook
+ *   pnpm weekly-digest --dry-run          # print to stdout only
+ *   pnpm weekly-digest --lookback 14      # 14-day lookback window
+ *   pnpm weekly-digest --json             # output raw JSON
+ *
+ * Environment variables:
+ *   SLACK_WEBHOOK_URL     — Slack incoming webhook URL
+ *   SANITY_API_TOKEN      — Sanity read token
+ *   AILF_TRIGGER_TYPE     — set to "scheduled" by the cron workflow
+ *   AILF_SCHEDULE         — the schedule name (e.g., "weekly-digest")
+ *
+ * @see docs/design-docs/report-store/implementation.md — Phase 5
+ */
+export declare function main(): Promise<void>;

package/dist/lib/weekly-digest.js

@@ -0,0 +1,148 @@
+/**
+ * weekly-digest.ts
+ *
+ * CLI script to generate and deliver a weekly evaluation digest.
+ *
+ * Queries the Sanity Content Lake for all reports within the configured
+ * lookback window, computes trend analysis, and delivers the digest
+ * via configured channels (Slack, stdout, or both).
+ *
+ * Usage:
+ *   pnpm weekly-digest                    # send to configured Slack webhook
+ *   pnpm weekly-digest --dry-run          # print to stdout only
+ *   pnpm weekly-digest --lookback 14      # 14-day lookback window
+ *   pnpm weekly-digest --json             # output raw JSON
+ *
+ * Environment variables:
+ *   SLACK_WEBHOOK_URL     — Slack incoming webhook URL
+ *   SANITY_API_TOKEN      — Sanity read token
+ *   AILF_TRIGGER_TYPE     — set to "scheduled" by the cron workflow
+ *   AILF_SCHEDULE         — the schedule name (e.g., "weekly-digest")
+ *
+ * @see docs/design-docs/report-store/implementation.md — Phase 5
+ */
+import { config as dotenvConfig } from "dotenv";
+import { existsSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+import { generateDigest } from "../schedules/digest.js";
+import { getDigestConfig } from "../schedules/loader.js";
+import { formatWeeklyDigest } from "../sinks/slack/format.js";
+// Load root .env (same override behavior as pipeline.ts)
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const envPath = resolve(__dirname, "..", "..", "..", "..", ".env");
+if (existsSync(envPath)) {
+    dotenvConfig({ override: true, path: envPath });
+}
+// ---------------------------------------------------------------------------
+// CLI argument parsing
+// ---------------------------------------------------------------------------
+const args = process.argv.slice(2);
+function getOption(name) {
+    const idx = args.indexOf(`--${name}`);
+    return idx >= 0 && idx + 1 < args.length ? args[idx + 1] : undefined;
+}
+function hasFlag(name) {
+    return args.includes(`--${name}`);
+}
+const DRY_RUN = hasFlag("dry-run");
+const JSON_OUTPUT = hasFlag("json");
+const lookbackOverride = getOption("lookback");
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+export async function main() {
+    console.log();
+    console.log("=== AI Literacy Weekly Digest ===");
+    console.log();
+    // Load digest config
+    const digestConfig = getDigestConfig();
+    const lookbackDays = lookbackOverride
+        ? parseInt(lookbackOverride, 10)
+        : (digestConfig?.lookbackDays ?? 7);
+    console.log(`  Lookback: ${lookbackDays} days`);
+    console.log(`  Mode: ${DRY_RUN ? "dry run (stdout only)" : "live"}`);
+    console.log();
+    // Generate digest — uses AILF_REPORT_* env vars for report store access,
+    // independent of SANITY_DATASET/SANITY_PROJECT_ID (which control doc evaluation)
+    const digest = await generateDigest({
+        dataset: process.env.AILF_REPORT_DATASET,
+        lookbackDays,
+        projectId: process.env.AILF_REPORT_PROJECT_ID,
+        token: process.env.AILF_REPORT_SANITY_API_TOKEN ?? process.env.SANITY_API_TOKEN,
+    });
+    if (!digest) {
+        console.log("  No reports found in the lookback window. Nothing to send.");
+        process.exit(0);
+    }
+    // Output
+    console.log(`  Reports found: ${digest.reportCount}`);
+    console.log(`  Overall: ${Math.round(digest.overallLatest)} (${digest.overallTrend})`);
+    console.log(`  Improved: ${digest.improved.join(", ") || "none"}`);
+    console.log(`  Regressed: ${digest.regressed.join(", ") || "none"}`);
+    console.log(`  Stable: ${digest.stable.join(", ") || "none"}`);
+    console.log();
+    if (JSON_OUTPUT) {
+        console.log(JSON.stringify(digest, null, 2));
+        return;
+    }
+    // Format for Slack
+    const message = formatWeeklyDigest(digest);
+    if (DRY_RUN) {
+        console.log("  --- Slack Message Preview ---");
+        console.log(`  Text: ${message.text}`);
+        console.log();
+        for (const block of message.blocks) {
+            if (block.text) {
+                console.log(`  [${block.type}] ${block.text.text}`);
+            }
+            if (block.fields) {
+                for (const field of block.fields) {
+                    console.log(`    [field] ${field.text}`);
+                }
+            }
+            if (block.elements) {
+                for (const el of block.elements) {
+                    console.log(`    [element] ${el.text}`);
+                }
+            }
+        }
+        console.log();
+        return;
+    }
+    // Deliver via Slack
+    const webhookUrl = digestConfig?.slackWebhookUrl ?? process.env.SLACK_WEBHOOK_URL;
+    if (!webhookUrl) {
+        console.warn("  ⚠️  No Slack webhook URL configured. Set SLACK_WEBHOOK_URL or configure in schedules.yaml");
+        console.log("  Printing digest to stdout instead:");
+        console.log();
+        console.log(`  ${message.text}`);
+        return;
+    }
+    console.log("  Sending to Slack...");
+    try {
+        const response = await fetch(webhookUrl, {
+            body: JSON.stringify(message),
+            headers: { "Content-Type": "application/json" },
+            method: "POST",
+        });
+        if (response.ok) {
+            console.log("  ✅ Digest sent successfully");
+        }
+        else {
+            const text = await response.text();
+            console.warn(`  ⚠️  Slack delivery failed: ${response.status} ${text}`);
+        }
+    }
+    catch (error) {
+        console.warn(`  ⚠️  Slack delivery error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+// Only run when invoked directly (not when imported)
+if (process.argv[1]?.endsWith("weekly-digest.ts") ||
+    process.argv[1]?.endsWith("weekly-digest.js")) {
+    main().catch((error) => {
+        console.error("Fatal error:", error);
+        process.exit(1);
+    });
+}

package/dist/orchestration/build-app-context.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Bridge from legacy ResolvedOptions to the new AppContext.
+ *
+ * This mapping function exists during the Phase 3→7 migration. It converts
+ * the old ResolvedOptions shape to ResolvedConfig, then delegates to
+ * createAppContext() (the composition root).
+ *
+ * Once all commands construct ResolvedConfig directly (or use --config),
+ * this bridge can be deleted.
+ */
+import type { AppContext, ResolvedConfig } from "../_vendor/ailf-core/index.d.ts";
+import type { ResolvedOptions } from "../commands/pipeline-action.js";
+/**
+ * Map legacy ResolvedOptions to ResolvedConfig.
+ *
+ * This is a mechanical mapping — every field in ResolvedConfig has a
+ * corresponding field in ResolvedOptions. Fields that don't map directly
+ * are derived (e.g., areas from areaOption).
+ */
+export declare function mapToResolvedConfig(opts: ResolvedOptions, rootDir: string): ResolvedConfig;
+/**
+ * Build an AppContext from legacy ResolvedOptions.
+ *
+ * Delegates to createAppContext() (composition root) after mapping
+ * ResolvedOptions → ResolvedConfig.
+ */
+export declare function buildAppContext(opts: ResolvedOptions, rootDir: string): AppContext;

package/dist/orchestration/build-app-context.js

@@ -0,0 +1,81 @@
+/**
+ * Bridge from legacy ResolvedOptions to the new AppContext.
+ *
+ * This mapping function exists during the Phase 3→7 migration. It converts
+ * the old ResolvedOptions shape to ResolvedConfig, then delegates to
+ * createAppContext() (the composition root).
+ *
+ * Once all commands construct ResolvedConfig directly (or use --config),
+ * this bridge can be deleted.
+ */
+import { createAppContext } from "../composition-root.js";
+/**
+ * Map legacy ResolvedOptions to ResolvedConfig.
+ *
+ * This is a mechanical mapping — every field in ResolvedConfig has a
+ * corresponding field in ResolvedOptions. Fields that don't map directly
+ * are derived (e.g., areas from areaOption).
+ */
+export function mapToResolvedConfig(opts, rootDir) {
+    return {
+        rootDir,
+        mode: opts.mode,
+        debug: opts.debug,
+        areas: opts.areaOption
+            ?.split(",")
+            .map((s) => s.trim())
+            .filter(Boolean),
+        tasks: opts.taskOption
+            ?.split(",")
+            .map((s) => s.trim())
+            .filter(Boolean),
+        changedDocs: opts.changedDocsOption
+            ?.split(",")
+            .map((s) => s.trim())
+            .filter(Boolean),
+        source: opts.source,
+        skipFetch: opts.skipFetch,
+        skipEval: opts.skipEval,
+        compareEnabled: opts.compareEnabled,
+        compareThreshold: opts.compareThreshold,
+        compareBaseline: opts.compareBaseline,
+        gapAnalysisEnabled: opts.gapAnalysisEnabled,
+        readinessEnabled: opts.readinessEnabled,
+        discoveryReportEnabled: opts.discoveryReportEnabled,
+        publishEnabled: opts.publishEnabled,
+        publishTag: opts.publishTag,
+        noCache: opts.noCache,
+        noRemoteCache: opts.noRemoteCache,
+        graderReplications: opts.graderReplications,
+        outputPath: opts.outputPath,
+        urls: opts.urlArgs.length > 0 ? opts.urlArgs : undefined,
+        headers: opts.headerArgs.length > 0
+            ? Object.fromEntries(opts.headerArgs.map((h) => {
+                const [key, ...rest] = h.split(":");
+                return [key.trim(), rest.join(":").trim()];
+            }))
+            : undefined,
+        allowedOrigins: opts.allowedOriginArgs.length > 0 ? opts.allowedOriginArgs : undefined,
+        searchMode: opts.searchMode ?? "open",
+        concurrency: opts.concurrency,
+        promptfooUrl: opts.promptfooUrl,
+        datasetOverride: opts.datasetOverride,
+        projectIdOverride: opts.projectIdOverride,
+        perspectiveOverride: opts.perspectiveOverride,
+        studioOriginOverride: opts.studioOriginOverride,
+        sanityDocumentArgs: opts.sanityDocumentArgs.length > 0 ? opts.sanityDocumentArgs : undefined,
+        beforeOption: opts.beforeOption,
+        taskSourceType: opts.taskSourceType,
+        repoTasksPath: opts.repoTasksPath,
+    };
+}
+/**
+ * Build an AppContext from legacy ResolvedOptions.
+ *
+ * Delegates to createAppContext() (composition root) after mapping
+ * ResolvedOptions → ResolvedConfig.
+ */
+export function buildAppContext(opts, rootDir) {
+    const config = mapToResolvedConfig(opts, rootDir);
+    return createAppContext(config);
+}

package/dist/orchestration/build-step-sequence.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Build the step sequence based on resolved config.
+ *
+ * This is the declarative description of the pipeline — a list of
+ * PipelineStep objects determined by config flags like skipFetch,
+ * skipEval, compareEnabled, etc.
+ */
+import type { AppContext, PipelineStep } from "../_vendor/ailf-core/index.d.ts";
+/**
+ * Build the pipeline step sequence based on config.
+ *
+ * @param ctx - The application context (used for config)
+ * @param pipelineStart - Pipeline start timestamp (for publish step)
+ */
+export declare function buildStepSequence(ctx: AppContext, pipelineStart?: number): PipelineStep[];

package/dist/orchestration/build-step-sequence.js

@@ -0,0 +1,84 @@
+/**
+ * Build the step sequence based on resolved config.
+ *
+ * This is the declarative description of the pipeline — a list of
+ * PipelineStep objects determined by config flags like skipFetch,
+ * skipEval, compareEnabled, etc.
+ */
+import { FULL_MODE_SUBMODES } from "../_vendor/ailf-shared/index.js";
+import { CallbackStep } from "./steps/callback-step.js";
+import { CalculateScoresStep } from "./steps/calculate-scores-step.js";
+import { CompareStep } from "./steps/compare-step.js";
+import { DiscoveryReportStep } from "./steps/discovery-report-step.js";
+import { FetchDocsStep } from "./steps/fetch-docs-step.js";
+import { GapAnalysisStep } from "./steps/gap-analysis-step.js";
+import { GenerateConfigsStep } from "./steps/generate-configs-step.js";
+import { GraderConsistencyStep } from "./steps/grader-consistency-step.js";
+import { PublishReportStep } from "./steps/publish-report-step.js";
+import { ReadinessStep } from "./steps/readiness-step.js";
+import { ReportStep } from "./steps/report-step.js";
+import { RunEvalStep } from "./steps/run-eval-step.js";
+import { MirrorRepoTasksStep } from "./steps/mirror-repo-tasks-step.js";
+import { ValidateStep } from "./steps/validate-step.js";
+/**
+ * Build the pipeline step sequence based on config.
+ *
+ * @param ctx - The application context (used for config)
+ * @param pipelineStart - Pipeline start timestamp (for publish step)
+ */
+export function buildStepSequence(ctx, pipelineStart = Date.now()) {
+    const config = ctx.config;
+    const steps = [];
+    // Step 0: Validate configuration
+    steps.push(new ValidateStep());
+    // Step 0b: Mirror repo tasks to Content Lake (optional, when --repo-tasks-path)
+    if (config.repoTasksPath) {
+        steps.push(new MirrorRepoTasksStep());
+    }
+    // Step 1: Fetch documentation (step handles --skip-fetch internally)
+    steps.push(new FetchDocsStep());
+    // Step 2: Generate Promptfoo configs
+    steps.push(new GenerateConfigsStep());
+    // Step 3: Run evaluation (steps handle --skip-eval internally)
+    const modes = config.mode === "full"
+        ? [...FULL_MODE_SUBMODES]
+        : [config.mode];
+    for (const mode of modes) {
+        steps.push(new RunEvalStep(mode));
+    }
+    // Step 3c: Grader consistency (optional, conditional)
+    if (config.graderReplications) {
+        steps.push(new GraderConsistencyStep());
+    }
+    // Step 4: Calculate scores
+    steps.push(new CalculateScoresStep());
+    // Step 4b: Gap analysis (on by default, opt-out via --no-gap-analysis)
+    if (config.gapAnalysisEnabled) {
+        steps.push(new GapAnalysisStep());
+    }
+    // Step 4b: Publish report (optional, when token is configured)
+    if (config.publishEnabled) {
+        steps.push(new PublishReportStep(pipelineStart, {
+            publishTag: config.publishTag,
+        }));
+    }
+    // Step 5: Generate report
+    steps.push(new ReportStep());
+    // Step 5b: Compare against baseline (optional)
+    if (config.compareEnabled) {
+        steps.push(new CompareStep());
+    }
+    // Step 6b: Readiness report (optional)
+    if (config.readinessEnabled) {
+        steps.push(new ReadinessStep());
+    }
+    // Step 6c: Discovery report (optional)
+    if (config.discoveryReportEnabled) {
+        steps.push(new DiscoveryReportStep());
+    }
+    // Step 7: Callback delivery (optional, API-triggered evaluations)
+    if (config.callback?.url) {
+        steps.push(new CallbackStep(config.callback, config.jobId));
+    }
+    return steps;
+}

package/dist/orchestration/config-to-source-overrides.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Extract source-relevant overrides from ResolvedConfig.
+ *
+ * Used by orchestration steps and command handlers to call loadSource()
+ * with typed overrides instead of relying on process.env.
+ */
+import type { ResolvedConfig } from "../_vendor/ailf-core/index.d.ts";
+import type { SourceOverrides } from "../sources.js";
+export declare function configToSourceOverrides(config: ResolvedConfig): SourceOverrides;

package/dist/orchestration/config-to-source-overrides.js

@@ -0,0 +1,28 @@
+/**
+ * Extract source-relevant overrides from ResolvedConfig.
+ *
+ * Used by orchestration steps and command handlers to call loadSource()
+ * with typed overrides instead of relying on process.env.
+ */
+export function configToSourceOverrides(config) {
+    return {
+        ...(config.allowedOrigins?.length
+            ? { allowedOrigins: config.allowedOrigins }
+            : {}),
+        ...(config.urls?.[0] ? { baseUrl: config.urls[0] } : {}),
+        ...(config.datasetOverride ? { dataset: config.datasetOverride } : {}),
+        ...(config.sanityDocumentArgs?.length
+            ? { documentIds: config.sanityDocumentArgs }
+            : {}),
+        ...(config.headers ? { headers: config.headers } : {}),
+        ...(config.perspectiveOverride
+            ? { perspective: config.perspectiveOverride }
+            : {}),
+        ...(config.projectIdOverride
+            ? { projectId: config.projectIdOverride }
+            : {}),
+        ...(config.studioOriginOverride
+            ? { studioOrigin: config.studioOriginOverride }
+            : {}),
+    };
+}

package/dist/orchestration/env-bridge.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Environment variable bridge — writes ResolvedConfig values to process.env
+ * so that lib/*.ts modules (which still read process.env) work correctly.
+ *
+ * This replaces the former global applyEnvironment() with an explicit
+ * per-step bridge. Each orchestration step calls this before invoking
+ * its lib/*.ts main() function.
+ *
+ * Phase 9 will eliminate this file entirely by giving lib/*.ts main()
+ * functions typed option parameters.
+ *
+ * @see docs/exec-plans/active/ports-and-adapters/phase-8-delete-legacy-step-layer.md
+ */
+import type { ResolvedConfig } from "../_vendor/ailf-core/index.d.ts";
+/**
+ * Bridge ResolvedConfig values to process.env.
+ *
+ * Idempotent — safe to call multiple times. Only sets env vars for
+ * config values that are defined (never deletes or resets).
+ */
+export declare function bridgeConfigToEnv(config: ResolvedConfig): void;

package/dist/orchestration/env-bridge.js

@@ -0,0 +1,66 @@
+/**
+ * Environment variable bridge — writes ResolvedConfig values to process.env
+ * so that lib/*.ts modules (which still read process.env) work correctly.
+ *
+ * This replaces the former global applyEnvironment() with an explicit
+ * per-step bridge. Each orchestration step calls this before invoking
+ * its lib/*.ts main() function.
+ *
+ * Phase 9 will eliminate this file entirely by giving lib/*.ts main()
+ * functions typed option parameters.
+ *
+ * @see docs/exec-plans/active/ports-and-adapters/phase-8-delete-legacy-step-layer.md
+ */
+/**
+ * Bridge ResolvedConfig values to process.env.
+ *
+ * Idempotent — safe to call multiple times. Only sets env vars for
+ * config values that are defined (never deletes or resets).
+ */
+export function bridgeConfigToEnv(config) {
+    // Mode
+    process.env.EVAL_MODE = config.mode;
+    // Search mode
+    if (config.searchMode !== "open") {
+        process.env.EVAL_SEARCH_MODE = config.searchMode;
+    }
+    // Source
+    if (config.source) {
+        process.env.DOC_SOURCE = config.source;
+    }
+    // URL-derived overrides
+    if (config.urls?.[0]) {
+        process.env.DOC_BASE_URL = config.urls[0];
+    }
+    // Sanity overrides
+    if (config.datasetOverride) {
+        process.env.SANITY_DATASET = config.datasetOverride;
+    }
+    if (config.projectIdOverride) {
+        process.env.SANITY_PROJECT_ID = config.projectIdOverride;
+    }
+    if (config.perspectiveOverride) {
+        process.env.SANITY_PERSPECTIVE = config.perspectiveOverride;
+    }
+    if (config.studioOriginOverride) {
+        process.env.SANITY_STUDIO_ORIGIN = config.studioOriginOverride;
+    }
+    if (config.sanityDocumentArgs?.length) {
+        process.env.SANITY_DOCUMENT_IDS = config.sanityDocumentArgs.join(",");
+    }
+    // Custom headers
+    if (config.headers) {
+        process.env.DOC_HEADERS = JSON.stringify(config.headers);
+    }
+    // Allowed origins
+    if (config.allowedOrigins?.length) {
+        process.env.DOC_ALLOWED_ORIGINS = config.allowedOrigins.join(",");
+    }
+    // Scoping filters
+    if (config.areas) {
+        process.env.EVAL_FILTER_AREAS = config.areas.join(",");
+    }
+    if (config.tasks) {
+        process.env.EVAL_FILTER_TASKS = config.tasks.join(",");
+    }
+}

package/dist/orchestration/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Orchestration barrel export.
+ *
+ * The new pipeline execution model: composable steps, uniform middleware,
+ * and declarative sequencing.
+ */
+export { buildAppContext, mapToResolvedConfig } from "./build-app-context.js";
+export { buildStepSequence } from "./build-step-sequence.js";
+export { orchestratePipeline } from "./pipeline-orchestrator.js";
+export { runStep } from "./step-runner.js";
+export * from "./steps/index.js";

package/dist/orchestration/index.js

@@ -0,0 +1,11 @@
+/**
+ * Orchestration barrel export.
+ *
+ * The new pipeline execution model: composable steps, uniform middleware,
+ * and declarative sequencing.
+ */
+export { buildAppContext, mapToResolvedConfig } from "./build-app-context.js";
+export { buildStepSequence } from "./build-step-sequence.js";
+export { orchestratePipeline } from "./pipeline-orchestrator.js";
+export { runStep } from "./step-runner.js";
+export * from "./steps/index.js";

package/dist/orchestration/pipeline-orchestrator.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Pipeline orchestrator — sequences steps and short-circuits on failure.
+ *
+ * This replaces the 1,672-line executePipeline() in pipeline-action.ts
+ * with declarative step sequencing. Each step is run through the
+ * StepRunner which provides uniform timing, precondition checking,
+ * error handling, and logging.
+ *
+ * When a jobId is present in the config (API-triggered evaluations),
+ * the orchestrator emits progress updates to the Content Lake after
+ * each step completes. This enables the GET /v1/jobs/:jobId polling
+ * endpoint to show real-time progress.
+ */
+import type { AppContext, PipelineResult, PipelineStep } from "../_vendor/ailf-core/index.d.ts";
+/**
+ * Run a sequence of pipeline steps, short-circuiting on required step failure.
+ *
+ * Optional steps (step.optional === true) may fail without stopping
+ * the pipeline. Required step failures cause an immediate abort.
+ *
+ * When ctx.config.jobId is set, emits progress updates to the Content
+ * Lake after each step completes.
+ */
+export declare function orchestratePipeline(ctx: AppContext, steps: PipelineStep[]): Promise<PipelineResult>;