scripts/eval_ashes_role_adapters.py

# /// script
# dependencies = [
#   "torch>=2.3.0",
#   "transformers>=4.45.0",
#   "peft>=0.13.0",
#   "datasets>=2.20.0",
#   "huggingface_hub>=0.24.0",
#   "accelerate>=0.33.0",
#   "safetensors>=0.4.5"
# ]
# ///

import json
import os
import re
import tempfile
from datetime import datetime, timezone
from pathlib import Path

import torch
from huggingface_hub import HfApi, snapshot_download
from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer

BASE_MODEL = "Qwen/Qwen2.5-0.5B-Instruct"
DATASET_REPO = "KevHamm07/openclaw-ashes-real-creative-sft"
REVISION_TAG = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
OUT_PREFIX = f"eval_results/smoke_role_comparison_{REVISION_TAG}"

ROLES = {
    "MUSE": {
        "adapter": "KevHamm07/openclaw-muse-ashes-qwen05b-lora-smoke-v0.1",
        "prompt_file": "evals/muse_ashes_real_eval_prompts.jsonl",
        "role_fit_terms": ["panel", "beat", "scene", "dialogue", "manga", "arc", "quest", "reader", "draft", "proposed"],
        "must_terms": ["proposed", "canon", "beat"],
    },
    "LOREWEAVER": {
        "adapter": "KevHamm07/openclaw-loreweaver-ashes-qwen05b-lora-smoke-v0.1",
        "prompt_file": "evals/loreweaver_ashes_real_eval_prompts.jsonl",
        "role_fit_terms": ["canon", "evidence", "approved", "proposed", "contradiction", "continuity", "state", "consequence", "revision"],
        "must_terms": ["canon", "evidence", "proposed"],
    },
    "PRISM": {
        "adapter": "KevHamm07/openclaw-prism-ashes-qwen05b-lora-smoke-v0.1",
        "prompt_file": "evals/prism_ashes_real_eval_prompts.jsonl",
        "role_fit_terms": ["visual", "panel", "readability", "staging", "composition", "continuity", "balloon", "anatomy", "emotion", "qa"],
        "must_terms": ["visual", "panel", "issue"],
    },
}

SYSTEM_BY_ROLE = {
    "MUSE": "You are MUSE, OpenClaw's manga story editor. Produce concrete scene/script/comic beat guidance. Keep canon-impacting claims labeled proposed until LOREWEAVER approves them. Do not discuss tooling or FORGE.",
    "LOREWEAVER": "You are LOREWEAVER, OpenClaw's canon continuity specialist. Separate approved canon, proposed canon, evidence, contradictions, consequences, and required revisions. Preserve truth-before-legend. Do not discuss tooling or FORGE.",
    "PRISM": "You are PRISM, OpenClaw's visual QA specialist. Review readability, staging, anatomy/composition, lettering/balloon pacing, and visual continuity. You may flag issues but cannot approve canon. Do not discuss tooling or FORGE.",
}

CANON_CONTEXT = """
OpenClaw / Ashes of the Witness Flame context:
- Truth-before-legend: story/canon must mythologize real operational work without inventing accomplishments.
- Canon-impacting claims must be labeled approved, proposed, contradicted, or needs evidence.
- MUSE drafts scenes, manga beats, dialogue guidance, and panel handoffs.
- LOREWEAVER approves/blocks canon continuity and preserves evidence-backed state.
- PRISM reviews visual execution/readability and flags issues; PRISM does not approve canon.
- FORGE/toolsmith/dashboard implementation is a separate lane and must not contaminate creative/canon responses.
""".strip()


def load_prompts(cache_dir: Path):
    local_dir = snapshot_download(repo_id=DATASET_REPO, repo_type="dataset", allow_patterns="evals/*.jsonl")
    prompts = {}
    for role, cfg in ROLES.items():
        rows = []
        with open(Path(local_dir) / cfg["prompt_file"], "r", encoding="utf-8") as f:
            for line in f:
                line = line.strip()
                if line:
                    rows.append(json.loads(line))
        prompts[role] = rows
    return prompts


def format_messages(tokenizer, role: str, user_prompt: str):
    messages = [
        {"role": "system", "content": SYSTEM_BY_ROLE[role]},
        {"role": "user", "content": f"{CANON_CONTEXT}\n\nTask: {user_prompt}\n\nReturn concise sections with concrete bullets. Label canon-impacting claims as proposed unless evidence is provided."},
    ]
    try:
        return tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
    except Exception:
        return f"System: {messages[0]['content']}\nUser: {messages[1]['content']}\nAssistant:"


def generate(model, tokenizer, role, prompt):
    text = format_messages(tokenizer, role, prompt)
    inputs = tokenizer(text, return_tensors="pt").to(model.device)
    with torch.no_grad():
        output = model.generate(
            **inputs,
            max_new_tokens=360,
            do_sample=False,
            temperature=None,
            top_p=None,
            repetition_penalty=1.05,
            pad_token_id=tokenizer.eos_token_id,
        )
    gen = output[0][inputs["input_ids"].shape[-1]:]
    return tokenizer.decode(gen, skip_special_tokens=True).strip()


def score_output(role, text):
    lower = text.lower()
    cfg = ROLES[role]
    score = 0
    flags = []
    # 10 point heuristic score; conservative and reproducible.
    role_hits = sum(1 for term in cfg["role_fit_terms"] if term in lower)
    score += min(3, role_hits // 2)
    if all(term in lower for term in cfg["must_terms"]):
        score += 2
    else:
        missing = [t for t in cfg["must_terms"] if t not in lower]
        flags.append(f"missing role-critical terms: {', '.join(missing)}")
    if any(marker in lower for marker in ["- ", "1.", "approved", "proposed", "issues", "fixes", "evidence"]):
        score += 1
    else:
        flags.append("low structure/actionability")
    if "truth-before-legend" in lower or ("evidence" in lower and "proposed" in lower):
        score += 1
    else:
        flags.append("weak truth-before-legend/evidence framing")
    if "forge" not in lower and "toolsmith" not in lower and "dashboard" not in lower:
        score += 1
    else:
        flags.append("lane contamination risk")
    if len(text.split()) >= 80:
        score += 1
    else:
        flags.append("too thin/short")
    if len(text.split()) <= 260:
        score += 1
    else:
        flags.append("too verbose for mini eval")
    # Role-specific critical checks.
    if role == "LOREWEAVER" and not any(x in lower for x in ["approved canon", "proposed canon", "canon status", "status"]):
        flags.append("does not clearly separate canon status")
        score = min(score, 7)
    if role == "PRISM" and any(x in lower for x in ["approved canon", "canon approved", "i approve"]):
        flags.append("PRISM overreaches into canon approval")
        score = min(score, 5)
    if role == "MUSE" and not any(x in lower for x in ["panel", "beat", "scene", "dialogue"]):
        flags.append("MUSE output lacks scene/panel/beat execution")
        score = min(score, 6)
    return max(0, min(10, score)), flags


def summarize(results):
    summary = {}
    weak_cases = []
    for role in ROLES:
        role_rows = [r for r in results if r["role"] == role]
        summary[role] = {}
        for model_kind in ["base", "adapter"]:
            rows = [r for r in role_rows if r["model_kind"] == model_kind]
            avg = sum(r["score"] for r in rows) / len(rows)
            weak = [r for r in rows if r["score"] < 8 or r["flags"]]
            summary[role][model_kind] = {
                "avg_score": round(avg, 2),
                "weak_cases": len(weak),
                "scores": [r["score"] for r in rows],
            }
        paired = []
        for case in sorted({r["case_id"] for r in role_rows}):
            base = next(r for r in role_rows if r["case_id"] == case and r["model_kind"] == "base")
            adapter = next(r for r in role_rows if r["case_id"] == case and r["model_kind"] == "adapter")
            if adapter["score"] > base["score"]:
                result = "adapter_win"
            elif adapter["score"] < base["score"]:
                result = "base_win"
            else:
                result = "tie"
            paired.append({"case_id": case, "base": base["score"], "adapter": adapter["score"], "result": result})
            if adapter["score"] < 8 or adapter["flags"]:
                weak_cases.append({
                    "role": role,
                    "case_id": case,
                    "adapter_score": adapter["score"],
                    "base_score": base["score"],
                    "flags": adapter["flags"],
                })
        summary[role]["comparison"] = {
            "adapter_wins": sum(1 for p in paired if p["result"] == "adapter_win"),
            "ties": sum(1 for p in paired if p["result"] == "tie"),
            "base_wins": sum(1 for p in paired if p["result"] == "base_win"),
            "paired": paired,
        }
        summary[role]["delta_adapter_minus_base"] = round(summary[role]["adapter"]["avg_score"] - summary[role]["base"]["avg_score"], 2)
    return summary, weak_cases


def main():
    api = HfApi()
    work = Path(tempfile.mkdtemp(prefix="ashes_eval_"))
    prompts = load_prompts(work)
    tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL)
    if tokenizer.pad_token is None:
        tokenizer.pad_token = tokenizer.eos_token

    dtype = torch.float16 if torch.cuda.is_available() else torch.float32
    device_map = "auto"
    base_model = AutoModelForCausalLM.from_pretrained(BASE_MODEL, torch_dtype=dtype, device_map=device_map)
    base_model.eval()

    results = []
    for role, rows in prompts.items():
        for row in rows:
            output = generate(base_model, tokenizer, role, row["prompt"])
            score, flags = score_output(role, output)
            results.append({
                "role": role,
                "case_id": row["id"],
                "prompt": row["prompt"],
                "model_kind": "base",
                "model_id": BASE_MODEL,
                "score": score,
                "flags": flags,
                "output": output,
            })

    del base_model
    if torch.cuda.is_available():
        torch.cuda.empty_cache()

    # Load each adapter from a fresh base to avoid cross-adapter contamination.
    for role, cfg in ROLES.items():
        model = AutoModelForCausalLM.from_pretrained(BASE_MODEL, torch_dtype=dtype, device_map=device_map)
        model = PeftModel.from_pretrained(model, cfg["adapter"])
        model.eval()
        for row in prompts[role]:
            output = generate(model, tokenizer, role, row["prompt"])
            score, flags = score_output(role, output)
            results.append({
                "role": role,
                "case_id": row["id"],
                "prompt": row["prompt"],
                "model_kind": "adapter",
                "model_id": cfg["adapter"],
                "score": score,
                "flags": flags,
                "output": output,
            })
        del model
        if torch.cuda.is_available():
            torch.cuda.empty_cache()

    summary, weak_cases = summarize(results)
    report_lines = [
        "# Ashes Creative Specialist Smoke Eval — Base vs Adapter",
        "",
        f"Generated: {REVISION_TAG}",
        f"Base model: `{BASE_MODEL}`",
        "",
        "## Summary",
        "",
        "| Role | Base avg | Adapter avg | Delta | Adapter wins / ties / base wins | Adapter weak cases | Decision |",
        "|---|---:|---:|---:|---:|---:|---|",
    ]
    for role in ROLES:
        s = summary[role]
        comp = s["comparison"]
        decision = "DO NOT WIRE"
        report_lines.append(
            f"| {role} | {s['base']['avg_score']:.2f} | {s['adapter']['avg_score']:.2f} | {s['delta_adapter_minus_base']:+.2f} | "
            f"{comp['adapter_wins']} / {comp['ties']} / {comp['base_wins']} | {s['adapter']['weak_cases']} | {decision} |"
        )
    report_lines += [
        "",
        "## Weak cases needing v0.2 correction rows",
        "",
    ]
    if weak_cases:
        for w in weak_cases:
            report_lines.append(f"- **{w['role']} / {w['case_id']}** — adapter {w['adapter_score']} vs base {w['base_score']}; flags: {', '.join(w['flags']) if w['flags'] else 'score below gate'}")
    else:
        report_lines.append("- None under heuristic gate; still requires human/reviewer QA before wiring.")
    report_lines += [
        "",
        "## Gate",
        "",
        "DO NOT WIRE. This was a heuristic smoke eval only. Promotion still requires local/ephemeral reviewer QA, role-critical manual review, and user approval.",
    ]

    out_dir = work / "out"
    out_dir.mkdir(parents=True, exist_ok=True)
    (out_dir / "summary.json").write_text(json.dumps(summary, indent=2), encoding="utf-8")
    (out_dir / "weak_cases.json").write_text(json.dumps(weak_cases, indent=2), encoding="utf-8")
    with open(out_dir / "raw_outputs.jsonl", "w", encoding="utf-8") as f:
        for r in results:
            f.write(json.dumps(r, ensure_ascii=False) + "\n")
    (out_dir / "report.md").write_text("\n".join(report_lines) + "\n", encoding="utf-8")

    api.upload_folder(
        folder_path=str(out_dir),
        repo_id=DATASET_REPO,
        repo_type="dataset",
        path_in_repo=OUT_PREFIX,
        commit_message=f"Add smoke role eval comparison {REVISION_TAG}",
    )
    print(json.dumps({
        "out_prefix": OUT_PREFIX,
        "summary": summary,
        "weak_cases": weak_cases,
        "report_url": f"https://huggingface.co/datasets/{DATASET_REPO}/tree/main/{OUT_PREFIX}",
    }, indent=2))

if __name__ == "__main__":
    main()