@interleavelove/keating 0.1.0

package/dist/src/core/verification.js

@@ -0,0 +1,162 @@
+import { createHash } from "node:crypto";
+import { readFile, writeFile } from "node:fs/promises";
+import * as dotenv from "dotenv";
+import { piComplete, piCompleteJson } from "./pi-agent.js";
+dotenv.config();
+export function topicContentHash(topic) {
+    const payload = JSON.stringify({
+        slug: topic.slug,
+        summary: topic.summary,
+        formalCore: topic.formalCore,
+        misconceptions: topic.misconceptions,
+        examples: topic.examples
+    });
+    return createHash("sha256").update(payload).digest("hex").slice(0, 16);
+}
+export function extractClaims(topic) {
+    const claims = [];
+    claims.push(`Summary: ${topic.summary}`);
+    for (const statement of topic.formalCore) {
+        claims.push(`Formal claim: ${statement}`);
+    }
+    for (const misconception of topic.misconceptions) {
+        claims.push(`Misconception assertion: ${misconception}`);
+    }
+    for (const example of topic.examples) {
+        if (example.length > 20) {
+            claims.push(`Example claim: ${example}`);
+        }
+    }
+    return claims;
+}
+export function buildVerificationChecklist(topic, result) {
+    const claims = extractClaims(topic);
+    const lines = [
+        `# Verification Checklist: ${topic.title}`,
+        "",
+        `**Domain**: ${topic.domain}`,
+        `**Content hash**: ${topicContentHash(topic)}`,
+        `**Generated**: ${new Date().toISOString()}`,
+        `**Overall Confidence**: ${result ? (result.overallConfidence * 100).toFixed(1) : 0}%`,
+        "",
+        "## Instructions",
+        "",
+        "Before teaching this topic, verify each claim below. For each claim:",
+        "1. Search for an authoritative source (textbook, peer-reviewed paper, official documentation, legal text).",
+        "2. Mark the claim as CONFIRMED, UNCONFIRMED, or CORRECTED.",
+        "3. If corrected, write the accurate version.",
+        "4. Do NOT teach unverified claims as settled facts.",
+        "",
+        "## Claims to Verify",
+        ""
+    ];
+    for (let i = 0; i < claims.length; i++) {
+        const verified = result?.claims[i];
+        lines.push(`### Claim ${i + 1}`);
+        lines.push("");
+        lines.push(`> ${claims[i]}`);
+        lines.push("");
+        lines.push(`- [${verified?.status === "confirmed" ? "x" : " "}] **Status**: _${verified?.status?.toUpperCase() || "CONFIRMED / UNCONFIRMED / CORRECTED"}_`);
+        lines.push(`- **Source**: _${verified?.source || "[cite source here]"}_`);
+        lines.push(`- **Correction** (if any): _${verified?.correction || "[write corrected claim here]"}_`);
+        lines.push("");
+    }
+    lines.push("## Verification Summary");
+    lines.push("");
+    lines.push("- **Total claims**: " + claims.length);
+    lines.push(`- **Confirmed**: ${result?.claims.filter(c => c.status === "confirmed").length || 0}`);
+    lines.push(`- **Unconfirmed**: ${result?.claims.filter(c => c.status === "unconfirmed").length || 0}`);
+    lines.push(`- **Corrected**: ${result?.claims.filter(c => c.status === "corrected").length || 0}`);
+    lines.push(`- **Overall confidence**: ${result && result.overallConfidence > 0.8 ? "high" : result && result.overallConfidence > 0.5 ? "medium" : "low"}`);
+    lines.push("");
+    lines.push("---");
+    lines.push("*This checklist was auto-generated by Keating using Chain-of-Verification (CoVe) and cross-consistency checks. The teaching agent must complete it before presenting this material.*");
+    return lines.join("\n");
+}
+export async function loadVerificationCache(cachePath) {
+    try {
+        const raw = await readFile(cachePath, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+export async function saveVerificationCache(cachePath, cache) {
+    await writeFile(cachePath, JSON.stringify(cache, null, 2), "utf8");
+}
+export function verificationStatus(topic, cache) {
+    const cached = cache[topic.slug];
+    if (!cached)
+        return null;
+    if (cached.contentHash !== topicContentHash(topic))
+        return null;
+    return cached;
+}
+export function buildPendingVerificationResult(topic) {
+    const claims = extractClaims(topic);
+    return {
+        topic: topic.slug,
+        contentHash: topicContentHash(topic),
+        claims: claims.map((claim) => ({
+            claim,
+            status: "unconfirmed"
+        })),
+        overallConfidence: 0,
+        checkedAt: new Date().toISOString()
+    };
+}
+/**
+ * Automated Chain-of-Verification (CoVe) with Consistency Checking.
+ * Inspired by EdinburghNLP Hallucination Detection research.
+ * 1. Generates verification questions for each claim.
+ * 2. Answers those questions independently (the "Blackbox" cross-check).
+ * 3. Checks for consistency between independent answers and the claim.
+ */
+export async function runCoveVerification(cwd, topic) {
+    const claims = extractClaims(topic);
+    const verifiedClaims = [];
+    let totalConfidence = 0;
+    for (const claim of claims) {
+        // Phase 1: Question Generation
+        const qGenPrompt = `Given this claim, generate 3 specific, granular questions that would verify its factual accuracy.
+Claim: "${claim}"
+Questions (one per line):`;
+        const questionsText = await piComplete(cwd, qGenPrompt, { thinking: "low" });
+        const questions = questionsText.trim().split("\n").filter(q => q.trim());
+        // Phase 2: Independent Answering (the "Blackbox" cross-check)
+        const answers = [];
+        for (const q of questions) {
+            const a = await piComplete(cwd, `Answer this factual question accurately and concisely: ${q}`, { thinking: "medium" });
+            answers.push(a.trim());
+        }
+        // Phase 3: Consistency Analysis (Hallucination Detection)
+        const finalPrompt = `Original Claim: "${claim}"
+Supporting Research:
+${questions.map((q, i) => `Q: ${q}\nA: ${answers[i]}`).join("\n")}
+
+Is the original claim CONFIRMED, UNCONFIRMED, or CORRECTED based ONLY on the Supporting Research?
+Provide a JSON response:
+{
+  "status": "confirmed" | "unconfirmed" | "corrected",
+  "reasoning": "string",
+  "correction": "string | null",
+  "confidence": number (0 to 1)
+}`;
+        const data = await piCompleteJson(cwd, finalPrompt, { thinking: "high" });
+        verifiedClaims.push({
+            claim,
+            status: data.status,
+            source: data.reasoning,
+            correction: data.correction || undefined
+        });
+        totalConfidence += data.confidence;
+    }
+    return {
+        topic: topic.slug,
+        contentHash: topicContentHash(topic),
+        claims: verifiedClaims,
+        overallConfidence: totalConfidence / claims.length,
+        checkedAt: new Date().toISOString()
+    };
+}

package/dist/src/pi/hyperteacher-extension.js

@@ -0,0 +1,180 @@
+import { relative } from "node:path";
+import { animateTopicArtifact, benchPolicyArtifact, currentPolicySummary, ensureProjectScaffold, evolvePolicyArtifact, evolvePromptArtifact, improveArtifact, improveHistory, listArtifacts, mapTopicArtifact, planTopicArtifact, verifyTopicArtifact } from "../core/project.js";
+import { learnerStatePath } from "../core/paths.js";
+import { loadLearnerState, recordFeedback, saveLearnerState } from "../core/learner-state.js";
+function topicFromArgs(args) {
+    return (Array.isArray(args) ? args.join(" ") : String(args ?? "")).trim();
+}
+function info(ctx, message) {
+    ctx.ui.notify(message, "info");
+}
+export default function hyperteacher(pi) {
+    pi.registerCommand("plan", {
+        description: "Generate a deterministic lesson plan artifact for a topic.",
+        handler: async (args, ctx) => {
+            const topic = topicFromArgs(args);
+            if (!topic) {
+                info(ctx, "Usage: /plan <topic>");
+                return;
+            }
+            const artifact = await planTopicArtifact(ctx.cwd, topic);
+            ctx.ui.setEditorText(`read ${relative(ctx.cwd, artifact.planPath)}`);
+            info(ctx, `Wrote ${relative(ctx.cwd, artifact.planPath)}`);
+        }
+    });
+    pi.registerCommand("map", {
+        description: "Generate a Mermaid lesson map and render it with oxdraw when available.",
+        handler: async (args, ctx) => {
+            const topic = topicFromArgs(args);
+            if (!topic) {
+                info(ctx, "Usage: /map <topic>");
+                return;
+            }
+            const artifact = await mapTopicArtifact(ctx.cwd, topic);
+            const outputs = [relative(ctx.cwd, artifact.mmdPath)];
+            if (artifact.svgPath)
+                outputs.push(relative(ctx.cwd, artifact.svgPath));
+            ctx.ui.setEditorText(`read ${outputs[0]}`);
+            info(ctx, `Generated ${outputs.join(" and ")}`);
+        }
+    });
+    pi.registerCommand("animate", {
+        description: "Generate a manim-web animation bundle for a topic.",
+        handler: async (args, ctx) => {
+            const topic = topicFromArgs(args);
+            if (!topic) {
+                info(ctx, "Usage: /animate <topic>");
+                return;
+            }
+            const artifact = await animateTopicArtifact(ctx.cwd, topic);
+            ctx.ui.setEditorText(`read ${relative(ctx.cwd, artifact.storyboardPath)}`);
+            info(ctx, `Generated ${relative(ctx.cwd, artifact.playerPath)}, ${relative(ctx.cwd, artifact.scenePath)}, and ${relative(ctx.cwd, artifact.manifestPath)}`);
+        }
+    });
+    pi.registerCommand("bench", {
+        description: "Run the synthetic learner benchmark suite against the current teaching policy.",
+        handler: async (args, ctx) => {
+            const topic = topicFromArgs(args) || undefined;
+            const artifact = await benchPolicyArtifact(ctx.cwd, topic);
+            ctx.ui.setEditorText(`read ${relative(ctx.cwd, artifact.reportPath)}`);
+            info(ctx, `Benchmark score ${artifact.overallScore.toFixed(2)} saved to ${relative(ctx.cwd, artifact.reportPath)}${artifact.tracePath ? ` with trace ${relative(ctx.cwd, artifact.tracePath)}` : ""}`);
+        }
+    });
+    pi.registerCommand("evolve", {
+        description: "Mutate and benchmark teaching policies, then keep the strongest safe candidate.",
+        handler: async (args, ctx) => {
+            const topic = topicFromArgs(args) || undefined;
+            const artifact = await evolvePolicyArtifact(ctx.cwd, topic);
+            ctx.ui.setEditorText(`read ${relative(ctx.cwd, artifact.reportPath)}`);
+            info(ctx, `Policy evolved to ${artifact.bestScore.toFixed(2)} and saved to ${relative(ctx.cwd, artifact.policyPath)}${artifact.tracePath ? ` with trace ${relative(ctx.cwd, artifact.tracePath)}` : ""}`);
+        }
+    });
+    pi.registerCommand("prompt-evolve", {
+        description: "Evolve a prompt template using prompt-learning feedback and PROSPER-style selection.",
+        handler: async (args, ctx) => {
+            const promptName = topicFromArgs(args) || "learn";
+            const artifact = await evolvePromptArtifact(ctx.cwd, promptName);
+            ctx.ui.setEditorText(`read ${relative(ctx.cwd, artifact.reportPath)}`);
+            info(ctx, `Prompt ${promptName} evolved to ${artifact.bestScore.toFixed(2)} and saved to ${relative(ctx.cwd, artifact.evolvedPromptPath)}`);
+        }
+    });
+    pi.registerCommand("policy", {
+        description: "Show the active hyperteacher policy.",
+        handler: async (_args, ctx) => {
+            ctx.ui.setEditorText(await currentPolicySummary(ctx.cwd));
+            info(ctx, "Loaded current policy into the editor.");
+        }
+    });
+    pi.registerCommand("outputs", {
+        description: "Browse Keating plans, maps, benchmark reports, and evolution logs.",
+        handler: async (_args, ctx) => {
+            const artifacts = await listArtifacts(ctx.cwd);
+            if (artifacts.length === 0) {
+                info(ctx, "No artifacts yet. Use /plan, /map, /bench, or /evolve first.");
+                return;
+            }
+            const selected = await ctx.ui.select("Keating Outputs", artifacts.map((artifact) => artifact.label));
+            const artifact = artifacts.find((entry) => entry.label === selected);
+            if (artifact) {
+                ctx.ui.setEditorText(`read ${artifact.path}`);
+            }
+        }
+    });
+    pi.registerCommand("verify", {
+        description: "Generate a fact-checking checklist for a topic before teaching it.",
+        handler: async (args, ctx) => {
+            const topic = topicFromArgs(args);
+            if (!topic) {
+                info(ctx, "Usage: /verify <topic>");
+                return;
+            }
+            const result = await verifyTopicArtifact(ctx.cwd, topic);
+            if (result.alreadyVerified) {
+                info(ctx, `Already verified: ${relative(ctx.cwd, result.checklistPath)}`);
+            }
+            else {
+                ctx.ui.setEditorText(`read ${relative(ctx.cwd, result.checklistPath)}`);
+                info(ctx, `Verification checklist generated. Complete it before teaching this topic.`);
+            }
+        }
+    });
+    pi.registerCommand("feedback", {
+        description: "Record feedback on the current teaching session (up, down, confused).",
+        handler: async (args, ctx) => {
+            const raw = topicFromArgs(args).toLowerCase();
+            const parts = raw.split(/\s+/);
+            const signalMap = {
+                up: "thumbs-up",
+                down: "thumbs-down",
+                confused: "confused"
+            };
+            const signal = signalMap[parts[0]];
+            if (!signal) {
+                info(ctx, "Usage: /feedback <up|down|confused> [topic]");
+                return;
+            }
+            const topic = parts.slice(1).join(" ") || "general";
+            const statePath = learnerStatePath(ctx.cwd);
+            const state = await loadLearnerState(statePath);
+            recordFeedback(state, topic, signal);
+            await saveLearnerState(statePath, state);
+            info(ctx, `Recorded ${signal} feedback for "${topic}".`);
+        }
+    });
+    pi.registerCommand("improve", {
+        description: "Generate a self-improvement proposal by diagnosing benchmark weaknesses.",
+        handler: async (args, ctx) => {
+            const sub = topicFromArgs(args).toLowerCase();
+            if (sub === "history") {
+                const md = await improveHistory(ctx.cwd);
+                ctx.ui.setEditorText(md);
+                info(ctx, "Loaded improvement history into the editor.");
+                return;
+            }
+            info(ctx, "Running benchmark and diagnosing weaknesses...");
+            const artifact = await improveArtifact(ctx.cwd);
+            ctx.ui.setEditorText(`read ${relative(ctx.cwd, artifact.proposalPath)}`);
+            info(ctx, `Improvement proposal ${artifact.proposal.id} targets ${artifact.proposal.targets.map(t => t.file).join(", ")}`);
+        }
+    });
+    pi.registerCommand("trace", {
+        description: "Browse persisted benchmark and evolution traces.",
+        handler: async (args, ctx) => {
+            const query = topicFromArgs(args).toLowerCase();
+            const artifacts = (await listArtifacts(ctx.cwd)).filter((artifact) => !query ? true : artifact.path.toLowerCase().includes(query) || artifact.label.toLowerCase().includes(query));
+            if (artifacts.length === 0) {
+                info(ctx, "No matching trace artifacts. Use /bench or /evolve first.");
+                return;
+            }
+            const selected = await ctx.ui.select("Keating Traces", artifacts.map((artifact) => artifact.label));
+            const artifact = artifacts.find((entry) => entry.label === selected);
+            if (artifact) {
+                ctx.ui.setEditorText(`read ${artifact.path}`);
+            }
+        }
+    });
+    pi.on("session_start", async (_event, ctx) => {
+        await ensureProjectScaffold(ctx.cwd);
+        info(ctx, "Keating loaded: use /plan, /map, /animate, /verify, /bench, /evolve, /prompt-evolve, /improve, /trace, /feedback, or /policy.");
+    });
+}

package/dist/src/runtime/pi.js

@@ -0,0 +1,118 @@
+import { existsSync, readFileSync } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { spawn, spawnSync } from "node:child_process";
+import { homedir } from "node:os";
+import { loadKeatingConfig, mergePiDefaults } from "../core/config.js";
+import { ensureProjectScaffold } from "../core/project.js";
+import { sessionsDir } from "../core/paths.js";
+function resolveStandalonePi() {
+    const result = spawnSync("which", ["pi"], { encoding: "utf8" });
+    if (result.status === 0 && result.stdout.trim()) {
+        return {
+            kind: "binary",
+            command: result.stdout.trim()
+        };
+    }
+    return null;
+}
+async function resolveEmbeddedPi() {
+    const base = join(homedir(), ".local", "share", "feynman");
+    const entries = await readdir(base, { withFileTypes: true }).catch(() => []);
+    const dirs = entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .sort()
+        .reverse();
+    for (const name of dirs) {
+        const appRoot = join(base, name, "app");
+        const cliPath = join(appRoot, "node_modules", "@mariozechner", "pi-coding-agent", "dist", "cli.js");
+        if (existsSync(cliPath)) {
+            return {
+                kind: "embedded-feynman",
+                command: process.execPath,
+                cliPath
+            };
+        }
+    }
+    return null;
+}
+export async function detectPiRuntime(cwd) {
+    const config = await loadKeatingConfig(cwd);
+    const standalone = resolveStandalonePi();
+    const embedded = await resolveEmbeddedPi();
+    let selected = null;
+    switch (config.pi.runtimePreference) {
+        case "embedded-only":
+            selected = embedded;
+            break;
+        case "prefer-standalone":
+            selected = standalone ?? embedded;
+            break;
+        case "standalone-only":
+        default:
+            selected = standalone;
+            break;
+    }
+    return {
+        selected,
+        standalone,
+        embedded,
+        preference: config.pi.runtimePreference
+    };
+}
+export async function launchPi(cwd, args) {
+    await ensureProjectScaffold(cwd);
+    const config = await loadKeatingConfig(cwd);
+    const report = await detectPiRuntime(cwd);
+    const runtime = report.selected;
+    if (!runtime) {
+        if (report.preference === "standalone-only") {
+            throw new Error("Keating is configured for a fresh standalone Pi install, but no `pi` binary was found on PATH. Install `@mariozechner/pi-coding-agent` or change `pi.runtimePreference` in keating.config.json.");
+        }
+        throw new Error("Could not find a Pi runtime matching the current Keating runtime preference.");
+    }
+    const extensionPath = resolve(cwd, "dist", "src", "pi", "hyperteacher-extension.js");
+    if (!existsSync(extensionPath)) {
+        throw new Error(`Missing built extension: ${extensionPath}. Run npm run build first.`);
+    }
+    const promptDir = resolve(cwd, "pi", "prompts");
+    const skillsDir = resolve(cwd, "pi", "skills");
+    const systemPrompt = readFileSync(resolve(cwd, "SYSTEM.md"), "utf8");
+    const sharedArgs = mergePiDefaults(config, [
+        "--session-dir",
+        sessionsDir(cwd),
+        "--extension",
+        extensionPath,
+        "--prompt-template",
+        promptDir,
+        "--skill",
+        skillsDir,
+        "--append-system-prompt",
+        systemPrompt,
+        "--tools",
+        "read,bash,edit,write,grep,find,ls",
+        ...args
+    ]);
+    const child = runtime.kind === "binary"
+        ? spawn(runtime.command, sharedArgs, {
+            cwd,
+            stdio: "inherit",
+            env: {
+                ...process.env,
+                PI_SKIP_VERSION_CHECK: process.env.PI_SKIP_VERSION_CHECK ?? "1"
+            }
+        })
+        : spawn(runtime.command, [runtime.cliPath, ...sharedArgs], {
+            cwd,
+            stdio: "inherit",
+            env: {
+                ...process.env,
+                PI_SKIP_VERSION_CHECK: process.env.PI_SKIP_VERSION_CHECK ?? "1"
+            }
+        });
+    return await new Promise((resolvePromise, reject) => {
+        child.on("error", reject);
+        child.on("exit", (code) => resolvePromise(code ?? 0));
+    });
+}

package/dist/test/animation.test.js

@@ -0,0 +1,43 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { animationSceneSource, buildAnimationManifest } from "../src/core/animation.js";
+import { lessonPlanToMermaid } from "../src/core/map.js";
+import { DEFAULT_POLICY, clampPolicy } from "../src/core/policy.js";
+import { Prng } from "../src/core/random.js";
+test("visual generators preserve meaning-map and animation invariants across randomized topics", () => {
+    const prng = new Prng(4242);
+    for (let index = 0; index < 80; index += 1) {
+        const policy = clampPolicy({
+            ...DEFAULT_POLICY,
+            name: `visual-${index}`,
+            analogyDensity: prng.next(),
+            socraticRatio: prng.next(),
+            formalism: prng.next(),
+            retrievalPractice: prng.next(),
+            exerciseCount: prng.int(1, 5),
+            diagramBias: prng.next(),
+            reflectionBias: prng.next(),
+            interdisciplinaryBias: prng.next(),
+            challengeRate: prng.next()
+        });
+        const topic = index % 4 === 0 ? "derivative" : `concept ${index} ${Math.floor(prng.next() * 1000)}`;
+        const mermaid = lessonPlanToMermaid(topic, policy);
+        const manifest = buildAnimationManifest(topic, policy);
+        const scene = animationSceneSource(topic, policy, "./vendor/manim-web.js");
+        assert.ok(mermaid.startsWith("graph TD"));
+        assert.ok(mermaid.includes('subgraph pedagogy["Teaching Loop"]'));
+        assert.ok(mermaid.includes('subgraph meaning["Meaning Map"]'));
+        assert.ok(mermaid.includes('subgraph friction["Misconceptions And Practice"]'));
+        assert.ok(mermaid.includes('subgraph transfer["Transfer Hooks"]'));
+        assert.ok(scene.includes('from "./vendor/manim-web.js"'));
+        assert.ok(scene.includes("export async function construct(scene)"));
+        assert.ok(manifest.rationale.length >= 4);
+        assert.equal(manifest.focusMoments.length, 4);
+    }
+});
+test("canonical topics select distinct animation grammars", () => {
+    assert.equal(buildAnimationManifest("derivative", DEFAULT_POLICY).sceneKind, "function-graph");
+    assert.equal(buildAnimationManifest("entropy", DEFAULT_POLICY).sceneKind, "distribution-bars");
+    assert.equal(buildAnimationManifest("bayes", DEFAULT_POLICY).sceneKind, "belief-update");
+    assert.equal(buildAnimationManifest("stoicism", DEFAULT_POLICY).sceneKind, "concept-card");
+});

package/dist/test/config.test.js

@@ -0,0 +1,36 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { DEFAULT_KEATING_CONFIG, configPath, ensureConfig, loadKeatingConfig, mergePiDefaults } from "../src/core/config.js";
+test("ensureConfig creates the default config and loadKeatingConfig reads it", async () => {
+    const workdir = await mkdtemp(join(tmpdir(), "keating-config-"));
+    await ensureConfig(workdir);
+    const config = await loadKeatingConfig(workdir);
+    const saved = JSON.parse(await readFile(configPath(workdir), "utf8"));
+    assert.deepEqual(config, DEFAULT_KEATING_CONFIG);
+    assert.deepEqual(saved, DEFAULT_KEATING_CONFIG);
+});
+test("mergePiDefaults injects model defaults but preserves explicit user overrides", async () => {
+    const workdir = await mkdtemp(join(tmpdir(), "keating-config-override-"));
+    await writeFile(configPath(workdir), JSON.stringify({
+        pi: {
+            runtimePreference: "prefer-standalone",
+            defaultProvider: "anthropic",
+            defaultModel: "anthropic/claude-sonnet-4-5",
+            defaultThinking: "high"
+        }
+    }, null, 2), "utf8");
+    const config = await loadKeatingConfig(workdir);
+    assert.deepEqual(mergePiDefaults(config, ["hello"]), [
+        "--thinking",
+        "high",
+        "--model",
+        "anthropic/claude-sonnet-4-5",
+        "--provider",
+        "anthropic",
+        "hello"
+    ]);
+    assert.deepEqual(mergePiDefaults(config, ["--model", "openai/gpt-5", "--provider", "openai", "--thinking", "low", "hello"]), ["--model", "openai/gpt-5", "--provider", "openai", "--thinking", "low", "hello"]);
+});

package/dist/test/evolution.test.js

@@ -0,0 +1,39 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { runBenchmarkSuite } from "../src/core/benchmark.js";
+import { evolvePolicy, noveltyScore } from "../src/core/evolution.js";
+import { DEFAULT_POLICY } from "../src/core/policy.js";
+test("accepted evolution candidates never underperform the current best by construction", async () => {
+    const workdir = await mkdtemp(join(tmpdir(), "keating-evolution-"));
+    const archivePath = join(workdir, "archive.json");
+    const run = await evolvePolicy(archivePath, DEFAULT_POLICY, undefined, 20, 1234);
+    assert.ok(run.best.overallScore >= run.baseline.overallScore);
+    for (const candidate of run.acceptedCandidates) {
+        assert.ok(candidate.novelty >= 0.05);
+        assert.ok(candidate.benchmark.overallScore >= run.baseline.overallScore);
+    }
+    const saved = JSON.parse(await readFile(archivePath, "utf8"));
+    assert.equal(saved.currentPolicy.name, run.best.policy.name);
+});
+test("noveltyScore uses Euclidean distance in parameter space", () => {
+    const base = { ...DEFAULT_POLICY };
+    const identical = { ...DEFAULT_POLICY };
+    const different = { ...DEFAULT_POLICY, analogyDensity: 0.1, formalism: 0.1 };
+    // Identical policy should have zero distance
+    const identicalNovelty = noveltyScore([base], identical);
+    assert.equal(identicalNovelty, 0);
+    // Different policy should have positive distance
+    const differentNovelty = noveltyScore([base], different);
+    assert.ok(differentNovelty > 0, `expected positive novelty, got ${differentNovelty}`);
+    // Empty archive should return 1
+    const emptyNovelty = noveltyScore([], different);
+    assert.equal(emptyNovelty, 1);
+});
+test("benchmark suite remains deterministic for fixed policy and seed", () => {
+    const left = runBenchmarkSuite(DEFAULT_POLICY, "derivative", 99);
+    const right = runBenchmarkSuite(DEFAULT_POLICY, "derivative", 99);
+    assert.deepEqual(left, right);
+});

package/dist/test/fuzz.test.js

@@ -0,0 +1,37 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { runBenchmarkSuite } from "../src/core/benchmark.js";
+import { buildLessonPlan } from "../src/core/lesson-plan.js";
+import { lessonPlanToMermaid } from "../src/core/map.js";
+import { DEFAULT_POLICY, clampPolicy } from "../src/core/policy.js";
+import { Prng } from "../src/core/random.js";
+test("fuzzed topics and policies stay bounded and renderable", () => {
+    const prng = new Prng(2026);
+    for (let index = 0; index < 200; index += 1) {
+        const policy = clampPolicy({
+            ...DEFAULT_POLICY,
+            name: `fuzz-${index}`,
+            analogyDensity: prng.next(),
+            socraticRatio: prng.next(),
+            formalism: prng.next(),
+            retrievalPractice: prng.next(),
+            exerciseCount: prng.int(1, 5),
+            diagramBias: prng.next(),
+            reflectionBias: prng.next(),
+            interdisciplinaryBias: prng.next(),
+            challengeRate: prng.next()
+        });
+        const topic = `topic ${index} ${Math.floor(prng.next() * 1000)}`;
+        const plan = buildLessonPlan(topic, policy);
+        const mermaid = lessonPlanToMermaid(topic, policy);
+        const benchmark = runBenchmarkSuite(policy, topic, index + 1);
+        assert.ok(plan.phases.length >= 6);
+        assert.ok(mermaid.startsWith("graph TD"));
+        assert.ok(benchmark.overallScore >= 0);
+        assert.ok(benchmark.overallScore <= 100);
+        for (const entry of benchmark.topicBenchmarks) {
+            assert.ok(entry.meanConfusion >= 0);
+            assert.ok(entry.meanConfusion <= 1);
+        }
+    }
+});