@sanity/ailf 3.7.0 → 3.8.0

package/dist/commands/pipeline-action.js

@@ -37,6 +37,10 @@ const VALID_SEARCH_MODES = ["open", "origin-only", "off"];
 export function computeResolvedOptions(opts) {
     // Resolve paths relative to the caller's cwd, not the eval package root
     const callerCwd = getCallerCwd();
+    // `.ailf/config.yaml` is the per-environment config home for `ailf run`
+    // (W0077 Phase 6a). Load early so downstream cascades (source, agentic,
+    // owner, output, etc.) can read from it.
+    const repoConfig = loadRepoConfigIfPresent(callerCwd);
     // Validate + normalize mode via the single boundary function.
     // normalizeMode() maps legacy variant names (baseline, agentic, etc.)
     // to canonical mode "literacy" + variant, and throws on invalid input.
@@ -59,34 +63,34 @@ export function computeResolvedOptions(opts) {
         console.error(`❌ ${err instanceof Error ? err.message : String(err)}`);
         process.exit(1);
     }
-    // Debug options — any sub-flag (--debug-n, --debug-pattern, --debug-sample)
-    // implies --debug, so users don't need to pass both.
-    // When DEBUG_EVAL is explicitly "0", ignore the sub-flags from env.
-    // CLI flags (--debug-n, --debug-pattern, --debug-sample) always win.
+    // Debug + filter options — any filter flag (--filter-first-n,
+    // --filter-pattern, --filter-sample) implies --debug, so users don't
+    // need to pass both. When DEBUG_EVAL is explicitly "0", ignore the env
+    // vars. CLI flags always win over env vars.
     const debugEnvDisabled = process.env.DEBUG_EVAL === "0";
-    const debugN = opts.debugN ??
+    const filterFirstN = opts.filterFirstN ??
         (process.env.DEBUG_EVAL_N && !debugEnvDisabled
             ? parseInt(process.env.DEBUG_EVAL_N, 10)
             : undefined);
-    const debugPattern = opts.debugPattern ??
+    const filterPattern = opts.filterPattern ??
         (process.env.DEBUG_EVAL_PATTERN && !debugEnvDisabled
             ? process.env.DEBUG_EVAL_PATTERN
             : undefined);
-    const debugSample = opts.debugSample ??
+    const filterSample = opts.filterSample ??
         (process.env.DEBUG_EVAL_SAMPLE && !debugEnvDisabled
             ? parseInt(process.env.DEBUG_EVAL_SAMPLE, 10)
             : undefined);
     const debugEnabled = opts.debug ||
         process.env.DEBUG_EVAL === "1" ||
-        debugN !== undefined ||
-        debugPattern !== undefined ||
-        debugSample !== undefined;
+        filterFirstN !== undefined ||
+        filterPattern !== undefined ||
+        filterSample !== undefined;
     const debug = debugEnabled
         ? {
             enabled: true,
-            firstN: debugN,
-            pattern: debugPattern,
-            sample: debugSample,
+            firstN: filterFirstN,
+            pattern: filterPattern,
+            sample: filterSample,
         }
         : undefined;
     // Search mode validation
@@ -95,16 +99,29 @@ export function computeResolvedOptions(opts) {
         console.error(`❌ Invalid --search mode "${searchMode}". Must be one of: ${VALID_SEARCH_MODES.join(", ")}`);
         process.exit(1);
     }
-    // Merge repeatable args (singular + plural aliases)
-    const urlArgs = [...opts.url, ...opts.urls];
-    const headerArgs = [...opts.header, ...opts.headers];
-    const allowedOriginArgs = [...opts.allowedOrigin, ...opts.allowedOrigins];
-    const sanityDocumentArgs = [...opts.sanityDocument, ...opts.sanityDocuments];
-    // Source overrides
-    const datasetOverride = opts.sanityDataset;
-    const projectIdOverride = opts.sanityProject;
+    // Merge repeatable args (singular + plural aliases). `headerArgs` and
+    // `allowedOriginArgs` are populated from `.ailf/config.yaml`'s `agentic`
+    // block (W0077 Phase 6f); the CLI flags `--header` and `--allowed-origin`
+    // were retired. The URL-classification block below may still append a
+    // host to `allowedOriginArgs` when neither config nor CLI provided one.
+    // The `DOC_HEADERS` and `DOC_ALLOWED_ORIGIN(S)` env vars still merge in
+    // sources.ts at the doc-fetch boundary (additive, unchanged).
+    const urlArgs = opts.url;
+    const headerArgs = [];
+    const allowedOriginArgs = [];
+    const sanityDocumentArgs = opts.sanityDocument;
+    if (repoConfig?.agentic?.headers) {
+        for (const [key, value] of Object.entries(repoConfig.agentic.headers)) {
+            headerArgs.push(`${key}: ${value}`);
+        }
+    }
+    if (repoConfig?.agentic?.allowedOrigins) {
+        allowedOriginArgs.push(...repoConfig.agentic.allowedOrigins);
+    }
+    // Source overrides — perspective stays per-run (CLI flag), the dataset /
+    // project / studio-origin trio moved into `.ailf/config.yaml`'s `source`
+    // block in W0077 Phase 6d. Env vars still win over the config-file value.
     const perspectiveOverride = opts.sanityPerspective;
-    const studioOriginOverride = opts.sanityStudioOrigin;
     // URL classification (pure computation — results captured, not applied to env)
     if (urlArgs.length > 0) {
         const classification = classifyUrls(urlArgs);
@@ -115,21 +132,6 @@ export function computeResolvedOptions(opts) {
             sanityDocumentArgs.push(...merged);
         }
     }
-    // Validate custom headers (early error)
-    if (headerArgs.length > 0) {
-        for (const h of headerArgs) {
-            const colonIdx = h.indexOf(":");
-            if (colonIdx === -1) {
-                console.error(`❌ Invalid header format: "${h}". Expected "Key: Value".`);
-                process.exit(1);
-            }
-            const key = h.slice(0, colonIdx).trim();
-            if (!key) {
-                console.error(`❌ Invalid header: empty key in "${h}"`);
-                process.exit(1);
-            }
-        }
-    }
     // Auto-infer allowed origin from --url
     if (urlArgs.length > 0 && allowedOriginArgs.length === 0) {
         try {
@@ -170,22 +172,48 @@ export function computeResolvedOptions(opts) {
             }
         }
     }
-    // Comparison: --before auto-enables --compare
-    const beforeOption = opts.before;
-    const compareEnabled = opts.compare || beforeOption !== undefined;
-    // Publish: smart default — auto-publish full runs when report store is configured
+    // Comparison: --before-source auto-enables --compare. The `--compare` flag
+    // is a Commander optional-argument: undefined when not passed, `true` for
+    // the bare flag (compare against latest), and a string path when the user
+    // pinned a specific baseline (`--compare path/to/baseline.json`).
+    const beforeOption = opts.beforeSource;
+    const compareEnabled = (opts.compare !== undefined && opts.compare !== false) ||
+        beforeOption !== undefined;
+    const compareBaseline = typeof opts.compare === "string" ? opts.compare : undefined;
+    // Task-source resolution (W0077 Phase 6h) — `--task-source` and
+    // `--repo-tasks-path` retired. Both move under `taskSource: {...}` in
+    // `.ailf/config.yaml`. Cascade: config → built-in default (content-lake).
+    // When type is `repo` and no path is set, fall back to `<cwd>/.ailf/tasks/`
+    // (the location `ailf init` scaffolds).
+    const resolvedTaskSourceType = resolveTaskSourceType(repoConfig?.taskSource?.type);
+    const resolvedRepoTasksPath = resolveRepoTasksPath(callerCwd, repoConfig?.taskSource?.repoTasksPath, resolvedTaskSourceType);
+    // Source overrides (W0077 Phase 6d) — `--sanity-dataset`, `--sanity-project`,
+    // and `--sanity-studio-origin` were retired from `ailf run`. Cascade is now:
+    //   env var > .ailf/config.yaml `source.*` > built-in default (in sources.ts).
+    const datasetOverride = process.env.SANITY_DATASET ?? repoConfig?.source?.dataset;
+    const projectIdOverride = process.env.SANITY_PROJECT_ID ?? repoConfig?.source?.projectId;
+    const studioOriginOverride = process.env.SANITY_STUDIO_ORIGIN ?? repoConfig?.source?.studioOrigin;
+    // Report store overrides (W0077 Phase 6e — `--report-dataset` and
+    // `--report-project` retired). Resolution order:
+    //   1. Environment variables (AILF_REPORT_DATASET, AILF_REPORT_PROJECT_ID)
+    //   2. .ailf/config.yaml reportStore block
+    //   3. Eval dataset override (so perspective evals publish to the same dataset)
+    const reportDataset = process.env.AILF_REPORT_DATASET ??
+        repoConfig?.reportStore?.dataset ??
+        datasetOverride ??
+        undefined;
+    const reportProjectId = process.env.AILF_REPORT_PROJECT_ID ??
+        repoConfig?.reportStore?.projectId ??
+        undefined;
+    // Publish polarity (W0077 Phase 4) — auto policy lives in
+    // .ailf/config.yaml's `publish.auto` (or env / default). CLI flags and
+    // AILF_PUBLISH still override the policy.
     const reportStoreToken = process.env.AILF_REPORT_SANITY_API_TOKEN ?? process.env.SANITY_API_TOKEN;
     const reportStoreConfigured = Boolean(reportStoreToken);
-    // Track whether the user explicitly chose --publish or --no-publish.
-    // In remote mode, when this is false we omit the field from the API
-    // request so the server can apply its own default (publish when jobId
-    // is present). Without this, the local smart-default (which checks for
-    // a local Sanity token the CLI doesn't have) would send publish:false
-    // and suppress server-side report publishing.
     const publishExplicit = opts.publish !== undefined || process.env.AILF_PUBLISH !== undefined;
+    const publishAuto = resolvePublishAuto(repoConfig?.publish?.auto);
     let publishEnabled;
     if (opts.publish !== undefined) {
-        // Explicit --publish or --no-publish always wins
         publishEnabled = opts.publish;
     }
     else if (process.env.AILF_PUBLISH === "1") {
@@ -195,36 +223,40 @@ export function computeResolvedOptions(opts) {
         publishEnabled = false;
     }
     else {
-        // Smart default: full runs auto-publish when store is configured
-        publishEnabled = reportStoreConfigured && !debugEnabled;
+        // Apply the auto policy. The report store still has to be configured
+        // for `auto: "always"` and `"full-runs"` — without a token, publishing
+        // is impossible regardless of policy.
+        switch (publishAuto) {
+            case "always":
+                publishEnabled = reportStoreConfigured;
+                break;
+            case "never":
+                publishEnabled = false;
+                break;
+            case "full-runs":
+            default:
+                publishEnabled = reportStoreConfigured && !debugEnabled;
+                break;
+        }
     }
-    // Resolve task source + repo tasks path before anything that depends on
-    // them (report store overrides, output dir). When --task-source=repo is
-    // set without --repo-tasks-path, default to ./.ailf/tasks/ — the location
-    // created by `ailf init`.
-    const resolvedTaskSourceType = resolveTaskSourceType(opts.taskSource);
-    const resolvedRepoTasksPath = resolveRepoTasksPath(callerCwd, opts.repoTasksPath, resolvedTaskSourceType);
-    // Report store overrides — resolution order:
-    //   1. Explicit CLI flags (--report-dataset, --report-project)
-    //   2. Environment variables (AILF_REPORT_DATASET, AILF_REPORT_PROJECT_ID)
-    //   3. .ailf/config.yaml reportStore block (when repo tasks path is set)
-    //   4. Eval dataset override (so perspective evals publish to the same dataset)
-    const repoConfig = loadRepoConfigIfPresent(resolvedRepoTasksPath);
-    const reportDataset = opts.reportDataset ??
-        process.env.AILF_REPORT_DATASET ??
-        repoConfig?.reportStore?.dataset ??
-        datasetOverride ??
-        undefined;
-    const reportProjectId = opts.reportProject ??
-        process.env.AILF_REPORT_PROJECT_ID ??
-        repoConfig?.reportStore?.projectId ??
-        undefined;
+    // Tag default cascade: --publish-tag > AILF_PUBLISH_TAG > .ailf/config.yaml
+    const publishTag = opts.publishTag ?? process.env.AILF_PUBLISH_TAG ?? repoConfig?.publish?.tag;
+    // Execution-tier resolution (W0077 Phase 6b) — concurrency, grader
+    // replications, gap analysis, and api URL all moved from CLI flags to
+    // `.ailf/config.yaml`'s `execution` block. Cascade for each:
+    //   env var (where one exists) > .ailf/config.yaml > built-in default
+    const concurrency = repoConfig?.execution?.concurrency;
+    const graderReplications = repoConfig?.execution?.graderReplications;
+    const gapAnalysisEnabled = repoConfig?.execution?.gapAnalysis ?? true;
     // Remote mode
     const remote = opts.remote || process.env.AILF_REMOTE === "1";
-    const apiUrl = opts.apiUrl ?? process.env.AILF_API_URL ?? "https://ailf-api.sanity.build";
+    const apiUrl = process.env.AILF_API_URL ??
+        repoConfig?.execution?.apiUrl ??
+        "https://ailf-api.sanity.build";
     const apiKey = process.env.AILF_API_KEY ?? undefined;
-    // Output directory: explicit --output-dir → $CWD/.ailf/results/latest/
-    const outputDir = resolveOutputDir(opts.outputDir);
+    // Output directory (W0077 Phase 6c) — `output.dir` from .ailf/config.yaml
+    // when set, otherwise <cwd>/.ailf/results/latest/.
+    const outputDir = resolveOutputDir(repoConfig?.output?.dir);
     return {
         allowedOriginArgs,
         apiKey,
@@ -232,16 +264,15 @@ export function computeResolvedOptions(opts) {
         areaOption,
         beforeOption,
         changedDocsOption,
-        compareBaseline: opts.compareBaseline,
+        compareBaseline,
         compareEnabled,
         compareThreshold: opts.threshold,
-        concurrency: opts.concurrency,
+        concurrency,
         datasetOverride,
         debug,
-        discoveryReportEnabled: opts.discoveryReport,
         dryRun: opts.dryRun,
-        gapAnalysisEnabled: opts.gapAnalysis,
-        graderReplications: opts.graderReplications,
+        gapAnalysisEnabled,
+        graderReplications,
         headerArgs,
         impactSummary,
         mode,
@@ -256,15 +287,14 @@ export function computeResolvedOptions(opts) {
         promptfooUrl: opts.promptfooUrl,
         publishEnabled,
         publishExplicit,
-        publishTag: opts.publishTag,
-        readinessEnabled: opts.readiness,
+        publishTag,
         remote,
         reportDataset,
         reportProjectId,
         sanityDocumentArgs,
         searchMode,
-        skipEval: opts.skipEval,
-        skipFetch: opts.skipFetch,
+        skipEval: opts.eval === false,
+        skipFetch: opts.fetch === false,
         source: opts.source,
         studioOriginOverride,
         repoTasksPath: resolvedRepoTasksPath,
@@ -272,37 +302,55 @@ export function computeResolvedOptions(opts) {
         tagOption,
         taskSourceType: resolvedTaskSourceType,
         urlArgs,
-        artifactsDisabled: opts.artifacts === false,
-        artifactsDir: resolveArtifactsDir(opts),
-        artifactsDryRun: opts.artifactsDryRun,
-        artifactsExclude: parseArtifactsExcludeList(opts.artifactsExclude),
+        // Artifact-writer settings (W0077 Phase 6g) — `--no-artifacts`,
+        // `--artifacts-dir`, and `--artifacts-exclude` retired. Cascade:
+        //   AILF_ARTIFACTS_DIR > .ailf/config.yaml `artifacts.dir` > default
+        //   .ailf/config.yaml `artifacts.enabled: false` > writers attached
+        //   .ailf/config.yaml `artifacts.exclude` > no exclusions
+        // `--no-artifacts-write` (artifactsDryRun) stays per-run.
+        artifactsDisabled: repoConfig?.artifacts?.enabled === false,
+        artifactsDir: process.env.AILF_ARTIFACTS_DIR ?? repoConfig?.artifacts?.dir,
+        artifactsDryRun: opts.artifactsWrite === false,
+        artifactsExclude: repoConfig?.artifacts?.exclude,
         classificationOption: opts.classification?.trim() || undefined,
-        ownerTeamOption: opts.ownerTeam?.trim() || undefined,
-        ownerIndividualOption: opts.ownerIndividual?.trim() || undefined,
+        // Owner attribution (W0077 Phase 6f) — `--owner-team` and
+        // `--owner-individual` retired. Cascade: AILF_OWNER_TEAM /
+        // AILF_OWNER_INDIVIDUAL env vars > .ailf/config.yaml `owner.*` > undefined.
+        // Downstream resolution in build-request.ts already honors the env var as a
+        // fallback when this option is unset, but threading it through here keeps
+        // the cascade order explicit.
+        ownerTeamOption: process.env.AILF_OWNER_TEAM?.trim() ||
+            repoConfig?.owner?.team ||
+            undefined,
+        ownerIndividualOption: process.env.AILF_OWNER_INDIVIDUAL?.trim() ||
+            repoConfig?.owner?.individual ||
+            undefined,
         purposeOption: opts.purpose?.trim() || undefined,
         labelOptions: opts.label ?? [],
     };
 }
+const PUBLISH_AUTO_VALUES = ["always", "full-runs", "never"];
 /**
- * Resolve the artifacts output directory from CLI flags and env vars.
- * Precedence (highest first):
- *   1. `--artifacts-dir` flag
- *   2. `AILF_ARTIFACTS_DIR` env var
+ * Resolve the publish auto policy. Precedence:
+ *   1. .ailf/config.yaml `publish.auto`
+ *   2. AILF_PUBLISH_AUTO env var
+ *   3. Default: "full-runs" (preserves the historical smart default)
  *
- * The `--capture-dir` / `AILF_CAPTURE_DIR` aliases were retired in W0052;
- * callers of those names are rejected at CLI entry (see cli.ts).
+ * Unrecognized env-var values fall through to the default with a warning;
+ * the schema validates the config-file value at parse time.
  */
-function resolveArtifactsDir(opts) {
-    return opts.artifactsDir ?? process.env.AILF_ARTIFACTS_DIR;
-}
-function parseArtifactsExcludeList(raw) {
-    if (!raw)
-        return undefined;
-    const list = raw
-        .split(",")
-        .map((s) => s.trim())
-        .filter(Boolean);
-    return list.length > 0 ? list : undefined;
+function resolvePublishAuto(repoValue) {
+    if (repoValue)
+        return repoValue;
+    const envValue = process.env.AILF_PUBLISH_AUTO?.trim();
+    if (envValue &&
+        PUBLISH_AUTO_VALUES.includes(envValue)) {
+        return envValue;
+    }
+    if (envValue) {
+        console.warn(`⚠️  AILF_PUBLISH_AUTO="${envValue}" is not recognized; valid values are ${PUBLISH_AUTO_VALUES.join(", ")}. Falling back to "full-runs".`);
+    }
+    return "full-runs";
 }
 /** Resolve and validate the --task-source flag value. */
 function resolveTaskSourceType(raw) {
@@ -370,18 +418,11 @@ export async function executePipeline(cliOpts) {
         const callerCwd = getCallerCwd();
         const adapter = new FileConfigAdapter(cliOpts.config, ROOT);
         const config = await adapter.resolve();
-        // Merge CLI-only flags that aren't in the config file.
-        // The file config (from the API payload) has taskSourceType and other
-        // pipeline options, but CLI-only args like --repo-tasks-path and
-        // --output are only available from the command line.
-        if (cliOpts.repoTasksPath) {
-            config.repoTasksPath = resolve(callerCwd, cliOpts.repoTasksPath);
-        }
-        else if (config.taskSourceType === "repo" && !config.repoTasksPath) {
-            // Default: when taskSource=repo but no path set, look in .ailf/tasks/
-            // (matches the `ailf init` scaffold location). Silent fallback here —
-            // composition root will surface a helpful error if the directory is
-            // missing.
+        // When `taskSource.type` is `repo` and no `repoTasksPath` was set in
+        // the config file, fall back to `<callerCwd>/.ailf/tasks/` (the
+        // location `ailf init` scaffolds). Silent fallback — composition-root
+        // surfaces a helpful error if the directory is missing.
+        if (config.taskSourceType === "repo" && !config.repoTasksPath) {
             const defaultPath = resolve(callerCwd, ".ailf", "tasks");
             if (existsSync(defaultPath)) {
                 config.repoTasksPath = defaultPath;
@@ -390,18 +431,13 @@ export async function executePipeline(cliOpts) {
         if (cliOpts.output) {
             config.outputPath = resolve(callerCwd, cliOpts.output);
         }
-        // Output dir: explicit CLI flag → $CWD/.ailf/results/latest/
-        config.outputDir = resolveOutputDir(cliOpts.outputDir);
-        // Artifact options — CLI flags and env vars aren't in the config file,
-        // so merge them here (same logic as resolveOptions).
-        const resolvedArtifactsDir = resolveArtifactsDir(cliOpts);
-        config.artifactsDisabled ??= cliOpts.artifacts === false;
-        config.artifactsDir ??= resolvedArtifactsDir;
-        config.artifactsDryRun ??= cliOpts.artifactsDryRun;
-        const excludeList = parseArtifactsExcludeList(cliOpts.artifactsExclude);
-        if (excludeList) {
-            config.artifactsExclude = excludeList;
-        }
+        // Artifact-writer env-var fallbacks. The adapter populates the bulk of
+        // the artifact settings from `EvalConfigSchema.artifacts.*` (W0077
+        // Phase 6g); we layer the env-var fallbacks here for fields the schema
+        // doesn't cover (GCS bucket, upload mode), and the AILF_ARTIFACTS_DIR
+        // override that wins over both schema and CLI.
+        config.artifactsDir = process.env.AILF_ARTIFACTS_DIR ?? config.artifactsDir;
+        config.artifactsDryRun ??= cliOpts.artifactsWrite === false;
         config.artifactGcsBucket ??= process.env.AILF_GCS_ARTIFACT_BUCKET;
         config.artifactUpload ??= parseArtifactUploadEnv(process.env.AILF_ARTIFACT_UPLOAD);
         // Create AppContext directly from the merged config so adapters
@@ -470,18 +506,16 @@ function writePipelineResult(result, outputDir) {
     console.log(`  📄 Pipeline result: ${resultFile}\n`);
 }
 /**
- * Load .ailf/config.yaml if --repo-tasks-path is set and the config file
- * exists. Returns null if not applicable.
+ * Load `<cwd>/.ailf/config.yaml` if it exists. Returns null when the file
+ * is absent or unparseable.
  *
- * The config.yaml lives one level up from the tasks/ directory:
- *   .ailf/config.yaml  ← config
- *   .ailf/tasks/       ← repoTasksPath
+ * Auto-loads regardless of `--task-source`: the same `.ailf/config.yaml` is
+ * the per-environment configuration home for every run (W0077 Phase 6a).
+ * Subsequent flag-family migrations (6b–6h) read additional fields from
+ * this same file via the same loader.
  */
-function loadRepoConfigIfPresent(repoTasksPath) {
-    if (!repoTasksPath)
-        return null;
-    // .ailf/tasks/ → .ailf/config.yaml
-    const configPath = resolve(repoTasksPath, "..", "config.yaml");
+function loadRepoConfigIfPresent(cwd) {
+    const configPath = resolve(cwd, ".ailf", "config.yaml");
     if (!existsSync(configPath))
         return null;
     try {

package/dist/commands/pr-comment.js

@@ -16,7 +16,7 @@ const ROOT = resolve(__dirname, "..", "..");
 export function createPrCommentCommand() {
     const cmd = new Command("pr-comment")
         .description("Generate a markdown PR comment from evaluation scores")
-        .option("--output <path>", "Write comment to file (default: stdout)")
+        .option("-o, --output <path>", "Write comment to file (default: stdout)")
         .option("--promptfoo-url <url>", "Promptfoo share URL to include")
         .action(async (opts) => {
         try {
@@ -29,8 +29,6 @@ export function createPrCommentCommand() {
                 skipEval: true,
                 compareEnabled: false,
                 gapAnalysisEnabled: false,
-                readinessEnabled: false,
-                discoveryReportEnabled: false,
                 publishEnabled: false,
                 noCache: true,
                 noRemoteCache: true,

package/dist/commands/publish.d.ts

@@ -4,7 +4,7 @@
  *
  * 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
+ * sinks — exactly the same as the publish step in `ailf run`, but
  * standalone.
  *
  * Uses createAppContext() (composition root) for all infrastructure access.

package/dist/commands/publish.js

@@ -4,7 +4,7 @@
  *
  * 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
+ * sinks — exactly the same as the publish step in `ailf run`, but
  * standalone.
  *
  * Uses createAppContext() (composition root) for all infrastructure access.
@@ -88,7 +88,6 @@ async function runPublishCommand(summaryPath, outputDir, opts) {
     // Wire up infrastructure via composition root
     const ctx = createAppContext({
         compareEnabled: false,
-        discoveryReportEnabled: false,
         gapAnalysisEnabled: false,
         mode: "literacy",
         noAutoScope: false,
@@ -97,7 +96,6 @@ async function runPublishCommand(summaryPath, outputDir, opts) {
         outputDir,
         publishEnabled: true,
         publishTag: opts.tag,
-        readinessEnabled: false,
         rootDir: ROOT,
         searchMode: "open",
         skipEval: true,
@@ -117,7 +115,7 @@ async function runPublishCommand(summaryPath, outputDir, opts) {
     if (!existsSync(resolvedPath)) {
         console.error(`  ✖ File not found: ${resolvedPath}`);
         console.error();
-        console.error("  Hint: Run `ailf pipeline` first to generate results,");
+        console.error("  Hint: Run `ailf run` first to generate results,");
         console.error("  or provide a path to an existing score-summary.json.");
         process.exit(1);
     }

package/dist/commands/readiness-report.js

@@ -15,23 +15,32 @@ import { formatReadinessMarkdown, generateReadinessReport, } from "../pipeline/r
 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 DEFAULT_RESULTS_DIR = join(ROOT, "results", "latest");
 // thresholds loaded via loadConfigFile below
 const BASELINES_DIR = join(ROOT, "results", "baselines");
+/** Resolve `--from-run` to an absolute results directory. */
+function resolveFromRun(value) {
+    if (value === "latest")
+        return DEFAULT_RESULTS_DIR;
+    return resolve(value);
+}
 export function createReadinessReportCommand() {
-    return new Command("readiness-report")
+    return new Command("readiness")
         .description("Generate launch readiness report for a feature area")
         .requiredOption("-a, --area <area>", "Feature area to evaluate (required)")
+        .option("--from-run <path>", "Results directory to read from (`latest` or a path to a results directory containing score-summary.json)", "latest")
         .option("-H, --history", "Include historical progress from baselines", false)
         .option("-o, --output <path>", "Write markdown to file instead of stdout")
         .action(async (opts) => {
+        const resultsDir = resolveFromRun(opts.fromRun);
+        const scoreSummaryPath = join(resultsDir, "score-summary.json");
+        const gapAnalysisPath = join(resultsDir, "gap-analysis.json");
         // Load score summary
-        if (!existsSync(SCORE_SUMMARY_PATH)) {
-            console.error(`❌ Score summary not found at ${SCORE_SUMMARY_PATH}. Run \`pnpm pipeline\` first.`);
+        if (!existsSync(scoreSummaryPath)) {
+            console.error(`❌ Score summary not found at ${scoreSummaryPath}. Run \`ailf run\` first or pass --from-run <path>.`);
             process.exit(1);
         }
-        const scoreSummary = JSON.parse(readFileSync(SCORE_SUMMARY_PATH, "utf-8"));
+        const scoreSummary = JSON.parse(readFileSync(scoreSummaryPath, "utf-8"));
         // Load threshold config
         let parsedThresholds;
         try {
@@ -57,8 +66,8 @@ export function createReadinessReportCommand() {
         const thresholdConfig = thresholdResult.data;
         // Load gap analysis (optional)
         let gapAnalysis;
-        if (existsSync(GAP_ANALYSIS_PATH)) {
-            gapAnalysis = JSON.parse(readFileSync(GAP_ANALYSIS_PATH, "utf-8"));
+        if (existsSync(gapAnalysisPath)) {
+            gapAnalysis = JSON.parse(readFileSync(gapAnalysisPath, "utf-8"));
         }
         const history = [];
         if (opts.history && existsSync(BASELINES_DIR)) {

package/dist/commands/remote-pipeline.d.ts

@@ -1,5 +1,5 @@
 /**
- * remote-pipeline.ts — Remote execution flow for `ailf pipeline --remote`.
+ * remote-pipeline.ts — Remote execution flow for `ailf run --remote`.
  *
  * Reads local `.ailf/tasks/` YAML, validates locally via Zod schemas,
  * submits to the AILF API, polls for completion, and writes the same

package/dist/commands/remote-pipeline.js

@@ -1,5 +1,5 @@
 /**
- * remote-pipeline.ts — Remote execution flow for `ailf pipeline --remote`.
+ * remote-pipeline.ts — Remote execution flow for `ailf run --remote`.
  *
  * Reads local `.ailf/tasks/` YAML, validates locally via Zod schemas,
  * submits to the AILF API, polls for completion, and writes the same
@@ -135,8 +135,6 @@ function toConfigSlice(opts) {
         perspectiveOverride: opts.perspectiveOverride,
         graderReplications: opts.graderReplications,
         gapAnalysisEnabled: opts.gapAnalysisEnabled,
-        readinessEnabled: opts.readinessEnabled,
-        discoveryReportEnabled: opts.discoveryReportEnabled,
         noRemoteCache: opts.noRemoteCache,
         // D0037 / W0069 caller envelope overrides — flags override env vars
         // inside buildCallerEnvelope(), which also merges AILF_* defaults.

package/dist/commands/run.d.ts

@@ -0,0 +1,64 @@
+/**
+ * run command — the main evaluation entry point.
+ *
+ * Renamed from `ailf pipeline` to `ailf run` per W0077 Phase 1
+ * (see docs/design-docs/pipeline-command-surface.md §3). The command drives
+ * the evaluation pipeline; the orchestrator internals retain the "pipeline"
+ * name because they describe a multi-step process, not the CLI verb.
+ *
+ * Defines all 44+ CLI flags via Commander, resolves them into a typed
+ * options object, bridges to process.env for downstream modules, and
+ * delegates to runPipeline().
+ *
+ * @see docs/guides/cli-guide.md for per-flag behavior notes, or
+ * docs/references/cli-reference.md for the auto-generated flag matrix.
+ */
+import { Command } from "commander";
+/**
+ * Raw CLI options as parsed by Commander.
+ * Field names follow Commander's camelCase convention for kebab-case flags.
+ */
+export interface PipelineCliOptions {
+    area?: string;
+    autoScope: boolean;
+    /** `--before-source <name>` — swap the doc source to a "before" state for impact evaluation. */
+    beforeSource?: string;
+    cache: boolean;
+    changedDocs?: string;
+    /**
+     * `--compare [baseline]` — Commander optional argument.
+     *   undefined → flag not passed
+     *   true      → bare `--compare` (compare against latest baseline)
+     *   string    → `--compare path/to/baseline.json` (pin to a file)
+     */
+    compare?: boolean | string;
+    config?: string;
+    debug: boolean;
+    filterFirstN?: number;
+    filterPattern?: string;
+    filterSample?: number;
+    dryRun: boolean;
+    eval: boolean;
+    fetch: boolean;
+    mode: string;
+    variant?: string;
+    output?: string;
+    promptfooUrl?: string;
+    publish?: boolean;
+    publishTag?: string;
+    remoteCache?: boolean;
+    sanityDocument: string[];
+    sanityPerspective?: string;
+    search?: string;
+    source?: string;
+    remote: boolean;
+    task?: string;
+    tag: string[];
+    threshold?: number;
+    url: string[];
+    artifactsWrite: boolean;
+    classification?: string;
+    purpose?: string;
+    label: string[];
+}
+export declare function createRunCommand(): Command;