keating 0.3.6

package/dist/src/core/evolution.js

@@ -0,0 +1,242 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { Prng } from "./random.js";
+import { clamp } from "./util.js";
+import { DEFAULT_POLICY, DEFAULT_WEIGHTS, clampPolicy, clampWeights } from "./policy.js";
+import { benchmarkToMarkdown, runBenchmarkSuite } from "./benchmark.js";
+function diffPolicy(before, after) {
+    const keys = [
+        "analogyDensity",
+        "socraticRatio",
+        "formalism",
+        "retrievalPractice",
+        "exerciseCount",
+        "diagramBias",
+        "reflectionBias",
+        "interdisciplinaryBias",
+        "challengeRate"
+    ];
+    return keys
+        .map((field) => {
+        const previous = before[field];
+        const next = after[field];
+        const delta = typeof previous === "number" && typeof next === "number" ? next - previous : 0;
+        return { field, before: previous, after: next, delta };
+    })
+        .filter((entry) => entry.delta !== 0);
+}
+function mutateScalar(prng, value, amplitude = 0.18) {
+    return clamp(value + (prng.next() * 2 - 1) * amplitude);
+}
+function mutateWeights(parent, prng, amplitude = 0.12) {
+    return clampWeights({
+        masteryGain: mutateScalar(prng, parent.masteryGain, amplitude),
+        retention: mutateScalar(prng, parent.retention, amplitude),
+        engagement: mutateScalar(prng, parent.engagement, amplitude),
+        transfer: mutateScalar(prng, parent.transfer, amplitude),
+        confusion: mutateScalar(prng, parent.confusion, amplitude)
+    });
+}
+function mutatePolicy(parent, prng, iteration) {
+    const mutated = clampPolicy({
+        ...parent,
+        name: `keating-candidate-${iteration}`,
+        analogyDensity: mutateScalar(prng, parent.analogyDensity),
+        socraticRatio: mutateScalar(prng, parent.socraticRatio),
+        formalism: mutateScalar(prng, parent.formalism),
+        retrievalPractice: mutateScalar(prng, parent.retrievalPractice),
+        exerciseCount: parent.exerciseCount + prng.int(-1, 1),
+        diagramBias: mutateScalar(prng, parent.diagramBias),
+        reflectionBias: mutateScalar(prng, parent.reflectionBias),
+        interdisciplinaryBias: mutateScalar(prng, parent.interdisciplinaryBias),
+        challengeRate: mutateScalar(prng, parent.challengeRate)
+    });
+    return mutated;
+}
+function policyVector(policy) {
+    return [
+        policy.analogyDensity,
+        policy.socraticRatio,
+        policy.formalism,
+        policy.retrievalPractice,
+        policy.exerciseCount / 5,
+        policy.diagramBias,
+        policy.reflectionBias,
+        policy.interdisciplinaryBias,
+        policy.challengeRate
+    ];
+}
+function euclideanDistance(a, b) {
+    let sum = 0;
+    for (let i = 0; i < a.length; i++) {
+        sum += (a[i] - b[i]) ** 2;
+    }
+    return Math.sqrt(sum / a.length);
+}
+export function noveltyScore(existingPolicies, candidate) {
+    if (existingPolicies.length === 0)
+        return 1;
+    const candidateVec = policyVector(candidate);
+    let minDist = Infinity;
+    for (const existing of existingPolicies) {
+        const dist = euclideanDistance(candidateVec, policyVector(existing));
+        minDist = Math.min(minDist, dist);
+    }
+    return minDist;
+}
+async function loadArchive(filePath) {
+    try {
+        const content = await readFile(filePath, "utf8");
+        return JSON.parse(content);
+    }
+    catch {
+        return {
+            currentPolicy: DEFAULT_POLICY,
+            bestScore: 0,
+            candidates: []
+        };
+    }
+}
+async function saveArchive(filePath, archive) {
+    await writeFile(filePath, `${JSON.stringify(archive, null, 2)}\n`, "utf8");
+}
+export async function evolvePolicy(archivePath, basePolicy, focusTopic, iterations = 24, seed = 20260401, baseWeights = DEFAULT_WEIGHTS) {
+    const archive = await loadArchive(archivePath);
+    const baseline = await runBenchmarkSuite(process.cwd(), basePolicy, focusTopic, seed, 3, baseWeights);
+    let best = baseline;
+    let bestWeights = baseWeights;
+    const acceptedCandidates = [];
+    const exploredCandidates = [];
+    const prng = new Prng(seed + 17);
+    const seen = [...archive.candidates.map((entry) => entry.policy), basePolicy];
+    for (let iteration = 1; iteration <= iterations; iteration += 1) {
+        const candidatePolicy = mutatePolicy(best.policy, prng, iteration);
+        const candidateWeights = mutateWeights(bestWeights, prng);
+        const novelty = noveltyScore(seen, candidatePolicy);
+        const candidateBenchmark = await runBenchmarkSuite(process.cwd(), candidatePolicy, focusTopic, seed + iteration * 11, 3, candidateWeights);
+        const parameterDelta = diffPolicy(best.policy, candidatePolicy);
+        const candidate = {
+            policy: candidatePolicy,
+            benchmark: candidateBenchmark,
+            parentName: best.policy.name,
+            iteration,
+            novelty,
+            accepted: false,
+            parameterDelta,
+            decision: {
+                improves: false,
+                safe: false,
+                novelEnough: false,
+                scoreDelta: 0,
+                weakestTopicDelta: 0,
+                reasons: []
+            }
+        };
+        const bestWeakest = Math.min(...best.topicBenchmarks.map((entry) => entry.meanScore));
+        const candidateWeakest = Math.min(...candidateBenchmark.topicBenchmarks.map((entry) => entry.meanScore));
+        const improves = candidateBenchmark.overallScore > best.overallScore;
+        const safe = candidateWeakest >= bestWeakest - 1.5;
+        const novelEnough = novelty >= 0.05;
+        candidate.decision.improves = improves;
+        candidate.decision.safe = safe;
+        candidate.decision.novelEnough = novelEnough;
+        candidate.decision.scoreDelta = candidateBenchmark.overallScore - best.overallScore;
+        candidate.decision.weakestTopicDelta = candidateWeakest - bestWeakest;
+        if (improves) {
+            candidate.decision.reasons.push(`overall score improved by ${candidate.decision.scoreDelta.toFixed(2)}`);
+        }
+        else {
+            candidate.decision.reasons.push(`overall score regressed by ${Math.abs(candidate.decision.scoreDelta).toFixed(2)}`);
+        }
+        if (safe) {
+            candidate.decision.reasons.push(`weakest-topic score stayed within tolerance (${candidate.decision.weakestTopicDelta.toFixed(2)})`);
+        }
+        else {
+            candidate.decision.reasons.push(`weakest-topic score fell too far (${candidate.decision.weakestTopicDelta.toFixed(2)})`);
+        }
+        if (novelEnough) {
+            candidate.decision.reasons.push(`novelty ${novelty.toFixed(3)} cleared the 0.05 threshold`);
+        }
+        else {
+            candidate.decision.reasons.push(`novelty ${novelty.toFixed(3)} was too close to archived policies`);
+        }
+        if (improves && safe && novelEnough) {
+            candidate.accepted = true;
+            best = candidateBenchmark;
+            bestWeights = candidateWeights;
+            acceptedCandidates.push(candidate);
+        }
+        exploredCandidates.push(candidate);
+        seen.push(candidate.policy);
+    }
+    const nextArchive = {
+        currentPolicy: best.policy,
+        bestScore: best.overallScore,
+        candidates: [
+            ...archive.candidates,
+            ...exploredCandidates.map((entry) => ({
+                policy: entry.policy,
+                score: entry.benchmark.overallScore,
+                novelty: entry.novelty,
+                accepted: entry.accepted,
+                iteration: entry.iteration
+            }))
+        ]
+    };
+    await saveArchive(archivePath, nextArchive);
+    return {
+        baseline,
+        best,
+        acceptedCandidates,
+        exploredCandidates,
+        archive: nextArchive
+    };
+}
+export function evolutionToMarkdown(run) {
+    const lines = [
+        `# Evolution Report: ${run.best.policy.name}`,
+        "",
+        `- Baseline score: ${run.baseline.overallScore.toFixed(2)}`,
+        `- Best score: ${run.best.overallScore.toFixed(2)}`,
+        `- Accepted candidates: ${run.acceptedCandidates.length}`,
+        `- Explored candidates: ${run.exploredCandidates.length}`,
+        ""
+    ];
+    lines.push("## Accepted Candidates");
+    lines.push("");
+    if (run.acceptedCandidates.length === 0) {
+        lines.push("- No candidate cleared both the novelty and safety gates in this run.");
+    }
+    else {
+        for (const candidate of run.acceptedCandidates) {
+            lines.push(`- Iteration ${candidate.iteration}: ${candidate.policy.name} scored ${candidate.benchmark.overallScore.toFixed(2)} with novelty ${candidate.novelty.toFixed(3)}.`);
+        }
+    }
+    lines.push("");
+    lines.push("## Decision Ledger");
+    lines.push("");
+    for (const candidate of run.exploredCandidates) {
+        lines.push(`- Iteration ${candidate.iteration} ${candidate.policy.name}: ${candidate.accepted ? "accepted" : "rejected"}`);
+        lines.push(`  - score delta: ${candidate.decision.scoreDelta.toFixed(2)}`);
+        lines.push(`  - weakest-topic delta: ${candidate.decision.weakestTopicDelta.toFixed(2)}`);
+        lines.push(`  - novelty: ${candidate.novelty.toFixed(3)}`);
+        lines.push(`  - gates: improves=${candidate.decision.improves}, safe=${candidate.decision.safe}, novelEnough=${candidate.decision.novelEnough}`);
+        lines.push(`  - reasons: ${candidate.decision.reasons.join("; ")}`);
+        if (candidate.parameterDelta.length > 0) {
+            lines.push(`  - parameter delta: ${candidate.parameterDelta
+                .map((entry) => `${entry.field}:${entry.delta >= 0 ? "+" : ""}${entry.delta.toFixed(2)}`)
+                .join(", ")}`);
+        }
+    }
+    lines.push("");
+    lines.push("## Best Benchmark Snapshot");
+    lines.push("");
+    lines.push(benchmarkToMarkdown(run.best).trim());
+    lines.push("");
+    return `${lines.join("\n")}\n`;
+}
+import { optimizePolicy } from "./ax-optimizer.js";
+import { mapElitesEvolve, mapElitesToEvolutionRun, mapElitesToMarkdown } from "./map-elites.js";
+export async function evolveWithGEPA(cwd, basePolicy, options) {
+    return optimizePolicy(cwd, basePolicy, options);
+}
+export { mapElitesEvolve, mapElitesToEvolutionRun, mapElitesToMarkdown };

package/dist/src/core/flashcards.js

@@ -0,0 +1,133 @@
+/**
+ * Flash Cards Engine — spaced-repetition flash cards with front/back and mnemonics.
+ */
+import { resolveTopic } from "./topics.js";
+export function generateFlashCards(topicName) {
+    const topic = resolveTopic(topicName);
+    const cards = [];
+    // Definition card
+    cards.push({
+        id: `${topic.slug}-fc-def`,
+        front: `What is ${topic.title}?`,
+        back: topic.summary,
+        tags: ["definition", topic.domain],
+        difficulty: "easy",
+        source: "definition"
+    });
+    // Formal core cards
+    topic.formalCore.forEach((fc, i) => {
+        cards.push({
+            id: `${topic.slug}-fc-formal-${i}`,
+            front: `Formal property of ${topic.title} (#${i + 1})`,
+            back: fc,
+            tags: ["formal", topic.domain],
+            difficulty: "hard",
+            source: "definition"
+        });
+    });
+    // Intuition cards
+    topic.intuition.forEach((inText, i) => {
+        cards.push({
+            id: `${topic.slug}-fc-intuition-${i}`,
+            front: `Intuition check: What does "${inText}" mean for ${topic.title}?`,
+            back: `This is a concrete way to think about ${topic.title} before formal notation.`,
+            mnemonic: inText,
+            tags: ["intuition", topic.domain],
+            difficulty: "medium",
+            source: "intuition"
+        });
+    });
+    // Misconception cards (crucial for learning)
+    topic.misconceptions.forEach((mis, i) => {
+        cards.push({
+            id: `${topic.slug}-fc-misconception-${i}`,
+            front: `True or False: "${mis}"`,
+            back: `FALSE. ${mis} is a common misconception.`,
+            tags: ["misconception", topic.domain],
+            difficulty: "hard",
+            source: "misconception"
+        });
+    });
+    // Example cards
+    topic.examples.forEach((ex, i) => {
+        cards.push({
+            id: `${topic.slug}-fc-example-${i}`,
+            front: `Worked example: ${ex}`,
+            back: `This example illustrates ${topic.title} in practice.`,
+            tags: ["example", topic.domain],
+            difficulty: "medium",
+            source: "example"
+        });
+    });
+    // Reflection cards
+    topic.reflections.forEach((ref, i) => {
+        cards.push({
+            id: `${topic.slug}-fc-reflection-${i}`,
+            front: ref,
+            back: `Consider ${topic.title} from a broader perspective. What changed in your understanding?`,
+            tags: ["reflection", topic.domain],
+            difficulty: "hard",
+            source: "transfer"
+        });
+    });
+    // Transfer card
+    if (topic.interdisciplinaryHooks.length > 0) {
+        cards.push({
+            id: `${topic.slug}-fc-transfer`,
+            front: `How does ${topic.title} connect to ${topic.interdisciplinaryHooks[0]}?`,
+            back: `Build an analogy that preserves structural relationships, not surface features.`,
+            tags: ["transfer", topic.domain],
+            difficulty: "hard",
+            source: "transfer"
+        });
+    }
+    return {
+        topic: topic.title,
+        slug: topic.slug,
+        generatedAt: new Date().toISOString(),
+        cards
+    };
+}
+export function flashcardsToMarkdown(deck) {
+    const lines = [
+        `# Flash Cards: ${deck.topic}`,
+        `> ${deck.cards.length} cards | Generated: ${deck.generatedAt}`,
+        ""
+    ];
+    for (const card of deck.cards) {
+        lines.push(`---`);
+        lines.push(`## ${card.id} [${card.difficulty}]`);
+        lines.push(`**Front:** ${card.front}`);
+        lines.push("");
+        lines.push(`**Back:** ${card.back}`);
+        if (card.mnemonic) {
+            lines.push(`**Mnemonic:** ${card.mnemonic}`);
+        }
+        lines.push(`*Tags:* ${card.tags.join(", ")}`);
+        lines.push("");
+    }
+    return lines.join("\n") + "\n";
+}
+/**
+ * Anki-compatible TSV export (front \t back).
+ */
+export function flashcardsToAnki(deck) {
+    const rows = deck.cards.map(c => {
+        const front = c.front.replace(/\t/g, " ");
+        const back = c.back.replace(/\t/g, " ");
+        return `${front}\t${back}`;
+    });
+    return rows.join("\n");
+}
+/**
+ * Mnemonics for selected topics.
+ */
+export function getMnemonic(topicName) {
+    const mnemonics = {
+        derivative: "DERIV-ative: Differential Equation Reveals Instant Velocity",
+        entropy: "ENTROPY: Energy Not Totally Recovered, Order Partially Yielded",
+        bayes: "BAYES: Beliefs Are Updated, Evidence Subtracts",
+        recursion: "RECURSION: Repeating Every Call Until Reaching Simple Initial-Case Output Now"
+    };
+    return mnemonics[topicName.toLowerCase()] ?? "";
+}

package/dist/src/core/learner-state.js

@@ -0,0 +1,108 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { clamp } from "./util.js";
+const DEFAULT_LEARNER_STATE = {
+    coveredTopics: [],
+    identifiedMisconceptions: [],
+    feedback: [],
+    sessions: [],
+    profile: {
+        id: "default",
+        priorKnowledge: 0.5,
+        abstractionComfort: 0.5,
+        analogyNeed: 0.5,
+        dialoguePreference: 0.5,
+        diagramAffinity: 0.5,
+        persistence: 0.5,
+        transferDesire: 0.5,
+        anxiety: 0.3
+    }
+};
+export async function loadLearnerState(filePath) {
+    // Read JSON from filePath. If file doesn't exist or is invalid, return default with id "learner-1"
+    try {
+        const raw = await readFile(filePath, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return { id: "learner-1", ...DEFAULT_LEARNER_STATE };
+    }
+}
+export async function saveLearnerState(filePath, state) {
+    await writeFile(filePath, JSON.stringify(state, null, 2), "utf8");
+}
+export function recordTopicCoverage(state, topic, masteryEstimate) {
+    const existing = state.coveredTopics.find(t => t.slug === topic.slug);
+    if (existing) {
+        existing.lastSeen = new Date().toISOString();
+        existing.masteryEstimate = clamp(masteryEstimate);
+        existing.sessionCount += 1;
+    }
+    else {
+        state.coveredTopics.push({
+            slug: topic.slug,
+            domain: topic.domain,
+            lastSeen: new Date().toISOString(),
+            masteryEstimate: clamp(masteryEstimate),
+            sessionCount: 1
+        });
+    }
+    return state;
+}
+export function recordMisconception(state, topic, misconception) {
+    const existing = state.identifiedMisconceptions.find(m => m.topic === topic && m.misconception === misconception);
+    if (!existing) {
+        state.identifiedMisconceptions.push({ topic, misconception, addressed: false });
+    }
+    return state;
+}
+export function recordFeedback(state, topic, signal, comment) {
+    state.feedback.push({
+        topic,
+        timestamp: new Date().toISOString(),
+        signal,
+        comment
+    });
+    return state;
+}
+export function recordSessionStart(state) {
+    if (!state.sessions)
+        state.sessions = [];
+    state.sessions.push({
+        startedAt: new Date().toISOString(),
+        topicsCovered: []
+    });
+    return state;
+}
+export function recordSessionEnd(state, topicsCovered) {
+    if (!state.sessions)
+        state.sessions = [];
+    const current = state.sessions[state.sessions.length - 1];
+    if (current && !current.endedAt) {
+        current.endedAt = new Date().toISOString();
+        current.topicsCovered = topicsCovered;
+    }
+    return state;
+}
+import { piCompleteJson } from "./pi-agent.js";
+export async function buildProfileFromFeedback(cwd, state) {
+    if (state.feedback.length === 0)
+        return { ...state.profile };
+    const prompt = `You are updating a learner's pedagogical profile based on their history.
+Current Profile: ${JSON.stringify(state.profile, null, 2)}
+Recent Feedback: ${JSON.stringify(state.feedback, null, 2)}
+Covered Topics: ${JSON.stringify(state.coveredTopics, null, 2)}
+
+Given this feedback, how should the learner's traits (priorKnowledge, abstractionComfort, analogyNeed, dialoguePreference, diagramAffinity, persistence, transferDesire, anxiety) be updated? Each trait is a scalar from 0.0 to 1.0. 
+Respond ONLY with a JSON object exactly matching the LearnerProfile schema (include all fields, even 'id'). Use thoughtful inferences. For example, if they are confused frequently, they may need more analogies and less abstraction. If they give thumbs-up on highly formal topics, they have high abstraction comfort.`;
+    try {
+        const updated = await piCompleteJson(cwd, prompt, { thinking: "low" });
+        return {
+            ...updated,
+            id: state.profile.id // Preserve ID
+        };
+    }
+    catch (error) {
+        console.error("Failed to dynamically update profile, falling back to current:", error);
+        return { ...state.profile };
+    }
+}

package/dist/src/core/lesson-plan.js

@@ -0,0 +1,155 @@
+import { resolveTopic } from "./topics.js";
+function prerequisiteBullets(topic) {
+    return topic.prerequisites.map((item) => `Recall ${item} and connect it to ${topic.title}.`);
+}
+function misconceptionBullets(topic) {
+    return topic.misconceptions.map((item) => `Address misconception: ${item}`);
+}
+function practiceBullets(topic, exerciseCount) {
+    const bullets = [...topic.exercises];
+    while (bullets.length < exerciseCount) {
+        bullets.push(`Invent a new example that makes ${topic.title} easier to explain.`);
+    }
+    return bullets.slice(0, exerciseCount).map((item) => `Practice: ${item}`);
+}
+export function buildLessonPlan(topicName, policy) {
+    const topic = resolveTopic(topicName);
+    const phases = [
+        {
+            id: "orient",
+            title: "Orientation",
+            purpose: "Assess prerequisites and frame the core question.",
+            bullets: [
+                `State the big question: ${topic.summary}`,
+                ...prerequisiteBullets(topic)
+            ]
+        },
+        {
+            id: "intuition",
+            title: "Intuition",
+            purpose: "Teach the concept concretely before pushing notation or abstract framing.",
+            bullets: topic.intuition.map((item) => `Intuition: ${item}`)
+        },
+        {
+            id: "formal-core",
+            title: "Formal Core",
+            purpose: "Escalate into rigorous structure once intuition has traction.",
+            bullets: topic.formalCore.map((item) => `Formal: ${item}`)
+        },
+        {
+            id: "misconceptions",
+            title: "Misconception Repair",
+            purpose: "Anticipate predictable mistakes before they calcify.",
+            bullets: misconceptionBullets(topic)
+        },
+        {
+            id: "examples",
+            title: "Worked Examples",
+            purpose: "Move between examples so the learner sees the invariant structure.",
+            bullets: topic.examples.map((item) => `Example: ${item}`)
+        },
+        {
+            id: "practice",
+            title: "Guided Practice",
+            purpose: "Force retrieval and re-expression, not passive agreement.",
+            bullets: practiceBullets(topic, policy.exerciseCount)
+        },
+        {
+            id: "transfer",
+            title: "Transfer and Reflection",
+            purpose: "Bridge the concept across domains and make the learner summarize what changed.",
+            bullets: [
+                ...topic.reflections.map((item) => `Reflect: ${item}`),
+                `Bridge ${topic.title} into: ${topic.interdisciplinaryHooks.join(", ")}.`
+            ]
+        }
+    ];
+    if (policy.diagramBias >= 0.55) {
+        phases.splice(4, 0, {
+            id: "diagram",
+            title: "Diagram",
+            purpose: "Compress the concept into a visual structure before free recall.",
+            bullets: [
+                `Map the concept using nodes: ${topic.diagramNodes.join(" -> ")}.`,
+                `Ask the learner to narrate the diagram without reading from it.`
+            ]
+        });
+    }
+    if (policy.socraticRatio >= 0.6) {
+        phases[0].bullets.unshift(`Open with a diagnostic question instead of a lecture on ${topic.title}.`);
+        phases[5].bullets.unshift(`Pause after each practice step and ask the learner to predict the next move.`);
+    }
+    // Domain-specific phase customizations
+    if (topic.domain === "code") {
+        const exIdx = phases.findIndex((p) => p.id === "examples");
+        if (exIdx !== -1) {
+            phases.splice(exIdx + 1, 0, {
+                id: "live-code",
+                title: "Live Code",
+                purpose: "Write and trace runnable code so the learner sees the concept execute.",
+                bullets: [
+                    `Write a minimal runnable example demonstrating ${topic.title}.`,
+                    `Step through execution line by line, narrating state changes.`,
+                    `Ask the learner to predict output before running.`
+                ]
+            });
+        }
+    }
+    if (topic.domain === "law") {
+        const examples = phases.find((p) => p.id === "examples");
+        if (examples) {
+            examples.bullets.push(`Cite at least one leading case or statute relevant to ${topic.title}.`, `Distinguish the ratio decidendi from obiter dicta.`);
+        }
+    }
+    if (topic.domain === "medicine") {
+        const formalCore = phases.find((p) => p.id === "formal-core");
+        if (formalCore) {
+            formalCore.bullets.push(`Reference the level of evidence (RCT, meta-analysis, observational) for key claims about ${topic.title}.`, `Distinguish mechanism-based reasoning from evidence-based conclusions.`);
+        }
+    }
+    if (topic.domain === "history") {
+        const examples = phases.find((p) => p.id === "examples");
+        if (examples) {
+            examples.bullets.push(`Place ${topic.title} on a timeline with at least two contextual events.`, `Distinguish primary sources from secondary interpretation.`);
+        }
+    }
+    if (topic.domain === "psychology") {
+        const misconceptions = phases.find((p) => p.id === "misconceptions");
+        if (misconceptions) {
+            misconceptions.bullets.push(`Flag the replication status of key studies related to ${topic.title}.`, `Distinguish folk-psychology usage from empirical findings.`);
+        }
+    }
+    if (topic.domain === "politics") {
+        const transfer = phases.find((p) => p.id === "transfer");
+        if (transfer) {
+            transfer.bullets.push(`Present at least two competing analytical frameworks for ${topic.title}.`, `Distinguish normative claims from descriptive ones.`);
+        }
+    }
+    if (topic.domain === "arts") {
+        const examples = phases.find((p) => p.id === "examples");
+        if (examples) {
+            examples.bullets.push(`Ground analysis in at least one specific work that exemplifies ${topic.title}.`, `Connect formal technique to expressive effect.`);
+        }
+    }
+    return { topic, policy, phases };
+}
+export function lessonPlanToMarkdown(plan) {
+    const lines = [
+        `# Lesson Plan: ${plan.topic.title}`,
+        "",
+        `- Domain: ${plan.topic.domain}`,
+        `- Policy: ${plan.policy.name}`,
+        `- Summary: ${plan.topic.summary}`,
+        ""
+    ];
+    for (const phase of plan.phases) {
+        lines.push(`## ${phase.title}`);
+        lines.push(phase.purpose);
+        lines.push("");
+        for (const bullet of phase.bullets) {
+            lines.push(`- ${bullet}`);
+        }
+        lines.push("");
+    }
+    return `${lines.join("\n").trim()}\n`;
+}