clawed 2.3.2__tar.gz → 2.3.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clawed
-Version: 2.3.2
+Version: 2.3.3
 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.3}/clawed/__init__.py

@@ -17,7 +17,7 @@ if hasattr(sys.stderr, "reconfigure"):
     except Exception:
         pass
 
-__version__ = "2.3.2"
+__version__ = "2.3.3"
 __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.3}/clawed/agent_core/tools/generate_lesson_bundle.py

@@ -232,6 +232,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 +340,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.3}/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.3}/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.3}/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.3}/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) ===")

clawed-2.3.3/clawed/persona_evolution.py

@@ -0,0 +1,271 @@
+"""Pedagogical Fingerprint Evolution — conservative persona drift tracking.
+
+Tracks changes to a teacher's persona over time.  Changes require 2+
+consistent signals (e.g. two separate ingestion runs that both detect
+the same style shift) before they are applied.  This prevents a single
+noisy extraction from overwriting the teacher's carefully-built identity.
+
+Flow:
+    1. New files ingested → ``record_ingestion_changes()`` compares old/new
+    2. Candidates accumulate in ``~/.eduagent/persona_candidates.json``
+    3. Each feedback cycle calls ``get_confirmed_changes()``
+    4. Only candidates with confirmations >= 2 are applied
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+from datetime import datetime, timezone
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+from clawed.models import TeacherPersona
+
+logger = logging.getLogger(__name__)
+
+# ── Evolvable fields ────────────────────────────────────────────────
+
+_EVOLVABLE_FIELDS: list[str] = [
+    "teaching_style",
+    "do_now_style",
+    "exit_ticket_style",
+    "source_types",
+    "activity_patterns",
+    "scaffolding_moves",
+    "signature_moves",
+    "handout_style",
+]
+
+# ── Confirmation threshold ──────────────────────────────────────────
+
+_CONFIRMATION_THRESHOLD = 2
+
+# ── Candidate file path ────────────────────────────────────────────
+
+def _candidates_path() -> Path:
+    base = Path(os.environ.get("EDUAGENT_DATA_DIR", str(Path.home() / ".eduagent")))
+    return base / "persona_candidates.json"
+
+
+def _load_candidates() -> list[dict[str, Any]]:
+    path = _candidates_path()
+    if not path.exists():
+        return []
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        logger.debug("Could not read persona candidates file; starting fresh")
+        return []
+
+
+def _save_candidates(candidates: list[dict[str, Any]]) -> None:
+    path = _candidates_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(candidates, indent=2, default=str), encoding="utf-8")
+
+
+# ── Serialization helper ───────────────────────────────────────────
+
+def _serialize(value: Any) -> Any:
+    """Convert a persona field value into a JSON-safe representation."""
+    if isinstance(value, Enum):
+        return value.value
+    if isinstance(value, list):
+        return [_serialize(v) for v in value]
+    return value
+
+
+# ── Core comparison logic ──────────────────────────────────────────
+
+def _compare_personas(
+    old: TeacherPersona,
+    new: TeacherPersona,
+) -> list[dict[str, Any]]:
+    """Compare two personas field-by-field across evolvable fields.
+
+    Returns a list of ``{"field": ..., "old_value": ..., "new_value": ...}``
+    dicts — one per changed field.
+    """
+    changes: list[dict[str, Any]] = []
+    for field in _EVOLVABLE_FIELDS:
+        old_val = _serialize(getattr(old, field, None))
+        new_val = _serialize(getattr(new, field, None))
+        if old_val != new_val:
+            changes.append({
+                "field": field,
+                "old_value": old_val,
+                "new_value": new_val,
+            })
+    return changes
+
+
+def _build_candidate_changes(
+    old: TeacherPersona,
+    new: TeacherPersona,
+    source: str = "ingestion",
+) -> list[dict[str, Any]]:
+    """Wrap comparison results into timestamped candidate entries."""
+    raw_changes = _compare_personas(old, new)
+    now_iso = datetime.now(timezone.utc).isoformat()
+    candidates: list[dict[str, Any]] = []
+    for change in raw_changes:
+        candidates.append({
+            "field": change["field"],
+            "old_value": change["old_value"],
+            "new_value": change["new_value"],
+            "source": source,
+            "first_seen": now_iso,
+            "last_seen": now_iso,
+            "confirmations": 1,
+        })
+    return candidates
+
+
+# ── Rating pattern analysis ────────────────────────────────────────
+
+def _analyze_rating_patterns(
+    ratings: list[tuple[int, str]],
+) -> list[dict[str, Any]]:
+    """Analyze ``(rating, notes)`` tuples for style-shift signals.
+
+    Requires a minimum of 10 ratings to produce any output — small
+    sample sizes are too noisy to act on.
+    """
+    if len(ratings) < 10:
+        return []
+
+    signals: list[dict[str, Any]] = []
+
+    # Split into halves to detect trend shifts
+    mid = len(ratings) // 2
+    first_half = ratings[:mid]
+    second_half = ratings[mid:]
+
+    first_avg = sum(r for r, _ in first_half) / len(first_half) if first_half else 0
+    second_avg = sum(r for r, _ in second_half) / len(second_half) if second_half else 0
+
+    if abs(second_avg - first_avg) >= 0.5:
+        direction = "improving" if second_avg > first_avg else "declining"
+        signals.append({
+            "type": "rating_trend",
+            "direction": direction,
+            "first_half_avg": round(first_avg, 2),
+            "second_half_avg": round(second_avg, 2),
+        })
+
+    # Look for keyword patterns in notes
+    all_notes = " ".join(n.lower() for _, n in ratings if n)
+    style_keywords = {
+        "inquiry": "inquiry_based",
+        "socratic": "socratic",
+        "direct": "direct_instruction",
+        "project": "project_based",
+        "workshop": "workshop",
+    }
+    for keyword, style in style_keywords.items():
+        if all_notes.count(keyword) >= 3:
+            signals.append({
+                "type": "style_keyword",
+                "keyword": keyword,
+                "suggested_style": style,
+                "occurrences": all_notes.count(keyword),
+            })
+
+    return signals
+
+
+# ── Public API ─────────────────────────────────────────────────────
+
+def record_ingestion_changes(
+    old_persona: TeacherPersona,
+    new_persona: TeacherPersona,
+) -> list[dict[str, Any]]:
+    """Record persona changes detected during file ingestion.
+
+    Compares old and new personas.  If a candidate for the same
+    field+new_value already exists, increments its confirmation count
+    instead of adding a duplicate.  Persists to disk.
+    """
+    new_candidates = _build_candidate_changes(old_persona, new_persona, source="ingestion")
+    if not new_candidates:
+        return []
+
+    existing = _load_candidates()
+    now_iso = datetime.now(timezone.utc).isoformat()
+
+    for nc in new_candidates:
+        # Look for an existing candidate with the same field and new_value
+        matched = False
+        for ec in existing:
+            if ec["field"] == nc["field"] and ec["new_value"] == nc["new_value"]:
+                ec["confirmations"] += 1
+                ec["last_seen"] = now_iso
+                matched = True
+                break
+        if not matched:
+            existing.append(nc)
+
+    _save_candidates(existing)
+    logger.info(
+        "Recorded %d persona change candidate(s) from ingestion",
+        len(new_candidates),
+    )
+    return new_candidates
+
+
+def get_confirmed_changes() -> list[dict[str, Any]]:
+    """Return candidates that have reached the confirmation threshold."""
+    candidates = _load_candidates()
+    return [c for c in candidates if c.get("confirmations", 0) >= _CONFIRMATION_THRESHOLD]
+
+
+def apply_confirmed_changes(
+    persona: TeacherPersona,
+) -> tuple[TeacherPersona, list[str]]:
+    """Apply confirmed changes to a persona and clear them from candidates.
+
+    Returns ``(updated_persona, list_of_change_descriptions)``.
+    """
+    confirmed = get_confirmed_changes()
+    if not confirmed:
+        return persona, []
+
+    # Work on a mutable dict representation
+    data = persona.model_dump()
+    descriptions: list[str] = []
+    applied_fields: set[str] = set()
+
+    for change in confirmed:
+        field = change["field"]
+        new_value = change["new_value"]
+        old_value = change.get("old_value", "unknown")
+
+        if field not in _EVOLVABLE_FIELDS:
+            continue
+
+        data[field] = new_value
+        applied_fields.add(field)
+
+        # Human-readable description
+        old_display = old_value if not isinstance(old_value, list) else ", ".join(str(v) for v in old_value)
+        new_display = new_value if not isinstance(new_value, list) else ", ".join(str(v) for v in new_value)
+        descriptions.append(f"{field}: {old_display} -> {new_display}")
+
+    if not descriptions:
+        return persona, []
+
+    updated = TeacherPersona.model_validate(data)
+
+    # Remove applied candidates from the file
+    candidates = _load_candidates()
+    remaining = [
+        c for c in candidates
+        if not (c["field"] in applied_fields and c.get("confirmations", 0) >= _CONFIRMATION_THRESHOLD)
+    ]
+    _save_candidates(remaining)
+
+    logger.info("Applied %d persona evolution(s): %s", len(descriptions), "; ".join(descriptions))
+    return updated, descriptions

{clawed-2.3.2 → clawed-2.3.3}/clawed/prompts/admin_lesson_plan.txt

@@ -24,7 +24,11 @@ Create a structured observation-ready lesson plan with these sections:
    - 1-2 common misconceptions students might have
    - How the teacher should redirect each misconception (use analogies when possible)
 
-4. **Teacher Content Knowledge** — 2-3 paragraphs of background information the teacher should know about the topic beyond what's in the lesson. This is the "expert knowledge" section — historical context, historiographic debates, connections to other units.
+4. **Teacher Content Knowledge** — 2-3 paragraphs of background information the teacher should know about the topic beyond what's in the lesson. Adapt to the subject:
+   - For history/social studies: historical context, historiographic debates, connections to other units.
+   - For math: common student misconceptions about this concept and how to address them, alternative solution methods, connections to prerequisite and future skills.
+   - For science: current scientific understanding beyond the grade level, common student misconceptions, real-world applications of the concept.
+   - For ELA: literary criticism perspectives, author background, connections to other texts and genres.
 
 ## Output Format
 

{clawed-2.3.2 → clawed-2.3.3}/clawed/prompts/lesson_plan.txt

@@ -124,7 +124,11 @@ Every lesson must meet these standards without exception:
 
 1. **All materials referenced must be self-contained.** If the lesson says "distribute the Source Analysis Organizer," the organizer must be fully described in the lesson with all column headers, row labels, and instructions. A teacher printing this lesson should never need to create a referenced material from scratch.
 
-2. **Primary sources must be quoted in full.** If using a primary source, include the complete excerpt with attribution (author, date, title). Do not write "[Insert primary source here]" — find or compose an appropriate excerpt.
+2. **Subject-specific content standards:**
+   - For history and social studies: Primary sources must be quoted in full with attribution (author, date, title). Do not write "[Insert primary source here]."
+   - For math: Worked examples must be fully solved step-by-step with think-aloud annotations. Do not write "students will solve equations" — show the actual equations with solutions.
+   - For science: Lab procedures must include specific measurements, materials quantities, and expected observations. Phenomenon descriptions must be concrete, not abstract.
+   - For ELA: Include the actual passage, poem excerpt, or mentor sentence — not "students will read a text."
 
 3. **Transitions must be scripted.** Between every section, write a 1-2 sentence transition the teacher can say aloud. "OK, now that we've..." not just a section heading.
 

{clawed-2.3.2 → clawed-2.3.3}/clawed/prompts/persona_extract.txt

@@ -83,6 +83,15 @@ Carefully read ALL provided documents and identify:
    - "Every transition includes a 'connection question' that links the previous section to the next"
    - "Ends every class with 'one word — what's the one word you're taking away from today?'"
 
+19. **Handout Style** — Describe how this teacher's student-facing handouts/worksheets are structured. What format do students receive? Look for patterns like:
+   - Dense text packets with primary source excerpts and marginal annotations
+   - Fill-in-the-blank guided notes that track the lecture
+   - Graphic organizer-heavy layouts with minimal text
+   - Station-based packets with documents and analysis questions
+   - Simple question-and-answer worksheets
+   - Creative/visual layouts with image hooks
+   If the materials don't reveal a clear handout style, leave this as an empty string.
+
 ## Output Format
 
 Respond with ONLY a JSON object (no markdown fencing, no explanation):
@@ -126,7 +135,8 @@ Respond with ONLY a JSON object (no markdown fencing, no explanation):
         "Reads primary sources aloud with dramatic emphasis before analysis",
         "Uses 'connection questions' between every section to link ideas",
         "Ends class with 'one word takeaway' — every student says one word as they walk out"
-    ]
+    ],
+    "handout_style": "Station-based packets with 2-4 primary source documents, context paragraphs, and scaffolded analysis questions building from identify to evaluate"
 }
 
 ## Documents to Analyze

{clawed-2.3.2 → clawed-2.3.3}/clawed/prompts/student_packet.txt

@@ -8,6 +8,9 @@ The packet should be 4-6 pages when printed. Every section has generous response
 ## Teacher Persona
 {persona}
 
+## Handout Style
+{handout_style_block}
+
 ## Instructions
 
 Create a student packet with these sections IN ORDER:
@@ -27,6 +30,13 @@ Create a student packet with these sections IN ORDER:
    - 3-4 analysis questions that build in complexity (identify → analyze → evaluate)
    - Each question needs 4-5 response lines
 
+**Subject Adaptation for Stations:**
+- History / Social Studies: Use primary source documents with full text, context, and sourcing questions.
+- Math: Use problem sets with worked examples at increasing difficulty. Each station covers a different problem type or approach.
+- Science: Use data tables, lab observations, or phenomenon descriptions. Each station presents different data to analyze.
+- ELA: Use different text excerpts (poetry, prose, nonfiction) with comprehension and analysis questions.
+Match the station format to the subject. Do not use primary source document analysis for a math or science lesson.
+
 5. **Graphic Organizer** — A table students fill in as they work through the stations or discussion. Define the column headers and number of rows. Common formats:
    - Document / Author's Claim / Evidence / Significance
    - Cause / Event / Effect