@sanity/ailf 0.1.0

package/dist/_vendor/ailf-core/ports/cache-store.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Port: How evaluation caching works.
+ *
+ * The CacheStore abstracts pipeline step caching behind a uniform
+ * interface. The StepRunner uses it for automatic cache lookup/record
+ * so individual steps don't need to manage their own caching.
+ *
+ * Adapters:
+ * - FilesystemCache — local results/cache/ directory (current behavior)
+ * - ContentLakeCacheAdapter — decorator that adds remote fingerprint
+ *   lookup on local cache miss
+ * - NoOpCache (testing) — always misses
+ *
+ * @see packages/eval/src/pipeline/cache.ts — existing implementation
+ * @see docs/design-docs/content-lake-eval-caching.md
+ */
+/**
+ * Opaque cache key — a content hash of the step's input files.
+ * Branded to prevent accidentally passing raw strings.
+ */
+export type CacheKey = string & {
+    readonly __brand: "CacheKey";
+};
+/**
+ * Stored metadata for a cache entry.
+ * Kept minimal — just enough for cache status reporting.
+ */
+export interface CacheEntryMetadata {
+    /** Duration of the original execution in milliseconds */
+    durationMs: number;
+    /** Output file paths produced (relative to package root) */
+    outputPaths: string[];
+    /** Human-readable summary of what was cached */
+    summary: string;
+    /** When this entry was created (ISO 8601) */
+    timestamp: string;
+}
+/** Result of a cache lookup */
+export type CacheLookupResult = {
+    hit: true;
+    entry: CacheEntryMetadata;
+} | {
+    hit: false;
+};
+/** Metadata to record after a successful step execution */
+export interface CacheRecordInput {
+    /** Duration of the execution in milliseconds */
+    durationMs: number;
+    /** Output file paths produced (relative to package root) */
+    outputPaths: string[];
+    /** Human-readable summary */
+    summary: string;
+}
+/**
+ * Port: Pipeline step caching.
+ *
+ * The StepRunner calls these methods around step execution:
+ * 1. computeKey(step.cacheInputs(ctx)) → CacheKey
+ * 2. lookup(stepName, key) → hit or miss
+ * 3. (on miss) execute step
+ * 4. (on success) record(stepName, key, metadata)
+ */
+export interface CacheStore {
+    /** Compute a cache key from file paths and optional context strings */
+    computeKey(inputPaths: string[], context?: string[]): Promise<CacheKey>;
+    /** Look up a cache entry by step name and key */
+    lookup(step: string, key: CacheKey): Promise<CacheLookupResult>;
+    /** Record a cache entry after successful step execution */
+    record(step: string, key: CacheKey, metadata: CacheRecordInput): Promise<void>;
+    /** Clear all cache entries */
+    clear(): Promise<void>;
+}

package/dist/_vendor/ailf-core/ports/cache-store.js

@@ -0,0 +1,17 @@
+/**
+ * Port: How evaluation caching works.
+ *
+ * The CacheStore abstracts pipeline step caching behind a uniform
+ * interface. The StepRunner uses it for automatic cache lookup/record
+ * so individual steps don't need to manage their own caching.
+ *
+ * Adapters:
+ * - FilesystemCache — local results/cache/ directory (current behavior)
+ * - ContentLakeCacheAdapter — decorator that adds remote fingerprint
+ *   lookup on local cache miss
+ * - NoOpCache (testing) — always misses
+ *
+ * @see packages/eval/src/pipeline/cache.ts — existing implementation
+ * @see docs/design-docs/content-lake-eval-caching.md
+ */
+export {};

package/dist/_vendor/ailf-core/ports/config-source.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Port: Where pipeline configuration comes from.
+ *
+ * The ConfigSource abstracts configuration resolution so the pipeline
+ * can be driven from different sources without changing orchestration:
+ *
+ * Adapters:
+ * - CliConfigAdapter — Commander flags + env vars (current behavior)
+ * - FileConfigAdapter — reads a JSON/YAML config file (--config flag)
+ * - ContentLakeConfigAdapter (future: studio-eval-config) — GROQ query
+ *
+ * @see packages/eval/src/commands/pipeline-action.ts — current implementation
+ * @see docs/ideas/studio-eval-config.md — future Content Lake adapter
+ */
+import type { ResolvedConfig } from "./context.js";
+/**
+ * Port: Resolve pipeline configuration from any source into the
+ * canonical ResolvedConfig shape.
+ *
+ * The adapter handles parsing, validation (via Zod), and defaults.
+ * The returned config is fully resolved — no env var lookups needed
+ * downstream.
+ */
+export interface ConfigSource {
+    /** Human-readable label for diagnostics (e.g., "CLI flags", "config.json") */
+    readonly label: string;
+    /**
+     * Resolve configuration into the canonical ResolvedConfig shape.
+     *
+     * @throws on validation failure (invalid config file, missing fields)
+     */
+    resolve(): Promise<ResolvedConfig>;
+}

package/dist/_vendor/ailf-core/ports/config-source.js

@@ -0,0 +1,15 @@
+/**
+ * Port: Where pipeline configuration comes from.
+ *
+ * The ConfigSource abstracts configuration resolution so the pipeline
+ * can be driven from different sources without changing orchestration:
+ *
+ * Adapters:
+ * - CliConfigAdapter — Commander flags + env vars (current behavior)
+ * - FileConfigAdapter — reads a JSON/YAML config file (--config flag)
+ * - ContentLakeConfigAdapter (future: studio-eval-config) — GROQ query
+ *
+ * @see packages/eval/src/commands/pipeline-action.ts — current implementation
+ * @see docs/ideas/studio-eval-config.md — future Content Lake adapter
+ */
+export {};

package/dist/_vendor/ailf-core/ports/context.d.ts

@@ -0,0 +1,172 @@
+/**
+ * Application context — the dependency carrier for all pipeline operations.
+ *
+ * Passed to every pipeline step, domain service, and adapter that needs
+ * access to infrastructure. Replaces process.env as the state-passing
+ * mechanism.
+ *
+ * Created once per CLI invocation by createAppContext() (composition root).
+ * Created per-test by createTestContext().
+ *
+ * Fields marked optional are transitional — they will become required
+ * as downstream consumers are converted to use them.
+ */
+import type { DebugOptions, EvalMode } from "../types/index.js";
+import type { CacheStore } from "./cache-store.js";
+import type { DocFetcher } from "./doc-fetcher.js";
+import type { EvalRunner } from "./eval-runner.js";
+import type { Logger } from "./logger.js";
+import type { TaskSource } from "./task-source.js";
+/**
+ * Resolved pipeline configuration — the typed, validated result of
+ * merging CLI flags, env vars, config files, and defaults.
+ *
+ * This replaces the ~25 process.env variables that applyEnvironment()
+ * currently sets. Fields are added incrementally as steps are converted.
+ */
+export interface ResolvedConfig {
+    /** Eval package root directory */
+    rootDir: string;
+    /** Evaluation mode */
+    mode: EvalMode;
+    /** Debug options */
+    debug?: DebugOptions;
+    /** Feature area filter */
+    areas?: string[];
+    /** Task ID filter */
+    tasks?: string[];
+    /** Changed doc slugs for impact scoping */
+    changedDocs?: string[];
+    /** Documentation source name */
+    source?: string;
+    /** Whether to skip the fetch-docs step */
+    skipFetch: boolean;
+    /** Whether to skip the eval step */
+    skipEval: boolean;
+    /** Whether comparison is enabled */
+    compareEnabled: boolean;
+    /** Comparison noise threshold */
+    compareThreshold?: number;
+    /** Comparison baseline path */
+    compareBaseline?: string;
+    /** Whether gap analysis is enabled */
+    gapAnalysisEnabled: boolean;
+    /** Whether readiness report is enabled */
+    readinessEnabled: boolean;
+    /** Whether discovery report is enabled */
+    discoveryReportEnabled: boolean;
+    /** Whether publishing is enabled */
+    publishEnabled: boolean;
+    /** Publish tag */
+    publishTag?: string;
+    /** Whether to disable local cache */
+    noCache: boolean;
+    /** Whether to disable remote (Content Lake) cache */
+    noRemoteCache: boolean;
+    /** Grader replications for consistency measurement */
+    graderReplications?: number;
+    /** Output path override */
+    outputPath?: string;
+    /** Doc source URL overrides */
+    urls?: string[];
+    /** Custom headers for doc fetching */
+    headers?: Record<string, string>;
+    /** Allowed origins for agentic mode */
+    allowedOrigins?: string[];
+    /** Search mode for agentic mode */
+    searchMode: "off" | "open" | "origin-only";
+    /** Eval concurrency */
+    concurrency?: number;
+    /** Promptfoo URL from eval output */
+    promptfooUrl?: string;
+    /** Sanity dataset override */
+    datasetOverride?: string;
+    /** Sanity project ID override */
+    projectIdOverride?: string;
+    /** Sanity perspective override */
+    perspectiveOverride?: string;
+    /** Sanity studio origin override */
+    studioOriginOverride?: string;
+    /** Sanity document filter args */
+    sanityDocumentArgs?: string[];
+    /** Before option for comparison */
+    beforeOption?: string;
+    /** Task source adapter selection */
+    taskSourceType?: "content-lake" | "yaml";
+    /** Path to repo-based tasks directory (e.g., .ailf/tasks/) */
+    repoTasksPath?: string;
+    /** Callback URL configuration for API-triggered evaluations */
+    callback?: {
+        url: string;
+        headers?: Record<string, string>;
+    };
+    /** Job ID for tracking API-triggered evaluations in the Content Lake */
+    jobId?: string;
+}
+/**
+ * Application context — the complete dependency carrier.
+ *
+ * Every pipeline step, domain service, and adapter receives this
+ * as its first parameter. It replaces:
+ * - process.env (environment-based state passing)
+ * - Module-level singletons (implicit global state)
+ * - Direct constructor calls (ad-hoc dependency creation)
+ *
+ * Created once per CLI invocation by createAppContext().
+ * Created per-test by createTestContext().
+ */
+export interface AppContext {
+    /** Evaluation caching (filesystem + optional Content Lake fallback) */
+    readonly cache?: CacheStore;
+    /** Resolved pipeline configuration */
+    readonly config: ResolvedConfig;
+    /** Documentation context fetcher */
+    readonly docFetcher?: DocFetcher;
+    /** LLM evaluation runner (Promptfoo adapter) */
+    readonly evalRunner: EvalRunner;
+    /** Structured logger */
+    readonly logger: Logger;
+    /**
+     * Persistent report store (Sanity Content Lake).
+     * Optional — not all commands need it. Commands that publish or
+     * query reports (publish, weekly-digest, pipeline with --publish)
+     * require this field.
+     */
+    readonly reportStore?: ReportStorePort;
+    /**
+     * Report delivery sinks (Slack, BigQuery, webhooks).
+     * Empty array when no sinks are configured.
+     */
+    readonly sinks?: ReportSinkPort[];
+    /** Task definition source (YAML, Content Lake, repo) */
+    readonly taskSource: TaskSource;
+}
+/**
+ * Minimal report store interface used by AppContext.
+ *
+ * The concrete ReportStore class in packages/eval implements this.
+ * Defined as a structural interface so the domain kernel has no
+ * import dependency on the concrete class.
+ */
+export interface ReportStorePort {
+    /** Auto-compare against the most recent comparable baseline */
+    autoCompare(currentSummary: unknown, provenance: unknown, completedAt: unknown): Promise<unknown>;
+    /** Find a report by its eval fingerprint (for cache lookup) */
+    findByFingerprint(fingerprint: string): Promise<null | unknown>;
+    /** Find the most recent comparable baseline for auto-comparison */
+    findComparableBaseline(query: unknown): Promise<null | unknown>;
+    /** Write a report to the store */
+    write(report: unknown): Promise<unknown>;
+}
+/**
+ * Minimal report sink interface used by AppContext.
+ *
+ * The concrete ReportSink type in packages/eval/src/sinks/ implements this.
+ * Defined structurally to avoid coupling the domain kernel to sink implementations.
+ */
+export interface ReportSinkPort {
+    /** Human-readable name for logging */
+    readonly name: string;
+    /** Deliver a report to this sink */
+    publish(report: unknown): Promise<unknown>;
+}

package/dist/_vendor/ailf-core/ports/context.js

@@ -0,0 +1,14 @@
+/**
+ * Application context — the dependency carrier for all pipeline operations.
+ *
+ * Passed to every pipeline step, domain service, and adapter that needs
+ * access to infrastructure. Replaces process.env as the state-passing
+ * mechanism.
+ *
+ * Created once per CLI invocation by createAppContext() (composition root).
+ * Created per-test by createTestContext().
+ *
+ * Fields marked optional are transitional — they will become required
+ * as downstream consumers are converted to use them.
+ */
+export {};

package/dist/_vendor/ailf-core/ports/doc-fetcher.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Port: Where documentation context comes from.
+ *
+ * Adapters:
+ * - SanityDocFetcher — GROQ queries against Sanity Content Lake
+ *   (perspective diffing, document overlays, URL fetching)
+ * - InMemoryDocFetcher (testing) — returns pre-loaded content
+ *
+ * The pipeline orchestrator and all downstream steps work with
+ * FetchResult regardless of where the documentation came from.
+ */
+import type { TaskDefinition } from "./task-source.js";
+/**
+ * A fetched documentation context ready for injection into prompts.
+ *
+ * Each DocContext corresponds to one task's documentation — the combined
+ * markdown of all canonical docs for that task plus any overlays/URLs.
+ */
+export interface DocContext {
+    /** The task ID this context belongs to */
+    taskId: string;
+    /** Combined markdown content of the fetched documentation */
+    content: string;
+    /** Document slugs included in this context */
+    slugs: string[];
+    /** Approximate token count (length / 4) */
+    tokenCount?: number;
+}
+/**
+ * Configuration for a documentation source.
+ *
+ * Maps to the resolved source config from config/sources.yaml, but
+ * expressed as a domain type independent of the YAML structure.
+ */
+export interface DocSourceConfig {
+    /** Base URL (e.g., "https://www.sanity.io/docs") */
+    baseUrl?: string;
+    /** Sanity dataset (e.g., "production") */
+    dataset?: string;
+    /** Sanity project ID */
+    projectId?: string;
+    /** Custom headers for authenticated requests */
+    headers?: Record<string, string>;
+    /** Content release perspective (e.g., bundle name) */
+    perspective?: string;
+    /** Direct URLs to fetch and include in context */
+    urls?: string[];
+    /** Sanity document IDs for overlay (replace/append to canonical docs) */
+    documentIds?: string[];
+}
+/** Metadata about a fetched document, for traceability */
+export interface DocumentManifestEntry {
+    _id: string;
+    _rev: string;
+    slug: string;
+    title: string;
+}
+/** Impact of a content release on canonical documents */
+export interface ReleaseImpact {
+    added: string[];
+    modified: string[];
+    removed: string[];
+    unchanged: string[];
+}
+/** Summary of document overlay operations */
+export interface DocumentOverlaySummary {
+    appendedCount: number;
+    documentIds: string[];
+    replacedSlugs: string[];
+}
+/** Metadata for a single URL fetch result */
+export interface UrlFetchEntry {
+    contentLength?: number;
+    error?: string;
+    method: string;
+    status?: number;
+    url: string;
+}
+/** Summary of URL fetch operations */
+export interface UrlFetchSummary {
+    failures: {
+        error?: string;
+        url: string;
+    }[];
+    fetchedUrls: UrlFetchEntry[];
+    totalFailed: number;
+    totalFetched: number;
+}
+/** Metadata about the fetch operation, for downstream pipeline consumption */
+export interface FetchMetadata {
+    /** Document manifest for traceability (slug, _id, _rev, title) */
+    manifest?: DocumentManifestEntry[];
+    /** Release impact from perspective diffing */
+    releaseImpact?: ReleaseImpact;
+    /** Document overlay operations summary */
+    documentOverlay?: DocumentOverlaySummary;
+    /** URL fetch operations summary */
+    urlFetch?: UrlFetchSummary;
+}
+/** Complete result of a doc fetch operation */
+export interface FetchResult {
+    /** Per-task documentation contexts */
+    contexts: DocContext[];
+    /** Optional metadata about the fetch (manifests, impact, overlays, URLs) */
+    metadata?: FetchMetadata;
+}
+/**
+ * Port: Where documentation context comes from.
+ *
+ * The pipeline never knows HOW docs are fetched — it only sees
+ * FetchResult. The adapter handles GROQ queries, Portable Text
+ * conversion, URL fetching, perspective diffing, document overlays, etc.
+ */
+export interface DocFetcher {
+    /**
+     * Fetch documentation context for a set of tasks.
+     *
+     * The adapter:
+     * 1. Collects unique slugs from tasks' canonicalDocs
+     * 2. Fetches documents from the source (with perspective/overlay support)
+     * 3. Converts to markdown
+     * 4. Assembles per-task context (combining all canonical docs + overlays)
+     * 5. Writes context files to disk (for Promptfoo consumption)
+     * 6. Returns structured metadata (manifest, release impact, etc.)
+     *
+     * @param tasks — Task definitions with canonical doc references
+     * @param source — Where to fetch documentation from
+     * @returns Fetched doc contexts + optional metadata
+     */
+    fetch(tasks: TaskDefinition[], source?: DocSourceConfig): Promise<FetchResult>;
+}

package/dist/_vendor/ailf-core/ports/doc-fetcher.js

@@ -0,0 +1,12 @@
+/**
+ * Port: Where documentation context comes from.
+ *
+ * Adapters:
+ * - SanityDocFetcher — GROQ queries against Sanity Content Lake
+ *   (perspective diffing, document overlays, URL fetching)
+ * - InMemoryDocFetcher (testing) — returns pre-loaded content
+ *
+ * The pipeline orchestrator and all downstream steps work with
+ * FetchResult regardless of where the documentation came from.
+ */
+export {};

package/dist/_vendor/ailf-core/ports/eval-runner.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Port: How LLM evaluation is executed.
+ *
+ * Abstracts the eval engine (Promptfoo today, potentially something else
+ * in the future). The domain kernel never mentions Promptfoo — it works
+ * with evaluation results.
+ */
+import type { StepResult } from "../types/index.js";
+export interface EvalRunConfig {
+    /** Path to the promptfoo config file to execute */
+    configPath: string;
+    /** Debug filter flags (--filter-first-n, --filter-pattern, etc.) */
+    filterFlags?: string;
+    /** Concurrency limit */
+    concurrency?: number;
+    /** Environment variables to pass to the eval process */
+    env?: Record<string, string>;
+}
+export interface EvalRunner {
+    /** Run an evaluation and return the step result */
+    run(config: EvalRunConfig): Promise<StepResult>;
+    /** Extract the share URL from eval output (Promptfoo-specific) */
+    extractShareUrl?(outputPath: string): string | undefined;
+}

package/dist/_vendor/ailf-core/ports/eval-runner.js

@@ -0,0 +1,8 @@
+/**
+ * Port: How LLM evaluation is executed.
+ *
+ * Abstracts the eval engine (Promptfoo today, potentially something else
+ * in the future). The domain kernel never mentions Promptfoo — it works
+ * with evaluation results.
+ */
+export {};

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

@@ -0,0 +1,15 @@
+/**
+ * @sanity/ailf-core — Port interfaces
+ *
+ * Ports define the contracts between the domain kernel and the outside world.
+ * Adapters (in packages/eval) implement these interfaces.
+ */
+export type { CacheEntryMetadata, CacheKey, CacheLookupResult, CacheRecordInput, CacheStore, } from "./cache-store.js";
+export type { ConfigSource } from "./config-source.js";
+export type { AppContext, ReportSinkPort, ReportStorePort, ResolvedConfig, } from "./context.js";
+export type { DocContext, DocFetcher, DocSourceConfig, DocumentManifestEntry, DocumentOverlaySummary, FetchMetadata, FetchResult, ReleaseImpact, UrlFetchEntry, UrlFetchSummary, } from "./doc-fetcher.js";
+export type { EvalRunConfig, EvalRunner } from "./eval-runner.js";
+export type { Logger } from "./logger.js";
+export type { PipelineStep } from "./pipeline-step.js";
+export type { AssertionDefinition, BaselineConfig, CanonicalDocRef, IdDocRef, PathDocRef, PerspectiveDocRef, SlugDocRef, TaskDefinition, TaskSource, TemplatedAssertion, ValueAssertion, } from "./task-source.js";
+export { canonicalDocRefLabel, isIdRef, isPathRef, isPerspectiveRef, isSlugRef, isTemplatedAssertion, } from "./task-source.js";

package/dist/_vendor/ailf-core/ports/index.js

@@ -0,0 +1,7 @@
+/**
+ * @sanity/ailf-core — Port interfaces
+ *
+ * Ports define the contracts between the domain kernel and the outside world.
+ * Adapters (in packages/eval) implement these interfaces.
+ */
+export { canonicalDocRefLabel, isIdRef, isPathRef, isPerspectiveRef, isSlugRef, isTemplatedAssertion, } from "./task-source.js";

package/dist/_vendor/ailf-core/ports/logger.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Port: Structured logging.
+ *
+ * All pipeline output flows through this interface. Adapters control
+ * formatting (emoji console, plain text, JSON, silent) without
+ * changing the calling code.
+ *
+ * This is the first port introduced in the Ports & Adapters migration.
+ * It establishes the pattern: interface in core, adapters in eval.
+ */
+import type { StepResult } from "../types/index.js";
+/**
+ * Logger port — the contract for all pipeline output.
+ *
+ * Implementations:
+ * - ConsoleLogger  — emoji-prefix human output (default)
+ * - QuietLogger    — errors and failures only
+ * - JsonLogger     — NDJSON machine-readable output
+ * - SilentLogger   — captures messages for test assertions
+ */
+export interface Logger {
+    /** Debug-level output (only shown with --verbose) */
+    debug(msg: string, ctx?: Record<string, unknown>): void;
+    /** Informational output (shown by default) */
+    info(msg: string, ctx?: Record<string, unknown>): void;
+    /** Warning output (always shown unless --quiet) */
+    warn(msg: string, ctx?: Record<string, unknown>): void;
+    /** Error output (always shown) */
+    error(msg: string, ctx?: Record<string, unknown>): void;
+    /** Pipeline step result (formatted with timing, icon, and summary) */
+    step(name: string, result: StepResult): void;
+    /** Section header (═══ formatted) */
+    section(title: string): void;
+    /** Table output (for score matrices, comparison tables, etc.) */
+    table(headers: string[], rows: string[][]): void;
+}

package/dist/_vendor/ailf-core/ports/logger.js

@@ -0,0 +1,11 @@
+/**
+ * Port: Structured logging.
+ *
+ * All pipeline output flows through this interface. Adapters control
+ * formatting (emoji console, plain text, JSON, silent) without
+ * changing the calling code.
+ *
+ * This is the first port introduced in the Ports & Adapters migration.
+ * It establishes the pattern: interface in core, adapters in eval.
+ */
+export {};

package/dist/_vendor/ailf-core/ports/pipeline-step.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Port: A single step in the evaluation pipeline.
+ *
+ * Steps are composable, independently testable, and uniformly executed
+ * by the StepRunner. Each step declares its preconditions, execution
+ * logic, and cache inputs.
+ */
+import type { PipelineState, StepResult, ValidationIssue } from "../types/index.js";
+import type { AppContext } from "./context.js";
+export interface PipelineStep {
+    /** Human-readable step name for logging and diagnostics */
+    readonly name: string;
+    /**
+     * Precondition check — validates that required files, config, and
+     * environment are in place before execution.
+     *
+     * @returns Array of validation issues (empty = all clear)
+     */
+    check(ctx: AppContext): ValidationIssue[];
+    /**
+     * Execute the step. May read from filesystem, call APIs, spawn
+     * processes, or delegate to domain services.
+     *
+     * @param ctx — Immutable application context (config, adapters, logger)
+     * @param state — Mutable state bag for inter-step data flow. Producer
+     *   steps write values (e.g., `state.reportId`); consumer steps read
+     *   them. Steps that don't participate in inter-step data flow can
+     *   ignore this parameter.
+     *
+     * @returns Step result with status, duration, and summary/error
+     */
+    execute(ctx: AppContext, state: PipelineState): Promise<StepResult>;
+    /**
+     * Cache key inputs — file paths or content identifiers that determine
+     * whether this step's output is still valid.
+     *
+     * When undefined, the step is never cached (always executes).
+     * When defined, the StepRunner computes a hash and checks the cache.
+     */
+    cacheInputs?(ctx: AppContext): string[];
+    /**
+     * Whether this step is optional — a failure in an optional step
+     * does not stop the pipeline.
+     */
+    readonly optional?: boolean;
+}

package/dist/_vendor/ailf-core/ports/pipeline-step.js

@@ -0,0 +1,8 @@
+/**
+ * Port: A single step in the evaluation pipeline.
+ *
+ * Steps are composable, independently testable, and uniformly executed
+ * by the StepRunner. Each step declares its preconditions, execution
+ * logic, and cache inputs.
+ */
+export {};