@sanity/ailf 1.0.0 → 2.0.0

package/dist/pipeline/compiler/__tests__/mcp-server-handler.test.js

@@ -10,8 +10,7 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 import { LiteracyVariant } from "../../normalize-mode.js";
-import { compileMCPTask, handler as mcpHandler, MCP_PROMPT_TEMPLATES, validateMCPTask, } from "../mode-handlers/mcp-server-handler.js";
-import { buildMCPAssertions } from "../mode-handlers/mcp-assertions.js";
+import { buildMCPAssertions, compileMCPTask, handler as mcpHandler, MCP_PROMPT_TEMPLATES, validateMCPTask, } from "../mode-handlers/mcp-server/index.js";
 import { allMCPExampleTasks, createAndPublishTask, inspectSchemaTask, queryDocumentsTask, semanticSearchTask, stdioServerTask, } from "../mode-handlers/__fixtures__/mcp-example-tasks.js";
 // ---------------------------------------------------------------------------
 // Helpers
@@ -26,6 +25,29 @@ function makeMinimalMCPTask(overrides) {
         ...overrides,
     };
 }
+/** Test models for compilation — simulates models from the registry */
+const TEST_MODELS = [
+    {
+        id: "anthropic:messages:claude-opus-4-6",
+        label: "Claude Opus 4.6",
+        config: { temperature: 0.2 },
+    },
+    {
+        id: "openai:responses:gpt-5.4",
+        label: "GPT 5.4",
+        config: { reasoning_effort: "medium" },
+    },
+];
+/** The custom MCP provider file:// path */
+const MCP_PROVIDER_PATH = "file://dist/pipeline/compiler/mode-handlers/mcp-tool-provider/index.js";
+/** Helper to get provider config */
+function cfg(provider) {
+    return provider.config;
+}
+/** Helper to get mcpServer sub-config from provider */
+function serverCfg(provider) {
+    return cfg(provider)?.mcpServer;
+}
 // ---------------------------------------------------------------------------
 // handler.getPrompts() — prompt template ownership
 // ---------------------------------------------------------------------------
@@ -38,11 +60,9 @@ describe("MCPServerHandler.getPrompts", () => {
     it("returns templates keyed by MCP-specific IDs (not literacy names)", () => {
         const prompts = mcpHandler.getPrompts();
         const keys = Object.keys(prompts);
-        // Must not use literacy template names
         assert.ok(!keys.includes("with-docs"), "should not use literacy key 'with-docs'");
         assert.ok(!keys.includes("without-docs"), "should not use literacy key 'without-docs'");
         assert.ok(!keys.includes(LiteracyVariant.AGENTIC), "should not use literacy key 'agentic'");
-        // Must have MCP-appropriate key(s)
         assert.ok(keys.includes("mcp-server"), "should include 'mcp-server' template");
     });
     it("mcp-server template instructs model to use MCP tools", () => {
@@ -50,7 +70,6 @@ describe("MCPServerHandler.getPrompts", () => {
         const template = prompts["mcp-server"];
         assert.ok(template, "mcp-server template should exist");
         assert.ok(template.template.includes("{{task}}"), "should include {{task}} placeholder");
-        // Should reference MCP tools / tool usage
         assert.ok(/tool/i.test(template.template), "template should mention tools (MCP-appropriate content)");
     });
     it("template has correct PromptTemplate shape", () => {
@@ -121,70 +140,91 @@ describe("validateMCPTask", () => {
     });
 });
 // ---------------------------------------------------------------------------
-// compileMCPTask
+// compileMCPTask — provider assembly
 // ---------------------------------------------------------------------------
 describe("compileMCPTask", () => {
     it("produces provider, tests, and prompts", () => {
-        const result = compileMCPTask(makeMinimalMCPTask());
+        const result = compileMCPTask(makeMinimalMCPTask(), { models: TEST_MODELS });
         assert.ok(result.providers.length > 0, "Should produce providers");
         assert.ok(result.tests.length > 0, "Should produce test cases");
         assert.ok(result.prompts.length > 0, "Should produce prompts");
     });
-    it("builds Promptfoo-native MCP provider for stdio", () => {
+    it("emits file:// providers using the custom MCP tool provider", () => {
         const result = compileMCPTask(makeMinimalMCPTask({
             serverConfig: {
                 transport: "stdio",
                 command: "node dist/server.js --flag",
             },
-        }));
-        assert.equal(result.providers.length, 1);
-        assert.equal(result.providers[0].id, "mcp");
-        const config = result.providers[0].config;
-        assert.equal(config.enabled, true);
-        const server = config.server;
-        assert.equal(server.command, "node");
-        assert.deepEqual(server.args, ["dist/server.js", "--flag"]);
-    });
-    it("builds Promptfoo-native MCP provider for URL-based transport", () => {
+        }), { models: TEST_MODELS });
+        assert.equal(result.providers.length, 2, "One provider per model");
+        // All providers use the custom MCP tool provider path
+        assert.equal(result.providers[0].id, MCP_PROVIDER_PATH);
+        assert.equal(result.providers[1].id, MCP_PROVIDER_PATH);
+        // Model ID is passed in config
+        assert.equal(cfg(result.providers[0]).model, "anthropic:messages:claude-opus-4-6");
+        assert.equal(cfg(result.providers[1]).model, "openai:responses:gpt-5.4");
+        // MCP server config is in config.mcpServer
+        const server = serverCfg(result.providers[0]);
+        assert.equal(server.command, "node dist/server.js --flag");
+    });
+    it("preserves model config in provider config", () => {
         const result = compileMCPTask(makeMinimalMCPTask({
-            serverConfig: {
-                transport: "sse",
-                url: "http://localhost:3000/sse",
-            },
-        }));
-        assert.equal(result.providers[0].id, "mcp");
-        const config = result.providers[0].config;
-        const server = config.server;
+            serverConfig: { transport: "sse", url: "http://localhost:3000/sse" },
+        }), { models: TEST_MODELS });
+        const c = cfg(result.providers[0]);
+        assert.equal(c.temperature, 0.2, "Model config preserved");
+        assert.ok(c.mcpServer, "MCP server config present");
+        assert.equal(c.maxToolRounds, 5, "Default maxToolRounds");
+    });
+    it("builds MCP server config for URL-based transport", () => {
+        const result = compileMCPTask(makeMinimalMCPTask({
+            serverConfig: { transport: "sse", url: "http://localhost:3000/sse" },
+        }), { models: TEST_MODELS });
+        const server = serverCfg(result.providers[0]);
         assert.equal(server.url, "http://localhost:3000/sse");
     });
-    it("maps auth config to Promptfoo provider", () => {
+    it("maps auth config to mcpServer config", () => {
         const result = compileMCPTask(makeMinimalMCPTask({
             serverConfig: {
                 transport: "streamable-http",
                 url: "https://mcp.example.com",
-                auth: {
-                    type: "bearer",
-                    token: "{{env.MY_TOKEN}}",
-                },
+                auth: { type: "bearer", token: "{{env.MY_TOKEN}}" },
             },
-        }));
-        const config = result.providers[0].config;
-        const server = config.server;
-        assert.deepEqual(server.auth, {
-            type: "bearer",
-            token: "{{env.MY_TOKEN}}",
-        });
+        }), { models: TEST_MODELS });
+        const server = serverCfg(result.providers[0]);
+        assert.deepEqual(server.auth, { type: "bearer", token: "{{env.MY_TOKEN}}" });
     });
-    it("maps capabilities to Promptfoo tools filter", () => {
+    it("maps capabilities to mcpTools config", () => {
         const result = compileMCPTask(makeMinimalMCPTask({
             capabilities: ["query_documents", "get_schema"],
             serverConfig: {
                 transport: "streamable-http",
                 url: "https://mcp.example.com",
             },
-        }));
-        const config = result.providers[0].config;
-        assert.deepEqual(config.tools, ["query_documents", "get_schema"]);
+        }), { models: TEST_MODELS });
+        assert.deepEqual(cfg(result.providers[0]).mcpTools, [
+            "query_documents",
+            "get_schema",
+        ]);
+    });
+    it("uses task-level models override when specified", () => {
+        const result = compileMCPTask(makeMinimalMCPTask({
+            models: ["anthropic:messages:claude-sonnet-4-20250514"],
+            serverConfig: { transport: "sse", url: "http://localhost:3000" },
+        }), { models: TEST_MODELS });
+        assert.equal(result.providers.length, 1);
+        assert.equal(cfg(result.providers[0]).model, "anthropic:messages:claude-sonnet-4-20250514");
+    });
+    it("respects task-level maxToolRounds", () => {
+        const result = compileMCPTask(makeMinimalMCPTask({ maxToolRounds: 10 }), {
+            models: TEST_MODELS,
+        });
+        assert.equal(cfg(result.providers[0]).maxToolRounds, 10);
+    });
+    it("falls back to default model when no models provided", () => {
+        const result = compileMCPTask(makeMinimalMCPTask());
+        assert.ok(result.providers.length > 0, "Should have a fallback provider");
+        assert.ok(result.warnings.some((w) => w.includes("no models")));
     });
     it("uses task description as prompt text", () => {
         const result = compileMCPTask(makeMinimalMCPTask({
@@ -217,7 +257,6 @@ describe("compileMCPTask", () => {
                 ],
             },
         }));
-        // Primary + multi-turn test cases
         assert.equal(result.tests.length, 2);
         assert.ok(result.tests[1].description.includes("[multi-turn]"));
     });
@@ -293,63 +332,61 @@ describe("buildMCPAssertions", () => {
 // Example task compilation (end-to-end)
 // ---------------------------------------------------------------------------
 describe("example MCP tasks — end-to-end compilation", () => {
+    const opts = { models: TEST_MODELS };
     it("compiles all example tasks without errors", () => {
         for (const task of allMCPExampleTasks) {
-            const result = compileMCPTask(task);
+            const result = compileMCPTask(task, opts);
             assert.ok(result.providers.length > 0, `${task.id}: should produce providers`);
             assert.ok(result.tests.length > 0, `${task.id}: should produce test cases`);
             assert.ok(result.prompts.length > 0, `${task.id}: should produce prompts`);
         }
     });
     it("query task has tool-called + contains + llm-rubric assertions", () => {
-        const result = compileMCPTask(queryDocumentsTask);
+        const result = compileMCPTask(queryDocumentsTask, opts);
         const asserts = result.tests[0].assert;
-        // tool-called (→ javascript), contains × 2, llm-rubric
         assert.equal(asserts.length, 4);
-        assert.equal(asserts[0].type, "javascript"); // tool-called → javascript
+        assert.equal(asserts[0].type, "javascript");
         assert.equal(asserts[1].type, "contains");
         assert.equal(asserts[2].type, "contains");
         assert.equal(asserts[3].type, "llm-rubric");
     });
     it("schema task uses get_schema tool", () => {
-        const result = compileMCPTask(inspectSchemaTask);
+        const result = compileMCPTask(inspectSchemaTask, opts);
         const asserts = result.tests[0].assert;
         assert.ok(asserts.some((a) => a.type === "javascript" && a.value.includes("get_schema")), "Should have tool-called assertion for get_schema");
     });
     it("create-publish task produces multi-turn test case", () => {
-        const result = compileMCPTask(createAndPublishTask);
-        // Primary + multi-turn
+        const result = compileMCPTask(createAndPublishTask, opts);
         assert.equal(result.tests.length, 2);
         assert.ok(result.tests[1].description?.includes("[multi-turn]"));
     });
-    it("stdio task has Promptfoo-native MCP provider with command", () => {
-        const result = compileMCPTask(stdioServerTask);
-        assert.equal(result.providers[0].id, "mcp");
-        const config = result.providers[0].config;
-        assert.equal(config.enabled, true);
-        const server = config.server;
-        assert.equal(server.command, "node");
-        assert.deepEqual(server.args, ["dist/sanity-mcp-server.js"]);
+    it("stdio task uses custom provider with command config", () => {
+        const result = compileMCPTask(stdioServerTask, opts);
+        assert.equal(result.providers[0].id, MCP_PROVIDER_PATH);
+        assert.equal(cfg(result.providers[0]).model, "anthropic:messages:claude-opus-4-6");
+        const server = serverCfg(result.providers[0]);
+        assert.equal(server.command, "node dist/sanity-mcp-server.js");
     });
     it("semantic search task has two tool-called + one llm-rubric assertion", () => {
-        const result = compileMCPTask(semanticSearchTask);
+        const result = compileMCPTask(semanticSearchTask, opts);
         const asserts = result.tests[0].assert;
-        // tool-called × 2 (→ javascript) + llm-rubric
         assert.equal(asserts.length, 3);
-        assert.equal(asserts[0].type, "javascript"); // tool-called → javascript
-        assert.ok(asserts[0].value.includes("list_embeddings_indices"), "Should have tool-called assertion for list_embeddings_indices");
-        assert.equal(asserts[1].type, "javascript"); // tool-called → javascript
-        assert.ok(asserts[1].value.includes("semantic_search"), "Should have tool-called assertion for semantic_search");
+        assert.equal(asserts[0].type, "javascript");
+        assert.ok(asserts[0].value.includes("list_embeddings_indices"));
+        assert.equal(asserts[1].type, "javascript");
+        assert.ok(asserts[1].value.includes("semantic_search"));
         assert.equal(asserts[2].type, "llm-rubric");
     });
     it("remote task has bearer auth and tools filter", () => {
-        const result = compileMCPTask(queryDocumentsTask);
-        const config = result.providers[0].config;
-        const server = config.server;
+        const result = compileMCPTask(queryDocumentsTask, opts);
+        const server = serverCfg(result.providers[0]);
         assert.deepEqual(server.auth, {
             type: "bearer",
             token: "{{env.SANITY_MCP_AUTH_TOKEN}}",
         });
-        assert.deepEqual(config.tools, ["query_documents", "get_schema"]);
+        assert.deepEqual(cfg(result.providers[0]).mcpTools, [
+            "query_documents",
+            "get_schema",
+        ]);
     });
 });

package/dist/pipeline/compiler/__tests__/scoring-and-presets.test.js

@@ -262,12 +262,14 @@ describe("InMemoryPluginRegistry", () => {
         });
         assert.equal(registry.getAssertions().length, 1);
     });
-    it("registers a complete preset", () => {
+    it("registers a complete preset with mode base", () => {
         const registry = new InMemoryPluginRegistry();
+        // Must register mode base first
+        const { createLiteracyModeBase } = require("../mode-bases/literacy.js");
+        registry.registerModeBase(createLiteracyModeBase());
         registry.registerPreset(sanityLiteracyPreset);
-        // Preset should register its modes, assertions, rubric templates
+        // Mode + rubrics from mode base, domain config from preset
         assert.ok(registry.getMode("literacy"));
-        assert.ok(registry.getAssertions().length > 0);
         assert.ok(registry.getRubricTemplates().length > 0);
         assert.ok(registry.getPresets().length === 1);
     });
@@ -280,83 +282,21 @@ describe("sanityLiteracyPreset", () => {
         assert.equal(sanityLiteracyPreset.name, "sanity-literacy");
         assert.equal(sanityLiteracyPreset.manifest.pluginApiVersion, 1);
     });
-    it("registers literacy mode", () => {
-        assert.equal(sanityLiteracyPreset.modes?.length, 1);
-        assert.equal(sanityLiteracyPreset.modes[0].id, "literacy");
-    });
-    it("includes core assertion types", () => {
-        const types = sanityLiteracyPreset.assertions.map((a) => a.type);
-        assert.ok(types.includes("contains"));
-        assert.ok(types.includes("llm-rubric"));
-        assert.ok(types.includes("javascript"));
-    });
-    it("includes 3 rubric templates", () => {
-        assert.equal(sanityLiteracyPreset.rubricTemplates?.length, 3);
-        const ids = sanityLiteracyPreset.rubricTemplates.map((t) => t.id);
-        assert.ok(ids.includes("task-completion"));
-        assert.ok(ids.includes("code-correctness"));
-        assert.ok(ids.includes("doc-coverage"));
-    });
-    it("rubric template scales match config/rubrics.ts authoritative source", () => {
-        const templates = sanityLiteracyPreset.rubricTemplates;
-        const tc = templates.find((t) => t.id === "task-completion");
-        assert.deepEqual(tc.scale, [
-            "0: Couldn't attempt — missing critical information",
-            "20: Attempted but fundamentally wrong approach",
-            "50: Partial implementation — major functional gaps",
-            "80: Mostly complete — minor issues or missing edge cases",
-            "100: Fully functional code — works as expected",
-        ]);
-        assert.equal(tc.criteriaLabel, "Must demonstrate:");
-        const cc = templates.find((t) => t.id === "code-correctness");
-        assert.deepEqual(cc.scale, [
-            "0: Broken code, syntax errors, or deprecated APIs",
-            "30: Works but uses anti-patterns or inefficient approaches",
-            "50: Works but not idiomatic",
-            "80: Follows most best practices",
-            "100: Follows all best practices, idiomatic implementation",
-        ]);
-        assert.equal(cc.criteriaLabel, "Check for:");
-        const dc = templates.find((t) => t.id === "doc-coverage");
-        assert.deepEqual(dc.scale, [
-            "0: Had to hallucinate/guess most implementation details",
-            "30: Significant gaps — filled with assumptions",
-            "50: Some gaps — inferred from partial information",
-            "80: Minor gaps — almost everything was documented",
-            "100: Complete coverage — all necessary info was in docs",
-        ]);
+    it("targets literacy mode base", () => {
+        assert.equal(sanityLiteracyPreset.mode, "literacy");
+    });
+    it("does not bundle assertions (now framework built-ins)", () => {
+        assert.equal(sanityLiteracyPreset.assertions, undefined);
+    });
+    it("does not bundle rubrics/scoring/prompts (now in literacy mode base)", () => {
+        // Evaluation methodology moved to mode-bases/literacy.ts
+        assert.equal(sanityLiteracyPreset.rubricTemplates, undefined);
+        assert.equal(sanityLiteracyPreset.scoringProfiles, undefined);
+        assert.equal(sanityLiteracyPreset.promptTemplates, undefined);
     });
     it("includes sanity:// fixture resolver", () => {
         assert.ok(sanityLiteracyPreset.fixtureResolvers?.some((r) => r.scheme === "sanity://"));
     });
-    it("includes 3 prompt templates", () => {
-        const templates = sanityLiteracyPreset.promptTemplates;
-        assert.ok(templates);
-        assert.ok(templates["with-docs"]);
-        assert.ok(templates["without-docs"]);
-        assert.ok(templates["agentic"]);
-        assert.equal(Object.keys(templates).length, 3);
-    });
-    it("prompt template content matches literacy handler", () => {
-        const templates = sanityLiteracyPreset.promptTemplates;
-        assert.ok(templates["with-docs"].template.includes("{{docs}}"));
-        assert.ok(templates["with-docs"].template.includes("{{task}}"));
-        assert.ok(templates["without-docs"].template.includes("{{task}}"));
-        assert.ok(templates["agentic"].template.includes("{{task}}"));
-    });
-    it("includes default and output-only scoring profiles", () => {
-        const profiles = sanityLiteracyPreset.scoringProfiles;
-        assert.ok(profiles);
-        assert.deepEqual(profiles["default"], {
-            "task-completion": 0.5,
-            "code-correctness": 0.25,
-            "doc-coverage": 0.25,
-        });
-        assert.deepEqual(profiles["output-only"], {
-            "task-completion": 0.6,
-            "code-correctness": 0.4,
-        });
-    });
     it("includes 3 source definitions", () => {
         const sources = sanityLiteracyPreset.sourceDefs;
         assert.ok(sources);
@@ -376,26 +316,13 @@ describe("sanityLiteracyPreset", () => {
         assert.ok(features);
         assert.equal(features.features.length, 14);
         const ids = features.features.map((f) => f.id);
-        // Covered features
         assert.ok(ids.includes("groq"));
         assert.ok(ids.includes("visual-editing"));
-        assert.ok(ids.includes("nextjs-live"));
-        assert.ok(ids.includes("functions"));
-        assert.ok(ids.includes("studio-setup"));
-        assert.ok(ids.includes("frameworks"));
-        // Uncovered features
         assert.ok(ids.includes("portable-text"));
-        assert.ok(ids.includes("image-assets"));
-        assert.ok(ids.includes("mutations"));
-        assert.ok(ids.includes("schemas"));
-        assert.ok(ids.includes("authentication"));
-        assert.ok(ids.includes("webhooks"));
-        assert.ok(ids.includes("realtime"));
         assert.ok(ids.includes("ai-assist"));
     });
     it("includes a docFetcher factory", () => {
         assert.equal(typeof sanityLiteracyPreset.docFetcher, "function");
-        // The factory should return a SanityDocFetcher instance
         const fetcher = sanityLiteracyPreset.docFetcher();
         assert.ok(fetcher);
         assert.equal(typeof fetcher.fetch, "function");
@@ -405,28 +332,34 @@ describe("sanityLiteracyPreset", () => {
 // createSanityLiteracyPreset factory
 // ---------------------------------------------------------------------------
 describe("createSanityLiteracyPreset", () => {
-    it("returns a preset with all extension points populated", () => {
+    it("returns a domain-only preset targeting literacy mode", () => {
         const preset = createSanityLiteracyPreset({ rootDir: "/tmp/test" });
         assert.equal(preset.name, "sanity-literacy");
-        assert.ok(preset.modes);
-        assert.ok(preset.assertions);
-        assert.ok(preset.rubricTemplates);
+        assert.equal(preset.mode, "literacy");
+        // Domain config present
         assert.ok(preset.fixtureResolvers);
-        assert.ok(preset.promptTemplates);
-        assert.ok(preset.scoringProfiles);
         assert.ok(preset.docFetcher);
         assert.ok(preset.sourceDefs);
         assert.ok(preset.featureDefs);
+        // Methodology inherited from mode base, not on preset
+        assert.equal(preset.rubricTemplates, undefined);
+        assert.equal(preset.scoringProfiles, undefined);
+        assert.equal(preset.promptTemplates, undefined);
     });
-    it("registers all extension points into the registry", () => {
+    it("registers all extension points via mode base + domain config", () => {
         const registry = new InMemoryPluginRegistry();
+        // Must register mode base first (composition root does this)
+        const { createLiteracyModeBase } = require("../mode-bases/literacy.js");
+        registry.registerModeBase(createLiteracyModeBase());
         const preset = createSanityLiteracyPreset({ rootDir: "/tmp/test" });
         registry.registerPreset(preset);
+        // Mode from mode base
         assert.ok(registry.getMode("literacy"));
-        assert.ok(registry.getAssertions().length > 0);
-        assert.ok(registry.getRubricTemplates().length === 3);
-        assert.ok(Object.keys(registry.getPromptTemplates()).length === 3);
-        assert.ok(Object.keys(registry.getScoringProfiles()).length === 2);
+        // Rubrics, scoring, prompts inherited from mode base
+        assert.equal(registry.getRubricTemplates().length, 3);
+        assert.equal(Object.keys(registry.getPromptTemplates()).length, 3);
+        assert.equal(Object.keys(registry.getScoringProfiles()).length, 2);
+        // Domain config from preset
         assert.ok(registry.getDocFetcherFactory());
         assert.equal(registry.getSourceDefs().length, 3);
         assert.ok(registry.getFeatureDefs());

package/dist/pipeline/compiler/literacy-bridge.d.ts

@@ -19,7 +19,7 @@
  * @see docs/exec-plans/architecture-overhaul/phase-7-migrate-literacy.md
  */
 import type { LiteracyTaskDefinition } from "../../_vendor/ailf-core/index.d.ts";
-import { type LiteracyCompileResult } from "./mode-handlers/literacy-handler.js";
+import { type LiteracyCompileResult } from "./mode-handlers/literacy/index.js";
 import { type LiteracyEvalSubMode } from "../normalize-mode.js";
 /** Options for compiling all literacy tasks via the new compiler */
 export interface LiteracyBridgeOptions {

package/dist/pipeline/compiler/literacy-bridge.js

@@ -18,7 +18,7 @@
  *
  * @see docs/exec-plans/architecture-overhaul/phase-7-migrate-literacy.md
  */
-import { compileLiteracyTask, } from "./mode-handlers/literacy-handler.js";
+import { compileLiteracyTask, } from "./mode-handlers/literacy/index.js";
 import { tryLoadConfigFile } from "./config-loader.js";
 import { buildTaskGraph } from "./task-graph-builder.js";
 // ---------------------------------------------------------------------------

package/dist/pipeline/compiler/mode-bases/agent-harness.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Agent Harness mode base — evaluation methodology for autonomous agent testing.
+ *
+ * Tests whether an autonomous agent can complete implementation tasks
+ * end-to-end, including tool use, file creation, and code generation.
+ *
+ * @see docs/MODES.md
+ */
+import type { ModeBase } from "../../../_vendor/ailf-core/index.d.ts";
+export declare function createAgentHarnessBase(): ModeBase;

package/dist/pipeline/compiler/mode-bases/agent-harness.js

@@ -0,0 +1,21 @@
+/**
+ * Agent Harness mode base — evaluation methodology for autonomous agent testing.
+ *
+ * Tests whether an autonomous agent can complete implementation tasks
+ * end-to-end, including tool use, file creation, and code generation.
+ *
+ * @see docs/MODES.md
+ */
+export function createAgentHarnessBase() {
+    return {
+        mode: {
+            id: "agent-harness",
+            label: "Agent Harness",
+            validProviderPatterns: ["^openai:", "^anthropic:", "^file://"],
+            rubricTemplateIds: [],
+            handlerModule: "./mode-handlers/agent-harness/index.js",
+        },
+        // Agent harness rubric templates and scoring profiles will be defined
+        // as the mode matures. The structural registration is in place.
+    };
+}

package/dist/pipeline/compiler/mode-bases/index.d.ts

@@ -0,0 +1,4 @@
+export { createAgentHarnessBase } from "./agent-harness.js";
+export { createKnowledgeProbeBase } from "./knowledge-probe.js";
+export { createLiteracyModeBase } from "./literacy.js";
+export { createMcpServerModeBase } from "./mcp-server.js";

package/dist/pipeline/compiler/mode-bases/index.js

@@ -0,0 +1,4 @@
+export { createAgentHarnessBase } from "./agent-harness.js";
+export { createKnowledgeProbeBase } from "./knowledge-probe.js";
+export { createLiteracyModeBase } from "./literacy.js";
+export { createMcpServerModeBase } from "./mcp-server.js";

package/dist/pipeline/compiler/mode-bases/knowledge-probe.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Knowledge Probe mode base — evaluation methodology for testing model knowledge.
+ *
+ * Tests what the model knows about a topic without providing documentation,
+ * establishing a baseline of model knowledge.
+ *
+ * @see docs/MODES.md
+ */
+import type { ModeBase } from "../../../_vendor/ailf-core/index.d.ts";
+export declare function createKnowledgeProbeBase(): ModeBase;

package/dist/pipeline/compiler/mode-bases/knowledge-probe.js

@@ -0,0 +1,22 @@
+/**
+ * Knowledge Probe mode base — evaluation methodology for testing model knowledge.
+ *
+ * Tests what the model knows about a topic without providing documentation,
+ * establishing a baseline of model knowledge.
+ *
+ * @see docs/MODES.md
+ */
+export function createKnowledgeProbeBase() {
+    return {
+        mode: {
+            id: "knowledge-probe",
+            label: "Knowledge Probe",
+            validProviderPatterns: ["^openai:", "^anthropic:", "^file://"],
+            rubricTemplateIds: [],
+            handlerModule: "./mode-handlers/knowledge-probe/index.js",
+        },
+        // Knowledge probe uses the same rubric dimensions as literacy
+        // but without doc-coverage (since no docs are provided).
+        // Rubric templates will be inherited or defined as the mode matures.
+    };
+}

package/dist/pipeline/compiler/mode-bases/literacy.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Literacy mode base — shared evaluation methodology for documentation literacy.
+ *
+ * Defines HOW literacy evaluations are scored (rubrics, weights, prompts),
+ * independently of WHAT documentation is being evaluated. Domain presets
+ * like `sanity-literacy` target this mode base and add their own sources,
+ * features, and doc fetcher.
+ *
+ * @see docs/MODES.md
+ */
+import type { ModeBase } from "../../../_vendor/ailf-core/index.d.ts";
+export declare function createLiteracyModeBase(): ModeBase;