agent-apprenticeship 0.1.8 → 0.2.0

package/docs/trace_schema.md

@@ -0,0 +1,192 @@
+# Agent Apprenticeship Trace Schema
+
+## Purpose
+
+Agent Apprenticeship traces record authentic task work so completed workflows can become reusable agent experience. AgentTrace records observable workflow steps: task state, Apprentice Agent action, observed environment response, next state, artifacts produced, and evidence used by mentors, evaluators, verifiers, and graders.
+
+Official quality labels come from mentor, expert, evaluator, verifier, and grader records, not from Apprentice Agent self-evaluation. This separation keeps the raw trace focused on what happened while outcome labels remain grounded in external evidence.
+
+## Public Product Model
+
+Public task metadata uses `apprenticeship_mode`:
+
+- `autonomous` for Autonomous Apprenticeship
+- `expert_led` for Expert-Led Apprenticeship
+- `org_custom` for Organization Custom
+
+The older internal `mentor_mode` field may remain in legacy packages for compatibility, but public docs and new package metadata should prefer `apprenticeship_mode`. Mentor Model Providers, experts, evaluators, verifiers, and graders remain outcome evidence sources. Apprentice Agent self-assessment is not outcome truth.
+
+## Authentic Workflow Tracing
+
+Trace real task work only. Do not trace Agent Apprenticeship packaging, public upload mechanics, or ecosystem storage steps as task work. Keep one meaningful action per step. Do not compress multiple actions into a vague paragraph. Preserve causality through `caused_by`, `causal_type`, and `causal_note`.
+
+## Canonical Outputs
+
+`actual_outputs.json` is the canonical output contract. Traces should include `actual_outputs_ref` when known, plus `artifact_refs`, `deliverable_refs`, `files_created`, `output_summary`, and `final_output_summary` derived from actual outputs rather than copied raw deliverables.
+
+Large files, screenshots, PDFs, tables, logs, audio, video, workbooks, and binary artifacts must be referenced through package-relative artifact refs. Do not embed huge binaries in JSON.
+
+## Observation, Input, Output, State Change
+
+`observation` records what the agent saw before acting. `input` records the exact command, tool request, user instruction, artifact, or feedback used. `output` records the observed tool/environment response. `state_change` records what changed after the action.
+
+## Step Core Fields
+
+Meaningful non-user steps should populate:
+
+- `step`, `turn`, `actor`, `action`
+- `operation`, `tool`
+- `observation`, `input`, `output`, `state_change`
+- `reasoning`
+- `caused_by`, `causal_type`, `causal_note`
+- `success`, `step_outcome`
+- `artifact_refs` when evidence or outputs are created, read, or validated
+
+## Conditional Fields
+
+Populate conditional fields when the event calls for them:
+
+- `input_source` when input comes from the user, a prior step, a tool result, an artifact, mentor feedback, verifier feedback, expert feedback, a follow-up, or retry context.
+- `feedback_type` and `feedback_content` when the step records feedback, correction, approval, clarification, revision guidance, or follow-up instructions.
+- `retry_of` when a step repairs or revises a prior step.
+- `alternatives_considered` for meaningful strategy, tool, remediation, or design choices.
+- `execution_mode` defaults to `serial`; use `parallel` and `parallel_group` only for real fanout work.
+- `started_at` and `ended_at` only when measured by runtime.
+
+## Environment Domain Taxonomy And Interaction Surface Taxonomy
+
+Every meaningful operation should identify its direct interface with `interaction_surface`, broader category with `environment_domain`, and a subtype with `surface_type` when useful.
+
+Supported surfaces:
+
+- `api`
+- `mcp_tool`, `mcp_resource`, `mcp_prompt`
+- `browser`, `computer_use`
+- `cli`, `file`, `codebase`
+- `database`
+- `spreadsheet`, `table`
+- `search`
+- `cloud_console`, `saas_app`
+- `async_job`, `queue`, `webhook`, `scheduler`
+- `messaging`, `email`, `collaboration`
+- `document`, `pdf`
+- `multimodal`
+- `device`, `industrial`, `physical`
+- `mixed`, `other_tool`, `other_surface`, `unknown`
+
+If a workflow crosses systems, use `environment_domain = mixed`, record `connected_surfaces`, split actions by system, and preserve `cross_system_dependencies`, `handoff_refs`, `state_sync_refs`, `consistency_checks`, and `system_of_record`.
+
+## Surface-Specific Evidence
+
+When an operation clearly uses a surface, do not leave the relevant fields silently empty. If data is unavailable, set `surface_capture_status`, `surface_capture_notes`, and `missing_surface_fields`.
+
+API steps should capture endpoint, method, version, status, request/response refs, resource IDs, auth mode without secrets, pagination, rate limits, retries, and errors.
+
+MCP steps should capture server, capability type, tool/resource/prompt name, argument refs, result refs, schemas, call IDs, and errors.
+
+Database steps should capture database type, schema/table, query type, query ref or hash, row counts, affected rows, transaction IDs, snapshots, explain plans, rollback refs, and errors.
+
+Spreadsheet and table steps should capture workbook refs, sheet names, ranges, row/column counts, formula refs, pivots, charts, validation refs, before/after refs, and diffs.
+
+CLI, file, and codebase steps should capture command, cwd ref, exit code, stdout/stderr refs, file operations, paths, diffs, patches, git state, test/build/lint refs, process IDs, and timeouts.
+
+Search steps should capture query, provider, scope, filters, result count, selected result refs, citation refs, ranking signals, time range, and errors.
+
+Browser, computer-use, and software steps should capture UI surface, app name/version, OS, device, window/page title, URL or resource ID, visible-state refs, screenshot refs, DOM/accessibility refs, selectors, coordinates, action type, input text, before/after refs, network/API refs, and software state refs.
+
+Cloud, SaaS, and enterprise app steps should capture service, workspace/project/tenant identifiers when safe, resource or ticket IDs, object state refs, permission context, region, environment, deployment IDs, audit logs, and change-request refs.
+
+Async, queue, webhook, and scheduler steps should capture job/message/webhook/schedule IDs, trigger type, enqueue/start/completion times, retry count, delivery/polling/callback status, result refs, and dead-letter refs.
+
+Messaging, email, and collaboration steps should capture platform, channel/thread/message IDs, sender/recipient roles, message refs, attachment refs, decisions, approval state, and follow-up requirements.
+
+Document, PDF, report, and extraction steps should capture document refs, document type, page/section refs, text/OCR/table/figure/citation/annotation refs, summaries, and document diffs.
+
+Device, industrial, and physical workflow steps should capture physical environment type, device details when safe, sensor/telemetry refs, actuator command summaries, control mode, before/after physical state refs, calibration refs, safety state, safety limits, operator override, human supervision, simulation or real-world status, latency, tolerance, rollback action, emergency stop, and compliance refs.
+
+## Multi-Agent And Multimodal Support
+
+Multi-agent workflows should preserve `actor_kind`, `actor_role`, `agent_id`, `agent_name`, `subagent_id`, `subagent_name`, `subagent_role`, `parent_agent_id`, `delegation_id`, `delegation_source_step`, `handoff_reason`, `handoff_payload_ref`, `handoff_output_refs`, `subagent_output_refs`, `coordination_pattern`, `communication_channel`, and `depends_on_agent_outputs`.
+
+Multimodal workflows should preserve `modality`, `modalities`, `media_type`, `mime_type`, `artifact_role`, `artifact_hash`, `artifact_preview_ref`, `ocr_text_ref`, `transcript_ref`, `annotation_ref`, `bbox_refs`, `frame_refs`, `timecode_refs`, `table_refs`, `sheet_refs`, and `derived_text_summary`.
+
+## Completeness Warnings
+
+New traces should record warnings, not fabricate missing values:
+
+- `surface_capture_status = complete | partial | unavailable | not_applicable`
+- `surface_capture_notes`
+- `missing_surface_fields`
+- `trace_quality_warnings`
+
+Old seed traces remain compatible when these fields are absent.
+
+## Loop Review Packets
+
+Each new iterative workflow loop should create review artifacts after an Apprentice Agent iteration and before model or expert review. The package-level structure is:
+
+```text
+loops/
+  loop_manifest.json
+  iterations/
+    001/
+      review_packet.md
+      review_packet.json
+      output_snapshot.json
+      artifact_index.json
+      trace_refs.json
+      rubric_status.json
+      verifier_status.json
+      evaluator_feedback.json
+      reviewer_feedback.json
+      revision_plan.json
+      diff_report.json
+      loop_decision.json
+```
+
+`review_packet.json` is the current iteration dossier. It should include `loop_id`, `loop_iteration`, mode, task/package/run ids, the current goal, output refs, `actual_outputs_ref`, artifact refs and previews, trace refs, key trace steps, rubric and verifier status, evaluator status, known failures, missing outputs, open questions, surface/environment summaries, previous iteration refs, diff from the previous iteration, reviewer instructions, recommended review focus, stop/continue options, and `created_at`.
+
+Autonomous model review should use the review packet as the review source before judging the attempt. Expert-Led review should show or link the packet before collecting expert feedback. Review feedback records should say whether the reviewer was `mentor_model_provider`, `human_expert`, `org_custom_reviewer`, or `simulated_for_test`; simulated or auto-test checkpoints must not be presented as real human review.
+
+Revision plans should cite feedback refs, list issues to fix, artifacts and outputs to update, verification steps, stop conditions, and creation time. The next iteration should record feedback refs used, changes made, changed artifacts/outputs, and whether feedback was applied. Record-only follow-ups may create a follow-up review update without inventing new execution data.
+
+## Experience Compiler Use
+
+The Experience Compiler runs after completed task work and follow-ups. It derives reusable runtime learning and training-time data from package evidence: task packets, rubrics, traces, `actual_outputs.json`, artifacts, attempt manifests, evaluator feedback, grader results, verifier results, revision plans, process supervision, reward modeling, revision preference pairs, lessons, follow-up records, mentor checkpoints, loop review packets, reviewer feedback, loop decisions, and diff reports.
+
+The compiler emits:
+
+- Experience Pack material
+- Skill Pack material, including `skill_pack/skill.md`
+- Runtime Learning Package material
+- Training-Time Package material
+- eval, verifier, reward, and preference rows
+- observed environment-response rows
+- surface event rows
+- `environment_spec.json`
+- reports and transfer-readiness records
+
+It does not claim model training happened. It produces training-ready and runtime-ready material grounded in observed workflow evidence.
+
+## World-Model-Ready Fields
+
+World-model-ready fields include `environment_domain`, `interaction_surface`, `state_before`, `agent_action`, `observed_environment_response`, `state_after`, `turn_idx`, `total_turns`, and environment-response quality scores.
+
+## World-Model-Ready Observed Rows
+
+Observed environment-response rows should include state/action/next-state style data:
+
+- `environment_domain`
+- `interaction_surface`
+- `state_before`
+- `agent_action`
+- `observed_environment_response`
+- `state_after`
+- `turn_idx`, `total_turns`
+- `format_score`, `factuality_score`, `consistency_score`, `realism_score`, `training_quality_score`, `environment_response_quality_score`
+
+These rows are saved as `environment_response_pairs.jsonl` in Experience Compiler outputs. `environment_spec.json` describes replay and environment readiness. No simulated environment responses are part of the product flow. There is no Qwen-AgentWorld runtime or simulator config in the product flow, and traces must not emit `simulated_environment_response`.
+
+## Not Included
+
+Do not add commerce metadata, public ranking language, or Apprentice Agent self-eval as outcome truth. Do not include secrets, API keys, auth headers, cookies, private local paths, `.env`, `.env.local`, source scrape internals, or huge binaries in JSON.

package/docs/v0.2_release_notes.md

@@ -0,0 +1,61 @@
+# Agent Apprenticeship v0.2.0 Technical Release Notes
+
+Agent Apprenticeship v0.2.0 expands the Experience Compilation system from Runtime Training reuse into a fuller package for agent training, evaluation, replay, verifier/reward work, and provenance audit.
+
+## Core Product Changes
+
+- Full Experience Compilation packages now include traces, attempts, artifacts, actual outputs, loop review packets, evaluation/verifier/grader records, Runtime Training, training-time packages, eval packages, environment/replay packages, manifests, and source evidence maps where available.
+- Public Ecosystem mode defaults to automatic upload of the full Experience Compilation after completed tasks.
+- Private Internal Only mode records a no-upload path and does not upload completed tasks.
+- Ecosystem consumption is centered on two actions: Export Full Experience Compilation and Install Runtime Training.
+- Runtime Training install/use records installed skill refs, selected Runtime Training refs, confidence metadata, injected sections, and compact contract-focused context.
+- `apprentice bundle check` accepts local Experience Compilation folders that use task/package/compiler manifests, including regenerated seed task packages.
+
+## Experience Compiler And Training Packages
+
+- Experience Compiler outputs now include stronger package metadata, schema versions, compiler versions, package versions from `get_package_version()`, row counts, public/private mode, and provenance fields.
+- Generated package material is no longer treated as only prompt/completion data. The package supports SFT and LoRA-ready instruction rows, process supervision, reward model rows, verifier model rows, preference pairs, critique/revision pairs, failure cases, task variants, eval/rubric rows, environment/replay rows, and agentic rollout material.
+- Source evidence maps now include stable evidence IDs, evidence types, visibility, confidence, content hashes where available, row evidence links, and validation for broken refs.
+- Eval and environment packages now have first-class manifests and replay/scoring-oriented metadata.
+
+## Demo B Local Proof
+
+Demo B is a local ALE workflow-family mirrored transfer proof, not an official ALE benchmark score.
+
+- Completed workflow families: 7
+- Improved: 7
+- Same: 0
+- Worse: 0
+- Severe regressions: 0
+- Average baseline score: 0.3429
+- Average treatment score: 0.8929
+- Average delta: +0.5500
+- Median delta: +0.4500
+- Leakage check: passed
+
+The supported claim is that Agent Apprenticeship Runtime Training from source Experience Compilations improved related held-out mirrored workflow-family tasks in this local proof set.
+
+## Seed Dataset v0.2
+
+Seed Dataset v0.2 is an Experience Compilation dataset generated from seed tasks. It is not the specialized bioactive/wellness model-training dataset.
+
+- Full Experience Compilations: 505
+- Skill packs: 505
+- Runtime Training packages: 505
+- Training-time packages: 505
+- Eval packages: 505
+- Environment/replay packages: 505
+- Source evidence maps: 505
+- Source evidence rows: 6,483
+- Row evidence links: 15,004
+- Viewer/export configs: 15
+- Normalized Data Viewer rows: 39,835
+
+Use the wording “505 Experience Compilations plus 39,835 normalized Data Viewer rows.” Do not describe the normalized viewer rows as tasks.
+
+## Release Boundary
+
+- The package version is 0.2.0 for release-candidate builds.
+- The regenerated Seed Dataset v0.2 was generated before npm v0.2.0 publication and records the local package metadata present at generation time.
+- No model weights are included.
+- No official ALE benchmark score is claimed for the mirrored transfer tasks.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-apprenticeship",
-  "version": "0.1.8",
+  "version": "0.2.0",
   "description": "The living ecosystem for AI agents learning from real-world work through iterative loops and training-signal exchange.",
   "license": "MIT",
   "repository": {
@@ -14,6 +14,7 @@
   "files": [
     "README.md",
     "LICENSE",
+    "docs",
     "pyproject.toml",
     "src/agent_apprenticeship_trace",
     "bin"

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agent-apprenticeship"
-version = "0.1.8"
+version = "0.2.0"
 description = "Open framework for turning real agent work into transferable agent experience"
 readme = "README.md"
 requires-python = ">=3.11"

package/src/agent_apprenticeship_trace/__init__.py

@@ -1,2 +1,2 @@
 """Agent Apprenticeship framework."""
-__version__ = "0.1.8"
+__version__ = "0.2.0"

package/src/agent_apprenticeship_trace/bundle_exporter.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import shutil
 import tempfile
 import re
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
 
@@ -12,6 +13,7 @@ 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
+from .version import get_package_version
 
 
 def _count_jsonl(path: Path) -> int:
@@ -87,8 +89,12 @@ def _run_status(release_root: Path) -> str:
 
 
 def contribution_counts(release_root: Path) -> dict[str, int]:
+    trace_count = _count_jsonl(release_root / "agent_traces.jsonl")
+    actual_outputs_count = _count_jsonl(release_root / "actual_outputs.jsonl")
     return {
-        "attempts": _count_jsonl(release_root / "actual_outputs.jsonl"),
+        "attempts": actual_outputs_count,
+        "actual_outputs_count": actual_outputs_count,
+        "trace_count": trace_count,
         "traced_steps": _trace_step_count(release_root / "agent_traces.jsonl"),
         "process_supervision_rows": _count_jsonl(release_root / "process_supervision.jsonl"),
         "reward_modeling_rows": _count_jsonl(release_root / "reward_modeling.jsonl"),
@@ -310,16 +316,31 @@ def _bundle_metadata_shape(bundle_root: Path, release_root: Path, settings: Sett
     role = task.get("agent_apprentice_role") or task.get("apprenticeship_role")
     metadata = {
         "bundle_id": f"aa-bundle-{_slug(run_id)}",
+        "experience_compilation_id": f"aa-compilation-{_slug(run_id)}",
+        "compilation_id": f"aa-compilation-{_slug(run_id)}",
+        "schema_version": "aa-experience-compilation-v0.2",
+        "package_version": get_package_version(),
+        "created_at": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"),
         "title": title,
+        "task_title": title,
         **counts,
         "domains": _list_value(task.get("domain")),
         "subdomains": _list_value(task.get("subdomain")),
+        "domain": (_list_value(task.get("domain")) or ["general"])[0],
+        "subdomain": (_list_value(task.get("subdomain")) or ["general"])[0],
+        "workflow_family": task.get("task_family") or task.get("workflow_family") or task.get("workflow_type") or "general_workflow",
+        "tags": sorted(set([str(task.get("domain") or "general"), str(task.get("subdomain") or "general"), str(task.get("workflow_type") or "workflow")]))[:12],
+        "surfaces": [],
+        "tools": [],
         "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),
+        "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",
         "task_status": task_status,
         "run_status": run_status,
     }
@@ -391,7 +412,14 @@ def _tdo_manifest_shape(release_root: Path) -> dict[str, Any]:
 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] = []
+    compiler_manifest: dict[str, Any] = {}
+    source_evidence_coverage: dict[str, Any] = {}
+    quality_report: dict[str, Any] = {}
     if len(compiler_dirs) == 1:
+        compiler_manifest = read_json(compiler_dirs[0] / "compiler_manifest.json") if (compiler_dirs[0] / "compiler_manifest.json").exists() else {}
+        source_map = read_json(compiler_dirs[0] / "source_evidence_map.json") if (compiler_dirs[0] / "source_evidence_map.json").exists() else {}
+        source_evidence_coverage = source_map.get("coverage_statistics") or {}
+        quality_report = read_json(compiler_dirs[0] / "quality_report.json") if (compiler_dirs[0] / "quality_report.json").exists() else {}
         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()}")
@@ -406,10 +434,17 @@ def _experience_compiler_manifest_shape(release_root: Path, latest_report: dict[
         "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 {},
+        "training_row_counts": latest_report.get("rows_accepted_by_type") or {},
+        "training_row_counts_by_file": compiler_manifest.get("training_row_counts_by_file") or quality_report.get("training_row_counts_by_file") or {},
+        "source_evidence_map_count": source_evidence_coverage.get("evidence_ref_count"),
+        "source_evidence_row_link_count": source_evidence_coverage.get("row_link_count"),
         "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"),
+        "compiler_version": compiler_manifest.get("compiler_version"),
+        "training_row_schema_version": compiler_manifest.get("training_row_schema_version"),
+        "source_evidence_map_schema_version": compiler_manifest.get("source_evidence_map_schema_version"),
     }
 
 

package/src/agent_apprenticeship_trace/cli.py

@@ -152,6 +152,12 @@ def _print_public_ecosystem_contribution_help(bundle: str | Path) -> None:
     typer.echo('Forsy ecosystem')
 
 
+def _print_private_internal_share_note(bundle: str | Path) -> None:
+    typer.echo('Private Internal Only: no Public Ecosystem upload was made.')
+    typer.echo('Optional manual share:')
+    typer.echo(f'apprentice ecosystem contribute {bundle}')
+
+
 def _print_first_run_banner() -> None:
     typer.echo(FIRST_RUN_BANNER)
     typer.echo("")
@@ -199,7 +205,7 @@ def _print_task_result(
             mode = get_settings().training_contribution_mode
             typer.echo(f'Agent Training Contribution Mode: {training_contribution_mode_display(mode)}')
             if mode == "private_internal_only":
-                _print_public_ecosystem_contribution_help(bundle)
+                _print_private_internal_share_note(bundle)
             typer.echo('')
             typer.echo('View files:')
             typer.echo(f'open {bundle}')
@@ -226,7 +232,7 @@ def _print_session_finished(status: dict, *, include_contribution_help: bool=Tru
             mode = get_settings().training_contribution_mode
             typer.echo(f'Agent Training Contribution Mode: {training_contribution_mode_display(mode)}')
             if mode == "private_internal_only":
-                _print_public_ecosystem_contribution_help(status.get('contribution_bundle_path'))
+                _print_private_internal_share_note(status.get('contribution_bundle_path'))
             typer.echo('')
             typer.echo('View files:')
             typer.echo(f"open {status.get('contribution_bundle_path')}")
@@ -1439,6 +1445,8 @@ def start(
     status = read_run_status(run_root)
     if quiet:
         _print_task_result(status, include_contribution_help=False)
+    elif not json_progress:
+        _print_task_result(status)
     _handle_ecosystem_auto_share(status, quiet=quiet, json_progress=json_progress)
 
 @app.command('run')
@@ -1652,7 +1660,7 @@ def status(run_id: str=typer.Argument(..., help='Run id or path to inspect.')):
     typer.echo(format_run_status(read_run_status(run_root)))
 
 
-@app.command('watch')
+@app.command('watch', help='Watch live run progress, loop reviews, artifacts, and Experience Compiler status.')
 def watch(
     run_id: str=typer.Argument(..., help='Run id or path to watch.'),
     interval: float=typer.Option(1.0, '--interval', help='Polling interval in seconds.'),
@@ -3940,17 +3948,25 @@ def bundle_check(path: Path=typer.Argument(..., help='Experience Compilation fol
 
     issues: list[str] = []
     bundle = Path(path).expanduser()
-    manifest_path = bundle / "contribution_manifest.json"
+    manifest_candidates = [
+        bundle / "contribution_manifest.json",
+        bundle / "task_manifest.json",
+        bundle / "package_manifest.json",
+        bundle / "manifest.json",
+        bundle / "experience_compiler" / "compiler_manifest.json",
+    ]
+    manifest_path = next((candidate for candidate in manifest_candidates if candidate.exists()), manifest_candidates[0])
     if not bundle.exists():
         issues.append(f"Bundle path does not exist: {bundle}")
     elif not manifest_path.exists():
-        issues.append(f"Experience Compilation manifest not found: {manifest_path}")
+        candidate_names = ", ".join(str(candidate.relative_to(bundle)) for candidate in manifest_candidates)
+        issues.append(f"Experience Compilation manifest not found. Checked: {candidate_names}")
     manifest_data = {}
     if manifest_path.exists():
         try:
             manifest_data = read_json(manifest_path)
         except Exception as exc:
-            issues.append(f"contribution_manifest.json could not be parsed: {exc}")
+            issues.append(f"{manifest_path.relative_to(bundle)} could not be parsed: {exc}")
     artifact_index_path = bundle / "outputs" / "artifacts_index.json"
     artifacts: list[dict] = []
     if artifact_index_path.exists():
@@ -4012,6 +4028,56 @@ def bundle_check(path: Path=typer.Argument(..., help='Experience Compilation fol
                 read_json(file_path)
             except Exception as exc:
                 issues.append(f"{file_path.relative_to(bundle)} could not be parsed: {exc}")
+        source_map_path = compiler_dir / "source_evidence_map.json"
+        if source_map_path.exists():
+            try:
+                source_map = read_json(source_map_path)
+                evidence_ids = {
+                    str(item.get("evidence_id"))
+                    for item in source_map.get("evidence_catalog") or []
+                    if isinstance(item, dict) and item.get("evidence_id")
+                }
+                for link in source_map.get("row_evidence_links") or []:
+                    if not isinstance(link, dict):
+                        continue
+                    link_ids = link.get("evidence_ref_ids") or link.get("source_evidence_ids") or []
+                    for evidence_id in link_ids:
+                        if str(evidence_id) not in evidence_ids:
+                            issues.append(f"source_evidence_map row {link.get('row_id')} references unknown evidence id: {evidence_id}")
+                orphan_count = (
+                    (source_map.get("coverage_statistics") or {}).get("orphan_evidence_id_count")
+                    if isinstance(source_map.get("coverage_statistics"), dict)
+                    else None
+                )
+                if orphan_count is None:
+                    orphan_count = (source_map.get("coverage") or {}).get("orphan_evidence_id_count")
+                if orphan_count not in (None, 0):
+                    issues.append(f"source_evidence_map has orphan evidence ids: {orphan_count}")
+            except Exception as exc:
+                issues.append(f"{source_map_path.relative_to(bundle)} could not be validated: {exc}")
+        seen_training_ids: set[str] = set()
+        for file_path in compiler_dir.rglob("*.jsonl"):
+            try:
+                rows = read_jsonl(file_path)
+            except Exception as exc:
+                issues.append(f"{file_path.relative_to(bundle)} could not be parsed: {exc}")
+                continue
+            if "training_time_package" in file_path.parts or "eval_package" in file_path.parts or "loop_learning" in file_path.parts:
+                for row in rows:
+                    if not isinstance(row, dict):
+                        continue
+                    row_id = row.get("row_id") or row.get("pair_id")
+                    if row_id:
+                        key = f"{file_path.relative_to(compiler_dir)}:{row_id}"
+                        if key in seen_training_ids:
+                            issues.append(f"Duplicate generated row id: {row_id}")
+                        seen_training_ids.add(key)
+                    if row.get("data_type") and not (
+                        row.get("source_evidence_ref_ids")
+                        or row.get("source_evidence_ids")
+                        or row.get("evidence_refs")
+                    ):
+                        issues.append(f"{file_path.relative_to(bundle)} row lacks evidence refs: {row_id or row.get('data_type')}")
     loops_dir = bundle / "loops"
     if loops_dir.exists():
         for file_path in loops_dir.rglob("*.json"):
@@ -4024,11 +4090,6 @@ def bundle_check(path: Path=typer.Argument(..., help='Experience Compilation fol
                 read_jsonl(file_path)
             except Exception as exc:
                 issues.append(f"{file_path.relative_to(bundle)} could not be parsed: {exc}")
-        for file_path in compiler_dir.rglob("*.jsonl"):
-            try:
-                read_jsonl(file_path)
-            except Exception as exc:
-                issues.append(f"{file_path.relative_to(bundle)} could not be parsed: {exc}")
     surface_warnings: list[str] = []
     for trace_path in [bundle / "traces" / "agent_traces.jsonl", bundle / "traces" / "raw_agent_traces.jsonl"]:
         if not trace_path.exists():
@@ -4061,7 +4122,7 @@ def bundle_check(path: Path=typer.Argument(..., help='Experience Compilation fol
     typer.echo(f"Task status: {status}")
     for warning in surface_warnings[:10]:
         typer.echo(f"Surface completeness warning: {redact_secrets(warning)}")
-    typer.echo("This Experience Compilation is ready to add to the public ecosystem.")
+    typer.echo("This Experience Compilation is ready for local export, Runtime Training install, or explicit sharing.")
 
 
 @bundle_app.command('contribute')