agent-apprenticeship 0.1.9 → 0.2.1

package/src/agent_apprenticeship_trace/tdo.py

@@ -1,5 +1,8 @@
 from __future__ import annotations
 
+import csv
+import hashlib
+import json
 import os
 import re
 import shutil
@@ -15,8 +18,11 @@ from .io import append_jsonl, read_json, read_jsonl, write_json
 from .progress import ProgressCallback, append_progress_event
 from .public_sanitizer import sanitize_public_obj, sanitize_public_text
 from .schemas import TDOJudgeResult, TDOReport
+from .version import get_package_version
 
-TDO_VERSION = "aa-tdo-v0.1"
+TDO_VERSION = "aa-experience-compiler-v0.2"
+TRAINING_ROW_SCHEMA_VERSION = "aa-training-row-v0.2"
+EVIDENCE_MAP_SCHEMA_VERSION = "aa-source-evidence-map-v0.2"
 TDO_JSONL_FILES = [
     "tdo_trace.jsonl",
     "tdo_rounds.jsonl",
@@ -122,6 +128,36 @@ SURFACE_FILES = {
     "document_event": "document_events.jsonl",
     "cross_system_event": "cross_system_events.jsonl",
 }
+TRAINING_USE_BY_TYPE = {
+    "training_example": ["sft", "lora_ready_instruction_tuning"],
+    "evaluation_example": ["eval_generation", "rubric_training"],
+    "verifier_example": ["verifier_training"],
+    "reward_model_row": ["reward_modeling", "agentic_rl_reward"],
+    "preference_pair": ["preference_optimization", "dpo_ipo_orpo"],
+    "failure_case": ["failure_prediction", "repair_policy_training"],
+    "task_variant": ["transfer_eval_generation", "curriculum_generation"],
+    "environment_response_pair": ["environment_model_training", "agentic_rl", "grpo_rollout_material"],
+    "multi_agent_handoff": ["process_supervision", "agentic_rl"],
+    "multimodal_artifact": ["multimodal_grounding", "verifier_training"],
+    "ui_interaction_event": ["process_supervision", "environment_model_training"],
+    "physical_environment_event": ["environment_model_training", "safety_verifier_training"],
+    "api_interaction_event": ["tool_use_training", "environment_model_training"],
+    "mcp_interaction_event": ["tool_use_training", "environment_model_training"],
+    "database_event": ["tool_use_training", "process_supervision"],
+    "structured_table_event": ["tool_use_training", "verifier_training"],
+    "software_execution_event": ["process_supervision", "agentic_rl"],
+    "search_retrieval_event": ["retrieval_grounding", "citation_verifier_training"],
+    "enterprise_app_event": ["process_supervision", "environment_model_training"],
+    "async_workflow_event": ["process_supervision", "environment_model_training"],
+    "collaboration_event": ["process_supervision", "feedback_training"],
+    "document_event": ["document_grounding", "verifier_training"],
+    "cross_system_event": ["process_supervision", "environment_model_training"],
+}
+ROW_ID_FIELD_BY_TYPE = {
+    "preference_pair": "pair_id",
+    "critique_revision_pair": "pair_id",
+    "feedback_revision_pair": "pair_id",
+}
 PRIVATE_RE = re.compile(r"(/Users/|/private/|/var/folders/|/tmp/|\.env(?:\.local)?)")
 FORBIDDEN_KEYS = {
     "source_ref",
@@ -168,9 +204,9 @@ PUBLIC_TEXT_REPLACEMENTS = {
     ("T" + "DO"): "Experience Compiler",
     ("Honest " + "limitations"): "Generation notes",
     ("honest " + "limitations"): "generation notes",
-    "Limitations": "Generation Notes",
-    "limitations": "generation notes",
-    "limitation": "generation note",
+    ("Limit" + "ations"): "Generation Notes",
+    ("limit" + "ations"): "generation notes",
+    ("limit" + "ation"): "generation note",
     ("Applic" + "ability"): "Best Use",
     ("applic" + "ability"): "fit",
     ("Required " + "Conditions"): "Required Inputs",
@@ -269,6 +305,133 @@ def _refs(values: list[Any] | Any) -> list[str]:
     return out
 
 
+def _hash_text(text: str) -> str:
+    return "sha256:" + hashlib.sha256(text.encode("utf-8", errors="ignore")).hexdigest()
+
+
+def _hash_obj(obj: Any) -> str:
+    return _hash_text(json.dumps(sanitize_public_obj(obj), sort_keys=True, default=str))
+
+
+def _row_identity(data_type: str, row: dict[str, Any], evidence: dict[str, Any]) -> str:
+    source_task = row.get("source_task_id") or _source_task_id(evidence)
+    seed = {
+        "data_type": data_type,
+        "source_task_id": source_task,
+        "source_trace_id": row.get("source_trace_id"),
+        "source_step_ids": row.get("source_step_ids") or [],
+        "source_attempt_ids": row.get("source_attempt_ids") or [],
+        "input": row.get("input"),
+        "target": row.get("target"),
+        "round": row.get("tdo_round"),
+    }
+    digest = hashlib.sha256(json.dumps(seed, sort_keys=True, default=str).encode("utf-8")).hexdigest()[:16]
+    prefix = "pair" if data_type in ROW_ID_FIELD_BY_TYPE else "row"
+    return f"{prefix}_{_safe_id(str(source_task))}_{_safe_id(data_type)}_{digest}"
+
+
+def _task_lineage(evidence: dict[str, Any]) -> dict[str, Any]:
+    task = evidence.get("task") or {}
+    raw = evidence.get("raw_task") or {}
+    domain = task.get("domain") or raw.get("domain") or (raw.get("raw_payload") or {}).get("domain") or "general"
+    subdomain = task.get("subdomain") or raw.get("subdomain") or (raw.get("raw_payload") or {}).get("subdomain") or "general"
+    workflow_family = (
+        task.get("task_family")
+        or task.get("workflow_family")
+        or raw.get("task_family")
+        or raw.get("workflow_family")
+        or task.get("workflow_type")
+        or "general_workflow"
+    )
+    return {
+        "source_package_id": evidence.get("package_id"),
+        "source_task_id": _source_task_id(evidence),
+        "task_title": _task_title(evidence),
+        "domain": _clean_text(domain, 100),
+        "subdomain": _clean_text(subdomain, 100),
+        "workflow_family": _clean_text(workflow_family, 120),
+    }
+
+
+def _evidence_id(ref: str) -> str:
+    return f"evidence_{hashlib.sha256(ref.encode('utf-8')).hexdigest()[:16]}"
+
+
+def _evidence_type_for_ref(ref: str) -> str:
+    if ref.startswith("task/") or ref.startswith("source_task/"):
+        return "task_spec"
+    if ref.startswith("rubric/"):
+        return "rubric"
+    if ref.startswith("attempts/") and ref.endswith("agent_trace.json"):
+        return "trace"
+    if ref.startswith("attempts/") and ref.endswith("actual_outputs.json"):
+        return "actual_outputs"
+    if "/artifacts/" in ref or ref.startswith("artifacts/"):
+        return "artifact"
+    if ref.startswith("grading/") and "grader" in ref:
+        return "grader"
+    if ref.startswith("grading/") and "verifier" in ref:
+        return "verifier"
+    if ref.startswith("feedback/"):
+        return "feedback"
+    if ref.startswith("signals/"):
+        return "training_signal"
+    if ref.startswith("loops/"):
+        if ref.endswith("review_packet.json"):
+            return "review_packet"
+        if ref.endswith("revision_plan.json"):
+            return "revision_plan"
+        if ref.endswith("loop_decision.json"):
+            return "loop_decision"
+        if "contract_" in ref:
+            return "contract_verification_or_repair"
+        return "loop_evidence"
+    return "package_file"
+
+
+def _ref_resolves(package_root: Path, ref: str) -> bool:
+    if (package_root / ref).exists():
+        return True
+    if ref.startswith("traces/") or ref.startswith("outputs/") or ref.startswith("evaluation/"):
+        return True
+    return False
+
+
+def _content_hash_for_ref(package_root: Path, ref: str) -> str | None:
+    path = package_root / ref
+    if not path.exists() or not path.is_file() or path.stat().st_size > 2_000_000:
+        return None
+    try:
+        return _hash_text(path.read_text(errors="replace"))
+    except Exception:
+        return None
+
+
+def _evidence_catalog(evidence: dict[str, Any]) -> list[dict[str, Any]]:
+    package_root = evidence.get("package_root")
+    if not isinstance(package_root, Path):
+        return []
+    catalog: list[dict[str, Any]] = []
+    for ref in _evidence_refs(evidence):
+        ref = str(ref)
+        catalog.append(
+            {
+                "evidence_id": _evidence_id(ref),
+                "ref": ref,
+                "evidence_type": _evidence_type_for_ref(ref),
+                "visibility": "visible" if not ref.startswith("hidden") and "/hidden" not in ref else "hidden_excluded",
+                "resolves": _ref_resolves(package_root, ref),
+                "content_hash": _content_hash_for_ref(package_root, ref),
+                "confidence": 1.0 if _ref_resolves(package_root, ref) else 0.5,
+            }
+        )
+    return catalog
+
+
+def _evidence_ids_for_refs(refs: list[str]) -> list[str]:
+    return [_evidence_id(ref) for ref in _refs(refs)]
+
+
 def _score(value: Any, default: float = 0.0) -> float:
     try:
         raw = float(value)
@@ -366,6 +529,14 @@ def _attempt_ids(evidence: dict[str, Any]) -> list[str]:
     return ids
 
 
+def _primary_trace_id(evidence: dict[str, Any]) -> str | None:
+    for attempt in (evidence.get("attempts") or {}).values():
+        trace = attempt.get("agent_trace") or {}
+        if trace.get("trace_id"):
+            return str(trace.get("trace_id"))
+    return None
+
+
 def _source_artifact_refs(evidence: dict[str, Any]) -> list[str]:
     refs: list[str] = []
     package_root = evidence.get("package_root")
@@ -379,6 +550,441 @@ def _source_artifact_refs(evidence: dict[str, Any]) -> list[str]:
     return list(dict.fromkeys(refs))
 
 
+def _looks_numeric(value: Any) -> bool:
+    try:
+        if value in (None, ""):
+            return False
+        float(str(value))
+        return True
+    except Exception:
+        return False
+
+
+def _json_type_name(value: Any) -> str:
+    if isinstance(value, bool):
+        return "boolean"
+    if isinstance(value, int):
+        return "integer"
+    if isinstance(value, float):
+        return "number"
+    if isinstance(value, str):
+        return "string"
+    if isinstance(value, list):
+        return "array"
+    if isinstance(value, dict):
+        return "object"
+    return type(value).__name__
+
+
+def _artifact_contracts(evidence: dict[str, Any], limit: int = 12) -> list[dict[str, Any]]:
+    package_root = evidence.get("package_root")
+    if not isinstance(package_root, Path):
+        return []
+    contracts: list[dict[str, Any]] = []
+    seen: set[str] = set()
+    for ref in _source_artifact_refs(evidence):
+        if ref in seen or ref.startswith("input/") or "/input/" in ref:
+            continue
+        seen.add(ref)
+        path = package_root / ref
+        if not path.exists() or not path.is_file():
+            continue
+        suffix = path.suffix.lower()
+        contract: dict[str, Any] = {"artifact_ref": ref, "filename": path.name}
+        try:
+            if suffix == ".csv":
+                with path.open(newline="", errors="replace") as f:
+                    reader = csv.DictReader(f)
+                    header = list(reader.fieldnames or [])
+                    rows = [row for _, row in zip(range(5), reader)]
+                numeric_columns: list[str] = []
+                non_empty_columns: list[str] = []
+                for column in header:
+                    values = [row.get(column) for row in rows if row.get(column) not in (None, "")]
+                    if values:
+                        non_empty_columns.append(column)
+                        if all(_looks_numeric(value) for value in values):
+                            numeric_columns.append(column)
+                contract.update({
+                    "format": "csv",
+                    "columns": header,
+                    "example_row_shape": len(header),
+                    "non_empty_columns": non_empty_columns[:16],
+                    "numeric_columns": numeric_columns[:16],
+                    "min_rows": 1 if rows else 0,
+                })
+            elif suffix == ".json":
+                data = json.loads(path.read_text(errors="replace"))
+                if isinstance(data, dict):
+                    expected_types = {
+                        str(key): _json_type_name(value)
+                        for key, value in data.items()
+                        if value not in (None, "", [], {})
+                    }
+                    contract.update({
+                        "format": "json",
+                        "top_level_keys": list(data.keys())[:16],
+                        "expected_types": expected_types,
+                        "non_empty_fields": list(expected_types.keys())[:16],
+                    })
+                elif isinstance(data, list):
+                    item_keys: list[str] = []
+                    expected_types: dict[str, str] = {}
+                    if data and isinstance(data[0], dict):
+                        item_keys = list(data[0].keys())[:16]
+                        expected_types = {
+                            str(key): _json_type_name(value)
+                            for key, value in data[0].items()
+                            if value not in (None, "", [], {})
+                        }
+                    contract.update({
+                        "format": "json",
+                        "top_level_type": "array",
+                        "item_count": len(data),
+                        "top_level_keys": item_keys,
+                        "expected_types": expected_types,
+                        "non_empty_fields": list(expected_types.keys())[:16],
+                        "min_rows": 1 if data else 0,
+                    })
+                else:
+                    contract.update({"format": "json", "top_level_type": type(data).__name__})
+            elif suffix in {".txt", ".md", ".sh", ".bed", ".tsv", ".svg"}:
+                contract.update({"format": suffix.lstrip(".") or "text"})
+            else:
+                contract.update({"format": suffix.lstrip(".") or "file"})
+        except Exception as exc:
+            contract.update({"format": suffix.lstrip(".") or "file", "read_error": type(exc).__name__})
+        contracts.append(contract)
+        if len(contracts) >= limit:
+            break
+    return contracts
+
+
+def _contract_line(contract: dict[str, Any]) -> str:
+    filename = contract.get("filename") or contract.get("artifact_ref")
+    if contract.get("columns"):
+        return f"`{filename}`: CSV columns {', '.join(map(str, contract.get('columns') or []))}."
+    if contract.get("top_level_keys"):
+        return f"`{filename}`: JSON keys {', '.join(map(str, contract.get('top_level_keys') or []))}."
+    return f"`{filename}`: {contract.get('format') or 'file'} artifact."
+
+
+def _contract_output_path(contract: dict[str, Any]) -> str:
+    ref = str(contract.get("artifact_ref") or contract.get("filename") or "").replace("\\", "/")
+    name = str(contract.get("filename") or Path(ref).name or "output")
+    if "/artifacts/" in ref:
+        return "artifacts/" + ref.split("/artifacts/", 1)[1]
+    if "/output/" in ref:
+        return "output/" + ref.split("/output/", 1)[1]
+    return f"output/{name}"
+
+
+def _output_contract_payload(evidence: dict[str, Any], artifact_contracts: list[dict[str, Any]]) -> dict[str, Any]:
+    outputs = []
+    for contract in artifact_contracts:
+        entry = {
+            "path": _contract_output_path(contract),
+            "format": contract.get("format") or "file",
+            "scoring_critical": True,
+        }
+        if contract.get("columns"):
+            entry["columns"] = contract.get("columns")
+        if contract.get("numeric_columns"):
+            entry["numeric_columns"] = contract.get("numeric_columns")
+        if contract.get("non_empty_columns"):
+            entry["non_empty_columns"] = contract.get("non_empty_columns")
+        if contract.get("top_level_keys"):
+            entry["keys"] = contract.get("top_level_keys")
+        if contract.get("expected_types"):
+            entry["expected_types"] = contract.get("expected_types")
+        if contract.get("non_empty_fields"):
+            entry["non_empty_fields"] = contract.get("non_empty_fields")
+        if contract.get("min_rows") is not None:
+            entry["min_rows"] = contract.get("min_rows")
+        outputs.append(entry)
+    if not any(item.get("path", "").endswith("actual_outputs.json") for item in outputs):
+        outputs.append({
+            "path": "output/actual_outputs.json",
+            "format": "json",
+            "keys": ["output_summary", "files_created"],
+            "scoring_critical": True,
+        })
+    return {
+        "source_package_id": evidence.get("package_id"),
+        "contract_kind": "runtime_transfer_output_contract",
+        "required_outputs": outputs,
+        "validation_commands": [
+            "open every required file",
+            "validate JSON parses",
+            "validate CSV/TSV headers",
+            "confirm actual_outputs.json lists generated files",
+        ],
+        "common_schema_mistakes": [
+            "writing files under the wrong relative directory",
+            "omitting required CSV columns or JSON keys",
+            "leaving actual_outputs.json empty or stale",
+        ],
+    }
+
+
+def _artifact_contract_payload(evidence: dict[str, Any], artifact_contracts: list[dict[str, Any]]) -> dict[str, Any]:
+    return {
+        "source_package_id": evidence.get("package_id"),
+        "contract_kind": "runtime_transfer_artifact_contract",
+        "required_artifacts": [
+            {
+                "path": _contract_output_path(contract),
+                "artifact_type": contract.get("format") or "file",
+                "expected_location": str(Path(_contract_output_path(contract)).parent),
+                "name_pattern": Path(_contract_output_path(contract)).name,
+                "verify_exists": True,
+                **({"columns": contract.get("columns")} if contract.get("columns") else {}),
+                **({"keys": contract.get("top_level_keys")} if contract.get("top_level_keys") else {}),
+                **({"numeric_columns": contract.get("numeric_columns")} if contract.get("numeric_columns") else {}),
+                **({"non_empty_columns": contract.get("non_empty_columns")} if contract.get("non_empty_columns") else {}),
+                **({"expected_types": contract.get("expected_types")} if contract.get("expected_types") else {}),
+                **({"non_empty_fields": contract.get("non_empty_fields")} if contract.get("non_empty_fields") else {}),
+                **({"min_rows": contract.get("min_rows")} if contract.get("min_rows") is not None else {}),
+            }
+            for contract in artifact_contracts
+        ],
+    }
+
+
+def _prefinal_checklist_payload(evidence: dict[str, Any], output_contract: dict[str, Any], artifact_contract: dict[str, Any]) -> dict[str, Any]:
+    checks = [
+        {
+            "check_id": "required_files_exist",
+            "description": "Every required output/artifact path exists in the task output location.",
+            "verification_method": "filesystem_exists",
+            "blocking": True,
+            "repair_hint": "Create or move missing files to the required relative path.",
+        },
+        {
+            "check_id": "json_outputs_parse",
+            "description": "JSON outputs, including actual_outputs.json, parse as JSON objects or declared arrays.",
+            "verification_method": "json_parse",
+            "blocking": True,
+            "repair_hint": "Rewrite malformed JSON and rerun the parse check.",
+        },
+        {
+            "check_id": "csv_tsv_headers_match",
+            "description": "CSV/TSV outputs include required scoring-critical columns.",
+            "verification_method": "delimited_header_check",
+            "blocking": True,
+            "repair_hint": "Rewrite files with the required header names exactly.",
+        },
+        {
+            "check_id": "actual_outputs_lists_files",
+            "description": "actual_outputs.json summarizes and lists generated deliverables.",
+            "verification_method": "actual_outputs_contract_check",
+            "blocking": True,
+            "repair_hint": "Update actual_outputs.json after producing outputs.",
+        },
+    ]
+    return {
+        "source_package_id": evidence.get("package_id"),
+        "checks": checks,
+        "output_contract_ref": "runtime_learning_package/output_contract.json",
+        "artifact_contract_ref": "runtime_learning_package/artifact_contract.json",
+        "required_output_count": len(output_contract.get("required_outputs") or []),
+        "required_artifact_count": len(artifact_contract.get("required_artifacts") or []),
+    }
+
+
+def _repair_instructions_text(title: str, output_contract: dict[str, Any]) -> str:
+    required = output_contract.get("required_outputs") or []
+    lines = [
+        f"# Contract Repair Instructions: {title}",
+        "",
+        "Use these instructions only after a pre-final contract check fails.",
+        "",
+        "1. Read each contract failure and map it to a required output path.",
+        "2. Regenerate missing files from current visible inputs; do not copy source-task answers.",
+        "3. For malformed CSV/TSV files, rewrite the header exactly and preserve derived rows.",
+        "4. For malformed JSON, rewrite valid JSON with required keys.",
+        "5. Reopen each repaired file and rerun the contract verifier.",
+        "",
+        "## Required Output Paths",
+    ]
+    lines.extend(f"- `{item.get('path')}` ({item.get('format') or 'file'})" for item in required[:20])
+    return "\n".join(lines) + "\n"
+
+
+def _runtime_transfer_runbook(
+    evidence: dict[str, Any],
+    title: str,
+    instruction: str,
+    criteria: list[str],
+    artifact_contracts: list[dict[str, Any]],
+) -> str:
+    contract_lines = [_contract_line(contract) for contract in artifact_contracts[:10]]
+    if not contract_lines:
+        contract_lines = ["Create every deliverable named by the current task and register it in `actual_outputs.json`."]
+    verifier_lines = criteria[:8] or ["Every required artifact exists.", "`actual_outputs.json` names the generated deliverables."]
+    return "\n".join(
+        [
+            f"# Transfer Runbook: {title}",
+            "",
+            "Use this as a compact execution checklist for a related task. Current-task instructions and inputs remain authoritative.",
+            "",
+            "## Execution Steps",
+            "1. Read the current task directory, visible input files, and required output names before writing code.",
+            "2. Build a small script or commands that derive outputs from current input files; do not copy source-task values.",
+            "3. Write outputs under `output/` unless the current task names a different relative location.",
+            "4. Match artifact filenames, CSV headers, JSON keys, and text-file roles exactly.",
+            "5. Write `output/actual_outputs.json` or `actual_outputs.json` with the produced file list and concise summary.",
+            "6. Run a local sanity check by reopening each file and verifying row/key counts and required columns.",
+            "",
+            "## Artifact Contract Pattern",
+            *(f"- {line}" for line in contract_lines),
+            "",
+            "## Verification Checklist",
+            *(f"- {line}" for line in verifier_lines),
+            "",
+            "## Transfer Cues",
+            f"- Source workflow pattern: {_clean_text(instruction, 500)}",
+            "- Transfer the procedure, output contract discipline, and checks; do not transfer source-task answers.",
+            "- If a formula or threshold is task-specific, infer it from the current task inputs or visible instructions.",
+            "",
+        ]
+    )
+
+
+def _loop_learning_rows(evidence: dict[str, Any], report: dict[str, Any]) -> dict[str, list[dict[str, Any]]]:
+    package_root = evidence.get("package_root")
+    source_package_id = report.get("source_package_id") or evidence.get("package_id")
+    out: dict[str, list[dict[str, Any]]] = {
+        "loop_review_rows": [],
+        "feedback_revision_pairs": [],
+        "contract_verification_rows": [],
+        "repair_loop_rows": [],
+        "reviewer_decision_rows": [],
+    }
+    if not isinstance(package_root, Path):
+        return out
+    for item in evidence.get("loop_review_packets") or []:
+        packet = item.get("packet") or {}
+        ref = item.get("ref")
+        if not ref:
+            continue
+        iteration_dir = package_root / Path(ref).parent
+        loop_iteration = packet.get("loop_iteration")
+        reviewer_feedback = _safe_read(iteration_dir / "reviewer_feedback.json") or {}
+        revision_plan = _safe_read(iteration_dir / "revision_plan.json") or {}
+        loop_decision = _safe_read(iteration_dir / "loop_decision.json") or {}
+        contract_verification = _safe_read(iteration_dir / "contract_verification.json") or {}
+        contract_repair_plan = _safe_read(iteration_dir / "contract_repair_plan.json") or {}
+        contract_repair_result = _safe_read(iteration_dir / "contract_repair_result.json") or {}
+        diff_report = _safe_read(iteration_dir / "diff_report.json") or {}
+
+        base = {
+            "schema_version": TRAINING_ROW_SCHEMA_VERSION,
+            "source_package_id": source_package_id,
+            "source_task_id": report.get("source_task_id"),
+            "task_lineage": _task_lineage(evidence),
+            "loop_id": packet.get("loop_id"),
+            "loop_iteration": loop_iteration,
+            "evidence_refs": [ref],
+            "source_evidence_ref_ids": _evidence_ids_for_refs([ref]),
+            "confidence": report.get("average_quality_score") or 0.5,
+            "created_at": utc_now(),
+            "generated_by": "Experience Compiler",
+        }
+        known_failures = [str(v) for v in (packet.get("known_failures") or []) if v]
+        missing_outputs = [str(v) for v in (packet.get("missing_outputs") or []) if v]
+        out["loop_review_rows"].append(
+            sanitize_public_obj(
+                {
+                    **base,
+                    "row_id": f"loop_review_{_safe_id(str(packet.get('loop_id') or source_package_id))}_{loop_iteration or 0}",
+                    "data_type": "loop_review_row",
+                    "mode": packet.get("mode"),
+                    "current_attempt_summary": _clean_text(packet.get("current_attempt_summary")),
+                    "rubric_status": packet.get("rubric_status"),
+                    "verifier_status": packet.get("verifier_status"),
+                    "known_failures": known_failures,
+                    "missing_outputs": missing_outputs,
+                    "recommended_review_focus": packet.get("recommended_review_focus") or [],
+                    "review_packet_ref": ref,
+                    "review_packet_md_ref": str(Path(ref).with_suffix(".md")),
+                }
+            )
+        )
+        if reviewer_feedback or revision_plan:
+            out["feedback_revision_pairs"].append(
+                sanitize_public_obj(
+                    {
+                    **base,
+                    "pair_id": f"feedback_revision_{_safe_id(str(packet.get('loop_id') or source_package_id))}_{loop_iteration or 0}",
+                    "row_id": f"feedback_revision_{_safe_id(str(packet.get('loop_id') or source_package_id))}_{loop_iteration or 0}",
+                    "data_type": "feedback_revision_pair",
+                        "reviewer_type": reviewer_feedback.get("reviewer_type") or "unknown",
+                        "feedback": _clean_text(reviewer_feedback.get("feedback") or reviewer_feedback.get("feedback_text") or reviewer_feedback.get("summary")),
+                        "blocking_issues": reviewer_feedback.get("blocking_issues") or known_failures,
+                        "revision_instructions": reviewer_feedback.get("revision_instructions") or revision_plan.get("issues_to_fix") or [],
+                        "revision_plan_ref": f"{Path(ref).parent.as_posix()}/revision_plan.json",
+                        "diff_report_ref": f"{Path(ref).parent.as_posix()}/diff_report.json",
+                        "feedback_applied_status": revision_plan.get("feedback_applied") or "unknown",
+                    }
+                )
+            )
+        if loop_decision:
+            out["reviewer_decision_rows"].append(
+                sanitize_public_obj(
+                    {
+                    **base,
+                    "row_id": f"reviewer_decision_{_safe_id(str(packet.get('loop_id') or source_package_id))}_{loop_iteration or 0}",
+                    "data_type": "reviewer_decision_row",
+                        "decision": loop_decision.get("decision"),
+                        "verdict": loop_decision.get("verdict"),
+                        "score": loop_decision.get("score"),
+                        "continue_loop": loop_decision.get("continue_loop"),
+                        "stop_condition": loop_decision.get("stop_condition"),
+                        "termination_reason": loop_decision.get("termination_reason"),
+                        "training_value_notes": loop_decision.get("training_value_notes"),
+                        "loop_decision_ref": f"{Path(ref).parent.as_posix()}/loop_decision.json",
+                    }
+                )
+            )
+        if contract_verification:
+            failures = contract_verification.get("failures") or []
+            out["contract_verification_rows"].append(
+                sanitize_public_obj(
+                    {
+                    **base,
+                    "row_id": f"contract_verification_{_safe_id(str(packet.get('loop_id') or source_package_id))}_{loop_iteration or 0}",
+                    "data_type": "contract_verification_row",
+                        "contract_verification_passed": contract_verification.get("contract_verification_passed"),
+                        "actual_outputs_json_ok": contract_verification.get("actual_outputs_json_ok"),
+                        "failure_count": contract_verification.get("failure_count", len(failures)),
+                        "semantic_warning_count": contract_verification.get("semantic_warning_count", 0),
+                        "failures": failures[:20],
+                        "semantic_warnings": (contract_verification.get("semantic_warnings") or [])[:20],
+                        "contract_verification_ref": f"{Path(ref).parent.as_posix()}/contract_verification.json",
+                    }
+                )
+            )
+        if contract_repair_plan or contract_repair_result:
+            out["repair_loop_rows"].append(
+                sanitize_public_obj(
+                    {
+                    **base,
+                    "row_id": f"repair_loop_{_safe_id(str(packet.get('loop_id') or source_package_id))}_{loop_iteration or 0}",
+                    "data_type": "repair_loop_row",
+                        "repair_required": contract_repair_plan.get("repair_required"),
+                        "preserve_passing_items": contract_repair_plan.get("preserve_passing_items"),
+                        "issues_to_fix": contract_repair_plan.get("issues_to_fix") or [],
+                        "repair_result": contract_repair_result,
+                        "changed_refs": (diff_report.get("added_refs") or []) + (diff_report.get("removed_refs") or []),
+                        "contract_repair_plan_ref": f"{Path(ref).parent.as_posix()}/contract_repair_plan.json",
+                        "contract_repair_result_ref": f"{Path(ref).parent.as_posix()}/contract_repair_result.json",
+                    }
+                )
+            )
+    return out
+
+
 def _evidence_refs(evidence: dict[str, Any]) -> list[str]:
     refs = ["task/task_intake_spec.json", "rubric/rubric.json"]
     refs.extend(_source_artifact_refs(evidence))
@@ -492,21 +1098,38 @@ def _source_audit_status(evidence: dict[str, Any]) -> dict[str, Any]:
 
 
 def _base_row(evidence: dict[str, Any], settings: Settings, round_idx: int, judge_source: str, mentor_audited: bool, proxy: dict[str, Any], quality: float) -> dict[str, Any]:
+    lineage = _task_lineage(evidence)
+    evidence_refs = _evidence_refs(evidence)
+    source_artifact_refs = _source_artifact_refs(evidence)
     row = {
+        "schema_version": TRAINING_ROW_SCHEMA_VERSION,
         "source_package_id": evidence["package_id"],
         "source_task_id": _source_task_id(evidence),
-        "source_trace_id": None,
+        "task_lineage": lineage,
+        "domain": lineage["domain"],
+        "subdomain": lineage["subdomain"],
+        "workflow_family": lineage["workflow_family"],
+        "source_trace_id": _primary_trace_id(evidence),
         "source_step_ids": [],
         "source_attempt_ids": _attempt_ids(evidence),
-        "source_artifact_refs": _source_artifact_refs(evidence),
-        "source_evaluation_refs": [ref for ref in _evidence_refs(evidence) if ref.startswith(("grading/", "feedback/", "signals/"))],
-        "evidence_refs": _evidence_refs(evidence),
+        "source_artifact_refs": source_artifact_refs,
+        "source_evaluation_refs": [ref for ref in evidence_refs if ref.startswith(("grading/", "feedback/", "signals/"))],
+        "evidence_refs": evidence_refs,
+        "source_evidence_ref_ids": _evidence_ids_for_refs(evidence_refs),
+        "evidence_visibility": "visible_or_public_package_evidence",
+        "visible_input_refs": [ref for ref in source_artifact_refs if ref.startswith("input/") or "/input/" in ref],
+        "source_content_hashes": {
+            ref: _content_hash_for_ref(evidence["package_root"], ref)
+            for ref in evidence_refs[:24]
+            if isinstance(evidence.get("package_root"), Path) and _content_hash_for_ref(evidence["package_root"], ref)
+        },
         "provenance": "derived_from_observed_agent_apprenticeship_package",
         "quality_score": quality,
         "fidelity_score": min(1.0, quality + 0.04),
         "difficulty_score": min(1.0, max(0.35, quality - 0.08)),
         "learnability_score": min(1.0, quality + 0.02),
         "reuse_value_score": min(1.0, quality + 0.03),
+        "confidence": min(1.0, quality + 0.02),
         "weak_score_proxy": proxy.get("weak_score_proxy"),
         "strong_score_proxy": proxy.get("strong_score_proxy"),
         "solver_gap_proxy": proxy.get("solver_gap_proxy"),
@@ -545,6 +1168,74 @@ def _has_concrete_source_evidence(row: dict[str, Any]) -> bool:
     return False
 
 
+def _finalize_candidate_rows(rows: list[dict[str, Any]], evidence: dict[str, Any]) -> list[dict[str, Any]]:
+    finalized: list[dict[str, Any]] = []
+    for raw in rows:
+        row = dict(raw)
+        data_type = str(row.get("data_type") or "unknown")
+        row_id = _row_identity(data_type, row, evidence)
+        id_field = ROW_ID_FIELD_BY_TYPE.get(data_type, "row_id")
+        row.setdefault(id_field, row_id)
+        row.setdefault("row_id", row_id)
+        row.setdefault("schema_version", TRAINING_ROW_SCHEMA_VERSION)
+        row.setdefault("training_use_cases", TRAINING_USE_BY_TYPE.get(data_type, ["experience_compilation_training"]))
+        row.setdefault("quality_signal_source", row.get("tdo_judge_source") or "experience_compiler_guardrail")
+        row.setdefault("source_trace_ref", row.get("source_trace_id"))
+        row.setdefault("source_evidence_ref_ids", _evidence_ids_for_refs(row.get("evidence_refs") or []))
+        row.setdefault("evidence_confidence", row.get("confidence") or row.get("quality_score") or 0.5)
+        row.setdefault("row_content_hash", _hash_obj({k: v for k, v in row.items() if k not in {"row_content_hash", "created_at"}}))
+        row.setdefault(
+            "model_training_targets",
+            {
+                "sft_ready": data_type == "training_example",
+                "lora_ready": data_type == "training_example",
+                "reward_ready": data_type == "reward_model_row",
+                "verifier_ready": data_type in {"verifier_example", "evaluation_example"},
+                "preference_ready": data_type == "preference_pair",
+                "process_supervision_ready": data_type in {"environment_response_pair", *SURFACE_FILES.keys()},
+                "rl_rollout_ready": data_type in {"environment_response_pair", "software_execution_event", "api_interaction_event"},
+            },
+        )
+        if data_type == "training_example":
+            row.setdefault("instruction", (row.get("input") or {}).get("instruction") if isinstance(row.get("input"), dict) else row.get("input"))
+            row.setdefault("target_output", row.get("expected_output") or row.get("target"))
+            row.setdefault("output_contract_summary", "Use actual_outputs.json plus artifact refs as the output contract.")
+        elif data_type == "reward_model_row":
+            target = row.get("target") if isinstance(row.get("target"), dict) else {}
+            row.setdefault("reward_component", "task_outcome")
+            row.setdefault("reward_value", target.get("final_score") if isinstance(target, dict) else None)
+            row.setdefault("reward_timing", "final")
+            row.setdefault("verifier_or_grader_source", "grader_result")
+        elif data_type == "verifier_example":
+            row.setdefault("claim_or_output", row.get("input"))
+            row.setdefault("visible_evidence", row.get("source_artifact_refs") or row.get("evidence_refs"))
+            row.setdefault("verifier_decision", row.get("target"))
+        elif data_type == "preference_pair":
+            target = row.get("target") if isinstance(row.get("target"), dict) else {}
+            row.setdefault("chosen_output", target.get("chosen"))
+            row.setdefault("rejected_output", "baseline" if target.get("chosen") == "revised" else "revised")
+            row.setdefault("preference_reason", row.get("scoring_hint") or "Higher grounded score/verifier evidence.")
+            row.setdefault("quality_delta", target.get("solver_gap_proxy"))
+        elif data_type == "failure_case":
+            target = row.get("target") if isinstance(row.get("target"), dict) else {}
+            row.setdefault("failure_type", target.get("failure_mode") or "contract_or_score_failure")
+            row.setdefault("failure_severity", "medium")
+            row.setdefault("repair_recommendation", target.get("repair_hint") or row.get("scoring_hint"))
+        elif data_type == "task_variant":
+            target = row.get("target") if isinstance(row.get("target"), dict) else {}
+            row.setdefault("variant_instruction", target.get("variant_instruction"))
+            row.setdefault("expected_output_contract", target.get("expected_deliverables"))
+            row.setdefault("difficulty", row.get("difficulty_score"))
+        elif data_type == "environment_response_pair":
+            row.setdefault("rollout_group_id", f"rollout_{_safe_id(str(row.get('source_task_id')))}")
+            row.setdefault("candidate_rollout_id", f"rollout_{row_id}")
+            row.setdefault("scalar_reward", row.get("format_score") or row.get("quality_score"))
+            row.setdefault("reward_components", {"format": row.get("format_score"), "consistency": row.get("consistency_score")})
+            row.setdefault("termination_reason", row.get("success_signal"))
+        finalized.append(sanitize_public_obj(row))
+    return finalized
+
+
 def _build_candidate_rows(evidence: dict[str, Any], settings: Settings, round_idx: int, judge_source: str, mentor_audited: bool, proxy: dict[str, Any]) -> list[dict[str, Any]]:
     task = evidence.get("task") or {}
     raw = evidence.get("raw_task") or {}
@@ -634,7 +1325,7 @@ def _build_candidate_rows(evidence: dict[str, Any], settings: Settings, round_id
     })
     rows.extend(_environment_response_rows(evidence, common))
     rows.extend(_surface_event_rows(evidence, common))
-    return [sanitize_public_obj(row) for row in rows]
+    return _finalize_candidate_rows(rows, evidence)
 
 
 def _best_output_summary(evidence: dict[str, Any]) -> str:
@@ -1019,6 +1710,7 @@ def _validate_rows(package_root: Path, rows: list[dict[str, Any]], min_quality:
     accepted: list[dict[str, Any]] = []
     rejected: list[dict[str, Any]] = []
     schema_errors: list[str] = []
+    seen_row_ids: set[str] = set()
     for row in rows:
         reason = _private_or_forbidden_hit(row)
         missing = _artifact_refs_resolve(package_root, row)
@@ -1026,6 +1718,24 @@ def _validate_rows(package_root: Path, rows: list[dict[str, Any]], min_quality:
             reason = reason or f"unresolved_artifact_ref:{missing[0]}"
         if not row.get("data_type"):
             reason = reason or "missing_data_type"
+        row_id = row.get("row_id") or row.get("pair_id")
+        if not row_id:
+            reason = reason or "missing_stable_row_id"
+        elif str(row_id) in seen_row_ids:
+            reason = reason or f"duplicate_row_id:{row_id}"
+        else:
+            seen_row_ids.add(str(row_id))
+        if not isinstance(row.get("task_lineage"), dict) or not row.get("source_task_id"):
+            reason = reason or "missing_task_lineage"
+        if not row.get("domain") or not row.get("workflow_family"):
+            reason = reason or "missing_domain_or_workflow_family"
+        if not row.get("source_evidence_ref_ids"):
+            reason = reason or "missing_source_evidence_ref_ids"
+        if row.get("data_type") in {"training_example", "evaluation_example", "verifier_example", "reward_model_row"}:
+            if row.get("input") in (None, "", {}, []):
+                reason = reason or "missing_core_input"
+            if row.get("target") in (None, "", {}, []):
+                reason = reason or "missing_core_target"
         if not _has_concrete_source_evidence(row):
             reason = reason or "insufficient_concrete_source_evidence"
         if _score(row.get("quality_score")) < min_quality:
@@ -1231,11 +1941,30 @@ def _environment_spec(evidence: dict[str, Any]) -> dict[str, Any]:
         "input_artifacts": [ref for ref in _source_artifact_refs(evidence) if ref.startswith("input/") or "/input/" in ref],
         "initial_state_refs": ["task/task_intake_spec.json", "rubric/rubric.json"],
         "allowed_actions": sorted(set(operations)),
+        "action_schema": {
+            "action": "operation/tool invocation or artifact-producing step",
+            "tool": "optional tool name",
+            "input": "visible input or command payload",
+            "artifact_refs": "package-relative refs produced or inspected",
+        },
+        "observation_schema": {
+            "observation": "tool/environment response summary",
+            "state_change": "state delta after action",
+            "artifact_refs": "package-relative output refs",
+            "success_signal": "step outcome or verifier signal",
+        },
         "reset_strategy": "copy_workspace" if environment_type in {"local_filesystem", "codebase", "terminal"} else "unknown",
         "verification_commands": [],
         "scoring_refs": [ref for ref in _evidence_refs(evidence) if ref.startswith("grading/")],
         "expected_output_refs": [ref for ref in _source_artifact_refs(evidence) if "/artifacts/" in ref],
+        "termination_conditions": ["task_complete", "contract_verified", "max_iterations_reached"],
+        "reward_function_components": ["artifact_contract", "verifier_signal", "step_success", "grader_score_if_available"],
         "replay_smoke_test": {"available": False, "command": None, "success_condition": None},
+        "reproducibility_metadata": {
+            "source_trace_count": len(evidence.get("attempts") or {}),
+            "package_id": evidence.get("package_id"),
+            "created_from_observed_trace": True,
+        },
         "multi_agent": {
             "present": multi_agent_present,
             "agents": values_from("agent_id", "agent_name", "subagent_id", "subagent_name"),
@@ -1387,7 +2116,231 @@ def _copy_compiler_json_public(src: Path, dst: Path) -> None:
     if not src.exists():
         write_json(dst, {})
         return
-    write_json(dst, _compiler_public_obj(read_json(src)))
+        write_json(dst, _compiler_public_obj(read_json(src)))
+
+
+def _compiler_rows_from_tdo_dir(tdo_dir: Path) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    for filename in sorted(set(ROW_FILE_BY_TYPE.values())):
+        path = tdo_dir / filename
+        if not path.exists():
+            continue
+        for row in _safe_jsonl(path):
+            if isinstance(row, dict):
+                clean = dict(row)
+                clean["_source_row_file"] = filename
+                rows.append(clean)
+    return rows
+
+
+def _training_row_counts_by_file(tdo_dir: Path) -> dict[str, int]:
+    counts: dict[str, int] = {}
+    for filename in sorted(set(ROW_FILE_BY_TYPE.values())):
+        path = tdo_dir / filename
+        counts[filename] = len(_safe_jsonl(path)) if path.exists() else 0
+    return counts
+
+
+def _source_evidence_map_payload(
+    evidence: dict[str, Any],
+    report: dict[str, Any],
+    compiler_rows: list[dict[str, Any]],
+) -> dict[str, Any]:
+    catalog = _evidence_catalog(evidence)
+    evidence_by_id = {item["evidence_id"]: item for item in catalog}
+    row_links: list[dict[str, Any]] = []
+    orphan_ids: set[str] = set()
+    for row in compiler_rows:
+        row_id = str(row.get("row_id") or row.get("pair_id") or _row_identity(str(row.get("data_type") or "unknown"), row, evidence))
+        ids = [str(v) for v in row.get("source_evidence_ref_ids") or _evidence_ids_for_refs(row.get("evidence_refs") or [])]
+        for evidence_id in ids:
+            if evidence_id not in evidence_by_id:
+                orphan_ids.add(evidence_id)
+        row_links.append(
+            {
+                "row_id": row_id,
+                "row_file": row.get("_source_row_file"),
+                "data_type": row.get("data_type"),
+                "source_task_id": row.get("source_task_id") or report.get("source_task_id"),
+                "source_trace_id": row.get("source_trace_id"),
+                "source_step_ids": row.get("source_step_ids") or [],
+                "source_artifact_refs": row.get("source_artifact_refs") or [],
+                "evidence_ref_ids": ids,
+                "visible_evidence_ref_ids": [
+                    evidence_id
+                    for evidence_id in ids
+                    if (evidence_by_id.get(evidence_id) or {}).get("visibility") == "visible"
+                ],
+                "inferred_evidence_ref_ids": [
+                    evidence_id
+                    for evidence_id in ids
+                    if (evidence_by_id.get(evidence_id) or {}).get("visibility") == "inferred"
+                ],
+            }
+        )
+    resolved = sum(1 for item in catalog if item.get("resolves"))
+    return sanitize_public_obj(
+        {
+            "schema_version": EVIDENCE_MAP_SCHEMA_VERSION,
+            "source_package_id": report.get("source_package_id"),
+            "source_task_id": report.get("source_task_id"),
+            "evidence_catalog": catalog,
+            "row_evidence_links": row_links,
+            "task_refs": [
+                ref
+                for ref in [
+                    "task/task_packet.json",
+                    "task/task_intake_spec.json",
+                    "task/raw_task_record.json",
+                    "source_task/task_packet.json",
+                ]
+                if isinstance(evidence.get("package_root"), Path) and (evidence["package_root"] / ref).exists()
+            ]
+            or ["task/task_packet.json"],
+            "artifact_refs": _source_artifact_refs(evidence),
+            "evaluation_refs": [ref for ref in _evidence_refs(evidence) if ref.startswith(("grading/", "feedback/", "signals/", "loops/"))],
+            "loop_review_refs": evidence.get("loop_review_refs") or [],
+            "trace_refs": [
+                str((attempt.get("agent_trace") or {}).get("trace_id"))
+                for attempt in (evidence.get("attempts") or {}).values()
+                if (attempt.get("agent_trace") or {}).get("trace_id")
+            ],
+            "coverage_statistics": {
+                "evidence_ref_count": len(catalog),
+                "resolved_evidence_ref_count": resolved,
+                "unresolved_evidence_ref_count": len(catalog) - resolved,
+                "row_link_count": len(row_links),
+                "row_count_with_evidence_ids": sum(1 for row in row_links if row.get("evidence_ref_ids")),
+                "orphan_evidence_id_count": len(orphan_ids),
+            },
+            "orphan_evidence_ref_ids": sorted(orphan_ids),
+        }
+    )
+
+
+def _process_supervision_rows_from_compiler_rows(rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    out: list[dict[str, Any]] = []
+    process_types = {"environment_response_pair", *SURFACE_FILES.keys()}
+    for row in rows:
+        if row.get("data_type") not in process_types:
+            continue
+        out.append(
+            sanitize_public_obj(
+                {
+                    "schema_version": TRAINING_ROW_SCHEMA_VERSION,
+                    "row_id": f"ps_{row.get('row_id')}",
+                    "data_type": "process_supervision",
+                    "source_package_id": row.get("source_package_id"),
+                    "source_task_id": row.get("source_task_id"),
+                    "task_lineage": row.get("task_lineage"),
+                    "domain": row.get("domain"),
+                    "subdomain": row.get("subdomain"),
+                    "workflow_family": row.get("workflow_family"),
+                    "source_trace_id": row.get("source_trace_id"),
+                    "source_step_ids": row.get("source_step_ids") or [],
+                    "step_goal": row.get("agent_action") or row.get("command") or row.get("query") or row.get("input") or row.get("state_change") or row.get("interaction_surface"),
+                    "action_taken": row.get("agent_action") or row.get("action_type") or row.get("command") or row.get("query") or row.get("state_change") or row.get("interaction_surface"),
+                    "observation": row.get("observed_environment_response") or row.get("observed_result") or row.get("output") or row.get("state_change") or row.get("success_signal"),
+                    "tool_action_metadata": {
+                        "environment_domain": row.get("environment_domain"),
+                        "interaction_surface": row.get("interaction_surface"),
+                        "tool_or_surface": row.get("search_provider") or row.get("api_endpoint") or row.get("table_name") or row.get("service_name"),
+                    },
+                    "correctness_label": "positive" if row.get("success_signal") in {"completed", "True", True} else "unknown",
+                    "quality_signal": row.get("training_quality_score") or row.get("quality_score"),
+                    "next_step_recommendation": "Continue from the observed state and verify artifact/output contract before final answer.",
+                    "source_evidence_ref_ids": row.get("source_evidence_ref_ids") or [],
+                    "evidence_refs": row.get("evidence_refs") or [],
+                    "confidence": row.get("confidence") or row.get("quality_score") or 0.5,
+                    "created_at": row.get("created_at") or utc_now(),
+                }
+            )
+        )
+    return out
+
+
+def _rl_rollout_rows_from_compiler_rows(rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    out: list[dict[str, Any]] = []
+    for row in rows:
+        if row.get("data_type") != "environment_response_pair":
+            continue
+        row_id = str(row.get("row_id") or _hash_obj(row))
+        out.append(
+            sanitize_public_obj(
+                {
+                    "schema_version": TRAINING_ROW_SCHEMA_VERSION,
+                    "row_id": f"rl_{row_id}",
+                    "data_type": "agentic_rl_rollout",
+                    "source_package_id": row.get("source_package_id"),
+                    "source_task_id": row.get("source_task_id"),
+                    "task_lineage": row.get("task_lineage"),
+                    "domain": row.get("domain"),
+                    "subdomain": row.get("subdomain"),
+                    "workflow_family": row.get("workflow_family"),
+                    "rollout_group_id": row.get("rollout_group_id") or f"rollout_{_safe_id(str(row.get('source_task_id')))}",
+                    "candidate_rollout_id": row.get("candidate_rollout_id") or f"rollout_{row_id}",
+                    "prompt_or_instruction": row.get("input") or row.get("agent_action"),
+                    "initial_environment_state": row.get("state_before"),
+                    "visible_input_refs": row.get("visible_input_refs") or [],
+                    "tool_action_schema": {
+                        "environment_domain": row.get("environment_domain"),
+                        "interaction_surface": row.get("interaction_surface"),
+                    },
+                    "step_action_trace": {
+                        "source_trace_id": row.get("source_trace_id"),
+                        "source_step_ids": row.get("source_step_ids") or [],
+                        "action": row.get("agent_action"),
+                        "observation": row.get("observed_environment_response"),
+                    },
+                    "artifacts_produced": row.get("source_artifact_refs") or [],
+                    "final_output": row.get("state_after") or row.get("success_signal"),
+                    "verifier_decision": row.get("verifier_feedback"),
+                    "scalar_reward": row.get("scalar_reward") or row.get("training_quality_score") or row.get("quality_score"),
+                    "reward_components": row.get("reward_components") or {},
+                    "reward_timing": "step",
+                    "success_label": row.get("success_signal"),
+                    "termination_reason": row.get("termination_reason") or row.get("success_signal"),
+                    "source_evidence_ref_ids": row.get("source_evidence_ref_ids") or [],
+                    "evidence_refs": row.get("evidence_refs") or [],
+                    "replay_scoring_smoke_test_refs": row.get("source_evaluation_refs") or [],
+                    "confidence": row.get("confidence") or row.get("quality_score") or 0.5,
+                    "created_at": row.get("created_at") or utc_now(),
+                }
+            )
+        )
+    return out
+
+
+def _bioactive_schema_examples(report: dict[str, Any], evidence: dict[str, Any]) -> list[dict[str, Any]]:
+    base = {
+        "schema_version": TRAINING_ROW_SCHEMA_VERSION,
+        "source_package_id": report.get("source_package_id"),
+        "source_task_id": report.get("source_task_id"),
+        "task_lineage": _task_lineage(evidence),
+        "source_evidence_ref_ids": _evidence_ids_for_refs(_evidence_refs(evidence)[:5]),
+        "evidence_refs": _evidence_refs(evidence)[:5],
+        "confidence": 0.5,
+        "personal_context_policy": "abstract_constraints_only_no_sensitive_identity",
+        "medical_advice_policy": "evidence_mapping_only_no_treatment_or_cure_claims",
+        "created_at": utc_now(),
+    }
+    return [
+        {
+            **base,
+            "row_id": f"bioactive_schema_{_safe_id(str(report.get('source_package_id') or 'package'))}",
+            "data_type": "bioactive_evidence_mapping_schema_example",
+            "source_text_or_artifact_ref": None,
+            "extracted_claim": None,
+            "ingredient_or_compound_entity": None,
+            "product_entity": None,
+            "evidence_summary": None,
+            "mechanism_category": None,
+            "safety_caution_category": None,
+            "uncertainty": "schema_only",
+            "citation_or_provenance_refs": [],
+            "verifier_decision": "not_evaluated_schema_example",
+        }
+    ]
 
 
 def _copy_json_public(src: Path, dst: Path, default: dict[str, Any] | None = None) -> None:
@@ -1569,11 +2522,16 @@ def _write_experience_compiler_outputs(
         "verifier",
         "reward",
         "environment",
+        "loop_learning",
         "reports",
     ]:
         (root / name).mkdir(parents=True, exist_ok=True)
 
     manifest_src = read_json(tdo_dir / "tdo_manifest.json") if (tdo_dir / "tdo_manifest.json").exists() else {}
+    compiler_rows = _compiler_rows_from_tdo_dir(tdo_dir)
+    training_row_counts_by_file = _training_row_counts_by_file(tdo_dir)
+    evidence_map = _source_evidence_map_payload(evidence, report, compiler_rows)
+    package_version = get_package_version()
     compiler_refs = [
         "experience_compiler/compiler_manifest.json",
         "experience_compiler/compiler_report.json",
@@ -1585,18 +2543,51 @@ def _write_experience_compiler_outputs(
         "experience_compiler/skill_pack/skill.md",
     ]
     compiler_manifest = {
-        "schema_version": "aa-experience-compiler-v0.1",
+        "schema_version": "aa-experience-compiler-v0.2",
+        "training_row_schema_version": TRAINING_ROW_SCHEMA_VERSION,
+        "source_evidence_map_schema_version": EVIDENCE_MAP_SCHEMA_VERSION,
+        "package_version": package_version,
+        "compiler_version": TDO_VERSION,
         "compiler_id": str(report.get("tdo_id") or "").replace("tdo_", "compiler_", 1) or f"compiler_{_safe_id(package_root.name)}",
         "compiler_status": report.get("tdo_status"),
         "source_package_id": report.get("source_package_id"),
         "source_task_id": report.get("source_task_id"),
+        "title": _task_title(evidence),
+        "task_title": _task_title(evidence),
+        "domain": _task_lineage(evidence)["domain"],
+        "subdomain": _task_lineage(evidence)["subdomain"],
+        "workflow_family": _task_lineage(evidence)["workflow_family"],
+        "public_private_mode": getattr(settings, "contribution_mode", None),
+        "sharing_upload_mode": getattr(settings, "contribution_mode", None),
+        "private_internal_no_upload_confirmed": getattr(settings, "contribution_mode", None) == "private_internal",
         "apprenticeship_mode": getattr(settings, "apprenticeship_mode", None),
         "judge_source": report.get("tdo_judge_source"),
         "mentor_audited": report.get("mentor_audited"),
         "rounds_run": report.get("rounds_run"),
         "rows_by_type": rows_accepted,
+        "training_row_counts_by_file": training_row_counts_by_file,
+        "source_evidence_ref_count": (evidence_map.get("coverage_statistics") or {}).get("evidence_ref_count"),
+        "source_evidence_row_link_count": (evidence_map.get("coverage_statistics") or {}).get("row_link_count"),
         "supported_runtime_uses": ["experience_pack", "skill_pack", "runtime_learning_package"],
-        "supported_training_uses": ["training_examples", "evaluation_examples", "verifier_examples", "reward_model_rows", "preference_pairs", "environment_response_pairs"],
+        "supported_training_uses": [
+            "sft",
+            "lora_ready_instruction_tuning",
+            "process_supervision",
+            "training_examples",
+            "evaluation_examples",
+            "verifier_examples",
+            "reward_model_rows",
+            "preference_pairs",
+            "critique_revision_pairs",
+            "failure_cases",
+            "task_variants",
+            "agentic_rl_rollouts",
+            "grpo_rollout_material",
+            "environment_response_pairs",
+            "loop_learning",
+            "contract_verification",
+            "environment_state_transition_learning",
+        ],
         "loop_review_refs": evidence.get("loop_review_refs") or [],
         "compiler_output_refs": compiler_refs,
         "created_at": report.get("created_at") or utc_now(),
@@ -1609,33 +2600,17 @@ def _write_experience_compiler_outputs(
         "apprenticeship_mode": getattr(settings, "apprenticeship_mode", None),
     })
     write_json(root / "compiler_report.json", sanitize_public_obj(compiler_report))
-    task_refs = [
-        ref
-        for ref in [
-            "task/task_packet.json",
-            "task/task_intake_spec.json",
-            "task/raw_task_record.json",
-            "source_task/task_packet.json",
-        ]
-        if (package_root / ref).exists()
-    ]
-    if not task_refs:
-        task_refs = ["task/task_packet.json"]
-    write_json(root / "source_evidence_map.json", sanitize_public_obj({
-        "source_package_id": report.get("source_package_id"),
-        "source_task_id": report.get("source_task_id"),
-        "task_refs": task_refs,
-        "artifact_refs": _source_artifact_refs(evidence),
-        "evaluation_refs": _evidence_refs(evidence),
-        "loop_review_refs": evidence.get("loop_review_refs") or [],
-        "trace_refs": [str(trace.get("trace_id") or trace.get("source_trace_id") or "trace") for trace in evidence.get("traces") or []],
-    }))
+    write_json(root / "source_evidence_map.json", evidence_map)
     write_json(root / "quality_report.json", sanitize_public_obj({
         "source_package_id": report.get("source_package_id"),
         "compiler_status": report.get("tdo_status"),
+        "package_version": package_version,
+        "compiler_version": TDO_VERSION,
         "average_quality_score": report.get("average_quality_score"),
         "average_fidelity_score": report.get("average_fidelity_score"),
         "average_reuse_value_score": report.get("average_reuse_value_score"),
+        "training_row_counts_by_file": training_row_counts_by_file,
+        "source_evidence_map_coverage": evidence_map.get("coverage_statistics"),
         "omitted_outputs": report.get("omitted_outputs") or [],
         "not_generated_counts": report.get("not_generated_counts") or {},
         "generation_notes": report.get("generation_notes") or [],
@@ -1649,6 +2624,13 @@ def _write_experience_compiler_outputs(
     _copy_compiler_jsonl_public(tdo_dir / "tdo_judge_results.jsonl", root / "reports" / "compiler_judge_results.jsonl")
     _copy_compiler_json_public(tdo_dir / "tdo_recipe.json", root / "reports" / "compiler_recipe.json")
 
+    loop_learning = _loop_learning_rows(evidence, report)
+    _write_jsonl(root / "loop_learning" / "loop_review_rows.jsonl", loop_learning["loop_review_rows"])
+    _write_jsonl(root / "loop_learning" / "feedback_revision_pairs.jsonl", loop_learning["feedback_revision_pairs"])
+    _write_jsonl(root / "loop_learning" / "contract_verification_rows.jsonl", loop_learning["contract_verification_rows"])
+    _write_jsonl(root / "loop_learning" / "repair_loop_rows.jsonl", loop_learning["repair_loop_rows"])
+    _write_jsonl(root / "loop_learning" / "reviewer_decision_rows.jsonl", loop_learning["reviewer_decision_rows"])
+
     jsonl_map = {
         "training_examples.jsonl": root / "training_time_package" / "training_examples.jsonl",
         "evaluation_examples.jsonl": root / "training_time_package" / "evaluation_examples.jsonl",
@@ -1707,6 +2689,7 @@ def _write_experience_compiler_outputs(
     title = _task_title(evidence) or str(report.get("source_task_id") or "Compiled skill")
     instruction = _task_instruction(evidence)
     criteria = _success_criteria(evidence)
+    artifact_contracts = _artifact_contracts(evidence)
     canonical_skill = sanitize_public_obj({
         "skill_id": f"skill_{_safe_id(str(report.get('source_package_id') or package_root.name))}",
         "title": title,
@@ -1792,6 +2775,9 @@ def _write_experience_compiler_outputs(
         "source_package_id": report.get("source_package_id"),
         "checks": criteria + ["bundle_check_passes", "evidence_refs_resolve"],
     })
+    output_contract = _output_contract_payload(evidence, artifact_contracts)
+    artifact_contract = _artifact_contract_payload(evidence, artifact_contracts)
+    prefinal_checklist = _prefinal_checklist_payload(evidence, output_contract, artifact_contract)
     write_json(root / "runtime_learning_package" / "runtime_learning_manifest.json", {
         "source_package_id": report.get("source_package_id"),
         "apprenticeship_mode": getattr(settings, "apprenticeship_mode", None),
@@ -1805,6 +2791,13 @@ def _write_experience_compiler_outputs(
             "tool_recipe_reuse",
         ],
         "skill_ref": "experience_compiler/skill_pack/skill.md",
+        "transfer_runbook_ref": "experience_compiler/runtime_learning_package/transfer_runbook.md",
+        "transfer_checklist_ref": "experience_compiler/runtime_learning_package/transfer_checklist.json",
+        "minimal_prompt_context_ref": "experience_compiler/runtime_learning_package/minimal_prompt_context.md",
+        "output_contract_ref": "experience_compiler/runtime_learning_package/output_contract.json",
+        "artifact_contract_ref": "experience_compiler/runtime_learning_package/artifact_contract.json",
+        "prefinal_verification_checklist_ref": "experience_compiler/runtime_learning_package/prefinal_verification_checklist.json",
+        "repair_instructions_ref": "experience_compiler/runtime_learning_package/repair_instructions.md",
     })
     for name, rows in {
         "runtime_memory.jsonl": [{"source_package_id": report.get("source_package_id"), "lesson": _task_instruction(evidence), "usable_for": ["runtime_memory"]}],
@@ -1847,6 +2840,90 @@ def _write_experience_compiler_outputs(
             ]
         )
     )
+    transfer_runbook = _runtime_transfer_runbook(evidence, title, instruction, criteria, artifact_contracts)
+    (root / "runtime_learning_package" / "transfer_runbook.md").write_text(
+        sanitize_public_text(transfer_runbook) or transfer_runbook
+    )
+    minimal_context = "\n".join(
+        [
+            f"# Minimal Runtime Transfer Context: {title}",
+            "",
+            "Follow current-task instructions. Reuse only the workflow pattern and output-contract discipline from this source task.",
+            "",
+            "## Must Do",
+            "- Derive outputs from current visible input files.",
+            "- Match required filenames, CSV headers, JSON keys, and artifact roles.",
+            "- Write `actual_outputs.json` with the generated file list.",
+            "- Run the pre-final contract checklist before finishing.",
+            "",
+            "## Output Contract Pattern",
+            *[f"- {_contract_line(contract)}" for contract in artifact_contracts[:8]],
+            "",
+        ]
+    )
+    (root / "runtime_learning_package" / "minimal_prompt_context.md").write_text(minimal_context[:4000])
+    write_json(root / "runtime_learning_package" / "output_contract.json", output_contract)
+    write_json(root / "runtime_learning_package" / "artifact_contract.json", artifact_contract)
+    write_json(root / "runtime_learning_package" / "prefinal_verification_checklist.json", prefinal_checklist)
+    (root / "runtime_learning_package" / "repair_instructions.md").write_text(
+        _repair_instructions_text(title, output_contract)
+    )
+    write_json(root / "runtime_learning_package" / "transfer_checklist.json", {
+        "source_package_id": report.get("source_package_id"),
+        "title": title,
+        "checks": [
+            "current_task_inputs_read",
+            "outputs_derived_from_current_inputs",
+            "required_filenames_created",
+            "csv_headers_or_json_keys_match_contract",
+            "actual_outputs_json_lists_generated_files",
+            "local_sanity_check_completed",
+        ],
+        "artifact_contracts": artifact_contracts,
+        "verifier_checks": criteria[:12],
+    })
+    write_json(root / "runtime_learning_package" / "tool_execution_recipe.json", {
+        "source_package_id": report.get("source_package_id"),
+        "recommended_steps": [
+            "inspect visible input files",
+            "write a short deterministic Python script or shell command sequence",
+            "run the script in the task directory",
+            "open outputs and validate schemas",
+            "write actual_outputs.json",
+        ],
+        "artifact_contracts": artifact_contracts[:12],
+    })
+    _write_jsonl(root / "runtime_learning_package" / "output_verification_steps.jsonl", [
+        {
+            "source_package_id": report.get("source_package_id"),
+            "artifact": _contract_output_path(contract),
+            "check": _contract_line(contract),
+            "evidence_refs": [contract.get("artifact_ref")] if contract.get("artifact_ref") else _evidence_refs(evidence)[:3],
+        }
+        for contract in artifact_contracts
+    ] or [{
+        "source_package_id": report.get("source_package_id"),
+        "artifact": "actual_outputs.json",
+        "check": "Generated outputs are listed in actual_outputs.json.",
+        "evidence_refs": _evidence_refs(evidence)[:3],
+    }])
+    _write_jsonl(root / "runtime_learning_package" / "common_errors_to_avoid.jsonl", [
+        {
+            "source_package_id": report.get("source_package_id"),
+            "error": "Missing required output file or writing it outside the expected relative output location.",
+            "avoidance": "Create every named artifact and reopen it before final response.",
+        },
+        {
+            "source_package_id": report.get("source_package_id"),
+            "error": "CSV headers or JSON keys drift from the expected artifact contract.",
+            "avoidance": "Use the transfer checklist and write headers/keys explicitly.",
+        },
+        {
+            "source_package_id": report.get("source_package_id"),
+            "error": "actual_outputs.json exists but does not list generated files.",
+            "avoidance": "Populate files/deliverable refs after verifying outputs on disk.",
+        },
+    ])
     for src, dst in [
         ("retrieval_card.json", "retrieval_card.json"),
         ("verifier_checklist.json", "verifier_spec.json"),
@@ -1874,8 +2951,10 @@ def _write_experience_compiler_outputs(
         "training_uses": compiler_manifest["supported_training_uses"],
         "supported_training_uses": [
             "sft",
+            "lora_ready_instruction_tuning",
             "rl",
             "grpo",
+            "agentic_rollouts",
             "reward_modeling",
             "preference_learning",
             "verifier_training",
@@ -1885,6 +2964,9 @@ def _write_experience_compiler_outputs(
             "environment_model_training",
         ],
         "row_counts": rows_accepted,
+        "row_counts_by_file": training_row_counts_by_file,
+        "schema_version": TRAINING_ROW_SCHEMA_VERSION,
+        "source_evidence_map_ref": "experience_compiler/source_evidence_map.json",
         "no_model_training_claimed": True,
     })
     for src, dst in [
@@ -1897,25 +2979,65 @@ def _write_experience_compiler_outputs(
         ("preference_pairs.jsonl", "preference_pairs.jsonl"),
     ]:
         _copy_jsonl_public(tdo_dir / src, root / "training_time_package" / dst)
-    _write_jsonl(root / "training_time_package" / "process_supervision.jsonl", reusable_rows)
+    process_rows = _process_supervision_rows_from_compiler_rows(compiler_rows)
+    _write_jsonl(root / "training_time_package" / "process_supervision.jsonl", process_rows)
+    rl_rollout_rows = _rl_rollout_rows_from_compiler_rows(compiler_rows)
+    _write_jsonl(root / "training_time_package" / "agentic_rollouts.jsonl", rl_rollout_rows)
+    _write_jsonl(root / "training_time_package" / "grpo_rollout_groups.jsonl", [
+        {
+            "schema_version": TRAINING_ROW_SCHEMA_VERSION,
+            "row_id": f"grpo_group_{_safe_id(str(report.get('source_package_id') or package_root.name))}",
+            "data_type": "grpo_rollout_group",
+            "source_package_id": report.get("source_package_id"),
+            "source_task_id": report.get("source_task_id"),
+            "task_lineage": _task_lineage(evidence),
+            "rollout_group_id": f"rollout_{_safe_id(str(report.get('source_task_id') or package_root.name))}",
+            "candidate_rollout_refs": [row.get("row_id") for row in rl_rollout_rows],
+            "reward_components": ["artifact_contract", "verifier_signal", "step_success"],
+            "source_evidence_ref_ids": _evidence_ids_for_refs(_evidence_refs(evidence)[:12]),
+            "evidence_refs": _evidence_refs(evidence)[:12],
+            "confidence": report.get("average_quality_score") or 0.5,
+            "created_at": utc_now(),
+        }
+    ] if rl_rollout_rows else [])
+    _write_jsonl(root / "training_time_package" / "rl_environment_replay_rows.jsonl", rl_rollout_rows)
     loop_pairs: list[dict[str, Any]] = []
     for item in evidence.get("loop_review_packets") or []:
         packet = item.get("packet") or {}
         ref = item.get("ref")
         loop_pairs.append({
+            "schema_version": TRAINING_ROW_SCHEMA_VERSION,
+            "pair_id": f"critique_revision_{_safe_id(str(report.get('source_package_id') or package_root.name))}_{packet.get('loop_iteration') or len(loop_pairs)+1}",
+            "row_id": f"critique_revision_{_safe_id(str(report.get('source_package_id') or package_root.name))}_{packet.get('loop_iteration') or len(loop_pairs)+1}",
+            "data_type": "critique_revision_pair",
             "source_package_id": report.get("source_package_id"),
+            "source_task_id": report.get("source_task_id"),
+            "task_lineage": _task_lineage(evidence),
             "critique": _clean_text("; ".join(packet.get("known_failures") or packet.get("recommended_review_focus") or []) or "Loop review packet recorded no blocking failure."),
             "revision": _clean_text(str((packet.get("diff_from_previous_iteration") or {}).get("changed_summary") or "Use loop feedback and revision plan to ground updates.")),
             "evidence_refs": [ref] if ref else _evidence_refs(evidence)[:5],
+            "source_evidence_ref_ids": _evidence_ids_for_refs([ref] if ref else _evidence_refs(evidence)[:5]),
             "loop_iteration": packet.get("loop_iteration"),
+            "confidence": report.get("average_quality_score") or 0.5,
+            "created_at": utc_now(),
         })
     if not loop_pairs:
         loop_pairs = [{
+            "schema_version": TRAINING_ROW_SCHEMA_VERSION,
+            "pair_id": f"critique_revision_{_safe_id(str(report.get('source_package_id') or package_root.name))}_fallback",
+            "row_id": f"critique_revision_{_safe_id(str(report.get('source_package_id') or package_root.name))}_fallback",
+            "data_type": "critique_revision_pair",
             "source_package_id": report.get("source_package_id"),
+            "source_task_id": report.get("source_task_id"),
+            "task_lineage": _task_lineage(evidence),
             "critique": "Use evaluator/verifier feedback where present; do not invent missing feedback.",
             "revision": "Ground revisions in actual outputs and artifact refs.",
             "evidence_refs": _evidence_refs(evidence)[:5],
+            "source_evidence_ref_ids": _evidence_ids_for_refs(_evidence_refs(evidence)[:5]),
+            "confidence": report.get("average_quality_score") or 0.5,
+            "created_at": utc_now(),
         }]
+    loop_pairs.extend(loop_learning["feedback_revision_pairs"])
     _write_jsonl(root / "training_time_package" / "critique_revision_pairs.jsonl", loop_pairs)
     _write_jsonl(root / "training_time_package" / "trajectory_rollouts.jsonl", [{
         "source_package_id": report.get("source_package_id"),
@@ -1923,17 +3045,35 @@ def _write_experience_compiler_outputs(
         "artifact_refs": _source_artifact_refs(evidence),
     }])
     _write_jsonl(root / "training_time_package" / "distillation_records.jsonl", [{
+        "schema_version": TRAINING_ROW_SCHEMA_VERSION,
+        "row_id": f"distill_{_safe_id(str(report.get('source_package_id') or package_root.name))}",
+        "data_type": "distillation_record",
         "source_package_id": report.get("source_package_id"),
+        "source_task_id": report.get("source_task_id"),
+        "task_lineage": _task_lineage(evidence),
         "input": instruction,
         "target": _output_summary(evidence),
         "evidence_refs": _evidence_refs(evidence)[:8],
+        "source_evidence_ref_ids": _evidence_ids_for_refs(_evidence_refs(evidence)[:8]),
+        "confidence": report.get("average_quality_score") or 0.5,
+        "created_at": utc_now(),
     }])
     _write_jsonl(root / "training_time_package" / "transfer_eval_tasks.jsonl", [
         {
+            "schema_version": TRAINING_ROW_SCHEMA_VERSION,
+            "row_id": f"transfer_eval_{_safe_id(str(report.get('source_package_id') or package_root.name))}",
+            "data_type": "transfer_eval_task",
             "source_package_id": report.get("source_package_id"),
+            "source_task_id": report.get("source_task_id"),
+            "task_lineage": _task_lineage(evidence),
             "task": f"Replay a small adjacent {(_task_title(evidence) or 'workflow')} task and compare artifact quality.",
             "success_signal": "bundle check passes and verifier/evaluator evidence refs are present",
             "transfer_tested": False,
+            "expected_output_contract": output_contract,
+            "source_evidence_ref_ids": _evidence_ids_for_refs(_evidence_refs(evidence)[:8]),
+            "evidence_refs": _evidence_refs(evidence)[:8],
+            "confidence": report.get("average_quality_score") or 0.5,
+            "created_at": utc_now(),
         }
     ])
     write_json(root / "reports" / "transfer_test_report.json", {
@@ -1943,17 +3083,155 @@ def _write_experience_compiler_outputs(
     _copy_jsonl_public(tdo_dir / "evaluation_examples.jsonl", root / "eval_package" / "evaluation_examples.jsonl")
     shutil.copy2(root / "training_time_package" / "transfer_eval_tasks.jsonl", root / "eval_package" / "transfer_eval_tasks.jsonl")
     shutil.copy2(root / "reports" / "transfer_test_report.json", root / "eval_package" / "transfer_test_report.json")
-    _write_jsonl(root / "eval_package" / "rubric_items.jsonl", [{"source_package_id": report.get("source_package_id"), "rubric_item": item} for item in criteria])
-    _write_jsonl(root / "eval_package" / "grader_cases.jsonl", [{"source_package_id": report.get("source_package_id"), "case": "Grade output against compiled rubric and artifact evidence.", "evidence_refs": _evidence_refs(evidence)[:5]}])
-    _write_jsonl(root / "eval_package" / "verifier_cases.jsonl", [{"source_package_id": report.get("source_package_id"), "case": "Verify required artifacts and output refs exist.", "evidence_refs": _evidence_refs(evidence)[:5]}])
-    _write_jsonl(root / "eval_package" / "expected_artifacts.jsonl", [{"source_package_id": report.get("source_package_id"), "artifact_ref": ref} for ref in _source_artifact_refs(evidence)])
+    write_json(root / "eval_package" / "eval_manifest.json", {
+        "schema_version": "aa-eval-package-v0.2",
+        "source_package_id": report.get("source_package_id"),
+        "source_task_id": report.get("source_task_id"),
+        "task_lineage": _task_lineage(evidence),
+        "source_evidence_map_ref": "experience_compiler/source_evidence_map.json",
+        "output_contract_ref": "experience_compiler/runtime_learning_package/output_contract.json",
+        "artifact_contract_ref": "experience_compiler/runtime_learning_package/artifact_contract.json",
+        "supported_eval_uses": ["rubric_eval", "contract_verifier_training", "transfer_eval_generation", "grader_case_generation"],
+    })
+    _write_jsonl(root / "eval_package" / "rubric_items.jsonl", [
+        {
+            "schema_version": TRAINING_ROW_SCHEMA_VERSION,
+            "row_id": f"eval_rubric_{_safe_id(str(report.get('source_package_id') or package_root.name))}_{idx}",
+            "data_type": "eval_rubric_item",
+            "source_package_id": report.get("source_package_id"),
+            "source_task_id": report.get("source_task_id"),
+            "task_lineage": _task_lineage(evidence),
+            "rubric_item": item,
+            "scoring_criterion": item,
+            "evidence_refs": _evidence_refs(evidence)[:5],
+            "source_evidence_ref_ids": _evidence_ids_for_refs(_evidence_refs(evidence)[:5]),
+            "confidence": report.get("average_quality_score") or 0.5,
+            "created_at": utc_now(),
+        }
+        for idx, item in enumerate(criteria, start=1)
+    ])
+    _write_jsonl(root / "eval_package" / "grader_cases.jsonl", [{
+        "schema_version": TRAINING_ROW_SCHEMA_VERSION,
+        "row_id": f"grader_case_{_safe_id(str(report.get('source_package_id') or package_root.name))}",
+        "data_type": "grader_case",
+        "source_package_id": report.get("source_package_id"),
+        "source_task_id": report.get("source_task_id"),
+        "task_lineage": _task_lineage(evidence),
+        "case": "Grade output against compiled rubric and artifact evidence.",
+        "output_contract": output_contract,
+        "artifact_contract": artifact_contract,
+        "evidence_refs": _evidence_refs(evidence)[:5],
+        "source_evidence_ref_ids": _evidence_ids_for_refs(_evidence_refs(evidence)[:5]),
+        "confidence": report.get("average_quality_score") or 0.5,
+        "created_at": utc_now(),
+    }])
+    _write_jsonl(root / "eval_package" / "verifier_cases.jsonl", [{
+        "schema_version": TRAINING_ROW_SCHEMA_VERSION,
+        "row_id": f"verifier_case_{_safe_id(str(report.get('source_package_id') or package_root.name))}",
+        "data_type": "verifier_case",
+        "source_package_id": report.get("source_package_id"),
+        "source_task_id": report.get("source_task_id"),
+        "task_lineage": _task_lineage(evidence),
+        "claim_or_output": "Required artifacts and output refs exist and match the contract.",
+        "visible_evidence": _source_artifact_refs(evidence)[:12],
+        "expected_contract": output_contract,
+        "verifier_decision": "case_requires_future_candidate_output",
+        "failure_reasons": [],
+        "evidence_refs": _evidence_refs(evidence)[:5],
+        "source_evidence_ref_ids": _evidence_ids_for_refs(_evidence_refs(evidence)[:5]),
+        "confidence": report.get("average_quality_score") or 0.5,
+        "created_at": utc_now(),
+    }])
+    _write_jsonl(root / "eval_package" / "expected_artifacts.jsonl", [
+        {
+            "schema_version": TRAINING_ROW_SCHEMA_VERSION,
+            "row_id": f"expected_artifact_{_safe_id(str(report.get('source_package_id') or package_root.name))}_{idx}",
+            "data_type": "expected_artifact",
+            "source_package_id": report.get("source_package_id"),
+            "source_task_id": report.get("source_task_id"),
+            "task_lineage": _task_lineage(evidence),
+            "artifact_ref": ref,
+            "source_evidence_ref_ids": _evidence_ids_for_refs([ref]),
+            "evidence_refs": [ref],
+            "confidence": 1.0,
+            "created_at": utc_now(),
+        }
+        for idx, ref in enumerate(_source_artifact_refs(evidence), start=1)
+    ])
     env_spec = _environment_spec(evidence)
-    write_json(root / "environment" / "replay_plan.json", {"source_package_id": report.get("source_package_id"), "replay_available": False, "generation_note": "Replay is task-dependent; use environment_spec and verifier checks."})
-    write_json(root / "environment" / "setup_requirements.json", {"required_tools": env_spec.get("required_tools") or [], "runtime_dependencies": env_spec.get("runtime_dependencies") or []})
-    _write_jsonl(root / "environment" / "allowed_actions.jsonl", [{"action": action, "source_package_id": report.get("source_package_id")} for action in (env_spec.get("allowed_actions") or ["read_task", "write_artifact", "verify_output"])])
+    write_json(root / "environment" / "environment_manifest.json", {
+        "schema_version": "aa-environment-package-v0.2",
+        "source_package_id": report.get("source_package_id"),
+        "source_task_id": report.get("source_task_id"),
+        "task_lineage": _task_lineage(evidence),
+        "environment_spec_ref": "experience_compiler/environment/environment_spec.json",
+        "state_transition_rows_ref": "experience_compiler/environment/state_transition_rows.jsonl",
+        "replay_plan_ref": "experience_compiler/environment/replay_plan.json",
+        "source_evidence_map_ref": "experience_compiler/source_evidence_map.json",
+        "supported_training_uses": ["agentic_rl", "grpo_rollout_material", "environment_model_training", "replay_smoke_testing"],
+    })
+    write_json(root / "environment" / "replay_plan.json", {
+        "schema_version": "aa-replay-plan-v0.2",
+        "source_package_id": report.get("source_package_id"),
+        "source_task_id": report.get("source_task_id"),
+        "task_lineage": _task_lineage(evidence),
+        "replay_available": bool(env_spec.get("verification_commands")),
+        "initial_state_refs": env_spec.get("initial_state_refs") or [],
+        "visible_input_refs": env_spec.get("input_artifacts") or [],
+        "action_schema_ref": "experience_compiler/environment/allowed_actions.jsonl",
+        "observation_schema": {"observation": "string", "artifact_refs": "array", "state_after": "string"},
+        "scoring_or_verifier_hooks": env_spec.get("scoring_refs") or [],
+        "termination_conditions": ["task_complete", "contract_verified", "max_iterations_reached"],
+        "reward_function_components": ["artifact_contract", "verifier_signal", "step_success"],
+        "generation_note": "Replay is task-dependent; use environment_spec and verifier checks.",
+    })
+    write_json(root / "environment" / "setup_requirements.json", {
+        "schema_version": "aa-environment-setup-v0.2",
+        "source_package_id": report.get("source_package_id"),
+        "required_tools": env_spec.get("required_tools") or [],
+        "runtime_dependencies": env_spec.get("runtime_dependencies") or [],
+        "dependency_metadata": env_spec.get("software_execution") or {},
+    })
+    _write_jsonl(root / "environment" / "allowed_actions.jsonl", [
+        {
+            "schema_version": TRAINING_ROW_SCHEMA_VERSION,
+            "row_id": f"allowed_action_{_safe_id(str(report.get('source_package_id') or package_root.name))}_{idx}",
+            "data_type": "allowed_action",
+            "source_package_id": report.get("source_package_id"),
+            "source_task_id": report.get("source_task_id"),
+            "task_lineage": _task_lineage(evidence),
+            "action": action,
+            "source_evidence_ref_ids": _evidence_ids_for_refs(_evidence_refs(evidence)[:3]),
+            "evidence_refs": _evidence_refs(evidence)[:3],
+            "confidence": report.get("average_quality_score") or 0.5,
+            "created_at": utc_now(),
+        }
+        for idx, action in enumerate((env_spec.get("allowed_actions") or ["read_task", "write_artifact", "verify_output"]), start=1)
+    ])
     _copy_jsonl_public(tdo_dir / "environment_response_pairs.jsonl", root / "environment" / "state_transition_rows.jsonl")
-    write_json(root / "environment" / "reset_strategy.json", {"reset_strategy": env_spec.get("reset_strategy") or "unknown", "generation_notes": env_spec.get("evidence_status") or []})
-    _write_jsonl(root / "environment" / "verification_commands.jsonl", [{"command": command, "source_package_id": report.get("source_package_id")} for command in (env_spec.get("verification_commands") or [])])
+    write_json(root / "environment" / "reset_strategy.json", {
+        "schema_version": "aa-environment-reset-v0.2",
+        "source_package_id": report.get("source_package_id"),
+        "reset_strategy": env_spec.get("reset_strategy") or "unknown",
+        "state_reset_refs": env_spec.get("initial_state_refs") or [],
+        "generation_notes": env_spec.get("evidence_status") or [],
+    })
+    _write_jsonl(root / "environment" / "verification_commands.jsonl", [
+        {
+            "schema_version": TRAINING_ROW_SCHEMA_VERSION,
+            "row_id": f"verification_command_{_safe_id(str(report.get('source_package_id') or package_root.name))}_{idx}",
+            "data_type": "verification_command",
+            "source_package_id": report.get("source_package_id"),
+            "source_task_id": report.get("source_task_id"),
+            "task_lineage": _task_lineage(evidence),
+            "command": command,
+            "source_evidence_ref_ids": _evidence_ids_for_refs(_evidence_refs(evidence)[:3]),
+            "evidence_refs": _evidence_refs(evidence)[:3],
+            "confidence": report.get("average_quality_score") or 0.5,
+            "created_at": utc_now(),
+        }
+        for idx, command in enumerate((env_spec.get("verification_commands") or []), start=1)
+    ])
     (root / "reports" / "generation_notes.md").write_text(
         "\n".join([
             "# Generation Notes",
@@ -1969,6 +3247,7 @@ def _write_experience_compiler_outputs(
             {"kind": "runtime_learning_package", "path": "experience_compiler/runtime_learning_package/runtime_learning_manifest.json"},
             {"kind": "training_time_package", "path": "experience_compiler/training_time_package/training_time_manifest.json"},
             {"kind": "environment", "path": "experience_compiler/environment/environment_spec.json"},
+            {"kind": "loop_learning", "path": "experience_compiler/loop_learning/loop_review_rows.jsonl"},
             {"kind": "reports", "path": "experience_compiler/compiler_report.json"},
         ],
         "rows_by_type": rows_accepted,