@sanity/ailf 1.0.0 → 2.0.0

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

@@ -1,8 +1,129 @@
 /**
- * repo-validation.ts — Re-exports semantic validation from @sanity/ailf-tasks.
+ * repo-validation.ts — Semantic validation for task definitions.
  *
- * The validation logic is the single source of truth in @sanity/ailf-tasks.
- * This file re-exports so existing eval-package importers don't need
- * to change their import paths.
+ * Checks that go beyond Zod schema parsing:
+ * - Assertion types are in the curated set
+ * - Rubric template names resolve to known templates
+ * - Doc ref slugs look reasonable (slugs, not URLs)
+ * - Tasks have at least one LLM rubric assertion (recommended)
+ * - Tasks have a prompt text (recommended)
+ *
+ * These produce warnings, not errors — the pipeline can still run
+ * with imperfect tasks. Only structural failures (caught by Zod) block.
+ *
+ * Previously this file re-exported from @sanity/ailf-tasks. That package
+ * has been eliminated — all validation logic now lives here.
+ */
+import { CURATED_ASSERTION_TYPES, RUBRIC_TEMPLATE_NAMES, } from "./repo-schemas.js";
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Run semantic validation on an array of parsed canonical tasks.
+ *
+ * Returns warnings for issues that don't block execution (unknown feature
+ * areas, unresolved slugs) and errors for issues that would cause pipeline
+ * failures (completely missing required fields — though Zod catches most).
+ */
+export function validateCanonicalTasks(tasks) {
+    const errors = [];
+    const warnings = [];
+    // Check for duplicate IDs
+    const seenIds = new Set();
+    for (const task of tasks) {
+        if (seenIds.has(task.id)) {
+            errors.push({
+                taskId: task.id,
+                field: "id",
+                message: `Duplicate task ID "${task.id}"`,
+            });
+        }
+        seenIds.add(task.id);
+    }
+    for (const task of tasks) {
+        const assertions = task.assertions ?? [];
+        // Check assertion types
+        for (let i = 0; i < assertions.length; i++) {
+            const assertion = assertions[i];
+            if (!CURATED_ASSERTION_TYPES.includes(assertion.type)) {
+                warnings.push({
+                    taskId: task.id,
+                    field: `assertions[${i}].type`,
+                    message: `Unknown assertion type "${assertion.type}". ` +
+                        `Valid types: ${CURATED_ASSERTION_TYPES.join(", ")}`,
+                });
+            }
+            // Check rubric template for llm-rubric assertions
+            if (assertion.type === "llm-rubric" && "template" in assertion) {
+                const template = assertion.template;
+                if (!RUBRIC_TEMPLATE_NAMES.includes(template)) {
+                    warnings.push({
+                        taskId: task.id,
+                        field: `assertions[${i}].template`,
+                        message: `Unknown rubric template "${template}". ` +
+                            `Valid templates: ${RUBRIC_TEMPLATE_NAMES.join(", ")}`,
+                    });
+                }
+            }
+        }
+        // Check canonical doc refs look reasonable
+        const docs = task.context?.docs ?? [];
+        for (let i = 0; i < docs.length; i++) {
+            const doc = docs[i];
+            // Slug refs: warn if they look like URLs or paths
+            if ("slug" in doc && !("id" in doc) && typeof doc.slug === "string") {
+                if (doc.slug.includes("/") || doc.slug.includes("http")) {
+                    warnings.push({
+                        taskId: task.id,
+                        field: `context.docs[${i}].slug`,
+                        message: `Slug "${doc.slug}" looks like a URL or path — use 'path' type for paths or 'slug' for document slugs (e.g., "groq-introduction")`,
+                    });
+                }
+            }
+        }
+        // Check task has at least one llm-rubric assertion (recommended but not required)
+        const hasLlmRubric = assertions.some((a) => a.type === "llm-rubric");
+        if (!hasLlmRubric) {
+            warnings.push({
+                taskId: task.id,
+                field: "assertions",
+                message: "No llm-rubric assertion found. Tasks should have at least one scored rubric for meaningful evaluation.",
+            });
+        }
+        // Check prompt text exists
+        if (!task.prompt?.text) {
+            warnings.push({
+                taskId: task.id,
+                field: "prompt.text",
+                message: "No task prompt found in prompt.text. The LLM will receive an empty implementation request.",
+            });
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+/**
+ * Format validation results for console output.
  */
-export { detectSnakeCaseFields, formatValidationResult, validateRepoTasks, } from "../../_vendor/ailf-tasks/index.js";
+export function formatValidationResult(result) {
+    const lines = [];
+    if (result.errors.length > 0) {
+        lines.push("Errors:");
+        for (const e of result.errors) {
+            lines.push(`  [${e.taskId}] ${e.field}: ${e.message}`);
+        }
+    }
+    if (result.warnings.length > 0) {
+        lines.push("Warnings:");
+        for (const w of result.warnings) {
+            lines.push(`  [${w.taskId}] ${w.field}: ${w.message}`);
+        }
+    }
+    if (result.valid && result.warnings.length === 0) {
+        lines.push("All tasks pass validation");
+    }
+    return lines.join("\n");
+}

package/dist/adapters/task-sources/task-file-loader.d.ts

@@ -3,8 +3,8 @@
  *
  * Supplements the existing YAML-based task loading by supporting
  * `*.task.ts` and `*.task.js` files in task directories. Files are
- * loaded via jiti and validated through the RepoTaskSchema from
- * @sanity/ailf-tasks.
+ * loaded via jiti and expected to export GeneralizedTaskDefinition
+ * objects authored with `defineTask()`.
  *
  * TS task files export a single task or an array of tasks:
  *

package/dist/adapters/task-sources/task-file-loader.js

@@ -3,8 +3,8 @@
  *
  * Supplements the existing YAML-based task loading by supporting
  * `*.task.ts` and `*.task.js` files in task directories. Files are
- * loaded via jiti and validated through the RepoTaskSchema from
- * @sanity/ailf-tasks.
+ * loaded via jiti and expected to export GeneralizedTaskDefinition
+ * objects authored with `defineTask()`.
  *
  * TS task files export a single task or an array of tasks:
  *

package/dist/commands/coverage-audit.js

@@ -8,6 +8,7 @@ import { Command } from "commander";
 import { dirname, resolve } from "path";
 import { fileURLToPath } from "url";
 import { countReferencedDocs, formatCoverageConsole, formatCoverageMarkdown, runCoverageAudit, } from "../pipeline/coverage-audit.js";
+import { createLiteracyModeBase } from "../pipeline/compiler/mode-bases/index.js";
 import { createSanityLiteracyPreset } from "../pipeline/compiler/presets/index.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const ROOT = resolve(__dirname, "..", "..");
@@ -17,9 +18,10 @@ export function createCoverageAuditCommand() {
         .option("--format <fmt>", "Output format: table, md, markdown")
         .option("--json", "Output raw JSON", false)
         .action(async (opts) => {
-        // Build a registry with preset features so coverage audit works
+        // Build a registry with mode base + preset so coverage audit works
         // even when config/features.ts is empty (preset is source of truth).
         const registry = new InMemoryPluginRegistry();
+        registry.registerModeBase(createLiteracyModeBase());
         registry.registerPreset(createSanityLiteracyPreset({ rootDir: ROOT }));
         const report = runCoverageAudit(ROOT, { registry });
         if (!report) {

package/dist/commands/init.d.ts

@@ -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

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