@interleavelove/keating 0.1.0

package/dist/src/core/policy.js

@@ -0,0 +1,53 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { clamp } from "./util.js";
+export const DEFAULT_POLICY = {
+    name: "keating-default",
+    analogyDensity: 0.72,
+    socraticRatio: 0.66,
+    formalism: 0.64,
+    retrievalPractice: 0.74,
+    exerciseCount: 3,
+    diagramBias: 0.7,
+    reflectionBias: 0.68,
+    interdisciplinaryBias: 0.62,
+    challengeRate: 0.58
+};
+export function clampPolicy(policy) {
+    return {
+        ...policy,
+        analogyDensity: clamp(policy.analogyDensity),
+        socraticRatio: clamp(policy.socraticRatio),
+        formalism: clamp(policy.formalism),
+        retrievalPractice: clamp(policy.retrievalPractice),
+        exerciseCount: Math.min(5, Math.max(1, Math.round(policy.exerciseCount))),
+        diagramBias: clamp(policy.diagramBias),
+        reflectionBias: clamp(policy.reflectionBias),
+        interdisciplinaryBias: clamp(policy.interdisciplinaryBias),
+        challengeRate: clamp(policy.challengeRate)
+    };
+}
+export function policySignature(policy) {
+    return [
+        policy.analogyDensity.toFixed(2),
+        policy.socraticRatio.toFixed(2),
+        policy.formalism.toFixed(2),
+        policy.retrievalPractice.toFixed(2),
+        String(policy.exerciseCount),
+        policy.diagramBias.toFixed(2),
+        policy.reflectionBias.toFixed(2),
+        policy.interdisciplinaryBias.toFixed(2),
+        policy.challengeRate.toFixed(2)
+    ].join("|");
+}
+export async function loadPolicy(filePath) {
+    try {
+        const content = await readFile(filePath, "utf8");
+        return clampPolicy(JSON.parse(content));
+    }
+    catch {
+        return DEFAULT_POLICY;
+    }
+}
+export async function savePolicy(filePath, policy) {
+    await writeFile(filePath, `${JSON.stringify(clampPolicy(policy), null, 2)}\n`, "utf8");
+}

package/dist/src/core/project.js

@@ -0,0 +1,189 @@
+import { readdir, stat, writeFile } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { loadKeatingConfig } from "./config.js";
+import { writeLessonAnimation } from "./animation.js";
+import { benchmarkToMarkdown, runBenchmarkSuite } from "./benchmark.js";
+import { evolutionToMarkdown, evolvePolicy } from "./evolution.js";
+import { buildLessonPlan, lessonPlanToMarkdown } from "./lesson-plan.js";
+import { writeLessonMap } from "./map.js";
+import { writePromptEvolutionArtifacts } from "./prompt-evolution.js";
+import { animationsDir, benchmarksDir, currentPolicyPath, ensureKeatingDirs, evolutionDir, mapsDir, plansDir, policyArchivePath, promptEvolutionDir, tracesDir, verificationsDir, verificationCachePath } from "./paths.js";
+import { ensureConfig } from "./config.js";
+import { DEFAULT_POLICY, loadPolicy, savePolicy } from "./policy.js";
+import { resolveTopic } from "./topics.js";
+import { slugify } from "./util.js";
+import { buildPendingVerificationResult, buildVerificationChecklist, loadVerificationCache, runCoveVerification, saveVerificationCache, verificationStatus } from "./verification.js";
+import { generateImprovementArtifact, loadImprovementArchive, improvementHistoryToMarkdown, evaluateImprovement, acceptImprovement, rejectImprovement } from "./self-improve.js";
+export async function ensureProjectScaffold(cwd) {
+    await ensureKeatingDirs(cwd);
+    await ensureConfig(cwd);
+    const policy = await loadPolicy(currentPolicyPath(cwd));
+    await savePolicy(currentPolicyPath(cwd), policy ?? DEFAULT_POLICY);
+}
+export async function planTopicArtifact(cwd, topicName) {
+    await ensureProjectScaffold(cwd);
+    const policy = await loadPolicy(currentPolicyPath(cwd));
+    const plan = buildLessonPlan(topicName, policy);
+    const planPath = join(plansDir(cwd), `${slugify(topicName)}.md`);
+    await writeFile(planPath, lessonPlanToMarkdown(plan), "utf8");
+    return { planPath };
+}
+export async function mapTopicArtifact(cwd, topicName) {
+    await ensureProjectScaffold(cwd);
+    const policy = await loadPolicy(currentPolicyPath(cwd));
+    return writeLessonMap(cwd, topicName, policy);
+}
+export async function animateTopicArtifact(cwd, topicName) {
+    await ensureProjectScaffold(cwd);
+    const policy = await loadPolicy(currentPolicyPath(cwd));
+    return writeLessonAnimation(cwd, topicName, policy);
+}
+export async function benchPolicyArtifact(cwd, focusTopic) {
+    await ensureProjectScaffold(cwd);
+    const config = await loadKeatingConfig(cwd);
+    const policy = await loadPolicy(currentPolicyPath(cwd));
+    const result = runBenchmarkSuite(policy, focusTopic, 20260401, config.debug.traceTopLearners);
+    const fileName = focusTopic ? `${slugify(focusTopic)}.md` : "core-suite.md";
+    const reportPath = join(benchmarksDir(cwd), fileName);
+    await writeFile(reportPath, benchmarkToMarkdown(result), "utf8");
+    const tracePath = config.debug.persistTraces
+        ? join(tracesDir(cwd), `${focusTopic ? slugify(focusTopic) : "core-suite"}-benchmark.json`)
+        : null;
+    if (tracePath) {
+        await writeFile(tracePath, `${JSON.stringify(result, null, 2)}\n`, "utf8");
+    }
+    return { reportPath, tracePath, overallScore: result.overallScore };
+}
+export async function evolvePolicyArtifact(cwd, focusTopic) {
+    await ensureProjectScaffold(cwd);
+    const config = await loadKeatingConfig(cwd);
+    const policyPath = currentPolicyPath(cwd);
+    const basePolicy = await loadPolicy(policyPath);
+    const run = await evolvePolicy(policyArchivePath(cwd), basePolicy, focusTopic);
+    await savePolicy(policyPath, run.best.policy);
+    const fileName = focusTopic ? `${slugify(focusTopic)}.md` : "latest.md";
+    const reportPath = join(evolutionDir(cwd), fileName);
+    await writeFile(reportPath, evolutionToMarkdown(run), "utf8");
+    const tracePath = config.debug.persistTraces
+        ? join(tracesDir(cwd), `${focusTopic ? slugify(focusTopic) : "latest"}-evolution.json`)
+        : null;
+    if (tracePath) {
+        await writeFile(tracePath, `${JSON.stringify(run, null, 2)}\n`, "utf8");
+    }
+    return { reportPath, tracePath, bestScore: run.best.overallScore, policyPath };
+}
+export async function evolvePromptArtifact(cwd, promptName = "learn") {
+    await ensureProjectScaffold(cwd);
+    return writePromptEvolutionArtifacts(cwd, promptName);
+}
+export async function verifyTopicArtifact(cwd, topicName, useLLM = true) {
+    await ensureProjectScaffold(cwd);
+    const topic = resolveTopic(topicName);
+    const cachePath = verificationCachePath(cwd);
+    const cache = await loadVerificationCache(cachePath);
+    const existing = verificationStatus(topic, cache);
+    if (existing && existing.claims.every((c) => c.status !== "unconfirmed")) {
+        return {
+            checklistPath: join(verificationsDir(cwd), `${topic.slug}.md`),
+            alreadyVerified: true,
+            result: existing
+        };
+    }
+    let result;
+    if (useLLM) {
+        try {
+            result = await runCoveVerification(cwd, topic);
+            cache[topic.slug] = result;
+            await saveVerificationCache(cachePath, cache);
+        }
+        catch (error) {
+            console.warn(`CoVe verification failed for ${topic.slug}, falling back to manual checklist:`, error);
+            result = buildPendingVerificationResult(topic);
+        }
+    }
+    else {
+        result = buildPendingVerificationResult(topic);
+    }
+    const checklist = buildVerificationChecklist(topic, result);
+    const checklistPath = join(verificationsDir(cwd), `${topic.slug}.md`);
+    await writeFile(checklistPath, checklist, "utf8");
+    return { checklistPath, alreadyVerified: false, result };
+}
+export async function improveArtifact(cwd) {
+    await ensureProjectScaffold(cwd);
+    return generateImprovementArtifact(cwd);
+}
+export async function improveAccept(cwd, proposalId) {
+    await ensureProjectScaffold(cwd);
+    const evaluation = await evaluateImprovement(cwd, 0);
+    await acceptImprovement(cwd, proposalId, evaluation.afterScore);
+    return { afterScore: evaluation.afterScore, delta: evaluation.delta };
+}
+export async function improveReject(cwd, proposalId, snapshots) {
+    await ensureProjectScaffold(cwd);
+    await rejectImprovement(cwd, proposalId, snapshots);
+}
+export async function improveHistory(cwd) {
+    await ensureProjectScaffold(cwd);
+    const archive = await loadImprovementArchive(cwd);
+    return improvementHistoryToMarkdown(archive);
+}
+export async function currentPolicySummary(cwd) {
+    await ensureProjectScaffold(cwd);
+    const policy = await loadPolicy(currentPolicyPath(cwd));
+    return [
+        `Policy: ${policy.name}`,
+        `analogyDensity=${policy.analogyDensity.toFixed(2)}`,
+        `socraticRatio=${policy.socraticRatio.toFixed(2)}`,
+        `formalism=${policy.formalism.toFixed(2)}`,
+        `retrievalPractice=${policy.retrievalPractice.toFixed(2)}`,
+        `exerciseCount=${policy.exerciseCount}`,
+        `diagramBias=${policy.diagramBias.toFixed(2)}`,
+        `reflectionBias=${policy.reflectionBias.toFixed(2)}`,
+        `interdisciplinaryBias=${policy.interdisciplinaryBias.toFixed(2)}`,
+        `challengeRate=${policy.challengeRate.toFixed(2)}`
+    ].join("\n");
+}
+export async function listArtifacts(cwd) {
+    await ensureProjectScaffold(cwd);
+    const roots = [
+        plansDir(cwd),
+        mapsDir(cwd),
+        animationsDir(cwd),
+        benchmarksDir(cwd),
+        evolutionDir(cwd),
+        promptEvolutionDir(cwd),
+        tracesDir(cwd),
+        verificationsDir(cwd)
+    ];
+    const artifacts = [];
+    async function collectFiles(root) {
+        const entries = await readdir(root, { withFileTypes: true }).catch(() => []);
+        const files = [];
+        for (const entry of entries) {
+            if (entry.name === "_vendor")
+                continue;
+            const fullPath = join(root, entry.name);
+            if (entry.isDirectory()) {
+                files.push(...(await collectFiles(fullPath)));
+            }
+            else if (entry.isFile()) {
+                files.push(fullPath);
+            }
+        }
+        return files;
+    }
+    for (const root of roots) {
+        for (const fullPath of await collectFiles(root)) {
+            const info = await stat(fullPath);
+            artifacts.push({
+                label: `${relative(cwd, fullPath)} (${Math.round(info.size / 1024) || 1}KB)`,
+                path: relative(cwd, fullPath),
+                mtime: info.mtimeMs
+            });
+        }
+    }
+    return artifacts
+        .sort((left, right) => right.mtime - left.mtime)
+        .map((artifact) => ({ label: artifact.label, path: artifact.path }));
+}

package/dist/src/core/prompt-evolution.js

@@ -0,0 +1,337 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import * as dotenv from "dotenv";
+import { promptEvolutionArchivePath, promptEvolutionDir } from "./paths.js";
+import { piComplete, piCompleteJson } from "./pi-agent.js";
+dotenv.config();
+const KEATING_QUOTE = "Boys, you must strive to find your own voice. Because the longer you wait to begin, the less likely you are to find it at all.";
+let piAvailabilityCache = null;
+function promptNameFromPath(promptPath) {
+    const fileName = promptPath.split(/[\\/]/).pop() ?? promptPath;
+    return fileName.replace(/\.md$/, "");
+}
+function parsePromptBody(raw) {
+    if (!raw.startsWith("---"))
+        return raw.trim();
+    const parts = raw.split("\n---\n");
+    if (parts.length < 2)
+        return raw.trim();
+    return parts.slice(1).join("\n---\n").trim();
+}
+function parseFrontMatter(raw) {
+    if (!raw.startsWith("---"))
+        return "";
+    const parts = raw.split("\n---\n");
+    if (parts.length < 2)
+        return "";
+    return `${parts[0]}\n---`.trim();
+}
+function clamp01(value) {
+    return Math.max(0, Math.min(1, value));
+}
+function keywordScore(body, keywords, base, bonus) {
+    const hits = keywords.filter((keyword) => body.includes(keyword)).length;
+    return clamp01(base + hits * bonus);
+}
+function heuristicPromptEvaluation(promptPath, prompt) {
+    const body = parsePromptBody(prompt).toLowerCase();
+    const objectives = {
+        voice_divergence: keywordScore(body, ["own words", "own language", "personal context", "say it again"], 0.35, 0.18),
+        diagnosis: keywordScore(body, ["diagnostic", "prerequisite", "misconception", "assumption check"], 0.4, 0.16),
+        verification: keywordScore(body, ["verify", "verification", "source", "unverified", "check claim"], 0.2, 0.18),
+        retrieval: keywordScore(body, ["retrieval", "reconstruct", "without looking", "recall", "practice"], 0.35, 0.18),
+        transfer: keywordScore(body, ["transfer", "bridge", "other domain", "practical consequence", "new setting"], 0.3, 0.18),
+        structure: keywordScore(body, ["diagnose", "intuition", "formal", "misconception", "example", "retrieval", "reflection"], 0.45, 0.09)
+    };
+    const feedback = [];
+    if (objectives.voice_divergence < 0.7)
+        feedback.push("Add an explicit requirement that the learner restate the idea in their own words.");
+    if (objectives.diagnosis < 0.7)
+        feedback.push("Strengthen diagnosis of prerequisite gaps and misconceptions before teaching.");
+    if (objectives.verification < 0.7)
+        feedback.push("Include a step that distinguishes verified claims from claims that still need checking.");
+    if (objectives.retrieval < 0.7)
+        feedback.push("Add a retrieval checkpoint that requires reconstruction rather than agreement.");
+    if (objectives.transfer < 0.7)
+        feedback.push("Bridge the concept into a different domain or practical context before ending.");
+    if (objectives.structure < 0.7)
+        feedback.push("Make the lesson loop explicit so the workflow is easy to follow and evaluate.");
+    const score = objectives.voice_divergence * 14 +
+        objectives.diagnosis * 20 +
+        objectives.verification * 18 +
+        objectives.retrieval * 18 +
+        objectives.transfer * 16 +
+        objectives.structure * 14;
+    return {
+        promptPath,
+        promptName: promptNameFromPath(promptPath),
+        score,
+        objectives,
+        feedback
+    };
+}
+function heuristicCandidatePrompt(basePrompt) {
+    const frontMatter = parseFrontMatter(basePrompt);
+    const body = parsePromptBody(basePrompt).trimEnd();
+    const additions = [
+        '4a. If the learner echoes your phrasing, stop and ask them to explain the idea again in their own words.',
+        '4b. Separate missing prerequisite, misconception, and partial intuition before choosing the next teaching move.',
+        '5a. Add one short retrieval checkpoint that the learner must answer without relying on your wording.',
+        '6a. Bridge the idea into a new domain, personal example, or practical consequence before ending.',
+        '6b. Mark any factual claim that still needs verification instead of presenting it as settled.'
+    ].filter((line) => !body.includes(line));
+    const evolvedBody = additions.length === 0 ? `${body}\n7a. Keep the learner cognitively active at every step.` : `${body}\n${additions.join("\n")}`;
+    return frontMatter ? `${frontMatter}\n${evolvedBody}\n` : `${evolvedBody}\n`;
+}
+export async function evaluatePromptContent(cwd, promptPath, prompt) {
+    const body = parsePromptBody(prompt);
+    const evalPrompt = `Evaluate the following teaching prompt template based on Keating's hyperteacher philosophy.
+Keating philosophy:
+- AI must not be a surrogate for thought.
+- Measuring success by the learner's independent articulation (finding their "voice").
+- Rejecting "surface agreement" (rote echoes or simple "yes/no" answers).
+- The "diagnose -> intuition -> formal core -> misconception repair -> example -> retrieval -> reflection" loop.
+
+Evaluate these objectives on a scale of 0 to 1 (floating point):
+1. voice_divergence: How well does the prompt force the learner to use their own language? Penalize prompts that allow the learner to echo the AI's explanation.
+2. diagnosis: Checking prerequisites and misconceptions before teaching.
+3. verification: Refusing to teach unverified claims as settled truth.
+4. retrieval: Using reconstruction and practice instead of passive agreement.
+5. transfer: Bridging the concept to other domains or practical consequences.
+6. structure: Having an explicit, logical teaching workflow.
+
+Provide the evaluation in JSON format:
+{
+  "objectives": {
+    "voice_divergence": number,
+    "diagnosis": number,
+    "verification": number,
+    "retrieval": number,
+    "transfer": number,
+    "structure": number
+  },
+  "feedback": string[]
+}
+
+Prompt Content:
+"""
+${body}
+"""
+`;
+    if (piAvailabilityCache === false) {
+        return heuristicPromptEvaluation(promptPath, prompt);
+    }
+    let data;
+    try {
+        data = await piCompleteJson(cwd, evalPrompt, { thinking: "low" });
+        piAvailabilityCache = true;
+    }
+    catch {
+        piAvailabilityCache = false;
+        const heuristic = heuristicPromptEvaluation(promptPath, prompt);
+        return heuristic;
+    }
+    const objectives = data.objectives;
+    const score = objectives.voice_divergence * 14 +
+        objectives.diagnosis * 20 +
+        objectives.verification * 18 +
+        objectives.retrieval * 18 +
+        objectives.transfer * 16 +
+        objectives.structure * 14;
+    return {
+        promptPath,
+        promptName: promptNameFromPath(promptPath),
+        score,
+        objectives,
+        feedback: data.feedback
+    };
+}
+async function generateCandidatePrompt(cwd, basePrompt, evaluation, iteration) {
+    const frontMatter = parseFrontMatter(basePrompt);
+    const body = parsePromptBody(basePrompt);
+    const generationPrompt = `You are Keating's prompt-learning agent. Your goal is to evolve a teaching prompt template so that it prevents "surface agreement" and forces the learner to find their own voice.
+
+Original Prompt:
+"""
+${body}
+"""
+
+Feedback:
+${evaluation.feedback.map(f => `- ${f}`).join("\n")}
+
+Mandate:
+1. PUSH FOR DIVERGENCE: Add instructions that force the learner to re-explain the concept using their own analogies or personal context.
+2. REJECT ECHOES: Instruct the teacher to identify if the learner is just repeating words from the previous explanation and, if so, ask them to "say it again, but as if you're explaining it to someone else entirely."
+3. ADDRESS FEEDBACK: Address the specific gaps in diagnosis, verification, and structure.
+
+Evolved Prompt Body (no code blocks, no frontmatter):`;
+    if (piAvailabilityCache === false) {
+        return heuristicCandidatePrompt(basePrompt);
+    }
+    let evolvedBody;
+    try {
+        evolvedBody = await piComplete(cwd, generationPrompt, { thinking: "medium" });
+        piAvailabilityCache = true;
+    }
+    catch {
+        piAvailabilityCache = false;
+        return heuristicCandidatePrompt(basePrompt);
+    }
+    return frontMatter ? `${frontMatter}\n${evolvedBody}\n` : `${evolvedBody}\n`;
+}
+function objectiveVector(candidate) {
+    const { objectives } = candidate.evaluation;
+    return [
+        objectives.voice_divergence,
+        objectives.diagnosis,
+        objectives.verification,
+        objectives.retrieval,
+        objectives.transfer,
+        objectives.structure
+    ];
+}
+function pairwisePreference(left, right) {
+    const leftVector = objectiveVector(left);
+    const rightVector = objectiveVector(right);
+    let wins = 0;
+    let losses = 0;
+    for (let index = 0; index < leftVector.length; index += 1) {
+        if (leftVector[index] > rightVector[index])
+            wins += 1;
+        if (leftVector[index] < rightVector[index])
+            losses += 1;
+    }
+    const aggregateDelta = left.evaluation.score - right.evaluation.score;
+    return wins - losses + aggregateDelta / 25;
+}
+export function prosperStyleWinner(candidates) {
+    let best = candidates[0];
+    let bestScore = -Infinity;
+    for (const candidate of candidates) {
+        const score = candidates.reduce((sum, opponent) => {
+            if (candidate === opponent)
+                return sum;
+            return sum + pairwisePreference(candidate, opponent);
+        }, 0);
+        candidate.preferenceScore = score;
+        if (score > bestScore) {
+            best = candidate;
+            bestScore = score;
+        }
+    }
+    return best;
+}
+async function loadArchive(archivePath) {
+    try {
+        const raw = await readFile(archivePath, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return { winners: [] };
+    }
+}
+async function saveArchive(archivePath, archive) {
+    await writeFile(archivePath, `${JSON.stringify(archive, null, 2)}\n`, "utf8");
+}
+export async function evolvePrompt(cwd, promptName = "learn", iterations = 4, evaluator = evaluatePromptContent, generator = generateCandidatePrompt) {
+    const promptPath = join(cwd, "pi", "prompts", `${promptName}.md`);
+    const prompt = await readFile(promptPath, "utf8");
+    const baseline = await evaluator(cwd, promptPath, prompt);
+    const candidates = [];
+    for (let iteration = 1; iteration <= iterations; iteration += 1) {
+        const candidatePrompt = await generator(cwd, prompt, baseline, iteration);
+        const evaluation = await evaluator(cwd, promptPath, candidatePrompt);
+        candidates.push({
+            iteration,
+            label: `${promptName}-candidate-${iteration}`,
+            prompt: candidatePrompt,
+            evaluation,
+            parentLabel: promptName,
+            accepted: false,
+            preferenceScore: 0
+        });
+    }
+    const best = prosperStyleWinner(candidates);
+    for (const candidate of candidates) {
+        candidate.accepted = candidate.label === best.label && candidate.evaluation.score >= baseline.score;
+    }
+    const archivePath = promptEvolutionArchivePath(cwd);
+    const archive = await loadArchive(archivePath);
+    archive.winners.push({
+        promptName,
+        label: best.label,
+        score: best.evaluation.score,
+        objectives: best.evaluation.objectives,
+        updatedAt: new Date().toISOString()
+    });
+    await saveArchive(archivePath, archive);
+    return {
+        promptPath,
+        promptName,
+        baseline,
+        best,
+        exploredCandidates: candidates,
+        acceptedCandidates: candidates.filter((candidate) => candidate.accepted)
+    };
+}
+export async function writePromptEvolutionArtifacts(cwd, promptName = "learn") {
+    const run = await evolvePrompt(cwd, promptName);
+    const reportPath = join(promptEvolutionDir(cwd), `${promptName}.md`);
+    const evolvedPromptPath = join(promptEvolutionDir(cwd), `${promptName}.evolved.md`);
+    await writeFile(reportPath, promptEvolutionToMarkdown(run), "utf8");
+    await writeFile(evolvedPromptPath, run.best.prompt, "utf8");
+    return {
+        reportPath,
+        evolvedPromptPath,
+        bestScore: run.best.evaluation.score,
+        promptPath: run.promptPath
+    };
+}
+export function promptEvolutionToMarkdown(run) {
+    const objectiveList = (objectives) => [
+        `voice_divergence=${objectives.voice_divergence.toFixed(2)}`,
+        `diagnosis=${objectives.diagnosis.toFixed(2)}`,
+        `verification=${objectives.verification.toFixed(2)}`,
+        `retrieval=${objectives.retrieval.toFixed(2)}`,
+        `transfer=${objectives.transfer.toFixed(2)}`,
+        `structure=${objectives.structure.toFixed(2)}`
+    ];
+    const lines = [
+        `# Prompt Evolution Report: ${run.promptName}`,
+        "",
+        `- Source prompt: ${run.promptPath}`,
+        `- Baseline score: ${run.baseline.score.toFixed(2)}`,
+        `- Best candidate: ${run.best.label}`,
+        `- Best candidate score: ${run.best.evaluation.score.toFixed(2)}`,
+        `- PROSPER-style preference score: ${run.best.preferenceScore.toFixed(2)}`,
+        "",
+        "## Baseline Feedback",
+        ""
+    ];
+    if (run.baseline.feedback.length === 0) {
+        lines.push("- No major prompt-learning gaps detected.");
+    }
+    else {
+        for (const item of run.baseline.feedback) {
+            lines.push(`- ${item}`);
+        }
+    }
+    lines.push("");
+    lines.push("## Candidate Comparison");
+    lines.push("");
+    for (const candidate of run.exploredCandidates) {
+        lines.push(`### ${candidate.label}`);
+        lines.push(`- score: ${candidate.evaluation.score.toFixed(2)}`);
+        lines.push(`- preference: ${candidate.preferenceScore.toFixed(2)}`);
+        lines.push(`- accepted: ${candidate.accepted ? "yes" : "no"}`);
+        lines.push(`- objectives: ${objectiveList(candidate.evaluation.objectives).join(", ")}`);
+        lines.push("");
+    }
+    lines.push("## Recommended Prompt");
+    lines.push("");
+    lines.push("```md");
+    lines.push(run.best.prompt.trimEnd());
+    lines.push("```");
+    lines.push("");
+    return `${lines.join("\n")}\n`;
+}

package/dist/src/core/random.js

@@ -0,0 +1,19 @@
+export class Prng {
+    state;
+    constructor(seed) {
+        this.state = seed >>> 0;
+    }
+    next() {
+        this.state += 0x6d2b79f5;
+        let value = this.state;
+        value = Math.imul(value ^ (value >>> 15), value | 1);
+        value ^= value + Math.imul(value ^ (value >>> 7), value | 61);
+        return ((value ^ (value >>> 14)) >>> 0) / 4294967296;
+    }
+    pick(items) {
+        return items[Math.floor(this.next() * items.length)];
+    }
+    int(min, max) {
+        return Math.floor(this.next() * (max - min + 1)) + min;
+    }
+}