@sanity/ailf 1.0.0 → 2.0.1

package/dist/pipeline/compiler/__tests__/promptfoo-compiler.test.js

@@ -9,7 +9,6 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 import { tmpdir } from "os";
-import { LiteracyVariant } from "../../normalize-mode.js";
 import { compileToPromptfoo } from "../promptfoo-compiler.js";
 // ---------------------------------------------------------------------------
 // Helpers
@@ -123,8 +122,8 @@ describe("compileToPromptfoo", () => {
         const result = compileToPromptfoo(graph, {
             mode: "literacy",
             models: makeModels([
-                { id: "model-a", label: "A", modes: [LiteracyVariant.STANDARD] },
-                { id: "model-b", label: "B", modes: ["agentic-naive"] },
+                { id: "model-a", label: "A", modes: ["literacy"] },
+                { id: "model-b", label: "B", modes: ["mcp-server"] },
             ]),
             rootDir: tmpdir(),
         });

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/__tests__/task-bridge.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * task-bridge.test.ts — Unit tests for the TaskDefinition ↔ LiteracyTaskDefinition bridge.
+ *
+ * Covers round-trip fidelity, edge cases (missing optionals, all optionals),
+ * assertion type mapping, and all four CanonicalDocRef / GeneralizedDocRef variants.
+ *
+ * Run: npx tsx --test src/pipeline/compiler/__tests__/task-bridge.test.ts
+ */
+export {};

package/dist/pipeline/compiler/__tests__/task-bridge.test.js

@@ -0,0 +1,339 @@
+/**
+ * task-bridge.test.ts — Unit tests for the TaskDefinition ↔ LiteracyTaskDefinition bridge.
+ *
+ * Covers round-trip fidelity, edge cases (missing optionals, all optionals),
+ * assertion type mapping, and all four CanonicalDocRef / GeneralizedDocRef variants.
+ *
+ * Run: npx tsx --test src/pipeline/compiler/__tests__/task-bridge.test.ts
+ */
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { toGeneralized, toLiteracyTask } from "../task-bridge.js";
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+/** Minimal old-style task — only required fields, no optionals */
+const minimalOldTask = {
+    id: "groq-filter-basic",
+    description: "Filter documents with GROQ",
+    featureArea: "groq",
+    taskPrompt: "Write a GROQ query that filters by _type",
+    canonicalDocs: [],
+    referenceSolution: "solutions/groq-filter-basic.ts",
+    docCoverage: false,
+    assertions: [],
+};
+/** Fully-populated old-style task — every optional filled */
+const fullOldTask = {
+    id: "mutations-create-advanced",
+    description: "Create documents with mutations API",
+    featureArea: "mutations",
+    taskPrompt: "Use the mutations API to create a document with references",
+    canonicalDocs: [
+        { slug: "mutations-overview", reason: "Primary mutations guide" },
+        { path: "/docs/mutations/create", reason: "Create-specific docs" },
+        {
+            id: "doc-123",
+            reason: "Imported draft",
+            slug: "draft-slug",
+            path: "/docs/draft",
+        },
+        { perspective: "release-v3", reason: "V3 release content" },
+    ],
+    referenceSolution: "solutions/mutations-create-advanced.ts",
+    docCoverage: true,
+    assertions: [
+        {
+            type: "llm-rubric",
+            template: "code-quality",
+            criteria: ["correct", "idiomatic"],
+            weight: 2,
+        },
+        { type: "contains", value: "createIfNotExists" },
+        { type: "javascript", value: "output.includes('mutation')", weight: 1 },
+    ],
+    baseline: { enabled: true, rubric: "full" },
+    tags: ["mutations", "advanced", "references"],
+    status: "active",
+    extraVars: { customHint: "Use createIfNotExists", maxRetries: 3 },
+};
+/** Minimal new-style literacy task — only required/mode fields */
+const minimalNewTask = {
+    mode: "literacy",
+    id: "studio-config-basic",
+    title: "Configure a Sanity Studio",
+};
+/** Fully-populated new-style literacy task (only fields that round-trip through old type) */
+const fullNewTask = {
+    mode: "literacy",
+    id: "groq-projection-advanced",
+    title: "Advanced GROQ projections",
+    area: "groq",
+    tags: ["groq", "projections"],
+    status: "active",
+    assertions: [
+        {
+            type: "llm-rubric",
+            template: "completeness",
+            criteria: ["covers edge cases"],
+            weight: 3,
+        },
+        { type: "contains", value: "coalesce" },
+    ],
+    prompt: {
+        text: "Write a GROQ query using projections with coalesce",
+        vars: { difficulty: "advanced", topic: "projections" },
+    },
+    context: {
+        docs: [
+            { slug: "groq-projections", reason: "Projection docs" },
+            { path: "/docs/groq/projections", reason: "Path-based ref" },
+            { id: "groq-doc-456", reason: "By ID" },
+            { perspective: "release-groq-v2", reason: "GROQ v2 release" },
+        ],
+    },
+    referenceSolution: "solutions/groq-projection-advanced.ts",
+    docCoverage: true,
+    baseline: { enabled: false, rubric: "abbreviated" },
+};
+// ---------------------------------------------------------------------------
+// toGeneralized — old TaskDefinition → LiteracyTaskDefinition
+// ---------------------------------------------------------------------------
+describe("toGeneralized", () => {
+    it("converts a minimal old task to a LiteracyTaskDefinition", () => {
+        const result = toGeneralized(minimalOldTask);
+        assert.equal(result.mode, "literacy");
+        assert.equal(result.id, "groq-filter-basic");
+        assert.equal(result.title, "Filter documents with GROQ");
+        assert.equal(result.area, "groq");
+        assert.equal(result.referenceSolution, "solutions/groq-filter-basic.ts");
+        assert.equal(result.docCoverage, false);
+        assert.deepEqual(result.assertions, []);
+        assert.deepEqual(result.context?.docs, []);
+        assert.equal(result.prompt?.text, "Write a GROQ query that filters by _type");
+    });
+    it("converts a fully-populated old task preserving all fields", () => {
+        const result = toGeneralized(fullOldTask);
+        assert.equal(result.mode, "literacy");
+        assert.equal(result.id, "mutations-create-advanced");
+        assert.equal(result.title, "Create documents with mutations API");
+        assert.equal(result.area, "mutations");
+        assert.equal(result.referenceSolution, "solutions/mutations-create-advanced.ts");
+        assert.equal(result.docCoverage, true);
+        assert.deepEqual(result.baseline, { enabled: true, rubric: "full" });
+        assert.deepEqual(result.tags, ["mutations", "advanced", "references"]);
+        assert.equal(result.status, "active");
+        assert.deepEqual(result.prompt?.vars, {
+            customHint: "Use createIfNotExists",
+            maxRetries: 3,
+        });
+        assert.equal(result.prompt?.text, "Use the mutations API to create a document with references");
+    });
+    it("does not set optional fields when absent in old task", () => {
+        const result = toGeneralized(minimalOldTask);
+        assert.equal(result.baseline, undefined);
+        assert.equal(result.tags, undefined);
+        assert.equal(result.status, undefined);
+        assert.equal(result.prompt?.vars, undefined);
+    });
+});
+// ---------------------------------------------------------------------------
+// toLiteracyTask — LiteracyTaskDefinition → old TaskDefinition
+// ---------------------------------------------------------------------------
+describe("toLiteracyTask", () => {
+    it("converts a minimal new task to a TaskDefinition", () => {
+        const result = toLiteracyTask(minimalNewTask);
+        assert.equal(result.id, "studio-config-basic");
+        assert.equal(result.description, "Configure a Sanity Studio");
+        assert.equal(result.featureArea, "");
+        assert.equal(result.taskPrompt, "");
+        assert.deepEqual(result.canonicalDocs, []);
+        assert.equal(result.referenceSolution, "");
+        assert.equal(result.docCoverage, false);
+        assert.deepEqual(result.assertions, []);
+    });
+    it("converts a fully-populated new task preserving all mappable fields", () => {
+        const result = toLiteracyTask(fullNewTask);
+        assert.equal(result.id, "groq-projection-advanced");
+        assert.equal(result.description, "Advanced GROQ projections");
+        assert.equal(result.featureArea, "groq");
+        assert.equal(result.taskPrompt, "Write a GROQ query using projections with coalesce");
+        assert.equal(result.referenceSolution, "solutions/groq-projection-advanced.ts");
+        assert.equal(result.docCoverage, true);
+        assert.deepEqual(result.baseline, { enabled: false, rubric: "abbreviated" });
+        assert.deepEqual(result.tags, ["groq", "projections"]);
+        assert.equal(result.status, "active");
+        assert.deepEqual(result.extraVars, {
+            difficulty: "advanced",
+            topic: "projections",
+        });
+    });
+    it("uses prompt.template as fallback when prompt.text is absent", () => {
+        const task = {
+            mode: "literacy",
+            id: "template-task",
+            title: "Template-based task",
+            prompt: { template: "my-named-template" },
+        };
+        const result = toLiteracyTask(task);
+        assert.equal(result.taskPrompt, "my-named-template");
+    });
+    it("does not set optional fields when absent in new task", () => {
+        const result = toLiteracyTask(minimalNewTask);
+        assert.equal(result.baseline, undefined);
+        assert.equal(result.tags, undefined);
+        assert.equal(result.status, undefined);
+        assert.equal(result.extraVars, undefined);
+    });
+});
+// ---------------------------------------------------------------------------
+// Round-trip: old → new → old (must be lossless)
+// ---------------------------------------------------------------------------
+describe("round-trip: toLiteracyTask(toGeneralized(oldTask))", () => {
+    it("preserves all fields of a minimal old task", () => {
+        const roundTripped = toLiteracyTask(toGeneralized(minimalOldTask));
+        assert.deepEqual(roundTripped, minimalOldTask);
+    });
+    it("preserves all fields of a fully-populated old task", () => {
+        const roundTripped = toLiteracyTask(toGeneralized(fullOldTask));
+        assert.deepEqual(roundTripped, fullOldTask);
+    });
+});
+// ---------------------------------------------------------------------------
+// Round-trip: new → old → new (lossless for mappable fields)
+// ---------------------------------------------------------------------------
+describe("round-trip: toGeneralized(toLiteracyTask(newTask))", () => {
+    it("preserves all fields of a minimal new task", () => {
+        const roundTripped = toGeneralized(toLiteracyTask(minimalNewTask));
+        assert.equal(roundTripped.mode, "literacy");
+        assert.equal(roundTripped.id, minimalNewTask.id);
+        assert.equal(roundTripped.title, minimalNewTask.title);
+    });
+    it("preserves all mappable fields of a fully-populated new task", () => {
+        const roundTripped = toGeneralized(toLiteracyTask(fullNewTask));
+        assert.equal(roundTripped.mode, "literacy");
+        assert.equal(roundTripped.id, fullNewTask.id);
+        assert.equal(roundTripped.title, fullNewTask.title);
+        assert.equal(roundTripped.area, fullNewTask.area);
+        assert.deepEqual(roundTripped.tags, fullNewTask.tags);
+        assert.equal(roundTripped.status, fullNewTask.status);
+        assert.deepEqual(roundTripped.assertions, fullNewTask.assertions);
+        assert.equal(roundTripped.prompt?.text, fullNewTask.prompt?.text);
+        assert.deepEqual(roundTripped.prompt?.vars, fullNewTask.prompt?.vars);
+        assert.deepEqual(roundTripped.context?.docs, fullNewTask.context?.docs);
+        assert.equal(roundTripped.referenceSolution, fullNewTask.referenceSolution);
+        assert.equal(roundTripped.docCoverage, fullNewTask.docCoverage);
+        assert.deepEqual(roundTripped.baseline, fullNewTask.baseline);
+    });
+});
+// ---------------------------------------------------------------------------
+// CanonicalDocRef ↔ GeneralizedDocRef mapping (all 4 variants)
+// ---------------------------------------------------------------------------
+describe("doc ref mapping", () => {
+    const slugRef = {
+        slug: "my-article",
+        reason: "testing slug",
+    };
+    const pathRef = {
+        path: "/docs/my-article",
+        reason: "testing path",
+    };
+    const idRef = {
+        id: "abc-123",
+        reason: "testing id",
+        slug: "annotated-slug",
+        path: "/docs/annotated",
+    };
+    const perspectiveRef = {
+        perspective: "release-v4",
+        reason: "testing perspective",
+    };
+    it("preserves slug ref through round-trip", () => {
+        const task = { ...minimalOldTask, canonicalDocs: [slugRef] };
+        const roundTripped = toLiteracyTask(toGeneralized(task));
+        assert.deepEqual(roundTripped.canonicalDocs, [slugRef]);
+    });
+    it("preserves path ref through round-trip", () => {
+        const task = { ...minimalOldTask, canonicalDocs: [pathRef] };
+        const roundTripped = toLiteracyTask(toGeneralized(task));
+        assert.deepEqual(roundTripped.canonicalDocs, [pathRef]);
+    });
+    it("preserves id ref (with optional slug/path annotations) through round-trip", () => {
+        const task = { ...minimalOldTask, canonicalDocs: [idRef] };
+        const roundTripped = toLiteracyTask(toGeneralized(task));
+        assert.deepEqual(roundTripped.canonicalDocs, [idRef]);
+    });
+    it("preserves perspective ref through round-trip", () => {
+        const task = {
+            ...minimalOldTask,
+            canonicalDocs: [perspectiveRef],
+        };
+        const roundTripped = toLiteracyTask(toGeneralized(task));
+        assert.deepEqual(roundTripped.canonicalDocs, [perspectiveRef]);
+    });
+    it("preserves all 4 ref variants together through round-trip", () => {
+        const allRefs = [slugRef, pathRef, idRef, perspectiveRef];
+        const task = { ...minimalOldTask, canonicalDocs: allRefs };
+        const roundTripped = toLiteracyTask(toGeneralized(task));
+        assert.deepEqual(roundTripped.canonicalDocs, allRefs);
+    });
+});
+// ---------------------------------------------------------------------------
+// Assertion type mapping
+// ---------------------------------------------------------------------------
+describe("assertion type mapping", () => {
+    const templatedAssertion = {
+        type: "llm-rubric",
+        template: "code-quality",
+        criteria: ["correct", "idiomatic", "secure"],
+        weight: 2,
+    };
+    const valueAssertion = {
+        type: "contains",
+        value: "createDocument",
+    };
+    const jsAssertion = {
+        type: "javascript",
+        value: "output.includes('done')",
+        weight: 1,
+    };
+    it("preserves templated assertions through old→new→old round-trip", () => {
+        const task = {
+            ...minimalOldTask,
+            assertions: [templatedAssertion],
+        };
+        const roundTripped = toLiteracyTask(toGeneralized(task));
+        assert.deepEqual(roundTripped.assertions, [templatedAssertion]);
+    });
+    it("preserves value assertions through old→new→old round-trip", () => {
+        const task = {
+            ...minimalOldTask,
+            assertions: [valueAssertion],
+        };
+        const roundTripped = toLiteracyTask(toGeneralized(task));
+        assert.deepEqual(roundTripped.assertions, [valueAssertion]);
+    });
+    it("preserves mixed assertion types through old→new→old round-trip", () => {
+        const mixed = [templatedAssertion, valueAssertion, jsAssertion];
+        const task = { ...minimalOldTask, assertions: mixed };
+        const roundTripped = toLiteracyTask(toGeneralized(task));
+        assert.deepEqual(roundTripped.assertions, mixed);
+    });
+    it("preserves assertions through new→old→new round-trip", () => {
+        const genAssertions = [
+            {
+                type: "llm-rubric",
+                template: "completeness",
+                criteria: ["thorough"],
+                weight: 1,
+            },
+            { type: "regex", value: "^import.*sanity" },
+        ];
+        const task = {
+            ...minimalNewTask,
+            assertions: genAssertions,
+        };
+        const roundTripped = toGeneralized(toLiteracyTask(task));
+        assert.deepEqual(roundTripped.assertions, genAssertions);
+    });
+});

package/dist/pipeline/compiler/__tests__/tool-loop-openai.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * tool-loop-openai.test.ts — Tests for the OpenAI MCP tool loop.
+ *
+ * Tests both API variants (Chat Completions and Responses) with mocked
+ * fetch to verify tool calling, error handling, token tracking, and
+ * round exhaustion.
+ *
+ * Run: npx tsx --test src/pipeline/compiler/__tests__/tool-loop-openai.test.ts
+ */
+export {};