@sanity/ailf 3.6.0 → 3.8.0

package/dist/adapters/config-sources/file-config-adapter.js

@@ -1,7 +1,7 @@
 /**
  * FileConfigAdapter — resolves pipeline config from a local config file.
  *
- * Enables `ailf pipeline --config <path>` to load all pipeline options
+ * Enables `ailf run --config <path>` to load all pipeline options
  * from a file instead of CLI flags. Supports multiple formats in
  * priority order:
  *
@@ -91,9 +91,16 @@ function mapEvalConfigToResolvedConfig(config, rootDir) {
     }
     // Normalize legacy mode names (e.g., "full" → literacy + variant)
     const normalized = normalizeMode(config.mode ?? "literacy");
+    // Output directory (W0077 Phase 6c) — resolve `output.dir` relative to the
+    // rootDir (the caller's workspace, set by the FileConfigAdapter caller).
+    // When unset, fall back to <rootDir>/.ailf/results/latest/ to mirror the
+    // CLI's default. This matches `resolveOutputDir` for the auto-load path.
+    const outputDir = config.output?.dir
+        ? resolve(rootDir, config.output.dir)
+        : resolve(rootDir, ".ailf", "results", "latest");
     return {
         rootDir,
-        outputDir: resolve(rootDir, "results", "latest"),
+        outputDir,
         mode: normalized.mode,
         variant: normalized.variant,
         noAutoScope: config.noAutoScope ?? false,
@@ -107,21 +114,40 @@ function mapEvalConfigToResolvedConfig(config, rootDir) {
         compareEnabled: config.compare ?? false,
         compareThreshold: config.compareThreshold,
         compareBaseline: config.compareBaseline,
-        gapAnalysisEnabled: config.gapAnalysis ?? true,
-        readinessEnabled: config.readiness ?? false,
-        discoveryReportEnabled: config.discoveryReport ?? false,
-        publishEnabled: config.publish ?? false,
-        publishTag: config.publishTag,
+        gapAnalysisEnabled: config.execution?.gapAnalysis ?? true,
+        // W0077 Phase 4 — `publish` is now a policy object. Map the auto value
+        // directly to a boolean for the file-config path; the runtime
+        // smart-default logic in pipeline-action.ts isn't relevant here because
+        // the user has explicitly handed us a config file.
+        publishEnabled: config.publish?.auto === "never"
+            ? false
+            : config.publish?.auto !== undefined,
+        publishTag: config.publish?.tag,
         noCache: config.noCache ?? false,
         noRemoteCache: config.noRemoteCache ?? false,
-        graderReplications: config.graderReplications,
+        graderReplications: config.execution?.graderReplications,
         urls: config.urls,
-        headers: config.headers,
-        allowedOrigins: config.allowedOrigins,
+        headers: config.agentic?.headers,
+        allowedOrigins: config.agentic?.allowedOrigins,
         searchMode: config.searchMode ?? "open",
-        concurrency: config.concurrency,
+        concurrency: config.execution?.concurrency,
         remote: false,
-        apiUrl: "https://ailf-api.sanity.build",
+        apiUrl: config.execution?.apiUrl ?? "https://ailf-api.sanity.build",
+        // W0077 Phase 6g — artifact writer settings. `enabled: false` flips
+        // `artifactsDisabled` so composition-root selects the NoOp writer.
+        artifactsDisabled: config.artifacts?.enabled === false ? true : undefined,
+        artifactsDir: config.artifacts?.dir
+            ? resolve(rootDir, config.artifacts.dir)
+            : undefined,
+        artifactsExclude: config.artifacts?.exclude,
+        // W0077 Phase 6h — task-source selection. Default is content-lake
+        // (signaled by `taskSourceType` undefined); when `repo`, the
+        // composition-root resolves `repoTasksPath` (defaulting to
+        // `<rootDir>/.ailf/tasks/` when unset).
+        taskSourceType: config.taskSource?.type === "repo" ? "repo" : undefined,
+        repoTasksPath: config.taskSource?.repoTasksPath
+            ? resolve(rootDir, config.taskSource.repoTasksPath)
+            : undefined,
         presets: config.presets,
     };
 }

package/dist/adapters/task-sources/content-lake-task-source.js

@@ -15,6 +15,7 @@
  * @see packages/core/src/ports/task-source.ts — TaskSource port
  * @see docs/decisions/D0038-content-lake-authorable-task-modes.md
  */
+import { ContentLakeAuthorableTaskSchema } from "./repo-schemas.js";
 // ---------------------------------------------------------------------------
 // GROQ query — fetches ailf.task documents with resolved references
 // ---------------------------------------------------------------------------
@@ -98,6 +99,22 @@ export class ContentLakeTaskSource {
             const mapped = mapToAuthorableTask(entry);
             if (!mapped)
                 continue;
+            // Runtime gate (W0073): every mapped task must satisfy the domain
+            // schema before it flows into the pipeline. Throws loudly on drift so
+            // a Studio document that strays from GeneralizedTaskDefinition
+            // surfaces at load time rather than corrupting downstream state.
+            const parsed = ContentLakeAuthorableTaskSchema.safeParse(mapped);
+            if (!parsed.success) {
+                const issues = parsed.error.issues
+                    .slice(0, 5)
+                    .map((i) => `  [${i.path.join(".")}]: ${i.message}`)
+                    .join("\n");
+                const more = parsed.error.issues.length > 5
+                    ? `\n  …and ${parsed.error.issues.length - 5} more issue(s)`
+                    : "";
+                throw new Error(`ContentLakeTaskSource: ailf.task "${mapped.id}" failed domain ` +
+                    `schema validation:\n${issues}${more}`);
+            }
             definitions.push(mapped);
         }
         if (definitions.length === 0 && !filter) {

package/dist/adapters/task-sources/index.d.ts

@@ -1,6 +1,6 @@
 export { CompositeTaskSource } from "./composite-task-source.js";
 export { ContentLakeTaskSource } from "./content-lake-task-source.js";
-export { CanonicalTaskFileSchema, CanonicalTaskSchema, CURATED_ASSERTION_TYPES, detectLegacyFieldNames, parseCanonicalTaskFile, parseRepoConfig, RepoConfigSchema, RUBRIC_TEMPLATE_NAMES, type CanonicalTask, type CuratedAssertionType, type RepoConfig, type RubricTemplateName, } from "./repo-schemas.js";
+export { CanonicalTaskFileSchema, CanonicalTaskSchema, ContentLakeAuthorableTaskSchema, CURATED_ASSERTION_TYPES, detectLegacyFieldNames, parseCanonicalTaskFile, parseRepoConfig, RepoConfigSchema, RUBRIC_TEMPLATE_NAMES, type CanonicalTask, type ContentLakeAuthorableTaskParsed, type CuratedAssertionType, type RepoConfig, type RubricTemplateName, } from "./repo-schemas.js";
 export { RepoTaskSource } from "./repo-task-source.js";
 export { detectTriggerContext, resolveTrigger, type ResolvedTrigger, type TriggerContext, } from "./repo-trigger.js";
 export { formatValidationResult, validateCanonicalTasks, type ValidationMessage, type ValidationResult, } from "./repo-validation.js";

package/dist/adapters/task-sources/index.js

@@ -1,6 +1,6 @@
 export { CompositeTaskSource } from "./composite-task-source.js";
 export { ContentLakeTaskSource } from "./content-lake-task-source.js";
-export { CanonicalTaskFileSchema, CanonicalTaskSchema, CURATED_ASSERTION_TYPES, detectLegacyFieldNames, parseCanonicalTaskFile, parseRepoConfig, RepoConfigSchema, RUBRIC_TEMPLATE_NAMES, } from "./repo-schemas.js";
+export { CanonicalTaskFileSchema, CanonicalTaskSchema, ContentLakeAuthorableTaskSchema, CURATED_ASSERTION_TYPES, detectLegacyFieldNames, parseCanonicalTaskFile, parseRepoConfig, RepoConfigSchema, RUBRIC_TEMPLATE_NAMES, } from "./repo-schemas.js";
 export { RepoTaskSource } from "./repo-task-source.js";
 export { detectTriggerContext, resolveTrigger, } from "./repo-trigger.js";
 export { formatValidationResult, validateCanonicalTasks, } from "./repo-validation.js";

package/dist/adapters/task-sources/repo-schemas.d.ts

@@ -664,6 +664,122 @@ export declare const CanonicalTaskSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strict>], "mode">;
 export type CanonicalTask = z.infer<typeof CanonicalTaskSchema>;
+export declare const ContentLakeAuthorableTaskSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    area: z.ZodOptional<z.ZodString>;
+    difficulty: z.ZodOptional<z.ZodEnum<{
+        basic: "basic";
+        intermediate: "intermediate";
+        advanced: "advanced";
+    }>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    status: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        draft: "draft";
+        paused: "paused";
+        archived: "archived";
+    }>>>;
+    assertions: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"llm-rubric">;
+        template: z.ZodEnum<{
+            "task-completion": "task-completion";
+            "code-correctness": "code-correctness";
+            "doc-coverage": "doc-coverage";
+            "mcp-input-validation": "mcp-input-validation";
+            "mcp-output-correctness": "mcp-output-correctness";
+            "mcp-error-handling": "mcp-error-handling";
+            "mcp-security": "mcp-security";
+            "factual-correctness": "factual-correctness";
+            completeness: "completeness";
+            currency: "currency";
+            "process-quality": "process-quality";
+            "agent-output": "agent-output";
+            "agent-tool-usage": "agent-tool-usage";
+        }>;
+        criteria: z.ZodArray<z.ZodString>;
+        weight: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodEnum<{
+            "llm-rubric": "llm-rubric";
+            contains: "contains";
+            "contains-any": "contains-any";
+            "contains-all": "contains-all";
+            "not-contains": "not-contains";
+            icontains: "icontains";
+            "icontains-any": "icontains-any";
+            regex: "regex";
+            javascript: "javascript";
+            similar: "similar";
+            cost: "cost";
+            latency: "latency";
+            "file-exists": "file-exists";
+            "file-contains": "file-contains";
+            "command-succeeds": "command-succeeds";
+            "diff-matches": "diff-matches";
+        }>;
+        value: z.ZodOptional<z.ZodUnknown>;
+        threshold: z.ZodOptional<z.ZodNumber>;
+        weight: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>]>>>;
+    rubric: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        ref: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        inline: z.ZodString;
+        dimensions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            weight: z.ZodNumber;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>]>>;
+    providers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    options: z.ZodOptional<z.ZodObject<{
+        timeout: z.ZodOptional<z.ZodNumber>;
+        cache: z.ZodOptional<z.ZodBoolean>;
+        transformOutput: z.ZodOptional<z.ZodString>;
+        promptfooOverrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    prompt: z.ZodOptional<z.ZodObject<{
+        template: z.ZodOptional<z.ZodString>;
+        text: z.ZodOptional<z.ZodString>;
+        systemMessage: z.ZodOptional<z.ZodString>;
+        vars: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    mode: z.ZodLiteral<"literacy">;
+    context: z.ZodOptional<z.ZodObject<{
+        docs: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            id: z.ZodString;
+            reason: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+            slug: z.ZodOptional<z.ZodString>;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            slug: z.ZodString;
+            reason: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        }, z.core.$strip>, z.ZodObject<{
+            path: z.ZodString;
+            reason: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        }, z.core.$strip>, z.ZodObject<{
+            perspective: z.ZodString;
+            reason: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        }, z.core.$strip>]>>>;
+        fixtures: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    referenceSolution: z.ZodOptional<z.ZodString>;
+    docCoverage: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    baseline: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        rubric: z.ZodOptional<z.ZodEnum<{
+            full: "full";
+            abbreviated: "abbreviated";
+            none: "none";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+export type ContentLakeAuthorableTaskParsed = z.infer<typeof ContentLakeAuthorableTaskSchema>;
 /**
  * Schema for an array of canonical tasks — what a single .ailf/tasks/*.yaml
  * file contains. Each file must define at least one task.
@@ -1318,11 +1434,49 @@ export declare const RepoConfigSchema: z.ZodObject<{
         projectId: z.ZodOptional<z.ZodString>;
         dataset: z.ZodOptional<z.ZodString>;
         baseUrl: z.ZodOptional<z.ZodString>;
+        studioOrigin: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     reportStore: z.ZodOptional<z.ZodObject<{
         projectId: z.ZodString;
         dataset: z.ZodString;
     }, z.core.$strip>>;
+    publish: z.ZodOptional<z.ZodObject<{
+        auto: z.ZodOptional<z.ZodEnum<{
+            never: "never";
+            always: "always";
+            "full-runs": "full-runs";
+        }>>;
+        tag: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    execution: z.ZodOptional<z.ZodObject<{
+        concurrency: z.ZodOptional<z.ZodNumber>;
+        graderReplications: z.ZodOptional<z.ZodNumber>;
+        gapAnalysis: z.ZodOptional<z.ZodBoolean>;
+        apiUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    output: z.ZodOptional<z.ZodObject<{
+        dir: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    owner: z.ZodOptional<z.ZodObject<{
+        team: z.ZodOptional<z.ZodString>;
+        individual: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    agentic: z.ZodOptional<z.ZodObject<{
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        allowedOrigins: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    artifacts: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        dir: z.ZodOptional<z.ZodString>;
+        exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    taskSource: z.ZodOptional<z.ZodObject<{
+        type: z.ZodOptional<z.ZodEnum<{
+            "content-lake": "content-lake";
+            repo: "repo";
+        }>>;
+        repoTasksPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
     triggers: z.ZodOptional<z.ZodObject<{
         pr: z.ZodOptional<z.ZodObject<{
             mode: z.ZodDefault<z.ZodEnum<{

package/dist/adapters/task-sources/repo-schemas.js

@@ -320,6 +320,16 @@ export const CanonicalTaskSchema = z.discriminatedUnion("mode", [
     KnowledgeProbeTaskSchema,
     CustomTaskSchema,
 ]);
+// ---------------------------------------------------------------------------
+// Content Lake authorable slice (D0038 / W0073)
+//
+// Runtime validator for Content Lake-authored tasks. Mirrors the
+// `ContentLakeAuthorableTask` type from @sanity/ailf-core: today exactly
+// the literacy variant. Expanding `ContentLakeAuthorableMode` requires
+// extending this schema in the same pass (use `z.discriminatedUnion("mode", [...])`
+// once the authorable set has more than one member).
+// ---------------------------------------------------------------------------
+export const ContentLakeAuthorableTaskSchema = LiteracyTaskSchema;
 /**
  * Schema for an array of canonical tasks — what a single .ailf/tasks/*.yaml
  * file contains. Each file must define at least one task.
@@ -417,12 +427,17 @@ const ScheduleTriggerSchema = TriggerConfigSchema.extend({
 /**
  * Documentation source configuration.
  * Defines which Sanity project holds the documentation being evaluated.
+ *
+ * `studioOrigin` (W0077 Phase 6d) replaces the retired
+ * `--sanity-studio-origin` CLI flag on `ailf run`. The `SANITY_STUDIO_ORIGIN`
+ * env var still wins over this value at resolution time.
  */
 const SourceConfigSchema = z
     .object({
     projectId: z.string().min(1).optional(),
     dataset: z.string().min(1).optional(),
     baseUrl: z.string().url().optional(),
+    studioOrigin: z.string().url().optional(),
 })
     .optional();
 /**
@@ -435,6 +450,121 @@ const ReportStoreConfigSchema = z
     dataset: z.string().min(1),
 })
     .optional();
+/**
+ * Publish policy. Controls when `ailf run` writes a report to the Content
+ * Lake without an explicit `--publish` / `--no-publish` flag.
+ *
+ * - `auto: "always"`    — publish any run with a configured report store
+ * - `auto: "full-runs"` — publish non-debug runs (default)
+ * - `auto: "never"`     — never auto-publish; users must pass --publish
+ *
+ * `tag` is a default value for `--publish-tag` when not passed at the CLI.
+ *
+ * @see docs/design-docs/pipeline-command-surface.md §5.3
+ */
+const PublishConfigSchema = z
+    .object({
+    auto: z.enum(["always", "full-runs", "never"]).optional(),
+    tag: z.string().optional(),
+})
+    .optional();
+/**
+ * Execution-tier configuration. Per-environment values that the four
+ * retired CLI flags used to set: concurrency, grader replications, gap
+ * analysis toggle, and the AILF API URL.
+ *
+ * @see docs/design-docs/pipeline-command-surface.md §5.7 (W0077 Phase 6b)
+ */
+const ExecutionConfigSchema = z
+    .object({
+    concurrency: z.number().int().positive().optional(),
+    graderReplications: z.number().int().positive().optional(),
+    gapAnalysis: z.boolean().optional(),
+    apiUrl: z.string().url().optional(),
+})
+    .optional();
+/**
+ * Task-source configuration (W0077 Phase 6h). Replaces the retired
+ * `--task-source` and `--repo-tasks-path` CLI flags on `ailf run`.
+ *
+ * - `type`           — `content-lake` (default) or `repo`. When `repo`,
+ *                      tasks load from `repoTasksPath` (or
+ *                      `<cwd>/.ailf/tasks/` if unset).
+ * - `repoTasksPath`  — optional explicit path. Resolved relative to the
+ *                      caller's cwd. Required to exist on disk.
+ *
+ * No env-var fallback today; cascade is config-file → built-in default.
+ */
+const TaskSourceConfigSchema = z
+    .object({
+    type: z.enum(["content-lake", "repo"]).optional(),
+    repoTasksPath: z.string().min(1).optional(),
+})
+    .optional();
+/**
+ * Artifact-writer configuration (W0077 Phase 6g). Replaces the retired
+ * `--no-artifacts`, `--artifacts-dir`, and `--artifacts-exclude` CLI flags
+ * on `ailf run`. The `AILF_ARTIFACTS_DIR` env var still wins over
+ * `artifacts.dir` at resolution time. `artifacts.enabled` defaults to
+ * `true` (writers attached); set `false` to disable all writers (mirrors
+ * the legacy `--no-artifacts` semantics).
+ *
+ * Other commands (`ailf runs export`, etc.) keep their `--artifacts-dir`
+ * flag — that's a "read from this directory" override, distinct from the
+ * pipeline's write-side `artifacts.dir`.
+ */
+const ArtifactsConfigSchema = z
+    .object({
+    enabled: z.boolean().optional(),
+    dir: z.string().min(1).optional(),
+    exclude: z.array(z.string().min(1)).optional(),
+})
+    .optional();
+/**
+ * Owner attribution (W0077 Phase 6f). Replaces the retired `--owner-team`
+ * and `--owner-individual` CLI flags. Both feed the D0037 caller envelope
+ * that surfaces in remote-mode runs. Env vars `AILF_OWNER_TEAM` and
+ * `AILF_OWNER_INDIVIDUAL` still win over these values at resolution time.
+ */
+const OwnerConfigSchema = z
+    .object({
+    team: z.string().min(1).optional(),
+    individual: z.string().min(1).optional(),
+})
+    .optional();
+/**
+ * Agentic-mode configuration (W0077 Phase 6f). Replaces the retired
+ * `--header` and `--allowed-origin` CLI flags. `headers` is a key/value
+ * object (mirrors `DOC_HEADERS` env-var JSON shape); `allowedOrigins` is a
+ * list of origin globs. The `DOC_HEADERS` and `DOC_ALLOWED_ORIGIN(S)` env
+ * vars still apply downstream as additive merges.
+ */
+const AgenticConfigSchema = z
+    .object({
+    headers: z.record(z.string(), z.string()).optional(),
+    allowedOrigins: z.array(z.string().min(1)).optional(),
+})
+    .optional();
+/**
+ * Output-directory configuration. Replaces the retired `--output-dir`
+ * CLI flag on `ailf run`. Resolution order:
+ *
+ *   .ailf/config.yaml `output.dir` > built-in default
+ *
+ * Path is resolved relative to the caller's cwd. The built-in default is
+ * `<cwd>/.ailf/results/latest/` (see resolve-output-dir.ts). Other commands
+ * (`ailf publish`, `ailf pr-comment`, etc.) keep their `--output-dir`
+ * flag — that's a "read from this directory" override, distinct from the
+ * pipeline's write-side `output.dir`.
+ *
+ * @see docs/design-docs/pipeline-command-surface.md §5.7 (W0077 Phase 6c)
+ * @see docs/design-docs/output-dir-routing.md
+ */
+const OutputConfigSchema = z
+    .object({
+    dir: z.string().min(1).optional(),
+})
+    .optional();
 /**
  * Zod schema for .ailf/config.yaml — controls documentation source,
  * report destination, and trigger behavior for evaluations from an
@@ -443,6 +573,13 @@ const ReportStoreConfigSchema = z
 export const RepoConfigSchema = z.object({
     source: SourceConfigSchema,
     reportStore: ReportStoreConfigSchema,
+    publish: PublishConfigSchema,
+    execution: ExecutionConfigSchema,
+    output: OutputConfigSchema,
+    owner: OwnerConfigSchema,
+    agentic: AgenticConfigSchema,
+    artifacts: ArtifactsConfigSchema,
+    taskSource: TaskSourceConfigSchema,
     triggers: z
         .object({
         pr: TriggerConfigSchema.optional(),

package/dist/cli.d.ts

@@ -11,7 +11,7 @@
  * appends Quick Start examples.
  *
  * Usage:
- *   ailf pipeline [flags]       # full evaluation pipeline
+ *   ailf run [flags]            # full evaluation run
  *   ailf compare [flags]        # compare evaluation runs
  *   ailf baseline <cmd> [flags] # baseline management
  *   ailf validate [flags]       # config validation
@@ -24,6 +24,6 @@
  *   --dotenv <path>             # override default .env path
  *
  * Dev mode (without building):
- *   tsx src/cli.ts pipeline --debug
+ *   tsx src/cli.ts run --debug
  */
 export {};