Profile inheritance update

README.md

@@ -1,26 +1,317 @@
 # Didactopus
 
-**Didactopus** is a local-first AI-assisted autodidactic mastery platform.
+**Didactopus** is a local‑first AI‑assisted autodidactic mastery platform designed to help motivated learners achieve **true expertise** in a chosen domain.
 
-This revision upgrades the evidence layer from a single weighted score to a **multi-dimensional mastery model**.
+The system combines:
 
-## Added in this revision
+• domain knowledge graphs  
+• mastery‑based learning models  
+• evidence‑driven assessment  
+• Socratic mentoring  
+• adaptive curriculum generation  
+• project‑based evaluation
 
-- per-concept mastery dimensions:
+Didactopus is designed for **serious learning**, not shallow answer generation.
+
+Its core philosophy is:
+
+> AI should function as a mentor, evaluator, and guide — not a substitute for thinking.
+
+---
+
+# Project Goals
+
+Didactopus aims to enable learners to:
+
+• build deep conceptual understanding  
+• practice reasoning and explanation  
+• complete real projects demonstrating competence  
+• identify weak areas through evidence‑based feedback  
+• progress through mastery rather than time spent
+
+The platform is particularly suitable for:
+
+• autodidacts  
+• researchers entering new fields  
+• students supplementing formal education  
+• interdisciplinary learners  
+• AI‑assisted self‑study programs
+
+---
+
+# Key Architectural Concepts
+
+## Domain Packs
+
+Knowledge is distributed as **domain packs** contributed by the community.
+
+Each pack can include:
+
+- concept definitions
+- prerequisite graphs
+- learning roadmaps
+- projects
+- rubrics
+- mastery profiles
+
+Example packs:
+
+```
+domain-packs/
+    statistics-foundations
+    bayes-extension
+    applied-inference
+```
+
+Domain packs are validated, dependency‑checked, and merged into a **unified learning graph**.
+
+---
+
+# Learning Graph
+
+Didactopus merges all installed packs into a directed concept graph:
+
+```
+Concept A → Concept B → Concept C
+```
+
+Edges represent prerequisites.
+
+The system then generates:
+
+• adaptive learning roadmaps  
+• next-best concepts to study  
+• projects unlocked by prerequisite completion
+
+---
+
+# Evidence‑Driven Mastery
+
+Concept mastery is **inferred from evidence**, not declared.
+
+Evidence types include:
+
+• explanations  
+• problem solutions  
+• transfer tasks  
+• project deliverables
+
+Evidence contributes weighted scores that determine:
+
+• mastery state  
+• learner confidence  
+• weak dimensions requiring further practice
+
+---
+
+# Multi‑Dimensional Mastery
+
+Didactopus tracks multiple competence dimensions:
+
+| Dimension | Meaning |
+|---|---|
+| correctness | accurate reasoning |
+| explanation | ability to explain clearly |
+| transfer | ability to apply knowledge |
+| project_execution | ability to build artifacts |
+| critique | ability to detect errors and assumptions |
+
+Different concepts can require different combinations of these dimensions.
+
+---
+
+# Concept Mastery Profiles
+
+Concepts define **mastery profiles** specifying:
+
+• required dimensions  
+• threshold overrides
+
+Example:
+
+```yaml
+mastery_profile:
+  required_dimensions:
+    - correctness
+    - transfer
+    - critique
+  dimension_threshold_overrides:
+    transfer: 0.8
+    critique: 0.8
+```
+
+---
+
+# Mastery Profile Inheritance
+
+This revision adds **profile templates** so packs can define reusable mastery models.
+
+Example:
+
+```yaml
+profile_templates:
+  foundation_concept:
+    required_dimensions:
       - correctness
       - explanation
+
+  critique_concept:
+    required_dimensions:
+      - correctness
       - transfer
-  - project_execution
       - critique
-- weighted, recency-aware dimension summaries
+```
-- per-dimension mastery thresholds
-- concept-level mastery determined from all required dimensions
-- dimension-specific weakness reporting
-- adaptive next-step selection informed by weak dimensions
-- tests for multi-dimensional mastery promotion and partial weakness detection
 
-## Why this matters
+Concepts can reference templates:
 
-Real mastery is not one scalar.
+```yaml
+mastery_profile:
+  template: critique_concept
+```
 
-A learner can be strong at routine correctness and still be weak at transfer, explanation, or critique. This revision lets Didactopus represent that distinction explicitly.
+This allows domain packs to remain concise while maintaining consistent evaluation standards.
+
+---
+
+# Adaptive Learning Engine
+
+The adaptive engine computes:
+
+• which concepts are ready to study  
+• which are blocked by prerequisites  
+• which are already mastered  
+• which projects are available
+
+Output includes:
+
+```
+next_best_concepts
+eligible_projects
+adaptive_learning_roadmap
+```
+
+---
+
+# Evidence Engine
+
+The evidence engine:
+
+• aggregates learner evidence  
+• computes weighted scores  
+• tracks confidence  
+• identifies weak competence dimensions  
+• updates mastery status
+
+Later weak performance can **resurface concepts for review**.
+
+---
+
+# Socratic Mentor
+
+Didactopus includes a mentor layer that:
+
+• asks probing questions  
+• challenges reasoning  
+• generates practice tasks  
+• proposes projects
+
+Models can run locally (recommended) or via remote APIs.
+
+---
+
+# Agentic AI Students
+
+Didactopus is also suitable for **AI‑driven learning agents**.
+
+A future architecture may include:
+
+```
+Didactopus Core
+       │
+       ├─ Human Learner
+       └─ AI Student Agent
+```
+
+An AI student could:
+
+1. read domain packs
+2. attempt practice tasks
+3. produce explanations
+4. critique model outputs
+5. complete simulated projects
+6. accumulate evidence
+7. progress through the mastery graph
+
+Such agents could be used for:
+
+• automated curriculum testing  
+• benchmarking AI reasoning  
+• synthetic expert generation  
+• evaluation of model capabilities
+
+Didactopus therefore supports both:
+
+• human learners  
+• agentic AI learners
+
+---
+
+# Project Structure
+
+```
+didactopus/
+    adaptive_engine/
+    artifact_registry/
+    evidence_engine/
+    learning_graph/
+    mentor/
+    practice/
+    project_advisor/
+```
+
+Additional directories:
+
+```
+configs/
+docs/
+domain-packs/
+tests/
+artwork/
+```
+
+---
+
+# Current Status
+
+Implemented:
+
+✓ domain pack validation  
+✓ dependency resolution  
+✓ learning graph merge  
+✓ adaptive roadmap generation  
+✓ evidence‑driven mastery  
+✓ multi‑dimensional competence tracking  
+✓ concept‑specific mastery profiles  
+✓ profile template inheritance
+
+Planned next phases:
+
+• curriculum optimization algorithms  
+• active‑learning task generation  
+• automated project evaluation  
+• distributed pack registry  
+• visualization tools for learning graphs
+
+---
+
+# Philosophy
+
+Didactopus is built around a simple principle:
+
+> Mastery requires thinking, explaining, testing, and building — not merely receiving answers.
+
+AI can accelerate the process, but genuine learning remains an **active intellectual endeavor**.
+
+---
+
+**Didactopus — many arms, one goal: mastery.**

docs/profile-inheritance.md

@@ -0,0 +1,26 @@
+# Mastery Profile Templates
+
+Domain packs can define reusable mastery profiles.
+
+Example:
+
+```
+profile_templates:
+  foundation_concept:
+    required_dimensions:
+      - correctness
+      - explanation
+
+  critique_concept:
+    required_dimensions:
+      - correctness
+      - transfer
+      - critique
+```
+Concepts can reference templates:
+
+```
+mastery_profile:
+  template: critique_concept
+```
+Concepts may still override thresholds or required dimensions.

src/didactopus/profile_templates.py

@@ -0,0 +1,34 @@
+from dataclasses import dataclass
+from typing import Dict, List
+
+
+@dataclass
+class ProfileTemplate:
+    name: str
+    required_dimensions: List[str]
+    dimension_threshold_overrides: Dict[str, float]
+
+
+def resolve_mastery_profile(concept_profile, templates, default_profile):
+    if concept_profile is None:
+        return default_profile
+
+    template_name = concept_profile.get("template")
+    if template_name:
+        base = templates.get(template_name, default_profile)
+        profile = {
+            "required_dimensions": list(base.required_dimensions),
+            "dimension_threshold_overrides": dict(base.dimension_threshold_overrides),
+        }
+    else:
+        profile = default_profile.copy()
+
+    if "required_dimensions" in concept_profile:
+        profile["required_dimensions"] = concept_profile["required_dimensions"]
+
+    if "dimension_threshold_overrides" in concept_profile:
+        profile["dimension_threshold_overrides"].update(
+            concept_profile["dimension_threshold_overrides"]
+        )
+
+    return profile