clawed 2.1.1__tar.gz → 2.3.1__tar.gz

{clawed-2.1.1 → clawed-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clawed
-Version: 2.1.1
+Version: 2.3.1
 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
@@ -79,15 +79,17 @@ Built on the OpenClaw agent framework. Open source. MIT license.
 
 ---
 
-## What's new in v2.0
+## What's new in v2.3
 
-**Clean output.** Zero XML tags, zero markdown artifacts, zero `<teacher prompt>` gibberish in your printed documents. Every text field in every export (DOCX, PPTX, handout) passes through a rewritten sanitization pipeline that strips LLM formatting artifacts before they reach the page.
+**Three documents, not one.** Every lesson now generates three professional files in parallel:
 
-**Your voice, for real.** The lesson generation LLM now receives your full persona, your SOUL.md, and up to 2000 characters of your voice sample in the system prompt. Lessons actually sound like you wrote them -- not a generic "expert lesson plan writer."
+1. **Student Packet** (4-6 page DOCX workbook) — Fill-in-the-blank guided notes, station sections with full primary source text and analysis questions, graphic organizer tables, exit ticket with sentence starters. This is what students hold in their hands.
+2. **Admin Lesson Plan** (observation-ready DOCX) — Multi-column table with per-section teacher actions (scripted language), student actions, observer look-fors, and differentiation. Anticipated student responses and misconceptions with teacher corrections. Teacher content knowledge appendix.
+3. **Slideshow** (PPTX) — Subject-themed slides with academic images from your own files first, then Library of Congress and Wikimedia. Vocabulary, source quotes, and section dividers on dedicated slides.
 
-**Your files matter.** When you say "make me a lesson on absolutism," the agent searches your knowledge base, finds your existing materials, and injects them as structured context into the generation prompt. The LLM sees your prior work and builds on it instead of starting from scratch.
+**Your files are first-class.** Ingestion extracts images from your PPTX/DOCX files, catalogues YouTube links, and classifies every file by type. The agent tells you what you already have before generating.
 
-**Images on by default.** Slideshows now include academic images (Library of Congress, Wikimedia) without needing `--images`. Logging added to diagnose fetch failures.
+**Pedagogical fingerprint.** "Teacher voice" means how you teach, not just how you sound. The persona captures source types, activity patterns, scaffolding moves, Do Now style, exit ticket format, and signature moves.
 
 ---
 

{clawed-2.1.1 → clawed-2.3.1}/README.md

@@ -13,15 +13,17 @@ Built on the OpenClaw agent framework. Open source. MIT license.
 
 ---
 
-## What's new in v2.0
+## What's new in v2.3
 
-**Clean output.** Zero XML tags, zero markdown artifacts, zero `<teacher prompt>` gibberish in your printed documents. Every text field in every export (DOCX, PPTX, handout) passes through a rewritten sanitization pipeline that strips LLM formatting artifacts before they reach the page.
+**Three documents, not one.** Every lesson now generates three professional files in parallel:
 
-**Your voice, for real.** The lesson generation LLM now receives your full persona, your SOUL.md, and up to 2000 characters of your voice sample in the system prompt. Lessons actually sound like you wrote them -- not a generic "expert lesson plan writer."
+1. **Student Packet** (4-6 page DOCX workbook) — Fill-in-the-blank guided notes, station sections with full primary source text and analysis questions, graphic organizer tables, exit ticket with sentence starters. This is what students hold in their hands.
+2. **Admin Lesson Plan** (observation-ready DOCX) — Multi-column table with per-section teacher actions (scripted language), student actions, observer look-fors, and differentiation. Anticipated student responses and misconceptions with teacher corrections. Teacher content knowledge appendix.
+3. **Slideshow** (PPTX) — Subject-themed slides with academic images from your own files first, then Library of Congress and Wikimedia. Vocabulary, source quotes, and section dividers on dedicated slides.
 
-**Your files matter.** When you say "make me a lesson on absolutism," the agent searches your knowledge base, finds your existing materials, and injects them as structured context into the generation prompt. The LLM sees your prior work and builds on it instead of starting from scratch.
+**Your files are first-class.** Ingestion extracts images from your PPTX/DOCX files, catalogues YouTube links, and classifies every file by type. The agent tells you what you already have before generating.
 
-**Images on by default.** Slideshows now include academic images (Library of Congress, Wikimedia) without needing `--images`. Logging added to diagnose fetch failures.
+**Pedagogical fingerprint.** "Teacher voice" means how you teach, not just how you sound. The persona captures source types, activity patterns, scaffolding moves, Do Now style, exit ticket format, and signature moves.
 
 ---
 

{clawed-2.1.1 → clawed-2.3.1}/clawed/__init__.py

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

{clawed-2.1.1 → clawed-2.3.1}/clawed/agent_core/core.py

@@ -361,7 +361,18 @@ class Gateway:
             soul_context=soul_context,
         )
 
-        # 2c. Enhance prompt for multi-step planning requests
+        # 2c. Cross-session context threading — greet with continuity
+        last_session = memory_ctx.get("last_session_summary", "")
+        if last_session and not session_history:
+            system += (
+                "\n\n=== Last Session Context ===\n"
+                f"The teacher's last interaction was about: {last_session}\n"
+                "If this is a new conversation, greet them with continuity — e.g. "
+                '"Last time we worked on [topic]. Want to continue or start something new?"\n'
+                "=== End Last Session Context ===\n"
+            )
+
+        # 2d. Enhance prompt for multi-step planning requests
         from clawed.agent_core.planner import build_planning_prompt, is_planning_request
 
         if is_planning_request(message):
@@ -415,6 +426,14 @@ class Gateway:
         except Exception:
             pass
 
+        # 8. Maybe compress old episodes (runs every COMPRESSION_THRESHOLD episodes)
+        try:
+            from clawed.memory_engine import maybe_compress_episodes
+
+            maybe_compress_episodes(teacher_id)
+        except Exception:
+            pass
+
         return result
 
     # ------------------------------------------------------------------

{clawed-2.1.1 → clawed-2.3.1}/clawed/agent_core/memory/episodes.py

@@ -96,3 +96,53 @@ class EpisodicMemory:
 
         scored.sort(key=lambda x: x["similarity"], reverse=True)
         return scored[:top_k]
+
+    def get_latest_episode(self, teacher_id: str) -> dict[str, Any] | None:
+        """Return the most recent episode for a teacher, or None."""
+        with sqlite3.connect(self._db_path) as conn:
+            conn.row_factory = sqlite3.Row
+            row = conn.execute(
+                "SELECT text, metadata, created_at FROM episodes "
+                "WHERE teacher_id = ? ORDER BY created_at DESC LIMIT 1",
+                (teacher_id,),
+            ).fetchone()
+        if not row:
+            return None
+        return {
+            "text": row["text"],
+            "metadata": json.loads(row["metadata"]),
+            "created_at": row["created_at"],
+        }
+
+    def count_episodes(self, teacher_id: str) -> int:
+        """Return the total number of episodes stored for a teacher."""
+        with sqlite3.connect(self._db_path) as conn:
+            row = conn.execute(
+                "SELECT COUNT(*) FROM episodes WHERE teacher_id = ?",
+                (teacher_id,),
+            ).fetchone()
+        return row[0] if row else 0
+
+    def get_all_episodes(
+        self,
+        teacher_id: str,
+        limit: int = 500,
+        offset: int = 0,
+    ) -> list[dict[str, Any]]:
+        """Return episodes in chronological order (oldest first)."""
+        with sqlite3.connect(self._db_path) as conn:
+            conn.row_factory = sqlite3.Row
+            rows = conn.execute(
+                "SELECT text, metadata, created_at FROM episodes "
+                "WHERE teacher_id = ? ORDER BY created_at ASC "
+                "LIMIT ? OFFSET ?",
+                (teacher_id, limit, offset),
+            ).fetchall()
+        return [
+            {
+                "text": row["text"],
+                "metadata": json.loads(row["metadata"]),
+                "created_at": row["created_at"],
+            }
+            for row in rows
+        ]

{clawed-2.1.1 → clawed-2.3.1}/clawed/agent_core/memory/loader.py

@@ -96,6 +96,28 @@ def load_memory_context(teacher_id: str, current_message: str) -> dict[str, Any]
     except Exception as e:
         logger.debug("Curriculum KB search failed: %s", e)
 
+    # Layer 6: Last session summary (cross-session context threading)
+    last_session_summary = ""
+    try:
+        from clawed.agent_core.memory.episodes import EpisodicMemory
+
+        mem = EpisodicMemory()
+        latest = mem.get_latest_episode(teacher_id)
+        if latest:
+            text = latest["text"]
+            # Extract teacher's message (first line is usually "Teacher: <msg>")
+            first_line = text.split("\n")[0].strip()
+            if first_line.startswith("Teacher: "):
+                topic = first_line[len("Teacher: "):]
+            else:
+                topic = first_line
+            # Truncate to a concise summary
+            if len(topic) > 150:
+                topic = topic[:147] + "..."
+            last_session_summary = topic
+    except Exception as e:
+        logger.debug("Last session summary load failed: %s", e)
+
     return {
         "identity_summary": identity_summary,
         "curriculum_summary": curriculum_summary,
@@ -104,4 +126,5 @@ def load_memory_context(teacher_id: str, current_message: str) -> dict[str, Any]
         "preferences_summary": preferences_summary,
         "autonomy_summary": autonomy_summary,
         "curriculum_kb_context": curriculum_kb_context,
+        "last_session_summary": last_session_summary,
     }

{clawed-2.1.1 → clawed-2.3.1}/clawed/agent_core/tools/generate_lesson_bundle.py

@@ -232,6 +232,44 @@ class GenerateLessonBundleTool:
         except Exception:
             pass  # Review is best-effort, don't block on failure
 
+        # ── Generate student packet + admin plan in parallel ──────────
+        import asyncio
+
+        from clawed.llm import LLMClient
+
+        llm_client = LLMClient(config)
+        persona_ctx = persona.to_prompt_context()
+        student_packet = None
+        admin_plan = None
+
+        async def _gen_packet():
+            return await llm_client.generate_student_packet(
+                lesson_json_str, persona_context=persona_ctx,
+            )
+
+        async def _gen_admin():
+            return await llm_client.generate_admin_plan(
+                lesson_json_str, persona_context=persona_ctx,
+            )
+
+        try:
+            results = await asyncio.gather(
+                _gen_packet(), _gen_admin(), return_exceptions=True,
+            )
+            if not isinstance(results[0], Exception):
+                student_packet = results[0]
+                logger.info("Student packet generated: %d stations, %d guided notes",
+                            len(student_packet.stations), len(student_packet.guided_notes))
+            else:
+                logger.warning("Student packet generation failed: %s", results[0])
+            if not isinstance(results[1], Exception):
+                admin_plan = results[1]
+                logger.info("Admin lesson plan generated: %d sections", len(admin_plan.sections))
+            else:
+                logger.warning("Admin plan generation failed: %s", results[1])
+        except Exception as e:
+            logger.warning("Parallel generation failed: %s", e)
+
         # ── Export all three files ────────────────────────────────────
         output_dir = Path("clawed_output").resolve()
         output_dir.mkdir(parents=True, exist_ok=True)
@@ -240,61 +278,39 @@ class GenerateLessonBundleTool:
         side_effects: list[str] = []
         errors: list[str] = []
 
-        # 1. Lesson plan DOCX
+        # 1. Admin lesson plan DOCX (or fallback to basic lesson plan)
         try:
             from clawed.export_docx import export_lesson_docx
 
-            docx_path = export_lesson_docx(lesson, persona, output_dir)
+            docx_path = export_lesson_docx(
+                lesson, persona, output_dir, admin_plan=admin_plan,
+            )
             generated_files.append(docx_path)
-            side_effects.append(f"Lesson plan DOCX: {docx_path.name}")
+            label = "Admin lesson plan" if admin_plan else "Lesson plan"
+            side_effects.append(f"{label} DOCX: {docx_path.name}")
         except Exception as e:
             logger.error("Lesson DOCX export failed: %s", e)
             errors.append(f"Lesson plan DOCX failed: {e}")
 
-        # 2. Generate student handout via LLM (first-class output, not regex extraction)
+        # 2. Student packet DOCX (structured) or fallback to old handout
         try:
-            import json_repair
+            from clawed.export_handout import export_student_packet_docx
 
-            from clawed.llm import LLMClient
-
-            llm_client = LLMClient(config)
-            handout_raw = await llm_client.generate_student_handout(
-                lesson_json_str,
-                persona_context=persona.to_prompt_context(),
-                subject=subject,
-                grade=grade,
-            )
-            # Parse handout JSON
-            handout_cleaned = handout_raw.strip()
-            if handout_cleaned.startswith("```"):
-                lines = handout_cleaned.split("\n")
-                lines = lines[1:]
-                if lines and lines[-1].strip() == "```":
-                    lines = lines[:-1]
-                handout_cleaned = "\n".join(lines)
-            try:
-                handout_data = json.loads(handout_cleaned)
-            except json.JSONDecodeError:
-                handout_data = json_repair.loads(handout_cleaned)
-
-            from clawed.export_handout import export_handout_docx
-
-            handout_path = export_handout_docx(handout_data, subject=subject)
-            if handout_path:
-                generated_files.append(Path(handout_path))
-                side_effects.append(f"Student handout DOCX: {Path(handout_path).name}")
-        except Exception as handout_err:
-            logger.warning("LLM handout generation failed, falling back: %s", handout_err)
-            # Fallback to regex-based handout
-            try:
+            if student_packet:
+                packet_path = export_student_packet_docx(
+                    student_packet, subject=subject, output_dir=output_dir,
+                )
+            else:
+                # Fallback: build minimal packet from lesson data
                 from clawed.export_docx import export_student_handout
+                packet_path = export_student_handout(lesson, persona, output_dir)
 
-                handout_path = export_student_handout(lesson, persona, output_dir)
-                if handout_path:
-                    generated_files.append(Path(handout_path))
-                    side_effects.append(f"Student handout DOCX: {Path(handout_path).name}")
-            except Exception:
-                pass
+            if packet_path:
+                generated_files.append(Path(packet_path))
+                side_effects.append(f"Student packet DOCX: {Path(packet_path).name}")
+        except Exception as e:
+            logger.warning("Student packet export failed: %s", e)
+            errors.append(f"Student packet failed: {e}")
 
         # 3. Slideshow PPTX
         try:

{clawed-2.1.1 → clawed-2.3.1}/clawed/export_docx.py

@@ -170,11 +170,20 @@ def export_lesson_docx(
     persona: "TeacherPersona",
     output_dir: Path | None = None,
     agent_name: str = "Claw-ED",
+    admin_plan: Any = None,
 ) -> Path:
     """Generate a Word document from a lesson plan with embedded academic images.
 
+    If an AdminLessonPlan is provided, generates an observation-ready document
+    with per-section teacher/student actions, observer look-fors, anticipated
+    responses, and teacher content knowledge.
+
     Returns the path to the saved .docx file.
     """
+    # If we have an admin plan, use the enriched export
+    if admin_plan is not None:
+        return _export_admin_lesson_docx(lesson, persona, admin_plan, output_dir, agent_name)
+
     from docx import Document
     from docx.enum.text import WD_ALIGN_PARAGRAPH
     from docx.shared import Pt, RGBColor
@@ -813,3 +822,203 @@ def _remove_table_borders(table: Any) -> None:
         )
         borders.append(element)
     tblPr.append(borders)
+
+
+# ── Admin lesson plan export ──────────────────────────────────────────
+
+
+def _export_admin_lesson_docx(
+    lesson: "DailyLesson",
+    persona: "TeacherPersona",
+    admin_plan: Any,
+    output_dir: Path | None = None,
+    agent_name: str = "Claw-ED",
+) -> Path:
+    """Generate an observation-ready lesson plan DOCX with multi-column tables.
+
+    This produces the format administrators expect: per-section teacher actions,
+    student actions, observer look-fors, and differentiation in a table layout,
+    plus anticipated responses and teacher content knowledge sections.
+    """
+    from docx import Document
+    from docx.enum.table import WD_TABLE_ALIGNMENT
+    from docx.enum.text import WD_ALIGN_PARAGRAPH
+    from docx.oxml.ns import qn
+    from docx.shared import Inches, Pt, RGBColor
+
+    from clawed.sanitize import sanitize_text
+
+    doc = Document()
+
+    # Page setup
+    for section in doc.sections:
+        section.top_margin = Inches(0.6)
+        section.bottom_margin = Inches(0.5)
+        section.left_margin = Inches(0.75)
+        section.right_margin = Inches(0.75)
+
+    style = doc.styles["Normal"]
+    style.font.name = "Calibri"
+    style.font.size = Pt(10)
+
+    theme = get_color_theme(persona.subject_area or "")
+    primary_hex = theme["primary"]
+    primary_rgb = RGBColor(int(primary_hex[:2], 16), int(primary_hex[2:4], 16), int(primary_hex[4:6], 16))
+
+    def _shade(cell, hex_color):
+        tc = cell._tc
+        tcPr = tc.get_or_add_tcPr()
+        shading = tcPr.makeelement(
+            qn("w:shd"), {qn("w:val"): "clear", qn("w:color"): "auto", qn("w:fill"): hex_color},
+        )
+        tcPr.append(shading)
+
+    # ── I. Header ─────────────────────────────────────────────────────
+    title_para = doc.add_paragraph()
+    title_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    r = title_para.add_run("LESSON PLAN")
+    r.bold = True
+    r.font.size = Pt(18)
+    r.font.color.rgb = primary_rgb
+
+    # Overview table
+    teacher_name = getattr(admin_plan, "teacher_name", "") or persona.name or "Teacher"
+    overview_data = [
+        ("Teacher", sanitize_text(teacher_name)),
+        ("Course", sanitize_text(getattr(admin_plan, "course", persona.subject_area or ""))),
+        ("Date", sanitize_text(getattr(admin_plan, "date", ""))),
+        ("Topic", sanitize_text(getattr(admin_plan, "topic", lesson.title))),
+        ("Grade Level", sanitize_text(getattr(admin_plan, "grade_level", ""))),
+        ("Duration", f"{getattr(admin_plan, 'duration_minutes', 40)} Minutes"),
+        ("Aim", sanitize_text(getattr(admin_plan, "aim", lesson.objective))),
+    ]
+    standards = getattr(admin_plan, "standards", []) or lesson.standards
+    if standards:
+        overview_data.append(("Standards", sanitize_text(", ".join(standards[:3]))))
+    materials = getattr(admin_plan, "materials", []) or lesson.materials_needed
+    if materials:
+        overview_data.append(("Materials", sanitize_text(", ".join(materials[:6]))))
+
+    overview_table = doc.add_table(rows=len(overview_data), cols=2)
+    overview_table.alignment = WD_TABLE_ALIGNMENT.CENTER
+    for i, (label, value) in enumerate(overview_data):
+        label_cell = overview_table.rows[i].cells[0]
+        value_cell = overview_table.rows[i].cells[1]
+        label_cell.text = ""
+        lp = label_cell.paragraphs[0]
+        lr = lp.add_run(label)
+        lr.bold = True
+        lr.font.size = Pt(10)
+        _shade(label_cell, theme.get("bg_light", "F5F5F5").lstrip("#"))
+        value_cell.text = value
+        for p in value_cell.paragraphs:
+            for run in p.runs:
+                run.font.size = Pt(10)
+    _set_table_borders(overview_table)
+
+    # ── II. Section-by-Section Breakdown ──────────────────────────────
+    sections = getattr(admin_plan, "sections", [])
+    if sections:
+        doc.add_paragraph("")
+        h = doc.add_heading("Lesson Plan & Pacing", level=2)
+        for run in h.runs:
+            run.font.color.rgb = primary_rgb
+
+        # 5-column table: Section | Teacher Actions | Student Actions | Look-Fors | Differentiation
+        col_headers = [
+            "Section & Timing", "Teacher Actions", "Student Actions",
+            "Observer Look-Fors", "Differentiation",
+        ]
+        section_table = doc.add_table(rows=1 + len(sections), cols=5)
+        section_table.alignment = WD_TABLE_ALIGNMENT.CENTER
+
+        # Header row
+        for ci, header in enumerate(col_headers):
+            cell = section_table.rows[0].cells[ci]
+            cell.text = ""
+            p = cell.paragraphs[0]
+            r = p.add_run(header)
+            r.bold = True
+            r.font.size = Pt(9)
+            r.font.color.rgb = RGBColor(0xFF, 0xFF, 0xFF)
+            _shade(cell, primary_hex)
+
+        # Data rows
+        for ri, sec in enumerate(sections):
+            row = section_table.rows[ri + 1]
+            if hasattr(sec, "section_name"):
+                fields = [
+                    f"{sec.section_name}\n({sec.timing_minutes} min)",
+                    sanitize_text(sec.teacher_actions),
+                    sanitize_text(sec.student_actions),
+                    sanitize_text(sec.observer_look_fors),
+                    sanitize_text(sec.differentiation),
+                ]
+            else:
+                fields = [str(sec)] + [""] * 4
+            for ci, text in enumerate(fields):
+                cell = row.cells[ci]
+                cell.text = text
+                for p in cell.paragraphs:
+                    for run in p.runs:
+                        run.font.size = Pt(9)
+            # Alternate row shading
+            if ri % 2 == 0:
+                for cell in row.cells:
+                    _shade(cell, "F9F9F9")
+
+        _set_table_borders(section_table)
+
+    # ── III. Anticipated Responses & Misconceptions ───────────────────
+    responses = getattr(admin_plan, "anticipated_responses", [])
+    if responses:
+        doc.add_paragraph("")
+        h = doc.add_heading("Anticipated Student Responses & Misconceptions", level=2)
+        for run in h.runs:
+            run.font.color.rgb = primary_rgb
+
+        for resp in responses:
+            is_mis = getattr(resp, "is_misconception", False) if hasattr(resp, "is_misconception") else False
+            text = sanitize_text(getattr(resp, "response_or_misconception", str(resp)))
+            correction = sanitize_text(getattr(resp, "teacher_correction", ""))
+
+            p = doc.add_paragraph()
+            prefix = "MISCONCEPTION: " if is_mis else "EXPECTED: "
+            pr = p.add_run(prefix)
+            pr.bold = True
+            pr.font.size = Pt(10)
+            pr.font.color.rgb = RGBColor(0xCC, 0x33, 0x33) if is_mis else RGBColor(0x33, 0x99, 0x33)
+            tr = p.add_run(f'"{text}"')
+            tr.italic = True
+            tr.font.size = Pt(10)
+
+            if correction:
+                cp = doc.add_paragraph()
+                cp.paragraph_format.left_indent = Inches(0.3)
+                cr = cp.add_run(f"Redirect: {correction}")
+                cr.font.size = Pt(9)
+                cr.font.color.rgb = RGBColor(0x44, 0x44, 0x44)
+
+    # ── IV. Teacher Content Knowledge ─────────────────────────────────
+    tck = sanitize_text(getattr(admin_plan, "teacher_content_knowledge", ""))
+    if tck:
+        doc.add_paragraph("")
+        h = doc.add_heading("Teacher Content Knowledge", level=2)
+        for run in h.runs:
+            run.font.color.rgb = primary_rgb
+        p = doc.add_paragraph(tck)
+        p.paragraph_format.space_after = Pt(6)
+        for run in p.runs:
+            run.font.size = Pt(10)
+
+    # ── Footer ────────────────────────────────────────────────────────
+    doc.add_paragraph("")
+    gen_footer = doc.add_paragraph()
+    gen_footer.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    fr = gen_footer.add_run(f"Generated by {agent_name}")
+    fr.font.size = Pt(8)
+    fr.font.color.rgb = RGBColor(0x99, 0x99, 0x99)
+
+    out = _resolve_output(output_dir, lesson, ".docx")
+    doc.save(str(out))
+    return out