clawed 2.3.8__tar.gz → 2.3.9__tar.gz

{clawed-2.3.8 → clawed-2.3.9}/PKG-INFO

@@ -1,22 +1,29 @@
 Metadata-Version: 2.4
 Name: clawed
-Version: 2.3.8
-Summary: Claw-ED — personal AI teaching agent. Learns your voice, works while you sleep.
-Project-URL: Homepage, https://github.com/SirhanMacx/Claw-ED
+Version: 2.3.9
+Summary: Free AI lesson planner for teachers. Learns your teaching voice from your curriculum files and generates complete lesson packages. Open source, runs locally, no subscription.
+Project-URL: Homepage, https://sirhanmacx.github.io/Claw-ED
 Project-URL: Documentation, https://github.com/SirhanMacx/Claw-ED#readme
-Project-URL: Issues, https://github.com/SirhanMacx/Claw-ED/issues
+Project-URL: Repository, https://github.com/SirhanMacx/Claw-ED
+Project-URL: Bug Tracker, https://github.com/SirhanMacx/Claw-ED/issues
+Project-URL: Changelog, https://github.com/SirhanMacx/Claw-ED/blob/main/CHANGELOG.md
+Project-URL: PyPI, https://pypi.org/project/clawed/
 Author: Jon Maccarello & Claw-ED contributors
 License-Expression: MIT
 License-File: LICENSE
-Keywords: ai,claw-ed,clawed,education,lesson-plans,teachers,teaching
+Keywords: ai,ai-for-teachers,claw-ed,clawed,curriculum,edtech,education,hermes-agent,k12,lesson-plan-generator,lesson-planner,lesson-planning,lesson-plans,open-source-education,pedagogy,teacher-tools,teachers,teaching,teaching-assistant
 Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
 Classifier: Intended Audience :: Education
 Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Education
+Classifier: Topic :: Education :: Computer Aided Instruction (CAI)
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.10
 Requires-Dist: apscheduler<4.0,>=3.10.0
 Requires-Dist: fastapi<1.0,>=0.110.0
@@ -71,17 +78,47 @@ Description-Content-Type: text/markdown
 
 Your personal AI teaching agent. Runs on your machine, learns your voice, works while you sleep.
 
-Built on the OpenClaw agent framework. Open source. MIT license.
+Built on the Hermes Agent framework (NousResearch). Open source. MIT license.
 
 <p align="center">
-  <a href="https://pypi.org/project/clawed/"><img src="https://img.shields.io/pypi/v/clawed?color=blue" alt="PyPI"></a>
-  <a href="https://python.org"><img src="https://img.shields.io/badge/Python-3.10+-blue" alt="Python 3.10+"></a>
+  <a href="https://pypi.org/project/clawed/"><img src="https://img.shields.io/pypi/v/clawed?color=blue" alt="PyPI version"></a>
+  <a href="https://pypi.org/project/clawed/"><img src="https://img.shields.io/pypi/pyversions/clawed" alt="Python versions"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/License-MIT-green" alt="MIT License"></a>
   <a href="https://github.com/SirhanMacx/Claw-ED/stargazers"><img src="https://img.shields.io/github/stars/SirhanMacx/Claw-ED" alt="GitHub stars"></a>
+  <a href="https://pepy.tech/project/clawed"><img src="https://static.pepy.tech/badge/clawed" alt="Downloads"></a>
 </p>
 
 ---
 
+## What's new in v2.3.9
+
+**Multi-agent lesson generation.** Instead of one LLM call doing everything, `--multi-agent` spawns a team of three specialized agents: a Researcher who finds primary sources and historical context, a Writer who drafts the lesson in your voice, and a Reviewer who scores quality on voice fidelity, pedagogy, and differentiation — sending it back for revision if any dimension scores below 7/10. The result: higher-quality lessons with better sources and stronger voice matching.
+
+```bash
+clawed lesson "The Missouri Compromise" -g 8 --multi-agent
+```
+
+**Claude Code integration.** Claw-ED now auto-reads OAuth tokens from Claude Code's credential store (`~/.claude/.credentials.json`). If you have Claude Code installed, Claw-ED just works — no separate API key setup needed, and tokens auto-refresh. Claw-ED also works as an MCP server that Claude Code can use directly:
+
+```bash
+clawed mcp-server  # Add to Claude Code as an MCP tool
+```
+
+**Continuous improvement pipeline.** The new `clawed train` command lets your AI fleet (or you) continuously improve lesson quality:
+
+```bash
+clawed train --drive          # Ingest new files from Google Drive, refine persona
+clawed train --path ./files   # Ingest local curriculum files
+clawed train --benchmark -n 5 # Generate 5 lessons and score them
+clawed train --full           # Drive ingest + benchmark
+```
+
+Persona refinement is now incremental — new voice markers merge with existing ones instead of overwriting. Your teaching identity gets richer over time.
+
+**OAuth auth fix.** All Anthropic API calls now correctly detect OAuth tokens and use Bearer authentication with Claude Code identity headers. Fixes the 401 errors that affected fleet agents and Claw-ED direct usage.
+
+---
+
 ## What's new in v2.3.8
 
 **No more silent failures.** Every step of lesson generation now reports what happened — persona loading, material search, quality review, voice matching. If something fails, you'll know exactly what and why, with structured NLAH failure codes. Quality review runs automatically on every generated lesson and fails closed: if the review itself crashes, it reports failure instead of silently passing.
@@ -116,7 +153,7 @@ Built on the OpenClaw agent framework. Open source. MIT license.
 
 ## What is this?
 
-Claw-ED is a personal AI agent for teachers. It uses the same architecture as other OpenClaw agents -- SOUL.md for identity, layered memory, a workspace, pulse jobs, tool use, and autonomous operation. The difference is what it knows: your lesson plans, your teaching style, your standards, your students.
+Claw-ED is a personal AI agent for teachers. It uses the same architecture as Hermes Agent -- SOUL.md for identity, layered memory, a workspace, cron jobs, tool use, and autonomous operation. The difference is what it knows: your lesson plans, your teaching style, your standards, your students.
 
 You feed it your curriculum files and it learns your voice. Not a generic "teacher tone" -- your actual patterns, your vocabulary, the way you structure a Do Now or frame an essential question. Then it works: drafting lessons that sound like you wrote them, organizing your Google Drive, answering student questions in your voice, prepping your week before you wake up.
 

{clawed-2.3.8 → clawed-2.3.9}/README.md

@@ -2,17 +2,47 @@
 
 Your personal AI teaching agent. Runs on your machine, learns your voice, works while you sleep.
 
-Built on the OpenClaw agent framework. Open source. MIT license.
+Built on the Hermes Agent framework (NousResearch). Open source. MIT license.
 
 <p align="center">
-  <a href="https://pypi.org/project/clawed/"><img src="https://img.shields.io/pypi/v/clawed?color=blue" alt="PyPI"></a>
-  <a href="https://python.org"><img src="https://img.shields.io/badge/Python-3.10+-blue" alt="Python 3.10+"></a>
+  <a href="https://pypi.org/project/clawed/"><img src="https://img.shields.io/pypi/v/clawed?color=blue" alt="PyPI version"></a>
+  <a href="https://pypi.org/project/clawed/"><img src="https://img.shields.io/pypi/pyversions/clawed" alt="Python versions"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/License-MIT-green" alt="MIT License"></a>
   <a href="https://github.com/SirhanMacx/Claw-ED/stargazers"><img src="https://img.shields.io/github/stars/SirhanMacx/Claw-ED" alt="GitHub stars"></a>
+  <a href="https://pepy.tech/project/clawed"><img src="https://static.pepy.tech/badge/clawed" alt="Downloads"></a>
 </p>
 
 ---
 
+## What's new in v2.3.9
+
+**Multi-agent lesson generation.** Instead of one LLM call doing everything, `--multi-agent` spawns a team of three specialized agents: a Researcher who finds primary sources and historical context, a Writer who drafts the lesson in your voice, and a Reviewer who scores quality on voice fidelity, pedagogy, and differentiation — sending it back for revision if any dimension scores below 7/10. The result: higher-quality lessons with better sources and stronger voice matching.
+
+```bash
+clawed lesson "The Missouri Compromise" -g 8 --multi-agent
+```
+
+**Claude Code integration.** Claw-ED now auto-reads OAuth tokens from Claude Code's credential store (`~/.claude/.credentials.json`). If you have Claude Code installed, Claw-ED just works — no separate API key setup needed, and tokens auto-refresh. Claw-ED also works as an MCP server that Claude Code can use directly:
+
+```bash
+clawed mcp-server  # Add to Claude Code as an MCP tool
+```
+
+**Continuous improvement pipeline.** The new `clawed train` command lets your AI fleet (or you) continuously improve lesson quality:
+
+```bash
+clawed train --drive          # Ingest new files from Google Drive, refine persona
+clawed train --path ./files   # Ingest local curriculum files
+clawed train --benchmark -n 5 # Generate 5 lessons and score them
+clawed train --full           # Drive ingest + benchmark
+```
+
+Persona refinement is now incremental — new voice markers merge with existing ones instead of overwriting. Your teaching identity gets richer over time.
+
+**OAuth auth fix.** All Anthropic API calls now correctly detect OAuth tokens and use Bearer authentication with Claude Code identity headers. Fixes the 401 errors that affected fleet agents and Claw-ED direct usage.
+
+---
+
 ## What's new in v2.3.8
 
 **No more silent failures.** Every step of lesson generation now reports what happened — persona loading, material search, quality review, voice matching. If something fails, you'll know exactly what and why, with structured NLAH failure codes. Quality review runs automatically on every generated lesson and fails closed: if the review itself crashes, it reports failure instead of silently passing.
@@ -47,7 +77,7 @@ Built on the OpenClaw agent framework. Open source. MIT license.
 
 ## What is this?
 
-Claw-ED is a personal AI agent for teachers. It uses the same architecture as other OpenClaw agents -- SOUL.md for identity, layered memory, a workspace, pulse jobs, tool use, and autonomous operation. The difference is what it knows: your lesson plans, your teaching style, your standards, your students.
+Claw-ED is a personal AI agent for teachers. It uses the same architecture as Hermes Agent -- SOUL.md for identity, layered memory, a workspace, cron jobs, tool use, and autonomous operation. The difference is what it knows: your lesson plans, your teaching style, your standards, your students.
 
 You feed it your curriculum files and it learns your voice. Not a generic "teacher tone" -- your actual patterns, your vocabulary, the way you structure a Do Now or frame an essential question. Then it works: drafting lessons that sound like you wrote them, organizing your Google Drive, answering student questions in your voice, prepping your week before you wake up.
 

{clawed-2.3.8 → clawed-2.3.9}/clawed/__init__.py

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

{clawed-2.3.8 → clawed-2.3.9}/clawed/_legacy_gateway.py

@@ -350,7 +350,7 @@ class Gateway:
 
     async def _status_response(self, teacher_id: str) -> GatewayResponse:
         try:
-            from clawed.openclaw_plugin import _show_status
+            from clawed.hermes_plugin import _show_status
             from clawed.state import TeacherSession
             session = TeacherSession.load(teacher_id)
             return GatewayResponse(text=_show_status(session))

{clawed-2.3.8 → clawed-2.3.9}/clawed/agent.py

@@ -13,6 +13,29 @@ from __future__ import annotations
 
 import json
 import logging
+
+
+def _anthropic_headers(api_key: str) -> dict[str, str]:
+    """Build Anthropic API headers, auto-detecting OAuth vs regular API keys.
+
+    OAuth tokens (sk-ant-oat01-*) need Bearer auth + Claude Code identity
+    headers. Regular API keys (sk-ant-api*) use x-api-key.
+    """
+    is_oauth = api_key.startswith("sk-ant-") and not api_key.startswith("sk-ant-api")
+    if is_oauth:
+        return {
+            "authorization": f"Bearer {api_key}",
+            "anthropic-version": "2023-06-01",
+            "anthropic-beta": "interleaved-thinking-2025-05-14,claude-code-20250219,oauth-2025-04-20",
+            "user-agent": "claude-cli/1.0.0 (external, cli)",
+            "x-app": "cli",
+            "content-type": "application/json",
+        }
+    return {
+        "x-api-key": api_key,
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json",
+    }
 from typing import Any
 
 from clawed.models import AppConfig, LLMProvider
@@ -137,11 +160,7 @@ async def _anthropic_with_tools(
     async with httpx.AsyncClient(timeout=120.0) as client:
         resp = await client.post(
             "https://api.anthropic.com/v1/messages",
-            headers={
-                "x-api-key": api_key,
-                "anthropic-version": "2023-06-01",
-                "content-type": "application/json",
-            },
+            headers=_anthropic_headers(api_key),
             json={
                 "model": config.anthropic_model,
                 "max_tokens": 4096,

{clawed-2.3.8 → clawed-2.3.9}/clawed/cli.py

@@ -39,6 +39,7 @@ from clawed.commands.generate import generate_app
 from clawed.commands.queue import queue_app
 from clawed.commands.schedule_cmd import schedule_app
 from clawed.commands.sub import sub_app
+from clawed.commands.train import train_app
 from clawed.commands.workspace_cmd import workspace_app
 
 # ── Build the main app ──────────────────────────────────────────────────
@@ -241,6 +242,7 @@ app.add_typer(class_app, name="class")
 app.add_typer(queue_app, name="queue")
 app.add_typer(workspace_app, name="workspace")
 app.add_typer(schedule_app, name="schedule")
+app.add_typer(train_app, name="train")
 
 # ── Register top-level commands from sub-modules ────────────────────────
 # Commands from generate_app, export_app, and bot_app are registered as

{clawed-2.3.8 → clawed-2.3.9}/clawed/commands/generate.py

@@ -298,6 +298,10 @@ def lesson(
     homework: bool = typer.Option(
         True, "--homework/--no-homework", help="Include homework"
     ),
+    multi_agent: bool = typer.Option(
+        False, "--multi-agent/--no-multi-agent",
+        help="Use multi-agent pipeline (researcher→writer→reviewer) for higher quality",
+    ),
     fmt: str = typer.Option("markdown", "--format", "-f", help="Export format: markdown, pptx, docx, pdf, handout"),
 ):
     """Generate a detailed daily lesson plan.
@@ -306,6 +310,9 @@ def lesson(
     Standalone mode (no unit plan needed):
         clawed lesson "The American Revolution" --grade 8 --subject "social studies"
 
+    Multi-agent mode (higher quality, 3x slower):
+        clawed lesson "The Missouri Compromise" -g 8 --multi-agent
+
     From a unit plan:
         clawed lesson "Photosynthesis" --unit-file output/unit_photosynthesis.json -n 1
     """
@@ -388,18 +395,46 @@ def lesson(
 
     with _safe_progress(console=console) as progress:
         task = progress.add_task(
-            f"Generating lesson {lesson_num}...", total=None
+            f"Generating lesson {lesson_num}{'  [multi-agent]' if multi_agent else ''}...",
+            total=None,
         )
         try:
-            daily = _run_async(
-                generate_lesson(
-                    lesson_number=lesson_num,
-                    unit=unit_plan,
-                    persona=persona,
-                    include_homework=homework,
-                    teacher_materials=kb_prompt_section,
+            if multi_agent:
+                # Multi-agent pipeline: researcher → writer → reviewer
+                from clawed.multi_agent import multi_agent_generate_master_content
+                from clawed.compile_teacher import compile_teacher_view
+                console.print("[dim]Using multi-agent pipeline (researcher→writer→reviewer)...[/dim]")
+                master = _run_async(
+                    multi_agent_generate_master_content(
+                        topic=topic,
+                        grade=grade,
+                        subject=subject,
+                        persona=persona,
+                        config=None,
+                        unit_context=kb_prompt_section,
+                    )
+                )
+                if master is None:
+                    console.print("[yellow]Multi-agent returned None, falling back to single-agent...[/yellow]")
+                    daily = _run_async(
+                        generate_lesson(
+                            lesson_number=lesson_num, unit=unit_plan,
+                            persona=persona, include_homework=homework,
+                            teacher_materials=kb_prompt_section,
+                        )
+                    )
+                else:
+                    daily = compile_teacher_view(master)
+            else:
+                daily = _run_async(
+                    generate_lesson(
+                        lesson_number=lesson_num,
+                        unit=unit_plan,
+                        persona=persona,
+                        include_homework=homework,
+                        teacher_materials=kb_prompt_section,
+                    )
                 )
-            )
         except (RuntimeError, ValueError) as e:
             console.print(f"[red]Generation failed:[/red] {e}")
             console.print("[dim]Run with --debug for full details[/dim]")

clawed-2.3.9/clawed/commands/train.py

@@ -0,0 +1,258 @@
+"""Continuous improvement pipeline for Claw-ED fleet agents.
+
+Usage:
+    clawed train --drive          Ingest from configured Google Drive folders
+    clawed train --path PATH      Ingest local materials and refine persona
+    clawed train --benchmark      Generate & score N lessons for quality check
+    clawed train --full           Drive ingest + benchmark in sequence
+"""
+
+from __future__ import annotations
+
+import json
+import random
+from datetime import date
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.table import Table
+
+from clawed.commands._helpers import console, run_async as _run_async
+
+train_app = typer.Typer(help="Continuous improvement pipeline.")
+
+_TRAINING_DIR = Path("~/.eduagent/training").expanduser()
+
+
+# ── Persona refinement helper ───────────────────────────────────────────
+
+async def _refine_persona(documents: list) -> None:
+    """Extract persona traits from new documents and merge into existing."""
+    from clawed.models import AppConfig, TeacherPersona
+    from clawed.persona import extract_persona, merge_persona, load_persona, save_persona
+    from clawed.commands._helpers import persona_path
+
+    config = AppConfig.load()
+    new_persona = await extract_persona(documents, config)
+
+    # Load existing persona if available
+    pp = persona_path()
+    if pp.exists():
+        existing = load_persona(pp)
+    else:
+        existing = TeacherPersona()
+
+    merged = merge_persona(existing, new_persona)
+    save_persona(merged, pp.parent)
+    console.print("[green]Persona updated.[/green]")
+
+
+# ── Drive ingest ────────────────────────────────────────────────────────
+
+async def _drive_ingest() -> list:
+    """Download and ingest from configured Drive URLs. Returns documents."""
+    from clawed.models import AppConfig
+    from clawed.drive import ingest_drive_folder
+    from clawed.ingestor import ingest_path
+
+    config = AppConfig.load()
+    drive_urls = config.teacher_profile.drive_urls
+
+    if not drive_urls:
+        console.print(
+            "[yellow]No Drive URLs configured.[/yellow] "
+            "Run [bold]clawed config profile[/bold] to add Google Drive folders."
+        )
+        return []
+
+    all_docs = []
+    for url in drive_urls:
+        console.print(f"[dim]Fetching:[/dim] {url}")
+        try:
+            docs = await ingest_drive_folder(url)
+            all_docs.extend(docs)
+            console.print(f"  -> {len(docs)} documents ingested")
+        except Exception as exc:
+            console.print(f"  [red]Error:[/red] {exc}")
+
+    if all_docs:
+        console.print(f"\n[green]{len(all_docs)} total documents from Drive.[/green]")
+    return all_docs
+
+
+# ── Path ingest ─────────────────────────────────────────────────────────
+
+def _path_ingest(path: Path) -> list:
+    """Ingest local files. Returns documents."""
+    from clawed.ingestor import ingest_path
+
+    if not path.exists():
+        console.print(f"[red]Path not found:[/red] {path}")
+        raise typer.Exit(1)
+
+    docs = ingest_path(path)
+    console.print(f"[green]{len(docs)} documents ingested from {path}[/green]")
+    return docs
+
+
+# ── Benchmark ───────────────────────────────────────────────────────────
+
+async def _run_benchmark(n: int) -> dict:
+    """Generate N lessons on random topics and score them. Returns report."""
+    from clawed.models import AppConfig, UnitPlan, LessonBrief, TeacherPersona
+    from clawed.lesson import generate_master_content
+    from clawed.quality import score_voice_match
+    from clawed.validation import validate_master_content
+    from clawed.llm import LLMClient
+    from clawed.commands._helpers import load_persona_or_exit
+
+    persona = load_persona_or_exit()
+    config = AppConfig.load()
+    client = LLMClient(config)
+
+    # Build a minimal unit for benchmarking
+    subjects = config.teacher_profile.subjects or ["General Studies"]
+    subject = random.choice(subjects)
+    grades = config.teacher_profile.grade_levels or persona.grade_levels or ["9"]
+    grade = random.choice(grades)
+
+    topics = [
+        "Causes of World War I", "Photosynthesis", "Linear Equations",
+        "The Civil Rights Movement", "Climate Change", "Shakespeare's Hamlet",
+        "The Water Cycle", "Fractions and Decimals", "Ancient Rome",
+        "Supply and Demand", "DNA and Genetics", "Poetry Analysis",
+    ]
+    sample_topics = random.sample(topics, min(n, len(topics)))
+
+    results = []
+    persona_ctx = persona.to_prompt_context()
+
+    for i, topic in enumerate(sample_topics, 1):
+        console.print(f"[dim]Generating lesson {i}/{n}: {topic}...[/dim]")
+        try:
+            unit = UnitPlan(
+                title=f"Benchmark: {topic}",
+                subject=subject,
+                grade_level=grade,
+                topic=topic,
+                duration_weeks=1,
+                overview=f"Benchmark lesson on {topic}",
+                daily_lessons=[LessonBrief(
+                    lesson_number=1,
+                    topic=topic,
+                    description=f"Students will understand key aspects of {topic}",
+                )],
+            )
+            mc = await generate_master_content(
+                lesson_number=1, unit=unit, persona=persona, config=config,
+            )
+
+            # Score voice match
+            lesson_text = mc.model_dump_json()[:3000]
+            voice_score = await score_voice_match(lesson_text, persona_ctx, client)
+
+            # Validate content structure
+            errors = validate_master_content(mc, topic)
+            pedagogy_score = max(1.0, 5.0 - len(errors) * 0.5)
+            diff_score = round((voice_score + pedagogy_score) / 2, 1)
+            overall = round((voice_score + pedagogy_score + diff_score) / 3, 1)
+
+            results.append({
+                "topic": topic,
+                "voice": round(voice_score, 1),
+                "pedagogy": round(pedagogy_score, 1),
+                "differentiation": diff_score,
+                "overall": overall,
+                "errors": errors,
+            })
+        except Exception as exc:
+            console.print(f"  [red]Failed:[/red] {exc}")
+            results.append({
+                "topic": topic,
+                "voice": 0.0, "pedagogy": 0.0,
+                "differentiation": 0.0, "overall": 0.0,
+                "errors": [str(exc)],
+            })
+
+    # Display table
+    table = Table(title=f"Benchmark Results ({len(results)} lessons)")
+    table.add_column("Topic", style="bold")
+    table.add_column("Voice", justify="right")
+    table.add_column("Pedagogy", justify="right")
+    table.add_column("Differentiation", justify="right")
+    table.add_column("Overall", justify="right")
+
+    for r in results:
+        table.add_row(
+            r["topic"][:20],
+            f"{r['voice']:.1f}",
+            f"{r['pedagogy']:.1f}",
+            f"{r['differentiation']:.1f}",
+            f"{r['overall']:.1f}",
+        )
+    console.print(table)
+
+    # Save report
+    report = {
+        "date": str(date.today()),
+        "n": len(results),
+        "results": results,
+        "avg_overall": round(
+            sum(r["overall"] for r in results) / max(len(results), 1), 2
+        ),
+    }
+    _TRAINING_DIR.mkdir(parents=True, exist_ok=True)
+    report_path = _TRAINING_DIR / f"{date.today()}_train_report.json"
+    report_path.write_text(json.dumps(report, indent=2), encoding="utf-8")
+    console.print(f"[dim]Report saved: {report_path}[/dim]")
+
+    return report
+
+
+# ── Main command ────────────────────────────────────────────────────────
+
+@train_app.callback(invoke_without_command=True)
+def train(
+    drive: bool = typer.Option(False, "--drive", help="Ingest from Google Drive folders"),
+    path: Optional[str] = typer.Option(None, "--path", help="Ingest local materials"),
+    benchmark: bool = typer.Option(False, "--benchmark", help="Generate & score lessons"),
+    n: int = typer.Option(3, "-n", help="Number of benchmark lessons"),
+    full: bool = typer.Option(False, "--full", help="Run drive + benchmark"),
+) -> None:
+    """Continuous improvement pipeline for Claw-ED fleet agents."""
+
+    if not any([drive, path, benchmark, full]):
+        console.print(
+            "[yellow]Specify a mode:[/yellow] --drive, --path, --benchmark, or --full\n"
+            "Run [bold]clawed train --help[/bold] for details."
+        )
+        raise typer.Exit(0)
+
+    async def _execute():
+        docs = []
+
+        # Drive ingest
+        if drive or full:
+            docs = await _drive_ingest()
+            if docs:
+                await _refine_persona(docs)
+
+        # Path ingest
+        if path:
+            local_docs = _path_ingest(Path(path))
+            if local_docs:
+                await _refine_persona(local_docs)
+                docs.extend(local_docs)
+
+        # Benchmark
+        if benchmark or full:
+            await _run_benchmark(n)
+
+        if docs:
+            console.print(
+                f"\n[bold green]Training complete.[/bold green] "
+                f"{len(docs)} documents processed."
+            )
+
+    _run_async(_execute())

{clawed-2.3.8 → clawed-2.3.9}/clawed/config.py

@@ -65,10 +65,35 @@ def _try_keyring_delete(key: str) -> bool:
         return False
 
 
+def _resolve_claude_code_token() -> Optional[str]:
+    """Read fresh OAuth token from Claude Code credential store.
+
+    Claude Code auto-refreshes OAuth tokens and stores them in
+    ~/.claude/.credentials.json. Using this as a source means Claw-ED
+    never hits expired tokens when Claude Code is installed.
+    """
+    import json as _json
+    for path in [
+        Path.home() / ".claude" / ".credentials.json",
+        Path.home() / ".claude.json",
+    ]:
+        if path.exists():
+            try:
+                data = _json.loads(path.read_text(encoding="utf-8"))
+                oauth = data.get("claudeAiOauth", {})
+                token = oauth.get("accessToken", "")
+                if token and token.startswith("sk-ant-"):
+                    return token
+            except (ValueError, KeyError, OSError):
+                continue
+    return None
+
+
 def get_api_key(provider: str) -> Optional[str]:
     """Retrieve an API key for the given provider.
 
-    Priority: environment variable > keyring > secrets.json file.
+    Priority: environment variable > Claude Code credentials (anthropic only)
+              > keyring > secrets.json file.
     """
     env_map = {
         "anthropic": "ANTHROPIC_API_KEY",
@@ -86,6 +111,12 @@ def get_api_key(provider: str) -> Optional[str]:
         if val:
             return val
 
+    # Claude Code credential store — auto-refreshing OAuth tokens
+    if provider == "anthropic":
+        cc_token = _resolve_claude_code_token()
+        if cc_token:
+            return cc_token
+
     key_name = f"{provider}_api_key"
     val = _try_keyring_get(key_name)
     if val:
@@ -214,12 +245,9 @@ async def test_llm_connection(config: Optional[AppConfig] = None) -> dict:
             return _result(False, model, "No API key configured", is_err=True)
         import httpx
         try:
+            from clawed.agent import _anthropic_headers
             async with httpx.AsyncClient(timeout=15.0) as client:
-                headers = {
-                    "x-api-key": api_key,
-                    "anthropic-version": "2023-06-01",
-                    "content-type": "application/json",
-                }
+                headers = _anthropic_headers(api_key)
                 body = {
                     "model": model, "max_tokens": 5,
                     "messages": [{"role": "user", "content": "Hi"}],