clawed 2.3.2__tar.gz → 2.3.4__tar.gz

{clawed-2.3.2 → clawed-2.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clawed
-Version: 2.3.2
+Version: 2.3.4
 Summary: Claw-ED — personal AI teaching agent. Learns your voice, works while you sleep.
 Project-URL: Homepage, https://github.com/SirhanMacx/Claw-ED
 Project-URL: Documentation, https://github.com/SirhanMacx/Claw-ED#readme

{clawed-2.3.2 → clawed-2.3.4}/clawed/__init__.py

@@ -17,7 +17,7 @@ if hasattr(sys.stderr, "reconfigure"):
     except Exception:
         pass
 
-__version__ = "2.3.2"
+__version__ = "2.3.4"
 __author__ = "Jon Maccarello & Claw-ED contributors"
 __description__ = "Personal AI teaching agent. Learns your voice, works while you sleep."
 

{clawed-2.3.2 → clawed-2.3.4}/clawed/agent_core/prompt.py

@@ -91,7 +91,11 @@ def build_system_prompt(
         "  'Building your lesson package now — plan, handout, and slides coming up.'\n"
         "The teacher should always know you're working, not stuck.\n"
         "1. Read SOUL.md to know your voice and values\n"
-        "2. Search the teacher's curriculum files for relevant prior work\n"
+        "2. **MANDATORY: Before calling generate_lesson_bundle, ALWAYS call "
+        "search_my_materials first** with the lesson topic. This is non-negotiable. "
+        "The teacher has uploaded materials — if you skip this step, you will "
+        "generate generic content instead of building on their prior work. "
+        "Tell the teacher what you found before generating.\n"
         "3. Generate complete packages (lesson plan + student handout + slideshow) "
         "using generate_lesson_bundle\n"
         "4. Never ask 'want me to create materials?' -- just create them\n"

{clawed-2.3.2 → clawed-2.3.4}/clawed/agent_core/tools/generate_lesson_bundle.py

@@ -22,7 +22,10 @@ class GenerateLessonBundleTool:
                 "description": (
                     "Generate a COMPLETE teaching package for a topic: "
                     "a lesson plan (DOCX), a student handout (DOCX), and "
-                    "a slideshow (PPTX). All three files are created at once."
+                    "a slideshow (PPTX). All three files are created at once. "
+                    "IMPORTANT: Always call search_my_materials FIRST to find "
+                    "the teacher's existing materials on this topic before "
+                    "calling this tool."
                 ),
                 "parameters": {
                     "type": "object",
@@ -232,6 +235,23 @@ class GenerateLessonBundleTool:
         except Exception:
             pass  # Review is best-effort, don't block on failure
 
+        # ── Voice validation ──────────────────────────────────────────
+        voice_notes: list[str] = []
+        try:
+            from clawed.voice_check import check_voice_match
+
+            voice_result = check_voice_match(
+                persona=persona,
+                do_now=lesson.do_now,
+                direct_instruction_opening=lesson.direct_instruction[:500] if lesson.direct_instruction else "",
+            )
+            if not voice_result.passed:
+                for issue in voice_result.issues:
+                    voice_notes.append(issue)
+                    logger.info("Voice check issue: %s", issue)
+        except Exception as e:
+            logger.debug("Voice check failed: %s", e)
+
         # ── Generate student packet + admin plan in parallel ──────────
         import asyncio
 
@@ -323,19 +343,57 @@ class GenerateLessonBundleTool:
             logger.error("PPTX export failed: %s", e)
             errors.append(f"Slideshow PPTX failed: {e}")
 
-        # ── Build response ───────────────────────────────────────────
-        lines = [f"Generated teaching package for: {lesson.title}\n"]
-        if generated_files:
-            lines.append("Files created:")
-            for f in generated_files:
-                lines.append(f"  - {f}")
-        if kb_context:
-            lines.append("\nReferenced your existing materials on this topic.")
-        if errors:
-            lines.append("\nErrors:")
+        # ── Build honest response ─────────────────────────────────────
+        used_fallback_packet = not student_packet and any("Student packet" in s for s in side_effects)
+
+        lines = []
+
+        if len(generated_files) == 3 and not errors:
+            lines.append(f"Complete teaching package for: {lesson.title}")
+            lines.append("All three files ready to print:")
+            for se in side_effects:
+                lines.append(f"  - {se}")
+        elif generated_files:
+            lines.append(f"Generated {len(generated_files)} of 3 files for: {lesson.title}")
+            for se in side_effects:
+                lines.append(f"  - {se}")
+            if errors:
+                lines.append("")
+                for err in errors:
+                    clean_err = str(err).split("\n")[0][:200]
+                    lines.append(f"  Could not generate: {clean_err}")
+                lines.append("Want me to try the failed item(s) again?")
+        else:
+            lines.append(f"Failed to generate teaching package for: {lesson.title}")
             for err in errors:
                 lines.append(f"  - {err}")
 
+        if used_fallback_packet:
+            lines.append("")
+            lines.append(
+                "Note: The student packet was generated using a simpler method — "
+                "it may not have full graphic organizers. Let me know if you'd like me to regenerate it."
+            )
+
+        if kb_context:
+            lines.append("\nReferenced your existing materials on this topic.")
+
+        # Self-review findings
+        try:
+            if review and not review.get("passed", True) and review.get("issues"):
+                lines.append("")
+                lines.append("Quality notes:")
+                for issue in review["issues"][:3]:
+                    lines.append(f"  - {issue}")
+        except NameError:
+            pass
+
+        if voice_notes:
+            lines.append("\nVoice match notes:")
+            for note in voice_notes:
+                lines.append(f"  - {note}")
+            lines.append("Want me to adjust the lesson to better match your voice?")
+
         return ToolResult(
             text="\n".join(lines),
             files=generated_files,

{clawed-2.3.2 → clawed-2.3.4}/clawed/agent_core/tools/ingest_materials.py

@@ -65,7 +65,31 @@ class IngestMaterialsTool:
                 from clawed.persona import extract_persona, save_persona
 
                 persona = await extract_persona(docs, context.config)
+                # Override LLM-inferred name with configured teacher name
+                try:
+                    if context.config and context.config.teacher_profile and context.config.teacher_profile.name:
+                        persona.name = f"{context.config.teacher_profile.name} Teaching Persona"
+                except Exception:
+                    pass
+                try:
+                    _id_path = Path.home() / ".eduagent" / "workspace" / "identity.md"
+                    if _id_path.exists():
+                        import re as _re
+                        _id_content = _id_path.read_text(encoding="utf-8")
+                        _name_match = _re.match(r"^#\s+(.+)", _id_content)
+                        if _name_match:
+                            _tname = _name_match.group(1).strip()
+                            if _tname and _tname != "Teacher":
+                                persona.name = f"{_tname} Teaching Persona"
+                except Exception:
+                    pass
                 save_persona(persona, Path.home() / ".eduagent")
+                # Track persona changes for evolution
+                try:
+                    from clawed.persona_evolution import record_ingestion_changes
+                    record_ingestion_changes(old_persona=None, new_persona=persona)
+                except Exception:
+                    pass
             except Exception:
                 pass
 
@@ -129,6 +153,39 @@ class IngestMaterialsTool:
             except Exception as e:
                 logger.debug("KB indexing failed: %s", e)
 
+            # Register assets for file-level search
+            try:
+                from clawed.asset_registry import AssetRegistry
+                registry = AssetRegistry()
+                asset_count = 0
+                for doc in docs:
+                    doc_type_val = (
+                        doc.doc_type.value
+                        if hasattr(doc.doc_type, "value")
+                        else str(doc.doc_type)
+                    )
+                    extraction = None
+                    if doc.source_path:
+                        try:
+                            from clawed.ingestor import extract_rich
+                            extraction = extract_rich(Path(doc.source_path))
+                        except Exception:
+                            pass
+                    aid = registry.register_asset(
+                        teacher_id=context.teacher_id,
+                        source_path=doc.source_path or "",
+                        title=doc.title,
+                        doc_type=doc_type_val,
+                        text=doc.content,
+                        extraction=extraction,
+                    )
+                    if aid:
+                        asset_count += 1
+                if asset_count:
+                    summary += f" ({asset_count} files catalogued for search)"
+            except Exception as e:
+                logger.debug("Asset registration failed: %s", e)
+
             # Update SOUL.md with what we learned
             try:
                 soul_path = Path.home() / ".eduagent" / "workspace" / "SOUL.md"

{clawed-2.3.2 → clawed-2.3.4}/clawed/agent_core/tools/update_soul.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 
 import logging
 from datetime import date
-from pathlib import Path
 from typing import Any
 
 from clawed.agent_core.context import AgentContext, ToolResult
@@ -92,7 +91,9 @@ class UpdateSoulTool:
                 text=f"Unknown section '{section_key}'. Valid sections: {valid}"
             )
 
-        soul_path = Path.home() / ".eduagent" / "workspace" / "SOUL.md"
+        from clawed.workspace import SOUL_PATH
+
+        soul_path = SOUL_PATH
         soul_path.parent.mkdir(parents=True, exist_ok=True)
 
         # Read or create SOUL.md
@@ -104,6 +105,14 @@ class UpdateSoulTool:
         # Build the datestamped entry
         entry = f"\n\n*({date.today().isoformat()})* {content}\n"
 
+        # Check for duplicate before writing
+        from clawed.workspace import _deduplicate_entry
+
+        if _deduplicate_entry(current, content, header):
+            return ToolResult(
+                text=f"Observation already exists in SOUL.md section '{section_key}' — skipping duplicate.",
+            )
+
         # Insert after the section header
         if header in current:
             current = current.replace(header, header + entry, 1)

{clawed-2.3.2 → clawed-2.3.4}/clawed/commands/generate.py

@@ -130,8 +130,36 @@ def ingest(
         persona = _run_async(extract_persona(documents))
         progress.update(task, description="Persona extracted!")
 
+    # Override LLM-inferred name with configured teacher name
+    try:
+        cfg = AppConfig.load()
+        if cfg.teacher_profile and cfg.teacher_profile.name:
+            persona.name = f"{cfg.teacher_profile.name} Teaching Persona"
+    except Exception:
+        pass
+    # Also check identity.md
+    try:
+        identity_path = Path.home() / ".eduagent" / "workspace" / "identity.md"
+        if identity_path.exists():
+            import re
+            content = identity_path.read_text(encoding="utf-8")
+            name_match = re.match(r"^#\s+(.+)", content)
+            if name_match:
+                teacher_name = name_match.group(1).strip()
+                if teacher_name and teacher_name != "Teacher":
+                    persona.name = f"{teacher_name} Teaching Persona"
+    except Exception:
+        pass
+
     out = save_persona(persona, _output_dir())
 
+    # Track persona changes for evolution
+    try:
+        from clawed.persona_evolution import record_ingestion_changes
+        record_ingestion_changes(old_persona=None, new_persona=persona)
+    except Exception:
+        pass
+
     # Index documents into curriculum knowledge base for KB search
     kb_msg = ""
     try:

{clawed-2.3.2 → clawed-2.3.4}/clawed/handlers/ingest.py

@@ -60,6 +60,25 @@ class IngestHandler:
             try:
                 from clawed.models import AppConfig
                 persona = await extract_persona(documents, AppConfig.load())
+                # Override LLM-inferred name with configured teacher name
+                try:
+                    config = AppConfig.load()
+                    if config.teacher_profile and config.teacher_profile.name:
+                        persona.name = f"{config.teacher_profile.name} Teaching Persona"
+                except Exception:
+                    pass
+                try:
+                    _id_path = Path.home() / ".eduagent" / "workspace" / "identity.md"
+                    if _id_path.exists():
+                        import re as _re
+                        _id_content = _id_path.read_text(encoding="utf-8")
+                        _name_match = _re.match(r"^#\s+(.+)", _id_content)
+                        if _name_match:
+                            _tname = _name_match.group(1).strip()
+                            if _tname and _tname != "Teacher":
+                                persona.name = f"{_tname} Teaching Persona"
+                except Exception:
+                    pass
                 from clawed.persona import save_persona
                 save_persona(persona, Path.home() / ".eduagent")
                 style_info = f"\nLearned teaching style: {persona.teaching_style}"
@@ -97,6 +116,35 @@ class IngestHandler:
             except Exception as e:
                 logger.debug("KB indexing skipped: %s", e)
 
+            # Register assets (files, images, YouTube links) for search
+            try:
+                from clawed.asset_registry import AssetRegistry
+                registry = AssetRegistry()
+                asset_count = 0
+                for doc in documents:
+                    doc_type_val = doc.doc_type.value if hasattr(doc.doc_type, "value") else str(doc.doc_type)
+                    extraction = None
+                    if doc.source_path:
+                        try:
+                            from clawed.ingestor import extract_rich
+                            extraction = extract_rich(Path(doc.source_path))
+                        except Exception:
+                            pass
+                    aid = registry.register_asset(
+                        teacher_id=teacher_id,
+                        source_path=doc.source_path or "",
+                        title=doc.title,
+                        doc_type=doc_type_val,
+                        text=doc.content,
+                        extraction=extraction,
+                    )
+                    if aid:
+                        asset_count += 1
+                if asset_count:
+                    kb_info += f" ({asset_count} files catalogued with images and links)"
+            except Exception as e:
+                logger.debug("Asset registration skipped: %s", e)
+
             return GatewayResponse(
                 text=f"Ingested {len(documents)} document(s).{style_info}{kb_info}"
             )

{clawed-2.3.2 → clawed-2.3.4}/clawed/llm.py

@@ -293,10 +293,36 @@ class LLMClient:
 
         prompt_path = Path(__file__).parent / "prompts" / "student_packet.txt"
         prompt_template = prompt_path.read_text(encoding="utf-8")
+
+        # Build handout style block from persona context
+        import re as _re
+        handout_style = ""
+        if persona_context:
+            hs_match = _re.search(
+                r"=== Handout Style ===\n(.+?)(?:\n===|\Z)",
+                persona_context, _re.DOTALL,
+            )
+            if hs_match:
+                handout_style = hs_match.group(1).strip()
+
+        if handout_style:
+            handout_style_block = (
+                f"This teacher's handout style: {handout_style}. "
+                "Match this format. If the teacher uses guided notes, include them. "
+                "If they use graphic organizers, lead with those. If they prefer "
+                "dense source packets, make the sources the centerpiece. "
+                "Don't impose a format the teacher wouldn't recognize as their own."
+            )
+        else:
+            handout_style_block = (
+                "No specific handout style detected — use the default format below."
+            )
+
         prompt = (
             prompt_template
             .replace("{lesson_json}", lesson_json[:6000])
             .replace("{persona}", persona_context)
+            .replace("{handout_style_block}", handout_style_block)
         )
 
         system = (

{clawed-2.3.2 → clawed-2.3.4}/clawed/memory_engine.py

@@ -397,6 +397,35 @@ def process_feedback(
     except Exception as e:
         logger.debug("Drift detection failed: %s", e)
 
+    # Check if persona evolution should trigger
+    try:
+        from clawed.persona_evolution import apply_confirmed_changes, get_confirmed_changes
+        confirmed = get_confirmed_changes()
+        if confirmed:
+            from clawed.commands._helpers import persona_path
+            from clawed.persona import load_persona
+            pp = persona_path()
+            if pp.exists():
+                current_persona = load_persona(pp)
+                updated, descriptions = apply_confirmed_changes(current_persona)
+                if descriptions:
+                    pp.write_text(updated.model_dump_json(indent=2), encoding="utf-8")
+                    # Log to SOUL.md
+                    from clawed.workspace import SOUL_PATH
+                    if SOUL_PATH.exists():
+                        soul_content = SOUL_PATH.read_text(encoding="utf-8")
+                        stamp = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+                        for desc in descriptions:
+                            entry = f"\n\n*({stamp})* Fingerprint updated: {desc}\n"
+                            marker = "## Agent Observations"
+                            soul_content = soul_content.replace(
+                                marker, marker + entry, 1
+                            )
+                        SOUL_PATH.write_text(soul_content, encoding="utf-8")
+                    logger.info("Persona evolution applied: %s", "; ".join(descriptions))
+    except Exception as e:
+        logger.debug("Persona evolution check failed: %s", e)
+
     return applied
 
 

{clawed-2.3.2 → clawed-2.3.4}/clawed/models.py

@@ -201,6 +201,11 @@ class TeacherPersona(BaseModel):
     'Always ends DI with "here is where it gets interesting"',
     'Uses physical movement — students walk to corners for opinion spectrums'."""
 
+    handout_style: str = ""
+    """Description of the teacher's handout/worksheet style, e.g.
+    'Dense text packets with primary source excerpts and marginal annotations'
+    or 'Graphic organizer-heavy with minimal text, always includes an image hook'."""
+
     def to_prompt_context(self) -> str:
         """Serialize persona into a string for LLM prompt injection."""
         lines = [
@@ -250,6 +255,10 @@ class TeacherPersona(BaseModel):
             for move in self.signature_moves:
                 lines.append(f"- {move}")
 
+        if self.handout_style:
+            lines.append(f"\n=== Handout Style ===\n{self.handout_style}")
+            lines.append("Student packets must match this format.")
+
         if self.voice_examples:
             lines.append("")
             lines.append("=== Voice Examples (write like this) ===")
@@ -479,6 +488,15 @@ class WorksheetItem(BaseModel):
     answer_key: str = ""
     point_value: int = 1
 
+    @field_validator("point_value", mode="before")
+    @classmethod
+    def _coerce_point_value(cls, v):
+        if isinstance(v, str):
+            import re
+            match = re.match(r"(\d+)", v.strip())
+            return int(match.group(1)) if match else 1
+        return v
+
 
 class AssessmentQuestion(BaseModel):
     """A single assessment question."""
@@ -490,6 +508,15 @@ class AssessmentQuestion(BaseModel):
     correct_answer: str = ""
     point_value: int = 1
 
+    @field_validator("point_value", mode="before")
+    @classmethod
+    def _coerce_point_value(cls, v):
+        if isinstance(v, str):
+            import re
+            match = re.match(r"(\d+)", v.strip())
+            return int(match.group(1)) if match else 1
+        return v
+
 
 class RubricCriterion(BaseModel):
     """A single rubric criterion with levels."""
@@ -665,6 +692,15 @@ class SummativeQuestion(BaseModel):
     point_value: int = 1
     standard_aligned: str = ""
 
+    @field_validator("point_value", mode="before")
+    @classmethod
+    def _coerce_point_value(cls, v):
+        if isinstance(v, str):
+            import re
+            match = re.match(r"(\d+)", v.strip())
+            return int(match.group(1)) if match else 1
+        return v
+
 
 class SummativeAssessment(BaseModel):
     """Unit test — mix of MC, short answer, DBQ/essay aligned to all unit objectives."""