@sanity/ailf 1.0.0 → 2.0.1

package/dist/commands/generate-configs.js

@@ -1,14 +1,14 @@
 /**
- * generate-configs command — generate promptfoo config files from models.yaml.
+ * generate-configs command — generate promptfoo config files via the compiler pipeline.
  *
- * Uses the composition root to wire adapters, then calls generateConfigs()
- * directly — the same code path as the pipeline.
+ * Uses the composition root to wire adapters, then runs GenerateConfigsStep
+ * directly — the same code path as the full pipeline.
  */
 import { dirname, resolve } from "path";
 import { fileURLToPath } from "url";
 import { Command } from "commander";
 import { createAppContext } from "../composition-root.js";
-import { generateConfigs } from "../pipeline/generate-configs.js";
+import { GenerateConfigsStep } from "../orchestration/steps/generate-configs-step.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const ROOT = resolve(__dirname, "..", "..");
 export function createGenerateConfigsCommand() {
@@ -19,6 +19,7 @@ export function createGenerateConfigsCommand() {
         try {
             const ctx = createAppContext({
                 rootDir: ROOT,
+                outputDir: resolve(ROOT, "results", "latest"),
                 mode: "literacy",
                 noAutoScope: false,
                 skipFetch: true,
@@ -35,10 +36,21 @@ export function createGenerateConfigsCommand() {
                 remote: false,
                 apiUrl: "https://ailf-api.sanity.build",
             });
-            generateConfigs({
-                rootDir: ctx.config.rootDir,
-                source: opts.source,
-            });
+            const step = new GenerateConfigsStep();
+            // Run validation checks first
+            const issues = step.check(ctx);
+            if (issues.length > 0) {
+                for (const issue of issues) {
+                    console.error(`  ❌ ${issue.message}`);
+                }
+                process.exitCode = 1;
+                return;
+            }
+            const result = await step.execute(ctx, {});
+            if (result.status === "failed") {
+                console.error(`❌ ${result.error}`);
+                process.exitCode = 1;
+            }
         }
         catch (err) {
             process.exitCode = 1;

package/dist/commands/init.d.ts

@@ -5,12 +5,13 @@
  * task files. The generated files are ready-to-edit starting points —
  * not live evaluation tasks.
  *
- * YAML output (default) preserves the inline comments from the source
- * YAML files in packages/core/examples/. JSON output is a plain
- * serialization of the parsed data — no comments.
+ * TypeScript output (default) uses define* helpers from @sanity/ailf-core
+ * for full IDE autocomplete and type checking. YAML output serializes the
+ * parsed task data. JSON output is a plain serialization of the parsed data.
  *
  * Usage:
- *   ailf init                        # YAML output (default)
+ *   ailf init                        # TypeScript output (default)
+ *   ailf init --output-format yaml   # YAML output
  *   ailf init --output-format json   # JSON output
  *   ailf init --force                # overwrite existing files
  *   ailf init --path ./my-dir        # target a specific directory

package/dist/commands/init.js

@@ -5,12 +5,13 @@
  * task files. The generated files are ready-to-edit starting points —
  * not live evaluation tasks.
  *
- * YAML output (default) preserves the inline comments from the source
- * YAML files in packages/core/examples/. JSON output is a plain
- * serialization of the parsed data — no comments.
+ * TypeScript output (default) uses define* helpers from @sanity/ailf-core
+ * for full IDE autocomplete and type checking. YAML output serializes the
+ * parsed task data. JSON output is a plain serialization of the parsed data.
  *
  * Usage:
- *   ailf init                        # YAML output (default)
+ *   ailf init                        # TypeScript output (default)
+ *   ailf init --output-format yaml   # YAML output
  *   ailf init --output-format json   # JSON output
  *   ailf init --force                # overwrite existing files
  *   ailf init --path ./my-dir        # target a specific directory
@@ -18,16 +19,17 @@
 import { Command } from "commander";
 import { existsSync, mkdirSync, writeFileSync } from "fs";
 import { resolve, relative } from "path";
-import { ailfConfigData, ailfConfigYaml, taskYamlFiles, TASK_FILE_NAMES, allTaskData, workflowYaml, } from "../_vendor/ailf-core/index.js";
+import { ailfConfigData, ailfConfigYaml, ailfConfigTs, taskYamlFiles, taskTsFiles, TASK_FILE_NAMES, TASK_EXAMPLES, allTaskData, workflowYaml, } from "../_vendor/ailf-core/index.js";
 // ---------------------------------------------------------------------------
 // Command factory
 // ---------------------------------------------------------------------------
 export function createInitCommand() {
     return new Command("init")
         .description("Initialize a directory for AI Literacy Framework evaluation")
-        .option("--output-format <fmt>", 'Output format for generated files: "yaml" (default) or "json"', "yaml")
+        .option("--output-format <fmt>", 'Output format for generated files: "ts" (default), "yaml", or "json"', "ts")
         .option("--force", "Overwrite existing files", false)
         .option("--path <dir>", "Target directory (default: current directory)", ".")
+        .option("--mode <mode>", "Scaffold for a specific mode: literacy, mcp-server, custom (default: all modes)")
         .action(async (opts) => {
         await runInit(opts);
     });
@@ -51,13 +53,27 @@ function rel(from, to) {
     const r = relative(from, to);
     return r.startsWith(".") ? r : `./${r}`;
 }
+/** Filter task stems by mode using TASK_EXAMPLES metadata */
+function taskStemsForMode(mode) {
+    return TASK_EXAMPLES.filter((t) => t.mode === mode).map((t) => t.stem);
+}
 // ---------------------------------------------------------------------------
 // Init logic
 // ---------------------------------------------------------------------------
 async function runInit(opts) {
-    const format = opts.outputFormat === "json" ? "json" : "yaml";
-    const ext = format === "json" ? ".json" : ".yaml";
+    const validFormats = new Set(["ts", "yaml", "json"]);
+    if (!validFormats.has(opts.outputFormat)) {
+        console.error(`  ✗ Invalid output format "${opts.outputFormat}". Valid options: ts, yaml, json`);
+        process.exitCode = 1;
+        return;
+    }
+    const format = opts.outputFormat;
     const force = opts.force;
+    if (format === "yaml") {
+        console.warn("  ⚠ --output-format yaml is deprecated. TypeScript (default) is the\n" +
+            "    recommended format — it provides full IDE autocomplete via defineTask().\n" +
+            "    YAML output will be removed in a future release.\n");
+    }
     // Resolve target from the caller's actual working directory
     const callerCwd = process.env.AILF_CALLER_CWD ?? process.cwd();
     const targetDir = resolve(callerCwd, opts.path);
@@ -72,27 +88,87 @@ async function runInit(opts) {
     console.log(`  ✓ Created ${rel(targetDir, tasksDir)}/`);
     const written = [];
     const skipped = [];
-    // 2. Write .ailf/config.yaml (or .json)
-    //    YAML: raw string passthrough (preserves comments)
-    //    JSON: serialize the parsed data
-    const configPath = resolve(ailfDir, `config${ext}`);
-    const configContent = format === "yaml"
-        ? ailfConfigYaml
-        : JSON.stringify(ailfConfigData, null, 2) + "\n";
-    if (writeIfNew(configPath, configContent, force)) {
-        written.push(rel(targetDir, configPath));
+    // 2. Write project config
+    if (format === "ts") {
+        // TypeScript: ailf.config.ts with defineConfig helper
+        const configPath = resolve(ailfDir, "ailf.config.ts");
+        if (writeIfNew(configPath, ailfConfigTs, force)) {
+            written.push(rel(targetDir, configPath));
+        }
+        else {
+            skipped.push(rel(targetDir, configPath));
+        }
+    }
+    else if (format === "yaml") {
+        // YAML: raw string passthrough (preserves comments)
+        const configPath = resolve(ailfDir, "config.yaml");
+        if (writeIfNew(configPath, ailfConfigYaml, force)) {
+            written.push(rel(targetDir, configPath));
+        }
+        else {
+            skipped.push(rel(targetDir, configPath));
+        }
     }
     else {
-        skipped.push(rel(targetDir, configPath));
+        // JSON: serialize the parsed data
+        const configPath = resolve(ailfDir, "config.json");
+        const content = JSON.stringify(ailfConfigData, null, 2) + "\n";
+        if (writeIfNew(configPath, content, force)) {
+            written.push(rel(targetDir, configPath));
+        }
+        else {
+            skipped.push(rel(targetDir, configPath));
+        }
     }
     // 3. Write example tasks to .ailf/tasks/
-    //    YAML: raw string passthrough (preserves comments)
-    //    JSON: serialize individual task data
-    if (format === "yaml") {
-        // Each task is its own commented YAML file — write as-is
-        for (const stem of TASK_FILE_NAMES) {
-            const taskPath = resolve(tasksDir, `${stem}.yaml`);
+    const modeFilter = opts.mode;
+    const isCustomMode = modeFilter === "custom";
+    // Determine which task stems to write based on mode filter
+    let stemsToWrite;
+    if (isCustomMode) {
+        // Custom mode: write one literacy example as a starting point
+        stemsToWrite = taskStemsForMode("literacy").slice(0, 1);
+    }
+    else if (modeFilter === "literacy") {
+        stemsToWrite = taskStemsForMode("literacy");
+    }
+    else if (modeFilter === "mcp-server") {
+        stemsToWrite = taskStemsForMode("mcp-server");
+    }
+    else if (modeFilter === "knowledge-probe") {
+        stemsToWrite = taskStemsForMode("knowledge-probe");
+    }
+    else {
+        // Default (no --mode): write all tasks
+        stemsToWrite = [...TASK_FILE_NAMES];
+    }
+    if (format === "ts") {
+        for (const stem of stemsToWrite) {
+            let content = taskTsFiles[stem];
+            if (!content)
+                continue;
+            // For MCP-only init, activate the draft task
+            if (modeFilter === "mcp-server") {
+                content = content.replace('status: "draft",', '// status: "active", // Activated — this task runs in evaluations');
+            }
+            const fileName = isCustomMode && stem === stemsToWrite[0]
+                ? "example-custom.task.ts"
+                : `${stem}.task.ts`;
+            const taskPath = resolve(tasksDir, fileName);
+            if (writeIfNew(taskPath, content, force)) {
+                written.push(rel(targetDir, taskPath));
+            }
+            else {
+                skipped.push(rel(targetDir, taskPath));
+            }
+        }
+    }
+    else if (format === "yaml") {
+        for (const stem of stemsToWrite) {
             const content = taskYamlFiles[stem];
+            if (!content)
+                continue;
+            const taskPath = resolve(tasksDir, `${stem}.yaml`);
             if (writeIfNew(taskPath, content, force)) {
                 written.push(rel(targetDir, taskPath));
             }
@@ -106,8 +182,12 @@ async function runInit(opts) {
         const tasks = Array.isArray(allTaskData)
             ? allTaskData
             : [allTaskData];
+        // Build a set of task IDs that match the selected stems
+        const selectedIds = new Set(stemsToWrite.flatMap((s) => TASK_EXAMPLES.filter((t) => t.stem === s).map((t) => t.stem)));
         for (const task of tasks) {
             const taskId = task.id;
+            if (!selectedIds.has(taskId))
+                continue;
             const taskPath = resolve(tasksDir, `${taskId}.json`);
             const content = JSON.stringify([task], null, 2) + "\n";
             if (writeIfNew(taskPath, content, force)) {
@@ -118,6 +198,16 @@ async function runInit(opts) {
             }
         }
     }
+    // 3b. Write custom preset scaffold (--mode custom only)
+    if (isCustomMode && format === "ts") {
+        const presetPath = resolve(ailfDir, "preset.ts");
+        if (writeIfNew(presetPath, CUSTOM_PRESET_TS, force)) {
+            written.push(rel(targetDir, presetPath));
+        }
+        else {
+            skipped.push(rel(targetDir, presetPath));
+        }
+    }
     // 4. Write .gitignore in .ailf/ (keep results out of version control)
     const gitignorePath = resolve(ailfDir, ".gitignore");
     const gitignoreContent = `# AILF generated files\nresults/\ncontexts/\n`;
@@ -150,18 +240,24 @@ async function runInit(opts) {
             console.log(`  ⊘ Skipped ${f} (already exists, use --force to overwrite)`);
         }
     }
+    const taskExt = format === "ts" ? ".task.ts" : format === "yaml" ? ".yaml" : ".json";
     console.log();
     console.log("  Next steps:");
     console.log();
     console.log(`  1. Edit the example tasks in ${rel(targetDir, tasksDir)}/ — update`);
     console.log("     slugs and prompts for your documentation");
-    console.log("  2. Validate locally: npx @sanity/ailf@latest validate-tasks .ailf/tasks/");
+    console.log(`  2. Validate locally: npx @sanity/ailf@latest validate-tasks .ailf/tasks/`);
     console.log("  3. Add two GitHub Actions secrets");
     console.log("     (Settings → Secrets and variables → Actions):");
     console.log("     • AILF_API_KEY — your API key (starts with ailf_live_sk_)");
     console.log("     • NPM_TOKEN   — npm token with read access to @sanity scope");
     console.log("  4. Push — the workflow at .github/workflows/ailf-eval.yml runs");
     console.log("     automatically on PRs");
+    if (format === "ts") {
+        console.log();
+        console.log(`  💡 TypeScript tasks (${taskExt}) give you full IDE autocomplete`);
+        console.log("     via defineTask() from @sanity/ailf-core.");
+    }
     console.log();
     console.log("  🔑 Retrieve secrets from 1Password (Sanity employees):");
     console.log();
@@ -177,3 +273,72 @@ async function runInit(opts) {
     console.log("     AILF_API_KEY=... npx @sanity/ailf@latest pipeline --remote --debug");
     console.log();
 }
+// ---------------------------------------------------------------------------
+// Custom preset scaffold template
+// ---------------------------------------------------------------------------
+const CUSTOM_PRESET_TS = `/**
+ * Custom preset — your domain-specific evaluation configuration.
+ *
+ * This preset targets the "literacy" mode base and inherits its evaluation
+ * methodology (rubrics, scoring profiles, prompt templates). You only need
+ * to provide domain-specific configuration: where your docs live, what
+ * features to track, and how to fetch documentation.
+ *
+ * To use a different mode (e.g., "mcp-server"), change the mode field.
+ * Available built-in modes: literacy, mcp-server, knowledge-probe, agent-harness.
+ *
+ * @see https://github.com/sanity-labs/ai-literacy-framework/blob/main/docs/presets.md
+ */
+
+import { definePreset } from "../_vendor/ailf-core/index.js"
+
+export default definePreset({
+  name: "my-docs-evaluation",
+  manifest: {
+    name: "my-docs-evaluation",
+    version: "1.0.0",
+    description: "Documentation literacy evaluation for my project.",
+    pluginApiVersion: 1,
+  },
+
+  // Target the literacy mode base — inherits rubrics, scoring, prompts.
+  // Change to "mcp-server" to evaluate MCP tool usage instead.
+  mode: "literacy",
+
+  // Source definitions — where your documentation lives.
+  sourceDefs: [
+    {
+      name: "production",
+      baseUrl: "https://docs.example.com",
+      // projectId: "your-sanity-project-id",
+      // dataset: "production",
+    },
+  ],
+
+  // Feature registry — what product features you're tracking coverage for.
+  featureDefs: {
+    features: [
+      {
+        id: "getting-started",
+        name: "Getting Started Guide",
+        sections: ["guides"],
+        status: "covered",
+        area: "guides",
+        priority: "critical",
+      },
+      {
+        id: "api-reference",
+        name: "API Reference",
+        sections: ["reference"],
+        status: "uncovered",
+        priority: "high",
+      },
+    ],
+  },
+
+  // Optional: override mode base rubrics, scoring, or prompts here.
+  // rubricTemplates: [{ ... }],
+  // scoringProfiles: { ... },
+  // promptTemplates: { ... },
+})
+`;

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

@@ -36,6 +36,8 @@ export interface ResolvedOptions {
     noAutoScope: boolean;
     noCache: boolean;
     noRemoteCache: boolean;
+    /** Base directory for user-facing pipeline output artifacts (always resolved). */
+    outputDir: string;
     outputPath?: string;
     perspectiveOverride?: string;
     projectIdOverride?: string;
@@ -57,10 +59,14 @@ export interface ResolvedOptions {
     repoTasksPath?: string;
     taskOption?: string;
     tagOption?: string[];
-    taskSourceType?: "content-lake" | "repo" | "yaml";
+    taskSourceType?: "content-lake" | "repo";
     urlArgs: string[];
     apiUrl: string;
     apiKey?: string;
+    captureEnabled: boolean;
+    captureDir?: string;
+    captureCompress: boolean;
+    captureExtras: boolean;
 }
 /**
  * Pure option resolution — computes ResolvedOptions from CLI flags without

package/dist/commands/pipeline-action.js

@@ -10,7 +10,7 @@
  *
  * @see packages/eval/src/orchestration/ for the step-based pipeline
  */
-import { existsSync, readFileSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, resolve } from "path";
 import { fileURLToPath } from "url";
 import { classifyUrls } from "../pipeline/classify-url.js";
@@ -209,6 +209,23 @@ export function computeResolvedOptions(opts) {
     const remote = opts.remote || process.env.AILF_REMOTE === "1";
     const apiUrl = opts.apiUrl ?? process.env.AILF_API_URL ?? "https://ailf-api.sanity.build";
     const apiKey = process.env.AILF_API_KEY ?? undefined;
+    // Output directory: explicit flag → repo-task heuristic → default
+    const resolvedRepoTasksPath = opts.repoTasksPath
+        ? resolve(callerCwd, opts.repoTasksPath)
+        : undefined;
+    const resolvedTaskSourceType = resolveTaskSourceType(opts.taskSource);
+    let outputDir;
+    if (opts.outputDir) {
+        outputDir = resolve(callerCwd, opts.outputDir);
+    }
+    else if (resolvedTaskSourceType === "repo" || resolvedRepoTasksPath) {
+        outputDir = resolvedRepoTasksPath
+            ? resolve(resolvedRepoTasksPath, "..", "results", "latest")
+            : resolve(callerCwd, ".ailf", "results", "latest");
+    }
+    else {
+        outputDir = resolve(ROOT, "results", "latest");
+    }
     return {
         allowedOriginArgs,
         apiKey,
@@ -233,6 +250,7 @@ export function computeResolvedOptions(opts) {
         noAutoScope: opts.autoScope === false,
         noCache: !opts.cache,
         noRemoteCache: opts.remoteCache === false,
+        outputDir,
         outputPath: opts.output,
         perspectiveOverride,
         projectIdOverride,
@@ -250,24 +268,25 @@ export function computeResolvedOptions(opts) {
         skipFetch: opts.skipFetch,
         source: opts.source,
         studioOriginOverride,
-        repoTasksPath: opts.repoTasksPath
-            ? resolve(callerCwd, opts.repoTasksPath)
-            : undefined,
+        repoTasksPath: resolvedRepoTasksPath,
         taskOption,
         tagOption,
-        taskSourceType: resolveTaskSourceType(opts.taskSource),
+        taskSourceType: resolvedTaskSourceType,
         urlArgs,
+        captureEnabled: opts.capture || process.env.AILF_CAPTURE === "1",
+        captureDir: opts.captureDir ?? process.env.AILF_CAPTURE_DIR,
+        captureCompress: opts.captureCompress !== false &&
+            process.env.AILF_CAPTURE_COMPRESS !== "0",
+        captureExtras: opts.captureExtras !== false && process.env.AILF_CAPTURE_EXTRAS !== "0",
     };
 }
 /** Resolve and validate the --task-source flag value. */
 function resolveTaskSourceType(raw) {
     if (!raw || raw === "content-lake")
         return undefined; // default — Content Lake
-    if (raw === "yaml")
-        return "yaml";
     if (raw === "repo")
         return "repo";
-    console.error(`❌ Invalid --task-source "${raw}". Must be "yaml", "repo", or "content-lake".`);
+    console.error(`❌ Invalid --task-source "${raw}". Must be "repo" or "content-lake".`);
     process.exit(1);
 }
 // ---------------------------------------------------------------------------
@@ -304,17 +323,26 @@ export async function executePipeline(cliOpts) {
         if (cliOpts.output) {
             config.outputPath = resolve(callerCwd, cliOpts.output);
         }
+        // Output dir: explicit CLI flag → repo-task heuristic → file-config default
+        if (cliOpts.outputDir) {
+            config.outputDir = resolve(callerCwd, cliOpts.outputDir);
+        }
+        else if (config.repoTasksPath) {
+            config.outputDir = resolve(config.repoTasksPath, "..", "results", "latest");
+        }
         // Create AppContext directly from the merged config so adapters
         // (especially taskSource) are wired from the file config's
         // taskSourceType — not from CLI defaults.
+        console.log(`  📂 Output directory: ${config.outputDir}`);
         const ctx = createAppContext(config);
         const pipelineStart = Date.now();
         const steps = buildStepSequence(ctx, pipelineStart);
         const result = await orchestratePipeline(ctx, steps);
-        writePipelineResult(result);
+        writePipelineResult(result, config.outputDir);
         process.exit(result.success ? 0 : 1);
     }
     const o = resolveOptions(cliOpts);
+    console.log(`  📂 Output directory: ${o.outputDir}`);
     // Remote mode — submit to AILF API instead of running locally.
     // Use the caller's working directory (not the package root) because
     // remote mode reads .ailf/tasks/ from the user's repo, not from
@@ -350,7 +378,7 @@ export async function executePipeline(cliOpts) {
     const pipelineStart = Date.now();
     const steps = buildStepSequence(ctx, pipelineStart);
     const result = await orchestratePipeline(ctx, steps);
-    writePipelineResult(result);
+    writePipelineResult(result, o.outputDir);
     process.exit(result.success ? 0 : 1);
 }
 // ---------------------------------------------------------------------------
@@ -362,15 +390,11 @@ export async function executePipeline(cliOpts) {
 function resolveOptions(opts) {
     return computeResolvedOptions(opts);
 }
-function writePipelineResult(result) {
-    const resultFile = resolve(ROOT, "results", "latest", "pipeline-result.json");
-    try {
-        writeFileSync(resultFile, JSON.stringify(result, null, 2));
-        console.log(`  📄 Pipeline result: ${resultFile}\n`);
-    }
-    catch {
-        // results/latest/ may not exist yet — not critical
-    }
+function writePipelineResult(result, outputDir) {
+    mkdirSync(outputDir, { recursive: true });
+    const resultFile = resolve(outputDir, "pipeline-result.json");
+    writeFileSync(resultFile, JSON.stringify(result, null, 2));
+    console.log(`  📄 Pipeline result: ${resultFile}\n`);
 }
 /**
  * Load .ailf/config.yaml if --repo-tasks-path is set and the config file

package/dist/commands/pipeline.d.ts

@@ -5,7 +5,7 @@
  * options object, bridges to process.env for downstream modules, and
  * delegates to runPipeline().
  *
- * @see docs/CLI.md for the full flag reference.
+ * @see docs/cli.md for the full flag reference.
  */
 import { Command } from "commander";
 /**
@@ -37,6 +37,7 @@ export interface PipelineCliOptions {
     mode: string;
     variant?: string;
     output?: string;
+    outputDir?: string;
     promptfooUrl?: string;
     publish?: boolean;
     publishTag?: string;
@@ -63,5 +64,9 @@ export interface PipelineCliOptions {
     url: string[];
     urls: string[];
     apiUrl?: string;
+    capture: boolean;
+    captureDir?: string;
+    captureCompress: boolean;
+    captureExtras: boolean;
 }
 export declare function createPipelineCommand(): Command;

package/dist/commands/pipeline.js

@@ -5,7 +5,7 @@
  * options object, bridges to process.env for downstream modules, and
  * delegates to runPipeline().
  *
- * @see docs/CLI.md for the full flag reference.
+ * @see docs/cli.md for the full flag reference.
  */
 import { Command } from "commander";
 import { LiteracyVariant } from "../pipeline/normalize-mode.js";
@@ -48,11 +48,16 @@ export function createPipelineCommand() {
         .option("--report-project <id>", "Sanity project ID for report store")
         .option("--config <path>", "Load pipeline config from a TS/JS/YAML/JSON file (overrides most CLI flags)")
         .option("-o, --output <path>", "Write PR comment markdown to file")
+        .option("--output-dir <path>", "Base directory for pipeline output artifacts (default: inferred from execution context)")
         .option("--promptfoo-url <url>", "Promptfoo share URL for report")
-        .option("--task-source <type>", "Task definition source: content-lake (default — Sanity Content Lake), repo (repo tasks only, no Content Lake merge), yaml (tasks/*.yaml files, legacy)", "content-lake")
+        .option("--task-source <type>", "Task definition source: content-lake (default — Sanity Content Lake), repo (repo tasks only, no Content Lake merge)", "content-lake")
         .option("--repo-tasks-path <path>", "Path to repo-based task definitions (.ailf/tasks/ directory)")
         .option("--remote", "Submit evaluation to the AILF API instead of running locally", false)
         .option("--api-url <url>", "AILF API base URL (default: https://ailf-api.sanity.build)")
+        .option("--capture", "Enable artifact capture for this run", false)
+        .option("--capture-dir <path>", "Base directory for capture output (default: results/captures/)")
+        .option("--no-capture-compress", "Disable tar.gz compression of captures")
+        .option("--no-capture-extras", "Exclude mode-specific artifacts from captures")
         .action(async (opts) => {
         const { executePipeline } = await import("./pipeline-action.js");
         await executePipeline(opts);

package/dist/commands/pr-comment.js

@@ -20,6 +20,7 @@ export function createPrCommentCommand() {
         try {
             const ctx = createAppContext({
                 rootDir: ROOT,
+                outputDir: resolve(ROOT, "results", "latest"),
                 mode: "literacy",
                 noAutoScope: false,
                 skipFetch: true,

package/dist/commands/publish.js

@@ -87,6 +87,7 @@ async function runPublishCommand(summaryPath, opts) {
         noAutoScope: false,
         noCache: true,
         noRemoteCache: true,
+        outputDir: resolve(ROOT, "results", "latest"),
         publishEnabled: true,
         publishTag: opts.tag,
         readinessEnabled: false,

package/dist/commands/shared/help.js

@@ -74,8 +74,8 @@ Quick Start:
 
 Documentation:
   Repository   https://github.com/sanity-io/ai-literacy-framework
-  CLI Guide    https://github.com/sanity-io/ai-literacy-framework/blob/main/docs/CLI.md
-  Getting Started  https://github.com/sanity-io/ai-literacy-framework/blob/main/docs/GETTING_STARTED.md
+  CLI Guide    https://github.com/sanity-io/ai-literacy-framework/blob/main/docs/cli.md
+  Getting Started  https://github.com/sanity-io/ai-literacy-framework/blob/main/docs/getting-started.md
 
 Run ailf <command> --help for detailed usage of any command.`;
 // ---------------------------------------------------------------------------

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

@@ -1,7 +1,7 @@
 /**
- * validate-tasks command — standalone validation of repo-based task YAML files.
+ * validate-tasks command — standalone validation of task files.
  *
- * Validates .ailf/tasks/*.yaml files against the RepoTaskSchema without
+ * Validates .ailf/tasks/*.yaml files against the CanonicalTaskSchema without
  * running the full pipeline. Useful for pre-commit hooks and CI checks
  * in external repos.
  *