agent-apprenticeship 0.1.5 → 0.1.7

package/src/agent_apprenticeship_trace/bundle_exporter.py

@@ -6,10 +6,12 @@ import re
 from pathlib import Path
 from typing import Any
 
-from .config import Settings, get_settings, normalize_mentor_mode
+from .config import Settings, apprenticeship_mode_display, get_settings, normalize_apprenticeship_mode, normalize_mentor_mode
 from .io import append_jsonl, read_json, read_jsonl, write_json
 from .public_sanitizer import sanitize_public_obj, sanitize_public_text
 from .release_exporter import create_release
+from .tdo import tdo_manifest_fields_from_report
+from .loop_review import summarize_loop_reviews
 
 
 def _count_jsonl(path: Path) -> int:
@@ -96,7 +98,7 @@ def contribution_counts(release_root: Path) -> dict[str, int]:
 
 def _write_card(bundle_root: Path) -> None:
     (bundle_root / "contribution_card.md").write_text(
-        "# Agent Apprenticeship Contribution Bundle\n\n"
+        "# Agent Apprenticeship Agent Experience Package\n\n"
         "This local bundle packages an apprenticeship session for public ecosystem contribution. "
         "It includes session events, task instructions, traces, actual outputs, evaluation results, "
         "and learning-data views when available.\n\n"
@@ -110,6 +112,15 @@ def _session_mentor_mode(session: dict[str, Any], settings: Settings) -> str:
     return normalize_mentor_mode(session.get("mentor_mode") or session.get("evaluation_mode") or settings.mentor_mode)
 
 
+def _session_apprenticeship_mode(session: dict[str, Any], settings: Settings) -> str:
+    return normalize_apprenticeship_mode(
+        session.get("apprenticeship_mode")
+        or session.get("mentor_mode")
+        or session.get("evaluation_mode")
+        or settings.apprenticeship_mode
+    )
+
+
 def _clean_session_metadata(session: dict[str, Any], settings: Settings) -> dict[str, Any]:
     allowed = {
         "run_id",
@@ -128,6 +139,8 @@ def _clean_session_metadata(session: dict[str, Any], settings: Settings) -> dict
         "session_status",
     }
     clean = {k: v for k, v in session.items() if k in allowed and v is not None}
+    clean["apprenticeship_mode"] = _session_apprenticeship_mode(session, settings)
+    clean["apprenticeship_mode_display"] = apprenticeship_mode_display(clean["apprenticeship_mode"])
     clean["mentor_mode"] = _session_mentor_mode(session, settings)
     return clean
 
@@ -141,6 +154,8 @@ def _copy_session_files(run_root: Path, bundle_root: Path, settings: Settings) -
         shutil.copytree(run_root / "task", bundle_root / "task", dirs_exist_ok=True)
     if (run_root / "mentor_checkpoints").exists():
         shutil.copytree(run_root / "mentor_checkpoints", bundle_root / "mentor_checkpoints", dirs_exist_ok=True)
+    if (run_root / "loops").exists():
+        shutil.copytree(run_root / "loops", bundle_root / "loops", dirs_exist_ok=True)
 
 
 def _copy_clean_bundle_files(release_root: Path, bundle_root: Path, include_debug: bool) -> None:
@@ -153,6 +168,9 @@ def _copy_clean_bundle_files(release_root: Path, bundle_root: Path, include_debu
     _copy_jsonl_if_nonempty(release_root / "actual_outputs.jsonl", bundle_root / "outputs" / "actual_outputs.jsonl")
     _copy_json_if_exists(release_root / "artifacts_index.json", bundle_root / "outputs" / "artifacts_index.json")
     _copy_indexed_package_files(release_root, bundle_root)
+    _copy_tdo_outputs(release_root, bundle_root)
+    _copy_experience_compiler_outputs(release_root, bundle_root)
+    _copy_loop_review_outputs(release_root, bundle_root)
 
     for name in [
         "grader_results.jsonl",
@@ -214,6 +232,42 @@ def _copy_indexed_package_files(release_root: Path, bundle_root: Path) -> None:
     write_json(bundle_root / "outputs" / "artifacts_index.json", rewritten)
 
 
+def _copy_tdo_outputs(release_root: Path, bundle_root: Path) -> None:
+    package_tdo_dirs = sorted(path for path in (release_root / "packages").glob("*/tdo") if path.is_dir())
+    if not package_tdo_dirs:
+        return
+    if len(package_tdo_dirs) == 1:
+        shutil.copytree(package_tdo_dirs[0], bundle_root / "tdo", dirs_exist_ok=True)
+        return
+    for src in package_tdo_dirs:
+        target = bundle_root / "tdo" / src.parent.name
+        shutil.copytree(src, target, dirs_exist_ok=True)
+
+
+def _copy_experience_compiler_outputs(release_root: Path, bundle_root: Path) -> None:
+    package_dirs = sorted(path for path in (release_root / "packages").glob("*/experience_compiler") if path.is_dir())
+    if not package_dirs:
+        return
+    if len(package_dirs) == 1:
+        shutil.copytree(package_dirs[0], bundle_root / "experience_compiler", dirs_exist_ok=True)
+        return
+    for src in package_dirs:
+        target = bundle_root / "experience_compiler" / src.parent.name
+        shutil.copytree(src, target, dirs_exist_ok=True)
+
+
+def _copy_loop_review_outputs(release_root: Path, bundle_root: Path) -> None:
+    package_dirs = sorted(path for path in (release_root / "packages").glob("*/loops") if path.is_dir())
+    if not package_dirs:
+        return
+    if len(package_dirs) == 1:
+        shutil.copytree(package_dirs[0], bundle_root / "loops", dirs_exist_ok=True)
+        return
+    for src in package_dirs:
+        target = bundle_root / "loops" / src.parent.name
+        shutil.copytree(src, target, dirs_exist_ok=True)
+
+
 def is_unsafe_bundle_ref(ref: str) -> bool:
     path = Path(ref)
     return path.is_absolute() or ".." in path.parts
@@ -263,6 +317,8 @@ def _bundle_metadata_shape(bundle_root: Path, release_root: Path, settings: Sett
         "agent_apprentice_role": role,
         "expected_economic_value": task.get("expected_economic_value"),
         "expected_economic_value_for_agent_apprentice": task.get("expected_economic_value_for_agent_apprentice"),
+        "apprenticeship_mode": _session_apprenticeship_mode(session, settings),
+        "apprenticeship_mode_display": apprenticeship_mode_display(_session_apprenticeship_mode(session, settings)),
         "mentor_mode": _session_mentor_mode(session, settings),
         "task_status": task_status,
         "run_status": run_status,
@@ -280,9 +336,83 @@ def _write_manifest(bundle_root: Path, release_root: Path, settings: Settings, i
         manifest["status_reason"] = session["status_reason"]
     if include_internal_schema:
         manifest["source_release_schema_version"] = release_manifest.get("schema_version")
+    manifest.update(_tdo_manifest_shape(release_root))
+    manifest.update(_loop_manifest_shape(release_root))
     write_json(bundle_root / "contribution_manifest.json", manifest)
 
 
+def _loop_manifest_shape(release_root: Path) -> dict[str, Any]:
+    summary = summarize_loop_reviews(release_root)
+    return {
+        "has_loop_review_packets": summary.get("has_loop_review_packets"),
+        "loop_iteration_count": summary.get("loop_iteration_count"),
+        "loop_reviewer_types": summary.get("reviewer_types") or [],
+        "final_loop_verdict": summary.get("final_loop_verdict"),
+        "loop_review_refs": summary.get("loop_review_refs") or [],
+    }
+
+
+def _tdo_manifest_shape(release_root: Path) -> dict[str, Any]:
+    reports = []
+    for path in sorted((release_root / "packages").glob("*/tdo/tdo_report.json")):
+        try:
+            reports.append(read_json(path))
+        except Exception:
+            continue
+    if not reports:
+        return {
+            "tdo_enabled": False,
+            "tdo_status": "not_run",
+            "tdo_output_refs": [],
+            "experience_compiler_enabled": False,
+            "experience_compiler_status": "not_run",
+            "experience_compiler_output_refs": [],
+        }
+    latest = reports[-1]
+    output_refs: list[str] = []
+    package_tdo_dirs = sorted(path for path in (release_root / "packages").glob("*/tdo") if path.is_dir())
+    if len(package_tdo_dirs) == 1:
+        for child in sorted(package_tdo_dirs[0].iterdir()):
+            if child.is_file():
+                output_refs.append(f"tdo/{child.name}")
+    else:
+        for src in package_tdo_dirs:
+            for child in sorted(src.iterdir()):
+                if child.is_file():
+                    output_refs.append(f"tdo/{src.parent.name}/{child.name}")
+    fields = tdo_manifest_fields_from_report(latest)
+    fields["tdo_output_refs"] = output_refs
+    fields.update(_experience_compiler_manifest_shape(release_root, latest))
+    if len(reports) > 1:
+        fields["tdo_package_count"] = len(reports)
+    return fields
+
+
+def _experience_compiler_manifest_shape(release_root: Path, latest_report: dict[str, Any]) -> dict[str, Any]:
+    compiler_dirs = sorted(path for path in (release_root / "packages").glob("*/experience_compiler") if path.is_dir())
+    refs: list[str] = []
+    if len(compiler_dirs) == 1:
+        for child in sorted(compiler_dirs[0].rglob("*")):
+            if child.is_file():
+                refs.append(f"experience_compiler/{child.relative_to(compiler_dirs[0]).as_posix()}")
+    else:
+        for src in compiler_dirs:
+            for child in sorted(src.rglob("*")):
+                if child.is_file():
+                    refs.append(f"experience_compiler/{src.parent.name}/{child.relative_to(src).as_posix()}")
+    return {
+        "experience_compiler_enabled": bool(compiler_dirs),
+        "experience_compiler_status": latest_report.get("tdo_status"),
+        "experience_compiler_id": str(latest_report.get("tdo_id") or "").replace("tdo_", "compiler_", 1),
+        "experience_compiler_output_refs": refs,
+        "experience_compiler_rows_by_type": latest_report.get("rows_accepted_by_type") or {},
+        "experience_compiler_rounds_run": latest_report.get("rounds_run"),
+        "experience_compiler_average_quality_score": latest_report.get("average_quality_score"),
+        "experience_compiler_average_reuse_value_score": latest_report.get("average_reuse_value_score"),
+        "experience_compiler_judge_source": latest_report.get("tdo_judge_source"),
+    }
+
+
 def create_contribution_bundle(
     run_root: Path,
     bundle_root: Path | None = None,