keating 0.3.6

package/dist/src/core/map-elites.js

@@ -0,0 +1,228 @@
+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";
+export const DEFAULT_DESCRIPTORS = ["formalism", "socraticRatio"];
+export const DEFAULT_RESOLUTION = 10;
+function mutateScalar(prng, value, amplitude = 0.18) {
+    return clamp(value + (prng.next() * 2 - 1) * amplitude);
+}
+function mutatePolicy(parent, prng, iteration) {
+    return clampPolicy({
+        ...parent,
+        name: `me-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)
+    });
+}
+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 getDescriptorValues(policy, descriptors) {
+    return descriptors.map((d) => {
+        const val = policy[d];
+        return typeof val === "number" ? val : 0;
+    });
+}
+function cellKey(descriptors, resolution) {
+    return descriptors
+        .map((d) => Math.min(Math.floor(d * resolution), resolution - 1))
+        .join(",");
+}
+export function createGrid(descriptors, resolution) {
+    return {
+        descriptors,
+        resolution,
+        cells: new Map()
+    };
+}
+export function placeInGrid(grid, policy, weights, score, benchmark, iteration) {
+    const descVals = getDescriptorValues(policy, grid.descriptors);
+    const key = cellKey(descVals, grid.resolution);
+    const existing = grid.cells.get(key);
+    if (!existing || score > existing.score) {
+        grid.cells.set(key, { policy, weights, score, benchmark, iteration });
+        return !existing;
+    }
+    return false;
+}
+function selectParent(grid, prng) {
+    const filled = Array.from(grid.cells.values()).filter((c) => c !== null);
+    if (filled.length === 0) {
+        return { policy: DEFAULT_POLICY, weights: DEFAULT_WEIGHTS };
+    }
+    const idx = Math.floor(prng.next() * filled.length);
+    return { policy: filled[idx].policy, weights: filled[idx].weights };
+}
+function randomPolicy(prng, iteration) {
+    return clampPolicy({
+        name: `me-random-${iteration}`,
+        analogyDensity: prng.next(),
+        socraticRatio: prng.next(),
+        formalism: prng.next(),
+        retrievalPractice: prng.next(),
+        exerciseCount: Math.round(1 + prng.next() * 4),
+        diagramBias: prng.next(),
+        reflectionBias: prng.next(),
+        interdisciplinaryBias: prng.next(),
+        challengeRate: prng.next()
+    });
+}
+function randomWeights(prng) {
+    return clampWeights({
+        masteryGain: 0.1 + prng.next() * 0.9,
+        retention: 0.1 + prng.next() * 0.9,
+        engagement: 0.1 + prng.next() * 0.9,
+        transfer: 0.1 + prng.next() * 0.9,
+        confusion: 0.1 + prng.next() * 0.9
+    });
+}
+export async function mapElitesEvolve(cwd, basePolicy, options = {}) {
+    const { iterations = 48, seed = 20260401, descriptors = DEFAULT_DESCRIPTORS, resolution = DEFAULT_RESOLUTION, focusTopic, initRandom = Math.floor(iterations * 0.25) } = options;
+    const prng = new Prng(seed);
+    const grid = createGrid(descriptors, resolution);
+    const totalCells = resolution ** descriptors.length;
+    const baseline = await runBenchmarkSuite(cwd, basePolicy, focusTopic, seed, 3, DEFAULT_WEIGHTS);
+    placeInGrid(grid, basePolicy, DEFAULT_WEIGHTS, baseline.overallScore, baseline, 0);
+    const exploredCandidates = [];
+    for (let i = 1; i <= iterations; i++) {
+        let candidatePolicy;
+        let candidateWeights;
+        if (i <= initRandom) {
+            candidatePolicy = randomPolicy(prng, i);
+            candidateWeights = randomWeights(prng);
+        }
+        else {
+            const parent = selectParent(grid, prng);
+            candidatePolicy = mutatePolicy(parent.policy, prng, i);
+            candidateWeights = mutateWeights(parent.weights, prng);
+        }
+        const candidateBenchmark = await runBenchmarkSuite(cwd, candidatePolicy, focusTopic, seed + i * 11, 3, candidateWeights);
+        const isNewCell = placeInGrid(grid, candidatePolicy, candidateWeights, candidateBenchmark.overallScore, candidateBenchmark, i);
+        exploredCandidates.push({
+            policy: candidatePolicy,
+            benchmark: candidateBenchmark,
+            parentName: null,
+            iteration: i,
+            novelty: isNewCell ? 1 : 0,
+            accepted: isNewCell,
+            decision: {
+                improves: isNewCell,
+                safe: true,
+                novelEnough: isNewCell,
+                scoreDelta: 0,
+                weakestTopicDelta: 0,
+                reasons: isNewCell
+                    ? [`placed in new cell or improved existing cell (score ${candidateBenchmark.overallScore.toFixed(2)})`]
+                    : [`discarded — cell already held a better elite`]
+            },
+            parameterDelta: []
+        });
+    }
+    let best = baseline;
+    for (const cell of grid.cells.values()) {
+        if (cell && cell.benchmark.overallScore > best.overallScore) {
+            best = cell.benchmark;
+        }
+    }
+    return {
+        baseline,
+        best,
+        grid,
+        filledCellCount: grid.cells.size,
+        totalCells,
+        exploredCandidates
+    };
+}
+export function mapElitesToMarkdown(run) {
+    const lines = [
+        "# MAP-Elites Evolution Report",
+        "",
+        `- Descriptors: ${run.grid.descriptors.join(" × ")}`,
+        `- Grid: ${run.grid.resolution}^${run.grid.descriptors.length} = ${run.totalCells} cells`,
+        `- Filled cells: ${run.filledCellCount} / ${run.totalCells} (${((run.filledCellCount / run.totalCells) * 100).toFixed(1)}%)`,
+        `- Baseline score: ${run.baseline.overallScore.toFixed(2)}`,
+        `- Best score: ${run.best.overallScore.toFixed(2)}`,
+        `- Explored candidates: ${run.exploredCandidates.length}`,
+        ""
+    ];
+    lines.push("## Elite Archive");
+    lines.push("");
+    const sorted = Array.from(run.grid.cells.entries())
+        .sort(([a], [b]) => a.localeCompare(b));
+    const header = run.grid.descriptors.map((d, i) => `${d}[${i}]`).join(" | ");
+    lines.push(`| ${header} | Policy | Score | Weights (m/r/e/t/c) |`);
+    lines.push(`| ${run.grid.descriptors.map(() => "---").join(" | ")} | --- | ---: | --- |`);
+    for (const [key, cell] of sorted) {
+        if (!cell)
+            continue;
+        const indices = key.split(",").map(Number);
+        const labels = indices.map((idx, i) => {
+            const lo = (idx / run.grid.resolution).toFixed(2);
+            const hi = ((idx + 1) / run.grid.resolution).toFixed(2);
+            return `${lo}–${hi}`;
+        }).join(" | ");
+        const w = cell.weights;
+        lines.push(`| ${labels} | ${cell.policy.name} | ${cell.score.toFixed(2)} | ${w.masteryGain.toFixed(2)}/${w.retention.toFixed(2)}/${w.engagement.toFixed(2)}/${w.transfer.toFixed(2)}/${w.confusion.toFixed(2)} |`);
+    }
+    lines.push("");
+    lines.push("## Best Benchmark Snapshot");
+    lines.push("");
+    lines.push(benchmarkToMarkdown(run.best).trim());
+    lines.push("");
+    return `${lines.join("\n")}\n`;
+}
+export async function loadMapElitesGrid(filePath, descriptors, resolution) {
+    try {
+        const content = await readFile(filePath, "utf8");
+        const data = JSON.parse(content);
+        const grid = createGrid(descriptors, resolution);
+        for (const [key, cell] of Object.entries(data.cells ?? {})) {
+            grid.cells.set(key, cell);
+        }
+        return grid;
+    }
+    catch {
+        return createGrid(descriptors, resolution);
+    }
+}
+export async function saveMapElitesGrid(filePath, grid) {
+    const serializable = {};
+    for (const [key, cell] of grid.cells.entries()) {
+        serializable[key] = cell;
+    }
+    await writeFile(filePath, `${JSON.stringify({ descriptors: grid.descriptors, resolution: grid.resolution, cells: serializable }, null, 2)}\n`, "utf8");
+}
+export function mapElitesToEvolutionRun(run) {
+    return {
+        baseline: run.baseline,
+        best: run.best,
+        acceptedCandidates: run.exploredCandidates.filter((c) => c.accepted),
+        exploredCandidates: run.exploredCandidates,
+        archive: {
+            currentPolicy: run.best.policy,
+            bestScore: run.best.overallScore,
+            candidates: run.exploredCandidates.map((c) => ({
+                policy: c.policy,
+                score: c.benchmark.overallScore,
+                novelty: c.novelty,
+                accepted: c.accepted,
+                iteration: c.iteration
+            }))
+        }
+    };
+}

package/dist/src/core/map.js

@@ -0,0 +1,89 @@
+import { spawnSync } from "node:child_process";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { buildLessonPlan } from "./lesson-plan.js";
+import { mapsDir } from "./paths.js";
+import { slugify } from "./util.js";
+function mermaidLabel(text) {
+    return text.replaceAll('"', "'").replaceAll("\n", " ");
+}
+export function lessonPlanToMermaid(topicName, policy) {
+    const plan = buildLessonPlan(topicName, policy);
+    const topicId = slugify(plan.topic.title);
+    const lines = [
+        "graph TD",
+        "  classDef phase fill:#12263f,stroke:#8db5ff,color:#f8f5ec,stroke-width:1px;",
+        "  classDef concept fill:#173122,stroke:#8fd7b6,color:#f8f5ec,stroke-width:1px;",
+        "  classDef friction fill:#3a2317,stroke:#ff9b6b,color:#f8f5ec,stroke-width:1px;",
+        "  classDef transfer fill:#2f2140,stroke:#d3a6ff,color:#f8f5ec,stroke-width:1px;",
+        `  learner(("Learner state"))`,
+        `  thesis["${mermaidLabel(plan.topic.title)}: ${mermaidLabel(plan.topic.summary)}"]`
+    ];
+    lines.push('  subgraph pedagogy["Teaching Loop"]');
+    for (const phase of plan.phases) {
+        lines.push(`    ${phase.id}["${mermaidLabel(phase.title)}"]`);
+    }
+    for (let index = 0; index < plan.phases.length - 1; index += 1) {
+        lines.push(`    ${plan.phases[index].id} --> ${plan.phases[index + 1].id}`);
+    }
+    lines.push("  end");
+    lines.push('  subgraph meaning["Meaning Map"]');
+    lines.push(`    ${topicId}_core["${mermaidLabel(plan.topic.title)}"]`);
+    for (const [index, node] of plan.topic.diagramNodes.entries()) {
+        lines.push(`    ${topicId}_concept_${index}["${mermaidLabel(node)}"]`);
+        lines.push(`    ${topicId}_core --> ${topicId}_concept_${index}`);
+    }
+    for (const [index, prerequisite] of plan.topic.prerequisites.slice(0, 3).entries()) {
+        lines.push(`    ${topicId}_prereq_${index}["Prereq: ${mermaidLabel(prerequisite)}"]`);
+        lines.push(`    ${topicId}_prereq_${index} --> ${topicId}_core`);
+    }
+    lines.push("  end");
+    lines.push('  subgraph friction["Misconceptions And Practice"]');
+    for (const [index, misconception] of plan.topic.misconceptions.slice(0, 2).entries()) {
+        lines.push(`    ${topicId}_mis_${index}["${mermaidLabel(misconception)}"]`);
+        lines.push(`    ${topicId}_core --> ${topicId}_mis_${index}`);
+    }
+    for (const [index, exercise] of plan.topic.exercises.slice(0, 2).entries()) {
+        lines.push(`    ${topicId}_exercise_${index}["Practice: ${mermaidLabel(exercise)}"]`);
+        lines.push(`    ${topicId}_mis_${Math.min(index, Math.max(plan.topic.misconceptions.length - 1, 0))} --> ${topicId}_exercise_${index}`);
+    }
+    lines.push("  end");
+    lines.push('  subgraph transfer["Transfer Hooks"]');
+    for (const [index, hook] of plan.topic.interdisciplinaryHooks.entries()) {
+        lines.push(`    ${topicId}_hook_${index}["${mermaidLabel(hook)}"]`);
+        lines.push(`    ${topicId}_core --> ${topicId}_hook_${index}`);
+    }
+    lines.push("  end");
+    lines.push("  learner --> orient");
+    lines.push("  thesis --> orient");
+    lines.push(`  ${plan.phases.at(-1).id} --> ${topicId}_hook_0`);
+    lines.push(`  ${plan.phases.find((phase) => phase.id === "diagram")?.id ?? "examples"} --> ${topicId}_core`);
+    lines.push(`  class ${plan.phases.map((phase) => phase.id).join(",")} phase;`);
+    lines.push(`  class ${topicId}_core,${plan.topic.diagramNodes.map((_, index) => `${topicId}_concept_${index}`).join(",")},${plan.topic.prerequisites.slice(0, 3).map((_, index) => `${topicId}_prereq_${index}`).join(",")} concept;`);
+    const frictionNodes = [
+        ...plan.topic.misconceptions.slice(0, 2).map((_, index) => `${topicId}_mis_${index}`),
+        ...plan.topic.exercises.slice(0, 2).map((_, index) => `${topicId}_exercise_${index}`)
+    ];
+    if (frictionNodes.length > 0) {
+        lines.push(`  class ${frictionNodes.join(",")} friction;`);
+    }
+    const transferNodes = plan.topic.interdisciplinaryHooks.map((_, index) => `${topicId}_hook_${index}`);
+    if (transferNodes.length > 0) {
+        lines.push(`  class ${transferNodes.join(",")} transfer;`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+export async function writeLessonMap(cwd, topicName, policy) {
+    const slug = slugify(topicName);
+    const mmdPath = join(mapsDir(cwd), `${slug}.mmd`);
+    const svgPath = join(mapsDir(cwd), `${slug}.svg`);
+    await writeFile(mmdPath, lessonPlanToMermaid(topicName, policy), "utf8");
+    const render = spawnSync("oxdraw", ["--input", mmdPath, "--output", svgPath], {
+        cwd,
+        encoding: "utf8"
+    });
+    if (render.status === 0) {
+        return { mmdPath, svgPath };
+    }
+    return { mmdPath, svgPath: null };
+}

package/dist/src/core/mastery.js

@@ -0,0 +1,207 @@
+/**
+ * Mastery Assessment Engine
+ *
+ * Generates multi-level diagnostic questions, scores learner responses,
+ * and produces a mastery report with per-dimension breakdown.
+ */
+import { resolveTopic } from "./topics.js";
+import { clamp } from "./util.js";
+export function generateDiagnosticQuestions(topic) {
+    const questions = [];
+    // Recall level (Blooms taxonomy L1)
+    questions.push({
+        id: `${topic.slug}-q1`,
+        level: "recall",
+        question: `State the definition of "${topic.title}" in your own words.`,
+        rubric: `1pt: attempts definition. 2pts: core elements present. 3pts: precise, recognizes nuance. Max ${3} points.`,
+        maxPoints: 3
+    });
+    // Recall from formal core
+    questions.push({
+        id: `${topic.slug}-q2`,
+        level: "recall",
+        question: `What are the key prerequisites needed before a learner can grasp ${topic.title}?`,
+        rubric: `1pt: mentions prerequisites. 2pts: explains connection. 3pts: correct full list. Max ${3} points.`,
+        maxPoints: 3
+    });
+    // Comprehension (Bloom L2)
+    const intuitionHook = topic.intuition[0] ?? "the core idea";
+    questions.push({
+        id: `${topic.slug}-q3`,
+        level: "comprehension",
+        question: `Explain why "${intuitionHook}" is a useful way to think about ${topic.title}.`,
+        rubric: `1pt: repeats hook. 2pts: connects to structure. 3pts: sees limitations and when it breaks. Max ${3} points.`,
+        maxPoints: 3
+    });
+    // Common misconception
+    const misconception = topic.misconceptions[0] ?? "the common error";
+    questions.push({
+        id: `${topic.slug}-q4`,
+        level: "comprehension",
+        question: `Many learners think: "${misconception}". Explain why this is incorrect.`,
+        rubric: `1pt: says it is wrong. 2pts: identifies the subtle issue. 3pts: gives a counterexample. Max ${3} points.`,
+        maxPoints: 3
+    });
+    // Application (Bloom L3)
+    const example = topic.examples[0] ?? "a basic scenario";
+    questions.push({
+        id: `${topic.slug}-q5`,
+        level: "application",
+        question: `Apply ${topic.title} to a new situation: ${example}`,
+        rubric: `1pt: attempts application. 2pts: correct mechanics, minor gaps. 3pts: fully correct with explanation. Max ${3} points.`,
+        maxPoints: 3
+    });
+    // Transfer (Bloom L5)
+    const hook = topic.interdisciplinaryHooks[0] ?? "another field";
+    questions.push({
+        id: `${topic.slug}-q6`,
+        level: "transfer",
+        question: `How might ${topic.title} be relevant in ${hook}? Construct an analogy.`,
+        rubric: `1pt: mentions connection. 2pts: coherent analogy. 3pts: analogy holds under scrutiny. Max ${3} points.`,
+        maxPoints: 3
+    });
+    return questions;
+}
+function classifyLevel(score, max) {
+    const ratio = score / max;
+    if (ratio >= 0.9)
+        return "expert";
+    if (ratio >= 0.7)
+        return "proficient";
+    if (ratio >= 0.5)
+        return "competent";
+    if (ratio >= 0.3)
+        return "beginner";
+    return "novice";
+}
+/**
+ * Score an answer heuristically (0–maxPoints).
+ * In practice an LLM should do this, but this provides deterministic defaults.
+ */
+export function scoreAnswer(question, answer) {
+    const trimmed = answer.trim();
+    if (trimmed.length === 0)
+        return 0;
+    if (trimmed.length < 20)
+        return 1; // Very short
+    // Medium-fidelity heuristic: longer + key topic words = higher
+    const topicWords = question.question.toLowerCase().split(/[^a-z]+/).filter(w => w.length > 3);
+    const matches = topicWords.filter(w => trimmed.toLowerCase().includes(w)).length;
+    const ratio = matches / Math.max(1, topicWords.length);
+    if (ratio > 0.5 && trimmed.length > 100)
+        return question.maxPoints;
+    if (ratio > 0.3 && trimmed.length > 50)
+        return Math.min(question.maxPoints, 2);
+    return Math.min(question.maxPoints, 2);
+}
+export function computeMasteryAssessment(topicName, answers) {
+    const topic = resolveTopic(topicName);
+    const questions = generateDiagnosticQuestions(topic);
+    const dimensions = [];
+    const gaps = [];
+    const strengths = [];
+    let totalScore = 0;
+    let totalMax = 0;
+    // Group by level
+    const levelGroups = {
+        recall: "Factual Recall",
+        comprehension: "Conceptual Understanding",
+        application: "Application",
+        analysis: "Analysis",
+        transfer: "Transfer"
+    };
+    for (const [level, dimName] of Object.entries(levelGroups)) {
+        const levelQs = questions.filter(q => q.level === level);
+        if (levelQs.length === 0)
+            continue;
+        let dimScore = 0;
+        let dimMax = 0;
+        const dimQuestions = [];
+        for (const q of levelQs) {
+            const answer = answers[q.id] ?? "";
+            const score = scoreAnswer(q, answer);
+            dimScore += score;
+            dimMax += q.maxPoints;
+            dimQuestions.push(q);
+        }
+        totalScore += dimScore;
+        totalMax += dimMax;
+        const recs = [];
+        const ratio = dimMax > 0 ? dimScore / dimMax : 0;
+        if (ratio < 0.5) {
+            recs.push(`Strengthen ${dimName.toLowerCase()} through targeted practice.`);
+            gaps.push(dimName);
+        }
+        else if (ratio >= 0.8) {
+            strengths.push(dimName);
+        }
+        dimensions.push({
+            name: dimName,
+            score: dimScore,
+            maxScore: dimMax,
+            questions: dimQuestions,
+            recommendations: recs
+        });
+    }
+    const overall = clamp(totalScore / Math.max(1, totalMax), 0, 1);
+    const nextSteps = [];
+    if (gaps.length > 0) {
+        nextSteps.push(`Focus on: ${gaps.join(", ")}.`);
+    }
+    if (strengths.length > 0) {
+        nextSteps.push(`Your strengths (${strengths.join(", ")}) are solid — leverage them for harder transfer problems.`);
+    }
+    if (gaps.length === 0 && strengths.length === dimensions.length) {
+        nextSteps.push("You score highly across all dimensions. Try synthesis-level questions or teach the topic to someone else.");
+    }
+    return {
+        topic: topic.title,
+        overallScore: totalScore,
+        maxScore: totalMax,
+        level: classifyLevel(totalScore, totalMax),
+        dimensions,
+        gaps,
+        strengths,
+        nextSteps
+    };
+}
+export function masteryAssessmentToMarkdown(ass) {
+    const lines = [
+        `# Mastery Assessment: ${ass.topic}`,
+        "",
+        `**Level**: ${ass.level.toUpperCase()} (${((ass.overallScore / ass.maxScore) * 100).toFixed(1)}%)`,
+        `**Score**: ${ass.overallScore} / ${ass.maxScore}`,
+        ""
+    ];
+    lines.push("## Dimension Breakdown");
+    lines.push("");
+    for (const d of ass.dimensions) {
+        const pct = ((d.score / d.maxScore) * 100).toFixed(0);
+        lines.push(`### ${d.name}: ${d.score}/${d.maxScore} (${pct}%)`);
+        for (const q of d.questions) {
+            lines.push(`- **${q.id}** (${q.level}): ${q.question}`);
+            lines.push(`  - Rubric: ${q.rubric}`);
+        }
+        if (d.recommendations.length > 0) {
+            lines.push(`  - *Recommendation:* ${d.recommendations[0]}`);
+        }
+        lines.push("");
+    }
+    if (ass.gaps.length > 0) {
+        lines.push("## Gaps Identified");
+        for (const g of ass.gaps)
+            lines.push(`- ${g}`);
+        lines.push("");
+    }
+    if (ass.strengths.length > 0) {
+        lines.push("## Strengths");
+        for (const s of ass.strengths)
+            lines.push(`- ${s}`);
+        lines.push("");
+    }
+    lines.push("## Next Steps");
+    for (const ns of ass.nextSteps)
+        lines.push(`- ${ns}`);
+    lines.push("");
+    return lines.join("\n");
+}

package/dist/src/core/paths.js

@@ -0,0 +1,100 @@
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+export function keatingRoot(cwd) {
+    return join(cwd, ".keating");
+}
+export function stateDir(cwd) {
+    return join(keatingRoot(cwd), "state");
+}
+export function outputsDir(cwd) {
+    return join(keatingRoot(cwd), "outputs");
+}
+export function plansDir(cwd) {
+    return join(outputsDir(cwd), "plans");
+}
+export function mapsDir(cwd) {
+    return join(outputsDir(cwd), "maps");
+}
+export function animationsDir(cwd) {
+    return join(outputsDir(cwd), "animations");
+}
+export function benchmarksDir(cwd) {
+    return join(outputsDir(cwd), "benchmarks");
+}
+export function evolutionDir(cwd) {
+    return join(outputsDir(cwd), "evolution");
+}
+export function promptEvolutionDir(cwd) {
+    return join(outputsDir(cwd), "prompt-evolution");
+}
+export function tracesDir(cwd) {
+    return join(outputsDir(cwd), "traces");
+}
+export function sessionsDir(cwd) {
+    return join(keatingRoot(cwd), "sessions");
+}
+export function configDir(cwd) {
+    return join(keatingRoot(cwd), "pi-config");
+}
+export function currentPolicyPath(cwd) {
+    return join(stateDir(cwd), "current-policy.json");
+}
+export function policyArchivePath(cwd) {
+    return join(stateDir(cwd), "policy-archive.json");
+}
+export function promptEvolutionArchivePath(cwd) {
+    return join(stateDir(cwd), "prompt-evolution-archive.json");
+}
+export function learnerStatePath(cwd) {
+    return join(stateDir(cwd), "learner.json");
+}
+export function verificationsDir(cwd) {
+    return join(outputsDir(cwd), "verifications");
+}
+export function verificationCachePath(cwd) {
+    return join(stateDir(cwd), "verification-cache.json");
+}
+export function engagementPolicyPath(cwd) {
+    return join(stateDir(cwd), "engagement-policy.json");
+}
+export function timelineDir(cwd) {
+    return join(outputsDir(cwd), "timelines");
+}
+export function quizDir(cwd) {
+    return join(outputsDir(cwd), "quizzes");
+}
+export function flashcardsDir(cwd) {
+    return join(outputsDir(cwd), "flashcards");
+}
+export function projectsDir(cwd) {
+    return join(outputsDir(cwd), "projects");
+}
+export function masteryDir(cwd) {
+    return join(outputsDir(cwd), "mastery");
+}
+export function workbooksDir(cwd) {
+    return join(outputsDir(cwd), "workbooks");
+}
+export async function ensureKeatingDirs(cwd) {
+    await Promise.all([
+        mkdir(stateDir(cwd), { recursive: true }),
+        mkdir(join(stateDir(cwd), "snapshots"), { recursive: true }),
+        mkdir(plansDir(cwd), { recursive: true }),
+        mkdir(mapsDir(cwd), { recursive: true }),
+        mkdir(animationsDir(cwd), { recursive: true }),
+        mkdir(benchmarksDir(cwd), { recursive: true }),
+        mkdir(evolutionDir(cwd), { recursive: true }),
+        mkdir(promptEvolutionDir(cwd), { recursive: true }),
+        mkdir(tracesDir(cwd), { recursive: true }),
+        mkdir(verificationsDir(cwd), { recursive: true }),
+        mkdir(join(outputsDir(cwd), "improvements"), { recursive: true }),
+        mkdir(sessionsDir(cwd), { recursive: true }),
+        mkdir(timelineDir(cwd), { recursive: true }),
+        mkdir(quizDir(cwd), { recursive: true }),
+        mkdir(flashcardsDir(cwd), { recursive: true }),
+        mkdir(projectsDir(cwd), { recursive: true }),
+        mkdir(masteryDir(cwd), { recursive: true }),
+        mkdir(workbooksDir(cwd), { recursive: true }),
+        mkdir(configDir(cwd), { recursive: true })
+    ]);
+}