@sanity/ailf 0.5.0 → 2.0.0

package/dist/commands/init.js

@@ -5,12 +5,14 @@
  * 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 preserves
+ * inline comments from the source files. 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 +20,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_TS_FILE_NAMES, 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);
     });
@@ -55,8 +58,13 @@ function rel(from, to) {
 // 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;
     // Resolve target from the caller's actual working directory
     const callerCwd = process.env.AILF_CALLER_CWD ?? process.cwd();
@@ -72,24 +80,103 @@ 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
+    const modeFilter = opts.mode;
+    const isCustomMode = modeFilter === "custom";
+    if (format === "ts") {
+        // TypeScript: *.task.ts files with defineTask helper
+        // Default (no --mode): write literacy examples + draft MCP/probe examples
+        // --mode literacy: only literacy examples
+        // --mode mcp-server: only MCP examples (active, not draft)
+        // --mode custom: only a custom example task
+        if (!modeFilter || modeFilter === "literacy") {
+            for (const stem of TASK_TS_FILE_NAMES) {
+                const taskPath = resolve(tasksDir, `${stem}.task.ts`);
+                const content = taskTsFiles[stem];
+                if (writeIfNew(taskPath, content, force)) {
+                    written.push(rel(targetDir, taskPath));
+                }
+                else {
+                    skipped.push(rel(targetDir, taskPath));
+                }
+            }
+        }
+        // Draft examples for other modes (default init only)
+        if (!modeFilter) {
+            const mcpPath = resolve(tasksDir, "example-mcp-tool-usage.task.ts");
+            if (writeIfNew(mcpPath, MCP_DRAFT_TASK_TS, force)) {
+                written.push(rel(targetDir, mcpPath));
+            }
+            else {
+                skipped.push(rel(targetDir, mcpPath));
+            }
+            const probePath = resolve(tasksDir, "example-knowledge-probe.task.ts");
+            if (writeIfNew(probePath, PROBE_DRAFT_TASK_TS, force)) {
+                written.push(rel(targetDir, probePath));
+            }
+            else {
+                skipped.push(rel(targetDir, probePath));
+            }
+        }
+        // MCP-only init
+        if (modeFilter === "mcp-server") {
+            const mcpContent = MCP_DRAFT_TASK_TS.replace('status: "draft",', '// status: "active", // Activated — this task runs in evaluations');
+            const mcpPath = resolve(tasksDir, "example-mcp-tool-usage.task.ts");
+            if (writeIfNew(mcpPath, mcpContent, force)) {
+                written.push(rel(targetDir, mcpPath));
+            }
+            else {
+                skipped.push(rel(targetDir, mcpPath));
+            }
+        }
+        // Custom preset scaffold
+        if (isCustomMode) {
+            const customTaskPath = resolve(tasksDir, "example-custom.task.ts");
+            // Reuse the GROQ literacy task as a starting point
+            if (taskTsFiles[TASK_TS_FILE_NAMES[0]]) {
+                if (writeIfNew(customTaskPath, taskTsFiles[TASK_TS_FILE_NAMES[0]], force)) {
+                    written.push(rel(targetDir, customTaskPath));
+                }
+                else {
+                    skipped.push(rel(targetDir, customTaskPath));
+                }
+            }
+        }
+    }
+    else if (format === "yaml") {
+        // YAML: raw string passthrough (preserves comments)
         for (const stem of TASK_FILE_NAMES) {
             const taskPath = resolve(tasksDir, `${stem}.yaml`);
             const content = taskYamlFiles[stem];
@@ -118,6 +205,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 +247,25 @@ 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. YAML and JSON are");
+        console.log("     also supported — re-run with --output-format yaml if preferred.");
+    }
     console.log();
     console.log("  🔑 Retrieve secrets from 1Password (Sanity employees):");
     console.log();
@@ -177,3 +281,178 @@ async function runInit(opts) {
     console.log("     AILF_API_KEY=... npx @sanity/ailf@latest pipeline --remote --debug");
     console.log();
 }
+// ---------------------------------------------------------------------------
+// Draft example templates for non-literacy modes
+// ---------------------------------------------------------------------------
+const MCP_DRAFT_TASK_TS = `/**
+ * Example Task: MCP Server tool-use evaluation (DRAFT).
+ *
+ * Tests whether an LLM can correctly discover and invoke Sanity MCP server
+ * tools. Connects to the hosted Sanity MCP server at https://mcp.sanity.io.
+ *
+ * Prerequisites:
+ *   - A Sanity API token with read access (for token-based auth)
+ *   - Or: OAuth authentication will be prompted on first connect
+ *
+ * Authentication options:
+ *   1. Token-based: set SANITY_API_TOKEN env var
+ *   2. OAuth: the server prompts for login on first connect
+ *
+ * Setup: npx sanity@latest mcp configure
+ * Docs:  https://www.sanity.io/docs/ai/mcp-server
+ *
+ * This task is a DRAFT — it won't run unless activated or explicitly targeted.
+ * To activate: change status to "active" or remove the status field.
+ */
+
+import { defineTask } from "../_vendor/ailf-core/index.js"
+
+export default defineTask({
+  mode: "mcp-server",
+  id: "example-mcp-tool-usage",
+  title: "MCP tool discovery and invocation",
+  description: "Example — tests Sanity MCP server tool-use (draft)",
+  area: "mcp",
+
+  // ── Server configuration ────────────────────────────────────
+  // The Sanity MCP server is hosted remotely at https://mcp.sanity.io.
+  // Authentication via API token header or OAuth.
+  //
+  // For token auth, set SANITY_API_TOKEN in your environment.
+  serverConfig: {
+    transport: "streamable-http",
+    url: "https://mcp.sanity.io",
+    env: {
+      SANITY_API_TOKEN: process.env.SANITY_API_TOKEN ?? "",
+    },
+  },
+
+  prompt: {
+    text: \`Use the available MCP tools to query all documents of type "article"
+in the Sanity dataset. Return the title and slug for each document.
+Limit results to 5 documents.\`,
+  },
+
+  assertions: [
+    {
+      type: "llm-rubric",
+      template: "mcp-input-validation",
+      criteria: [
+        "Correctly identifies the query_documents tool",
+        "Passes a valid GROQ query to filter by document type",
+        "Requests only the needed fields (title, slug)",
+      ],
+    },
+  ],
+
+  status: "draft",
+})
+`;
+const PROBE_DRAFT_TASK_TS = `/**
+ * Example Task: Knowledge probe baseline (DRAFT).
+ *
+ * Tests what the model knows about a topic without providing documentation.
+ * Used to establish a baseline for comparison with literacy evaluations.
+ * This task is a DRAFT — it won't run unless activated or explicitly targeted.
+ *
+ * To activate: change status to "active" or remove the status field.
+ */
+
+import { defineTask } from "../_vendor/ailf-core/index.js"
+
+export default defineTask({
+  mode: "knowledge-probe",
+  id: "example-knowledge-probe",
+  title: "Model knowledge of GROQ syntax",
+  description: "Example — probes baseline model knowledge (draft)",
+  area: "groq",
+
+  prompt: {
+    text: \`Explain the GROQ query language used by Sanity. Cover:
+1. Basic query syntax and projections
+2. How to filter and sort results
+3. Common patterns for fetching related documents
+Provide working code examples.\`,
+  },
+
+  assertions: [
+    {
+      type: "llm-rubric",
+      template: "task-completion",
+      criteria: [
+        "Demonstrates understanding of GROQ query syntax",
+        "Shows filtering and projection patterns",
+        "Code examples use valid GROQ syntax",
+      ],
+    },
+  ],
+
+  status: "draft",
+})
+`;
+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/interactive.js

@@ -9,6 +9,10 @@
  * Uses @inquirer/prompts for a clean, modern terminal UI.
  */
 import { Command } from "commander";
+import { LiteracyVariant } from "../pipeline/normalize-mode.js";
+// CLI command name for the baseline snapshot management subcommand.
+// Defined as a constant to avoid scattering the literal string across routing code.
+const BASELINE_CMD = "baseline";
 export function createInteractiveCommand() {
     return new Command("interactive")
         .description("Guided wizard for common evaluation workflows")
@@ -65,7 +69,7 @@ async function runInteractiveWizard() {
             {
                 description: "Save, compare, or list historical score snapshots",
                 name: "Manage baselines",
-                value: "baseline",
+                value: BASELINE_CMD,
             },
             {
                 description: "Weekly evaluation trends and area summaries",
@@ -93,7 +97,7 @@ async function runInteractiveWizard() {
         });
         return { args: dryRun ? ["--dry-run"] : [], command: "weekly-digest" };
     }
-    if (workflow === "baseline") {
+    if (workflow === BASELINE_CMD) {
         const subcommand = await select({
             choices: [
                 { name: "Save current scores", value: "save" },
@@ -102,7 +106,7 @@ async function runInteractiveWizard() {
             ],
             message: "Baseline operation:",
         });
-        return { args: [subcommand], command: "baseline" };
+        return { args: [subcommand], command: BASELINE_CMD };
     }
     if (workflow === "grader") {
         const subcommand = await select({
@@ -140,22 +144,22 @@ async function runInteractiveWizard() {
             {
                 description: "Evaluate with pre-fetched documentation context",
                 name: "Baseline (with docs vs without docs)",
-                value: "baseline",
+                value: LiteracyVariant.STANDARD,
             },
             {
                 description: "Baseline + record HTTP request patterns",
                 name: "Observed (instrumented)",
-                value: "observed",
+                value: LiteracyVariant.OBSERVED,
             },
             {
                 description: "Agent searches for docs itself via web tools",
                 name: "Agentic (agent-driven retrieval)",
-                value: "agentic",
+                value: LiteracyVariant.AGENTIC,
             },
         ],
         message: "Evaluation mode:",
     });
-    if (mode !== "baseline") {
+    if (mode !== LiteracyVariant.STANDARD) {
         args.push("--mode", mode);
     }
     // Step 3: Area scoping

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

@@ -31,6 +31,8 @@ export interface ResolvedOptions {
     headerArgs: string[];
     impactSummary?: ImpactSummary;
     mode: EvalMode;
+    /** Literacy variant — set when the user passes a legacy mode name */
+    variant?: string;
     noAutoScope: boolean;
     noCache: boolean;
     noRemoteCache: boolean;

package/dist/commands/pipeline-action.js

@@ -14,6 +14,7 @@ import { existsSync, readFileSync, writeFileSync } from "fs";
 import { dirname, resolve } from "path";
 import { fileURLToPath } from "url";
 import { classifyUrls } from "../pipeline/classify-url.js";
+import { normalizeMode } from "../pipeline/normalize-mode.js";
 import { assessImpact, buildReverseMapping, } from "../pipeline/reverse-mapping.js";
 import { buildAppContext } from "../orchestration/build-app-context.js";
 import { buildStepSequence } from "../orchestration/build-step-sequence.js";
@@ -23,9 +24,8 @@ import { parseRepoConfig, } from "../adapters/task-sources/repo-schemas.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const ROOT = resolve(__dirname, "..", "..");
 // ---------------------------------------------------------------------------
-// Valid modes & search modes
+// Valid search modes
 // ---------------------------------------------------------------------------
-const VALID_MODES = ["baseline", "observed", "agentic", "full"];
 const VALID_SEARCH_MODES = ["open", "origin-only", "off"];
 /**
  * Pure option resolution — computes ResolvedOptions from CLI flags without
@@ -36,10 +36,19 @@ 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 = process.env.AILF_CALLER_CWD ?? process.cwd();
-    // Validate mode
-    const mode = opts.mode;
-    if (!VALID_MODES.includes(mode)) {
-        console.error(`❌ Invalid mode "${opts.mode}". Must be one of: ${VALID_MODES.join(", ")}`);
+    // 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.
+    let mode;
+    let variant;
+    try {
+        const normalized = normalizeMode(opts.mode);
+        mode = normalized.mode;
+        // Explicit --variant flag takes precedence over what normalizeMode inferred
+        variant = opts.variant ?? normalized.variant;
+    }
+    catch (err) {
+        console.error(`❌ ${err instanceof Error ? err.message : String(err)}`);
         process.exit(1);
     }
     // Debug options — any sub-flag (--debug-n, --debug-pattern, --debug-sample)
@@ -220,6 +229,7 @@ export function computeResolvedOptions(opts) {
         headerArgs,
         impactSummary,
         mode,
+        variant,
         noAutoScope: opts.autoScope === false,
         noCache: !opts.cache,
         noRemoteCache: opts.remoteCache === false,

package/dist/commands/pipeline.d.ts

@@ -35,6 +35,7 @@ export interface PipelineCliOptions {
     header: string[];
     headers: string[];
     mode: string;
+    variant?: string;
     output?: string;
     promptfooUrl?: string;
     publish?: boolean;

package/dist/commands/pipeline.js

@@ -8,11 +8,13 @@
  * @see docs/CLI.md for the full flag reference.
  */
 import { Command } from "commander";
+import { LiteracyVariant } from "../pipeline/normalize-mode.js";
 import { addAgenticOptions, addDebugOptions, addSanitySourceOptions, } from "./shared/options.js";
 export function createPipelineCommand() {
     const cmd = new Command("pipeline")
         .description("Run the full evaluation pipeline")
-        .option("-m, --mode <mode>", "Evaluation mode: full (default — floor + ceiling + actual), baseline (floor + ceiling only), agentic (actual only), observed", "full")
+        .option("-m, --mode <mode>", "Evaluation mode: literacy (default), mcp-server, agent-harness, knowledge-probe, custom. Legacy aliases (baseline, agentic, observed, full) are accepted and normalized to literacy + variant.", LiteracyVariant.FULL)
+        .option("--variant <variant>", "Literacy variant: full (default — standard + agentic), baseline (standard only), agentic (agentic only), observed. Only applies to --mode literacy.")
         .option("-s, --source <name>", "Documentation source name (from sources.yaml)")
         .option("-n, --dry-run", "Validate configuration only, no execution", false)
         .option("--skip-fetch", "Reuse cached documentation contexts", false)
@@ -44,7 +46,7 @@ export function createPipelineCommand() {
         .option("--publish-tag <tag>", "Label for published report")
         .option("--report-dataset <name>", "Sanity dataset for report store")
         .option("--report-project <id>", "Sanity project ID for report store")
-        .option("--config <path>", "Load pipeline config from a JSON/YAML file (overrides most CLI flags)")
+        .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("--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")

package/dist/commands/pr-comment.js

@@ -20,7 +20,7 @@ export function createPrCommentCommand() {
         try {
             const ctx = createAppContext({
                 rootDir: ROOT,
-                mode: "baseline",
+                mode: "literacy",
                 noAutoScope: false,
                 skipFetch: true,
                 skipEval: true,

package/dist/commands/publish.js

@@ -52,7 +52,7 @@ export function createPublishCommand() {
  */
 function buildProvenanceFromSummary(summary) {
     const areas = summary.scores.map((s) => s.feature);
-    const mode = (process.env.EVAL_MODE ?? "baseline");
+    const mode = (process.env.EVAL_MODE ?? "literacy");
     const source = {
         baseUrl: summary.source?.baseUrl ?? "https://www.sanity.io/docs",
         dataset: summary.source?.dataset ?? process.env.SANITY_DATASET ?? "next",
@@ -83,7 +83,7 @@ async function runPublishCommand(summaryPath, opts) {
         compareEnabled: false,
         discoveryReportEnabled: false,
         gapAnalysisEnabled: false,
-        mode: "baseline",
+        mode: "literacy",
         noAutoScope: false,
         noCache: true,
         noRemoteCache: true,

package/dist/commands/readiness-report.js

@@ -10,14 +10,14 @@ 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 { ConfigNotFoundError, loadConfigFile, } from "../pipeline/compiler/config-loader.js";
 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");
+// thresholds loaded via loadConfigFile below
 const BASELINES_DIR = join(ROOT, "results", "baselines");
 export function createReadinessReportCommand() {
     return new Command("readiness-report")
@@ -33,12 +33,19 @@ export function createReadinessReportCommand() {
         }
         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}.`);
+        let parsedThresholds;
+        try {
+            parsedThresholds = loadConfigFile("thresholds", ROOT).data;
+        }
+        catch (err) {
+            if (err instanceof ConfigNotFoundError) {
+                console.error("❌ Threshold config not found in config/.");
+            }
+            else {
+                console.error(`❌ Failed to load threshold config: ${err instanceof Error ? err.message : err}`);
+            }
             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

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.
  *