@sanity/ailf 0.1.0

package/dist/commands/publish.js

@@ -0,0 +1,253 @@
+/**
+ * publish command — manually publish a local evaluation report to the
+ * Sanity Content Lake without re-running the pipeline.
+ *
+ * Reads a score-summary.json (defaulting to results/latest/score-summary.json),
+ * builds provenance, writes the report to Sanity, and fans out to configured
+ * sinks — exactly the same as the publish step in `ailf pipeline`, but
+ * standalone.
+ *
+ * Uses createAppContext() (composition root) for all infrastructure access.
+ *
+ * @example
+ *   ailf publish                                        # default path
+ *   ailf publish ./my-results/score-summary.json        # custom path
+ *   ailf publish --tag "manual-2026-03-13"              # with a label
+ *   ailf publish --dry-run                              # preview without writing
+ *
+ * @see packages/eval/src/composition-root.ts
+ * @see docs/design-docs/report-store/architecture.md
+ */
+import { existsSync, readFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+import { Command } from "commander";
+import { createAppContext } from "../composition-root.js";
+import { buildProvenance, } from "../pipeline/provenance.js";
+import { generateReportId } from "../report-store.js";
+import { withRetry } from "../sinks/retry.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, "..", "..");
+const DEFAULT_SUMMARY_PATH = resolve(ROOT, "results", "latest", "score-summary.json");
+export function createPublishCommand() {
+    return new Command("publish")
+        .description("Publish a local evaluation report to the Sanity Content Lake")
+        .argument("[summary-path]", "Path to score-summary.json", DEFAULT_SUMMARY_PATH)
+        .option("-t, --tag <tag>", "Label for the published report")
+        .option("-n, --dry-run", "Preview the report without writing to Sanity or sinks", false)
+        .action(async (summaryPath, opts) => {
+        await runPublishCommand(summaryPath, opts);
+    });
+}
+// ---------------------------------------------------------------------------
+// Provenance builder (from score summary, not full pipeline context)
+// ---------------------------------------------------------------------------
+/**
+ * Build a ProvenanceInput from a ScoreSummary for manual publish.
+ *
+ * When publishing outside the pipeline, we reconstruct what we can from
+ * the summary metadata and environment. Some fields (contextHash,
+ * promptfooUrl) are not available for manual publishes.
+ */
+function buildProvenanceFromSummary(summary) {
+    const areas = summary.scores.map((s) => s.feature);
+    const mode = (process.env.EVAL_MODE ?? "baseline");
+    const source = {
+        baseUrl: summary.source?.baseUrl ?? "https://www.sanity.io/docs",
+        dataset: summary.source?.dataset ?? process.env.SANITY_DATASET ?? "next",
+        documentIds: [],
+        llmsTxt: (summary.source?.baseUrl ?? "https://www.sanity.io/docs") + "/llms.txt",
+        name: summary.source?.name ?? "production",
+        perspective: summary.source?.perspective ??
+            process.env.SANITY_PERSPECTIVE ??
+            undefined,
+        priorityDomain: "sanity.io",
+        projectId: summary.source?.projectId ?? process.env.SANITY_PROJECT_ID ?? "3do82whm",
+        studioOrigin: "https://admin.sanity.io",
+        urls: [],
+    };
+    return {
+        areas,
+        mode,
+        rootDir: ROOT,
+        source,
+    };
+}
+// ---------------------------------------------------------------------------
+// Command implementation
+// ---------------------------------------------------------------------------
+async function runPublishCommand(summaryPath, opts) {
+    // Wire up infrastructure via composition root
+    const ctx = createAppContext({
+        compareEnabled: false,
+        discoveryReportEnabled: false,
+        gapAnalysisEnabled: false,
+        mode: "baseline",
+        noCache: true,
+        noRemoteCache: true,
+        publishEnabled: true,
+        publishTag: opts.tag,
+        readinessEnabled: false,
+        rootDir: ROOT,
+        searchMode: "open",
+        skipEval: true,
+        skipFetch: true,
+    });
+    const store = ctx.reportStore;
+    const sinks = (ctx.sinks ?? []);
+    console.log();
+    console.log("=== Publish Report ===");
+    console.log();
+    // -----------------------------------------------------------------------
+    // 1. Resolve and read the score summary
+    // -----------------------------------------------------------------------
+    const resolvedPath = resolve(summaryPath);
+    if (!existsSync(resolvedPath)) {
+        console.error(`  ✖ File not found: ${resolvedPath}`);
+        console.error();
+        console.error("  Hint: Run `ailf pipeline` first to generate results,");
+        console.error("  or provide a path to an existing score-summary.json.");
+        process.exit(1);
+    }
+    let summary;
+    try {
+        summary = JSON.parse(readFileSync(resolvedPath, "utf-8"));
+    }
+    catch (err) {
+        console.error(`  ✖ Failed to parse ${resolvedPath}: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+    // Basic validation — a ScoreSummary must have scores
+    if (!summary.scores || !Array.isArray(summary.scores)) {
+        console.error("  ✖ Invalid score-summary.json: missing `scores` array.");
+        process.exit(1);
+    }
+    const areaCount = summary.scores.length;
+    const overallScore = summary.overall.avgScore;
+    console.log(`  File:     ${resolvedPath}`);
+    console.log(`  Areas:    ${areaCount} (${summary.scores.map((s) => s.feature).join(", ")})`);
+    console.log(`  Overall:  ${overallScore.toFixed(1)}`);
+    if (opts.tag) {
+        console.log(`  Tag:      ${opts.tag}`);
+    }
+    console.log(`  Mode:     ${opts.dryRun ? "dry run (no writes)" : "live"}`);
+    console.log();
+    // -----------------------------------------------------------------------
+    // 2. Build provenance
+    // -----------------------------------------------------------------------
+    const provenanceInput = buildProvenanceFromSummary(summary);
+    const provenance = buildProvenance(provenanceInput);
+    // -----------------------------------------------------------------------
+    // 3. Create report
+    // -----------------------------------------------------------------------
+    const now = new Date().toISOString();
+    if (!store) {
+        console.warn("  ⚠️  No Sanity API token found. Set AILF_REPORT_SANITY_API_TOKEN");
+        console.warn("  or SANITY_API_TOKEN in your .env file.");
+        if (!opts.dryRun) {
+            console.warn("  Cannot publish without a token. Exiting.");
+            process.exit(1);
+        }
+    }
+    // Auto-compare against most recent comparable baseline
+    const comparison = opts.dryRun || !store
+        ? null
+        : await store.autoCompare(summary, provenance, now);
+    const reportId = generateReportId();
+    const report = {
+        comparison: comparison ?? undefined,
+        completedAt: now,
+        durationMs: 0, // manual publish — no pipeline duration
+        id: reportId,
+        provenance,
+        summary,
+        tag: opts.tag,
+    };
+    // -----------------------------------------------------------------------
+    // 4. Dry run — print preview and exit
+    // -----------------------------------------------------------------------
+    if (opts.dryRun) {
+        console.log("  --- Report Preview ---");
+        console.log(`  ID:          ${reportId}`);
+        console.log(`  Completed:   ${now}`);
+        console.log(`  Mode:        ${provenance.mode}`);
+        console.log(`  Source:      ${provenance.source.name}`);
+        console.log(`  Models:      ${provenance.models.map((m) => m.id).join(", ")}`);
+        console.log(`  Grader:      ${provenance.graderModel}`);
+        console.log(`  Trigger:     ${provenance.trigger.type}`);
+        if (opts.tag) {
+            console.log(`  Tag:         ${opts.tag}`);
+        }
+        console.log();
+        if (sinks.length > 0) {
+            console.log(`  Sinks:       ${sinks.map((s) => s.name).join(", ")}`);
+        }
+        else {
+            console.log("  Sinks:       none configured");
+        }
+        console.log();
+        console.log("  ✔ Dry run complete. No data was written.");
+        return;
+    }
+    // -----------------------------------------------------------------------
+    // 5. Write to Sanity (system of record)
+    // -----------------------------------------------------------------------
+    console.log("  Writing to Sanity Content Lake...");
+    const sanityResult = store ? await store.write(report) : null;
+    if (sanityResult) {
+        console.log(`  ✅ Report written: ${sanityResult}`);
+    }
+    else {
+        console.warn("  ⚠️  Sanity write failed (see warnings above)");
+    }
+    // -----------------------------------------------------------------------
+    // 6. Auto-comparison result
+    // -----------------------------------------------------------------------
+    if (comparison) {
+        const delta = comparison.deltas.overall;
+        const sign = delta >= 0 ? "+" : "";
+        console.log(`  📊 Auto-compared vs baseline: ${sign}${delta.toFixed(1)}`);
+    }
+    // -----------------------------------------------------------------------
+    // 7. Fan out to sinks
+    // -----------------------------------------------------------------------
+    if (sinks.length > 0) {
+        console.log();
+        console.log(`  Delivering to ${sinks.length} sink(s)...`);
+        const settled = await Promise.allSettled(sinks.map(async (sink) => {
+            const result = await withRetry(() => sink.publish(report));
+            return { name: sink.name, result };
+        }));
+        for (const outcome of settled) {
+            if (outcome.status === "fulfilled") {
+                const { name, result } = outcome.value;
+                if (result.status === "failed") {
+                    console.warn(`  ⚠️  Sink ${name} failed: ${result.error}`);
+                }
+                else if (result.status === "skipped") {
+                    console.log(`  ⏭️  Sink ${name} skipped: ${result.reason}`);
+                }
+                else {
+                    console.log(`  ✅ Sink ${name} delivered${result.detail ? ` (${result.detail})` : ""}`);
+                }
+            }
+            else {
+                const error = outcome.reason instanceof Error
+                    ? outcome.reason.message
+                    : String(outcome.reason);
+                console.warn(`  ⚠️  Sink delivery error: ${error}`);
+            }
+        }
+    }
+    // -----------------------------------------------------------------------
+    // 8. Summary
+    // -----------------------------------------------------------------------
+    console.log();
+    if (sanityResult) {
+        console.log(`  ✔ Published report ${reportId}`);
+    }
+    else {
+        console.log("  ✖ Report was not persisted to Sanity.");
+        process.exit(1);
+    }
+}

package/dist/commands/readiness-report.d.ts

@@ -0,0 +1,10 @@
+/**
+ * readiness-report command — generates a launch readiness checklist
+ * for a given feature area.
+ *
+ * Combines threshold evaluation, ceiling decomposition, and gap analysis
+ * into a single actionable report.
+ *
+ */
+import { Command } from "commander";
+export declare function createReadinessReportCommand(): Command;

package/dist/commands/readiness-report.js

@@ -0,0 +1,104 @@
+/**
+ * readiness-report command — generates a launch readiness checklist
+ * for a given feature area.
+ *
+ * Combines threshold evaluation, ceiling decomposition, and gap analysis
+ * into a single actionable report.
+ *
+ */
+import { Command } from "commander";
+import { existsSync, readFileSync, readdirSync, writeFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+import { load } from "js-yaml";
+import { formatReadinessMarkdown, generateReadinessReport, } from "../pipeline/readiness-report.js";
+import { ThresholdConfigSchema, } from "../pipeline/schemas.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, "..", "..");
+const SCORE_SUMMARY_PATH = join(ROOT, "results", "latest", "score-summary.json");
+const GAP_ANALYSIS_PATH = join(ROOT, "results", "latest", "gap-analysis.json");
+const THRESHOLDS_PATH = join(ROOT, "config", "thresholds.yaml");
+const BASELINES_DIR = join(ROOT, "results", "baselines");
+export function createReadinessReportCommand() {
+    return new Command("readiness-report")
+        .description("Generate launch readiness report for a feature area")
+        .requiredOption("-a, --area <area>", "Feature area to evaluate (required)")
+        .option("-H, --history", "Include historical progress from baselines", false)
+        .option("-o, --output <path>", "Write markdown to file instead of stdout")
+        .action(async (opts) => {
+        // Load score summary
+        if (!existsSync(SCORE_SUMMARY_PATH)) {
+            console.error(`❌ Score summary not found at ${SCORE_SUMMARY_PATH}. Run \`pnpm pipeline\` first.`);
+            process.exit(1);
+        }
+        const scoreSummary = JSON.parse(readFileSync(SCORE_SUMMARY_PATH, "utf-8"));
+        // Load threshold config
+        if (!existsSync(THRESHOLDS_PATH)) {
+            console.error(`❌ Threshold config not found at ${THRESHOLDS_PATH}.`);
+            process.exit(1);
+        }
+        const rawThresholds = readFileSync(THRESHOLDS_PATH, "utf-8");
+        const parsedThresholds = load(rawThresholds);
+        const thresholdResult = ThresholdConfigSchema.safeParse(parsedThresholds);
+        if (!thresholdResult.success) {
+            const messages = thresholdResult.error.issues
+                .map((i) => `  ${i.path.join(".")}: ${i.message}`)
+                .join("\n");
+            console.error(`❌ Invalid thresholds.yaml:\n${messages}`);
+            process.exit(1);
+        }
+        const thresholdConfig = thresholdResult.data;
+        // Load gap analysis (optional)
+        let gapAnalysis;
+        if (existsSync(GAP_ANALYSIS_PATH)) {
+            gapAnalysis = JSON.parse(readFileSync(GAP_ANALYSIS_PATH, "utf-8"));
+        }
+        const history = [];
+        if (opts.history && existsSync(BASELINES_DIR)) {
+            const files = readdirSync(BASELINES_DIR)
+                .filter((f) => f.endsWith(".json"))
+                .sort();
+            for (const file of files) {
+                try {
+                    const raw = readFileSync(join(BASELINES_DIR, file), "utf-8");
+                    const data = JSON.parse(raw);
+                    const areaScore = data.scores?.find((s) => s.feature === opts.area);
+                    if (!areaScore)
+                        continue;
+                    const nameWithoutExt = file.replace(/\.json$/, "");
+                    const parts = nameWithoutExt.split("_");
+                    const tag = parts.length > 4 ? parts.slice(4).join("_") : undefined;
+                    history.push({
+                        score: areaScore.totalScore,
+                        tag,
+                        timestamp: data.timestamp ?? nameWithoutExt,
+                    });
+                }
+                catch {
+                    // Skip malformed baseline files
+                }
+            }
+        }
+        // Generate report
+        const report = generateReadinessReport({
+            area: opts.area,
+            gapAnalysis,
+            history,
+            scoreSummary,
+            thresholdConfig,
+        });
+        // Format and output
+        const markdown = formatReadinessMarkdown(report);
+        if (opts.output) {
+            writeFileSync(opts.output, markdown, "utf-8");
+            console.error(`✅ Readiness report written to ${opts.output}`);
+        }
+        else {
+            console.log(markdown);
+        }
+        // Exit with non-zero if not ready
+        if (!report.pass) {
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/shared/options.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Shared option groups for the AILF CLI.
+ *
+ * Each function adds a group of related options to a Commander command.
+ * This eliminates copy-paste across commands that share common flags
+ * (e.g., debug options, Sanity source options, output options).
+ */
+import type { Command } from "commander";
+/**
+ * Add agentic options: --url, --header, --allowed-origin, --search
+ */
+export declare function addAgenticOptions(cmd: Command): Command;
+/**
+ * Add debug options: --debug, --debug-n, --debug-pattern, --debug-sample
+ */
+export declare function addDebugOptions(cmd: Command): Command;
+/**
+ * Add output options: --output, --format
+ */
+export declare function addOutputOptions(cmd: Command): Command;
+/**
+ * Add Sanity source options: --sanity-dataset, --sanity-project, etc.
+ */
+export declare function addSanitySourceOptions(cmd: Command): Command;
+/**
+ * Collect repeatable string options into an array.
+ * Used as a Commander argParser for options like --url, --header, --allowed-origin.
+ */
+export declare function collect(value: string, previous: string[]): string[];

package/dist/commands/shared/options.js

@@ -0,0 +1,57 @@
+/**
+ * Shared option groups for the AILF CLI.
+ *
+ * Each function adds a group of related options to a Commander command.
+ * This eliminates copy-paste across commands that share common flags
+ * (e.g., debug options, Sanity source options, output options).
+ */
+/**
+ * Add agentic options: --url, --header, --allowed-origin, --search
+ */
+export function addAgenticOptions(cmd) {
+    return cmd
+        .option("--url <url>", "Documentation URL (repeatable)", collect, [])
+        .option("--urls <url>", "Alias for --url (repeatable)", collect, [])
+        .option("--header <header>", 'Custom HTTP header "Key: Value" (repeatable)', collect, [])
+        .option("--headers <header>", "Alias for --header (repeatable)", collect, [])
+        .option("--allowed-origin <origin>", "Agent origin sandbox (repeatable, supports globs)", collect, [])
+        .option("--allowed-origins <origin>", "Alias for --allowed-origin (repeatable)", collect, [])
+        .option("-S, --search <mode>", "Web search mode: open, origin-only, off");
+}
+/**
+ * Add debug options: --debug, --debug-n, --debug-pattern, --debug-sample
+ */
+export function addDebugOptions(cmd) {
+    return cmd
+        .option("-d, --debug", "Run subset of tests for fast feedback", false)
+        .option("--debug-n <n>", "First N tests", parseInt)
+        .option("--debug-pattern <regex>", "Filter tests by description regex")
+        .option("--debug-sample <n>", "Random sample of N tests", parseInt);
+}
+/**
+ * Add output options: --output, --format
+ */
+export function addOutputOptions(cmd) {
+    return cmd
+        .option("-o, --output <path>", "Write output to a specific file path")
+        .option("-f, --format <fmt>", "Output format (e.g., table, json, md)");
+}
+/**
+ * Add Sanity source options: --sanity-dataset, --sanity-project, etc.
+ */
+export function addSanitySourceOptions(cmd) {
+    return cmd
+        .option("--sanity-dataset <name>", "Override Sanity dataset")
+        .option("--sanity-project <id>", "Override Sanity project ID")
+        .option("--sanity-perspective <id>", "Sanity release perspective ID")
+        .option("--sanity-studio-origin <url>", "Sanity Studio base URL")
+        .option("--sanity-document <id>", "Evaluate specific Sanity document(s) (repeatable)", collect, [])
+        .option("--sanity-documents <id>", "Alias for --sanity-document (repeatable)", collect, []);
+}
+/**
+ * Collect repeatable string options into an array.
+ * Used as a Commander argParser for options like --url, --header, --allowed-origin.
+ */
+export function collect(value, previous) {
+    return [...previous, value];
+}

package/dist/commands/update-quality-scores.d.ts

@@ -0,0 +1,5 @@
+/**
+ * update-quality-scores command — update QUALITY_SCORE.md from scores.
+ */
+import { Command } from "commander";
+export declare function createUpdateQualityScoresCommand(): Command;

package/dist/commands/update-quality-scores.js

@@ -0,0 +1,20 @@
+/**
+ * update-quality-scores command — update QUALITY_SCORE.md from scores.
+ */
+import { Command } from "commander";
+export function createUpdateQualityScoresCommand() {
+    return new Command("update-quality-scores")
+        .description("Update docs/QUALITY_SCORE.md from score-summary.json")
+        .action(async () => {
+        const { updateQualityScores } = await import("../scripts/update-quality-scores.js");
+        console.log("=== Updating QUALITY_SCORE.md from score-summary.json ===\n");
+        const result = updateQualityScores();
+        if (result.success) {
+            console.log(`  ✅ ${result.message}`);
+        }
+        else {
+            console.error(`  ❌ ${result.message}`);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/validate-tasks.d.ts

@@ -0,0 +1,16 @@
+/**
+ * validate-tasks command — standalone validation of repo-based task YAML files.
+ *
+ * Validates .ailf/tasks/*.yaml files against the RepoTaskSchema without
+ * running the full pipeline. Useful for pre-commit hooks and CI checks
+ * in external repos.
+ *
+ * Usage:
+ *   ailf validate-tasks .ailf/tasks/
+ *   ailf validate-tasks /path/to/external-repo/.ailf/tasks/
+ *
+ * @see packages/eval/src/adapters/task-sources/repo-schemas.ts
+ * @see packages/eval/src/adapters/task-sources/repo-validation.ts
+ */
+import { Command } from "commander";
+export declare function createValidateTasksCommand(): Command;

package/dist/commands/validate-tasks.js

@@ -0,0 +1,93 @@
+/**
+ * validate-tasks command — standalone validation of repo-based task YAML files.
+ *
+ * Validates .ailf/tasks/*.yaml files against the RepoTaskSchema without
+ * running the full pipeline. Useful for pre-commit hooks and CI checks
+ * in external repos.
+ *
+ * Usage:
+ *   ailf validate-tasks .ailf/tasks/
+ *   ailf validate-tasks /path/to/external-repo/.ailf/tasks/
+ *
+ * @see packages/eval/src/adapters/task-sources/repo-schemas.ts
+ * @see packages/eval/src/adapters/task-sources/repo-validation.ts
+ */
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { resolve, relative } from "path";
+import { Command } from "commander";
+import { load } from "js-yaml";
+import { parseRepoTaskFile } from "../adapters/task-sources/repo-schemas.js";
+import { validateRepoTasks, formatValidationResult, } from "../adapters/task-sources/repo-validation.js";
+export function createValidateTasksCommand() {
+    return new Command("validate-tasks")
+        .description("Validate repo-based task YAML files (.ailf/tasks/) against the schema")
+        .argument("[path]", "Path to tasks directory (default: .ailf/tasks/)", ".ailf/tasks")
+        .option("--strict", "Treat warnings as errors", false)
+        .action(async (tasksPath, opts) => {
+        const resolvedPath = resolve(tasksPath);
+        if (!existsSync(resolvedPath)) {
+            console.error(`❌ Directory not found: ${resolvedPath}`);
+            process.exit(1);
+        }
+        const yamlFiles = readdirSync(resolvedPath).filter((f) => (f.endsWith(".yaml") || f.endsWith(".yml")) && !f.startsWith("."));
+        if (yamlFiles.length === 0) {
+            console.error(`❌ No YAML files found in ${resolvedPath}`);
+            process.exit(1);
+        }
+        console.log(`\nValidating ${yamlFiles.length} task file(s) in ${relative(process.cwd(), resolvedPath)}/\n`);
+        let totalTasks = 0;
+        let hasErrors = false;
+        const allTasks = [];
+        for (const file of yamlFiles) {
+            const filePath = resolve(resolvedPath, file);
+            const raw = readFileSync(filePath, "utf-8");
+            let parsed;
+            try {
+                parsed = load(raw);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.error(`  ❌ ${file}: YAML parse error`);
+                console.error(`     ${msg}\n`);
+                hasErrors = true;
+                continue;
+            }
+            if (!Array.isArray(parsed)) {
+                console.error(`  ❌ ${file}: Expected a YAML array of task definitions`);
+                hasErrors = true;
+                continue;
+            }
+            try {
+                const tasks = parseRepoTaskFile(parsed, file);
+                console.log(`  ✅ ${file}: ${tasks.length} task${tasks.length === 1 ? "" : "s"} valid`);
+                totalTasks += tasks.length;
+                allTasks.push(...tasks);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.error(`  ❌ ${file}: Schema validation failed`);
+                console.error(`${msg
+                    .split("\n")
+                    .map((l) => `     ${l}`)
+                    .join("\n")}\n`);
+                hasErrors = true;
+            }
+        }
+        // Run semantic validation on all parsed tasks
+        if (allTasks.length > 0) {
+            console.log(); // blank line
+            const semanticResult = validateRepoTasks(allTasks);
+            const formatted = formatValidationResult(semanticResult);
+            console.log(formatted);
+            if (!semanticResult.valid) {
+                hasErrors = true;
+            }
+            if (opts.strict && semanticResult.warnings.length > 0) {
+                hasErrors = true;
+                console.log("\n  ⚠️  --strict mode: warnings treated as errors");
+            }
+        }
+        console.log(`\n${hasErrors ? "❌" : "✅"} ${totalTasks} task${totalTasks === 1 ? "" : "s"} across ${yamlFiles.length} file${yamlFiles.length === 1 ? "" : "s"}\n`);
+        process.exit(hasErrors ? 1 : 0);
+    });
+}

package/dist/commands/validate.d.ts

@@ -0,0 +1,9 @@
+/**
+ * validate command — checks pipeline configuration consistency.
+ *
+ * Validates all YAML files, task-to-mapping cross-references, reference
+ * solutions, context files, and environment variables.
+ *
+ */
+import { Command } from "commander";
+export declare function createValidateCommand(): Command;